post.c

OpenFVM-v1.1 open source cfd code

      for (j = 0; j < elements[element].nbnodes; j++)
	{
	  fprintf (fp, " %E", nodes[elements[element].node[j]].z);
	}

      if (iphix == 0)
	vx = V_GetCmp (&xu, element + 1);
      if (iphix == 1)
	vx = V_GetCmp (&xv, element + 1);
      if (iphix == 2)
	vx = V_GetCmp (&xw, element + 1);
      if (iphix == 3)
	vx = V_GetCmp (&xp, element + 1);
      if (iphix == 4)
	vx = V_GetCmp (&xT, element + 1);
      if (iphix == 5)
	vx = V_GetCmp (&xs, element + 1);

      if (iphiy == 0)
	vy = V_GetCmp (&xu, element + 1);
      if (iphiy == 1)
	vy = V_GetCmp (&xv, element + 1);
      if (iphiy == 2)
	vy = V_GetCmp (&xw, element + 1);
      if (iphiy == 3)
	vy = V_GetCmp (&xp, element + 1);
      if (iphiy == 4)
	vy = V_GetCmp (&xT, element + 1);
      if (iphiy == 5)
	vy = V_GetCmp (&xs, element + 1);

      if (iphiz == 0)
	vz = V_GetCmp (&xu, element + 1);
      if (iphiz == 1)
	vz = V_GetCmp (&xv, element + 1);
      if (iphiz == 2)
	vz = V_GetCmp (&xw, element + 1);
      if (iphiz == 3)
	vz = V_GetCmp (&xp, element + 1);
      if (iphiz == 4)
	vz = V_GetCmp (&xT, element + 1);
      if (iphiz == 5)
	vz = V_GetCmp (&xs, element + 1);

      for (j = 0; j < elements[element].nbnodes; j++)
	{
	  fprintf (fp, " %E %E %E", vx, vy, vz);
	}

      fprintf (fp, "\n");
    }

}

void
PrintAsciiScalarFace (FILE * fp, double *sf)
{

  int i, j;

  int face;

  double sd;

  for (i = 0; i < nbfaces; i++)
    {

      face = i;

      if (faces[face].type != TRIANGLE)
	continue;

      for (j = 0; j < faces[face].nbnodes; j++)
	{
	  fprintf (fp, " %E", nodes[faces[face].node[j]].x);
	}

      for (j = 0; j < faces[face].nbnodes; j++)
	{
	  fprintf (fp, " %E", nodes[faces[face].node[j]].y);
	}

      for (j = 0; j < faces[face].nbnodes; j++)
	{
	  fprintf (fp, " %E", nodes[faces[face].node[j]].z);
	}

      for (j = 0; j < faces[face].nbnodes; j++)
	{

	  sd = sf[face];

	  fprintf (fp, " %E", sd);
	}

      fprintf (fp, "\n");
    }

  for (i = 0; i < nbfaces; i++)
    {

      face = i;

      if (faces[face].type != QUADRANGLE)
	continue;

      for (j = 0; j < faces[face].nbnodes; j++)
	{
	  fprintf (fp, " %E", nodes[faces[face].node[j]].x);
	}

      for (j = 0; j < faces[face].nbnodes; j++)
	{
	  fprintf (fp, " %E", nodes[faces[face].node[j]].y);
	}

      for (j = 0; j < faces[face].nbnodes; j++)
	{
	  fprintf (fp, " %E", nodes[faces[face].node[j]].z);
	}

      for (j = 0; j < faces[face].nbnodes; j++)
	{
	  sd = sf[face];

	  fprintf (fp, " %E", sd);
	}

      fprintf (fp, "\n");
    }

}

void
PrintBinaryScalarNode (FILE * fp, double *sn)
{

  int i, j;

  int element;

  double *tetras;
  double *hexas;
  double *prisms;

  int nt, nh, np;

  tetras = calloc (4 * nbtetras * 4, sizeof (double));
  hexas = calloc (4 * nbhexas * 8, sizeof (double));
  prisms = calloc (4 * nbprisms * 6, sizeof (double));

  nt = 0;
  nh = 0;
  np = 0;

  for (i = 0; i < nbelements; i++)
    {

      element = i;

      if (elements[element].type == TETRAHEDRON)
	{

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].x;
	      nt++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].y;
	      nt++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].z;
	      nt++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {

	      tetras[nt] = sn[elements[element].node[j]];
	      nt++;

	    }
	}

      if (elements[element].type == HEXAHEDRON)
	{

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      hexas[nh] = nodes[elements[element].node[j]].x;
	      nh++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      hexas[nh] = nodes[elements[element].node[j]].y;
	      nh++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      hexas[nh] = nodes[elements[element].node[j]].z;
	      nh++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {

	      hexas[nh] = sn[elements[element].node[j]];
	      nh++;

	    }
	}

      if (elements[element].type == PRISM)
	{

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      prisms[np] = nodes[elements[element].node[j]].x;
	      np++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      prisms[np] = nodes[elements[element].node[j]].y;
	      np++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      prisms[np] = nodes[elements[element].node[j]].z;
	      np++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {

	      prisms[np] = sn[elements[element].node[j]];
	      np++;

	    }
	}
    }

  fwrite (tetras, sizeof (double), nt, fp);
  fwrite (hexas, sizeof (double), nh, fp);
  fwrite (prisms, sizeof (double), np, fp);

  free (tetras);
  free (hexas);
  free (prisms);

}

void
PrintBinaryScalarFace (FILE * fp, double *sf)
{

  int i, j;

  int face;

  double *tris;
  double *quads;

  int nt, nq;

  tris = calloc (4 * nbtris * 3, sizeof (double));
  quads = calloc (4 * nbquads * 4, sizeof (double));

  nt = 0;
  nq = 0;

  for (i = 0; i < nbfaces; i++)
    {

      face = i;

      if (faces[face].type == TRIANGLE)
	{

	  for (j = 0; j < faces[face].nbnodes; j++)
	    {
	      tris[nt] = nodes[faces[face].node[j]].x;
	      nt++;
	    }

	  for (j = 0; j < faces[face].nbnodes; j++)
	    {
	      tris[nt] = nodes[faces[face].node[j]].y;
	      nt++;
	    }

	  for (j = 0; j < faces[face].nbnodes; j++)
	    {
	      tris[nt] = nodes[faces[face].node[j]].z;
	      nt++;
	    }

	  for (j = 0; j < faces[face].nbnodes; j++)
	    {

	      tris[nt] = sf[face];

	      nt++;

	    }
	}

      if (faces[face].type == QUADRANGLE)
	{

	  for (j = 0; j < faces[face].nbnodes; j++)
	    {
	      quads[nq] = nodes[faces[face].node[j]].x;
	      nq++;
	    }

	  for (j = 0; j < faces[face].nbnodes; j++)
	    {
	      quads[nq] = nodes[faces[face].node[j]].y;
	      nq++;
	    }

	  for (j = 0; j < faces[face].nbnodes; j++)
	    {
	      quads[nq] = nodes[faces[face].node[j]].z;
	      nq++;
	    }

	  for (j = 0; j < faces[face].nbnodes; j++)
	    {

	      quads[nq] = sf[face];

	      nq++;

	    }
	}

    }

  fwrite (tris, sizeof (double), nt, fp);
  fwrite (quads, sizeof (double), nq, fp);

  free (tris);
  free (quads);

}

void
PrintBinaryScalarElement (FILE * fp, double *se)
{

  int i, j;

  int element;

  double *tetras;
  double *hexas;
  double *prisms;

  int nt, nh, np;

  tetras = calloc (4 * nbtetras * 4, sizeof (double));
  hexas = calloc (4 * nbhexas * 8, sizeof (double));
  prisms = calloc (4 * nbprisms * 6, sizeof (double));

  nt = 0;
  nh = 0;
  np = 0;

  for (i = 0; i < nbelements; i++)
    {

      element = i;

      if (elements[element].type == TETRAHEDRON)
	{

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].x;
	      nt++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].y;
	      nt++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].z;
	      nt++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {

	      tetras[nt] = se[element];

	      nt++;

	    }
	}

      if (elements[element].type == HEXAHEDRON)
	{

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      hexas[nh] = nodes[elements[element].node[j]].x;
	      nh++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      hexas[nh] = nodes[elements[element].node[j]].y;
	      nh++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      hexas[nh] = nodes[elements[element].node[j]].z;
	      nh++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {

	      hexas[nh] = se[element];

	      nh++;

	    }
	}

      if (elements[element].type == PRISM)
	{

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      prisms[np] = nodes[elements[element].node[j]].x;
	      np++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      prisms[np] = nodes[elements[element].node[j]].y;
	      np++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      prisms[np] = nodes[elements[element].node[j]].z;
	      np++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {

	      prisms[np] = se[element];

	      np++;

	    }
	}
    }

  fwrite (tetras, sizeof (double), nt, fp);
  fwrite (hexas, sizeof (double), nh, fp);
  fwrite (prisms, sizeof (double), np, fp);

  free (tetras);
  free (hexas);
  free (prisms);

}

void
PrintBinaryVectorElement (FILE * fp, int iphix, int iphiy, int iphiz)
{

  int i, j;

  int element;

  double vx, vy, vz;

  double *tetras;
  double *hexas;
  double *prisms;

  int nt, nh, np;

  vx = 0.0;
  vy = 0.0;
  vz = 0.0;
  
  tetras = calloc (6 * nbtetras * 4, sizeof (double));
  hexas = calloc (6 * nbhexas * 8, sizeof (double));
  prisms = calloc (6 * nbprisms * 6, sizeof (double));

  nt = 0;
  nh = 0;
  np = 0;

  for (i = 0; i < nbelements; i++)
    {

      element = i;

      if (elements[element].type == TETRAHEDRON)
	{

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].x;
	      nt++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].y;
	      nt++;
	    }

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {
	      tetras[nt] = nodes[elements[element].node[j]].z;
	      nt++;
	    }

	  if (iphix == 0)
	    vx = V_GetCmp (&xu, element + 1);
	  if (iphix == 1)
	    vx = V_GetCmp (&xv, element + 1);
	  if (iphix == 2)
	    vx = V_GetCmp (&xw, element + 1);
	  if (iphix == 3)
	    vx = V_GetCmp (&xp, element + 1);
	  if (iphix == 4)
	    vx = V_GetCmp (&xT, element + 1);
	  if (iphix == 5)
	    vx = V_GetCmp (&xs, element + 1);

	  if (iphiy == 0)
	    vy = V_GetCmp (&xu, element + 1);
	  if (iphiy == 1)
	    vy = V_GetCmp (&xv, element + 1);
	  if (iphiy == 2)
	    vy = V_GetCmp (&xw, element + 1);
	  if (iphiy == 3)
	    vy = V_GetCmp (&xp, element + 1);
	  if (iphiy == 4)
	    vy = V_GetCmp (&xT, element + 1);
	  if (iphiy == 5)
	    vy = V_GetCmp (&xs, element + 1);

	  if (iphiz == 0)
	    vz = V_GetCmp (&xu, element + 1);
	  if (iphiz == 1)
	    vz = V_GetCmp (&xv, element + 1);
	  if (iphiz == 2)
	    vz = V_GetCmp (&xw, element + 1);
	  if (iphiz == 3)
	    vz = V_GetCmp (&xp, element + 1);
	  if (iphiz == 4)
	    vz = V_GetCmp (&xT, element + 1);
	  if (iphiz == 5)
	    vz = V_GetCmp (&xs, element + 1);

	  for (j = 0; j < elements[element].nbnodes; j++)
	    {

	      tetras[nt] = vx;
	      nt++;