post.c

OpenFVM-v1.1 open source cfd code

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

	  if (iphix == 0)
	    vx = V_GetCmp (&xul, element);
	  if (iphix == 1)
	    vx = V_GetCmp (&xvl, element);
	  if (iphix == 2)
	    vx = V_GetCmp (&xwl, element);
	  if (iphix == 3)
	    vx = V_GetCmp (&xpl, element);
	  if (iphix == 4)
	    vx = V_GetCmp (&xTl, element);
	  if (iphix == 5)
	    vx = V_GetCmp (&xsl, element);

	  if (iphiy == 0)
	    vy = V_GetCmp (&xul, element);
	  if (iphiy == 1)
	    vy = V_GetCmp (&xvl, element);
	  if (iphiy == 2)
	    vy = V_GetCmp (&xwl, element);
	  if (iphiy == 3)
	    vy = V_GetCmp (&xpl, element);
	  if (iphiy == 4)
	    vy = V_GetCmp (&xTl, element);
	  if (iphiy == 5)
	    vy = V_GetCmp (&xsl, element);

	  if (iphiz == 0)
	    vz = V_GetCmp (&xul, element);
	  if (iphiz == 1)
	    vz = V_GetCmp (&xvl, element);
	  if (iphiz == 2)
	    vz = V_GetCmp (&xwl, element);
	  if (iphiz == 3)
	    vz = V_GetCmp (&xpl, element);
	  if (iphiz == 4)
	    vz = V_GetCmp (&xTl, element);
	  if (iphiz == 5)
	    vz = V_GetCmp (&xsl, element);

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

	      tetras[nt] = vx;
	      nt++;

	      tetras[nt] = vy;
	      nt++;

	      tetras[nt] = vz;
	      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++;
	    }

	  if (iphix == 0)
	    vx = V_GetCmp (&xul, element);
	  if (iphix == 1)
	    vx = V_GetCmp (&xvl, element);
	  if (iphix == 2)
	    vx = V_GetCmp (&xwl, element);
	  if (iphix == 3)
	    vx = V_GetCmp (&xpl, element);
	  if (iphix == 4)
	    vx = V_GetCmp (&xTl, element);
	  if (iphix == 5)
	    vx = V_GetCmp (&xsl, element);

	  if (iphiy == 0)
	    vy = V_GetCmp (&xul, element);
	  if (iphiy == 1)
	    vy = V_GetCmp (&xvl, element);
	  if (iphiy == 2)
	    vy = V_GetCmp (&xwl, element);
	  if (iphiy == 3)
	    vy = V_GetCmp (&xpl, element);
	  if (iphiy == 4)
	    vy = V_GetCmp (&xTl, element);
	  if (iphiy == 5)
	    vy = V_GetCmp (&xsl, element);

	  if (iphiz == 0)
	    vz = V_GetCmp (&xul, element);
	  if (iphiz == 1)
	    vz = V_GetCmp (&xvl, element);
	  if (iphiz == 2)
	    vz = V_GetCmp (&xwl, element);
	  if (iphiz == 3)
	    vz = V_GetCmp (&xpl, element);
	  if (iphiz == 4)
	    vz = V_GetCmp (&xTl, element);
	  if (iphiz == 5)
	    vz = V_GetCmp (&xsl, element);

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

	      hexas[nh] = vx;
	      nh++;

	      hexas[nh] = vy;
	      nh++;

	      hexas[nh] = vz;
	      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++;
	    }

	  if (iphix == 0)
	    vx = V_GetCmp (&xul, element);
	  if (iphix == 1)
	    vx = V_GetCmp (&xvl, element);
	  if (iphix == 2)
	    vx = V_GetCmp (&xwl, element);
	  if (iphix == 3)
	    vx = V_GetCmp (&xpl, element);
	  if (iphix == 4)
	    vx = V_GetCmp (&xTl, element);
	  if (iphix == 5)
	    vx = V_GetCmp (&xsl, element);

	  if (iphiy == 0)
	    vy = V_GetCmp (&xul, element);
	  if (iphiy == 1)
	    vy = V_GetCmp (&xvl, element);
	  if (iphiy == 2)
	    vy = V_GetCmp (&xwl, element);
	  if (iphiy == 3)
	    vy = V_GetCmp (&xpl, element);
	  if (iphiy == 4)
	    vy = V_GetCmp (&xTl, element);
	  if (iphiy == 5)
	    vy = V_GetCmp (&xsl, element);

	  if (iphiz == 0)
	    vz = V_GetCmp (&xul, element);
	  if (iphiz == 1)
	    vz = V_GetCmp (&xvl, element);
	  if (iphiz == 2)
	    vz = V_GetCmp (&xwl, element);
	  if (iphiz == 3)
	    vz = V_GetCmp (&xpl, element);
	  if (iphiz == 4)
	    vz = V_GetCmp (&xTl, element);
	  if (iphiz == 5)
	    vz = V_GetCmp (&xsl, element);

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

	      prisms[np] = vx;
	      np++;

	      prisms[np] = vy;
	      np++;

	      prisms[np] = vz;
	      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
WriteAsciiScalarElement (FILE * fp, char *label, int iphi, double curtime)
{

  int i;

  int element;

  double vs;

  double *se;

  vs = 0.0;
  
  fprintf (fp, "$View\n");

  se = calloc (nbelements, sizeof (double));

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

      element = i;

      if (iphi == 0)
	vs = V_GetCmp (&xul, element);
      if (iphi == 1)
	vs = V_GetCmp (&xvl, element);
      if (iphi == 2)
	vs = V_GetCmp (&xwl, element);
      if (iphi == 3)
	vs = V_GetCmp (&xpl, element);
      if (iphi == 4)
	vs = V_GetCmp (&xTl, element);
      if (iphi == 5)
	vs = V_GetCmp (&xsl, element);

      se[element] = vs;

    }

  PrintAsciiHeaderScalarElement (fp, label);
  PrintAsciiTime (fp, curtime);
  PrintAsciiScalarElement (fp, se);

  fprintf (fp, "$EndView\n");

  free (se);

}

void
WriteAsciiVectorElement (FILE * fp, char *label, int iphix, int iphiy,
			 int iphiz, double curtime)
{

  fprintf (fp, "$View\n");

  PrintAsciiHeaderVectorElement (fp, label);
  PrintAsciiTime (fp, curtime);
  PrintAsciiVectorElement (fp, iphix, iphiy, iphiz);

  fprintf (fp, "$EndView\n");

}

void
WriteAsciiStreamFunction (FILE * fp, char *label, double curtime)
{

  double *sn;

  fprintf (fp, "$View\n");

  sn = calloc (nbnodes, sizeof (double));

  CalculateStreamFunction (sn);

  PrintAsciiHeaderScalarElement (fp, label);
  PrintAsciiTime (fp, curtime);
  PrintAsciiScalarNode (fp, sn);

  fprintf (fp, "$EndView\n");

  free (sn);

}


void
WriteAsciiVorticity (FILE * fp, char *label, int axis, double curtime)
{

  int i;

  int element;

  double vs;

  double *se;
  
  msh_vector gradu, gradv, gradw;

  vs = 0.0;
  
  fprintf (fp, "$View\n");

  se = calloc (nbelements, sizeof (double));

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

      element = i;

      gradu = Gradient (&xul, &xuf, LOGICAL_FALSE, element);
      gradv = Gradient (&xvl, &xvf, LOGICAL_FALSE, element);
      gradw = Gradient (&xwl, &xwf, LOGICAL_FALSE, element);

      if (axis == 0)
	{
	  vs = gradw.y - gradv.z;
	}

      if (axis == 1)
	{
	  vs = gradu.z - gradw.x;
	}

      if (axis == 2)
	{
	  vs = gradv.x - gradu.y;
	}

      se[element] = vs;

    }

  PrintAsciiHeaderScalarElement (fp, label);
  PrintAsciiTime (fp, curtime);
  PrintAsciiScalarElement (fp, se);

  fprintf (fp, "\n$EndView\n");

  free (se);

}

void
WriteAsciiScalarFace (FILE * fp, char *label, int iphi, double curtime)
{

  int i;

  int face;

  double vs;

  double *sf;

  vs = 0.0;
  
  fprintf (fp, "$View\n");

  sf = calloc (nbfaces, sizeof (double));

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

      face = i;

      if (iphi == 0)
	vs = V_GetCmp (&xuf, face);
      if (iphi == 1)
	vs = V_GetCmp (&xvf, face);
      if (iphi == 2)
	vs = V_GetCmp (&xwf, face);
      if (iphi == 3)
	vs = V_GetCmp (&xpf, face);
      if (iphi == 4)
	vs = V_GetCmp (&xTf, face);
      if (iphi == 5)
	vs = V_GetCmp (&xsf, face);

      sf[face] = vs;

    }

  PrintAsciiHeaderScalarFace (fp, label);
  PrintAsciiTime (fp, curtime);
  PrintAsciiScalarFace (fp, sf);

  fprintf (fp, "\n$EndView\n");

  free (sf);

}

void
WriteAsciiVectorMagnitudeFace (FILE * fp, char *label,
			       int iphix, int iphiy, int iphiz,
			       double curtime)
{

  int i;

  int face;

  double vx, vy, vz;
  
  double *sf;

  vx = 0.0;
  vy = 0.0;
  vz = 0.0;
  
  sf = calloc (nbfaces, sizeof (double));

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

      face = i;

      if (iphix == 0)
	vx = V_GetCmp (&xuf, face);
      if (iphix == 1)
	vx = V_GetCmp (&xvf, face);
      if (iphix == 2)
	vx = V_GetCmp (&xwf, face);
      if (iphix == 3)
	vx = V_GetCmp (&xpf, face);
      if (iphix == 4)
	vx = V_GetCmp (&xTf, face);
      if (iphix == 5)
	vx = V_GetCmp (&xsf, face);

      if (iphiy == 0)
	vy = V_GetCmp (&xuf, face);
      if (iphiy == 1)
	vy = V_GetCmp (&xvf, face);
      if (iphiy == 2)
	vy = V_GetCmp (&xwf, face);
      if (iphiy == 3)
	vy = V_GetCmp (&xpf, face);
      if (iphiy == 4)
	vy = V_GetCmp (&xTf, face);
      if (iphiy == 5)
	vy = V_GetCmp (&xsf, face);

      if (iphiz == 0)
	vz = V_GetCmp (&xuf, face);
      if (iphiz == 1)
	vz = V_GetCmp (&xvf, face);
      if (iphiz == 2)
	vz = V_GetCmp (&xwf, face);
      if (iphiz == 3)
	vz = V_GetCmp (&xpf, face);
      if (iphiz == 4)
	vz = V_GetCmp (&xTf, face);
      if (iphiz == 5)
	vz = V_GetCmp (&xsf, face);

      sf[face] = sqrt (vx * vx + vy * vy + vz * vz);

    }

  fprintf (fp, "$View\n");

  PrintAsciiHeaderScalarFace (fp, label);
  PrintAsciiTime (fp, curtime);
  PrintAsciiScalarFace (fp, sf);

  fprintf (fp, "\n$EndView\n");

  free (sf);

}

void
WriteAsciiFlux (FILE * fp, char *label, double curtime)
{

  int i;

  int face;

  double vs;

  double *sf;

  vs = 0.0;
  
  fprintf (fp, "$View\n");

  sf = calloc (nbfaces, sizeof (double));

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

      face = i;

      vs = V_GetCmp (&uf, face);

      sf[face] = vs;

    }

  PrintAsciiHeaderScalarFace (fp, label);
  PrintAsciiTime (fp, curtime);
  PrintAsciiScalarFace (fp, sf);

  fprintf (fp, "\n$EndView\n");

  free (sf);

}

void
WriteBinaryFlux (FILE * fp, char *label, double curtime)
{

  int i;

  int face;

  double vs;

  double *sf;

  vs = 0.0;
  
  fprintf (fp, "$View\n");

  sf = calloc (nbfaces, sizeof (double));

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

      face = i;

      vs = V_GetCmp (&uf, face);

      sf[face] = vs;

    }

  PrintBinaryHeaderScalarFace (fp, label);
  PrintBinaryTime (fp, curtime);
  PrintBinaryScalarFace (fp, sf);