int main (int argc, char **argv) { int exoid, exoid1, error, idum; int CPU_word_size,IO_word_size; float version; char *cdum = 0; ex_opts(EX_VERBOSE | EX_ABORT); /* open EXODUS II files */ CPU_word_size = 0; /* sizeof(float) */ IO_word_size = 0; /* use size in file */ 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); CPU_word_size = 8; /* this really shouldn't matter for the copy but tests the conversion routines */ IO_word_size = 4; exoid1 = ex_create ("testcp.exo", /* filename */ EX_CLOBBER|EX_NORMAL_MODEL, /* OK to overwrite, normal */ &CPU_word_size, /* CPU float word size in bytes */ &IO_word_size); /* I/O float word size in bytes */ printf ("\nafter ex_create, exoid = %3d\n",exoid1); if (exoid1 < 0) exit(1); printf (" CPU word size %1d\n",CPU_word_size); printf (" I/O word size %1d\n",IO_word_size); /* ncopts = NC_VERBOSE; */ error = ex_copy (exoid, exoid1); printf ("\nafter ex_copy, error = %3d\n", error); error = ex_close (exoid); printf ("\nafter ex_close, error = %3d\n", error); error = ex_close (exoid1); printf ("\nafter ex_close, error = %3d\n", error); return 0; }
int ex_inquire_int (int exoid, int req_info) { char *cdummy = NULL; /* Needed just for function call, unused. */ float fdummy = 0; /* Needed just for function call, unused. */ int ret_val = 0; int error = ex_inquire(exoid, req_info, &ret_val, &fdummy, cdummy); if (error < 0) ret_val = error; return ret_val; }
void update_internal_structs( int out_exoid, int inqcode, struct list_item** ctr_list ) { int i; int number; double fdum; char* cdum = 0; ex_inquire (out_exoid, inqcode, &number, &fdum, cdum); if (number > 0) { for (i=0; i<number; i++) ex_inc_file_item (out_exoid, ctr_list); } }
void set_init_Element_Storage(ELEM_BLK_STRUCT *eb_ptr, int mn) /***************************************************************** * * set_init_Element_Storage() * * * like its predecessor init_element_storage, this function actually * places initial values for the draining and wetting curves for the * TANH_HYST function, according to the request in the material property * database cards for the current material * *****************************************************************/ { int ielem_type, ip_total, i, j, ifound, ip; double sat_switch = 0.0, pc_switch = 0.0, Draining_curve, *ev_tmp; int error, num_dim, num_nodes; int num_elem, num_elem_blk, num_node_sets, num_side_sets, time_step; float version; /* version number of EXODUS II */ int exoid; /* ID of the open EXODUS II file */ char title[MAX_LINE_LENGTH]; /* title of the EXODUS II database */ float ret_float; /* any returned float */ char ret_char[3]; /* any returned character */ int num_vars; /* number of var_type variables */ char **var_names = NULL; /* array containing num_vars variable names */ char appended_name[MAX_VAR_NAME_LNGTH]; /*Quick return if model is not hysteretic in nature */ if(mp_glob[mn]->SaturationModel == TANH_HYST) { ielem_type = eb_ptr->Elem_Type; ip_total = eb_ptr->IP_total; Draining_curve = mp_glob[mn]->u_saturation[8]; if (Guess_Flag ==4 || Guess_Flag == 5) { EH(-1,"Not a smooth restart for hysteretic saturation function. If you really want to do this use read_exoII_file or call us"); } if(Guess_Flag == 5 || Guess_Flag == 6) { WH(-1,"Initializing Hysteretic Curve values at all Gauss points with read_exoII_file"); CPU_word_size = sizeof(double); IO_word_size = 0; exoid = ex_open(ExoAuxFile, EX_READ, &CPU_word_size, &IO_word_size , &version); EH(exoid, "ex_open"); error = ex_get_init(exoid, title, &num_dim, &num_nodes, &num_elem, &num_elem_blk, &num_node_sets, &num_side_sets); EH(error, "ex_get_init for efv or init guess"); /* * Obtain the number of time steps in the exodus file, time_step, * We will read only from the last time step */ error = ex_inquire(exoid, EX_INQ_TIME, &time_step, &ret_float, ret_char); EH(error, "ex_inquire"); /* Based on problem type and available info in database, extract * appropriate fields */ /* * Get the number of nodal variables in the file, and allocate * space for storage of their names. */ error = ex_get_var_param(exoid, "e", &num_vars); EH(error, "ex_get_var_param"); /* First extract all nodal variable names in exoII database */ if (num_vars > 0) { var_names = alloc_VecFixedStrings(num_vars, (MAX_STR_LENGTH+1)); error = ex_get_var_names(exoid, "e", num_vars, var_names); EH(error, "ex_get_var_names"); for (i = 0; i < num_vars; i++) strip(var_names[i]); } else { fprintf(stderr, "Warning: no element variables for saturation stored in exoII input file.\n"); } /*****THIS IS WHERE YOU LOAD THEM UP ******/ ev_tmp = (double *) smalloc(eb_ptr->Num_Elems_In_Block* sizeof(double)); ifound = 0; for(ip = 0; ip < ip_total; ip++) { sprintf(appended_name, "sat_curve_type%d", ip ); for(j=0; j < num_vars; j++) { if(!strcasecmp(appended_name,var_names[j])) { /*Found variable so load it into element storage */ error = ex_get_elem_var(exoid, time_step, j+1, eb_ptr->Elem_Blk_Id, eb_ptr->Num_Elems_In_Block, ev_tmp); ifound = 1; } } if(ifound) { for (i = 0; i < eb_ptr->Num_Elems_In_Block; i++) { eb_ptr->ElemStorage[i].sat_curve_type[ip] = ev_tmp[i]; } } else { EH(-1,"Cannot find an element variable for sat. hysteresis"); } ifound = 0; sprintf(appended_name, "sat_switch%d", ip ); for(j=0; j < num_vars; j++) { if(!strcasecmp(appended_name,var_names[j])) { /*Found variable so load it into element storage */ error = ex_get_elem_var(exoid, time_step, j+1, eb_ptr->Elem_Blk_Id, eb_ptr->Num_Elems_In_Block, ev_tmp); ifound = 1; } } if(ifound) { for (i = 0; i < eb_ptr->Num_Elems_In_Block; i++) { eb_ptr->ElemStorage[i].Sat_QP_tn[ip] = ev_tmp[i]; } } else { EH(-1,"Cannot find an element variable for sat. hysteresis"); } ifound = 0; sprintf(appended_name, "pc_switch%d", ip ); for(j=0; j < num_vars; j++) { if(!strcasecmp(appended_name,var_names[j])) { /*Found variable so load it into element storage */ error = ex_get_elem_var(exoid, time_step, j+1, eb_ptr->Elem_Blk_Id, eb_ptr->Num_Elems_In_Block, ev_tmp); ifound = 1; } } if(ifound) { for (i = 0; i < eb_ptr->Num_Elems_In_Block; i++) { eb_ptr->ElemStorage[i].p_cap_QP[ip] = ev_tmp[i]; } } else { EH(-1,"Cannot find an element variable for sat. hysteresis"); } } error = ex_close(exoid); safer_free((void **) &var_names); free(ev_tmp); } else /*Initialize as dictated by input cards */ { if(Draining_curve == 1.0) { sat_switch = mp->u_saturation[0]; pc_switch = 1.e-12; } else if (Draining_curve == 0.0) { double sat_max = mp->u_saturation[0]; double sat_min = mp->u_saturation[4]; double alpha_w = mp->u_saturation[3]; double beta_w = mp->u_saturation[2]; pc_switch = 1.e12*alpha_w; sat_switch = sat_max - ( sat_max - sat_min)*0.5*(1.0+tanh( beta_w - alpha_w/pc_switch ) ) ; } else { EH(-1,"TANH_HYST must have 1.0 or 0.0 in 9th spot"); } for (i = 0; i < eb_ptr->Num_Elems_In_Block; i++) { for(ip = 0; ip < ip_total; ip++) { eb_ptr->ElemStorage[i].p_cap_QP[ip] = pc_switch; eb_ptr->ElemStorage[i].Sat_QP_tn[ip] = sat_switch; eb_ptr->ElemStorage[i].sat_curve_type[ip] = Draining_curve; } } } } if(elc_glob[mn]->thermal_expansion_model == SHRINKAGE) { ip_total = eb_ptr->IP_total; if (Guess_Flag ==4 || Guess_Flag == 5) { EH(-1,"Not a smooth restart for solidification shrinkage model.Use read_exoII_file or call us"); } if(Guess_Flag == 5 || Guess_Flag == 6) { EH(-1,"Initializing solidified shrinkage model from exoII file not available yet. Use zero"); } // Load em up as all unsolidified for(ip = 0; ip < ip_total; ip++) { for (i = 0; i < eb_ptr->Num_Elems_In_Block; i++) { eb_ptr->ElemStorage[i].solidified[ip] = 0.0; } } } }
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; }
int ex_get_nodal_var_time (int exoid, int nodal_var_index, int node_number, int beg_time_step, int end_time_step, void *nodal_var_vals) { int status; int varid; size_t start[3], count[3]; float fdum; char *cdum = 0; char errmsg[MAX_ERR_LENGTH]; /* inquire previously defined variable */ if (end_time_step < 0) { /* user is requesting the maximum time step; we find this out using the * database inquire function to get the number of time steps; the ending * time step number is 1 less due to 0 based array indexing in C */ if ((status = ex_inquire (exoid, EX_INQ_TIME, &end_time_step, &fdum, cdum)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get number of time steps in file id %d", exoid); ex_err("ex_get_nodal_var_time",errmsg,exerrval); return (EX_FATAL); } } end_time_step--; if (ex_large_model(exoid) == 0) { /* read values of the nodal variable; * assume node number is 1-based (first node is numbered 1); adjust * so it is 0-based */ if ((status = nc_inq_varid(exoid, VAR_NOD_VAR, &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Warning: could not find nodal variable %d in file id %d", nodal_var_index, exoid); ex_err("ex_get_nodal_var",errmsg,exerrval); return (EX_WARN); } start[0] = --beg_time_step; start[1] = --nodal_var_index; start[2] = --node_number; count[0] = end_time_step - beg_time_step + 1; count[1] = 1; count[2] = 1; } else { if ((status = nc_inq_varid(exoid, VAR_NOD_VAR_NEW(nodal_var_index), &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Warning: could not find nodal variable %d in file id %d", nodal_var_index, exoid); ex_err("ex_get_nodal_var",errmsg,exerrval); return (EX_WARN); } /* read values of the nodal variable; * assume node number is 1-based (first node is numbered 1); adjust * so it is 0-based */ start[0] = --beg_time_step; start[1] = --node_number; count[0] = end_time_step - beg_time_step + 1; count[1] = 1; } if (ex_comp_ws(exoid) == 4) { status = nc_get_vara_float(exoid, varid, start, count, nodal_var_vals); } else { status = nc_get_vara_double(exoid, varid, start, count, nodal_var_vals); } if (status != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get nodal variables in file id %d", exoid); ex_err("ex_get_nodal_var_time",errmsg,exerrval); return (EX_FATAL); } return (EX_NOERR); }
int ex_put_concat_sets (int exoid, ex_entity_type set_type, const struct ex_set_specs* set_specs) { int status; int temp; const int *set_ids = set_specs->sets_ids; const int *num_entries_per_set = set_specs->num_entries_per_set; const int *num_dist_per_set = set_specs->num_dist_per_set; const int *sets_entry_index = set_specs->sets_entry_index; const int *sets_dist_index = set_specs->sets_dist_index; const int *sets_entry_list = set_specs->sets_entry_list; const int *sets_extra_list = set_specs->sets_extra_list; const void *sets_dist_fact = set_specs->sets_dist_fact; char *cdum; int i, num_sets, cur_num_sets, dimid, varid, set_id_ndx, dims[1], *set_stat; float fdum; const float *flt_dist_fact; const double *dbl_dist_fact; char errmsg[MAX_ERR_LENGTH]; char* idsptr; char* statptr; char* numdfptr = NULL; char* factptr = NULL; char* elemptr = NULL; char* extraptr = NULL; ex_inquiry ex_inq_val; const 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) { ex_inq_val = EX_INQ_NODE_SETS; idsptr = VAR_NS_IDS; statptr = VAR_NS_STAT; } else if (set_type == EX_EDGE_SET) { ex_inq_val = EX_INQ_EDGE_SETS; idsptr = VAR_ES_IDS; statptr = VAR_ES_STAT; } else if (set_type == EX_FACE_SET) { ex_inq_val = EX_INQ_FACE_SETS; idsptr = VAR_FS_IDS; statptr = VAR_FS_STAT; } else if (set_type == EX_SIDE_SET) { ex_inq_val = EX_INQ_SIDE_SETS; idsptr = VAR_SS_IDS; statptr = VAR_SS_STAT; } else if (set_type == EX_ELEM_SET) { ex_inq_val = EX_INQ_ELEM_SETS; idsptr = VAR_ELS_IDS; statptr = VAR_ELS_STAT; } 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), &temp)) != NC_NOERR) { if (status == NC_EBADDIM) { exerrval = status; sprintf(errmsg, "Error: no %ss defined for file id %d", ex_name_of_object(set_type), exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } else { exerrval = status; sprintf(errmsg, "Error: failed to locate %ss defined in file id %d", ex_name_of_object(set_type), exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } return (EX_FATAL); } /* inquire how many sets are to be stored */ if (ex_inquire(exoid, ex_inq_val, &num_sets, &fdum, cdum) != NC_NOERR) { 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_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } /* Fill out set status array */ /* First, allocate space for the status list */ if (!(set_stat= malloc(num_sets*sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for %s status array in file id %d", ex_name_of_object(set_type), exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } for (i=0;i<num_sets;i++) { if (num_entries_per_set[i] == 0) /* Is this a NULL set? */ set_stat[i] = 0; /* change set status to NULL */ else set_stat[i] = 1; /* change set status to TRUE */ } /* Next, get variable id of status array */ if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate %s status in file id %d", ex_name_of_object(set_type), exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } status = nc_put_var_int(exoid, varid, set_stat); if (status != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to store %s status array to file id %d", ex_name_of_object(set_type), exoid); ex_err("ex_put_concat_set",errmsg,exerrval); return (EX_FATAL); } free(set_stat); /* put netcdf file into define mode */ if ((status = nc_redef (exoid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } /* create set definitions */ for (i=0; i<num_sets; i++) { /* Keep track of the total number of sets defined using a counter stored in a linked list keyed by exoid. NOTE: ex_get_file_item is used to find the number of sets of type for a specific file and returns that value. */ cur_num_sets=ex_get_file_item(exoid, ex_get_counter_list(set_type)); if (cur_num_sets >= num_sets) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of %ss (%d) defined in file id %d", ex_name_of_object(set_type), num_sets,exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); goto error_ret; } /* NOTE: ex_inc_file_item is used to find the number of sets for a specific file and returns that value incremented. */ cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(set_type)); set_id_ndx = cur_num_sets + 1; /* setup more pointers based on set_type */ if (set_type == EX_NODE_SET) { elemptr = VAR_NODE_NS(set_id_ndx); extraptr = NULL; /* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */ numdfptr = DIM_NUM_NOD_NS(set_id_ndx); factptr = VAR_FACT_NS(set_id_ndx); } else if (set_type == EX_EDGE_SET) { elemptr = VAR_EDGE_ES(set_id_ndx); extraptr = VAR_ORNT_ES(set_id_ndx); numdfptr = DIM_NUM_DF_ES(set_id_ndx); factptr = VAR_FACT_ES(set_id_ndx); } else if (set_type == EX_FACE_SET) { elemptr = VAR_FACE_FS(set_id_ndx); extraptr = VAR_ORNT_FS(set_id_ndx); numdfptr = DIM_NUM_DF_FS(set_id_ndx); factptr = VAR_FACT_FS(set_id_ndx); } else if (set_type == EX_SIDE_SET) { elemptr = VAR_ELEM_SS(set_id_ndx); extraptr = VAR_SIDE_SS(set_id_ndx); numdfptr = DIM_NUM_DF_SS(set_id_ndx); factptr = VAR_FACT_SS(set_id_ndx); } if (set_type == EX_ELEM_SET) { elemptr = VAR_ELEM_ELS(set_id_ndx); extraptr = NULL; numdfptr = DIM_NUM_DF_ELS(set_id_ndx); factptr = VAR_FACT_ELS(set_id_ndx); } /* define dimension for number of entries per set */ if (num_entries_per_set[i] == 0) /* Is this a NULL set? */ continue; /* Do not create anything for NULL sets! */ if ((status = nc_def_dim(exoid, ex_dim_num_entries_in_object(set_type, set_id_ndx), num_entries_per_set[i], &dimid)) != NC_NOERR) { if (status == NC_ENAMEINUSE) { exerrval = status; sprintf(errmsg, "Error: %s entry count %d already defined in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } else { exerrval = status; sprintf(errmsg, "Error: failed to define number of entries for %s %d in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } goto error_ret; } /* create element list variable for set */ dims[0] = dimid; if ((status = nc_def_var(exoid,elemptr,NC_INT,1,dims, &temp)) != NC_NOERR) { if (status == NC_ENAMEINUSE) { exerrval = status; sprintf(errmsg, "Error: element list already exists for %s %d in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } else { exerrval = status; sprintf(errmsg, "Error: failed to create element list for %s %d in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } /* create extra list variable for set (only for edge, face and side sets) */ if (extraptr) { if ((status = nc_def_var(exoid,extraptr,NC_INT,1,dims, &temp)) != NC_NOERR) { if (status == NC_ENAMEINUSE) { exerrval = status; sprintf(errmsg, "Error: extra list already exists for %s %d in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } else { exerrval = status; sprintf(errmsg, "Error: failed to create extra list for %s %d in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } } /* define dimension for number of dist factors per set */ /* NOTE: only define df count if the dist factors exist! */ if (num_dist_per_set[i] > 0) { if (set_type == EX_NODE_SET) { if (num_dist_per_set[i] != num_entries_per_set[i]) { exerrval = EX_FATAL; sprintf(errmsg, "Error: # dist fact (%d) not equal to # nodes (%d) in node set %d file id %d", num_dist_per_set[i], num_entries_per_set[i], set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); goto error_ret; /* exit define mode and return */ } /* resuse dimid from entry lists */ } else { if ((status = nc_def_dim(exoid, numdfptr, num_dist_per_set[i], &dimid)) != NC_NOERR) { if (status == NC_ENAMEINUSE) { exerrval = status; sprintf(errmsg, "Error: %s df count %d already defined in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } else { exerrval = status; sprintf(errmsg, "Error: failed to define %s df count for set %d in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } goto error_ret; } } /* create distribution factor list variable for set */ dims[0] = dimid; if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &temp)) != NC_NOERR) { if (status == NC_ENAMEINUSE) { exerrval = status; sprintf(errmsg, "Error: dist factor list already exists for %s %d in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } else { exerrval = status; sprintf(errmsg, "Error: failed to create dist factor list for %s %d in file id %d", ex_name_of_object(set_type), set_ids[i],exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } } /* end define dist factors */ } /* leave define mode */ if ((status = nc_enddef (exoid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to complete definition in file id %d", exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } /* Next, fill out set ids array */ /* first get id of set ids array variable */ if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate %s ids array in file id %d", ex_name_of_object(set_type), exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } /* then, write out set id list */ status = nc_put_var_int(exoid, varid, set_ids); if (status != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to store %s id array in file id %d", ex_name_of_object(set_type), exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } /* If the sets_entry_index is passed in as a NULL pointer, then * the user only wants us to define the sets and not populate * the data structures. */ if (sets_entry_index == 0) return(EX_NOERR); /* Now, use ExodusII call to store sets */ for (i=0; i<num_sets; i++) { if (num_entries_per_set[i] == 0) /* Is this a NULL set? */ continue; /* Do not create anything for NULL sets! */ /* set extra list */ 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_put_set(exoid, set_type, set_ids[i], &(sets_entry_list[sets_entry_index[i]]), extra_list) == -1) return(EX_FATAL); /* error will be reported by subroutine */ if (ex_comp_ws(exoid) == sizeof(float)) { flt_dist_fact = sets_dist_fact; if (num_dist_per_set[i] > 0) { /* store dist factors if required */ if (ex_put_set_dist_fact(exoid, set_type, set_ids[i], &(flt_dist_fact[sets_dist_index[i]])) == -1) { sprintf(errmsg, "Error: failed to store %s %d dist factors for file id %d", ex_name_of_object(set_type), set_ids[i],exoid); /* use error val from exodusII routine */ ex_err("ex_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } } } else if (ex_comp_ws(exoid) == sizeof(double)) { dbl_dist_fact = sets_dist_fact; if (num_dist_per_set[i] > 0) { /* only store if they exist */ if (ex_put_set_dist_fact(exoid, set_type, set_ids[i], &(dbl_dist_fact[sets_dist_index[i]])) == -1) { sprintf(errmsg, "Error: failed to store %s %d dist factors for file id %d", ex_name_of_object(set_type), set_ids[i],exoid); /* use error val from exodusII routine */ ex_err("ex_put_concat_sets",errmsg,exerrval); return (EX_FATAL); } } } else { /* unknown floating point word size */ exerrval = EX_BADPARAM; sprintf(errmsg, "Error: unsupported floating point word size %d for file id %d", ex_comp_ws(exoid), exoid); ex_err("ex_put_concat_sets", errmsg, exerrval); return (EX_FATAL); } } return(EX_NOERR); /* Fatal error: exit definition mode and return */ error_ret: if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */ { sprintf(errmsg, "Error: failed to complete definition for file id %d", exoid); ex_err("ex_put_concat_sets",errmsg,exerrval); } return (EX_FATAL); }
int ex_get_nodal_var_time (int exoid, int nodal_var_index, int node_number, int beg_time_step, int end_time_step, void *nodal_var_vals) { int varid; long start[3], count[3]; float fdum; char *cdum; char errmsg[MAX_ERR_LENGTH]; /* inquire previously defined variable */ cdum = 0; /* initialize even though it is not used */ if (end_time_step < 0) { /* user is requesting the maximum time step; we find this out using the * database inquire function to get the number of time steps; the ending * time step number is 1 less due to 0 based array indexing in C */ if (ex_inquire (exoid, EX_INQ_TIME, &end_time_step, &fdum, cdum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of time steps in file id %d", exoid); ex_err("ex_get_nodal_var_time",errmsg,exerrval); return (EX_FATAL); } } end_time_step--; if (ex_large_model(exoid) == 0) { /* read values of the nodal variable; * assume node number is 1-based (first node is numbered 1); adjust * so it is 0-based */ if ((varid = ncvarid (exoid, VAR_NOD_VAR)) == -1) { exerrval = ncerr; sprintf(errmsg, "Warning: could not find nodal variable %d in file id %d", nodal_var_index, exoid); ex_err("ex_get_nodal_var",errmsg,exerrval); return (EX_WARN); } start[0] = --beg_time_step; start[1] = --nodal_var_index; start[2] = --node_number; count[0] = end_time_step - beg_time_step + 1; count[1] = 1; count[2] = 1; } else { if ((varid = ncvarid (exoid, VAR_NOD_VAR_NEW(nodal_var_index))) == -1) { exerrval = ncerr; sprintf(errmsg, "Warning: could not find nodal variable %d in file id %d", nodal_var_index, exoid); ex_err("ex_get_nodal_var",errmsg,exerrval); return (EX_WARN); } /* read values of the nodal variable; * assume node number is 1-based (first node is numbered 1); adjust * so it is 0-based */ start[0] = --beg_time_step; start[1] = --node_number; count[0] = end_time_step - beg_time_step + 1; count[1] = 1; } if (ncvarget (exoid, varid, start, count, ex_conv_array(exoid,RTN_ADDRESS,nodal_var_vals,count[0])) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get nodal variables in file id %d", exoid); ex_err("ex_get_nodal_var_time",errmsg,exerrval); return (EX_FATAL); } ex_conv_array( exoid, READ_CONVERT, nodal_var_vals, count[0] ); return (EX_NOERR); }
int ex_get_side_set_node_list_len(int exoid, int side_set_id, int *side_set_node_list_len) { int i, j, m; int num_side_sets, num_elem_blks, num_df, ndim; int tot_num_elem = 0, tot_num_ss_elem = 0; int *elem_blk_ids; int *ss_elem_ndx; int *side_set_elem_list, *side_set_side_list; int elem_ctr; int num_elem_in_blk, num_nodes_per_elem, num_attr; float fdum; char *cdum, elem_type[MAX_STR_LENGTH+1]; struct elem_blk_parm { char elem_type[MAX_STR_LENGTH+1]; int elem_blk_id; int num_elem_in_blk; int num_nodes_per_elem; int num_nodes_per_side; int num_attr; int elem_ctr; int elem_type_val; } *elem_blk_parms; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ *side_set_node_list_len = 0; /* default value */ /* first check if any side sets are specified */ /* inquire how many side sets have been stored */ if ((ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get number of side sets in file id %d",exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return(EX_FATAL); } if (num_side_sets == 0) { sprintf(errmsg, "Warning: no side sets defined in file id %d",exoid); ex_err("ex_get_side_set_node_list_len",errmsg,EX_WARN); return(EX_WARN); } if ((ex_inquire(exoid, EX_INQ_ELEM_BLK, &num_elem_blks, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get number of element blocks in file id %d",exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return(EX_FATAL); } if ((ex_inquire(exoid, EX_INQ_ELEM, &tot_num_elem, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get total number of elements in file id %d",exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return(EX_FATAL); } /* get the dimensionality of the coordinates; this is necessary to distinguish between 2d TRIs and 3d TRIs */ if ((ex_inquire(exoid, EX_INQ_DIM, &ndim, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get dimensionality in file id %d",exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return(EX_FATAL); } /* First determine the # of elements in the side set*/ if ((ex_get_side_set_param(exoid,side_set_id,&tot_num_ss_elem,&num_df)) == -1) { sprintf(errmsg, "Error: failed to get number of elements in side set %d in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return(EX_FATAL); } if (tot_num_ss_elem == 0) /* NULL side set? */ return (EX_NOERR); /* return zero */ /* Allocate space for the side set element list */ if (!(side_set_elem_list=static_cast<int*>(malloc(tot_num_ss_elem*sizeof(int))))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set element list for file id %d", exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the side set side list */ if (!(side_set_side_list=static_cast<int*>(malloc(tot_num_ss_elem*sizeof(int))))) { free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set side list for file id %d", exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return (EX_FATAL); } if (ex_get_side_set(exoid, side_set_id, side_set_elem_list, side_set_side_list) == -1) { free(side_set_elem_list); free(side_set_side_list); sprintf(errmsg, "Error: failed to get side set %d in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the ss element index array */ if (!(ss_elem_ndx=static_cast<int*>(malloc(tot_num_ss_elem*sizeof(int))))) { free(side_set_elem_list); free(side_set_side_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem sort array for file id %d", exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return (EX_FATAL); } /* Sort side set element list into index array - non-destructive */ for (i=0;i<tot_num_ss_elem;i++) ss_elem_ndx[i] = i; /* init index array to current position */ ex_iqsort(side_set_elem_list, ss_elem_ndx,tot_num_ss_elem); /* Allocate space for the element block ids */ if (!(elem_blk_ids=static_cast<int*>(malloc(num_elem_blks*sizeof(int))))) { exerrval = EX_MEMFAIL; free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to allocate space for element block ids for file id %d", exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return (EX_FATAL); } if (ex_get_elem_blk_ids(exoid, elem_blk_ids)) { free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to get element block ids in file id %d", exoid); ex_err("ex_get_side_set_node_list_len",errmsg,EX_MSG); return(EX_FATAL); } /* Allocate space for the element block params */ if (!(elem_blk_parms=static_cast<struct elem_blk_parm*>(malloc(num_elem_blks*sizeof(struct elem_blk_parm))))) { free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for element block params for file id %d", exoid); ex_err("ex_get_side_set_node_list_len",errmsg,exerrval); return (EX_FATAL); } elem_ctr = 0; for (i=0; i<num_elem_blks; i++) { /* read in an element block parameter */ if ((ex_get_elem_block (exoid, elem_blk_ids[i], elem_type, &num_elem_in_blk, &num_nodes_per_elem, &num_attr)) == -1) { free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to get element block %d parameters in file id %d", elem_blk_ids[i], exoid); ex_err("ex_get_side_set_node_list_len",errmsg,EX_MSG); return(EX_FATAL); } elem_blk_parms[i].num_elem_in_blk = num_elem_in_blk; elem_blk_parms[i].num_nodes_per_elem = num_nodes_per_elem; elem_blk_parms[i].num_attr = num_attr; elem_blk_parms[i].elem_blk_id = elem_blk_ids[i]; for (m=0; m < strlen(elem_type); m++) elem_blk_parms[i].elem_type[m] = toupper((int)elem_type[m]); elem_blk_parms[i].elem_type[m] = '\0'; if (strncmp(elem_blk_parms[i].elem_type,"CIRCLE",3) == 0) { elem_blk_parms[i].elem_type_val = CIRCLE; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"SPHERE",3) == 0) { elem_blk_parms[i].elem_type_val = SPHERE; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"QUAD",3) == 0) { elem_blk_parms[i].elem_type_val = QUAD; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side = 2; else if (elem_blk_parms[i].num_nodes_per_elem == 5) elem_blk_parms[i].num_nodes_per_side = 2; else elem_blk_parms[i].num_nodes_per_side = 3; } else if (strncmp(elem_blk_parms[i].elem_type,"TRIANGLE",3) == 0) { elem_blk_parms[i].elem_type_val = TRIANGLE; /* determine side set node stride */ if (ndim == 2) /* 2d TRIs */ { if (elem_blk_parms[i].num_nodes_per_elem == 3) elem_blk_parms[i].num_nodes_per_side = 2; else elem_blk_parms[i].num_nodes_per_side = 3; } else if (ndim == 3) /* 3d TRIs */ { /* set the default number of nodes per side; catch exceptions later */ if (elem_blk_parms[i].num_nodes_per_elem == 3) elem_blk_parms[i].num_nodes_per_side = 3; else elem_blk_parms[i].num_nodes_per_side = 6; } } else if (strncmp(elem_blk_parms[i].elem_type,"SHELL",3) == 0) { elem_blk_parms[i].elem_type_val = SHELL; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) /* KLUDGE for 2D Shells*/ elem_blk_parms[i].num_nodes_per_side = 2; else if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side = 4; else elem_blk_parms[i].num_nodes_per_side = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"HEX",3) == 0) { elem_blk_parms[i].elem_type_val = HEX; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 8) elem_blk_parms[i].num_nodes_per_side = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 9) elem_blk_parms[i].num_nodes_per_side = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 12) /* HEXSHELL */ elem_blk_parms[i].num_nodes_per_side = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 27) elem_blk_parms[i].num_nodes_per_side = 9; else elem_blk_parms[i].num_nodes_per_side = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"TETRA",3) == 0) { elem_blk_parms[i].elem_type_val = TETRA; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side = 3; else if (elem_blk_parms[i].num_nodes_per_elem == 8) elem_blk_parms[i].num_nodes_per_side = 4; else elem_blk_parms[i].num_nodes_per_side = 6; } else if (strncmp(elem_blk_parms[i].elem_type,"WEDGE",3) == 0) { elem_blk_parms[i].elem_type_val = WEDGE; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 6) elem_blk_parms[i].num_nodes_per_side = 4; else elem_blk_parms[i].num_nodes_per_side = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"PYRAMID",3) == 0) { elem_blk_parms[i].elem_type_val = PYRAMID; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 5) elem_blk_parms[i].num_nodes_per_side = 4; else elem_blk_parms[i].num_nodes_per_side = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"BEAM",3) == 0) { elem_blk_parms[i].elem_type_val = BEAM; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) elem_blk_parms[i].num_nodes_per_side = 2; else elem_blk_parms[i].num_nodes_per_side = 3; } else if ( (strncmp(elem_blk_parms[i].elem_type,"TRUSS",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"BAR",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"EDGE",3) == 0)) { elem_blk_parms[i].elem_type_val = TRUSS; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) elem_blk_parms[i].num_nodes_per_side = 2; else elem_blk_parms[i].num_nodes_per_side = 3; } else if (strncmp(elem_blk_parms[i].elem_type,"NULL",3) == 0) { elem_blk_parms[i].elem_type_val = '\0'; elem_blk_parms[i].num_nodes_per_side = 0; elem_blk_parms[i].num_elem_in_blk = 0; } else { /* unsupported element type; no problem if no sides specified for this element block */ elem_blk_parms[i].elem_type_val = UNK; elem_blk_parms[i].num_nodes_per_side = 0; } elem_ctr += elem_blk_parms[i].num_elem_in_blk; elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */ } /* Walk through element list and keep a running count of the node length */ *side_set_node_list_len = 0; for (i=0;i<tot_num_ss_elem;i++) { for (j=0; j<num_elem_blks; j++) { if (elem_blk_parms[j].elem_type_val != '\0') if (side_set_elem_list[i] <= elem_blk_parms[j].elem_ctr) break; /* stop because we found the parameters for this element */ } if (j >= num_elem_blks) { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid element number %d found in side set %d in file %d", side_set_elem_list[i], side_set_id, exoid); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); ex_err("ex_get_side_set_node_list_len",errmsg,EX_MSG); return (EX_FATAL); } /* Update *side_set_node_list_len (which points to next node in chain */ /* WEDGEs with 3 node sides (side 4 or 5) are special cases */ if (elem_blk_parms[j].elem_type_val == WEDGE && (side_set_side_list[i] == 4 || side_set_side_list[i] == 5)) { if (elem_blk_parms[j].num_nodes_per_elem == 6) *side_set_node_list_len += 3; /* 3 node side */ else *side_set_node_list_len += 6; /* 6 node side */ } /* PYRAMIDSs with 3 node sides (sides 1,2,3,4) are also special */ else if (elem_blk_parms[j].elem_type_val == PYRAMID && (side_set_side_list[i] < 5)) { if (elem_blk_parms[j].num_nodes_per_elem == 5) *side_set_node_list_len += 3; /* 3 node side */ else *side_set_node_list_len += 6; /* 6 node side */ } /* side numbers 3,4,5,6 for SHELLs are also special */ else if (elem_blk_parms[j].elem_type_val == SHELL && (side_set_side_list[i] > 2 )) { if (elem_blk_parms[j].num_nodes_per_elem == 4) *side_set_node_list_len += 2; /* 2 node side */ else *side_set_node_list_len += 3; /* 3 node side */ } /* sides 3, 4, and 5 of 3d TRIs are special cases */ else if (elem_blk_parms[j].elem_type_val == TRIANGLE && ndim == 3 && side_set_side_list[i] > 2 ) { if (elem_blk_parms[j].num_nodes_per_elem == 3) /* 3-node TRI */ *side_set_node_list_len += 2; /* 2 node side */ else /* 6-node TRI */ *side_set_node_list_len += 3; /* 3 node side */ } else if (elem_blk_parms[j].elem_type_val == UNK) { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: %s in elem block %d is an unsupported element type", elem_blk_parms[i].elem_type, elem_blk_parms[i].elem_blk_id); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); ex_err("ex_get_side_set_node_list_len",errmsg,EX_MSG); return (EX_FATAL); } else /* all other element types */ *side_set_node_list_len += elem_blk_parms[j].num_nodes_per_side; } /* All done: release element block ids array, element block parameters array, and side set element index array */ free(elem_blk_ids); free(elem_blk_parms); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_NOERR); }
int ex_put_concat_side_sets (int exoid, const int *side_set_ids, const int *num_elem_per_set, const int *num_dist_per_set, const int *side_sets_elem_index, const int *side_sets_dist_index, const int *side_sets_elem_list, const int *side_sets_side_list, const void *side_sets_dist_fact) { char *cdum; int i, num_side_sets, cur_num_side_sets, dimid, varid, dims[1], *ss_stat; int iresult; long start[1], count[1]; nclong *lptr; float fdum; const float *flt_dist_fact; const double *dbl_dist_fact; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ /* first check if any side sets are specified */ if (ncdimid (exoid, DIM_NUM_SS) == -1) { if (ncerr == NC_EBADDIM) { exerrval = ncerr; sprintf(errmsg, "Error: no side sets defined for file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate side sets defined in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } return (EX_FATAL); } /* inquire how many side sets are to be stored */ if (ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum) == -1) { sprintf(errmsg, "Error: failed to get number of side sets defined for file id %d", exoid); /* use error val from inquire */ ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* fill out side set status array */ /* First, allocate space for the side set status list */ if (!(ss_stat= malloc(num_side_sets*sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set status array in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } for (i=0;i<num_side_sets;i++) { if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */ ss_stat[i] = 0; /* change side set status to NULL */ else ss_stat[i] = 1; /* change side set status to TRUE */ } /* Next, get variable id of status array */ if ((varid = ncvarid (exoid, VAR_SS_STAT)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate side set status in file id %d", exoid); ex_err("ex_put_concat_node_set",errmsg,exerrval); return (EX_FATAL); } /* this contortion is necessary because netCDF is expecting nclongs; fortunately it's necessary only when ints and nclongs aren't the same size */ start[0] = 0; count[0] = num_side_sets; if (sizeof(int) == sizeof(nclong)) { iresult = ncvarput (exoid, varid, start, count, ss_stat); } else { lptr = itol (ss_stat, num_side_sets); iresult = ncvarput (exoid, varid, start, count, lptr); free(lptr); } if (iresult == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store side set status array to file id %d", exoid); ex_err("ex_put_concat_side_set",errmsg,exerrval); return (EX_FATAL); } free(ss_stat); /* put netcdf file into define mode */ if (ncredef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to put file id %d into define mode", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* create side set definitions */ for (i=0; i<num_side_sets; i++) { /* Keep track of the total number of side sets defined using a counter stored in a linked list keyed by exoid. NOTE: ex_get_file_item is used to find the number of side sets for a specific file and returns that value. */ cur_num_side_sets=ex_get_file_item(exoid, &ss_ctr_list ); if (cur_num_side_sets >= num_side_sets) { exerrval = EX_FATAL; sprintf(errmsg, "Error: exceeded number of side sets (%d) defined in file id %d", num_side_sets,exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); goto error_ret; } /* NOTE: ex_inc_file_item is used to find the number of side sets for a specific file and returns that value incremented. */ cur_num_side_sets=ex_inc_file_item(exoid, &ss_ctr_list ); /* define dimension for number of sides/elements per side set */ if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */ continue; /* Do not create anything for NULL side sets! */ if ((dimid = ncdimdef (exoid, DIM_NUM_SIDE_SS(cur_num_side_sets+1), (long)num_elem_per_set[i])) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: side set side count %d already defined in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to define number of sides for set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; } /* create element list variable for side set */ dims[0] = dimid; if (ncvardef (exoid,VAR_ELEM_SS(cur_num_side_sets+1),NC_LONG,1,dims) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: element list already exists for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create element list for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } /* create side list variable for side set */ if (ncvardef (exoid,VAR_SIDE_SS(cur_num_side_sets+1),NC_LONG,1,dims) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: side list already exists for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create side list for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } /* define dimension for number of dist factors/nodes per side set */ /* NOTE: only define df count if the dist factors exist! */ if (num_dist_per_set[i] > 0) { if ((dimid = ncdimdef (exoid, DIM_NUM_DF_SS(cur_num_side_sets+1), (long)num_dist_per_set[i])) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: side set df count %d already defined in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to define side set df count for set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; } /* create distribution factor list variable for side set */ dims[0] = dimid; if (ncvardef (exoid, VAR_FACT_SS(cur_num_side_sets+1), nc_flt_code(exoid), 1, dims) == -1) { if (ncerr == NC_ENAMEINUSE) { exerrval = ncerr; sprintf(errmsg, "Error: dist factor list already exists for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } else { exerrval = ncerr; sprintf(errmsg, "Error: failed to create dist factor list for side set %d in file id %d", side_set_ids[i],exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } goto error_ret; /* exit define mode and return */ } } /* end define dist factors */ } /* leave define mode */ if (ncendef (exoid) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to complete definition in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* Next, fill out side set ids array */ /* first get id of side set ids array variable */ if ((varid = ncvarid (exoid, VAR_SS_IDS)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate side set ids array in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* then, write out side set id list */ /* this contortion is necessary because netCDF is expecting nclongs; fortunately it's necessary only when ints and nclongs aren't the same size */ start[0] = 0; count[0] = num_side_sets; if (sizeof(int) == sizeof(nclong)) { iresult = ncvarput (exoid, varid, start, count, side_set_ids); } else { lptr = itol (side_set_ids, num_side_sets); iresult = ncvarput (exoid, varid, start, count, lptr); free(lptr); } if (iresult == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to store side set id array in file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } /* If the side_sets_elem_index is passed in as a NULL pointer, then * the user only wants us to define the sidesets and not populate * the data structures. */ if (side_sets_elem_index == 0) return(EX_NOERR); /* Now, use ExodusII call to store side sets */ for (i=0; i<num_side_sets; i++) { if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */ continue; /* Do not create anything for NULL side sets! */ if (ex_comp_ws(exoid) == sizeof(float)) { flt_dist_fact = side_sets_dist_fact; if (ex_put_side_set(exoid, side_set_ids[i], &(side_sets_elem_list[side_sets_elem_index[i]]), &(side_sets_side_list[side_sets_elem_index[i]])) == -1) return(EX_FATAL); /* error will be reported by subroutine */ if (num_dist_per_set[i] > 0) /* store dist factors if required */ { if (ex_put_side_set_dist_fact(exoid, side_set_ids[i], &(flt_dist_fact[side_sets_dist_index[i]])) == -1) { sprintf(errmsg, "Error: failed to store side set %d dist factors for file id %d", side_set_ids[i],exoid); /* use error val from exodusII routine */ ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } } } else if (ex_comp_ws(exoid) == sizeof(double)) { dbl_dist_fact = side_sets_dist_fact; if (ex_put_side_set(exoid, side_set_ids[i], &(side_sets_elem_list[side_sets_elem_index[i]]), &(side_sets_side_list[side_sets_elem_index[i]])) == -1) return(EX_FATAL); /* error will be reported by subroutine */ if (num_dist_per_set[i] > 0) /* only store if they exist */ { if (ex_put_side_set_dist_fact(exoid, side_set_ids[i], &(dbl_dist_fact[side_sets_dist_index[i]])) == -1) { sprintf(errmsg, "Error: failed to store side set %d dist factors for file id %d", side_set_ids[i],exoid); /* use error val from exodusII routine */ ex_err("ex_put_concat_side_sets",errmsg,exerrval); return (EX_FATAL); } } } else { /* unknown floating point word size */ exerrval = EX_BADPARAM; sprintf(errmsg, "Error: unsupported floating point word size %d for file id %d", ex_comp_ws(exoid), exoid); ex_err("ex_put_concat_side_sets", errmsg, exerrval); return (EX_FATAL); } } return(EX_NOERR); /* Fatal error: exit definition mode and return */ error_ret: if (ncendef (exoid) == -1) /* exit define mode */ { sprintf(errmsg, "Error: failed to complete definition for file id %d", exoid); ex_err("ex_put_concat_side_sets",errmsg,exerrval); } return (EX_FATAL); }
//---------------------------------------------------------------------------- void vtkExodusReader::ExecuteInformation() { int exoid; int error; int CPU_word_size, IO_word_size; float version; float fdum; int num_node_sets, num_side_sets; int num_node_vars, num_ele_vars; //char *coord_names[3]; int i; int num_elem_in_block; int num_nodes_per_elem; int num_attr; int *ids; char *cdum = NULL; char elem_type[MAX_STR_LENGTH+1]; CPU_word_size = 0; // float or double. IO_word_size = 0; exoid = ex_open(this->FileName, EX_READ, &CPU_word_size, &IO_word_size, &version); if (exoid < 0) { vtkErrorMacro("Problem reading information from file " << this->FileName); return; } if (this->Title == NULL) { this->Title = new char[MAX_LINE_LENGTH+1]; } error = ex_get_init(exoid, this->Title, &this->Dimensionality, &this->NumberOfNodes, &this->NumberOfElements, &this->NumberOfBlocks, &num_node_sets, &num_side_sets); if (error < 0) { vtkErrorMacro("Error: " << error << " initializing exodus file " << this->FileName); } // Read coordinate names. What will we do with these? //for (i = 0; i < num_dim; ++i) // { // coord_names[i] = new char [MAX_STR_LENGTH+1]; // } //error = ex_get_coord_names(exoid, coord_names); //for (i = 0; i < num_dim; ++i) // { // delete [] coord_names[i]; // coord_names[i] = NULL; // } // Read element block paramemters. this->NumberOfBlockElements->Reset(); this->BlockIds->Reset(); this->BlockIds->SetNumberOfValues(this->NumberOfBlocks); ids = this->BlockIds->GetPointer((int)(0)); error = ex_get_elem_blk_ids (exoid, ids); for (i = 0; i < this->NumberOfBlocks; ++i) { error = ex_get_elem_block (exoid, ids[i], elem_type, &(num_elem_in_block), &(num_nodes_per_elem), &(num_attr)); if (error < 0) { vtkErrorMacro("Error: " << error << " reading block information from file " << this->FileName); } this->NumberOfBlockElements->InsertValue(i, num_elem_in_block); } // Read the attribute array information. error = ex_get_var_param(exoid, "n", &(num_node_vars)); if (error < 0) { vtkErrorMacro("Error: " << error << " while reading number of point array from file " << this->FileName); } this->SetNumberOfPointDataArrays(num_node_vars); if (num_node_vars > 0) { error = ex_get_var_names(exoid, "n", num_node_vars, this->PointDataArrayNames); if (error < 0) { vtkErrorMacro("Error: " << error << " while reading point array names from file " << this->FileName); } this->NumberOfPointDataArrays = this->SimplifyArrayNames(this->PointDataArrayNames, this->PointDataArrayNumberOfComponents, this->NumberOfPointDataArrays); } // Cell array names error = ex_get_var_param(exoid, "e", &(num_ele_vars)); if (error < 0) { vtkErrorMacro("Error: " << error << " while reading number of element array from file " << this->FileName); } this->SetNumberOfCellDataArrays(num_ele_vars); if (num_ele_vars > 0) { // not all cell variables exist over all element blocks. A "truth table" // will say whether a variable is defined for a certain block. this->CellVarTruthTable->Resize(num_ele_vars*this->NumberOfBlocks); int *ptr = CellVarTruthTable->GetPointer(0); ex_get_elem_var_tab(exoid, this->NumberOfBlocks, num_ele_vars, ptr); error = ex_get_var_names (exoid, "e", num_ele_vars, this->CellDataArrayNames); if (error < 0) { vtkErrorMacro("Error: " << error << " while reading element array names from file " << this->FileName); } this->NumberOfCellDataArrays = this->SimplifyArrayNames(this->CellDataArrayNames, this->CellDataArrayNumberOfComponents, this->NumberOfCellDataArrays); } // Read the number of time steps available. error = ex_inquire(exoid, EX_INQ_TIME, &this->NumberOfTimeSteps, &fdum,cdum); if (error < 0) { vtkErrorMacro("Error: " << error << " while reading number of time steps from file " << this->FileName); } error = ex_close(exoid); if (error < 0) { vtkErrorMacro("Error: " << error << " closing file " << this->FileName); } if (this->StartBlock < 0) { this->StartBlock = 0; this->EndBlock = this->NumberOfBlocks - 1; } }
int ex_get_side_set_node_list(int exoid, int side_set_id, int *side_set_node_cnt_list, int *side_set_node_list) { int i, j, m; int num_side_sets, num_elem_blks, num_df, ndim; int tot_num_elem = 0, tot_num_ss_elem = 0, elem_num = 0; int connect_offset, side_num, node_pos; int *elem_blk_ids, *connect; int *ss_elem_ndx, *ss_elem_node_ndx, *ss_parm_ndx; int *side_set_elem_list, *side_set_side_list; int elem_ctr, node_ctr, elem_num_pos; int num_elem_in_blk, num_nodes_per_elem, num_attr; float fdum; char *cdum, elem_type[MAX_STR_LENGTH+1]; struct elem_blk_parm { char elem_type[MAX_STR_LENGTH+1]; int elem_blk_id; int num_elem_in_blk; int num_nodes_per_elem; int num_nodes_per_side; int num_attr; int elem_ctr; int elem_type_val; } *elem_blk_parms; /* side to node translation tables - These tables are used to look up the side number based on the first and second node in the side/face list. The side node order is found in the original Exodus document, SAND87-2997. The element node order is found in the ExodusII document, SAND92-2137. These tables were generated by following the right-hand rule for determining the outward normal. */ /* triangle */ static int tri_table[3][3] = { /* 1 2 3 side */ {1,2,4}, {2,3,5}, {3,1,6} /* nodes */ }; /* triangle 3d */ static int tri3_table[5][7] = { /* 1 2 side */ {1,2,3,4,5,6,7}, {3,2,1,6,5,4,7}, /* nodes */ /* 3 4 5 side */ {1,2,4,0,0,0,0}, {2,3,5,0,0,0,0}, {3,1,6,0,0,0,0} /* nodes */ }; /* quad */ static int quad_table[4][3] = { /* 1 2 3 4 side */ {1,2,5}, {2,3,6}, {3,4,7}, {4,1,8} /* nodes */ }; /* shell */ static int shell_table[6][8] = { /* 1 2 side */ {1,2,3,4,5,6,7,8}, {1,4,3,2,8,7,6,5} , /* nodes */ /* 3 4 side */ {1,2,5,0,0,0,0,0}, {2,3,6,0,0,0,0,0} , /* nodes */ /* 5 6 side */ {3,4,7,0,0,0,0,0}, {4,1,8,0,0,0,0,0} /* nodes */ }; /* tetra */ static int tetra_table[4][6] = { /* 1 2 3 4 side */ {1,2,4,5,9,8}, {2,3,4,6,10,9}, {1,4,3,8,10,7}, {1,3,2,7,6,5} /* nodes */ }; /* wedge */ static int wedge_table[5][8] = { /* 1 2 3 side */ {1,2,5,4,7,11,13,10}, {2,3,6,5,8,12,14,11}, {1,4,6,3,10,15,12,9}, /* 4 5 side */ {1,3,2,0,9,8,7,0}, {4,5,6,0,13,14,15,0} /* nodes */ }; /* hex */ static int hex_table[6][9] = { /* 1 2 side */ {1,2,6,5,9,14,17,13,26}, {2,3,7,6,10,15,18,14,25}, /* nodes */ /* 3 4 side */ {3,4,8,7,11,16,19,15,27}, {1,5,8,4,13,20,16,12,24}, /* nodes */ /* 5 6 side */ {1,4,3,2,12,11,10,9,22}, {5,6,7,8,17,18,19,20,23} /* nodes */ }; /* pyramid */ static int pyramid_table[5][8] = { /* 1 2 3 side */ {1,2,5,0,6,11,10,0}, {2,3,5,0,7,12,11,0}, {3,4,5,0,8,13,12,0}, /* nodes */ /* 4 5 side */ {1,5,4,0,10,13,9,0}, {1,4,3,2,9,8,7,6} /* nodes */ }; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ /* first check if any side sets are specified */ /* inquire how many side sets have been stored */ if ((ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get number of side sets in file id %d",exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } if (num_side_sets == 0) { sprintf(errmsg, "Warning: no side sets defined in file id %d",exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_WARN); return(EX_WARN); } /* Lookup index of side set id in VAR_SS_IDS array */ ex_id_lkup(exoid,VAR_SS_IDS,side_set_id); if (exerrval != 0) { if (exerrval == EX_NULLENTITY) { sprintf(errmsg, "Warning: side set %d is NULL in file id %d", side_set_id,exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_MSG); return (EX_WARN); } else { sprintf(errmsg, "Error: failed to locate side set id %d in VAR_SS_IDS array in file id %d", side_set_id,exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } } if ((ex_inquire(exoid, EX_INQ_ELEM_BLK, &num_elem_blks, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get number of element blocks in file id %d",exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } if ((ex_inquire(exoid, EX_INQ_ELEM, &tot_num_elem, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get total number of elements in file id %d",exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } /* get the dimensionality of the coordinates; this is necessary to distinguish between 2d TRIs and 3d TRIs */ if ((ex_inquire(exoid, EX_INQ_DIM, &ndim, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get dimensionality in file id %d",exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return(EX_FATAL); } /* First determine the # of elements in the side set*/ if ((ex_get_side_set_param(exoid,side_set_id,&tot_num_ss_elem,&num_df)) == -1) { sprintf(errmsg, "Error: failed to get number of elements in side set %d in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } /* Allocate space for the side set element list */ if (!(side_set_elem_list=static_cast<int*>(malloc(tot_num_ss_elem*sizeof(int))))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set element list for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the side set side list */ if (!(side_set_side_list=static_cast<int*>(malloc(tot_num_ss_elem*sizeof(int))))) { free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set side list for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } if (ex_get_side_set(exoid, side_set_id, side_set_elem_list, side_set_side_list) == -1) { free(side_set_elem_list); free(side_set_side_list); sprintf(errmsg, "Error: failed to get side set %d in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the ss element index array */ if (!(ss_elem_ndx= static_cast<int*>(malloc(tot_num_ss_elem*sizeof(int))))) { free(side_set_elem_list); free(side_set_side_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem sort array for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } /* Sort side set element list into index array - non-destructive */ for (i=0;i<tot_num_ss_elem;i++) ss_elem_ndx[i] = i; /* init index array to current position */ ex_iqsort(side_set_elem_list, ss_elem_ndx,tot_num_ss_elem); /* Allocate space for the element block ids */ if (!(elem_blk_ids= static_cast<int*>(malloc(num_elem_blks*sizeof(int))))) { exerrval = EX_MEMFAIL; free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to allocate space for element block ids for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } if (ex_get_elem_blk_ids(exoid, elem_blk_ids) == -1) { free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to get element block ids in file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_MSG); return(EX_FATAL); } /* Allocate space for the element block params */ if (!(elem_blk_parms= static_cast<struct elem_blk_parm*>(malloc(num_elem_blks*sizeof(struct elem_blk_parm))))) { free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for element block params for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } elem_ctr = 0; for (i=0; i<num_elem_blks; i++) { /* read in an element block parameter */ if ((ex_get_elem_block (exoid, elem_blk_ids[i], elem_type, &num_elem_in_blk, &num_nodes_per_elem, &num_attr)) == -1) { free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to get element block %d parameters in file id %d", elem_blk_ids[i], exoid); ex_err("ex_get_side_set_node_list",errmsg,EX_MSG); return(EX_FATAL); } elem_blk_parms[i].num_elem_in_blk = num_elem_in_blk; elem_blk_parms[i].num_nodes_per_elem = num_nodes_per_elem; elem_blk_parms[i].num_attr = num_attr; for (m=0; m < strlen(elem_type); m++) elem_blk_parms[i].elem_type[m] = toupper((int)elem_type[m]); elem_blk_parms[i].elem_type[m] = '\0'; if (strncmp(elem_blk_parms[i].elem_type,"CIRCLE",3) == 0) { elem_blk_parms[i].elem_type_val = CIRCLE; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"SPHERE",3) == 0) { elem_blk_parms[i].elem_type_val = SPHERE; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"QUAD",3) == 0) { elem_blk_parms[i].elem_type_val = QUAD; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side = 2; else if (elem_blk_parms[i].num_nodes_per_elem == 5) elem_blk_parms[i].num_nodes_per_side = 2; else elem_blk_parms[i].num_nodes_per_side = 3; } else if (strncmp(elem_blk_parms[i].elem_type,"TRIANGLE",3) == 0) { elem_blk_parms[i].elem_type_val = TRIANGLE; /* set default side set node stride */ if (ndim == 2) /* 2d TRIs */ { if (elem_blk_parms[i].num_nodes_per_elem == 3) elem_blk_parms[i].num_nodes_per_side = 2; else elem_blk_parms[i].num_nodes_per_side = 3; } else if (ndim == 3) /* 3d TRIs */ { if (elem_blk_parms[i].num_nodes_per_elem == 3) elem_blk_parms[i].num_nodes_per_side = 3; else elem_blk_parms[i].num_nodes_per_side = 6; } } else if (strncmp(elem_blk_parms[i].elem_type,"SHELL",3) == 0) { elem_blk_parms[i].elem_type_val = SHELL; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) /* KLUDGE for 2D Shells*/ elem_blk_parms[i].num_nodes_per_side = 2; else if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side = 4; else elem_blk_parms[i].num_nodes_per_side = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"HEX",3) == 0) { elem_blk_parms[i].elem_type_val = HEX; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 8) /* 8-node bricks */ elem_blk_parms[i].num_nodes_per_side = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 9) /* 9-node bricks */ elem_blk_parms[i].num_nodes_per_side = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 12) /* HEXSHELLS */ elem_blk_parms[i].num_nodes_per_side = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 27) /* 27-node bricks */ elem_blk_parms[i].num_nodes_per_side = 9; else elem_blk_parms[i].num_nodes_per_side = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"TETRA",3) == 0) { elem_blk_parms[i].elem_type_val = TETRA; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side = 3; else if (elem_blk_parms[i].num_nodes_per_elem == 8) elem_blk_parms[i].num_nodes_per_side = 4; else elem_blk_parms[i].num_nodes_per_side = 6; } else if (strncmp(elem_blk_parms[i].elem_type,"WEDGE",3) == 0) { elem_blk_parms[i].elem_type_val = WEDGE; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 6) elem_blk_parms[i].num_nodes_per_side = 4; else elem_blk_parms[i].num_nodes_per_side = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"PYRAMID",3) == 0) { elem_blk_parms[i].elem_type_val = PYRAMID; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 5) elem_blk_parms[i].num_nodes_per_side = 4; else elem_blk_parms[i].num_nodes_per_side = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"BEAM",3) == 0) { elem_blk_parms[i].elem_type_val = BEAM; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) elem_blk_parms[i].num_nodes_per_side = 2; else elem_blk_parms[i].num_nodes_per_side = 3; } else if ( (strncmp(elem_blk_parms[i].elem_type,"TRUSS",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"BAR",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"EDGE",3) == 0) ) { elem_blk_parms[i].elem_type_val = TRUSS; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) elem_blk_parms[i].num_nodes_per_side = 2; else elem_blk_parms[i].num_nodes_per_side = 3; } else if (strncmp(elem_blk_parms[i].elem_type,"NULL",3) == 0) { elem_blk_parms[i].elem_type_val = '\0'; elem_blk_parms[i].num_nodes_per_side = 0; elem_blk_parms[i].num_elem_in_blk = 0; } else { /* unsupported element type; no problem if no sides specified for this element block */ elem_blk_parms[i].elem_type_val = UNK; elem_blk_parms[i].num_nodes_per_side = 0; } elem_blk_parms[i].elem_blk_id = elem_blk_ids[i]; /* save id */ elem_ctr += elem_blk_parms[i].num_elem_in_blk; elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */ } /* Allocate space for the ss element to element block parameter index array */ if (!(ss_parm_ndx=static_cast<int*>(malloc(tot_num_ss_elem*sizeof(int))))) { free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem parms index for file id %d" , exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the ss element to node list index array */ if (!(ss_elem_node_ndx=static_cast<int*>(malloc(tot_num_ss_elem*sizeof(int))))) { free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem to node index for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } /* Build side set element to node list index and side set element parameter index. */ node_ctr = 0; for (i=0;i<tot_num_ss_elem;i++) { for (j=0; j<num_elem_blks; j++) { if (elem_blk_parms[j].elem_type_val != '\0') if (side_set_elem_list[i] <= elem_blk_parms[j].elem_ctr) break; } if (j >= num_elem_blks) { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid element number %d found in side set %d in file %d", side_set_elem_list[i], side_set_id, exoid); free(ss_parm_ndx); free(ss_elem_node_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); ex_err("ex_get_side_set_node_list",errmsg,EX_MSG); return (EX_FATAL); } ss_parm_ndx[i] = j; /* assign parameter block index */ ss_elem_node_ndx[i] = node_ctr; /* assign node list index */ /* Update node_ctr (which points to next node in chain */ /* WEDGEs with 3 node sides (side 4 or 5) are special cases */ if (elem_blk_parms[j].elem_type_val == WEDGE && (side_set_side_list[i] == 4 || side_set_side_list[i] == 5)) { if (elem_blk_parms[j].num_nodes_per_elem == 6) node_ctr += 3; /* 3 node side */ else node_ctr += 6; /* 6 node side */ } /* PYRAMIDSs with 3 node sides (sides 1,2,3,4) are also special */ else if (elem_blk_parms[j].elem_type_val == PYRAMID && (side_set_side_list[i] < 5)) { if (elem_blk_parms[j].num_nodes_per_elem == 5) node_ctr += 3; /* 3 node side */ else node_ctr += 6; /* 6 node side */ } /* side numbers 3,4,5,6 for SHELLs are also special */ else if (elem_blk_parms[j].elem_type_val == SHELL && (side_set_side_list[i] > 2 )) { if (elem_blk_parms[j].num_nodes_per_elem == 4) node_ctr += 2; /* 2 node side */ else node_ctr += 3; /* 3 node side */ } /* side numbers 3,4,5 for 3d TRIs are also special */ else if (elem_blk_parms[j].elem_type_val == TRIANGLE && ndim == 3 && side_set_side_list[i] > 2 ) { if (elem_blk_parms[j].num_nodes_per_elem == 3) /* 3-node TRI */ node_ctr += 2; /* 2 node side */ else /* 6-node TRI */ node_ctr += 3; /* 3 node side */ } else /* all other element types */ node_ctr += elem_blk_parms[j].num_nodes_per_side; } /* All setup, ready to go ... */ elem_ctr=0; for (j=0; j < tot_num_ss_elem; j++) { if (side_set_elem_list[ss_elem_ndx[j]] > elem_ctr) { /* release connectivity array space and get next one */ if (elem_ctr > 0) { free(connect); } /* Allocate space for the connectivity array for new element block */ if (!(connect=static_cast<int*>(malloc(elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].num_elem_in_blk* elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].num_nodes_per_elem* (int)sizeof(int))))) { free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for connectivity array for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } /* get connectivity array */ if (ex_get_elem_conn( exoid, elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, connect) == -1) { free(connect); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to allocate space for connectivity array for file id %d", exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return (EX_FATAL); } elem_ctr = elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_ctr; } /* For each side in side set, use the appropriate lookup table to determine the nodes from the connect array. */ elem_num = side_set_elem_list[ss_elem_ndx[j]]-1;/* element number 0-based*/ /* calculate the relative element number position in it's block*/ elem_num_pos = elem_num - (elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_ctr - elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].num_elem_in_blk); /* calculate the beginning of the node list for this element by using the ss_elem_node_ndx index into the side_sets_node_index and adding the element number position * number of nodes per elem */ num_nodes_per_elem = elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].num_nodes_per_elem; node_pos = ss_elem_node_ndx[ss_elem_ndx[j]]; connect_offset = num_nodes_per_elem*elem_num_pos; side_num = side_set_side_list[ss_elem_ndx[j]]-1; switch (elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_type_val) { case CIRCLE: case SPHERE: { /* Note: no side-node lookup table is used for this simple case */ side_set_node_list[node_pos] = connect[connect_offset]; side_set_node_cnt_list[ss_elem_ndx[j]] = 1; /* 1 node object */ break; } case TRUSS: case BEAM: { /* Note: no side-node lookup table is used for this simple case */ side_set_node_list[node_pos] = connect[connect_offset]; side_set_node_list[node_pos+1] = connect[connect_offset+1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 2; /* 2 node object */ if (num_nodes_per_elem > 2) { side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node object */ side_set_node_list[node_pos+2] = connect[connect_offset+2]; } break; } case TRIANGLE: { if (side_num+1 < 1 || side_num+1 > 5) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid triangle edge number %d in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); free(connect); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_FATAL); } if (ndim == 2) /* 2d TRIs */ { side_set_node_list[node_pos] = connect[connect_offset+tri_table[side_num][0]-1]; side_set_node_list[node_pos+1] = connect[connect_offset+tri_table[side_num][1]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 2; /* 2 node object */ if (num_nodes_per_elem > 3) /* 6-node TRI */ { side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node object */ side_set_node_list[node_pos+2] = connect[connect_offset+tri_table[side_num][2]-1]; } } else if (ndim == 3) /* 3d TRIs */ { side_set_node_list[node_pos] = connect[connect_offset+tri3_table[side_num][0]-1]; side_set_node_list[node_pos+1] = connect[connect_offset+tri3_table[side_num][1]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 2; /* 2 node object */ if (side_num+1 <= 2) /* 3- or 6-node face */ { if (num_nodes_per_elem == 3) /* 3-node face */ { side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node object */ side_set_node_list[node_pos+2] = connect[connect_offset+tri3_table[side_num][2]-1]; } else /* 6-node face */ { side_set_node_cnt_list[ss_elem_ndx[j]] = 6; /* 6 node object */ side_set_node_list[node_pos+2] = connect[connect_offset+tri3_table[side_num][2]-1]; side_set_node_list[node_pos+3] = connect[connect_offset+tri3_table[side_num][3]-1]; side_set_node_list[node_pos+4] = connect[connect_offset+tri3_table[side_num][4]-1]; side_set_node_list[node_pos+5] = connect[connect_offset+tri3_table[side_num][5]-1]; } } else /* 2- or 3-node edge */ { if (num_nodes_per_elem > 3) /* 3-node edge */ { side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node object */ side_set_node_list[node_pos+2] = connect[connect_offset+tri3_table[side_num][2]-1]; } } } break; } case QUAD: { if (side_num+1 < 1 || side_num+1 > 4) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid quad edge number %d in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); free(connect); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_FATAL); } side_set_node_list[node_pos] = connect[connect_offset+quad_table[side_num][0]-1]; side_set_node_list[node_pos+1] = connect[connect_offset+quad_table[side_num][1]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 2; /* 2 node object */ if (num_nodes_per_elem > 5) { side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node object */ side_set_node_list[node_pos+2] = connect[connect_offset+quad_table[side_num][2]-1]; } break; } case SHELL: { if (side_num+1 < 1 || side_num+1 > 6) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid shell face number %d in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); free(connect); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_FATAL); } side_set_node_list[node_pos] = connect[connect_offset+shell_table[side_num][0]-1]; side_set_node_list[node_pos+1] = connect[connect_offset+shell_table[side_num][1]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 2; /* 2 node object */ if (num_nodes_per_elem > 2) /*** KLUDGE for 2D shells ***/ { if (side_num+1 <= 2) /* 4-node face */ { side_set_node_cnt_list[ss_elem_ndx[j]] = 4; /* 4 node object */ side_set_node_list[node_pos+2] = connect[connect_offset+shell_table[side_num][2]-1]; side_set_node_list[node_pos+3] = connect[connect_offset+shell_table[side_num][3]-1]; } } if (num_nodes_per_elem == 8) { if (side_num+1 <= 2) /* 8-node face */ { side_set_node_cnt_list[ss_elem_ndx[j]] = 8; /* 8 node object */ side_set_node_list[node_pos+4] = connect[connect_offset+shell_table[side_num][4]-1]; side_set_node_list[node_pos+5] = connect[connect_offset+shell_table[side_num][5]-1]; side_set_node_list[node_pos+6] = connect[connect_offset+shell_table[side_num][6]-1]; side_set_node_list[node_pos+7] = connect[connect_offset+shell_table[side_num][7]-1]; } else { side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node edge */ side_set_node_list[node_pos+2] = connect[connect_offset+shell_table[side_num][2]-1]; } } break; } case TETRA: { if (side_num+1 < 1 || side_num+1 > 4) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid tetra face number %d in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); free(connect); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_FATAL); } side_set_node_list[node_pos] = connect[connect_offset+tetra_table[side_num][0]-1]; side_set_node_list[node_pos+1] = connect[connect_offset+tetra_table[side_num][1]-1]; side_set_node_list[node_pos+2] = connect[connect_offset+tetra_table[side_num][2]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node object */ if (num_nodes_per_elem == 8) { side_set_node_cnt_list[ss_elem_ndx[j]] = 4; /* 4 node object */ side_set_node_list[node_pos+3] = connect[connect_offset+tetra_table[side_num][3]-1]; } else if (num_nodes_per_elem > 8) { side_set_node_cnt_list[ss_elem_ndx[j]] = 6; /* 6 node object */ side_set_node_list[node_pos+3] = connect[connect_offset+tetra_table[side_num][3]-1]; side_set_node_list[node_pos+4] = connect[connect_offset+tetra_table[side_num][4]-1]; side_set_node_list[node_pos+5] = connect[connect_offset+tetra_table[side_num][5]-1]; } break; } case WEDGE: { if (side_num+1 < 1 || side_num+1 > 5) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid wedge face number %d in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); free(connect); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_FATAL); } side_set_node_list[node_pos++] = connect[connect_offset+wedge_table[side_num][0]-1]; side_set_node_list[node_pos++] = connect[connect_offset+wedge_table[side_num][1]-1]; side_set_node_list[node_pos++] = connect[connect_offset+wedge_table[side_num][2]-1]; if (wedge_table[side_num][3] == 0) { /* degenerate side? */ side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node side */ } else { side_set_node_list[node_pos++] = connect[connect_offset+wedge_table[side_num][3]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 4; /* 4 node side */ } if (num_nodes_per_elem > 6) { side_set_node_cnt_list[ss_elem_ndx[j]] = 8; /* 8 node object */ side_set_node_list[node_pos++] = connect[connect_offset+wedge_table[side_num][4]-1]; side_set_node_list[node_pos++] = connect[connect_offset+wedge_table[side_num][5]-1]; side_set_node_list[node_pos++] = connect[connect_offset+wedge_table[side_num][6]-1]; if (wedge_table[side_num][7] == 0) /* degenerate side? */ side_set_node_cnt_list[ss_elem_ndx[j]] = 6; /* 6 node side */ else { side_set_node_list[node_pos++] = connect[connect_offset+wedge_table[side_num][7]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 8; /* 8 node side */ } } break; } case PYRAMID: { if (side_num+1 < 1 || side_num+1 > 5) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid pyramid face number %d in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); free(connect); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_FATAL); } side_set_node_list[node_pos++] = connect[connect_offset+pyramid_table[side_num][0]-1]; side_set_node_list[node_pos++] = connect[connect_offset+pyramid_table[side_num][1]-1]; side_set_node_list[node_pos++] = connect[connect_offset+pyramid_table[side_num][2]-1]; if (pyramid_table[side_num][3] == 0) { /* degenerate side? */ side_set_node_cnt_list[ss_elem_ndx[j]] = 3; /* 3 node side */ } else { side_set_node_list[node_pos++] = connect[connect_offset+pyramid_table[side_num][3]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 4; /* 4 node side */ } if (num_nodes_per_elem > 5) { side_set_node_cnt_list[ss_elem_ndx[j]] = 8; /* 8 node object */ side_set_node_list[node_pos++] = connect[connect_offset+pyramid_table[side_num][4]-1]; side_set_node_list[node_pos++] = connect[connect_offset+pyramid_table[side_num][5]-1]; side_set_node_list[node_pos++] = connect[connect_offset+pyramid_table[side_num][6]-1]; if (pyramid_table[side_num][7] == 0) /* degenerate side? */ side_set_node_cnt_list[ss_elem_ndx[j]] = 6; /* 6 node side */ else { side_set_node_list[node_pos++] = connect[connect_offset+pyramid_table[side_num][7]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 8; /* 8 node side */ } } break; } case HEX: { if (side_num+1 < 1 || side_num+1 > 6) /* side number range check */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid hex face number %d in file id %d", side_num+1, exoid); ex_err("ex_get_side_set_node_list",errmsg,exerrval); free(connect); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(ss_elem_node_ndx); free(ss_parm_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_FATAL); } side_set_node_list[node_pos] = connect[connect_offset+hex_table[side_num][0]-1]; side_set_node_list[node_pos+1] = connect[connect_offset+hex_table[side_num][1]-1]; side_set_node_list[node_pos+2] = connect[connect_offset+hex_table[side_num][2]-1]; side_set_node_list[node_pos+3] = connect[connect_offset+hex_table[side_num][3]-1]; side_set_node_cnt_list[ss_elem_ndx[j]] = 4; /* 4 node object */ if (num_nodes_per_elem > 12) /* more nodes than HEXSHELL */ { side_set_node_cnt_list[ss_elem_ndx[j]] = 8; /* 8 node object */ side_set_node_list[node_pos+4] = connect[connect_offset+hex_table[side_num][4]-1]; side_set_node_list[node_pos+5] = connect[connect_offset+hex_table[side_num][5]-1]; side_set_node_list[node_pos+6] = connect[connect_offset+hex_table[side_num][6]-1]; side_set_node_list[node_pos+7] = connect[connect_offset+hex_table[side_num][7]-1]; } if (num_nodes_per_elem == 27) /* 27-node brick */ { side_set_node_cnt_list[ss_elem_ndx[j]] = 9; /* 9 node object */ side_set_node_list[node_pos+8] = connect[connect_offset+hex_table[side_num][8]-1]; } break; } default: { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: %s is an unsupported element type", elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_type); ex_err("ex_get_side_set_node_list",errmsg,exerrval); return(EX_FATAL); } } } /* All done: release connectivity array space, element block ids array, element block parameters array, and side set element index array */ free(connect); free(ss_parm_ndx); free(elem_blk_ids); free(elem_blk_parms); free(ss_elem_ndx); free(ss_elem_node_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_NOERR); }
printf("\tNumber of element blocks: %d\n", num_elem_blk); printf("---------------------------------------------------------\n"); } #endif /* Cross-check the load balance file info against the mesh info */ if(((size_t)num_nodes != globals.Num_Node) || ((size_t)num_elem != globals.Num_Elem) || (num_elem_blk != globals.Num_Elem_Blk)) { fprintf(stderr, "%s: ERROR: Problem dimensions in the LB File don't match with those \ in mesh file",yo); exit(1); } /* Read the QA Records */ error = ex_inquire(lb_exoid, EX_INQ_QA, &num_qa_rec, NULL, NULL); check_exodus_error(error, "ex_inquire"); if(num_qa_rec > 0) { length_qa = 4 * num_qa_rec; qa_record_ptr = (char **)array_alloc(__FILE__, __LINE__, 1, length_qa, sizeof(char *)); for(int i = 0; i < length_qa; i++) { qa_record_ptr[i] = (char *) array_alloc (__FILE__, __LINE__, 1, (MAX_STR_LENGTH+1), sizeof(char)); } error = ex_get_qa(lb_exoid, (char *(*)[4]) &qa_record_ptr[0]); check_exodus_error(error, "ex_get_qa"); } /* Read the Info Records */
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; }
int main(int argc, char **argv) { int exoid, num_dim, num_nodes, num_elem_blk; int *num_elem_in_block, *num_face_in_block, *num_nodes_per_elem, *num_edges_per_elem, *num_faces_per_elem, *num_attr; int error, nnodes; int i, j, k; int *connect, *fconnect; int *ids, *nnpe, *nnpf; int num_qa_rec, num_info; int CPU_word_size, IO_word_size; int idum; float *x, *y, *z; float version, fdum; char *coord_names[3], *qa_record[2][4], *info[3]; char *block_names[10]; char *elem_type[10]; char name[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-nfaced.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(" I/O word size %1d\n", IO_word_size); ex_inquire(exoid, EX_INQ_LIB_VERS, &idum, &version, cdum); printf("EXODUSII Library API; version %4.2f (%d)\n", version, idum); /* read database parameters */ { ex_init_params par; error = ex_get_init_ext(exoid, &par); printf("after ex_get_init, error = %3d\n", error); printf("database parameters:\n"); printf("title = '%s'\n", par.title); printf("num_dim = %" PRId64 "\n", par.num_dim); printf("num_nodes = %" PRId64 "\n", par.num_nodes); printf("num_edge = %" PRId64 "\n", par.num_edge); printf("num_face = %" PRId64 "\n", par.num_face); printf("num_elem = %" PRId64 "\n", par.num_elem); printf("num_elem_blk = %" PRId64 "\n", par.num_elem_blk); printf("num_node_sets = %" PRId64 "\n", par.num_node_sets); printf("num_side_sets = %" PRId64 "\n", par.num_side_sets); num_dim = par.num_dim; num_nodes = par.num_nodes; num_elem_blk = par.num_elem_blk; } assert(num_dim == 3); /* read nodal coordinates values and names from database */ x = (float *)calloc(num_nodes, sizeof(float)); y = (float *)calloc(num_nodes, sizeof(float)); z = (float *)calloc(num_nodes, sizeof(float)); error = ex_get_coord(exoid, x, y, z); printf("\nafter ex_get_coord, error = %3d\n", error); printf("x, y, z coords = \n"); for (i = 0; i < num_nodes; i++) { printf("%5.1f\t%5.1f\t%5.1f\n", x[i], y[i], z[i]); } free(x); free(y); 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]); printf("y coord name = '%s'\n", coord_names[1]); printf("z coord name = '%s'\n", coord_names[2]); for (i = 0; i < num_dim; i++) free(coord_names[i]); /* 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_face_in_block = (int *)calloc(num_elem_blk, sizeof(int)); num_nodes_per_elem = (int *)calloc(num_elem_blk, sizeof(int)); num_edges_per_elem = (int *)calloc(num_elem_blk, sizeof(int)); num_faces_per_elem = (int *)calloc(num_elem_blk, sizeof(int)); num_attr = (int *)calloc(num_elem_blk, sizeof(int)); for (i = 0; i < num_elem_blk; i++) { elem_type[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char)); block_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char)); } error = ex_get_elem_blk_ids(exoid, ids); printf("\nafter ex_get_elem_blk_ids, error = %3d\n", error); 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[i], &(num_elem_in_block[i]), &(num_nodes_per_elem[i]), &(num_edges_per_elem[i]), &(num_faces_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 block type = '%s'\n", elem_type[i]); printf("num_elem_in_block = %2d\n", num_elem_in_block[i]); printf("num_total_nodes_per_block = %2d\n", num_nodes_per_elem[i]); printf("num_total_edges_per_block = %2d\n", num_edges_per_elem[i]); printf("num_total_faces_per_block = %2d\n", num_faces_per_elem[i]); printf("num_attr = %2d\n", num_attr[i]); printf("name = '%s'\n", block_names[i]); } } /* read connectivity */ for (i = 0; i < num_elem_blk; i++) { if (num_elem_in_block[i] > 0) { if (strcmp(elem_type[i], "NFACED") == 0 || strcmp(elem_type[i], "nfaced") == 0) { int nfaces = 0; connect = (int *)calloc((num_faces_per_elem[i]), sizeof(int)); nnpe = (int *)calloc(num_elem_in_block[i], sizeof(int)); error = ex_get_entity_count_per_polyhedra(exoid, EX_ELEM_BLOCK, ids[i], nnpe); printf("\nafter ex_get_entity_count_per_polyhedra, error = %d\n", error); for (j = 0; j < num_elem_in_block[i]; j++) { nfaces += nnpe[j]; } assert(nfaces == num_faces_per_elem[i]); error = ex_get_conn(exoid, EX_ELEM_BLOCK, ids[i], NULL, NULL, connect); printf("\nafter ex_get_conn, error = %d\n", error); printf("face connectivity array for elem block %2d\n", ids[i]); nfaces = 0; for (j = 0; j < num_elem_in_block[i]; j++) { printf("Element %d, %d faces:\t", j + 1, nnpe[j]); for (k = 0; k < nnpe[j]; k++) { printf("%3d ", connect[nfaces + k]); } printf("\n"); nfaces += nnpe[j]; } /* Now get the faces and their connectivity... */ /* * Convention is that the faces for an nfaced block are in a * face block which has the same id as the element block... * (Or, at least let's try that for awhile and see if it works...) */ /* NOTE: We are overwriting the element block data here... */ error = ex_get_block(exoid, EX_FACE_BLOCK, ids[i], elem_type[i], &(num_face_in_block[i]), &(num_nodes_per_elem[i]), NULL, NULL, &(num_attr[i])); printf("\nafter ex_get_block (EX_FACE_BLOCK), error = %d\n", error); error = ex_get_names(exoid, EX_FACE_BLOCK, block_names); printf("\nafter ex_get_names, error = %3d\n", error); printf("\tface block id = %2d\n", ids[i]); printf("\tface block type = '%s'\n", elem_type[i]); printf("\tnum_face_in_block = %2d\n", num_face_in_block[i]); printf("\tnum_total_nodes_per_block = %2d\n", num_nodes_per_elem[i]); printf("\tnum_attr = %2d\n", num_attr[i]); printf("\tname = '%s'\n", block_names[i]); fconnect = (int *)calloc((num_nodes_per_elem[i]), sizeof(int)); nnpf = (int *)calloc(num_face_in_block[i], sizeof(int)); error = ex_get_entity_count_per_polyhedra(exoid, EX_FACE_BLOCK, ids[i], nnpf); printf("\nafter ex_get_entity_count_per_polyhedra, error = %d\n", error); nnodes = 0; for (j = 0; j < num_face_in_block[i]; j++) { nnodes += nnpf[j]; } assert(nnodes == num_nodes_per_elem[i]); error = ex_get_conn(exoid, EX_FACE_BLOCK, ids[i], fconnect, NULL, NULL); printf("\nafter ex_get_conn, error = %d\n", error); printf("node connectivity array for face block %2d\n", ids[i]); nnodes = 0; for (j = 0; j < num_face_in_block[i]; j++) { printf("Face %d, %d nodes:\t", j + 1, nnpf[j]); for (k = 0; k < nnpf[j]; k++) { printf("%3d ", fconnect[nnodes + k]); } printf("\n"); nnodes += nnpf[j]; } free(fconnect); free(nnpe); free(nnpf); } else { 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]); } } free(connect); } } for (i = 0; i < num_elem_blk; i++) { free(elem_type[i]); free(block_names[i]); } if (num_elem_blk > 0) { free(ids); free(num_nodes_per_elem); free(num_edges_per_elem); free(num_faces_per_elem); free(num_attr); } /* 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]); } error = ex_close(exoid); printf("\nafter ex_close, error = %3d\n", error); return 0; }
int ex_get_glob_var_time (int exoid, int glob_var_index, int beg_time_step, int end_time_step, void *glob_var_vals) { int varid; long start[2], count[2]; float fdum; char *cdum; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ /* inquire previously defined variable */ if ((varid = ncvarid (exoid, VAR_GLO_VAR)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate global variables in file id %d", exoid); ex_err("ex_get_glob_var_time",errmsg,exerrval); return (EX_WARN); } /* read values of global variables */ start[0] = --beg_time_step; start[1] = --glob_var_index; if (end_time_step < 0) { /* user is requesting the maximum time step; we find this out using the * database inquire function to get the number of time steps */ if (ex_inquire (exoid, EX_INQ_TIME, &end_time_step, &fdum, cdum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of time steps in file id %d", exoid); ex_err("ex_get_glob_var_time",errmsg,exerrval); return (EX_FATAL); } } end_time_step--; count[0] = end_time_step - beg_time_step + 1; count[1] = 1; if (ncvarget (exoid, varid, start, count, ex_conv_array(exoid,RTN_ADDRESS,glob_var_vals,count[0])) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get global variable %d values from file id %d", glob_var_index, exoid); ex_err("ex_get_glob_var_time",errmsg,exerrval); return (EX_FATAL); } ex_conv_array( exoid, READ_CONVERT, glob_var_vals, count[0] ); return (EX_NOERR); }
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; 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); /* 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); /* 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_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_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_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_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_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_STR_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_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_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_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_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_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_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_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_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_STR_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_STR_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_STR_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_STR_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_STR_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); error = ex_close(exoid); printf("\nafter ex_close, error = %3d\n", error); return 0; }
int ex_get_glob_var_time (int exoid, int glob_var_index, int beg_time_step, int end_time_step, void *glob_var_vals) { int status; int varid; size_t start[2], count[2]; float fdum; char *cdum = 0; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* inquire previously defined variable */ if ((status = nc_inq_varid (exoid, VAR_GLO_VAR, &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate global variables in file id %d", exoid); ex_err("ex_get_glob_var_time",errmsg,exerrval); return (EX_WARN); } /* read values of global variables */ start[0] = --beg_time_step; start[1] = --glob_var_index; if (end_time_step < 0) { /* user is requesting the maximum time step; we find this out using the * database inquire function to get the number of time steps */ if ((status = ex_inquire (exoid, EX_INQ_TIME, &end_time_step, &fdum, cdum)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get number of time steps in file id %d", exoid); ex_err("ex_get_glob_var_time",errmsg,exerrval); return (EX_FATAL); } } end_time_step--; count[0] = end_time_step - beg_time_step + 1; count[1] = 1; if (ex_comp_ws(exoid) == 4) { status = nc_get_vara_float(exoid, varid, start, count, glob_var_vals); } else { status = nc_get_vara_double(exoid, varid, start, count, glob_var_vals); } if (status != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get global variable %d values from file id %d", glob_var_index, exoid); ex_err("ex_get_glob_var_time",errmsg,exerrval); return (EX_FATAL); } return (EX_NOERR); }
int ex_get_side_set_node_count(int exoid, int side_set_id, int *side_set_node_cnt_list) { int ii, i, j, m; int num_side_sets, num_elem_blks, num_df, ndim; int tot_num_elem = 0, tot_num_ss_elem = 0, side, elem; int *elem_blk_ids; int *ss_elem_ndx; int *side_set_elem_list, *side_set_side_list; int elem_ctr; int num_elem_in_blk, num_nodes_per_elem, num_attr; float fdum; char *cdum, elem_type[MAX_STR_LENGTH+1]; struct elem_blk_parm { char elem_type[MAX_STR_LENGTH+1]; int elem_blk_id; int num_elem_in_blk; int num_nodes_per_elem; int num_sides; int num_nodes_per_side[6]; int num_attr; int elem_ctr; int elem_type_val; } *elem_blk_parms; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ /* first check if any side sets are specified */ /* inquire how many side sets have been stored */ if ((ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get number of side sets in file id %d",exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return(EX_FATAL); } if (num_side_sets == 0) { sprintf(errmsg, "Warning: no side sets defined in file id %d",exoid); ex_err("ex_get_side_set_node_count",errmsg,EX_WARN); return(EX_WARN); } /* Lookup index of side set id in VAR_SS_IDS array */ ex_id_lkup(exoid,VAR_SS_IDS,side_set_id); if (exerrval != 0) { if (exerrval == EX_NULLENTITY) { sprintf(errmsg, "Warning: side set %d is NULL in file id %d", side_set_id,exoid); ex_err("ex_get_side_set_node_count",errmsg,EX_MSG); return (EX_WARN); } else { sprintf(errmsg, "Error: failed to locate side set id %d in VAR_SS_IDS array in file id %d", side_set_id,exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return (EX_FATAL); } } if ((ex_inquire(exoid, EX_INQ_ELEM_BLK, &num_elem_blks, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get number of element blocks in file id %d",exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return(EX_FATAL); } if ((ex_inquire(exoid, EX_INQ_ELEM, &tot_num_elem, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get total number of elements in file id %d",exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return(EX_FATAL); } /* get the dimensionality of the coordinates; this is necessary to distinguish between 2d TRIs and 3d TRIs */ if ((ex_inquire(exoid, EX_INQ_DIM, &ndim, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get dimensionality in file id %d",exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return(EX_FATAL); } /* First determine the # of elements in the side set*/ if ((ex_get_side_set_param(exoid,side_set_id,&tot_num_ss_elem,&num_df)) == -1) { sprintf(errmsg, "Error: failed to get number of elements in side set %d in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return(EX_FATAL); } /* Allocate space for the side set element list */ if (!(side_set_elem_list=malloc(tot_num_ss_elem*sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set element list for file id %d", exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the side set side list */ if (!(side_set_side_list=malloc(tot_num_ss_elem*sizeof(int)))) { free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set side list for file id %d", exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return (EX_FATAL); } if (ex_get_side_set(exoid, side_set_id, side_set_elem_list, side_set_side_list) == -1) { free(side_set_elem_list); free(side_set_side_list); sprintf(errmsg, "Error: failed to get side set %d in file id %d", side_set_id, exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the ss element index array */ if (!(ss_elem_ndx=malloc(tot_num_ss_elem*sizeof(int)))) { free(side_set_elem_list); free(side_set_side_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem sort array for file id %d", exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return (EX_FATAL); } /* Sort side set element list into index array - non-destructive */ for (i=0;i<tot_num_ss_elem;i++) { ss_elem_ndx[i] = i; /* init index array to current position */ } ex_iqsort(side_set_elem_list, ss_elem_ndx,tot_num_ss_elem); /* Allocate space for the element block ids */ if (!(elem_blk_ids=malloc(num_elem_blks*sizeof(int)))) { exerrval = EX_MEMFAIL; free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to allocate space for element block ids for file id %d", exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return (EX_FATAL); } if (ex_get_elem_blk_ids(exoid, elem_blk_ids) == -1) { free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to get element block ids in file id %d", exoid); ex_err("ex_get_side_set_node_count",errmsg,EX_MSG); return(EX_FATAL); } /* Allocate space for the element block params */ if (!(elem_blk_parms=malloc(num_elem_blks*sizeof(struct elem_blk_parm)))) { free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for element block params for file id %d", exoid); ex_err("ex_get_side_set_node_count",errmsg,exerrval); return (EX_FATAL); } elem_ctr = 0; for (i=0; i<num_elem_blks; i++) { /* read in an element block parameter */ if ((ex_get_elem_block (exoid, elem_blk_ids[i], elem_type, &num_elem_in_blk, &num_nodes_per_elem, &num_attr)) == -1) { free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); sprintf(errmsg, "Error: failed to get element block %d parameters in file id %d", elem_blk_ids[i], exoid); ex_err("ex_get_side_set_node_count",errmsg,EX_MSG); return(EX_FATAL); } elem_blk_parms[i].num_elem_in_blk = num_elem_in_blk; elem_blk_parms[i].num_nodes_per_elem = num_nodes_per_elem; elem_blk_parms[i].num_attr = num_attr; for (m=0; (size_t)m < strlen(elem_type); m++) { elem_blk_parms[i].elem_type[m] = (char)toupper((int)elem_type[m]); } elem_blk_parms[i].elem_type[m] = '\0'; if (strncmp(elem_blk_parms[i].elem_type,"CIRCLE",3) == 0) { elem_blk_parms[i].elem_type_val = CIRCLE; elem_blk_parms[i].num_sides = 1; elem_blk_parms[i].num_nodes_per_side[0] = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"SPHERE",3) == 0) { elem_blk_parms[i].elem_type_val = SPHERE; elem_blk_parms[i].num_sides = 1; elem_blk_parms[i].num_nodes_per_side[0] = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"QUAD",3) == 0) { elem_blk_parms[i].elem_type_val = QUAD; elem_blk_parms[i].num_sides = 4; if (elem_blk_parms[i].num_nodes_per_elem == 4) { elem_blk_parms[i].num_nodes_per_side[0] = 2; elem_blk_parms[i].num_nodes_per_side[1] = 2; elem_blk_parms[i].num_nodes_per_side[2] = 2; elem_blk_parms[i].num_nodes_per_side[3] = 2; } else if (elem_blk_parms[i].num_nodes_per_elem == 5) { elem_blk_parms[i].num_nodes_per_side[0] = 2; elem_blk_parms[i].num_nodes_per_side[1] = 2; elem_blk_parms[i].num_nodes_per_side[2] = 2; elem_blk_parms[i].num_nodes_per_side[3] = 2; } else if (elem_blk_parms[i].num_nodes_per_elem == 9 || elem_blk_parms[i].num_nodes_per_elem == 8) { elem_blk_parms[i].num_nodes_per_side[0] = 3; elem_blk_parms[i].num_nodes_per_side[1] = 3; elem_blk_parms[i].num_nodes_per_side[2] = 3; elem_blk_parms[i].num_nodes_per_side[3] = 3; } else { EL_NODE_COUNT_ERROR; } } else if (strncmp(elem_blk_parms[i].elem_type,"TRIANGLE",3) == 0) { elem_blk_parms[i].elem_type_val = TRIANGLE; if (ndim == 2) { /* 2d TRIs */ elem_blk_parms[i].num_sides = 3; if (elem_blk_parms[i].num_nodes_per_elem == 3) { elem_blk_parms[i].num_nodes_per_side[0] = 2; elem_blk_parms[i].num_nodes_per_side[1] = 2; elem_blk_parms[i].num_nodes_per_side[2] = 2; } else if (elem_blk_parms[i].num_nodes_per_elem == 6) { elem_blk_parms[i].num_nodes_per_side[0] = 3; elem_blk_parms[i].num_nodes_per_side[1] = 3; elem_blk_parms[i].num_nodes_per_side[2] = 3; } } else if (ndim == 3) { /* 3d TRIs -- triangular shell*/ elem_blk_parms[i].num_sides = 5; /* 2 Faces and 3 Edges */ if (elem_blk_parms[i].num_nodes_per_elem == 3) { elem_blk_parms[i].num_nodes_per_side[0] = 3; elem_blk_parms[i].num_nodes_per_side[1] = 3; elem_blk_parms[i].num_nodes_per_side[2] = 2; elem_blk_parms[i].num_nodes_per_side[3] = 2; elem_blk_parms[i].num_nodes_per_side[4] = 2; } else if (elem_blk_parms[i].num_nodes_per_elem == 6) { elem_blk_parms[i].num_nodes_per_side[0] = 6; elem_blk_parms[i].num_nodes_per_side[1] = 6; elem_blk_parms[i].num_nodes_per_side[2] = 3; elem_blk_parms[i].num_nodes_per_side[3] = 3; elem_blk_parms[i].num_nodes_per_side[4] = 3; } else { EL_NODE_COUNT_ERROR; } } } else if (strncmp(elem_blk_parms[i].elem_type,"SHELL",3) == 0) { elem_blk_parms[i].elem_type_val = SHELL; if (elem_blk_parms[i].num_nodes_per_elem == 2) {/* KLUDGE for 2D Shells*/ elem_blk_parms[i].num_sides = 2; elem_blk_parms[i].num_nodes_per_side[0] = 2; elem_blk_parms[i].num_nodes_per_side[1] = 2; } else if (elem_blk_parms[i].num_nodes_per_elem == 4) { elem_blk_parms[i].num_sides = 6; /* 2 Faces, 4 Edges */ elem_blk_parms[i].num_nodes_per_side[0] = 4; elem_blk_parms[i].num_nodes_per_side[1] = 4; elem_blk_parms[i].num_nodes_per_side[2] = 2; elem_blk_parms[i].num_nodes_per_side[3] = 2; elem_blk_parms[i].num_nodes_per_side[4] = 2; elem_blk_parms[i].num_nodes_per_side[5] = 2; } else if (elem_blk_parms[i].num_nodes_per_elem == 8 || elem_blk_parms[i].num_nodes_per_elem == 9) { elem_blk_parms[i].num_sides = 6; /* 2 Faces, 4 Edges */ elem_blk_parms[i].num_nodes_per_side[0] = elem_blk_parms[i].num_nodes_per_elem; /* 8 or 9 */ elem_blk_parms[i].num_nodes_per_side[1] = elem_blk_parms[i].num_nodes_per_elem; /* 8 or 9 */ elem_blk_parms[i].num_nodes_per_side[2] = 3; elem_blk_parms[i].num_nodes_per_side[3] = 3; elem_blk_parms[i].num_nodes_per_side[4] = 3; elem_blk_parms[i].num_nodes_per_side[5] = 3; } else { EL_NODE_COUNT_ERROR; } } else if (strncmp(elem_blk_parms[i].elem_type,"HEX",3) == 0) { elem_blk_parms[i].elem_type_val = HEX; elem_blk_parms[i].num_sides = 6; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 8) { /* 8-node bricks */ elem_blk_parms[i].num_nodes_per_side[0] = 4; elem_blk_parms[i].num_nodes_per_side[1] = 4; elem_blk_parms[i].num_nodes_per_side[2] = 4; elem_blk_parms[i].num_nodes_per_side[3] = 4; elem_blk_parms[i].num_nodes_per_side[4] = 4; elem_blk_parms[i].num_nodes_per_side[5] = 4; } else if (elem_blk_parms[i].num_nodes_per_elem == 9) { /* 9-node bricks */ elem_blk_parms[i].num_nodes_per_side[0] = 4; elem_blk_parms[i].num_nodes_per_side[1] = 4; elem_blk_parms[i].num_nodes_per_side[2] = 4; elem_blk_parms[i].num_nodes_per_side[3] = 4; elem_blk_parms[i].num_nodes_per_side[4] = 4; elem_blk_parms[i].num_nodes_per_side[5] = 4; } else if (elem_blk_parms[i].num_nodes_per_elem == 12) { /* HEXSHELLS */ elem_blk_parms[i].num_nodes_per_side[0] = 6; elem_blk_parms[i].num_nodes_per_side[1] = 6; elem_blk_parms[i].num_nodes_per_side[2] = 6; elem_blk_parms[i].num_nodes_per_side[3] = 6; elem_blk_parms[i].num_nodes_per_side[4] = 4; elem_blk_parms[i].num_nodes_per_side[5] = 4; } else if (elem_blk_parms[i].num_nodes_per_elem == 20) { /* 20-node bricks */ elem_blk_parms[i].num_nodes_per_side[0] = 8; elem_blk_parms[i].num_nodes_per_side[1] = 8; elem_blk_parms[i].num_nodes_per_side[2] = 8; elem_blk_parms[i].num_nodes_per_side[3] = 8; elem_blk_parms[i].num_nodes_per_side[4] = 8; elem_blk_parms[i].num_nodes_per_side[5] = 8; } else if (elem_blk_parms[i].num_nodes_per_elem == 27) { /* 27-node bricks */ elem_blk_parms[i].num_nodes_per_side[0] = 9; elem_blk_parms[i].num_nodes_per_side[1] = 9; elem_blk_parms[i].num_nodes_per_side[2] = 9; elem_blk_parms[i].num_nodes_per_side[3] = 9; elem_blk_parms[i].num_nodes_per_side[4] = 9; elem_blk_parms[i].num_nodes_per_side[5] = 9; } else { EL_NODE_COUNT_ERROR; } } else if (strncmp(elem_blk_parms[i].elem_type,"TETRA",3) == 0) { elem_blk_parms[i].elem_type_val = TETRA; elem_blk_parms[i].num_sides = 4; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) { elem_blk_parms[i].num_nodes_per_side[0] = 3; elem_blk_parms[i].num_nodes_per_side[1] = 3; elem_blk_parms[i].num_nodes_per_side[2] = 3; elem_blk_parms[i].num_nodes_per_side[3] = 3; } else if (elem_blk_parms[i].num_nodes_per_elem == 8) { elem_blk_parms[i].num_nodes_per_side[0] = 4; elem_blk_parms[i].num_nodes_per_side[1] = 4; elem_blk_parms[i].num_nodes_per_side[2] = 4; elem_blk_parms[i].num_nodes_per_side[3] = 4; } else if (elem_blk_parms[i].num_nodes_per_elem == 10) { elem_blk_parms[i].num_nodes_per_side[0] = 6; elem_blk_parms[i].num_nodes_per_side[1] = 6; elem_blk_parms[i].num_nodes_per_side[2] = 6; elem_blk_parms[i].num_nodes_per_side[3] = 6; } else { EL_NODE_COUNT_ERROR; } } else if (strncmp(elem_blk_parms[i].elem_type,"WEDGE",3) == 0) { elem_blk_parms[i].elem_type_val = WEDGE; elem_blk_parms[i].num_sides = 5; if (elem_blk_parms[i].num_nodes_per_elem == 6) { elem_blk_parms[i].num_nodes_per_side[0] = 4; elem_blk_parms[i].num_nodes_per_side[1] = 4; elem_blk_parms[i].num_nodes_per_side[2] = 4; elem_blk_parms[i].num_nodes_per_side[3] = 3; elem_blk_parms[i].num_nodes_per_side[4] = 3; } else if (elem_blk_parms[i].num_nodes_per_elem == 15){ elem_blk_parms[i].num_nodes_per_side[0] = 8; elem_blk_parms[i].num_nodes_per_side[1] = 8; elem_blk_parms[i].num_nodes_per_side[2] = 8; elem_blk_parms[i].num_nodes_per_side[3] = 6; elem_blk_parms[i].num_nodes_per_side[4] = 6; } else { EL_NODE_COUNT_ERROR; } } else if (strncmp(elem_blk_parms[i].elem_type,"PYRAMID",3) == 0) { elem_blk_parms[i].elem_type_val = PYRAMID; elem_blk_parms[i].num_sides = 5; if (elem_blk_parms[i].num_nodes_per_elem == 5) { elem_blk_parms[i].num_nodes_per_side[0] = 3; elem_blk_parms[i].num_nodes_per_side[1] = 3; elem_blk_parms[i].num_nodes_per_side[2] = 3; elem_blk_parms[i].num_nodes_per_side[3] = 3; elem_blk_parms[i].num_nodes_per_side[4] = 4; } else if (elem_blk_parms[i].num_nodes_per_elem == 13){ elem_blk_parms[i].num_nodes_per_side[0] = 6; elem_blk_parms[i].num_nodes_per_side[1] = 6; elem_blk_parms[i].num_nodes_per_side[2] = 6; elem_blk_parms[i].num_nodes_per_side[3] = 6; elem_blk_parms[i].num_nodes_per_side[4] = 8; } else { EL_NODE_COUNT_ERROR; } } else if (strncmp(elem_blk_parms[i].elem_type,"BEAM",3) == 0) { elem_blk_parms[i].elem_type_val = BEAM; elem_blk_parms[i].num_sides = 2; if (elem_blk_parms[i].num_nodes_per_elem == 2) { elem_blk_parms[i].num_nodes_per_side[0] = 2; elem_blk_parms[i].num_nodes_per_side[1] = 2; } else if (elem_blk_parms[i].num_nodes_per_elem == 3){ elem_blk_parms[i].num_nodes_per_side[0] = 3; elem_blk_parms[i].num_nodes_per_side[1] = 3; } else { EL_NODE_COUNT_ERROR; } } else if ( (strncmp(elem_blk_parms[i].elem_type,"TRUSS",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"BAR",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"EDGE",3) == 0) ) { elem_blk_parms[i].elem_type_val = TRUSS; elem_blk_parms[i].num_sides = 2; if (elem_blk_parms[i].num_nodes_per_elem == 2) { elem_blk_parms[i].num_nodes_per_side[0] = 2; elem_blk_parms[i].num_nodes_per_side[1] = 2; } else if (elem_blk_parms[i].num_nodes_per_elem == 3) { elem_blk_parms[i].num_nodes_per_side[0] = 3; elem_blk_parms[i].num_nodes_per_side[1] = 3; } else { EL_NODE_COUNT_ERROR; } } /* Used for an empty block in a parallel decomposition */ else if (strncmp(elem_blk_parms[i].elem_type,"NULL",3) == 0) { elem_blk_parms[i].elem_type_val = '\0'; elem_blk_parms[i].num_sides = 0; elem_blk_parms[i].num_nodes_per_side[0] = 0; elem_blk_parms[i].num_elem_in_blk = 0; } else { /* unsupported element type; no problem if no sides specified for this element block */ elem_blk_parms[i].elem_type_val = UNK; elem_blk_parms[i].num_sides = 0; elem_blk_parms[i].num_nodes_per_side[0] = 0; } elem_blk_parms[i].elem_blk_id = elem_blk_ids[i]; /* save id */ elem_ctr += elem_blk_parms[i].num_elem_in_blk; elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */ } /* Finally... Create the list of node counts for each face in the * side set. */ j = 0; /* The current element block... */ for (ii=0;ii<tot_num_ss_elem;ii++) { i = ss_elem_ndx[ii]; elem = side_set_elem_list[i]; side = side_set_side_list[i]-1; /* Convert to 0-based sides */ /* * Since the elements are being accessed in sorted, order, the * block that contains the elements must progress sequentially * from block 0 to block[num_elem_blks-1]. Once we find an element * not in this block, find a following block that contains it... */ for ( ; j<num_elem_blks; j++) { if (elem <= elem_blk_parms[j].elem_ctr) { break; } } if (j < num_elem_blks) { assert(side < elem_blk_parms[j].num_sides); side_set_node_cnt_list[i] = elem_blk_parms[j].num_nodes_per_side[side]; } else { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: Invalid element number %d found in side set %d in file %d", side_set_elem_list[i], side_set_id, exoid); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); ex_err("ex_get_side_set_node_count",errmsg,EX_MSG); return (EX_FATAL); } } /* All done: release connectivity array space, element block ids * array, element block parameters array, and side set element index * array */ free(elem_blk_ids); free(elem_blk_parms); free(ss_elem_ndx); free(side_set_side_list); free(side_set_elem_list); return(EX_NOERR); }
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); }
int ex_get_var_time( int exoid, int var_type, int var_index, int id, int beg_time_step, int end_time_step, void* var_vals ) { int i, dimid, varid, numel = 0, offset; nclong *obj_ids, *stat_vals; long num_obj, num_entries_this_obj = 0, start[2], count[2]; float fdum; char *cdum; char errmsg[MAX_ERR_LENGTH]; const char* tname; const char* dimnumobj; const char* varobjids; const char* varobstat; switch (var_type) { case EX_GLOBAL: return ex_get_glob_var_time( exoid, var_index, beg_time_step, end_time_step, var_vals ); case EX_NODAL: return ex_get_nodal_var_time( exoid, var_index, id, beg_time_step, end_time_step, var_vals ); case EX_EDGE_BLOCK: tname = "edge block"; dimnumobj = DIM_NUM_ED_BLK; varobjids = VAR_ID_ED_BLK; varobstat = VAR_STAT_ED_BLK; break; case EX_FACE_BLOCK: tname = "face block"; dimnumobj = DIM_NUM_FA_BLK; varobjids = VAR_ID_FA_BLK; varobstat = VAR_STAT_FA_BLK; break; case EX_ELEM_BLOCK: tname = "element block"; dimnumobj = DIM_NUM_EL_BLK; varobjids = VAR_ID_EL_BLK; varobstat = VAR_STAT_EL_BLK; break; case EX_NODE_SET: tname = "node set"; dimnumobj = DIM_NUM_NSET_VAR; varobjids = VAR_NS_IDS; varobstat = VAR_NS_STAT; break; case EX_EDGE_SET: tname = "edge set"; dimnumobj = DIM_NUM_ESET_VAR; varobjids = VAR_ES_IDS; varobstat = VAR_ES_STAT; break; case EX_FACE_SET: tname = "face set"; dimnumobj = DIM_NUM_FSET_VAR; varobjids = VAR_FS_IDS; varobstat = VAR_FS_STAT; break; case EX_SIDE_SET: tname = "side set"; dimnumobj = DIM_NUM_SSET_VAR; varobjids = VAR_SS_IDS; varobstat = VAR_SS_STAT; break; case EX_ELEM_SET: tname = "element set"; dimnumobj = DIM_NUM_ELSET_VAR; varobjids = VAR_ELS_IDS; varobstat = VAR_ELS_STAT; break; default: exerrval = EX_BADPARAM; sprintf( errmsg, "Error: Invalid variable type (%d) specified for file id %d", var_type, exoid ); ex_err( "ex_get_var_time", errmsg, exerrval ); return (EX_FATAL); } exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ /* assume entry number is 1-based (the first entry of an object is 1, not 0); * adjust so it is 0-based */ id--; /* find what object the entry is in */ /* first, find out how many objects there are */ if ((dimid = ncdimid (exoid, dimnumobj)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate number of %ss in file id %d", tname,exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } if (ncdiminq (exoid, dimid, (char *) 0, &num_obj) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of %ss in file id %d", tname,exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } /* get the array of object ids */ /* don't think we need this anymore since the netcdf variable names associated with objects don't contain the object ids */ if (!(obj_ids = malloc(num_obj*sizeof(nclong)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate memory for %s ids for file id %d", tname,exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } if ((varid = ncvarid (exoid, varobjids)) == -1) { exerrval = ncerr; free(obj_ids); sprintf(errmsg, "Error: failed to locate %s ids in file id %d", tname,exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } start[0] = 0; count[0] = num_obj; if (ncvarget (exoid, varid, start, count, obj_ids) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get %s ids from file id %d", tname,exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } /* allocate space for stat array */ if (!(stat_vals = malloc((int)num_obj*sizeof(nclong)))) { exerrval = EX_MEMFAIL; free (obj_ids); sprintf(errmsg, "Error: failed to allocate memory for %s status array for file id %d", tname,exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } /* get variable id of status array */ if ((varid = ncvarid (exoid, varobstat)) != -1) { /* if status array exists, use it, otherwise assume, object exists to be backward compatible */ start[0] = 0; start[1] = 0; count[0] = num_obj; count[1] = 0; if (ncvarget (exoid, varid, start, count, (void *)stat_vals) == -1) { exerrval = ncerr; free (obj_ids); free(stat_vals); sprintf(errmsg, "Error: failed to get %s status array from file id %d", tname,exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } } else /* default: status is true */ for(i=0;i<num_obj;i++) stat_vals[i]=1; /* loop through each object until id is found; since entry * numbers are sequential (beginning with 1) id is in obj_i * when id_first_i <= id <= id_last_i, where * id_first_i is the entry number of the first entry in * obj_i and id_last_i is the entry number of the last * entry in obj_i */ i = 0; if (stat_vals[i] != 0) { if ((dimid = ncdimid (exoid, ex_dim_num_entries_in_object(var_type,i+1))) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate number of entries in %s %d in file id %d", tname, obj_ids[i], exoid); ex_err("ex_get_var_time",errmsg,exerrval); free(stat_vals); free(obj_ids); return (EX_FATAL); } if (ncdiminq (exoid, dimid, (char *) 0, &num_entries_this_obj) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of entries in %s %d in file id %d", tname, obj_ids[i], exoid); ex_err("ex_get_var_time",errmsg,exerrval); free(stat_vals); free(obj_ids); return (EX_FATAL); } } /* End NULL object check */ numel = num_entries_this_obj; while (numel <= id) { if (stat_vals[++i] != 0) { if ((dimid = ncdimid(exoid,ex_dim_num_entries_in_object(var_type,i+1))) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate number of entries in %s %d in file id %d", tname, obj_ids[i], exoid); ex_err("ex_get_var_time",errmsg,exerrval); free(stat_vals); free(obj_ids); return (EX_FATAL); } if (ncdiminq (exoid, dimid, (char *) 0, &num_entries_this_obj) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of entries in %s %d in file id %d", tname, obj_ids[i], exoid); ex_err("ex_get_var_time",errmsg,exerrval); free(stat_vals); free(obj_ids); return (EX_FATAL); } numel += num_entries_this_obj; } } offset = id - (numel - num_entries_this_obj); /* inquire previously defined variable */ if((varid=ncvarid(exoid,ex_name_var_of_object(var_type,var_index,i+1))) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to locate variable %d for %s %d in file id %d", var_index,tname,obj_ids[i],exoid); ex_err("ex_get_var_time",errmsg,exerrval); free(stat_vals); free(obj_ids); return (EX_FATAL); } free(stat_vals); free(obj_ids); /* read values of object variable */ start[0] = --beg_time_step; start[1] = offset; if (end_time_step < 0) { /* user is requesting the maximum time step; we find this out using the * database inquire function to get the number of time steps; the ending * time step number is 1 less due to 0 based array indexing in C */ if (ex_inquire (exoid, EX_INQ_TIME, &end_time_step, &fdum, cdum) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get maximum time step in file id %d", exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } } end_time_step--; count[0] = end_time_step - beg_time_step + 1; count[1] = 1; if (ncvarget (exoid, varid, start, count, ex_conv_array(exoid,RTN_ADDRESS,var_vals,count[0])) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get %s variable values in file id %d", tname,exoid); ex_err("ex_get_var_time",errmsg,exerrval); return (EX_FATAL); } ex_conv_array( exoid, READ_CONVERT, var_vals, count[0] ); return (EX_NOERR); }
int main(int argc, char **argv) { int exoid, exoid2, num_dim, num_nodes, num_elem, num_elem_blk; int num_elem_in_block, num_node_sets, num_nodes_per_elem, num_attr; int num_side_sets, error; int i, j; int *elem_map, *connect, *node_list, *node_ctr_list, *elem_list, *side_list; int *ids; int num_nodes_in_set, num_elem_in_set; int num_sides_in_set, num_df_in_set; int num_qa_rec, num_info; int CPU_word_size, IO_word_size; int num_props, prop_value, *prop_values; float *x, *y, *z; float *dist_fact; float version, fdum; float attrib[1]; char *coord_names[3], *qa_record[2][4], *info[3]; char title[MAX_LINE_LENGTH + 1], elem_type[MAX_STR_LENGTH + 1]; char *prop_names[3]; char *cdum = 0; /* Specify compute and i/o word size */ CPU_word_size = 0; /* sizeof(float) */ IO_word_size = 4; /* float */ /* open EXODUS II file for reading */ ex_opts(EX_VERBOSE | EX_ABORT); exoid = ex_open("test.exo", /* filename path */ EX_READ, /* access mode */ &CPU_word_size, /* CPU float word size in bytes */ &IO_word_size, /* I/O float word size in bytes */ &version); /* returned version number */ printf("after ex_open for test.exo\n"); printf(" cpu word size: %d io word size: %d\n", CPU_word_size, IO_word_size); /* create EXODUS II file for writing */ exoid2 = ex_create("test2.exo", /* 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 test2.exo, exoid = %d\n", exoid2); /* read initialization 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 = %d\n", error); /* write initialization parameters */ error = ex_put_init(exoid2, title, num_dim, num_nodes, num_elem, num_elem_blk, num_node_sets, num_side_sets); printf("after ex_put_init, error = %d\n", error); /* read nodal coordinate values */ 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); /* write nodal coordinate values */ error = ex_put_coord(exoid2, x, y, z); printf("after ex_put_coord, error = %d\n", error); free(x); free(y); if (num_dim >= 3) free(z); /* read nodal coordinate names */ 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); /* write nodal coordinate names */ error = ex_put_coord_names(exoid2, coord_names); printf("after ex_put_coord_names, error = %d\n", error); for (i = 0; i < num_dim; i++) { free(coord_names[i]); } /* 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); /* write element order map */ error = ex_put_map(exoid2, elem_map); printf("after ex_put_map, error = %d\n", error); free(elem_map); /* read and write element block parameters and element connectivity */ ids = (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); attrib[0] = 3.14159; for (i = 0; i < num_elem_blk; i++) { error = ex_get_elem_block(exoid, ids[i], elem_type, &num_elem_in_block, &num_nodes_per_elem, &num_attr); printf("\nafter ex_get_elem_block, error = %d\n", error); error = ex_put_elem_block(exoid2, ids[i], elem_type, num_elem_in_block, num_nodes_per_elem, num_attr); printf("after ex_put_elem_block, error = %d\n", error); connect = (int *)calloc((num_nodes_per_elem * num_elem_in_block), sizeof(int)); error = ex_get_elem_conn(exoid, ids[i], connect); printf("\nafter ex_get_elem_conn, error = %d\n", error); error = ex_put_elem_conn(exoid2, ids[i], connect); printf("after ex_put_elem_conn, error = %d\n", error); /* write element block attributes */ error = ex_put_attr(exoid2, EX_ELEM_BLOCK, ids[i], attrib); printf("after ex_put_elem_attr, error = %d\n", error); free(connect); } /* read and write element block properties */ error = ex_inquire(exoid, EX_INQ_EB_PROP, &num_props, &fdum, cdum); printf("\nafter ex_inquire, error = %d\n", error); 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); error = ex_put_prop_names(exoid2, EX_ELEM_BLOCK, num_props, prop_names); printf("after ex_put_prop_names, error = %d\n", error); for (i = 0; i < num_props; i++) { for (j = 0; j < num_elem_blk; j++) { error = ex_get_prop(exoid, EX_ELEM_BLOCK, ids[j], prop_names[i], &prop_value); printf("after ex_get_prop, error = %d\n", error); if (i > 0) { /* first property is the ID which is already stored */ error = ex_put_prop(exoid2, EX_ELEM_BLOCK, ids[j], prop_names[i], prop_value); printf("after ex_put_prop, error = %d\n", error); } } } for (i = 0; i < num_props; i++) free(prop_names[i]); free(ids); /* read and write individual node sets */ 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++) { 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); error = ex_put_node_set_param(exoid2, ids[i], num_nodes_in_set, num_df_in_set); printf("after ex_put_node_set_param, error = %d\n", error); 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); error = ex_put_node_set(exoid2, ids[i], node_list); printf("after ex_put_node_set, error = %d\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); error = ex_put_node_set_dist_fact(exoid2, ids[i], dist_fact); printf("after ex_put_node_set, error = %d\n", error); } free(node_list); free(dist_fact); } 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); 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); error = ex_put_prop_names(exoid2, EX_NODE_SET, num_props, prop_names); printf("after ex_put_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); printf("after ex_get_prop_array, error = %d\n", error); error = ex_put_prop_array(exoid2, EX_NODE_SET, prop_names[i], prop_values); printf("after ex_put_prop_array, error = %d\n", error); } for (i = 0; i < num_props; i++) free(prop_names[i]); free(prop_values); /* read and write individual side sets */ 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++) { 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); error = ex_put_side_set_param(exoid2, ids[i], num_sides_in_set, num_df_in_set); printf("after ex_put_side_set_param, error = %d\n", error); /* 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_put_side_set(exoid2, ids[i], elem_list, side_list); printf("after ex_put_side_set, error = %d\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); error = ex_put_side_set_dist_fact(exoid2, ids[i], dist_fact); printf("after ex_put_side_set_dist_fact, error = %d\n", error); } 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); 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); printf("after ex_get_prop, error = %d\n", error); if (i > 0) { /* first property is ID so it is already stored */ error = ex_put_prop(exoid2, EX_SIDE_SET, ids[j], prop_names[i], prop_value); printf("after ex_put_prop, error = %d\n", error); } } } for (i = 0; i < num_props; i++) free(prop_names[i]); free(ids); /* read and write 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); error = ex_put_qa(exoid2, num_qa_rec, qa_record); printf("after ex_put_qa, error = %d\n", error); for (i = 0; i < num_qa_rec; i++) { for (j = 0; j < 4; j++) { free(qa_record[i][j]); } } /* read and write 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); error = ex_put_info(exoid2, num_info, info); printf("after ex_put_info, error = %d\n", error); for (i = 0; i < num_info; i++) { free(info[i]); } /* close the EXODUS files */ error = ex_close(exoid); printf("after ex_close, error = %d\n", error); error = ex_close(exoid2); printf("after ex_close (2), error = %d\n", error); return 0; }
int ex_cvt_nodes_to_sides(int exoid, int *num_elem_per_set, int *num_nodes_per_set, int *side_sets_elem_index, int *side_sets_node_index, int *side_sets_elem_list, int *side_sets_node_list, int *side_sets_side_list) { int i, j, k, m, n; int num_side_sets, num_elem_blks; int tot_num_elem = 0, tot_num_ss_elem = 0, elem_num = 0, ndim; int *elem_blk_ids, *connect = 0; int *ss_elem_ndx, *ss_elem_node_ndx, *ss_parm_ndx; int elem_ctr, node_ctr, elem_num_pos; int num_elem_in_blk, num_nodes_per_elem, num_node_per_side, num_attr; int *same_elem_type, el_type = -1; float fdum; char *cdum, elem_type[MAX_STR_LENGTH+1]; struct elem_blk_parm *elem_blk_parms; /* node to side translation tables - These tables are used to look up the side number based on the first and second node in the side/face list. The side node order is found in the original Exodus document, SAND87-2997. The element node order is found in the ExodusII document, SAND92-2137. These tables were generated by following the right-hand rule for determining the outward normal. Note: Only the more complex 3-D shapes require these tables, the simple shapes are trivial - the first node found is also the side number. */ /* 1 2 3 4 node 1 */ static int shell_table[2][8] = { {2,4, 3,1, 4,2, 1,3}, /* node 2 */ {1,2, 1,2, 1,2, 1,2} /* side # */ }; /* 1 2 3 4 node 1 */ static int shell_edge_table[2][8] = { {2,4, 3,1, 4,2, 1,3}, /* node 2 */ {3,6, 4,3, 5,4, 6,5} /* side # */ }; /* 1 2 3 node 1 */ static int trishell_table[2][6] = { {2,3, 3,1, 1,2}, /* node 2 */ {1,2, 1,2, 1,2} /* side # */ }; /* 1 2 3 4 node 1 */ static int tetra_table[2][12] = { {2,3,4, 1,3,4, 4,1,2, 1,2,3}, /* node 2 */ {1,4,3, 4,2,1, 2,3,4, 1,2,3} /* side # */ }; #if 0 static int wedge_table[2][18] = { /* 1 2 3 4 5 6 node 1 */ {2,4,3, 5,1,3, 6,1,2, 1,6,5, 6,2,4, 4,3,5}, /* node 2 */ {1,3,4, 1,4,2, 2,3,4, 1,3,5, 5,2,1, 5,3,2} /* side # */ }; #endif static int hex_table[2][24] = { /* 1 2 3 4 5 6 7 8 node 1 */ {4,2,5, 1,3,6, 7,4,2, 3,1,8, 6,8,1, 5,2,7, 8,6,3, 7,5,4},/* node 2 */ {5,1,4, 5,2,1, 2,3,5, 5,4,3, 6,4,1, 1,2,6, 6,2,3, 3,6,4} /* side # */ }; char errmsg[MAX_ERR_LENGTH]; (void)side_sets_elem_index; (void)side_sets_node_index; exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ /* first check if any side sets are specified */ /* inquire how many side sets have been stored */ if ((ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get number of side sets in file id %d",exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return(EX_FATAL); } if (num_side_sets == 0) { sprintf(errmsg, "Warning: no side sets defined in file id %d",exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,EX_WARN); return(EX_WARN); } if ((ex_inquire(exoid, EX_INQ_ELEM_BLK, &num_elem_blks, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get number of element blocks in file id %d",exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return(EX_FATAL); } if ((ex_inquire(exoid, EX_INQ_ELEM, &tot_num_elem, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get total number of elements in file id %d",exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return(EX_FATAL); } /* get the dimensionality of the coordinates; this is necessary to distinguish between 2d TRIs and 3d TRIs */ if ((ex_inquire(exoid, EX_INQ_DIM, &ndim, &fdum, cdum)) == -1) { sprintf(errmsg, "Error: failed to get dimensionality in file id %d",exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return(EX_FATAL); } /* First count up # of elements in the side sets*/ for (i=0;i<num_side_sets;i++) tot_num_ss_elem += num_elem_per_set[i]; /* Allocate space for the ss element index array */ if (!(ss_elem_ndx=malloc(tot_num_ss_elem*sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem sort array for file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return (EX_FATAL); } /* Sort side set element list into index array - non-destructive */ for (i=0;i<tot_num_ss_elem;i++) ss_elem_ndx[i] = i; /* init index array to current position */ ex_iqsort(side_sets_elem_list, ss_elem_ndx,tot_num_ss_elem); /* Allocate space for the element block ids */ if (!(elem_blk_ids=malloc(num_elem_blks*sizeof(int)))) { free(ss_elem_ndx); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for element block ids for file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return (EX_FATAL); } if (ex_get_elem_blk_ids(exoid, elem_blk_ids)) { free(elem_blk_ids); free(ss_elem_ndx); sprintf(errmsg, "Error: failed to get element block ids in file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,EX_MSG); return(EX_FATAL); } /* Allocate space for the element block params */ if (!(elem_blk_parms=malloc(num_elem_blks*sizeof(struct elem_blk_parm)))) { free(elem_blk_ids); free(ss_elem_ndx); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for element block params for file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return (EX_FATAL); } elem_ctr = 0; for (i=0; i<num_elem_blks; i++) { /* read in an element block parameter */ if ((ex_get_elem_block (exoid, elem_blk_ids[i], elem_type, &num_elem_in_blk, &num_nodes_per_elem, &num_attr)) == -1) { free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); sprintf(errmsg, "Error: failed to get element block %d parameters in file id %d", elem_blk_ids[i], exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,EX_MSG); return(EX_FATAL); } elem_blk_parms[i].num_elem_in_blk = num_elem_in_blk; elem_blk_parms[i].num_nodes_per_elem = num_nodes_per_elem; elem_blk_parms[i].num_attr = num_attr; for (m=0; m < (int)strlen(elem_type); m++) elem_blk_parms[i].elem_type[m] = (char) toupper((int)elem_type[m]); elem_blk_parms[i].elem_type[m] = '\0'; if (strncmp(elem_blk_parms[i].elem_type,"CIRCLE",3) == 0) { elem_blk_parms[i].elem_type_val = CIRCLE; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side[0] = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"SPHERE",3) == 0) { elem_blk_parms[i].elem_type_val = SPHERE; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side[0] = 1; } else if (strncmp(elem_blk_parms[i].elem_type,"QUAD",3) == 0) { elem_blk_parms[i].elem_type_val = QUAD; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side[0] = 2; else if (elem_blk_parms[i].num_nodes_per_elem == 5) elem_blk_parms[i].num_nodes_per_side[0] = 2; else elem_blk_parms[i].num_nodes_per_side[0] = 3; } else if (strncmp(elem_blk_parms[i].elem_type,"TRIANGLE",3) == 0) { elem_blk_parms[i].elem_type_val = TRIANGLE; /* determine side set node stride */ if (ndim == 2) /* 2d TRIs */ { if (elem_blk_parms[i].num_nodes_per_elem == 3) elem_blk_parms[i].num_nodes_per_side[0] = 2; else elem_blk_parms[i].num_nodes_per_side[0] = 3; } else if (ndim == 3) /* 3d TRIs */ { elem_blk_parms[i].elem_type_val = TRISHELL; elem_blk_parms[i].num_nodes_per_side[0] = elem_blk_parms[i].num_nodes_per_elem; } } else if (strncmp(elem_blk_parms[i].elem_type,"SHELL",3) == 0) { elem_blk_parms[i].elem_type_val = SHELL; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) { /* 2d SHELL; same as BEAM or TRUSS or BAR */ elem_blk_parms[i].num_nodes_per_side[0] = 2; elem_blk_parms[i].elem_type_val = BEAM; } else if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side[0] = 4; else elem_blk_parms[i].num_nodes_per_side[0] = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"HEX",3) == 0) { elem_blk_parms[i].elem_type_val = HEX; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 8) elem_blk_parms[i].num_nodes_per_side[0] = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 9) elem_blk_parms[i].num_nodes_per_side[0] = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 12) /* HEXSHELL */ elem_blk_parms[i].num_nodes_per_side[0] = 4; else if (elem_blk_parms[i].num_nodes_per_elem == 27) elem_blk_parms[i].num_nodes_per_side[0] = 9; else elem_blk_parms[i].num_nodes_per_side[0] = 8; } else if (strncmp(elem_blk_parms[i].elem_type,"TETRA",3) == 0) { elem_blk_parms[i].elem_type_val = TETRA; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 4) elem_blk_parms[i].num_nodes_per_side[0] = 3; else if (elem_blk_parms[i].num_nodes_per_elem == 8) elem_blk_parms[i].num_nodes_per_side[0] = 4; else elem_blk_parms[i].num_nodes_per_side[0] = 6; } else if (strncmp(elem_blk_parms[i].elem_type,"WEDGE",3) == 0) { elem_blk_parms[i].elem_type_val = WEDGE; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 6) elem_blk_parms[i].num_nodes_per_side[0] = 4; else elem_blk_parms[i].num_nodes_per_side[0] = 8; sprintf(errmsg, "Warning: WEDGE%d is assumed to have %d nodes per face", elem_blk_parms[i].num_nodes_per_elem, elem_blk_parms[i].num_nodes_per_side[0]); ex_err("ex_cvt_nodes_to_sides",errmsg,EX_MSG); } else if (strncmp(elem_blk_parms[i].elem_type,"PYRAMID",3) == 0) { elem_blk_parms[i].elem_type_val = PYRAMID; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 5) elem_blk_parms[i].num_nodes_per_side[0] = 4; else elem_blk_parms[i].num_nodes_per_side[0] = 8; sprintf(errmsg, "Warning: PYRAMID%d is assumed to have %d nodes per face", elem_blk_parms[i].num_nodes_per_elem, elem_blk_parms[i].num_nodes_per_side[0]); ex_err("ex_cvt_nodes_to_sides",errmsg,EX_MSG); } else if (strncmp(elem_blk_parms[i].elem_type,"BEAM",3) == 0) { elem_blk_parms[i].elem_type_val = BEAM; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) elem_blk_parms[i].num_nodes_per_side[0] = 2; else elem_blk_parms[i].num_nodes_per_side[0] = 3; } else if ( (strncmp(elem_blk_parms[i].elem_type,"TRUSS",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"BAR",3) == 0) || (strncmp(elem_blk_parms[i].elem_type,"EDGE",3) == 0) ) { elem_blk_parms[i].elem_type_val = TRUSS; /* determine side set node stride */ if (elem_blk_parms[i].num_nodes_per_elem == 2) elem_blk_parms[i].num_nodes_per_side[0] = 2; else elem_blk_parms[i].num_nodes_per_side[0] = 3; } else if (strncmp(elem_blk_parms[i].elem_type,"NULL",3) == 0) { elem_blk_parms[i].elem_type_val = NULL_ELEMENT; /* set side set node stride */ elem_blk_parms[i].num_nodes_per_side[0] = 0; } else { /* unsupported element type; no problem if no sides specified for this element block */ elem_blk_parms[i].elem_type_val = UNK; elem_blk_parms[i].num_nodes_per_side[0] = 0; } elem_blk_parms[i].elem_blk_id = elem_blk_ids[i]; /* save id */ elem_ctr += elem_blk_parms[i].num_elem_in_blk; elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */ } /* Allocate space for the ss element to element block parameter index array */ if (!(ss_parm_ndx=malloc(tot_num_ss_elem*sizeof(int)))) { free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem parms index for file id %d" , exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return (EX_FATAL); } /* Allocate space for the ss element to node list index array */ if (!(ss_elem_node_ndx=malloc((tot_num_ss_elem+1)*sizeof(int)))) { free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for side set elem to node index for file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return (EX_FATAL); } /* determine if each side set has uniform element types; this will be used to help determine the stride through the node list */ /* Allocate space for same element type flag array*/ if (!(same_elem_type=malloc(num_side_sets*sizeof(int)))) { free(ss_elem_ndx); exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for element type flag array for file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return (EX_FATAL); } elem_ctr = num_elem_per_set[0]; same_elem_type[0] = TRUE; for (i=0,k=0;i<tot_num_ss_elem;i++) { for (j=0; j<num_elem_blks; j++) { if (side_sets_elem_list[i] <= elem_blk_parms[j].elem_ctr) break; } if ( i == 0 ) { el_type = elem_blk_parms[j].elem_type_val; } /* determine which side set this element is in; assign to kth side set */ if ( i >= elem_ctr ) { elem_ctr += num_elem_per_set[++k]; el_type = elem_blk_parms[j].elem_type_val; same_elem_type[k] = TRUE; } if (el_type != elem_blk_parms[j].elem_type_val) same_elem_type[k] = FALSE; } /* Build side set element to node list index and side set element parameter index. */ node_ctr = 0; elem_ctr = num_elem_per_set[0]; for (i=0,k=0;i<tot_num_ss_elem;i++) { for (j=0; j<num_elem_blks; j++) { if (side_sets_elem_list[i] <= elem_blk_parms[j].elem_ctr) { ss_parm_ndx[i] = j; /* assign parameter block index */ break; } } ss_elem_node_ndx[i] = node_ctr; /* assign node list index */ /* determine which side set this element is in; assign to kth side set */ if (i >= elem_ctr) { /* skip over NULL side sets */ while (num_elem_per_set[++k] == 0); elem_ctr += num_elem_per_set[k]; } /* determine number of nodes per side */ if (((num_nodes_per_set[k] % num_elem_per_set[k]) == 0) && (same_elem_type[k])) { /* all side set elements are same type */ node_ctr += num_nodes_per_set[k] /num_elem_per_set[k]; } else { node_ctr += elem_blk_parms[j].num_nodes_per_side[0]; } } ss_elem_node_ndx[i] = node_ctr; /* assign node list index */ free(same_elem_type); /* All setup, ready to go ... */ elem_ctr=0; for (j=0; j < tot_num_ss_elem; j++) { if (side_sets_elem_list[ss_elem_ndx[j]] > elem_ctr) { /* release connectivity array space and get next one */ if (elem_ctr > 0) free(connect); /* Allocate space for the connectivity array for new element block */ if (!(connect= malloc(elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].num_elem_in_blk* elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].num_nodes_per_elem* sizeof(int)))) { exerrval = EX_MEMFAIL; sprintf(errmsg, "Error: failed to allocate space for connectivity array for file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } /* get connectivity array */ if (ex_get_elem_conn( exoid, elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, connect) == -1) { sprintf(errmsg, "Error: failed to get connectivity array for elem blk %d for file id %d", elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } elem_ctr = elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_ctr; } /* For the first node of each side in side set, using a linear search (of up to num_nodes_per_elem) of the connectivity array, locate the node position in the element. The first node position and the second node position are used with a element type specific table to determine the side. */ elem_num = side_sets_elem_list[ss_elem_ndx[j]]-1;/* element number 0-based*/ /* calculate the relative element number position in it's block*/ elem_num_pos = elem_num - (elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_ctr - elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].num_elem_in_blk); /* calculate the beginning of the node list for this element by using the ss_elem_node_ndx index into the side_sets_node_index and adding the element number position * number of nodes per elem */ num_nodes_per_elem = elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].num_nodes_per_elem; for (n=0; n<num_nodes_per_elem; n++) { /* find node in connectivity array that matches first node in side set */ if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]] == connect[num_nodes_per_elem*(elem_num_pos)+n]) { switch (elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_type_val) { case CIRCLE: case SPHERE: { /* simple case: 1st node number is same as side # */ side_sets_side_list[ss_elem_ndx[j]] = n+1; break; } case QUAD: case TRIANGLE: case TRUSS: case BEAM: { /* simple case: 1st node number is same as side # */ side_sets_side_list[ss_elem_ndx[j]] = n+1; break; } case TRISHELL: { /* use table to find which node to compare to next */ num_node_per_side = ss_elem_node_ndx[ss_elem_ndx[j]+1] - ss_elem_node_ndx[ss_elem_ndx[j]]; if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (trishell_table[0][2*n]-1)]) { /* Assume only front or back, no edges... */ side_sets_side_list[ss_elem_ndx[j]] = trishell_table[1][2*n]; } else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (trishell_table[0][2*n+1]-1)]) { /* Assume only front or back, no edges... */ side_sets_side_list[ss_elem_ndx[j]] = trishell_table[1][2*n+1]; } else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (trishell_table[0][2*n+2]-1)]) { /* Assume only front or back, no edges... */ side_sets_side_list[ss_elem_ndx[j]] = trishell_table[1][2*n+2]; } else { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: failed to find TRIANGULAR SHELL element %d, node %d in connectivity array %d for file id %d", side_sets_elem_list[ss_elem_ndx[j]], side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1], elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } break; } case SHELL: { /* use table to find which node to compare to next */ num_node_per_side = ss_elem_node_ndx[ss_elem_ndx[j]+1] - ss_elem_node_ndx[ss_elem_ndx[j]]; if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (shell_table[0][2*n]-1)]) { if (num_node_per_side >= 4) /* 4- or 8-node side (front or back face) */ side_sets_side_list[ss_elem_ndx[j]] = shell_table[1][2*n]; else /* 2- or 3-node side (edge of shell) */ side_sets_side_list[ss_elem_ndx[j]] = shell_edge_table[1][2*n]; } else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (shell_table[0][2*n+1]-1)]) { if (num_node_per_side >= 4) /* 4- or 8-node side (front or back face) */ side_sets_side_list[ss_elem_ndx[j]] = shell_table[1][2*n+1]; else /* 2- or 3-node side (edge of shell) */ side_sets_side_list[ss_elem_ndx[j]]=shell_edge_table[1][2*n+1]; } else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (shell_table[0][2*n+2]-1)]) { if (num_node_per_side >= 4) /* 4- or 8-node side (front or back face) */ side_sets_side_list[ss_elem_ndx[j]] = shell_table[1][2*n+2]; else /* 2- or 3-node side (edge of shell) */ side_sets_side_list[ss_elem_ndx[j]]=shell_edge_table[1][2*n+2]; } else { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: failed to find SHELL element %d, node %d in connectivity array %d for file id %d", side_sets_elem_list[ss_elem_ndx[j]], side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1], elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } break; } case HEX: { /* use table to find which node to compare to next */ if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (hex_table[0][3*n]-1)]) side_sets_side_list[ss_elem_ndx[j]] = hex_table[1][3*n]; else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (hex_table[0][3*n+1]-1)]) side_sets_side_list[ss_elem_ndx[j]] = hex_table[1][3*n+1]; else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (hex_table[0][3*n+2]-1)]) side_sets_side_list[ss_elem_ndx[j]] = hex_table[1][3*n+2]; else { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: failed to find HEX element %d, node %d in connectivity array %d for file id %d", side_sets_elem_list[ss_elem_ndx[j]], side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1], elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } break; } case TETRA: { /* use table to find which node to compare to next */ if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (tetra_table[0][3*n]-1)]) side_sets_side_list[ss_elem_ndx[j]] = tetra_table[1][3*n]; else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (tetra_table[0][3*n+1]-1)]) side_sets_side_list[ss_elem_ndx[j]] = tetra_table[1][3*n+1]; else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (tetra_table[0][3*n+2]-1)]) side_sets_side_list[ss_elem_ndx[j]] = tetra_table[1][3*n+2]; else { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: failed to find TETRA element %d, node %d in connectivity array %d for file id %d", side_sets_elem_list[ss_elem_ndx[j]], side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1], elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } break; } case PYRAMID: { /* NOTE: PYRAMID elements in side set node lists are currently not supported */ exerrval = EX_BADPARAM; sprintf(errmsg, "ERROR: unsupported PYRAMID element found in side set node list in file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } case WEDGE: { #if 1 /* NOTE: WEDGE elements in side set node lists are currently not supported */ exerrval = EX_BADPARAM; sprintf(errmsg, "ERROR: unsupported WEDGE element found in side set node list in file id %d", exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); #else /* use wedge_table to find which node to compare to next */ /* This section is commented out because Wedges are no longer supported !!!*/ if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (wedge_table[0][3*n]-1)]) side_sets_side_list[ss_elem_ndx[j]] = wedge_table[1][3*n]; else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (wedge_table[0][3*n+1]-1)]) side_sets_side_list[ss_elem_ndx[j]] = wedge_table[1][3*n+1]; else if (side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1] == connect[num_nodes_per_elem*(elem_num_pos)+ (wedge_table[0][3*n+2]-1)]) side_sets_side_list[ss_elem_ndx[j]] = wedge_table[1][3*n+2]; else { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: failed to find WEDGE element %d, node %d in connectivity array %d for file id %d", side_sets_elem_list[ss_elem_ndx[j]], side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]+1], elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } break; #endif } default: { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: %s is an unsupported element type", elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_type); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); return(EX_FATAL); } } break; /* done with this element */ } } if (n >= num_nodes_per_elem) /* did we find the node? */ { exerrval = EX_BADPARAM; sprintf(errmsg, "Error: failed to find element %d, node %d in element block %d for file id %d", side_sets_elem_list[ss_elem_ndx[j]], side_sets_node_list[ss_elem_node_ndx[ss_elem_ndx[j]]], elem_blk_parms[ss_parm_ndx[ss_elem_ndx[j]]].elem_blk_id, exoid); ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval); free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_FATAL); } } /* All done: release connectivity array space, element block ids array, element block parameters array, and side set element index array */ free(connect); free(ss_elem_node_ndx); free(ss_parm_ndx); free(elem_blk_parms); free(elem_blk_ids); free(ss_elem_ndx); return (EX_NOERR); }
int ex_get_concat_node_sets (int exoid, int *node_set_ids, int *num_nodes_per_set, int *num_df_per_set, int *node_sets_node_index, int *node_sets_df_index, int *node_sets_node_list, void *node_sets_dist_fact) { int i, num_node_sets, node_index_ctr, df_index_ctr; float fdum; char *cdum; float *flt_dist_fact; double *dbl_dist_fact; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ cdum = 0; /* initialize even though it is not used */ /* first check if any node sets are specified */ if (ncdimid (exoid, DIM_NUM_NS) == -1) { exerrval = ncerr; sprintf(errmsg, "Warning: failed to locate number of node sets in file id %d", exoid); ex_err("ex_get_concat_node_sets",errmsg,exerrval); return (EX_WARN); /* no node sets were defined */ } /* inquire how many node sets have been stored */ if ((ex_inquire(exoid, EX_INQ_NODE_SETS, &num_node_sets, &fdum, cdum)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get number of node sets in file id %d", exoid); ex_err("ex_get_concat_node_sets",errmsg,exerrval); return(EX_FATAL); } if ((ex_get_node_set_ids (exoid, node_set_ids)) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get node sets ids in file id %d",exoid); ex_err("ex_get_concat_node_sets",errmsg,exerrval); return(EX_FATAL); } node_index_ctr = 0; df_index_ctr = 0; for (i=0; i<num_node_sets; i++) { if ((ex_get_node_set_param(exoid, node_set_ids[i], &(num_nodes_per_set[i]), &(num_df_per_set[i]))) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get node set parameters in file id %d",exoid); ex_err("ex_get_concat_node_sets",errmsg,exerrval); return(EX_FATAL); } /* get nodes for this set */ if (num_nodes_per_set[i] > 0) { if (ex_get_node_set(exoid, node_set_ids[i], &(node_sets_node_list[node_index_ctr])) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get node set %d in file id %d", node_set_ids[i], exoid); ex_err("ex_get_concat_node_sets",errmsg,exerrval); return(EX_FATAL); } if (ex_comp_ws(exoid) == sizeof(float) ) /* 4-byte float word */ { /* get distribution factors for this set */ flt_dist_fact = node_sets_dist_fact; if (num_df_per_set[i] > 0) /* only get df if they exist */ { if (ex_get_node_set_dist_fact(exoid, node_set_ids[i], &(flt_dist_fact[df_index_ctr])) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get node set %d dist factors in file id %d", node_set_ids[i], exoid); ex_err("ex_get_concat_node_sets",errmsg,exerrval); return(EX_FATAL); } } } else if (ex_comp_ws(exoid) == sizeof(double) ) /* 8-byte float word */ { /* get distribution factors for this set */ dbl_dist_fact = node_sets_dist_fact; if (num_df_per_set[i] > 0) /* only get df if they exist */ { if (ex_get_node_set_dist_fact(exoid, node_set_ids[i], &(dbl_dist_fact[df_index_ctr])) == -1) { exerrval = ncerr; sprintf(errmsg, "Error: failed to get node set %d dist factors in file id %d", node_set_ids[i], exoid); ex_err("ex_get_concat_node_sets",errmsg,exerrval); return(EX_FATAL); } } } else { /* unknown floating point word size */ exerrval = EX_BADPARAM; sprintf(errmsg, "Error: unsupported floating point word size %d for file id %d", ex_comp_ws(exoid), exoid); ex_err("ex_get_concat_node_sets", errmsg, exerrval); return (EX_FATAL); } } /* update index arrays */ if (i < num_node_sets) { node_sets_node_index[i] = node_index_ctr; node_index_ctr += num_nodes_per_set[i]; /* keep running count */ if (num_df_per_set[i] > 0) /* only get df if they exist */ { node_sets_df_index[i] = df_index_ctr; df_index_ctr += num_df_per_set[i]; /* keep running count */ } else { node_sets_df_index[i] = -1; /* signal non-existence of df */ } } } return(EX_NOERR); }