applications/utilities/postProcessing/dataConversion/foamToFieldview9/write_binary_uns.c

   1 /*
   2 ** Support functions for writing a combined (grid and results) file
   3 ** in the binary FIELDVIEW unstructured format.
   4 */
   5
   6 /* Include system stuff for I/O and string and exit functions. */
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10
  11 /* Include the defines for the FV_* codes and wall_info values. */
  12 #include "fv_reader_tags.h"
  13
  14
  15 /* Don't change these - used by fv_encode_elem_header ! */
  16 #define MAX_NUM_ELEM_FACES     6
  17 #define BITS_PER_WALL  3
  18 #define ELEM_TYPE_BIT_SHIFT    (MAX_NUM_ELEM_FACES*BITS_PER_WALL)
  19
  20
  21 /*
  22 ** fv_encode_elem_header:  return an encoded binary element header
  23 **
  24 ** Input:
  25 **    elem_type:  integer element type as shown in fv_reader_tags.h
  26 **    wall_info:  array of integer "wall" flags, one for each face of
  27 **                the element.  The wall flags are used during streamline
  28 **                calculation.  Currently, the only meaningful values are
  29 **                A_WALL and NOT_A_WALL as shown in fv_reader_tags.h.
  30 **                Streamlines are forced away from faces marked as
  31 **                "A_WALL", by limiting velocity and position very near
  32 **                the wall.
  33 ** Output:
  34 **    Function return value is the encoded binary element header.
  35 */
  36
  37 #ifdef __STDC__
  38 unsigned int fv_encode_elem_header (int elem_type, int wall_info[])
  39 #else
  40 unsigned int fv_encode_elem_header (elem_type, wall_info)
  41 int elem_type;
  42 int wall_info[];
  43 #endif
  44 {
  45     unsigned int header;
  46     int i, nfaces;
  47
  48     switch (elem_type)
  49     {
  50         case FV_TET_ELEM_ID:
  51             header = (1 << ELEM_TYPE_BIT_SHIFT);
  52             nfaces = 4;
  53             break;
  54         case FV_HEX_ELEM_ID:
  55             header = (4 << ELEM_TYPE_BIT_SHIFT);
  56             nfaces = 6;
  57             break;
  58         case FV_PRISM_ELEM_ID:
  59             header = (3 << ELEM_TYPE_BIT_SHIFT);
  60             nfaces = 5;
  61             break;
  62         case FV_PYRA_ELEM_ID:
  63             header = (2 << ELEM_TYPE_BIT_SHIFT);
  64             nfaces = 5;
  65             break;
  66         default:
  67             fprintf(stderr, "ERROR:  Unknown element type\n");
  68             return 0;
  69     }
  70
  71     for (i = 0; i < nfaces; i++)
  72     {
  73         unsigned int u = wall_info[i];
  74         if (u > A_WALL)
  75         {
  76             fprintf(stderr, "ERROR:  Bad wall value\n");
  77             return 0;
  78         }
  79         header |= (u << (i*BITS_PER_WALL));
  80     }
  81     return header;
  82 }
  83
  84 /*
  85 ** fwrite_str80:  write out a string padded to 80 characters.
  86 **
  87 ** Like fwrite, this returns the number of items written, which
  88 ** should be 80 if successful, and less than 80 if it failed.
  89 */
  90 #ifdef __STDC__
  91 size_t fwrite_str80 (char *str, FILE *fp)
  92 #else
  93 int fwrite_str80 (str, fp)
  94 char *str;
  95 FILE *fp;
  96 #endif
  97 {
  98     char cbuf[80];
  99     size_t len;
 100     int i;
 101
 102     /* Most of this just to avoid garbage after the name. */
 103     len = strlen(str);
 104     strncpy(cbuf, str, len < 80 ? len : 80);
 105
 106     for (i = len; i < 80; i++)
 107         cbuf[i] = '\0';  /* pad with zeros */
 108
 109     return fwrite(cbuf, sizeof(char), 80, fp);
 110 }
 111
 112
 113 /*
 114 ** Sample program which writes out a single unstructured grid containing
 115 ** four hex elements, with pressure and velocity data at the nodes, and
 116 ** surface data for temperature and velocity on some of the boundaries.
 117 **
 118 ** The data is written as a combined (grid and results) file in the
 119 ** binary FIELDVIEW unstructured format.
 120 **
 121 ** For simplicity, no error checking is done on the calls to fwrite
 122 ** and fwrite_str80.
 123 */
 124 #if 0    /***** CHANGE THIS TO "#if 1" TO RUN THE SAMPLE PROGRAM. *****/
 125 int main()
 126 {
 127     char *file_name = "quad_hex.uns";
 128     FILE *outfp;
 129     int num_grids = 1;
 130     int num_face_types = 5;
 131     /*
 132     ** Note that one of the boundary type names is "wall."
 133     ** The boundary name "wall" has no special meaning in FIELDVIEW.
 134     ** Boundary types and element walls are independent pieces of
 135     ** information.  The only way to mark an element face as a wall
 136     ** (for streamline calculation) is with the wall_info array passed
 137     ** to fv_encode_elem_header.
 138     */
 139     static char *face_type_names[5] = { "bottom", "top", "wall",
 140                                         "trimmed cell", "hanging node cell"};
 141     /*
 142     ** Each boundary type is flagged with 1 or 0 depending on
 143     ** whether surface results are present or absent (see below).
 144     */
 145     static int results_flag[5]      =  { 1, 1, 0, 1, 1 };
 146     /*
 147     ** Each boundary type is flagged with 1 or 0 depending on
 148     ** whether surface normals can be calculated from a "right
 149     ** hand rule" (see below).
 150     */
 151     static int normals_flag[5]      =  { 1, 1, 0, 1, 1 };
 152
 153     /*
 154     ** Note that vector variables are specified by a ';' and vector name
 155     ** following the first scalar name of 3 scalar components of the
 156     ** vector.  If writing 2-D results, the third component must still
 157     ** be provided here, and its values must be written in the variables
 158     ** section below (typically padded with zeros.)
 159     */
 160     int num_vars = 4;
 161     static char *var_names[4] = { "pressure", "uvel; velocity", "vvel", "wvel" };
 162     int num_bvars = 4;
 163     static char *bvar_names[4] = { "temperature", "uvel; velocity", "vvel", "wvel" };
 164
 165     unsigned int elem_header;
 166     int grid, i;
 167     int ibuf[10];
 168
 169     int nnodes = 31;    /* Number of nodes in the grid. */
 170     const int num_faces_trim_cell = 7;
 171     const int num_faces_hang_cell = 6;
 172
 173     /* Constants. */
 174     static float consts[4] = { 1., 0., 0., 0. };
 175
 176     /* XYZ coordinates of the nodes. */
 177     static float x[31] = {-1., -1., 1., 1., -1., -1., 1., 1., -1., -1., 1.,1.,                     2., 2., 3., 3., 2.5, 3., 2., 3., 3., 2., 2.5,
 178                    3., 3., 3., 2.5, 2., 2., 2.0, 2.5};
 179
 180     static float y[31] = {-1., -1., -1., -1., 1., 1., 1., 1., 3., 3., 3., 3.,
 181                            0., 0., 0., 0., 0., .5, 1., 1., 1., 1., .5,
 182                2., 2., 1.5, 2., 2., 2., 1.45, 1.5};
 183
 184     static float z[31] = {-1., 1., -1., 1., -1., 1., -1., 1., -1., 1., -1.,1.,                    1., 0., 0., .5, 1., 1., 1., 1., 0., 0., .5,
 185                0., 1., 1., 1., 1., 0., 1., 1.};
 186
 187     /* hex1 and hex2 are hex elements, defined as an array of node numbers. */
 188     static int hex1[8] = {1,2,3,4,5,6,7,8};
 189     static int hex2[8] = {5,6,7,8,9,10,11,12};
 190
 191     /*
 192     ** Face definitions for boundary faces.
 193     ** All faces have 4 vertices.  If the face is triangular,
 194     ** the last vertex should be zero.
 195     */
 196     static int bot_faces[4] = { 1,2,4,3 };
 197     static int top_faces[4] = { 9,10,12,11 };
 198     static int wall_faces[8][4] =
 199         { {1,2,6,5}, {5,6,10,9}, {3,4,8,7}, {7,8,12,11},
 200           {1,3,7,5}, {5,7,11,9}, {2,4,8,6}, {6,8,12,10} };
 201
 202     /* Arbitrary Polyhedron faces: */
 203     static int trim_cell_face[num_faces_trim_cell][6] =
 204                                       { {5,13,14,15,16,17}, {3,16,18,17},
 205                     {5,15,21,20,18,16}, {5,13,17,18,20,19},
 206                     {4,13,19,22,14},  {4,14,22,21,15},
 207                     {4,19,20,21,22} };
 208
 209     static int hang_cell_face[num_faces_hang_cell][8] =
 210                                         { {5,20,21,24,25,26},
 211                       {5,24,29,28,27,25},
 212                       {7,20,26,25,27,28,30,19},
 213                       {4,20,19,22,21},
 214                           {4,21,22,29,24},
 215                       {5,22,19,30,28,29} };
 216
 217     /* Wall values for element faces. */
 218     static int hex1_walls[6] = { A_WALL, A_WALL, NOT_A_WALL,
 219         NOT_A_WALL, A_WALL, A_WALL };
 220     static int hex2_walls[6] = { A_WALL, A_WALL, NOT_A_WALL,
 221         NOT_A_WALL, A_WALL, A_WALL };
 222
 223     /* 4 variables (pressure and velocity values) at the 31 grid nodes. */
 224     static float vars[4][31] =
 225       { {1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,1.10,1.11,
 226          1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,1.10,1.11,
 227          1.12,1.13,1.14,1.15,1.16,1.17,1.18},
 228         {0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,
 229      1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,1.10,1.11,
 230      1.12,1.13,1.14,1.15,1.16,1.17,1.18},
 231         {1.2,1.1,1.0,0.9,0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1,
 232      1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,1.10,1.11,
 233      1.12,1.13,1.14,1.15,1.16,1.17,1.18},
 234         {0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,
 235      1.0,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,1.10,1.11,
 236      1.12,1.13,1.14,1.15,1.16,1.17,1.18} };
 237
 238     /*
 239     ** 4 boundary variables (temperature and velocity values) defined on
 240     ** the single top face, and the the single bottom face.
 241     */
 242     static float top_bvars[4] = { 1.0, 2.0,4.0,2.5 };
 243     static float bot_bvars[4] = { 1.0, 4.5,3.0,3.0 };
 244
 245     /* Arbitrary Polyhedron boundary face variables: */
 246     static float trim_cell_bvars[4][num_faces_trim_cell] =
 247                                       { {1.0,1.1,1.2,1.3,1.4,1.5,1.6},
 248                     {1.7,1.8,1.9,1.1,1.11,1.12,1.13},
 249                     {1.14,1.15,1.16,1.17,1.18,1.19,1.2},
 250                     {1.21,1.22,1.23,1.24,1.25,1.26,1.27} };
 251
 252     static float hang_cell_bvars[4][num_faces_hang_cell] =
 253                                          { {1.1,1.11,1.12,1.13,1.14,1.15},
 254                        {1.16,1.17,1.18,1.19,1.2,1.21},
 255                        {1.22,1.23,1.24,1.25,1.26,1.27},
 256                        {1.28,1.29,1.30,1.31,1.32,1.33} };
 257
 258     /* Open the file for binary write access. */
 259     if ((outfp = fopen(file_name, "wb")) == NULL)
 260     {
 261         perror ("Cannot open output file");
 262         exit(1);
 263     }
 264
 265     /* Output the magic number. */
 266     ibuf[0] = FV_MAGIC;
 267     fwrite(ibuf, sizeof(int), 1, outfp);
 268
 269     /* Output file header and version number. */
 270     fwrite_str80("FIELDVIEW", outfp);
 271
 272     /*
 273     ** This version of the FIELDVIEW unstructured file is "3.0".
 274     ** This is written as two integers.
 275     */
 276     ibuf[0] = 3;
 277     ibuf[1] = 0;
 278     fwrite(ibuf, sizeof(int), 2, outfp);
 279
 280     /* File type code - new in version 2.7 */
 281     ibuf[0] = FV_COMBINED_FILE;
 282     fwrite(ibuf, sizeof(int), 1, outfp);
 283
 284     /* Reserved field, always write a zero - new in version 2.6 */
 285     ibuf[0] = 0;
 286     fwrite(ibuf, sizeof(int), 1, outfp);
 287
 288     /* Output constants for time, fsmach, alpha and re. */
 289     fwrite(consts, sizeof(float), 4, outfp);
 290
 291     /* Output the number of grids. */
 292     ibuf[0] = num_grids;
 293     fwrite(ibuf, sizeof(int), 1, outfp);
 294
 295     /*
 296     ** Output the table of boundary types.
 297     ** Each boundary type is preceded by 2 integer flags.
 298     ** The first flag is an "surface results flag".
 299     ** A value of 1 means surface results will be present for this
 300     ** boundary type (if any boundary variables are specified in the
 301     ** boundary variable names table below).
 302     ** A value of 0 means no surface results will be present.
 303     ** The second flag indicates whether boundary faces of this type have
 304     ** consistent "clockness" for the purpose of calculating a surface
 305     ** normal.  A value of 1 means that all faces of this type are
 306     ** written following a "right hand rule" for clockness.  In other
 307     ** words, if the vertices are written on counter-clockwise:
 308     ** 4 --- 3
 309     ** |     |
 310     ** 1 --- 2
 311     ** then the normal to the face is pointing towards you (not away
 312     ** from you).  A value of 0 means that the faces do not have any
 313     ** consistent clockness.  The "clockness" of surface normals is
 314     ** only used for calculating certain special surface integrals
 315     ** that involve surface normals.  If the surface normals flag
 316     ** is 0, these special integrals will not be available.
 317     */
 318     ibuf[0] = num_face_types;
 319     fwrite(ibuf, sizeof(int), 1, outfp);
 320     for (i = 0; i < num_face_types; i++) {
 321     ibuf[0] = results_flag[i];
 322     ibuf[1] = normals_flag[i];
 323     fwrite(ibuf, sizeof(int), 2, outfp);
 324         fwrite_str80(face_type_names[i], outfp);
 325     }
 326
 327     /* Output the table of variable names. */
 328     /* The number of variables can be zero. */
 329     ibuf[0] = num_vars;
 330     fwrite(ibuf, sizeof(int), 1, outfp);
 331     for (i = 0; i < num_vars; i++)
 332         fwrite_str80(var_names[i], outfp);
 333
 334     /*
 335     ** Output the table of boundary variable names.
 336     ** Boundary variables are associated with boundary faces, rather than
 337     ** with grid nodes.
 338     ** FIELDVIEW will automatically append "[BNDRY]" to each name
 339     ** so boundary variables can be easily distinguished from ordinary
 340     ** (grid node) variables.
 341     ** The number of boundary variables can be different from the number
 342     ** of ordinary variables.  The number of boundary variables can be
 343     ** zero.
 344     */
 345     ibuf[0] = num_bvars;
 346     fwrite(ibuf, sizeof(int), 1, outfp);
 347     for (i = 0; i < num_bvars; i++)
 348         fwrite_str80(bvar_names[i], outfp);
 349
 350     /* Output grid data. */
 351     for (grid = 0; grid < num_grids; grid++)
 352     {
 353     /* Output the node definition section for this grid. */
 354         ibuf[0] = FV_NODES;
 355         ibuf[1] = nnodes;
 356         fwrite(ibuf, sizeof(int), 2, outfp);
 357
 358     /*
 359     ** Output the X, then Y, then Z node coordinates.
 360     ** Note that all of the X coordinates are output before any of
 361     ** the Y coordinates.
 362     */
 363         fwrite(x, sizeof(float), nnodes, outfp);
 364         fwrite(y, sizeof(float), nnodes, outfp);
 365         fwrite(z, sizeof(float), nnodes, outfp);
 366
 367     /*
 368         ** Output boundary faces of the 3 different types.
 369     ** All faces have 4 vertices.  If the face is triangular,
 370     ** the last vertex should be zero.
 371     ** TIP: A single boundary type can be broken into several sections
 372     ** if you prefer.  Also, boundary face sections do not have to
 373     ** be in order.  You may have a section of 10 faces of type 3,
 374     ** followed by a section of 20 faces of type 2, followed by a
 375     ** section of 15 more faces of type 3.  Breaking a boundary
 376     ** type into very many short sections is less efficient.  The
 377     ** boundaries will require more memory and be somewhat
 378     ** slower to calculate in FIELDVIEW.
 379     **
 380     */
 381         ibuf[0] = FV_FACES;
 382         ibuf[1] = 1;    /* first boundary type */
 383         ibuf[2] = 1;    /* number of faces of this type */
 384         fwrite(ibuf, sizeof(int), 3, outfp);
 385         fwrite(bot_faces, sizeof(int), 4, outfp);
 386
 387         ibuf[0] = FV_FACES;
 388         ibuf[1] = 2;    /* second boundary type */
 389         ibuf[2] = 1;    /* number of faces of this type */
 390         fwrite(ibuf, sizeof(int), 3, outfp);
 391         fwrite(top_faces, sizeof(int), 4, outfp);
 392
 393         ibuf[0] = FV_FACES;
 394         ibuf[1] = 3;    /* third boundary type */
 395         ibuf[2] = 8;    /* number of faces of this type */
 396         fwrite(ibuf, sizeof(int), 3, outfp);
 397         fwrite(wall_faces, sizeof(int), 8*4, outfp);
 398
 399     /* Arbitrary Polygon boundary faces:
 400     ** The format (in psuedocode) is as follows:
 401     **   >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 402     **   FV_ARB_POLY_FACES (section header)
 403     **   BndryFaceType NumBndryFaces
 404     **
 405     **   [for N = 1, NumBndryFaces]
 406     **       NumVertsFaceN Vert1 Vert2 ... Vert{NumVertsFaceN}
 407     **
 408     **   <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
 409     ** * The above block should be repeated for different boundary face
 410     **     types, as is the case for standard boundary faces.
 411     ** * These blocks should be after the blocks for standard faces,
 412     **     within the FIELDVIEW-Uns file.
 413     ** * The node ordering for specifying faces should follow a
 414     **    right-handed rule with the normal pointing away from the
 415     **    cell center. So nodes should be given by traversing the face
 416     **     in a counter-clockwise manner.
 417     ** * Hanging nodes are not permitted on boundary faces.
 418     */
 419
 420     ibuf[0] = FV_ARB_POLY_FACES;
 421     ibuf[1] = 4;  /* boundary face type */
 422     ibuf[2] = 7;  /* num faces for the trimmed cell */
 423
 424     fwrite(ibuf, sizeof(int), 3, outfp);
 425
 426     for(i = 0; i < num_faces_trim_cell; ++i) /* loop over the faces */
 427         fwrite(trim_cell_face[i], sizeof(int), trim_cell_face[i][0] + 1,
 428            outfp);
 429
 430     ibuf[0] = FV_ARB_POLY_FACES;
 431     ibuf[1] = 5;  /* boundary face type */
 432     ibuf[2] = 6;  /* num faces for the hanging node cell */
 433
 434     fwrite(ibuf, sizeof(int), 3, outfp);
 435
 436     for(i = 0; i < num_faces_hang_cell; ++i) /* loop over the faces */
 437         fwrite(hang_cell_face[i], sizeof(int), hang_cell_face[i][0] + 1,
 438            outfp);
 439
 440     /*
 441     ** Start an elements section.
 442     ** There may be as many elements sections as needed.
 443     ** Each section may contain a single element type or a
 444     ** mixture of element types.
 445     ** For maximum efficiency, each section should contain
 446     ** a significant percentage of the elements in the grid.
 447     ** The most efficient case is a single section containing
 448     ** all elements in the grid.
 449     */
 450         ibuf[0] = FV_ELEMENTS;
 451         ibuf[1] = 0;  /* tet count */
 452         ibuf[2] = 2;  /* hex count */
 453         ibuf[3] = 0;  /* prism count */
 454         ibuf[4] = 0;  /* pyramid count */
 455         fwrite(ibuf, sizeof(int), 5, outfp);
 456
 457         /* Write header for first element. */
 458         elem_header = fv_encode_elem_header(FV_HEX_ELEM_ID, hex1_walls);
 459     if (elem_header == 0)
 460     {
 461         fprintf (stderr, "fv_encode_elem_header failed for first hex.\n");
 462         exit(1);
 463     }
 464     fwrite (&elem_header, sizeof(elem_header), 1, outfp);
 465
 466     /* Write node definition for first element. */
 467         fwrite(hex1, sizeof(int), 8, outfp);
 468
 469         /* Write header for second element. */
 470         elem_header = fv_encode_elem_header(FV_HEX_ELEM_ID, hex2_walls);
 471     if (elem_header == 0)
 472     {
 473         fprintf (stderr, "fv_encode_elem_header failed for second hex.\n");
 474         exit(1);
 475     }
 476     fwrite (&elem_header, sizeof(elem_header), 1, outfp);
 477
 478     /* Write node definition for second element. */
 479         fwrite(hex2, sizeof(int), 8, outfp);
 480
 481         /* Arbitrary Polyhedron elements:
 482     ** The format (in psuedocode) is as follows:
 483     ** >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 484     ** FV_ARB_POLY_ELEMENTS (section header)
 485     ** NumArbPolyElements
 486     **
 487     ** [for elem = 1, NumArbPolyElements]
 488     ** {
 489     **    NumFaces NumNodesElement CenterNode
 490     **
 491     **    [for face = 1, NumFaces]
 492     **        WallFlag NumNodesFace FaceNode1 ... FaceNode{NumNodesFace}
 493     **    NumHangNodes HangNode1 ... HangNode{NumHangNodes}
 494     ** }
 495     ** <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
 496     ** * These blocks can be after or before the standard element blocks.
 497     **     There can be any number of these for any one grid.
 498     ** * The WallFlag has the same meaning as for standard elements,
 499     **     i.e., A_WALL or NOT_A_WALL.
 500     ** * The node ordering for specifying faces should follow a
 501     **    right-handed rule with the normal pointing away from the
 502     **    cell center. So nodes should be given by traversing the face
 503     **     in a counter-clockwise manner.
 504     ** * Hanging nodes are associated with a face interior and should
 505     **     not be on an edge. Hanging nodes on an edge should be
 506     **    interpretted as a regular face node.
 507     */
 508     ibuf[0] = FV_ARB_POLY_ELEMENTS;
 509     ibuf[1] = 2; /* have 2 elements here */
 510
 511     fwrite(ibuf, sizeof(int), 2, outfp);
 512
 513     /* trimmed face element */
 514     ibuf[0] = 7;  /* num faces for the trimmed cell */
 515     ibuf[1] = 11; /* number of nodes including a center node */
 516     ibuf[2] = 23; /* the center node */
 517     fwrite(ibuf, sizeof(int), 3, outfp);
 518
 519     ibuf[0] = A_WALL; /* wall value */
 520     ibuf[1] = 0; /* number of hanging nodes */
 521
 522     for(i = 0; i < num_faces_trim_cell; ++i) /* write out face info */
 523     {
 524         fwrite(ibuf, sizeof(int), 1, outfp); /* write wall value */
 525         fwrite(trim_cell_face[i], sizeof(int), trim_cell_face[i][0] + 1,
 526            outfp); /* write num verts and verts */
 527         fwrite(&ibuf[1], sizeof(int), 1, outfp); /* write num hang nodes */
 528     }
 529
 530         /* hanging node element */
 531     ibuf[0] = 6;  /* num faces for the hanging node cell */
 532     ibuf[1] = 12; /* number of nodes excluding a center node */
 533     ibuf[2] = -1; /* the center node, this indicates that FIELDVIEW
 534              ** should calculate the center node and associated
 535              ** centernode variable values
 536              */
 537     fwrite(ibuf, sizeof(int), 3, outfp);
 538
 539     ibuf[0] = A_WALL; /* wall value */
 540     ibuf[1] = 0; /* number of hanging nodes */
 541     ibuf[2] = 1; /* number of hanging nodes for face 3 */
 542     ibuf[3] = 31; /* the node number for the hanging node on face 3*/
 543
 544     for(i = 0; i < 2; ++i) /* write out face info for first 2 faces */
 545     {
 546         fwrite(ibuf, sizeof(int), 1, outfp); /* write wall value */
 547         fwrite(hang_cell_face[i], sizeof(int), hang_cell_face[i][0] + 1,
 548            outfp); /* write num verts and verts */
 549         fwrite(&ibuf[1], sizeof(int), 1, outfp); /* write num hang nodes */
 550     }
 551
 552     /* this face has a hanging node */
 553     fwrite(ibuf, sizeof(int), 1, outfp);
 554     fwrite(hang_cell_face[2], sizeof(int), hang_cell_face[2][0] + 1, outfp);
 555     fwrite(&ibuf[2], sizeof(int), 2, outfp);
 556
 557     /* write out face info for last 3 faces */
 558     for(i = 3; i < num_faces_hang_cell; ++i)
 559     {
 560         fwrite(ibuf, sizeof(int), 1, outfp); /* write wall value */
 561         fwrite(hang_cell_face[i], sizeof(int), hang_cell_face[i][0] + 1,
 562            outfp); /* write num verts and verts */
 563         fwrite(&ibuf[1], sizeof(int), 1, outfp); /* write num hang nodes */
 564     }
 565
 566         /*
 567     ** Output the variables data.
 568     ** You must write the section header even if the number
 569     ** of variables is zero.
 570     */
 571     ibuf[0] = FV_VARIABLES;
 572     fwrite(ibuf, sizeof(int), 1, outfp);
 573
 574     /*
 575     ** Note that all of the data for the first variable is output
 576     ** before any of the data for the second variable.
 577     */
 578     for (i = 0; i < num_vars; i++)
 579         fwrite(vars[i], sizeof(float), nnodes, outfp);
 580
 581         /*
 582     ** Output the boundary variables data.
 583     ** Remember that the Boundary Table above has a "surface results
 584     ** flag" indicating which boundary types have surface results.
 585     ** The data should be written in the same order as the faces in
 586     ** the Boundary Faces section, skipping over faces whose boundary
 587     ** type has a surface results flag of zero (false).
 588     ** For each variable, you should write one number per boundary face.
 589     ** You must write the section header even if the number of boundary
 590     ** variables is zero.
 591     */
 592     ibuf[0] = FV_BNDRY_VARS;
 593     fwrite(ibuf, sizeof(int), 1, outfp);
 594
 595     /*
 596     ** Note that all of the data for the first variable is output
 597     ** before any of the data for the second variable.
 598     */
 599     for (i = 0; i < num_bvars; i++) {
 600         int num_faces;
 601         /*
 602         ** The data for the bottom face is written first for each
 603         ** variable, because the bottom face was written first in the
 604         ** "Boundary Faces" section.
 605         ** The "wall" faces are skipped, because the surface results
 606         ** flag for the wall boundary type was 0 (false) in the
 607         ** Boundary Table section.
 608         */
 609         num_faces = 1;    /* number of bottom faces */
 610         fwrite(&bot_bvars[i], sizeof(float), num_faces, outfp);
 611         num_faces = 1;    /* number of top faces */
 612         fwrite(&top_bvars[i], sizeof(float), num_faces, outfp);
 613     }
 614
 615     /* Arbitrary Polyhedron boundary face results:
 616     ** The format is the same as for standard boundary face results.
 617     */
 618     ibuf[0] = FV_ARB_POLY_BNDRY_VARS;
 619     fwrite(ibuf, sizeof(int), 1, outfp);
 620
 621     for (i = 0; i < num_bvars; ++i)
 622     {
 623         int num_faces;
 624
 625         num_faces = 7;  /* num faces for the trimmed cell */
 626         fwrite(trim_cell_bvars[i], sizeof(float), num_faces, outfp);
 627
 628         num_faces = 6;  /* num faces for the hanging node cell */
 629         fwrite(hang_cell_bvars[i], sizeof(float), num_faces, outfp);
 630     }
 631     }
 632
 633     if (fclose(outfp) != 0)
 634     {
 635     perror ("Cannot close output file");
 636     exit(1);
 637     }
 638
 639     return 0;
 640 }
 641 #endif    /* end commenting out the sample program */