Excn::ExodusFile::ExodusFile(int processor) : myProcessor_(processor) { SMART_ASSERT(processor < processorCount_)(processor)(processorCount_); SMART_ASSERT(fileids_.size() == (size_t)processorCount_); if (!keepOpen_ && processor != 0) { float version = 0.0; int cpu_word_size = cpuWordSize_; int io_word_size_var = ioWordSize_; int mode = EX_READ; mode |= mode64bit_; fileids_[processor] = ex_open(filenames_[processor].c_str(), mode, &cpu_word_size, &io_word_size_var, &version); if (fileids_[processor] < 0) { std::cerr << "Cannot open file '" << filenames_[processor] << "' - exiting" << std::endl; exit(1); } ex_set_max_name_length(fileids_[processor], maximumNameLength_); SMART_ASSERT(io_word_size_var == ioWordSize_); SMART_ASSERT(cpu_word_size == cpuWordSize_); } }
bool Excn::ExodusFile::create_output(const SystemInterface& si) // Create output file... { outputFilename_ = si.outputName_; int mode = EX_CLOBBER | exodusMode_; if (si.ints_64_bit()) mode |= EX_ALL_INT64_DB; std::cout << "Output: '" << outputFilename_ << "'" << std::endl; outputId_ = ex_create(outputFilename_.c_str(), mode, &cpuWordSize_, &ioWordSize_); if (outputId_ < 0) { std::cerr << "Cannot open file '" << outputFilename_ << "'" << std::endl; return false; } std::cout << "IO Word size is " << ioWordSize_ << " bytes.\n"; ex_set_max_name_length(outputId_, maximumNameLength_); return true; }
Excn::ExodusFile::ExodusFile(size_t which) : myLocation_(which) { SMART_ASSERT(which < filenames_.size())(which)(filenames_.size()); SMART_ASSERT(fileids_.size() == filenames_.size()); if (!keepOpen_ && which != 0) { float version = 0.0; int cpu_word_size = cpuWordSize_; int io_wrd_size = ioWordSize_; fileids_[which] = ex_open(filenames_[which].c_str(), EX_READ|exodusMode_, &cpu_word_size, &io_wrd_size, &version); if (fileids_[which] < 0) { std::cerr << "Cannot open file '" << filenames_[which] << "' - exiting" << std::endl; exit(1); } ex_set_max_name_length(fileids_[which], maximumNameLength_); SMART_ASSERT(io_wrd_size == ioWordSize_); SMART_ASSERT(cpu_word_size == cpuWordSize_); } }
int main (int argc, char **argv) { int exoid, num_dim, num_nodes, num_elem, num_elem_blk; int num_elem_in_block[10], num_nodes_per_elem[10]; int num_nodes_in_nset[10]; int num_node_sets, num_side_sets; int i, j, k, m, *elem_map, *connect; int node_list[100]; int ebids[10], nsids[10]; int num_qa_rec, num_info; int num_glo_vars, num_nod_vars, num_ele_vars, num_nset_vars; int *truth_tab; int whole_time_step, num_time_steps; int CPU_word_size,IO_word_size; int prop_array[2]; float *glob_var_vals, *nodal_var_vals, *elem_var_vals; float *nset_var_vals; float time_value; float x[100]; float attrib[10], dist_fact[100]; char *coord_names[3], *qa_record[2][4], *info[3], *var_names[3]; char *block_names[10], *nset_names[10]; char *prop_names[2], *attrib_names[2]; char *title = "This is a test"; ex_opts (EX_VERBOSE | EX_ABORT ); /* Specify compute and i/o word size */ CPU_word_size = 0; /* sizeof(float) */ IO_word_size = 4; /* (4 bytes) */ /* create EXODUS II file */ exoid = ex_create ("oned.e", /* filename path */ EX_CLOBBER, /* create mode */ &CPU_word_size, /* CPU float word size in bytes */ &IO_word_size); /* I/O float word size in bytes */ printf ("after ex_create for oned.e, exoid = %d\n", exoid); printf (" cpu word size: %d io word size: %d\n",CPU_word_size,IO_word_size); EXCHECK(ex_set_max_name_length(exoid, 40)); /* ncopts = NC_VERBOSE; */ /* initialize file with parameters */ num_dim = 1; num_nodes = 10; num_elem = 10; /* 9 lines plus a point */ num_elem_blk = 3; num_node_sets = 2; num_side_sets = 0; EXCHECK(ex_put_init (exoid, title, num_dim, num_nodes, num_elem, num_elem_blk, num_node_sets, num_side_sets)); for (i=0; i < num_nodes; i++) { x[i] = exp((float)i/10.0); } EXCHECK(ex_put_coord (exoid, x, NULL, NULL)); coord_names[0] = "xcoor"; EXCHECK(ex_put_coord_names (exoid, coord_names)); /* Add nodal attributes */ EXCHECK(ex_put_attr_param(exoid, EX_NODAL, 0, 1)); EXCHECK(ex_put_one_attr(exoid, EX_NODAL, 0, 1, x)); attrib_names[0] = "Node_attr_1"; EXCHECK(ex_put_attr_names (exoid, EX_NODAL, 0, attrib_names)); /* write element order map */ elem_map = (int *) calloc(num_elem, sizeof(int)); for (i=1; i<=num_elem; i++) { elem_map[i-1] = 10*i; } EXCHECK(ex_put_map (exoid, elem_map)); free (elem_map); /* write element block parameters */ block_names[0] = "left_side"; block_names[1] = "right_side"; block_names[2] = "center"; num_elem_in_block[0] = 4; num_elem_in_block[1] = 5; num_elem_in_block[2] = 1; num_nodes_per_elem[0] = 2; num_nodes_per_elem[1] = 2; num_nodes_per_elem[2] = 1; ebids[0] = 10; ebids[1] = 20; ebids[2] = 30; EXCHECK(ex_put_elem_block (exoid, ebids[0], "line", num_elem_in_block[0], num_nodes_per_elem[0], 1)); EXCHECK(ex_put_elem_block (exoid, ebids[1], "line", num_elem_in_block[1], num_nodes_per_elem[1], 1)); EXCHECK(ex_put_elem_block (exoid, ebids[2], "point", num_elem_in_block[2], num_nodes_per_elem[2], 0)); /* Write element block names */ EXCHECK(ex_put_names(exoid, EX_ELEM_BLOCK, block_names)); /* write element block properties */ prop_names[0] = "DENSITY"; EXCHECK(ex_put_prop_names(exoid,EX_ELEM_BLOCK,1,prop_names)); EXCHECK(ex_put_prop(exoid, EX_ELEM_BLOCK, ebids[0], prop_names[0], 1.345)); EXCHECK(ex_put_prop(exoid, EX_ELEM_BLOCK, ebids[1], prop_names[0], 10.995)); EXCHECK(ex_put_prop(exoid, EX_ELEM_BLOCK, ebids[2], prop_names[0], 0.001)); /* write element connectivity */ connect = (int *) calloc(18, sizeof(int)); for (i=0; i < num_elem*2; i+=2) { connect[i] = i/2+1; connect[i+1] = i/2+2; } EXCHECK(ex_put_conn (exoid, EX_ELEM_BLOCK, ebids[0], connect, NULL, NULL)); EXCHECK(ex_put_conn (exoid, EX_ELEM_BLOCK, ebids[1], connect+8, NULL, NULL)); /* Circle */ connect[0] = 5; EXCHECK(ex_put_conn (exoid, EX_ELEM_BLOCK, ebids[2], connect, NULL, NULL)); /* write element block attributes */ for (i=0; i < num_elem; i++) { attrib[i] = 3.14159 * i; } EXCHECK(ex_put_attr (exoid, EX_ELEM_BLOCK, ebids[0], attrib)); EXCHECK(ex_put_attr (exoid, EX_ELEM_BLOCK, ebids[1], attrib+num_elem_in_block[0])); attrib_names[0] = "THICKNESS"; EXCHECK(ex_put_attr_names (exoid, EX_ELEM_BLOCK, ebids[0], attrib_names)); attrib_names[0] = "WIDTH"; EXCHECK(ex_put_attr_names (exoid, EX_ELEM_BLOCK, ebids[1], attrib_names)); /* write individual node sets */ num_nodes_in_nset[0] = 5; num_nodes_in_nset[1] = 3; nsids[0] = 20; nsids[1] = 21; EXCHECK(ex_put_node_set_param (exoid, nsids[0], 5, 5)); node_list[0] = 1; node_list[1] = 3; node_list[2] = 5; node_list[3] = 7; node_list[4] = 9; dist_fact[0] = 1.0; dist_fact[1] = 2.0; dist_fact[2] = 3.0; dist_fact[3] = 4.0; dist_fact[4] = 5.0; EXCHECK(ex_put_node_set (exoid, nsids[0], node_list)); EXCHECK(ex_put_node_set_dist_fact (exoid, nsids[0], dist_fact)); EXCHECK(ex_put_node_set_param (exoid, nsids[1], 3, 3)); node_list[0] = 2; node_list[1] = 4; node_list[2] = 6; dist_fact[0] = 1.0; dist_fact[1] = 2.0; dist_fact[2] = 3.0; EXCHECK(ex_put_node_set (exoid, nsids[1], node_list)); EXCHECK(ex_put_node_set_dist_fact (exoid, nsids[1], dist_fact)); /* Write node set names */ nset_names[0] = "all_odd_nodes"; nset_names[1] = "some_even_nodes"; EXCHECK(ex_put_names(exoid, EX_NODE_SET, nset_names)); EXCHECK(ex_put_prop(exoid, EX_NODE_SET, nsids[0], "FACE", 4)); EXCHECK(ex_put_prop(exoid, EX_NODE_SET, nsids[1], "FACE", 5)); prop_array[0] = 1000; prop_array[1] = 2000; EXCHECK(ex_put_prop_array(exoid, EX_NODE_SET, "VELOCITY", prop_array)); /* Add nodeset attributes */ EXCHECK(ex_put_attr_param(exoid, EX_NODE_SET, nsids[0], 1)); EXCHECK(ex_put_attr(exoid, EX_NODE_SET, nsids[0], x)); attrib_names[0] = "Nodeset_attribute"; EXCHECK(ex_put_attr_names (exoid, EX_NODE_SET, nsids[0], attrib_names)); /* write QA records; test empty and just blank-filled records */ num_qa_rec = 2; qa_record[0][0] = "TESTWT"; qa_record[0][1] = "testwt"; qa_record[0][2] = "07/07/93"; qa_record[0][3] = "15:41:33"; qa_record[1][0] = ""; qa_record[1][1] = " "; qa_record[1][2] = ""; qa_record[1][3] = " "; EXCHECK(ex_put_qa (exoid, num_qa_rec, qa_record)); /* write information records; test empty and just blank-filled records */ num_info = 3; info[0] = "This is the first information record."; info[1] = ""; info[2] = " "; EXCHECK(ex_put_info (exoid, num_info, info)); /* write results variables parameters and names */ num_glo_vars = 1; var_names[0] = "glo_vars"; EXCHECK(ex_put_variable_param (exoid, EX_GLOBAL, num_glo_vars)); EXCHECK(ex_put_variable_names (exoid, EX_GLOBAL, num_glo_vars, var_names)); num_nod_vars = 2; /* 12345678901234567890123456789012 */ var_names[0] = "node_variable_a_very_long_name_0"; var_names[1] = "nod_var1"; EXCHECK(ex_put_variable_param (exoid, EX_NODAL, num_nod_vars)); EXCHECK(ex_put_variable_names (exoid, EX_NODAL, num_nod_vars, var_names)); num_ele_vars = 3; /* 0 1 2 3 */ /* 12345678901234567890123456789012 */ var_names[0] = "this_variable_name_is_short"; var_names[1] = "this_variable_name_is_just_right"; var_names[2] = "this_variable_name_is_tooooo_long"; EXCHECK(ex_put_variable_param (exoid, EX_ELEM_BLOCK, num_ele_vars)); EXCHECK(ex_put_variable_names (exoid, EX_ELEM_BLOCK, num_ele_vars, var_names)); num_nset_vars = 3; var_names[0] = "ns_var0"; var_names[1] = "ns_var1"; var_names[2] = "ns_var2"; EXCHECK(ex_put_variable_param (exoid, EX_NODE_SET, num_nset_vars)); EXCHECK(ex_put_variable_names (exoid, EX_NODE_SET, num_nset_vars, var_names)); /* write element variable truth table */ truth_tab = (int *) calloc ((num_elem_blk*num_ele_vars), sizeof(int)); k = 0; for (i=0; i<num_elem_blk; i++) { for (j=0; j<num_ele_vars; j++) { truth_tab[k++] = 1; } } EXCHECK(ex_put_truth_table(exoid, EX_ELEM_BLOCK, num_elem_blk, num_ele_vars, truth_tab)); free (truth_tab); /* for each time step, write the analysis results; * the code below fills the arrays glob_var_vals, * nodal_var_vals, and elem_var_vals with values for debugging purposes; */ whole_time_step = 1; num_time_steps = 10; glob_var_vals = (float *) calloc (num_glo_vars, CPU_word_size); nodal_var_vals = (float *) calloc (num_nodes, CPU_word_size); elem_var_vals = (float *) calloc (num_elem, CPU_word_size); nset_var_vals = (float *) calloc (10, CPU_word_size); for (i=0; i<num_time_steps; i++) { time_value = (float)(i+1)/100.; /* write time value */ EXCHECK(ex_put_time (exoid, whole_time_step, &time_value)); /* write global variables */ for (j=0; j<num_glo_vars; j++) { glob_var_vals[j] = (float)(j+2) * time_value; } EXCHECK(ex_put_var (exoid, whole_time_step, EX_GLOBAL, 0, 0, num_glo_vars, glob_var_vals)); /* write nodal variables */ for (k=1; k<=num_nod_vars; k++) { for (j=0; j<num_nodes; j++) { nodal_var_vals[j] = (float)k + ((float)(j+1) * time_value); } EXCHECK(ex_put_var (exoid, whole_time_step, EX_NODAL, k, 1, num_nodes, nodal_var_vals)); } /* write element variables */ for (k=1; k<=num_ele_vars; k++) { for (j=0; j<num_elem_blk; j++) { for (m=0; m<num_elem_in_block[j]; m++) { elem_var_vals[m] = (float)(k+1) + (float)(j+2) + ((float)(m+1)*time_value); } EXCHECK(ex_put_var (exoid, whole_time_step, EX_ELEM_BLOCK, k, ebids[j], num_elem_in_block[j], elem_var_vals)); } } /* write nodeset variables */ for (k=1; k<=num_nset_vars; k++) { for (j=0; j<num_node_sets; j++) { for (m=0; m<num_nodes_in_nset[j]; m++) { nset_var_vals[m] = (float)(k+3) + (float)(j+4) + ((float)(m+1)*time_value); } EXCHECK(ex_put_var (exoid, whole_time_step, EX_NODE_SET, k, nsids[j], num_nodes_in_nset[j], nset_var_vals)); } } whole_time_step++; /* update the data file; this should be done at the end of every time step * to ensure that no data is lost if the analysis dies */ EXCHECK(ex_update (exoid)); } free(glob_var_vals); free(nodal_var_vals); free(elem_var_vals); free(nset_var_vals); /* close the EXODUS files */ EXCHECK(ex_close (exoid)); return 0; }
void NemSpread<T,INT>::read_restart_params() /* Function which reads the restart variable parameters for the EXODUS II * database which contains the results information. Allocate necessary * memory on each processor. * *---------------------------------------------------------------------------- * * Functions called: * * compare_mesh_param -- function which checks that parameters in * the restart EXODUS II file are the same as in * the mesh EXODUS II file * read_var_param -- function which reads the time indicies, number * of variables, and their names from the restart file * *---------------------------------------------------------------------------- */ { const char *yo="read_restart_params"; int exoid, cpu_ws=0; float vers; int max_name_length = 0; /* Open the ExodusII file */ cpu_ws = io_ws; int mode = EX_READ | int64api; if ((exoid=ex_open(Exo_Res_File, mode, &cpu_ws, &io_ws, &vers)) < 0) { fprintf(stderr, "%s: Could not open file %s for restart info\n", yo, Exo_Res_File); exit(1); } max_name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_USED_NAME_LENGTH); ex_set_max_name_length(exoid, max_name_length); /* * Just do a rudimentary check to figure out if the mesh parameters * in the results file are the same as the mesh parameters in the * mesh file. */ if (strcmp(ExoFile, Exo_Res_File) != 0) if (!compare_mesh_param(exoid)) { fprintf(stderr, "%s: Mesh parameters in mesh and result files" " differ\n", yo); exit(1); } /* get the time, and the variable names */ if (read_var_param(exoid, max_name_length) < 0) { fprintf(stderr, "%s: Error occured while reading variable parameters\n", yo); exit(1); } /* Close the ExodusII file */ ex_close(exoid); return; }
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 *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; int max_name_length; 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 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]; char *name = NULL; 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); ex_inquire(exoid,EX_INQ_LIB_VERS, &idum, &version, cdum); printf ("EXODUSII Library API; version %4.2f (%d)\n", version, idum); /* Query size of names used in this file */ { int max_all_name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH); int max_use_name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_USED_NAME_LENGTH); printf ("This file can use at most %d-character names\n", max_all_name_length); printf ("The maximum name length used is %d-character names\n", max_use_name_length); max_name_length = max_use_name_length; ex_set_max_name_length(exoid, max_name_length); } name = (char *) calloc(max_name_length+1, sizeof(char)); /* 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 = %3d\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)); y = (float *) calloc(num_nodes, sizeof(float)); 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]); } 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); free (y); if (num_dim >= 3) free (z); for (i=0; i<num_dim; i++) { coord_names[i] = (char *) calloc ((max_name_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]); 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_name_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_elem_blk_ids (exoid, ids); printf ("\nafter ex_get_elem_blk_ids, error = %3d\n", error); for (i=0; i<num_elem_blk; i++) { block_names[i] = (char *) calloc ((max_name_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_elem_block (exoid, ids[i], elem_type, &(num_elem_in_block[i]), &(num_nodes_per_elem[i]), &(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]); 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_name_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_elem_conn (exoid, 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_name_length+1), sizeof(char)); attrib = (float *) calloc(num_attr[i]*num_elem_in_block[i],sizeof(float)); error = ex_get_elem_attr (exoid, ids[i], attrib); printf ("\n after ex_get_elem_attr, error = %d\n", error); if (error == 0) { error = ex_get_elem_attr_names (exoid, 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_node_set_ids (exoid, 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_name_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_node_set_param (exoid, 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_node_set (exoid, ids[i], node_list); printf ("\nafter ex_get_node_set, error = %3d\n", error); if (num_df_in_set > 0) { error = ex_get_node_set_dist_fact (exoid, 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_df_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_name_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_name_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_side_set_ids (exoid, 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_name_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_side_set_param (exoid, 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_side_set (exoid, 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_side_set_dist_fact (exoid, 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_name_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_name_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_var_param (exoid, "g", &num_glo_vars); printf ("\nafter ex_get_var_param, error = %3d\n", error); for (i=0; i<num_glo_vars; i++) { var_names[i] = (char *) calloc ((max_name_length+1), sizeof(char)); } error = ex_get_var_names (exoid, "g", num_glo_vars, var_names); printf ("\nafter ex_get_var_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_var_param (exoid, "n", &num_nod_vars); printf ("\nafter ex_get_var_param, error = %3d\n", error); for (i=0; i<num_nod_vars; i++) { var_names[i] = (char *) calloc ((max_name_length+1), sizeof(char)); } error = ex_get_var_names (exoid, "n", num_nod_vars, var_names); printf ("\nafter ex_get_var_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_var_param (exoid, "e", &num_ele_vars); printf ("\nafter ex_get_var_param, error = %3d\n", error); for (i=0; i<num_ele_vars; i++) { var_names[i] = (char *) calloc ((max_name_length+1), sizeof(char)); } error = ex_get_var_names (exoid, "e", num_ele_vars, var_names); printf ("\nafter ex_get_var_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_elem_var_tab (exoid, 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_var_param (exoid, "m", &num_nset_vars); printf ("\nafter ex_get_var_param, error = %3d\n", error); if (num_nset_vars > 0) { for (i=0; i<num_nset_vars; i++) { var_names[i] = (char *) calloc ((max_name_length+1), sizeof(char)); } error = ex_get_var_names (exoid, "m", num_nset_vars, var_names); printf ("\nafter ex_get_var_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_nset_var_tab (exoid, 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_var_param (exoid, "s", &num_sset_vars); printf ("\nafter ex_get_var_param, error = %3d\n", error); if (num_sset_vars > 0) { for (i=0; i<num_sset_vars; i++) { var_names[i] = (char *) calloc ((max_name_length+1), sizeof(char)); } error = ex_get_var_names (exoid, "s", num_sset_vars, var_names); printf ("\nafter ex_get_var_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_sset_var_tab (exoid, 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_nodal_var (exoid, time_step, var_index, 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_nodal_var_time (exoid, 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_elem_blk_ids (exoid, 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_elem_var (exoid, time_step, 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_elem_var_time (exoid, 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_side_set_ids (exoid, 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_sset_var (exoid, time_step, 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_node_set_ids (exoid, 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_nset_var (exoid, time_step, 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); free (name); error = ex_close (exoid); printf ("\nafter ex_close, error = %3d\n", error); return 0; }
template <typename INT> void ExoII_Read<INT>::Get_Init_Data() { SMART_ASSERT(Check_State()); SMART_ASSERT(file_id >= 0); // Determine max size of entity and variable names on the database int name_length = ex_inquire_int(file_id, EX_INQ_DB_MAX_USED_NAME_LENGTH); ex_set_max_name_length(file_id, name_length); ex_init_params info; info.title[0] = '\0'; int err = ex_get_init_ext(file_id, &info); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get init data!" << " Error number = " << err << ". Aborting..." << '\n'; exit(1); } dimension = info.num_dim; num_nodes = info.num_nodes; num_elmts = info.num_elem; num_elmt_blocks = info.num_elem_blk; num_node_sets = info.num_node_sets; num_side_sets = info.num_side_sets; title = info.title; if (err > 0 && !interface.quiet_flag) std::cout << "EXODIFF WARNING: was issued, number = " << err << '\n'; if (dimension < 1 || dimension > 3 || num_elmt_blocks < 0 || num_node_sets < 0 || num_side_sets < 0) { std::cout << "EXODIFF ERROR: Init data appears corrupt:" << '\n' << " dimension = " << dimension << '\n' << " num_nodes = " << num_nodes << '\n' << " num_elmts = " << num_elmts << '\n' << " num_elmt_blocks = " << num_elmt_blocks << '\n' << " num_node_sets = " << num_node_sets << '\n' << " num_side_sets = " << num_side_sets << '\n' << " ... Aborting..." << '\n'; exit(1); } int num_qa = ex_inquire_int(file_id, EX_INQ_QA); int num_info = ex_inquire_int(file_id, EX_INQ_INFO); if (num_qa < 0 || num_info < 0) { std::cout << "EXODIFF ERROR: inquire data appears corrupt:" << '\n' << " num_qa = " << num_qa << '\n' << " num_info = " << num_info << '\n' << " ... Aborting..." << '\n'; exit(1); } // Coordinate Names... char **coords = get_name_array(3, name_length); err = ex_get_coord_names(file_id, coords); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get coordinate" << " names! Aborting..." << '\n'; exit(1); } coord_names.clear(); for (size_t i = 0; i < dimension; ++i) { coord_names.push_back(coords[i]); } free_name_array(coords, 3); // Element Block Data... if (eblocks) delete[] eblocks; eblocks = nullptr; if (num_elmt_blocks > 0) { eblocks = new Exo_Block<INT>[num_elmt_blocks]; SMART_ASSERT(eblocks != nullptr); std::vector<INT> ids(num_elmt_blocks); err = ex_get_ids(file_id, EX_ELEM_BLOCK, TOPTR(ids)); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get element" << " block ids! Aborting..." << '\n'; exit(1); } size_t e_count = 0; for (size_t b = 0; b < num_elmt_blocks; ++b) { if (ids[b] <= EX_INVALID_ID) { std::cout << "EXODIFF WARNING: Element block Id " << "for block index " << b << " is " << ids[b] << " which is negative. This was returned by call to ex_get_elem_blk_ids()." << '\n'; } eblocks[b].initialize(file_id, ids[b]); e_count += eblocks[b].Size(); } if (e_count != num_elmts && !interface.quiet_flag) { std::cout << "EXODIFF WARNING: Total number of elements " << num_elmts << " does not equal the sum of the number of elements " << "in each block " << e_count << '\n'; } // Gather the attribute names (even though not all attributes are on all blocks) std::set<std::string> names; for (size_t b = 0; b < num_elmt_blocks; ++b) { for (int a = 0; a < eblocks[b].attr_count(); a++) { names.insert(eblocks[b].Get_Attribute_Name(a)); } } elmt_atts.resize(names.size()); std::copy(names.begin(), names.end(), elmt_atts.begin()); } // Node & Side sets... if (nsets) delete[] nsets; nsets = nullptr; if (num_node_sets > 0) { nsets = new Node_Set<INT>[num_node_sets]; SMART_ASSERT(nsets != nullptr); std::vector<INT> ids(num_node_sets); err = ex_get_ids(file_id, EX_NODE_SET, TOPTR(ids)); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get " << "nodeset ids! Aborting..." << '\n'; exit(1); } for (size_t nset = 0; nset < num_node_sets; ++nset) { if (ids[nset] <= EX_INVALID_ID) { std::cout << "EXODIFF WARNING: Nodeset Id " << "for nodeset index " << nset << " is " << ids[nset] << " which is negative. This was returned by call to ex_get_ids()." << '\n'; } nsets[nset].initialize(file_id, ids[nset]); } } if (ssets) delete[] ssets; ssets = nullptr; if (num_side_sets) { ssets = new Side_Set<INT>[num_side_sets]; SMART_ASSERT(ssets != nullptr); std::vector<INT> ids(num_side_sets); err = ex_get_ids(file_id, EX_SIDE_SET, TOPTR(ids)); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get " << "sideset ids! Aborting..." << '\n'; exit(1); } for (size_t sset = 0; sset < num_side_sets; ++sset) { if (ids[sset] <= EX_INVALID_ID) { std::cout << "EXODIFF WARNING: Sideset Id " << "for sideset index " << sset << " is " << ids[sset] << " which is negative. This was returned by call to ex_get_ids()." << '\n'; } ssets[sset].initialize(file_id, ids[sset]); } } // ************** RESULTS info *************** // int num_global_vars, num_nodal_vars, num_elmt_vars, num_ns_vars, num_ss_vars; err = ex_get_variable_param(file_id, EX_GLOBAL, &num_global_vars); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get number of" << " global variables! Aborting..." << '\n'; exit(1); } err = ex_get_variable_param(file_id, EX_NODAL, &num_nodal_vars); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get number of" << " nodal variables! Aborting..." << '\n'; exit(1); } err = ex_get_variable_param(file_id, EX_ELEM_BLOCK, &num_elmt_vars); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get number of" << " element variables! Aborting..." << '\n'; exit(1); } err = ex_get_variable_param(file_id, EX_NODE_SET, &num_ns_vars); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get number of" << " nodeset variables! Aborting..." << '\n'; exit(1); } err = ex_get_variable_param(file_id, EX_SIDE_SET, &num_ss_vars); if (err < 0) { std::cout << "EXODIFF ERROR: Failed to get number of" << " sideset variables! Aborting..." << '\n'; exit(1); } if (num_global_vars < 0 || num_nodal_vars < 0 || num_elmt_vars < 0 || num_ns_vars < 0 || num_ss_vars < 0) { std::cout << "EXODIFF ERROR: Data appears corrupt for" << " number of variables !" << '\n' << "\tnum global vars = " << num_global_vars << '\n' << "\tnum nodal vars = " << num_nodal_vars << '\n' << "\tnum element vars = " << num_elmt_vars << '\n' << " ... Aborting..." << '\n'; exit(1); } read_vars(file_id, EX_GLOBAL, "Global", num_global_vars, global_vars); read_vars(file_id, EX_NODAL, "Nodal", num_nodal_vars, nodal_vars); read_vars(file_id, EX_ELEM_BLOCK, "Element", num_elmt_vars, elmt_vars); read_vars(file_id, EX_NODE_SET, "Nodeset", num_ns_vars, ns_vars); read_vars(file_id, EX_SIDE_SET, "Sideset", num_ss_vars, ss_vars); // Times: num_times = ex_inquire_int(file_id, EX_INQ_TIME); if (num_times < 0) { std::cout << "EXODIFF ERROR: Number of time steps came" << " back negative (" << num_times << ")! Aborting..." << '\n'; exit(1); } if ((num_global_vars > 0 || num_nodal_vars > 0 || num_elmt_vars > 0 || num_ns_vars > 0 || num_ss_vars > 0) && num_times == 0) { std::cout << "EXODIFF Consistency error -- The database contains transient variables, but no " "timesteps!" << '\n'; exit(1); } if (num_times) { times = new double[num_times]; SMART_ASSERT(times != nullptr); err = ex_get_all_times(file_id, times); } if (num_nodal_vars) { if (num_times == 0) { std::cout << "EXODIFF Consistency error--The database contains " << num_nodal_vars << " nodal variables, but there are no time steps defined." << '\n'; } if (num_times) { results = new double *[num_nodal_vars]; for (int i = 0; i < num_nodal_vars; ++i) results[i] = nullptr; } } } // End of EXODIFF
bool Excn::ExodusFile::initialize(const SystemInterface& si, int start_part, int part_count) { processorCount_ = si.processor_count(); // Total number processors partCount_ = part_count; // Total parts we are processing startPart_ = start_part; // Which one to start with SMART_ASSERT(partCount_ + startPart_ <= processorCount_)(partCount_)(startPart_)(processorCount_); // EPU always wants entity (block, set, map) ids as 64-bit quantities... mode64bit_ = EX_IDS_INT64_API; if (si.int64()) { mode64bit_ |= EX_ALL_INT64_API; // For output... mode64bit_ |= EX_ALL_INT64_DB; } // See if we can keep files open int max_files = get_free_descriptor_count(); if (partCount_ <= max_files) { keepOpen_ = true; if (si.debug() & 1) std::cout << "Files kept open... (Max open = " << max_files << ")\n\n"; } else { keepOpen_ = false; std::cout << "Single file mode... (Max open = " << max_files << ")\n" << "Consider using the -subcycle option for faster execution...\n\n"; } fileids_.resize(processorCount_); filenames_.resize(processorCount_); std::string curdir = si.cwd(); std::string file_prefix = si.basename(); std::string exodus_suffix = si.exodus_suffix(); std::string root_dir = si.root_dir(); std::string sub_dir = si.sub_dir(); ParallelDisks disks; disks.Raid_Offset(si.raid_offset()); disks.Number_of_Raids(si.raid_count()); float version = 0.0; // create exo names for(int p = 0; p < partCount_; p++) { std::string name = file_prefix; if (!exodus_suffix.empty()) { name += "." + exodus_suffix; } int proc = p + startPart_; disks.rename_file_for_mp(root_dir, sub_dir, name, proc, processorCount_); filenames_[p] = name; if (p == 0) { int cpu_word_size = sizeof(float); int io_word_size_var = 0; int mode = EX_READ; mode |= mode64bit_; int exoid = ex_open(filenames_[p].c_str(), mode, &cpu_word_size, &io_word_size_var, &version); if (exoid < 0) { std::cerr << "Cannot open file '" << filenames_[p] << "'" << std::endl; return false; } int int64db = ex_int64_status(exoid) & EX_ALL_INT64_DB; if (int64db) { // If anything stored on input db as 64-bit int, then output db will have // everything stored as 64-bit ints and all API functions will use 64-bit mode64bit_ |= EX_ALL_INT64_API; mode64bit_ |= EX_ALL_INT64_DB; } int max_name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_USED_NAME_LENGTH); if (max_name_length > maximumNameLength_) maximumNameLength_ = max_name_length; ex_close(exoid); if (io_word_size_var < (int)sizeof(float)) io_word_size_var = sizeof(float); ioWordSize_ = io_word_size_var; cpuWordSize_ = io_word_size_var; } if (keepOpen_ || p == 0) { int io_word_size_var = 0; int mode = EX_READ; // All entity ids (block, sets) are read/written as 64-bit... mode |= mode64bit_; fileids_[p] = ex_open(filenames_[p].c_str(), mode, &cpuWordSize_, &io_word_size_var, &version); if (fileids_[p] < 0) { std::cerr << "Cannot open file '" << filenames_[p] << "'" << std::endl; return false; } ex_set_max_name_length(fileids_[p], maximumNameLength_); SMART_ASSERT(ioWordSize_ == io_word_size_var)(ioWordSize_)(io_word_size_var); } if (si.debug()&64 || p==0 || p==partCount_-1) { std::cout << "Input(" << p << "): '" << name.c_str() << "'" << std::endl; if (!(si.debug()&64) && p==0) std::cout << "..." << std::endl; } } if (mode64bit_ & EX_ALL_INT64_DB) { std::cout << "Input files contain 8-byte integers.\n"; si.set_int64(); } return true; }
/* // Read and EXODUSII database and return a TECPLOT file */ void tec(int exoid, const char *filename) { int i, j, k, idum; int ndim, nnode, nelem, nblk, nnset, neset, nvar, ntime, itime; char title[MAX_LINE_LENGTH + 1]; char * nameco[3], **varnames = NULL; double *x[3], **q = NULL, *time; int * elem_id = NULL, *node_per_elem = NULL, *elem_per_blk = NULL, *attr_per_blk = NULL; int ** icon = NULL, *ic = NULL, izone; char ** elem_type = NULL; int name_size = 0; FILE * tecfile = NULL; void teczone(int, int, int, char *, int, int, int *, int, double **, int, double **, FILE *); /* * FIRST, READ THE EXODUS DATA BASE */ /* * Open the output file, if we can */ tecfile = fopen(filename, "w"); if (tecfile == NULL) { printf("\nCannot open file %s for writing\n\n", filename); exit(1); } /* * Determine max name size used in databsae... */ name_size = ex_inquire_int(exoid, EX_INQ_DB_MAX_USED_NAME_LENGTH); ex_set_max_name_length(exoid, name_size); /* * Read database size, get coordinates and connectivity */ memset(title, 0, MAX_LINE_LENGTH + 1); ex_get_init(exoid, title, &ndim, &nnode, &nelem, &nblk, &nnset, &neset); x[0] = x[1] = x[2] = NULL; for (i = 0; i < ndim; i++) { nameco[i] = (char *)malloc((name_size + 1) * sizeof(char)); x[i] = (double *)malloc(nnode * sizeof(double)); } ex_get_coord_names(exoid, nameco); if (strlen(nameco[0]) == 0) strcpy(nameco[0], "X"); if (strlen(nameco[1]) == 0) strcpy(nameco[1], "Y"); if (ndim > 2) if (strlen(nameco[2]) == 0) strcpy(nameco[2], "Z"); ex_get_coord(exoid, x[0], x[1], x[2]); elem_id = (int *)malloc(nblk * sizeof(int)); node_per_elem = (int *)malloc(nblk * sizeof(int)); elem_per_blk = (int *)malloc(nblk * sizeof(int)); attr_per_blk = (int *)malloc(nblk * sizeof(int)); elem_type = (char **)malloc(nblk * sizeof(char *)); icon = (int **)malloc(nblk * sizeof(int *)); for (i = 0; i < nblk; i++) elem_type[i] = (char *)malloc((name_size + 1) * sizeof(char)); ex_get_elem_blk_ids(exoid, elem_id); for (i = 0; i < nblk; i++) { ex_get_elem_block(exoid, elem_id[i], elem_type[i], &elem_per_blk[i], &node_per_elem[i], &attr_per_blk[i]); icon[i] = (int *)malloc(elem_per_blk[i] * node_per_elem[i] * sizeof(int)); ex_get_elem_conn(exoid, elem_id[i], icon[i]); } /* * Read time step information */ ntime = ex_inquire_int(exoid, EX_INQ_TIME); if (ntime > 0) { time = (double *)malloc(ntime * sizeof(double)); ex_get_all_times(exoid, time); } /* * Read number of nodal variables and save space */ nvar = 0; ex_get_var_param(exoid, "n", &nvar); if (nvar > 0) { varnames = (char **)malloc(nvar * sizeof(char *)); q = (double **)malloc(nvar * sizeof(double *)); for (i = 0; i < nvar; i++) { varnames[i] = (char *)malloc((name_size + 1) * sizeof(char)); q[i] = (double *)malloc(nnode * sizeof(double)); } ex_get_var_names(exoid, "n", nvar, varnames); } /* ///////////////////////////////////////////////////////////////////// // PROMPT USER FOR INFO AND WRITE TECPLOT FILE ///////////////////////////////////////////////////////////////////// */ /* * Write the TECPLOT header information */ assert(strlen(title) < (MAX_LINE_LENGTH + 1)); fprintf(tecfile, "TITLE = \"%s\"\n", title); fprintf(tecfile, "VARIABLES = "); for (i = 0; i < ndim; i++) { fprintf(tecfile, "\"%s\"", nameco[i]); if (i < (ndim - 1)) fprintf(tecfile, ", "); } if (nvar == 0) fprintf(tecfile, "\n"); else fprintf(tecfile, ",\n "); idum = 0; for (i = 0; i < nvar; i++) { idum += strlen(varnames[i]); assert(idum < 1022); fprintf(tecfile, "\"%s\"", varnames[i]); if (i < (nvar - 1)) { if ((i + 1) % 4 == 0) { idum = 0; fprintf(tecfile, ",\n "); } else fprintf(tecfile, ", "); } } fprintf(tecfile, "\n"); /* * Select a time step */ izone = 0; if (ntime == 0) { printf("\nNo solution variables available, saving mesh only\n\n"); izone = 1; } else { printf("\nTime step information:\n\n"); for (i = 0; i < ntime; i++) printf(" Time step %5d, time = %e\n", i + 1, time[i]); do { printf("\nSelect time step number to save,\n"); printf(" or 0 for zone animation of all time steps: "); scanf("%d", &itime); printf("\n"); } while (itime < 0 || itime > ntime); printf("\n"); if (itime == 0) izone = 0; else izone = 1; } /* * Write time steps */ if (izone == 0) { /* * Collapse the zones into one */ /* * Make sure we are using all the same element types * Create one master connectivity array */ for (i = 1; i < nblk; i++) if (strcmp(elem_type[0], elem_type[i]) != 0) { printf("\nCannot create zone animation because\n"); ; printf("\n there are multiple element types."); exit(1); } ic = (int *)malloc(nelem * node_per_elem[0] * sizeof(int)); k = 0; for (j = 0; j < nblk; j++) for (i = 0; i < node_per_elem[j] * elem_per_blk[j]; i++) ic[k++] = icon[j][i]; assert(k == nelem * node_per_elem[0]); if (itime == 0) { for (j = 0; j < ntime; j++) { for (i = 0; i < nvar; i++) ex_get_nodal_var(exoid, j + 1, i + 1, nnode, q[i]); i = 0; teczone(1, nnode, j + 1, elem_type[i], node_per_elem[i], nelem, ic, ndim, x, nvar, q, tecfile); } printf("\n"); } free(ic); } else if (izone == 1) { /* || Write out each zone individually */ for (i = 0; i < nvar; i++) ex_get_nodal_var(exoid, itime, i + 1, nnode, q[i]); for (i = 0; i < nblk; i++) teczone(nblk, nnode, elem_id[i], elem_type[i], node_per_elem[i], elem_per_blk[i], icon[i], ndim, x, nvar, q, tecfile); printf("\n"); } /* ///////////////////////////////////////////////////////////////////// // CLEAN UP ///////////////////////////////////////////////////////////////////// */ fclose(tecfile); /* * Free up allocated memory */ for (i = 0; i < ndim; i++) { free(nameco[i]); free(x[i]); } free(elem_id); free(node_per_elem); free(elem_per_blk); free(attr_per_blk); if (elem_type != NULL) { for (i = 0; i < nblk; i++) { free(elem_type[i]); } free(elem_type); } if (icon != NULL) { for (i = 0; i < nblk; i++) { free(icon[i]); } free(icon); } if (nvar > 0) { if (varnames != NULL) { for (i = 0; i < nvar; i++) { free(varnames[i]); } free(varnames); } if (q != NULL) { for (i = 0; i < nvar; i++) { free(q[i]); } free(q); } } }
bool Excn::ExodusFile::initialize(const SystemInterface& si) { // See if we can keep files open size_t max_files = get_free_descriptor_count(); if (si.inputFiles_.size() <= max_files) { keepOpen_ = true; if (si.debug() & 1) std::cout << "Files kept open... (Max open = " << max_files << ")\n\n"; } else { keepOpen_ = false; std::cout << "Single file mode... (Max open = " << max_files << ")\n" << "Consider using the -subcycle option for faster execution...\n\n"; } float version = 0.0; // create exo names filenames_.resize(si.inputFiles_.size()); fileids_.resize(si.inputFiles_.size()); int int_byte_size_api = 4; if (si.ints_64_bit()) int_byte_size_api = 8; int overall_max_name_length = 0; for(size_t p = 0; p < si.inputFiles_.size(); p++) { std::string name = si.inputFiles_[p]; filenames_[p] = name; if (p == 0) { int cpu_word_size = sizeof(float); int io_wrd_size = 0; int exoid = ex_open(filenames_[p].c_str(), EX_READ, &cpu_word_size, &io_wrd_size, &version); if (exoid < 0) { std::cerr << "Cannot open file '" << filenames_[p] << "'" << std::endl; return false; } int max_name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_USED_NAME_LENGTH); if (max_name_length > overall_max_name_length) overall_max_name_length = max_name_length; ex_close(exoid); if (io_wrd_size < (int)sizeof(float)) io_wrd_size = sizeof(float); ioWordSize_ = io_wrd_size; cpuWordSize_ = io_wrd_size; if (ex_int64_status(exoid & EX_ALL_INT64_DB) || si.ints_64_bit()) { exodusMode_ = EX_ALL_INT64_API; } } if (keepOpen_ || p == 0) { int io_wrd_size = 0; int mode = EX_READ | exodusMode_; fileids_[p] = ex_open(filenames_[p].c_str(), mode, &cpuWordSize_, &io_wrd_size, &version); if (fileids_[p] < 0) { std::cerr << "Cannot open file '" << filenames_[p] << "'" << std::endl; return false; } SMART_ASSERT(ioWordSize_ == io_wrd_size)(ioWordSize_)(io_wrd_size); } std::cout << "Part " << p+1 << ": '" << name.c_str() << "'" << std::endl; } maximumNameLength_ = overall_max_name_length; for(size_t p = 0; p < si.inputFiles_.size(); p++) { ex_set_max_name_length(fileids_[p], maximumNameLength_); } return true; }