コード例 #1
0
ファイル: exgssd.c プロジェクト: CPFDSoftware-Tony/gmv
int ex_get_side_set_dist_fact (int   exoid,
                               int   side_set_id,
                               void *side_set_dist_fact)
{
  return ex_get_set_dist_fact(exoid, EX_SIDE_SET, side_set_id, 
			      side_set_dist_fact);
}
コード例 #2
0
ファイル: exgnsd.c プロジェクト: FlorianChevassu/VTK
int ex_get_node_set_dist_fact  (int   exoid,
                                int   node_set_id,
                                void *node_set_dist_fact)
{
  return ex_get_set_dist_fact(exoid, EX_NODE_SET, node_set_id,
                              node_set_dist_fact);
}
コード例 #3
0
ファイル: node_set.C プロジェクト: agrippa/Trilinos
template <typename INT> const double *Node_Set<INT>::Distribution_Factors() const
{
  if (!dist_factors && num_dist_factors > 0) {
    dist_factors = new double[num_dist_factors];
    SMART_ASSERT(dist_factors != nullptr);
    ex_get_set_dist_fact(fileId, EX_NODE_SET, id_, dist_factors);
  }
  return dist_factors;
}
コード例 #4
0
ファイル: ReadEdgeFace.c プロジェクト: agrippa/Trilinos
int cReadEdgeFace(int argc, char *argv[])
{
  int            exoid;
  int            appWordSize  = 8;
  int            diskWordSize = 8;
  float          exoVersion;
  int            itmp[5];
  int *          ids;
  int            nids;
  int            obj;
  int            i, j;
  int            num_timesteps;
  int            ti;
  char **        obj_names;
  char **        var_names;
  int            have_var_names;
  int            num_vars;    /* number of variables per object */
  int            num_entries; /* number of values per variable per object */
  double *       entry_vals;  /* variable values for each entry of an object */
  ex_init_params modelParams;

  exoid = ex_open(EX_TEST_FILENAME, EX_READ, &appWordSize, &diskWordSize, &exoVersion);
  if (exoid <= 0) {
    fprintf(stderr, "Unable to open \"%s\" for reading.\n", EX_TEST_FILENAME);
    return 1;
  }

  EXCHECK(ex_get_init_ext(exoid, &modelParams), "Unable to read database parameters.\n");

  fprintf(stdout, "Title: <%s>\n"
                  "Dimension: %" PRId64 "\n"
                  "Nodes: %" PRId64 "\n"
                  "Edges: %" PRId64 "\n"
                  "Faces: %" PRId64 "\n"
                  "Elements: %" PRId64 "\n"
                  "Edge Blocks: %" PRId64 "\n"
                  "Face Blocks: %" PRId64 "\n"
                  "Element Blocks: %" PRId64 "\n"
                  "Node Sets: %" PRId64 "\n"
                  "Edge Sets: %" PRId64 "\n"
                  "Face Sets: %" PRId64 "\n"
                  "Side Sets: %" PRId64 "\n"
                  "Element Sets: %" PRId64 "\n"
                  "Node Maps: %" PRId64 "\n"
                  "Edge Maps: %" PRId64 "\n"
                  "Face Maps: %" PRId64 "\n"
                  "Element Maps: %" PRId64 "\n",
          modelParams.title, modelParams.num_dim, modelParams.num_nodes, modelParams.num_edge,
          modelParams.num_face, modelParams.num_elem, modelParams.num_edge_blk,
          modelParams.num_face_blk, modelParams.num_elem_blk, modelParams.num_node_sets,
          modelParams.num_edge_sets, modelParams.num_face_sets, modelParams.num_side_sets,
          modelParams.num_elem_sets, modelParams.num_node_maps, modelParams.num_edge_maps,
          modelParams.num_face_maps, modelParams.num_elem_maps);

  num_timesteps = ex_inquire_int(exoid, EX_INQ_TIME);

  /* *** NEW API *** */
  for (i = 0; i < sizeof(obj_types) / sizeof(obj_types[0]); ++i) {
    int *truth_tab = 0;
    have_var_names = 0;

    EXCHECK(ex_inquire(exoid, obj_sizes[i], &nids, 0, 0),
            "Object ID list size could not be determined.\n");

    if (!nids) {
      fprintf(stdout, "=== %ss: none\n\n", obj_typenames[i]);
      continue;
    }
    else {
      fprintf(stdout, "=== %ss: %d\n", obj_typenames[i], nids);
    }

    ids       = (int *)malloc(nids * sizeof(int));
    obj_names = (char **)malloc(nids * sizeof(char *));
    for (obj         = 0; obj < nids; ++obj)
      obj_names[obj] = (char *)malloc((MAX_STR_LENGTH + 1) * sizeof(char));

    EXCHECK(ex_get_ids(exoid, obj_types[i], ids), "Could not read object ids.\n");
    EXCHECK(ex_get_names(exoid, obj_types[i], obj_names), "Could not read object ids.\n");

    if ((OBJECT_IS_BLOCK(i)) || (OBJECT_IS_SET(i))) {
      int *tp;
      EXCHECK(ex_get_var_param(exoid, obj_typestr[i], &num_vars),
              "Could not read number of variables.\n");

      if (num_vars && num_timesteps > 0) {
        truth_tab = (int *)malloc(num_vars * nids * sizeof(int));
        EXCHECK(ex_get_var_tab(exoid, obj_typestr[i], nids, num_vars, truth_tab),
                "Could not read truth table.\n");
        tp = truth_tab;
        fprintf(stdout, "Truth:");
        for (obj = 0; obj < nids; ++obj) {
          for (j = 0; j < num_vars; ++j, ++tp) {
            fprintf(stdout, " %d", *tp);
          }
          fprintf(stdout, "\n      ");
        }
        fprintf(stdout, "\n");

        var_names = (char **)malloc(num_vars * sizeof(char *));
        for (j         = 0; j < num_vars; ++j)
          var_names[j] = (char *)malloc((MAX_STR_LENGTH + 1) * sizeof(char));

        EXCHECK(ex_get_var_names(exoid, obj_typestr[i], num_vars, var_names),
                "Could not read variable names.\n");
        have_var_names = 1;
      }
    }

    if (!have_var_names)
      var_names = 0;

    for (obj = 0; obj < nids; ++obj) {
      if (obj_names[obj])
        fprintf(stdout, "%s %3d (%s): ", obj_typenames[i], ids[obj], obj_names[obj]);
      else
        fprintf(stdout, "%s %3d: ", obj_typenames[i], ids[obj]);

      if (OBJECT_IS_BLOCK(i)) {
        int *nconn;
        int *econn;
        int *fconn;
        int  ele;
        int  ctr;
        int  num_attrs;
        if (obj_types[i] == EX_ELEM_BLOCK) {
          EXCHECK(ex_get_block(exoid, obj_types[i], ids[obj], 0, itmp, itmp + 1, itmp + 2, itmp + 3,
                               &num_attrs),
                  "Could not read block params.\n");
          fprintf(stdout,
                  "Entries: %3d Nodes/entry: %d Edges/entry: %d Faces/entry: %d Attributes: %d",
                  itmp[0], itmp[1], itmp[2], itmp[3], num_attrs);
        }
        else {
          EXCHECK(ex_get_block(exoid, obj_types[i], ids[obj], 0, itmp, itmp + 1, 0, 0, &num_attrs),
                  "Could not read block params.\n");
          fprintf(stdout, "Entries: %3d Nodes/entry: %d Attributes: %d", itmp[0], itmp[1],
                  num_attrs);
          itmp[2] = itmp[3] = 0;
        }
        fprintf(stdout, "\n   ");
        num_entries = itmp[0];
        nconn       = itmp[1] ? (int *)malloc(itmp[1] * num_entries * sizeof(int)) : 0;
        econn       = itmp[2] ? (int *)malloc(itmp[2] * num_entries * sizeof(int)) : 0;
        fconn       = itmp[3] ? (int *)malloc(itmp[3] * num_entries * sizeof(int)) : 0;
        EXCHECK(ex_get_conn(exoid, obj_types[i], ids[obj], nconn, econn, fconn),
                "Could not read connectivity.\n");
        for (ele = 0; ele < num_entries; ++ele) {
          for (ctr = 0; ctr < itmp[1]; ++ctr) {
            fprintf(stdout, " %2d", nconn[ele * itmp[1] + ctr]);
          }
          if (itmp[2]) {
            fprintf(stdout, "  ++");
            for (ctr = 0; ctr < itmp[2]; ++ctr) {
              fprintf(stdout, " %2d", econn[ele * itmp[2] + ctr]);
            }
          }
          if (itmp[3]) {
            fprintf(stdout, "  ++");
            for (ctr = 0; ctr < itmp[3]; ++ctr) {
              fprintf(stdout, " %2d", fconn[ele * itmp[3] + ctr]);
            }
          }
          fprintf(stdout, "\n   ");
        }
        free(nconn);
        free(econn);
        free(fconn);

        if (num_attrs) {
          char ** attr_names;
          double *attr;
          attr       = (double *)malloc(num_entries * num_attrs * sizeof(double));
          attr_names = (char **)malloc(num_attrs * sizeof(char *));
          for (j          = 0; j < num_attrs; ++j)
            attr_names[j] = (char *)malloc((MAX_STR_LENGTH + 1) * sizeof(char));

          EXCHECK(ex_get_attr_names(exoid, obj_types[i], ids[obj], attr_names),
                  "Could not read attributes names.\n");
          EXCHECK(ex_get_attr(exoid, obj_types[i], ids[obj], attr),
                  "Could not read attribute values.\n");

          fprintf(stdout, "\n      Attributes:\n      ID ");
          for (j = 0; j < num_attrs; ++j)
            fprintf(stdout, " %s", attr_names[j]);
          fprintf(stdout, "\n");
          for (j = 0; j < num_entries; ++j) {
            int k;
            fprintf(stdout, "      %2d ", j + 1);
            for (k = 0; k < num_attrs; ++k) {
              fprintf(stdout, " %4.1f", attr[j * num_attrs + k]);
            }
            fprintf(stdout, "\n");
          }

          for (j = 0; j < num_attrs; ++j)
            free(attr_names[j]);
          free(attr_names);
          free(attr);
        }
      }
      else if (OBJECT_IS_SET(i)) {
        int     num_df;
        int *   set_entry;
        int *   set_extra;
        double *set_df;
        EXCHECK(ex_get_set_param(exoid, obj_types[i], ids[obj], &num_entries, &num_df),
                "Could not read set parameters.\n");

        set_entry = (int *)malloc(num_entries * sizeof(int));
        set_extra = (obj_types[i] != EX_NODE_SET && obj_types[i] != EX_ELEM_SET)
                        ? (int *)malloc(num_entries * sizeof(int))
                        : 0;
        EXCHECK(ex_get_set(exoid, obj_types[i], ids[obj], set_entry, set_extra),
                "Could not read set.\n");
        fprintf(stdout, "Entries: %3d Distribution factors: %3d\n", num_entries, num_df);
        if (set_extra) {
          for (j = 0; j < num_entries; ++j)
            fprintf(stdout, "      %2d %2d\n", set_entry[j], set_extra[j]);
        }
        else {
          for (j = 0; j < num_entries; ++j)
            fprintf(stdout, "      %2d\n", set_entry[j]);
        }
        free(set_entry);
        free(set_extra);

        set_df = num_df ? (double *)malloc(num_df * sizeof(double)) : 0;
        if (set_df) {
          EXCHECK(ex_get_set_dist_fact(exoid, obj_types[i], ids[obj], set_df),
                  "Could not read set distribution factors.\n");
          fprintf(stdout, "\n    Distribution factors:\n");
          for (j = 0; j < num_df; ++j)
            fprintf(stdout, "      %4.1f\n", set_df[j]);
          free(set_df);
        }
      }
      else { /* object is map */
        int *map;
        switch (obj_types[i]) {
        case EX_NODE_MAP: num_entries = modelParams.num_nodes; break;
        case EX_EDGE_MAP: num_entries = modelParams.num_edge; break;
        case EX_FACE_MAP: num_entries = modelParams.num_face; break;
        case EX_ELEM_MAP: num_entries = modelParams.num_elem; break;
        default: num_entries          = 0;
        }
        if (num_entries) {
          fprintf(stdout, "Entries: %3d\n                :", num_entries);
          map = (int *)malloc(num_entries * sizeof(int));
          EXCHECK(ex_get_num_map(exoid, obj_types[i], ids[obj], map), "Could not read map.\n");
          for (j = 0; j < num_entries; ++j) {
            fprintf(stdout, " %d", map[j]);
          }
        }
        else {
          fprintf(stdout, "Entries: none");
        }
      }
      fprintf(stdout, "\n");

      /* Read results variables */
      if (((OBJECT_IS_BLOCK(i)) || (OBJECT_IS_SET(i))) && num_vars && num_timesteps > 0) {
        /* Print out all the time values to exercise get_var */
        entry_vals = (double *)malloc(num_entries * sizeof(double));
        for (j = 0; j < num_vars; ++j) {
          int k;
          if (!truth_tab[num_vars * obj + j])
            continue;

          fprintf(stdout, "      Variable: %s", var_names[j]);
          for (ti = 1; ti <= num_timesteps; ++ti) {
            EXCHECK(ex_get_var(exoid, ti, obj_types[i], 1 + j, ids[obj], num_entries, entry_vals),
                    "Could not read variable values.\n");

            fprintf(stdout, "\n       @t%d ", ti);
            for (k = 0; k < num_entries; ++k) {
              fprintf(stdout, " %4.1f", entry_vals[k]);
            }
          }
          fprintf(stdout, "\n");
        }
        fprintf(stdout, "\n");
        free(entry_vals);
      }
    }

    if (((OBJECT_IS_BLOCK(i)) || (OBJECT_IS_SET(i))) && num_vars && num_timesteps > 0) {
      /* Print out one element's time values to exercise get_var_time */
      entry_vals = (double *)malloc(num_timesteps * sizeof(double));
      EXCHECK(ex_inquire(exoid, obj_sizeinq[i], itmp, 0, 0), "Inquire failed.\n");
      itmp[1] = 11;
      while (itmp[1] > itmp[0])
        itmp[1] /= 2;
      for (j = 0; j < num_vars; ++j) {
        /* FIXME: This works for the dataset created by CreateEdgeFace, but not for any dataset in
         * general since
         * NULL truth table entries may mean the referenced elements don't have variable values.
         */
        EXCHECK(ex_get_var_time(exoid, obj_types[i], j + 1, itmp[1], 1, num_timesteps, entry_vals),
                "Could not read variable over time.\n");
        fprintf(stdout, "    Variable over time: %s  Entry: %3d ", var_names[j], itmp[1]);
        for (ti = 1; ti <= num_timesteps; ++ti)
          fprintf(stdout, " @t%d: %4.1f", ti, entry_vals[ti - 1]);
        fprintf(stdout, "\n");
      }
      free(entry_vals);
    }

    if (var_names) {
      for (j = 0; j < num_vars; ++j)
        free(var_names[j]);
      free(var_names);
    }
    free(truth_tab);
    free(ids);

    for (obj = 0; obj < nids; ++obj)
      free(obj_names[obj]);
    free(obj_names);

    fprintf(stdout, "\n");
  }

  EXCHECK(ex_close(exoid), "Unable to close database.\n");

  return 0;
}
コード例 #5
0
ファイル: exgcset.c プロジェクト: hs9906/paraview
int ex_get_concat_sets (int   exoid,
                        int   set_type,
                        struct ex_set_specs* set_specs)
{
   int  *set_ids = set_specs->sets_ids;
   int  *num_entries_per_set = set_specs->num_entries_per_set;
   int  *num_dist_per_set = set_specs->num_dist_per_set;
   int  *sets_entry_index = set_specs->sets_entry_index;
   int  *sets_dist_index = set_specs->sets_dist_index;
   int  *sets_entry_list = set_specs->sets_entry_list;
   int  *sets_extra_list = set_specs->sets_extra_list;
   void *sets_dist_fact = set_specs->sets_dist_fact;
   char *cdum;
   int num_sets, i;
   float fdum;
   float  *flt_dist_fact;
   double *dbl_dist_fact;
   char errmsg[MAX_ERR_LENGTH];
   char* typeName;
   char* dimptr;
   char* idsptr;
   int ex_inq_val;
   int *extra_list;   

   exerrval = 0; /* clear error code */

   cdum = 0; /* initialize even though it is not used */

  /* setup pointers based on set_type 
    NOTE: there is another block that sets more stuff later ... */

   if (set_type == EX_NODE_SET) {
     typeName = "node";
     ex_inq_val = EX_INQ_NODE_SETS;
     dimptr = DIM_NUM_NS;
     idsptr = VAR_NS_IDS;
   }
   else if (set_type == EX_EDGE_SET) {
     typeName = "edge";
     ex_inq_val = EX_INQ_EDGE_SETS;
     dimptr = DIM_NUM_ES;
     idsptr = VAR_ES_IDS;
   }
   else if (set_type == EX_FACE_SET) {
     typeName = "face";
     ex_inq_val = EX_INQ_FACE_SETS;
     dimptr = DIM_NUM_FS;
     idsptr = VAR_FS_IDS;
   }
   else if (set_type == EX_SIDE_SET) {
     typeName = "side";
     ex_inq_val = EX_INQ_SIDE_SETS;
     dimptr = DIM_NUM_SS;
     idsptr = VAR_SS_IDS;
   }
   else if (set_type == EX_ELEM_SET) {
     typeName = "elem";
     ex_inq_val = EX_INQ_ELEM_SETS;
     dimptr = DIM_NUM_ELS;
     idsptr = VAR_ELS_IDS;
   }
   else {
     exerrval = EX_FATAL;
     sprintf(errmsg,
             "Error: invalid set type (%d)", set_type);
     ex_err("ex_put_set_param",errmsg,exerrval);
     return (EX_FATAL);
   }

/* first check if any sets are specified */

   if (ncdimid (exoid, dimptr)  == -1)
   {
     if (ncerr == NC_EBADDIM)
     {
       exerrval = ncerr;
       sprintf(errmsg,
               "Warning: no %s sets defined for file id %d", typeName, exoid);
       ex_err("ex_get_concat_sets",errmsg,exerrval);
       return (EX_WARN);
     }
     else
     {
       exerrval = ncerr;
       sprintf(errmsg,
              "Error: failed to locate %s sets defined in file id %d", 
               typeName, exoid);
       ex_err("ex_get_concat_sets",errmsg,exerrval);
       return (EX_FATAL);
     }
   }

/* inquire how many sets have been stored */

   if (ex_inquire(exoid, ex_inq_val, &num_sets, &fdum, cdum) == -1)
   {
     sprintf(errmsg,
            "Error: failed to get number of %s sets defined for file id %d",
             typeName, exoid);
     /* use error val from inquire */
     ex_err("ex_get_concat_sets",errmsg,exerrval);
     return (EX_FATAL);
   }

   if (ex_get_ids (exoid, set_type, set_ids) == -1)
   {
     sprintf(errmsg,
            "Error: failed to get %s set ids for file id %d",
             typeName, exoid);
     /* use error val from inquire */
     ex_err("ex_get_concat_sets",errmsg,exerrval);
     return (EX_FATAL);
   }

   sets_entry_index[0] = 0;
   sets_dist_index[0] = 0;

   for (i=0; i<num_sets; i++)
   {
     if (ex_get_set_param(exoid, set_type, set_ids[i], 
                       &(num_entries_per_set[i]), &(num_dist_per_set[i])) == -1)
       return(EX_FATAL); /* error will be reported by sub */

     if (i < num_sets-1)
     {
       /* fill in entry and dist factor index arrays */
       sets_entry_index[i+1] = sets_entry_index[i]+num_entries_per_set[i];
       sets_dist_index[i+1] = sets_dist_index[i]+num_dist_per_set[i];
     }

     if (num_entries_per_set[i] == 0) /* NULL  set? */
       continue;

     /* Now, use ExodusII call to get sets */

     if (set_type == EX_EDGE_SET || set_type == EX_FACE_SET ||
         set_type == EX_SIDE_SET)
       extra_list = &(sets_extra_list[sets_entry_index[i]]);
     else
       extra_list = NULL;

     if (ex_comp_ws(exoid) == sizeof(float))
     {
       if (ex_get_set(exoid, set_type, set_ids[i],
                         &(sets_entry_list[sets_entry_index[i]]),
                         &(sets_extra_list[sets_entry_index[i]])) == -1)
         return(EX_FATAL); /* error will be reported by subroutine */

       /* get distribution factors for this set */
       flt_dist_fact = sets_dist_fact;
       if (num_dist_per_set[i] > 0)       /* only get df if they exist */
       {
         if (ex_get_set_dist_fact(exoid, set_type, set_ids[i],
                               &(flt_dist_fact[sets_dist_index[i]])) == -1)
         {
           exerrval = ncerr;
           sprintf(errmsg,
                  "Error: failed to get %s set %d dist factors in file id %d",
                   typeName, set_ids[i], exoid);
           ex_err("ex_get_concat_sets",errmsg,exerrval);
           return(EX_FATAL);
         }
       } else {  /* fill distribution factor array with 1's */
       }
     }
     else if (ex_comp_ws(exoid) == sizeof(double))
     {
       if (ex_get_set(exoid, set_type, set_ids[i],
                      &(sets_entry_list[sets_entry_index[i]]),
                      &(sets_extra_list[sets_entry_index[i]])) == -1)
         return(EX_FATAL); /* error will be reported by subroutine */

       /* get distribution factors for this set */
       dbl_dist_fact = sets_dist_fact;
       if (num_dist_per_set[i] > 0)       /* only get df if they exist */
       {
         if (ex_get_set_dist_fact(exoid, set_type, set_ids[i],
                               &(dbl_dist_fact[sets_dist_index[i]])) == -1)
         {
           exerrval = ncerr;
           sprintf(errmsg,
                  "Error: failed to get %s set %d dist factors in file id %d",
                   typeName, set_ids[i], exoid);
           ex_err("ex_get_concat_sets",errmsg,exerrval);
           return(EX_FATAL);
         }
       } else {  /* fill distribution factor array with 1's */
       }
     }
   }

   return(EX_NOERR);

}
コード例 #6
0
ファイル: ex_get_concat_sets.c プロジェクト: 00liujj/trilinos
int ex_get_concat_sets (int   exoid,
                        ex_entity_type set_type,
                        struct ex_set_specs* set_specs)
{
  int status, dimid;
  void_int  *num_entries_per_set = set_specs->num_entries_per_set;
  void_int  *num_dist_per_set = set_specs->num_dist_per_set;
  void_int  *sets_entry_index = set_specs->sets_entry_index;
  void_int  *sets_dist_index = set_specs->sets_dist_index;

  void *sets_dist_fact = set_specs->sets_dist_fact; 

  int num_sets, i;
  float  *flt_dist_fact;
  double *dbl_dist_fact;
  char errmsg[MAX_ERR_LENGTH];
  ex_inquiry ex_inq_val;

  exerrval = 0; /* clear error code */

  /* setup pointers based on set_type 
     NOTE: there is another block that sets more stuff later ... */

  if (set_type == EX_NODE_SET) {
    ex_inq_val = EX_INQ_NODE_SETS;
  }
  else if (set_type == EX_EDGE_SET) {
    ex_inq_val = EX_INQ_EDGE_SETS;
  }
  else if (set_type == EX_FACE_SET) {
    ex_inq_val = EX_INQ_FACE_SETS;
  }
  else if (set_type == EX_SIDE_SET) {
    ex_inq_val = EX_INQ_SIDE_SETS;
  }
  else if (set_type == EX_ELEM_SET) {
    ex_inq_val = EX_INQ_ELEM_SETS;
  }
  else {
    exerrval = EX_FATAL;
    sprintf(errmsg,
	    "Error: invalid set type (%d)", set_type);
    ex_err("ex_put_set_param",errmsg,exerrval);
    return (EX_FATAL);
  }

  /* first check if any sets are specified */

  if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
    exerrval = status;
    if (status == NC_EBADDIM) {
      sprintf(errmsg,
	      "Warning: no %ss defined for file id %d",
	      ex_name_of_object(set_type), exoid);
      ex_err("ex_get_concat_sets",errmsg,exerrval);
      return (EX_WARN);
    } else {
      sprintf(errmsg,
	      "Error: failed to locate %ss defined in file id %d", 
	      ex_name_of_object(set_type), exoid);
      ex_err("ex_get_concat_sets",errmsg,exerrval);
      return (EX_FATAL);
    }
  }

  /* inquire how many sets have been stored */

  num_sets = ex_inquire_int(exoid, ex_inq_val);
  if (num_sets < 0) {
    sprintf(errmsg,
            "Error: failed to get number of %ss defined for file id %d",
	    ex_name_of_object(set_type), exoid);
    /* use error val from inquire */
    ex_err("ex_get_concat_sets",errmsg,exerrval);
    return (EX_FATAL);
  }

  if (ex_get_ids (exoid, set_type, set_specs->sets_ids) != NC_NOERR) {
    sprintf(errmsg,
            "Error: failed to get %s ids for file id %d",
	    ex_name_of_object(set_type), exoid);
    /* use error val from inquire */
    ex_err("ex_get_concat_sets",errmsg,exerrval);
    return (EX_FATAL);
  }

  if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
    ((int64_t*)sets_entry_index)[0] = 0;
    ((int64_t*)sets_dist_index)[0] = 0;
  } else {
    ((int*)sets_entry_index)[0] = 0;
    ((int*)sets_dist_index)[0] = 0;
  }

  for (i=0; i<num_sets; i++) {
    int set_id;
    if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
      set_id = ((int64_t*)set_specs->sets_ids)[i];
    } else {
      set_id = ((int*)set_specs->sets_ids)[i];
    }

    if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
      if (ex_get_set_param(exoid, set_type, set_id, 
			   &(((int64_t*)num_entries_per_set)[i]),
			   &(((int64_t*)num_dist_per_set)[i])) != NC_NOERR)
	return(EX_FATAL); /* error will be reported by sub */
      
      if (i < num_sets-1) {
	/* fill in entry and dist factor index arrays */
	((int64_t*)sets_entry_index)[i+1] = ((int64_t*)sets_entry_index)[i]+((int64_t*)num_entries_per_set)[i];
	((int64_t*)sets_dist_index)[i+1] = ((int64_t*)sets_dist_index)[i]+((int64_t*)num_dist_per_set)[i];
      }

      if (((int64_t*)num_entries_per_set)[i] == 0) /* NULL  set? */
	continue;

      {
	/* Now, use ExodusII call to get sets */
	int64_t *sets_entry_list = set_specs->sets_entry_list;
	int64_t *sets_extra_list = set_specs->sets_extra_list;
	int64_t *sets_extra = sets_extra_list ? &((int64_t*)sets_extra_list)[((int64_t*)sets_entry_index)[i]] : NULL;
	status = ex_get_set(exoid, set_type, set_id,
			    &(sets_entry_list[((int64_t*)sets_entry_index)[i]]),
			    sets_extra);
      }
    } else {
      if (ex_get_set_param(exoid, set_type, set_id, 
			   &(((int*)num_entries_per_set)[i]),
			   &(((int*)num_dist_per_set)[i])) != NC_NOERR)
	return(EX_FATAL); /* error will be reported by sub */
      
      if (i < num_sets-1) {
	/* fill in entry and dist factor index arrays */
	((int*)sets_entry_index)[i+1] = ((int*)sets_entry_index)[i]+((int*)num_entries_per_set)[i];
	((int*)sets_dist_index)[i+1] = ((int*)sets_dist_index)[i]+((int*)num_dist_per_set)[i];
      }

      if (((int*)num_entries_per_set)[i] == 0) /* NULL  set? */
	continue;

      {
	/* Now, use ExodusII call to get sets */
	int *sets_entry_list = set_specs->sets_entry_list;
	int *sets_extra_list = set_specs->sets_extra_list;
	int *sets_extra = sets_extra_list ? &((int*)sets_extra_list)[((int*)sets_entry_index)[i]] : NULL;
	status = ex_get_set(exoid, set_type, set_id,
			    &(sets_entry_list[((int*)sets_entry_index)[i]]),
			    sets_extra);
      }
    }

    if (status != NC_NOERR)
      return(EX_FATAL); /* error will be reported by subroutine */
    
    /* get distribution factors for this set */
    if (sets_dist_fact != 0) {
      size_t df_idx;
      size_t num_dist;
      if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
	df_idx = ((int64_t*)sets_dist_index)[i];
	num_dist = ((int64_t*)num_dist_per_set)[i];
      } else {
	df_idx = ((int*)sets_dist_index)[i];
	num_dist = ((int*)num_dist_per_set)[i];
      }
      if (num_dist > 0) {      /* only get df if they exist */
	if (ex_comp_ws(exoid) == sizeof(float)) {
	  flt_dist_fact = sets_dist_fact;
	  status = ex_get_set_dist_fact(exoid, set_type, set_id,
					&(flt_dist_fact[df_idx]));
	} else {
	  dbl_dist_fact = sets_dist_fact;
	  status = ex_get_set_dist_fact(exoid, set_type, set_id,
					&(dbl_dist_fact[df_idx]));
	}
	if (status != NC_NOERR) {
	  return(EX_FATAL); /* error will be reported by subroutine */
	}
      }
    }
  }
  return(EX_NOERR);
}
コード例 #7
0
ファイル: testrd_ss.c プロジェクト: jbcarleton/seacas
int main(int argc, char **argv)
{
  int  exoid, num_dim, num_nodes, num_elem, num_elem_blk, num_node_sets;
  int  num_side_sets, error;
  int  i, j, k, node_ctr;
  int *connect, *node_list, *node_ctr_list, *elem_list, *side_list;
  int *ids;
  int *num_elem_per_set;
  int *num_df_per_set;
  int *elem_ind, *df_ind;
  int *num_elem_in_block, *num_nodes_per_elem, *num_attr;
  int  num_elem_in_set;
  int  num_sides_in_set, num_df_in_set;
  int  elem_list_len = 0;
  int  node_list_len = 0;
  int  df_list_len   = 0;
  int  CPU_word_size, IO_word_size;
  int  idum;

  float *dist_fact;
  float  version, fdum;

  char  title[MAX_LINE_LENGTH + 1], elem_type[MAX_STR_LENGTH + 1];
  char *cdum = 0;

  CPU_word_size = 0; /* sizeof(float) */
  IO_word_size  = 0; /* use what is stored in file */

  ex_opts(EX_VERBOSE | EX_ABORT);

  /* open EXODUS II files */

  exoid = ex_open("test.exo",     /* filename path */
                  EX_READ,        /* access mode = READ */
                  &CPU_word_size, /* CPU word size */
                  &IO_word_size,  /* IO word size */
                  &version);      /* ExodusII library version */

  printf("\nafter ex_open\n");
  if (exoid < 0)
    exit(1);

  printf("test.exo is an EXODUSII file; version %4.2f\n", version);
  /*   printf ("         CPU word size %1d\n",CPU_word_size);  */
  printf("         I/O word size %1d\n", IO_word_size);
  ex_inquire(exoid, EX_INQ_API_VERS, &idum, &version, cdum);
  printf("EXODUSII API; version %4.2f\n", version);

  /* read database parameters */

  error = ex_get_init(exoid, title, &num_dim, &num_nodes, &num_elem, &num_elem_blk, &num_node_sets,
                      &num_side_sets);

  printf("after ex_get_init, error = %3d\n", error);

  printf("database parameters:\n");
  printf("title =  '%s'\n", title);
  printf("num_dim = %3d\n", num_dim);
  printf("num_nodes = %3d\n", num_nodes);
  printf("num_elem = %3d\n", num_elem);
  printf("num_elem_blk = %3d\n", num_elem_blk);
  printf("num_node_sets = %3d\n", num_node_sets);
  printf("num_side_sets = %3d\n", num_side_sets);

  /* read element block parameters */

  ids                = (int *)calloc(num_elem_blk, sizeof(int));
  num_elem_in_block  = (int *)calloc(num_elem_blk, sizeof(int));
  num_nodes_per_elem = (int *)calloc(num_elem_blk, sizeof(int));
  num_attr           = (int *)calloc(num_elem_blk, sizeof(int));

  error = ex_get_ids(exoid, EX_ELEM_BLOCK, ids);
  printf("\nafter ex_get_elem_blk_ids, error = %3d\n", error);

  for (i = 0; i < num_elem_blk; i++) {
    error = ex_get_block(exoid, EX_ELEM_BLOCK, ids[i], elem_type, &(num_elem_in_block[i]),
                         &(num_nodes_per_elem[i]), NULL, NULL, &(num_attr[i]));
    printf("\nafter ex_get_elem_block, error = %d\n", error);

    printf("element block id = %2d\n", ids[i]);
    printf("element type = '%s'\n", elem_type);
    printf("num_elem_in_block = %2d\n", num_elem_in_block[i]);
    printf("num_nodes_per_elem = %2d\n", num_nodes_per_elem[i]);
    printf("num_attr = %2d\n", num_attr[i]);
  }

  /* read element connectivity */

  for (i = 0; i < num_elem_blk; i++) {
    connect = (int *)calloc((num_nodes_per_elem[i] * num_elem_in_block[i]), sizeof(int));

    error = ex_get_conn(exoid, EX_ELEM_BLOCK, ids[i], connect, NULL, NULL);
    printf("\nafter ex_get_elem_conn, error = %d\n", error);

    printf("connect array for elem block %2d\n", ids[i]);

    for (j = 0; j < num_nodes_per_elem[i]; j++) {
      printf("%3d\n", connect[j]);
    }
    free(connect);
  }
  free(ids);
  free(num_elem_in_block);
  free(num_nodes_per_elem);
  free(num_attr);

  /* read individual side sets */

  ids = (int *)calloc(num_side_sets, sizeof(int));

  error = ex_get_ids(exoid, EX_SIDE_SET, ids);
  printf("\nafter ex_get_side_set_ids, error = %3d\n", error);

  for (i = 0; i < num_side_sets; i++) {
    error = ex_get_set_param(exoid, EX_SIDE_SET, ids[i], &num_sides_in_set, &num_df_in_set);
    printf("\nafter ex_get_side_set_param, error = %3d\n", error);

    printf("side set %2d parameters:\n", ids[i]);
    printf("num_sides = %3d\n", num_sides_in_set);
    printf("num_dist_factors = %3d\n", num_df_in_set);

    /* Note: The # of elements is same as # of sides!  */
    num_elem_in_set = num_sides_in_set;
    elem_list       = (int *)calloc(num_elem_in_set, sizeof(int));
    side_list       = (int *)calloc(num_sides_in_set, sizeof(int));
    node_ctr_list   = (int *)calloc(num_elem_in_set, sizeof(int));
    node_list       = (int *)calloc(num_elem_in_set * 21, sizeof(int));
    dist_fact       = (float *)calloc(num_df_in_set, sizeof(float));

    error = ex_get_set(exoid, EX_SIDE_SET, ids[i], elem_list, side_list);
    printf("\nafter ex_get_side_set, error = %3d\n", error);

    error = ex_get_side_set_node_list(exoid, ids[i], node_ctr_list, node_list);
    printf("\nafter ex_get_side_set_node_list, error = %3d\n", error);

    if (num_df_in_set > 0) {
      error = ex_get_set_dist_fact(exoid, EX_SIDE_SET, ids[i], dist_fact);
      printf("\nafter ex_get_side_set_dist_fact, error = %3d\n", error);
    }

    printf("element list for side set %2d\n", ids[i]);
    for (j = 0; j < num_elem_in_set; j++) {
      printf("%3d\n", elem_list[j]);
    }

    printf("side list for side set %2d\n", ids[i]);
    for (j = 0; j < num_sides_in_set; j++) {
      printf("%3d\n", side_list[j]);
    }

    node_ctr = 0;
    printf("node list for side set %2d\n", ids[i]);
    for (k = 0; k < num_elem_in_set; k++) {
      printf("%3d nodes for side %3d\n", node_ctr_list[k], k);
      for (j = 0; j < node_ctr_list[k]; j++) {
        printf("%3d\n", node_list[node_ctr + j]);
      }
      node_ctr += node_ctr_list[k];
    }

    if (num_df_in_set > 0) {
      printf("dist factors for side set %2d\n", ids[i]);

      for (j = 0; j < num_df_in_set; j++) {
        printf("%5.3f\n", dist_fact[j]);
      }
    }
    else
      printf("no dist factors for side set %2d\n", ids[i]);

    free(elem_list);
    free(side_list);
    free(node_ctr_list);
    free(node_list);
    free(dist_fact);
  }
  free(ids);

  if (num_side_sets > 0) {
    error = ex_inquire(exoid, EX_INQ_SS_ELEM_LEN, &elem_list_len, &fdum, cdum);
    printf("\nafter ex_inquire: EX_INQ_SS_ELEM_LEN = %d,  error = %d\n", elem_list_len, error);

    error = ex_inquire(exoid, EX_INQ_SS_NODE_LEN, &node_list_len, &fdum, cdum);
    printf("\nafter ex_inquire: EX_INQ_SS_NODE_LEN = %d,  error = %d\n", node_list_len, error);

    error = ex_inquire(exoid, EX_INQ_SS_DF_LEN, &df_list_len, &fdum, cdum);
    printf("\nafter ex_inquire: EX_INQ_SS_DF_LEN = %d,  error = %d\n", df_list_len, error);
  }

  /* read concatenated side sets; this produces the same information as
   * the above code which reads individual side sets
   */

  /* concatenated side set read */

  ids              = (int *)calloc(num_side_sets, sizeof(int));
  num_elem_per_set = (int *)calloc(num_side_sets, sizeof(int));
  num_df_per_set   = (int *)calloc(num_side_sets, sizeof(int));
  elem_ind         = (int *)calloc(num_side_sets, sizeof(int));
  df_ind           = (int *)calloc(num_side_sets, sizeof(int));
  elem_list        = (int *)calloc(elem_list_len, sizeof(int));
  side_list        = (int *)calloc(elem_list_len, sizeof(int));
  dist_fact        = (float *)calloc(df_list_len, sizeof(float));

  {
    struct ex_set_specs set_specs;

    set_specs.sets_ids            = ids;
    set_specs.num_entries_per_set = num_elem_per_set;
    set_specs.num_dist_per_set    = num_df_per_set;
    set_specs.sets_entry_index    = elem_ind;
    set_specs.sets_dist_index     = df_ind;
    set_specs.sets_entry_list     = elem_list;
    set_specs.sets_extra_list     = side_list;
    set_specs.sets_dist_fact      = dist_fact;

    error = ex_get_concat_sets(exoid, EX_SIDE_SET, &set_specs);
  }
  printf("\nafter ex_get_concat_side_sets, error = %3d\n", error);

  printf("concatenated side set info\n");

  printf("ids = \n");
  for (i = 0; i < num_side_sets; i++)
    printf("%3d\n", ids[i]);

  printf("num_elem_per_set = \n");
  for (i = 0; i < num_side_sets; i++)
    printf("%3d\n", num_elem_per_set[i]);

  printf("num_dist_per_set = \n");
  for (i = 0; i < num_side_sets; i++)
    printf("%3d\n", num_df_per_set[i]);

  printf("elem_ind = \n");
  for (i = 0; i < num_side_sets; i++)
    printf("%3d\n", elem_ind[i]);

  printf("dist_ind = \n");
  for (i = 0; i < num_side_sets; i++)
    printf("%3d\n", df_ind[i]);

  printf("elem_list = \n");
  for (i = 0; i < elem_list_len; i++)
    printf("%3d\n", elem_list[i]);

  printf("side_list = \n");
  for (i = 0; i < elem_list_len; i++)
    printf("%3d\n", side_list[i]);

  printf("dist_fact = \n");
  for (i = 0; i < df_list_len; i++)
    printf("%5.3f\n", dist_fact[i]);

  free(ids);
  free(num_elem_per_set);
  free(num_df_per_set);
  free(df_ind);
  free(elem_ind);
  free(elem_list);
  free(side_list);
  free(dist_fact);

  /* end of concatenated side set read */

  error = ex_close(exoid);
  printf("\nafter ex_close, error = %3d\n", error);
  return 0;
}
コード例 #8
0
ファイル: testrd_par.c プロジェクト: mhoemmen/Trilinos
int main(int argc, char **argv)
{
    MPI_Comm mpi_comm = MPI_COMM_WORLD;
    MPI_Info mpi_info = MPI_INFO_NULL;

    int  exoid, num_dim, num_nodes, num_elem, num_elem_blk, num_node_sets;
    int  num_side_sets, error;
    int  i, j, k, node_ctr;
    int *elem_map, *connect, *node_list, *node_ctr_list, *elem_list, *side_list;
    int *ids;
    int *num_nodes_per_set = NULL;
    int *num_elem_per_set  = NULL;
    int *num_df_per_set    = NULL;
    int *node_ind          = NULL;
    int *elem_ind          = NULL;
    int *df_ind            = NULL;
    int  num_qa_rec, num_info;
    int  num_glo_vars, num_nod_vars, num_ele_vars;
    int  num_nset_vars, num_sset_vars;
    int *truth_tab;
    int  num_time_steps;
    int *num_elem_in_block  = NULL;
    int *num_nodes_per_elem = NULL;
    int *num_attr           = NULL;
    int  num_nodes_in_set, num_elem_in_set;
    int  num_sides_in_set, num_df_in_set;
    int  list_len, elem_list_len, node_list_len, df_list_len;
    int  node_num, time_step, var_index, beg_time, end_time, elem_num;
    int  CPU_word_size, IO_word_size;
    int  num_props, prop_value, *prop_values;
    int  idum;

    float  time_value, *time_values, *var_values;
    float *x, *y, *z;
    float *attrib, *dist_fact;
    float  version, fdum;

    char *coord_names[3], *qa_record[2][4], *info[3], *var_names[3];
    char *block_names[10], *nset_names[10], *sset_names[10];
    char *attrib_names[10];
    char  name[MAX_STR_LENGTH + 1];
    char  title[MAX_LINE_LENGTH + 1], elem_type[MAX_STR_LENGTH + 1];
    char  title_chk[MAX_LINE_LENGTH + 1];
    char *cdum = 0;
    char *prop_names[3];

    CPU_word_size = 0; /* sizeof(float) */
    IO_word_size  = 0; /* use what is stored in file */

    ex_opts(EX_VERBOSE | EX_ABORT);

    /* Initialize MPI. */
    MPI_Init(&argc, &argv);

    /* open EXODUS II files */
    exoid = ex_open_par("test.exo",     /* filename path */
                        EX_READ,        /* access mode = READ */
                        &CPU_word_size, /* CPU word size */
                        &IO_word_size,  /* IO word size */
                        &version,       /* ExodusII library version */
                        mpi_comm, mpi_info);

    printf("\nafter ex_open\n");
    if (exoid < 0)
        exit(1);

    printf("test.exo is an EXODUSII file; version %4.2f\n", version);
    /*   printf ("         CPU word size %1d\n",CPU_word_size);  */
    printf("         I/O word size %1d\n", IO_word_size);
    ex_inquire(exoid, EX_INQ_API_VERS, &idum, &version, cdum);
    printf("EXODUSII API; version %4.2f\n", version);

    ex_inquire(exoid, EX_INQ_LIB_VERS, &idum, &version, cdum);
    printf("EXODUSII Library API; version %4.2f (%d)\n", version, idum);

    /* read database parameters */

    error = ex_get_init(exoid, title, &num_dim, &num_nodes, &num_elem, &num_elem_blk, &num_node_sets,
                        &num_side_sets);

    printf("after ex_get_init, error = %3d\n", error);

    printf("database parameters:\n");
    printf("title =  '%s'\n", title);
    printf("num_dim = %3d\n", num_dim);
    printf("num_nodes = %3d\n", num_nodes);
    printf("num_elem = %3d\n", num_elem);
    printf("num_elem_blk = %3d\n", num_elem_blk);
    printf("num_node_sets = %3d\n", num_node_sets);
    printf("num_side_sets = %3d\n", num_side_sets);

    /* Check that ex_inquire gives same title */
    error = ex_inquire(exoid, EX_INQ_TITLE, &idum, &fdum, title_chk);
    printf(" after ex_inquire, error = %d\n", error);
    if (strcmp(title, title_chk) != 0) {
        printf("error in ex_inquire for EX_INQ_TITLE\n");
    }

    /* read nodal coordinates values and names from database */

    x = (float *)calloc(num_nodes, sizeof(float));
    if (num_dim >= 2)
        y = (float *)calloc(num_nodes, sizeof(float));
    else
        y = 0;

    if (num_dim >= 3)
        z = (float *)calloc(num_nodes, sizeof(float));
    else
        z = 0;

    error = ex_get_coord(exoid, x, y, z);
    printf("\nafter ex_get_coord, error = %3d\n", error);

    printf("x coords = \n");
    for (i = 0; i < num_nodes; i++) {
        printf("%5.1f\n", x[i]);
    }

    if (num_dim >= 2) {
        printf("y coords = \n");
        for (i = 0; i < num_nodes; i++) {
            printf("%5.1f\n", y[i]);
        }
    }
    if (num_dim >= 3) {
        printf("z coords = \n");
        for (i = 0; i < num_nodes; i++) {
            printf("%5.1f\n", z[i]);
        }
    }

    /*
      error = ex_get_1_coord (exoid, 2, x, y, z);
      printf ("\nafter ex_get_1_coord, error = %3d\n", error);

      printf ("x coord of node 2 = \n");
      printf ("%f \n", x[0]);

      printf ("y coord of node 2 = \n");
      printf ("%f \n", y[0]);
    */
    free(x);
    if (num_dim >= 2)
        free(y);
    if (num_dim >= 3)
        free(z);

    for (i = 0; i < num_dim; i++) {
        coord_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
    }

    error = ex_get_coord_names(exoid, coord_names);
    printf("\nafter ex_get_coord_names, error = %3d\n", error);
    printf("x coord name = '%s'\n", coord_names[0]);
    if (num_dim > 1)
        printf("y coord name = '%s'\n", coord_names[1]);
    if (num_dim > 2)
        printf("z coord name = '%s'\n", coord_names[2]);

    for (i = 0; i < num_dim; i++)
        free(coord_names[i]);

    {
        int num_attrs = 0;
        error         = ex_get_attr_param(exoid, EX_NODAL, 0, &num_attrs);
        printf(" after ex_get_attr_param, error = %d\n", error);
        printf("num nodal attributes = %d\n", num_attrs);
        if (num_attrs > 0) {
            for (j = 0; j < num_attrs; j++) {
                attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
            }
            error = ex_get_attr_names(exoid, EX_NODAL, 0, attrib_names);
            printf(" after ex_get_attr_names, error = %d\n", error);

            if (error == 0) {
                attrib = (float *)calloc(num_nodes, sizeof(float));
                for (j = 0; j < num_attrs; j++) {
                    printf("nodal attribute %d = '%s'\n", j, attrib_names[j]);
                    error = ex_get_one_attr(exoid, EX_NODAL, 0, j + 1, attrib);
                    printf(" after ex_get_one_attr, error = %d\n", error);
                    for (i = 0; i < num_nodes; i++) {
                        printf("%5.1f\n", attrib[i]);
                    }
                    free(attrib_names[j]);
                }
                free(attrib);
            }
        }
    }

    /* read element order map */

    elem_map = (int *)calloc(num_elem, sizeof(int));

    error = ex_get_map(exoid, elem_map);
    printf("\nafter ex_get_map, error = %3d\n", error);

    for (i = 0; i < num_elem; i++) {
        printf("elem_map(%d) = %d \n", i, elem_map[i]);
    }

    free(elem_map);

    /* read element block parameters */

    if (num_elem_blk > 0) {
        ids                = (int *)calloc(num_elem_blk, sizeof(int));
        num_elem_in_block  = (int *)calloc(num_elem_blk, sizeof(int));
        num_nodes_per_elem = (int *)calloc(num_elem_blk, sizeof(int));
        num_attr           = (int *)calloc(num_elem_blk, sizeof(int));

        error = ex_get_ids(exoid, EX_ELEM_BLOCK, ids);
        printf("\nafter ex_get_elem_blk_ids, error = %3d\n", error);

        for (i = 0; i < num_elem_blk; i++) {
            printf("Block # %d is id %d\n", i, ids[i]);
            block_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }

        error = ex_get_names(exoid, EX_ELEM_BLOCK, block_names);
        printf("\nafter ex_get_names, error = %3d\n", error);

        for (i = 0; i < num_elem_blk; i++) {
            ex_get_name(exoid, EX_ELEM_BLOCK, ids[i], name);
            if (strcmp(name, block_names[i]) != 0) {
                printf("error in ex_get_name for block id %d\n", ids[i]);
            }
            error = ex_get_block(exoid, EX_ELEM_BLOCK, ids[i], elem_type, &(num_elem_in_block[i]),
                                 &(num_nodes_per_elem[i]), &(num_attr[i]));
            printf("\nafter ex_get_elem_block, id = %d, error = %d\n", ids[i], error);

            printf("element block id = %2d\n", ids[i]);
            printf("element type = '%s'\n", elem_type);
            printf("num_elem_in_block = %2d\n", num_elem_in_block[i]);
            printf("num_nodes_per_elem = %2d\n", num_nodes_per_elem[i]);
            printf("num_attr = %2d\n", num_attr[i]);
            printf("name = '%s'\n", block_names[i]);
            free(block_names[i]);
        }

        /* read element block properties */
        error = ex_inquire(exoid, EX_INQ_EB_PROP, &num_props, &fdum, cdum);
        printf("\nafter ex_inquire, error = %d\n", error);
        printf("\nThere are %2d properties for each element block\n", num_props);

        for (i = 0; i < num_props; i++) {
            prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }

        error = ex_get_prop_names(exoid, EX_ELEM_BLOCK, prop_names);
        printf("after ex_get_prop_names, error = %d\n", error);

        for (i = 1; i < num_props; i++) /* Prop 1 is id; skip that here */
        {
            for (j = 0; j < num_elem_blk; j++) {
                error = ex_get_prop(exoid, EX_ELEM_BLOCK, ids[j], prop_names[i], &prop_value);
                if (error == 0)
                    printf("element block %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
                           prop_value);
                else
                    printf("after ex_get_prop, error = %d\n", error);
            }
        }

        for (i = 0; i < num_props; i++)
            free(prop_names[i]);
    }

    /* read element connectivity */

    for (i = 0; i < num_elem_blk; i++) {
        if (num_elem_in_block[i] > 0) {
            connect = (int *)calloc((num_nodes_per_elem[i] * num_elem_in_block[i]), sizeof(int));

            error = ex_get_conn(exoid, EX_ELEM_BLOCK, ids[i], connect);
            printf("\nafter ex_get_elem_conn, error = %d\n", error);

            printf("connect array for elem block %2d\n", ids[i]);

            for (j = 0; j < num_nodes_per_elem[i]; j++) {
                printf("%3d\n", connect[j]);
            }
            /*
              error = ex_get_1_elem_conn (exoid, 1, ids[i], connect);
              printf ("\nafter ex_get_elem_conn, error = %d\n", error);

              printf ("node list for first element of element block %d \n ", ids[i]);
              for (j=0; j<num_nodes_per_elem[i]; j++)
              {
              printf ("%d \n", connect[j]);
              }
            */
            free(connect);
        }
    }

    /* read element block attributes */

    for (i = 0; i < num_elem_blk; i++) {
        if (num_elem_in_block[i] > 0) {
            for (j            = 0; j < num_attr[i]; j++)
                attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));

            attrib = (float *)calloc(num_attr[i] * num_elem_in_block[i], sizeof(float));
            error  = ex_get_attr(exoid, EX_ELEM_BLOCK, ids[i], attrib);
            printf("\n after ex_get_elem_attr, error = %d\n", error);

            if (error == 0) {
                error = ex_get_attr_names(exoid, EX_ELEM_BLOCK, ids[i], attrib_names);
                printf(" after ex_get_elem_attr_names, error = %d\n", error);

                if (error == 0) {
                    printf("element block %d attribute '%s' = %6.4f\n", ids[i], attrib_names[0], *attrib);
                }
            }
            free(attrib);
            for (j = 0; j < num_attr[i]; j++)
                free(attrib_names[j]);
        }
    }

    if (num_elem_blk > 0) {
        free(ids);
        free(num_nodes_per_elem);
        free(num_attr);
    }

    /* read individual node sets */
    if (num_node_sets > 0) {
        ids = (int *)calloc(num_node_sets, sizeof(int));

        error = ex_get_ids(exoid, EX_NODE_SET, ids);
        printf("\nafter ex_get_node_set_ids, error = %3d\n", error);

        for (i = 0; i < num_node_sets; i++) {
            nset_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }

        error = ex_get_names(exoid, EX_NODE_SET, nset_names);
        printf("\nafter ex_get_names, error = %3d\n", error);

        for (i = 0; i < num_node_sets; i++) {
            ex_get_name(exoid, EX_NODE_SET, ids[i], name);
            if (strcmp(name, nset_names[i]) != 0) {
                printf("error in ex_get_name for nodeset id %d\n", ids[i]);
            }

            error = ex_get_set_param(exoid, EX_NODE_SET, ids[i], &num_nodes_in_set, &num_df_in_set);
            printf("\nafter ex_get_node_set_param, error = %3d\n", error);

            printf("\nnode set %2d parameters: \n", ids[i]);
            printf("num_nodes = %2d\n", num_nodes_in_set);
            printf("name = '%s'\n", nset_names[i]);
            free(nset_names[i]);
            node_list = (int *)calloc(num_nodes_in_set, sizeof(int));
            dist_fact = (float *)calloc(num_nodes_in_set, sizeof(float));

            error = ex_get_set(exoid, EX_NODE_SET, ids[i], node_list);
            printf("\nafter ex_get_node_set, error = %3d\n", error);

            if (num_df_in_set > 0) {
                error = ex_get_set_dist_fact(exoid, EX_NODE_SET, ids[i], dist_fact);
                printf("\nafter ex_get_node_set_dist_fact, error = %3d\n", error);
            }

            printf("\nnode list for node set %2d\n", ids[i]);

            for (j = 0; j < num_nodes_in_set; j++) {
                printf("%3d\n", node_list[j]);
            }

            if (num_df_in_set > 0) {
                printf("dist factors for node set %2d\n", ids[i]);

                for (j = 0; j < num_nodes_in_set; j++) {
                    printf("%5.2f\n", dist_fact[j]);
                }
            }
            else
                printf("no dist factors for node set %2d\n", ids[i]);

            free(node_list);
            free(dist_fact);

            {
                int num_attrs = 0;
                error         = ex_get_attr_param(exoid, EX_NODE_SET, ids[i], &num_attrs);
                printf(" after ex_get_attr_param, error = %d\n", error);
                printf("num nodeset attributes for nodeset %d = %d\n", ids[i], num_attrs);
                if (num_attrs > 0) {
                    for (j = 0; j < num_attrs; j++) {
                        attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
                    }
                    error = ex_get_attr_names(exoid, EX_NODE_SET, ids[i], attrib_names);
                    printf(" after ex_get_attr_names, error = %d\n", error);

                    if (error == 0) {
                        attrib = (float *)calloc(num_nodes_in_set, sizeof(float));
                        for (j = 0; j < num_attrs; j++) {
                            printf("nodeset attribute %d = '%s'\n", j, attrib_names[j]);
                            error = ex_get_one_attr(exoid, EX_NODE_SET, ids[i], j + 1, attrib);
                            printf(" after ex_get_one_attr, error = %d\n", error);
                            for (k = 0; k < num_nodes_in_set; k++) {
                                printf("%5.1f\n", attrib[k]);
                            }
                            free(attrib_names[j]);
                        }
                        free(attrib);
                    }
                }
            }
        }
        free(ids);

        /* read node set properties */
        error = ex_inquire(exoid, EX_INQ_NS_PROP, &num_props, &fdum, cdum);
        printf("\nafter ex_inquire, error = %d\n", error);
        printf("\nThere are %2d properties for each node set\n", num_props);

        for (i = 0; i < num_props; i++) {
            prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }
        prop_values = (int *)calloc(num_node_sets, sizeof(int));

        error = ex_get_prop_names(exoid, EX_NODE_SET, prop_names);
        printf("after ex_get_prop_names, error = %d\n", error);

        for (i = 0; i < num_props; i++) {
            error = ex_get_prop_array(exoid, EX_NODE_SET, prop_names[i], prop_values);
            if (error == 0)
                for (j = 0; j < num_node_sets; j++)
                    printf("node set %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
                           prop_values[j]);
            else
                printf("after ex_get_prop_array, error = %d\n", error);
        }
        for (i = 0; i < num_props; i++)
            free(prop_names[i]);
        free(prop_values);

        /* read concatenated node sets; this produces the same information as
         * the above code which reads individual node sets
         */

        error = ex_inquire(exoid, EX_INQ_NODE_SETS, &num_node_sets, &fdum, cdum);
        printf("\nafter ex_inquire, error = %3d\n", error);

        ids               = (int *)calloc(num_node_sets, sizeof(int));
        num_nodes_per_set = (int *)calloc(num_node_sets, sizeof(int));
        num_df_per_set    = (int *)calloc(num_node_sets, sizeof(int));
        node_ind          = (int *)calloc(num_node_sets, sizeof(int));
        df_ind            = (int *)calloc(num_node_sets, sizeof(int));

        error = ex_inquire(exoid, EX_INQ_NS_NODE_LEN, &list_len, &fdum, cdum);
        printf("\nafter ex_inquire: EX_INQ_NS_NODE_LEN = %d, error = %3d\n", list_len, error);
        node_list = (int *)calloc(list_len, sizeof(int));

        error = ex_inquire(exoid, EX_INQ_NS_DF_LEN, &list_len, &fdum, cdum);
        printf("\nafter ex_inquire: EX_INQ_NS_DF_LEN = %d, error = %3d\n", list_len, error);
        dist_fact = (float *)calloc(list_len, sizeof(float));

        error = ex_get_concat_node_sets(exoid, ids, num_nodes_per_set, num_df_per_set, node_ind, df_ind,
                                        node_list, dist_fact);
        printf("\nafter ex_get_concat_node_sets, error = %3d\n", error);

        printf("\nconcatenated node set info\n");

        printf("ids = \n");
        for (i = 0; i < num_node_sets; i++)
            printf("%3d\n", ids[i]);

        printf("num_nodes_per_set = \n");
        for (i = 0; i < num_node_sets; i++)
            printf("%3d\n", num_nodes_per_set[i]);

        printf("node_ind = \n");
        for (i = 0; i < num_node_sets; i++)
            printf("%3d\n", node_ind[i]);

        printf("node_list = \n");
        for (i = 0; i < list_len; i++)
            printf("%3d\n", node_list[i]);

        printf("dist_fact = \n");
        for (i = 0; i < list_len; i++)
            printf("%5.3f\n", dist_fact[i]);

        free(ids);
        free(df_ind);
        free(node_ind);
        free(num_df_per_set);
        free(node_list);
        free(dist_fact);
    }

    /* read individual side sets */

    if (num_side_sets > 0) {
        ids = (int *)calloc(num_side_sets, sizeof(int));

        error = ex_get_ids(exoid, EX_SIDE_SET, ids);
        printf("\nafter ex_get_side_set_ids, error = %3d\n", error);

        for (i = 0; i < num_side_sets; i++) {
            sset_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }

        error = ex_get_names(exoid, EX_SIDE_SET, sset_names);
        printf("\nafter ex_get_names, error = %3d\n", error);

        for (i = 0; i < num_side_sets; i++) {
            ex_get_name(exoid, EX_SIDE_SET, ids[i], name);
            if (strcmp(name, sset_names[i]) != 0) {
                printf("error in ex_get_name for sideset id %d\n", ids[i]);
            }

            error = ex_get_set_param(exoid, EX_SIDE_SET, ids[i], &num_sides_in_set, &num_df_in_set);
            printf("\nafter ex_get_side_set_param, error = %3d\n", error);

            printf("side set %2d parameters:\n", ids[i]);
            printf("name = '%s'\n", sset_names[i]);
            printf("num_sides = %3d\n", num_sides_in_set);
            printf("num_dist_factors = %3d\n", num_df_in_set);
            free(sset_names[i]);

            /* Note: The # of elements is same as # of sides!  */
            num_elem_in_set = num_sides_in_set;
            elem_list       = (int *)calloc(num_elem_in_set, sizeof(int));
            side_list       = (int *)calloc(num_sides_in_set, sizeof(int));
            node_ctr_list   = (int *)calloc(num_elem_in_set, sizeof(int));
            node_list       = (int *)calloc(num_elem_in_set * 21, sizeof(int));
            dist_fact       = (float *)calloc(num_df_in_set, sizeof(float));

            error = ex_get_set(exoid, EX_SIDE_SET, ids[i], elem_list, side_list);
            printf("\nafter ex_get_side_set, error = %3d\n", error);

            error = ex_get_side_set_node_list(exoid, ids[i], node_ctr_list, node_list);
            printf("\nafter ex_get_side_set_node_list, error = %3d\n", error);

            if (num_df_in_set > 0) {
                error = ex_get_set_dist_fact(exoid, EX_SIDE_SET, ids[i], dist_fact);
                printf("\nafter ex_get_side_set_dist_fact, error = %3d\n", error);
            }

            printf("element list for side set %2d\n", ids[i]);
            for (j = 0; j < num_elem_in_set; j++) {
                printf("%3d\n", elem_list[j]);
            }

            printf("side list for side set %2d\n", ids[i]);
            for (j = 0; j < num_sides_in_set; j++) {
                printf("%3d\n", side_list[j]);
            }

            node_ctr = 0;
            printf("node list for side set %2d\n", ids[i]);
            for (k = 0; k < num_elem_in_set; k++) {
                for (j = 0; j < node_ctr_list[k]; j++) {
                    printf("%3d\n", node_list[node_ctr + j]);
                }
                node_ctr += node_ctr_list[k];
            }

            if (num_df_in_set > 0) {
                printf("dist factors for side set %2d\n", ids[i]);

                for (j = 0; j < num_df_in_set; j++) {
                    printf("%5.3f\n", dist_fact[j]);
                }
            }
            else
                printf("no dist factors for side set %2d\n", ids[i]);

            free(elem_list);
            free(side_list);
            free(node_ctr_list);
            free(node_list);
            free(dist_fact);
        }

        /* read side set properties */
        error = ex_inquire(exoid, EX_INQ_SS_PROP, &num_props, &fdum, cdum);
        printf("\nafter ex_inquire, error = %d\n", error);
        printf("\nThere are %2d properties for each side set\n", num_props);

        for (i = 0; i < num_props; i++) {
            prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }

        error = ex_get_prop_names(exoid, EX_SIDE_SET, prop_names);
        printf("after ex_get_prop_names, error = %d\n", error);

        for (i = 0; i < num_props; i++) {
            for (j = 0; j < num_side_sets; j++) {
                error = ex_get_prop(exoid, EX_SIDE_SET, ids[j], prop_names[i], &prop_value);
                if (error == 0)
                    printf("side set %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
                           prop_value);
                else
                    printf("after ex_get_prop, error = %d\n", error);
            }
        }
        for (i = 0; i < num_props; i++)
            free(prop_names[i]);
        free(ids);

        error = ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum);
        printf("\nafter ex_inquire: EX_INQ_SIDE_SETS = %d,  error = %d\n", num_side_sets, error);

        if (num_side_sets > 0) {
            error = ex_inquire(exoid, EX_INQ_SS_ELEM_LEN, &elem_list_len, &fdum, cdum);
            printf("\nafter ex_inquire: EX_INQ_SS_ELEM_LEN = %d,  error = %d\n", elem_list_len, error);

            error = ex_inquire(exoid, EX_INQ_SS_NODE_LEN, &node_list_len, &fdum, cdum);
            printf("\nafter ex_inquire: EX_INQ_SS_NODE_LEN = %d,  error = %d\n", node_list_len, error);

            error = ex_inquire(exoid, EX_INQ_SS_DF_LEN, &df_list_len, &fdum, cdum);
            printf("\nafter ex_inquire: EX_INQ_SS_DF_LEN = %d,  error = %d\n", df_list_len, error);
        }

        /* read concatenated side sets; this produces the same information as
         * the above code which reads individual side sets
         */

        /* concatenated side set read */

        if (num_side_sets > 0) {
            ids              = (int *)calloc(num_side_sets, sizeof(int));
            num_elem_per_set = (int *)calloc(num_side_sets, sizeof(int));
            num_df_per_set   = (int *)calloc(num_side_sets, sizeof(int));
            elem_ind         = (int *)calloc(num_side_sets, sizeof(int));
            df_ind           = (int *)calloc(num_side_sets, sizeof(int));
            elem_list        = (int *)calloc(elem_list_len, sizeof(int));
            side_list        = (int *)calloc(elem_list_len, sizeof(int));
            dist_fact        = (float *)calloc(df_list_len, sizeof(float));

            error = ex_get_concat_side_sets(exoid, ids, num_elem_per_set, num_df_per_set, elem_ind,
                                            df_ind, elem_list, side_list, dist_fact);
            printf("\nafter ex_get_concat_side_sets, error = %3d\n", error);

            printf("concatenated side set info\n");

            printf("ids = \n");
            for (i = 0; i < num_side_sets; i++)
                printf("%3d\n", ids[i]);

            printf("num_elem_per_set = \n");
            for (i = 0; i < num_side_sets; i++)
                printf("%3d\n", num_elem_per_set[i]);

            printf("num_dist_per_set = \n");
            for (i = 0; i < num_side_sets; i++)
                printf("%3d\n", num_df_per_set[i]);

            printf("elem_ind = \n");
            for (i = 0; i < num_side_sets; i++)
                printf("%3d\n", elem_ind[i]);

            printf("dist_ind = \n");
            for (i = 0; i < num_side_sets; i++)
                printf("%3d\n", df_ind[i]);

            printf("elem_list = \n");
            for (i = 0; i < elem_list_len; i++)
                printf("%3d\n", elem_list[i]);

            printf("side_list = \n");
            for (i = 0; i < elem_list_len; i++)
                printf("%3d\n", side_list[i]);

            printf("dist_fact = \n");
            for (i = 0; i < df_list_len; i++)
                printf("%5.3f\n", dist_fact[i]);

            free(ids);
            free(num_df_per_set);
            free(df_ind);
            free(elem_ind);
            free(elem_list);
            free(side_list);
            free(dist_fact);
        }
    }
    /* end of concatenated side set read */

    /* read QA records */

    ex_inquire(exoid, EX_INQ_QA, &num_qa_rec, &fdum, cdum);

    for (i = 0; i < num_qa_rec; i++) {
        for (j = 0; j < 4; j++) {
            qa_record[i][j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }
    }

    error = ex_get_qa(exoid, qa_record);
    printf("\nafter ex_get_qa, error = %3d\n", error);

    printf("QA records = \n");
    for (i = 0; i < num_qa_rec; i++) {
        for (j = 0; j < 4; j++) {
            printf(" '%s'\n", qa_record[i][j]);
            free(qa_record[i][j]);
        }
    }

    /* read information records */

    error = ex_inquire(exoid, EX_INQ_INFO, &num_info, &fdum, cdum);
    printf("\nafter ex_inquire, error = %3d\n", error);

    for (i = 0; i < num_info; i++) {
        info[i] = (char *)calloc((MAX_LINE_LENGTH + 1), sizeof(char));
    }

    error = ex_get_info(exoid, info);
    printf("\nafter ex_get_info, error = %3d\n", error);

    printf("info records = \n");
    for (i = 0; i < num_info; i++) {
        printf(" '%s'\n", info[i]);
        free(info[i]);
    }

    /* read global variables parameters and names */

    error = ex_get_variable_param(exoid, EX_GLOBAL, &num_glo_vars);
    printf("\nafter ex_get_variable_param, error = %3d\n", error);

    for (i = 0; i < num_glo_vars; i++) {
        var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
    }

    error = ex_get_variable_names(exoid, EX_GLOBAL, num_glo_vars, var_names);
    printf("\nafter ex_get_variable_names, error = %3d\n", error);

    printf("There are %2d global variables; their names are :\n", num_glo_vars);
    for (i = 0; i < num_glo_vars; i++) {
        printf(" '%s'\n", var_names[i]);
        free(var_names[i]);
    }

    /* read nodal variables parameters and names */
    num_nod_vars = 0;
    if (num_nodes > 0) {
        error = ex_get_variable_param(exoid, EX_NODE_SET, &num_nod_vars);
        printf("\nafter ex_get_variable_param, error = %3d\n", error);

        for (i = 0; i < num_nod_vars; i++) {
            var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }

        error = ex_get_variable_names(exoid, EX_NODAL, num_nod_vars, var_names);
        printf("\nafter ex_get_variable_names, error = %3d\n", error);

        printf("There are %2d nodal variables; their names are :\n", num_nod_vars);
        for (i = 0; i < num_nod_vars; i++) {
            printf(" '%s'\n", var_names[i]);
            free(var_names[i]);
        }
    }

    /* read element variables parameters and names */

    num_ele_vars = 0;
    if (num_elem > 0) {
        error = ex_get_variable_param(exoid, EX_ELEM_BLOCK, &num_ele_vars);
        printf("\nafter ex_get_variable_param, error = %3d\n", error);

        for (i = 0; i < num_ele_vars; i++) {
            var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
        }

        error = ex_get_variable_names(exoid, EX_ELEM_BLOCK, num_ele_vars, var_names);
        printf("\nafter ex_get_variable_names, error = %3d\n", error);

        printf("There are %2d element variables; their names are :\n", num_ele_vars);
        for (i = 0; i < num_ele_vars; i++) {
            printf(" '%s'\n", var_names[i]);
            free(var_names[i]);
        }

        /* read element variable truth table */

        if (num_ele_vars > 0) {
            truth_tab = (int *)calloc((num_elem_blk * num_ele_vars), sizeof(int));

            error = ex_get_truth_table(exoid, EX_ELEM_BLOCK, num_elem_blk, num_ele_vars, truth_tab);
            printf("\nafter ex_get_elem_var_tab, error = %3d\n", error);

            printf("This is the element variable truth table:\n");

            k = 0;
            for (i = 0; i < num_elem_blk * num_ele_vars; i++) {
                printf("%2d\n", truth_tab[k++]);
            }
            free(truth_tab);
        }
    }

    /* read nodeset variables parameters and names */

    num_nset_vars = 0;
    if (num_node_sets > 0) {
        error = ex_get_variable_param(exoid, "m", &num_nset_vars);
        printf("\nafter ex_get_variable_param, error = %3d\n", error);

        if (num_nset_vars > 0) {
            for (i = 0; i < num_nset_vars; i++) {
                var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
            }

            error = ex_get_variable_names(exoid, "m", num_nset_vars, var_names);
            printf("\nafter ex_get_variable_names, error = %3d\n", error);

            printf("There are %2d nodeset variables; their names are :\n", num_nset_vars);
            for (i = 0; i < num_nset_vars; i++) {
                printf(" '%s'\n", var_names[i]);
                free(var_names[i]);
            }

            /* read nodeset variable truth table */

            if (num_nset_vars > 0) {
                truth_tab = (int *)calloc((num_node_sets * num_nset_vars), sizeof(int));

                error = ex_get_truth_table(exoid, EX_NODE_SET, num_node_sets, num_nset_vars, truth_tab);
                printf("\nafter ex_get_nset_var_tab, error = %3d\n", error);

                printf("This is the nodeset variable truth table:\n");

                k = 0;
                for (i = 0; i < num_node_sets * num_nset_vars; i++) {
                    printf("%2d\n", truth_tab[k++]);
                }
                free(truth_tab);
            }
        }
    }

    /* read sideset variables parameters and names */

    num_sset_vars = 0;
    if (num_side_sets > 0) {
        error = ex_get_variable_param(exoid, EX_SIDE_SET, &num_sset_vars);
        printf("\nafter ex_get_variable_param, error = %3d\n", error);

        if (num_sset_vars > 0) {
            for (i = 0; i < num_sset_vars; i++) {
                var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
            }

            error = ex_get_variable_names(exoid, EX_SIDE_SET, num_sset_vars, var_names);
            printf("\nafter ex_get_variable_names, error = %3d\n", error);

            printf("There are %2d sideset variables; their names are :\n", num_sset_vars);
            for (i = 0; i < num_sset_vars; i++) {
                printf(" '%s'\n", var_names[i]);
                free(var_names[i]);
            }

            /* read sideset variable truth table */

            if (num_sset_vars > 0) {
                truth_tab = (int *)calloc((num_side_sets * num_sset_vars), sizeof(int));

                error = ex_get_truth_table(exoid, EX_SIDE_SET, num_side_sets, num_sset_vars, truth_tab);
                printf("\nafter ex_get_sset_var_tab, error = %3d\n", error);

                printf("This is the sideset variable truth table:\n");

                k = 0;
                for (i = 0; i < num_side_sets * num_sset_vars; i++) {
                    printf("%2d\n", truth_tab[k++]);
                }
                free(truth_tab);
            }
        }
    }

    /* determine how many time steps are stored */

    error = ex_inquire(exoid, EX_INQ_TIME, &num_time_steps, &fdum, cdum);
    printf("\nafter ex_inquire, error = %3d\n", error);
    printf("There are %2d time steps in the database.\n", num_time_steps);

    /* read time value at one time step */

    time_step = 3;
    error     = ex_get_time(exoid, time_step, &time_value);
    printf("\nafter ex_get_time, error = %3d\n", error);

    printf("time value at time step %2d = %5.3f\n", time_step, time_value);

    /* read time values at all time steps */

    time_values = (float *)calloc(num_time_steps, sizeof(float));

    error = ex_get_all_times(exoid, time_values);
    printf("\nafter ex_get_all_times, error = %3d\n", error);

    printf("time values at all time steps are:\n");
    for (i = 0; i < num_time_steps; i++)
        printf("%5.3f\n", time_values[i]);

    free(time_values);

    /* read all global variables at one time step */

    var_values = (float *)calloc(num_glo_vars, sizeof(float));

    error = ex_get_glob_vars(exoid, time_step, num_glo_vars, var_values);
    printf("\nafter ex_get_glob_vars, error = %3d\n", error);

    printf("global variable values at time step %2d\n", time_step);
    for (i = 0; i < num_glo_vars; i++)
        printf("%5.3f\n", var_values[i]);

    free(var_values);

    /* read a single global variable through time */

    var_index = 1;
    beg_time  = 1;
    end_time  = -1;

    var_values = (float *)calloc(num_time_steps, sizeof(float));

    error = ex_get_glob_var_time(exoid, var_index, beg_time, end_time, var_values);
    printf("\nafter ex_get_glob_var_time, error = %3d\n", error);

    printf("global variable %2d values through time:\n", var_index);
    for (i = 0; i < num_time_steps; i++)
        printf("%5.3f\n", var_values[i]);

    free(var_values);

    /* read a nodal variable at one time step */

    if (num_nodes > 0) {
        var_values = (float *)calloc(num_nodes, sizeof(float));

        error = ex_get_var(exoid, time_step, EX_NODAL, var_index, 1, num_nodes, var_values);
        printf("\nafter ex_get_nodal_var, error = %3d\n", error);

        printf("nodal variable %2d values at time step %2d\n", var_index, time_step);
        for (i = 0; i < num_nodes; i++)
            printf("%5.3f\n", var_values[i]);

        free(var_values);

        /* read a nodal variable through time */

        var_values = (float *)calloc(num_time_steps, sizeof(float));

        node_num = 1;
        error = ex_get_var_time(exoid, EX_NODAL, var_index, node_num, beg_time, end_time, var_values);
        printf("\nafter ex_get_nodal_var_time, error = %3d\n", error);

        printf("nodal variable %2d values for node %2d through time:\n", var_index, node_num);
        for (i = 0; i < num_time_steps; i++)
            printf("%5.3f\n", var_values[i]);

        free(var_values);
    }
    /* read an element variable at one time step */

    if (num_elem_blk > 0) {
        ids = (int *)calloc(num_elem_blk, sizeof(int));

        error = ex_get_ids(exoid, EX_ELEM_BLOCK, ids);
        printf("\n after ex_get_elem_blk_ids, error = %3d\n", error);

        for (i = 0; i < num_elem_blk; i++) {
            if (num_elem_in_block[i] > 0) {
                var_values = (float *)calloc(num_elem_in_block[i], sizeof(float));

                error = ex_get_var(exoid, time_step, EX_ELEM_BLOCK, var_index, ids[i], num_elem_in_block[i],
                                   var_values);
                printf("\nafter ex_get_elem_var, error = %3d\n", error);

                if (!error) {
                    printf("element variable %2d values of element block %2d at time step %2d\n", var_index,
                           ids[i], time_step);
                    for (j = 0; j < num_elem_in_block[i]; j++)
                        printf("%5.3f\n", var_values[j]);
                }

                free(var_values);
            }
        }
        free(num_elem_in_block);
        free(ids);
    }
    /* read an element variable through time */

    if (num_ele_vars > 0) {
        var_values = (float *)calloc(num_time_steps, sizeof(float));

        var_index = 2;
        elem_num  = 2;
        error =
            ex_get_var_time(exoid, EX_ELEM_BLOCK, var_index, elem_num, beg_time, end_time, var_values);
        printf("\nafter ex_get_elem_var_time, error = %3d\n", error);

        printf("element variable %2d values for element %2d through time:\n", var_index, elem_num);
        for (i = 0; i < num_time_steps; i++)
            printf("%5.3f\n", var_values[i]);

        free(var_values);
    }

    /* read a sideset variable at one time step */

    if (num_sset_vars > 0) {
        ids = (int *)calloc(num_side_sets, sizeof(int));

        error = ex_get_ids(exoid, EX_SIDE_SET, ids);
        printf("\n after ex_get_side_set_ids, error = %3d\n", error);

        for (i = 0; i < num_side_sets; i++) {
            var_values = (float *)calloc(num_elem_per_set[i], sizeof(float));

            error = ex_get_var(exoid, time_step, EX_SIDE_SET, var_index, ids[i], num_elem_per_set[i],
                               var_values);
            printf("\nafter ex_get_sset_var, error = %3d\n", error);

            if (!error) {
                printf("sideset variable %2d values of sideset %2d at time step %2d\n", var_index, ids[i],
                       time_step);
                for (j = 0; j < num_elem_per_set[i]; j++)
                    printf("%5.3f\n", var_values[j]);
            }

            free(var_values);
        }
        free(num_elem_per_set);
        free(ids);
    }

    /* read a nodeset variable at one time step */

    if (num_nset_vars > 0) {
        ids = (int *)calloc(num_node_sets, sizeof(int));

        error = ex_get_ids(exoid, EX_NODE_SET, ids);
        printf("\n after ex_get_node_set_ids, error = %3d\n", error);

        for (i = 0; i < num_node_sets; i++) {
            var_values = (float *)calloc(num_nodes_per_set[i], sizeof(float));

            error = ex_get_var(exoid, time_step, EX_NODE_SET, var_index, ids[i], num_nodes_per_set[i],
                               var_values);
            printf("\nafter ex_get_nset_var, error = %3d\n", error);

            if (!error) {
                printf("nodeset variable %2d values of nodeset %2d at time step %2d\n", var_index, ids[i],
                       time_step);
                for (j = 0; j < num_nodes_per_set[i]; j++)
                    printf("%5.3f\n", var_values[j]);
            }

            free(var_values);
        }
        free(ids);
    }
    if (num_node_sets > 0)
        free(num_nodes_per_set);

    error = ex_close(exoid);
    printf("\nafter ex_close, error = %3d\n", error);
    MPI_Finalize();
    return 0;
}