void get_put_vars(int exo_file, ex_entity_type type, int num_blocks, int num_vars,
int num_time_steps, const std::vector<int> &num_per_block, const char* mname)
{
/* truth table */
if (debug) logger("\tTruth Table");
std::vector<int> truth_table(num_vars*num_blocks);
ex_get_truth_table(exo_file, type, num_blocks, num_vars,TOPTR(truth_table));
size_t num_entity = std::accumulate(num_per_block.begin(), num_per_block.end(), 0);
std::vector<double> scr(num_entity * num_time_steps);
std::vector<int> ids(num_blocks);
ex_get_ids(exo_file, type, TOPTR(ids));
char str[32];
for (int i=0; i < num_vars; i++) {
if (debug) logger("\tReading");
std::fill(scr.begin(), scr.end(), 0.0);
size_t n=0;
sprintf(str,mname,i+1);
for (int j=0; j<num_time_steps; j++){
for (int k=0; k<num_blocks; k++){
if (truth_table[num_vars*k+i]==1) {
ex_get_var(exo_file,j+1,type, i+1,ids[k],num_per_block[k],&scr[n]);
}
n=n+num_per_block[k];
}
}
if (debug) logger("\tWriting");
PutDbl(str,num_entity,num_time_steps,TOPTR(scr));
}
}
int main (int argc, char *argv[])
{
char
*str,**str2,*(*qa_records)[4],*line, *oname, *dot, *filename;
const char* ext=EXT;
int
i,j,k,n,n1,n2,cpu_word_size,io_word_size,exo_file,err,
num_axes,num_nodes,num_elements,num_blocks,
num_side_sets,num_node_sets,num_time_steps,
num_qa_lines,num_info_lines,num_global_vars,
num_nodal_vars,num_element_vars,num_nodeset_vars, num_sideset_vars,
*ids,*iscr,*num_elem_in_block,*junk,
*elem_list,*side_list,
*nsssides,*nssdfac,
*nnsnodes,*nnsdfac,
nstr2, has_ss_dfac;
float
exo_version;
double
*scr,*x,*y,*z;
oname=0;
/* process arguments */
for (j=1; j< argc; j++){
if ( strcmp(argv[j],"-t")==0){ /* write text file (*.m) */
del_arg(&argc,argv,j);
textfile=1;
j--;
continue;
}
if ( strcmp(argv[j],"-o")==0){ /* specify output file name */
del_arg(&argc,argv,j);
if ( argv[j] ){
oname=(char*)calloc(strlen(argv[j])+10,sizeof(char));
strcpy(oname,argv[j]);
del_arg(&argc,argv,j);
printf("output file: %s\n",oname);
}
else {
fprintf(stderr,"Invalid output file specification.\n");
return 2;
}
j--;
continue;
}
}
/* QA Info */
printf("%s: %s, %s\n", qainfo[0], qainfo[2], qainfo[1]);
/* usage message*/
if(argc != 2){
printf("%s [options] exodus_file_name.\n",argv[0]);
printf(" the exodus_file_name is required (exodusII only).\n");
printf(" Options:\n");
printf(" -t write a text (.m) file rather than a binary .mat\n");
printf(" -o output file name (rather than auto generate)\n");
printf(" ** note **\n");
printf("Binary files are written by default on all platforms with");
printf(" available libraries.\n");
exit(1);
}
/* open output file */
if ( textfile )
ext=".m";
if ( !oname ){
filename = (char*)malloc( strlen(argv[1])+10);
strcpy(filename,argv[1]);
dot=strrchr(filename,'.');
if ( dot ) *dot=0;
strcat(filename,ext);
}
else {
filename=oname;
}
if ( textfile ){
m_file = fopen(filename,"w");
if (!m_file ){
fprintf(stderr,"Unable to open %s\n",filename);
exit(1);
}
}
else {
mat_file = Mat_CreateVer(filename, NULL, MAT_FT_MAT5);
if (mat_file == NULL) {
fprintf(stderr,"Unable to create matlab file %s\n",filename);
exit(1);
}
}
/* word sizes */
cpu_word_size=sizeof(double);
io_word_size=0;
/* open exodus file */
exo_file=ex_open(argv[1],EX_READ,&cpu_word_size,&io_word_size,&exo_version);
if (exo_file < 0){
printf("error opening %s\n",argv[1]);
exit(1);
}
/* print */
fprintf(stderr,"translating %s to %s ...\n",argv[1],filename);
/* read database paramters */
line=(char *) calloc ((MAX_LINE_LENGTH+1),sizeof(char));
err = ex_get_init(exo_file,line,
&num_axes,&num_nodes,&num_elements,&num_blocks,
&num_node_sets,&num_side_sets);
num_qa_lines = ex_inquire_int(exo_file,EX_INQ_QA);
num_info_lines = ex_inquire_int(exo_file,EX_INQ_INFO);
num_time_steps = ex_inquire_int(exo_file,EX_INQ_TIME);
err=ex_get_variable_param(exo_file,EX_GLOBAL,&num_global_vars);
err=ex_get_variable_param(exo_file,EX_NODAL,&num_nodal_vars);
err=ex_get_variable_param(exo_file,EX_ELEM_BLOCK,&num_element_vars);
err=ex_get_variable_param(exo_file,EX_NODE_SET,&num_nodeset_vars);
err=ex_get_variable_param(exo_file,EX_SIDE_SET,&num_sideset_vars);
/* export paramters */
PutInt("naxes", 1, 1,&num_axes);
PutInt("nnodes", 1, 1,&num_nodes);
PutInt("nelems", 1, 1,&num_elements);
PutInt("nblks", 1, 1,&num_blocks);
PutInt("nnsets", 1, 1,&num_node_sets);
PutInt("nssets", 1, 1,&num_side_sets);
PutInt("nsteps", 1, 1,&num_time_steps);
PutInt("ngvars", 1, 1,&num_global_vars);
PutInt("nnvars", 1, 1,&num_nodal_vars);
PutInt("nevars", 1, 1,&num_element_vars);
PutInt("nnsvars", 1, 1,&num_nodeset_vars);
PutInt("nssvars", 1, 1,&num_sideset_vars);
/* allocate -char- scratch space*/
n = num_info_lines;
n = (n > num_global_vars) ? n : num_global_vars;
n = (n > num_nodal_vars) ? n : num_nodal_vars;
n = (n > num_element_vars) ? n : num_element_vars;
n = (n > num_blocks) ? n : num_blocks;
nstr2 = n;
str2= (char **) calloc (n,sizeof(char *));
for (i=0;i<nstr2;i++)
str2[i]=(char *) calloc ((MAX_LINE_LENGTH+1),sizeof(char));
str= (char *) calloc ((MAX_LINE_LENGTH+1)*n,sizeof(char));
/* title */
PutStr("Title",line);
#if 0
/* QA records */
if (num_qa_lines > 0 ){
qa_records =(char *(*)[4]) calloc (num_qa_lines*4,sizeof(char **));
for (i=0;i<num_qa_lines;i++)
for (j=0;j<4;j++)
qa_records[i][j]=(char *) calloc ((MAX_STR_LENGTH+1),sizeof(char));
err=ex_get_qa(exo_file,qa_records);
str[0]='\0';
for (i=0;i<num_qa_lines;i++){
for (j=0;j<4;j++)
sprintf(str+strlen(str),"%s ",qa_records[i][j]);
strcat(str,"\n");
}
for (i=0;i<num_qa_lines;i++){
for (j=0;j<4;j++)
free(qa_records[i][j]);
}
free(qa_records);
}
/* information records */
if (num_info_lines > 0 ){
err = ex_get_info(exo_file,str2);
str[0]='\0';
for (i=0;i<num_info_lines;i++)
sprintf(str+strlen(str),"%s\n",str2[i]);
PutStr("info",str);
str[0]='\0';
for (i=0;i<num_info_lines;i++)
if (strncmp(str2[i],"cavi",4)==0)
sprintf(str+strlen(str),"%s\n",str2[i]);
PutStr("cvxp",str);
}
#endif
/* nodal coordinates */
x = (double *) calloc(num_nodes,sizeof(double));
y = (double *) calloc(num_nodes,sizeof(double));
if (num_axes == 3)
z = (double *) calloc(num_nodes,sizeof(double));
else
z = NULL;
err = ex_get_coord(exo_file,x,y,z);
PutDbl("x0", num_nodes, 1, x);
PutDbl("y0", num_nodes, 1, y);
free(x);
free(y);
if (num_axes == 3){
PutDbl("z0",num_nodes,1, z);
free(z);
}
/* side sets */
if(num_side_sets > 0){
ids=(int *) calloc(num_side_sets,sizeof(int));
err = ex_get_ids(exo_file,EX_SIDE_SET,ids);
PutInt( "ssids",num_side_sets, 1,ids);
nsssides = (int *) calloc(num_side_sets,sizeof(int)); /*dgriffi */
nssdfac = (int *) calloc(num_side_sets,sizeof(int)); /*dgriffi */
for (i=0;i<num_side_sets;i++){
err = ex_get_set_param(exo_file,EX_SIDE_SET, ids[i],&n1,&n2);
nsssides[i]=n1; /* dgriffi */
nssdfac[i]=n2; /* dgriffi */
/*
* the following provision is from Version 1.6 when there are no
* distribution factors in exodus file
*/
has_ss_dfac = (n2 != 0);
if(n2==0 || n1==n2){
printf(" WARNING: Exodus II file does not contain distribution factors.\n");
/* n1=number of faces, n2=number of df */
/* using distribution factors to determine number of nodes in the sideset
causes a lot grief since some codes do not output distribution factors
if they are all equal to 1. mkbhard: I am using the function call below
to figure out the total number of nodes in this sideset. Some redundancy
exists, but it works for now */
junk = (int*) calloc(n1,sizeof(int));
err = ex_get_side_set_node_count(exo_file,ids[i],junk);
n2=0; /* n2 will be equal to the total number of nodes in the sideset */
for (j=0;j<n1;j++) n2+=junk[j];
free(junk);
}
iscr = (int *) calloc(n1+n2,sizeof(int));
err = ex_get_side_set_node_list(exo_file,ids[i],iscr,iscr+n1);
/* number-of-nodes-per-side list */
sprintf(str,"ssnum%02d",i+1);
PutInt(str,n1,1,iscr);
/* nodes list */
sprintf(str,"ssnod%02d",i+1);
PutInt(str,n2,1,iscr+n1);
free(iscr);
/* distribution-factors list */
scr = (double *) calloc (n2,sizeof(double));
if (has_ss_dfac) {
ex_get_side_set_dist_fact(exo_file,ids[i],scr);
} else {
for (j=0; j<n2; j++) {
scr[j] = 1.0;
}
}
sprintf(str,"ssfac%02d",i+1);
PutDbl(str,n2,1,scr);
free(scr);
/* element and side list for side sets (dgriffi) */
elem_list = (int *) calloc(n1, sizeof(int));
side_list = (int *) calloc(n1, sizeof(int));
err = ex_get_set(exo_file,EX_SIDE_SET,ids[i],elem_list,side_list);
sprintf(str,"ssside%02d",i+1);
PutInt(str,n1,1,side_list);
sprintf(str,"sselem%02d",i+1);
PutInt(str,n1,1,elem_list);
free(elem_list);
free(side_list);
}
/* Store # sides and # dis. factors per side set (dgriffi) */
PutInt("nsssides",num_side_sets,1,nsssides);
PutInt("nssdfac",num_side_sets,1,nssdfac);
free(ids);
free(nsssides);
free(nssdfac);
}
/* node sets (section by dgriffi) */
if(num_node_sets > 0){
ids=(int *) calloc(num_node_sets,sizeof(int));
err = ex_get_ids(exo_file,EX_NODE_SET, ids);
PutInt( "nsids",num_node_sets, 1,ids);
nnsnodes = (int *) calloc(num_node_sets,sizeof(int));
nnsdfac = (int *) calloc(num_node_sets,sizeof(int));
for (i=0;i<num_node_sets;i++){
err = ex_get_set_param(exo_file,EX_NODE_SET,ids[i],&n1,&n2);
iscr = (int *) calloc(n1,sizeof(int));
err = ex_get_node_set(exo_file,ids[i],iscr);
/* nodes list */
sprintf(str,"nsnod%02d",i+1);
PutInt(str,n1,1,iscr);
free(iscr);
/* distribution-factors list */
scr = (double *) calloc (n2,sizeof(double));
ex_get_node_set_dist_fact(exo_file,ids[i],scr);
sprintf(str,"nsfac%02d",i+1);
PutDbl(str,n2,1,scr);
free(scr);
nnsnodes[i]=n1;
nnsdfac[i]=n2;
}
/* Store # nodes and # dis. factors per node set */
PutInt("nnsnodes",num_node_sets,1,nnsnodes);
PutInt("nnsdfac",num_node_sets,1,nnsdfac);
free(ids);
free(nnsdfac);
free(nnsnodes);
}
/* element blocks */
ids=(int *) calloc(num_blocks,sizeof(int));
num_elem_in_block=(int *) calloc(num_blocks,sizeof(int));
err = ex_get_ids(exo_file,EX_ELEM_BLOCK,ids);
PutInt( "blkids",num_blocks, 1,ids);
for (i=0;i<num_blocks;i++) {
err = ex_get_elem_block(exo_file,ids[i],str2[i],&n,&n1,&n2);
num_elem_in_block[i]=n;
iscr = (int *) calloc(n*n1,sizeof(int));
err = ex_get_conn(exo_file,EX_ELEM_BLOCK,ids[i],iscr, NULL, NULL);
sprintf(str,"blk%02d",i+1);
PutInt(str,n1,n,iscr);
free(iscr);
}
str[0]='\0';
for (i=0;i<num_blocks;i++)
sprintf(str+strlen(str),"%s\n",str2[i]);
PutStr("blknames",str);
/* time values */
if (num_time_steps > 0 ) {
scr = (double *) calloc (num_time_steps,sizeof(double));
err= ex_get_all_times (exo_file,scr);
PutDbl( "time", num_time_steps, 1,scr);
free(scr);
}
/* global variables */
if (num_global_vars > 0 ) {
err = ex_get_variable_names(exo_file,EX_GLOBAL,num_global_vars,str2);
str[0]='\0';
for (i=0;i<num_global_vars;i++)
sprintf(str+strlen(str),"%s\n",str2[i]);
PutStr("gnames",str);
scr = (double *) calloc (num_time_steps,sizeof(double));
for (i=0;i<num_global_vars;i++){
sprintf(str,"gvar%02d",i+1);
err=ex_get_glob_var_time(exo_file,i+1,1,num_time_steps,scr);
PutDbl(str,num_time_steps,1,scr);
}
free(scr);
}
/* nodal variables */
if (num_nodal_vars > 0 ) {
err = ex_get_variable_names(exo_file,EX_NODAL,num_nodal_vars,str2);
str[0]='\0';
for (i=0;i<num_nodal_vars;i++)
sprintf(str+strlen(str),"%s\n",str2[i]);
PutStr("nnames",str);
scr = (double *) calloc (num_nodes*num_time_steps,sizeof(double));
for (i=0;i<num_nodal_vars;i++){
sprintf(str,"nvar%02d",i+1);
for (j=0;j<num_time_steps;j++)
err=ex_get_nodal_var(exo_file,j+1,i+1,num_nodes,
scr+num_nodes*j);
PutDbl(str,num_nodes,num_time_steps,scr);
}
free(scr);
}
/* element variables */
if (num_element_vars > 0 ) {
err = ex_get_variable_names(exo_file,EX_ELEM_BLOCK,num_element_vars,str2);
str[0]='\0';
for (i=0;i<num_element_vars;i++)
sprintf(str+strlen(str),"%s\n",str2[i]);
PutStr("enames",str);
/* truth table */
iscr = (int *) calloc(num_element_vars*num_blocks, sizeof(int));
ex_get_elem_var_tab(exo_file,num_blocks,num_element_vars,iscr);
for (i=0;i<num_element_vars;i++){
scr = (double *) calloc (num_elements*num_time_steps,sizeof(double));
n=0;
sprintf(str,"evar%02d",i+1);
for (j=0;j<num_time_steps;j++){
for (k=0;k<num_blocks;k++){
if(iscr[num_element_vars*k+i]==1)
ex_get_elem_var(exo_file,j+1,i+1,ids[k],num_elem_in_block[k],scr+n);
n=n+num_elem_in_block[k];
}
}
PutDbl(str,num_elements,num_time_steps,scr);
free(scr);
}
free(iscr);
}
free(num_elem_in_block);
free(ids);
/* node and element number maps */
ex_opts(0); /* turn off error reporting. It is not an error to have no map*/
ids = (int *)malloc(num_nodes*sizeof(int));
err = ex_get_node_num_map(exo_file,ids);
if ( err==0 ){
PutInt("node_num_map",num_nodes,1,ids);
}
free(ids);
ids = (int *)malloc(num_elements*sizeof(int));
err = ex_get_elem_num_map(exo_file,ids);
if ( err==0 ){
PutInt("elem_num_map",num_elements,1,ids);
}
free(ids);
/* close exo file */
ex_close(exo_file);
/* close mat file */
if ( textfile )
fclose(m_file);
else
Mat_Close(mat_file);
/* */
fprintf(stderr,"done.\n");
free(filename);
free(line);
free(str);
for (i=0;i<nstr2;i++)
free(str2[i]);
free(str2);
/* exit status */
add_to_log("exo2mat", 0);
return(0);
}
int read_exo_weights(Problem_Description* prob, Weight_Description<INT>* weight)
{
int exoid, cpu_ws=0, io_ws=0;
int neblks;
float version, minval = 1.0f;
char elem_type[MAX_STR_LENGTH+1];
char ctemp[1024];
/*---------------------------Execution Begins--------------------------------*/
/* Open the ExodusII file containing the weights */
int mode = EX_READ | prob->int64api;
if((exoid=ex_open(weight->exo_filename.c_str(), mode, &cpu_ws, &io_ws,
&version)) < 0)
{
sprintf(ctemp, "fatal: could not open ExodusII file %s",
weight->exo_filename.c_str());
Gen_Error(0, ctemp);
return 0;
}
std::vector<float> values(weight->nvals);
if(prob->type == NODAL)
{
size_t tmp_nodes = ex_inquire_int(exoid, EX_INQ_NODES);
/* check to make sure the sizes agree */
if ((size_t)weight->nvals != tmp_nodes) {
Gen_Error(0, "fatal: different number of nodes in mesh and weight files");
ex_close(exoid);
return 0;
}
weight->ow.resize(weight->nvals);
/* Read in the nodal values */
if(ex_get_nodal_var(exoid, weight->exo_tindx, weight->exo_vindx,
weight->nvals, TOPTR(values)) < 0)
{
Gen_Error(0, "fatal: unable to read nodal values");
ex_close(exoid);
return 0;
}
}
else
{
size_t tmp_elem = ex_inquire_int(exoid, EX_INQ_ELEM);
/* check to make sure the sizes agree */
if ((size_t)weight->nvals != tmp_elem) {
Gen_Error(0, "fatal: different number of elems in mesh and weight files");
ex_close(exoid);
return 0;
}
/* Get the number of element blocks */
neblks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
std::vector<INT> eblk_ids(neblks);
std::vector<INT> eblk_ecnts(neblks);
if(ex_get_ids(exoid, EX_ELEM_BLOCK, &eblk_ids[0]) < 0)
{
Gen_Error(0, "fatal: unable to get element block IDs");
ex_close(exoid);
return 0;
}
/* Get the count of elements in each element block */
for(int cnt=0; cnt < neblks; cnt++) {
INT dum1, dum2;
if(ex_get_elem_block(exoid, eblk_ids[cnt], elem_type,
&(eblk_ecnts[cnt]), &dum1, &dum2) < 0)
{
Gen_Error(0, "fatal: unable to get element block");
ex_close(exoid);
return 0;
}
}
/* Get the element variables */
size_t offset = 0;
for(int cnt=0; cnt < neblks; cnt++)
{
if(ex_get_elem_var(exoid, weight->exo_tindx, weight->exo_vindx,
eblk_ids[cnt], eblk_ecnts[cnt], &(values[offset])) < 0)
{
Gen_Error(0, "fatal: unable to get element variable");
ex_close(exoid);
return 0;
}
offset += eblk_ecnts[cnt];
}
}
/* Close the ExodusII weighting file */
if(ex_close(exoid) < 0)
{
sprintf(ctemp, "warning: failed to close ExodusII file %s",
weight->exo_filename.c_str());
Gen_Error(0, ctemp);
}
/* now I need to translate the values to positive integers */
/* first find the minimum value */
minval = *std::min_element(values.begin(), values.end());
/* now translate the values to be greater than 1 and convert to ints */
for (int cnt=0; cnt < weight->nvals; cnt++) {
values[cnt] += 1.0 - minval;
weight->vertices[cnt] = roundfloat(values[cnt]);
}
return 1;
} /*------------------------End read_exo_weights()----------------------*/
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_side_set_node_list(int exoid, ex_entity_id side_set_id, void_int *side_set_node_cnt_list,
void_int *side_set_node_list)
{
size_t i, j;
int64_t elem, side;
int64_t num_side_sets, num_elem_blks, num_df, ndim;
int64_t tot_num_elem = 0, tot_num_ss_elem = 0, elem_num = 0;
size_t connect_offset, side_num, node_pos;
void_int *elem_blk_ids = NULL;
void_int *connect = NULL;
void_int *ss_elem_ndx = NULL;
void_int *ss_elem_node_ndx = NULL;
void_int *ss_parm_ndx = NULL;
void_int *side_set_elem_list = NULL;
void_int *side_set_side_list = NULL;
size_t elem_ctr, node_ctr, elem_num_pos;
size_t num_nodes_per_elem;
int int_size, ids_size;
int err_stat = EX_NOERR;
int status;
struct elem_blk_parm *elem_blk_parms = NULL;
/* 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, 4}, /* side 1 */
{2, 3, 5}, /* side 2 */
{3, 1, 6} /* side 3 */
};
/* triangle 3d */
static int tri3_table[5][7] = {
{1, 2, 3, 4, 5, 6, 7}, /* side 1 (face) */
{3, 2, 1, 6, 5, 4, 7}, /* side 2 (face) */
{1, 2, 4, 0, 0, 0, 0}, /* side 3 (edge) */
{2, 3, 5, 0, 0, 0, 0}, /* side 4 (edge) */
{3, 1, 6, 0, 0, 0, 0} /* side 5 (edge) */
};
/* quad */
static int quad_table[4][3] = {
{1, 2, 5}, /* side 1 */
{2, 3, 6}, /* side 2 */
{3, 4, 7}, /* side 3 */
{4, 1, 8} /* side 4 */
};
/* shell */
static int shell_table[6][9] = {
{1, 2, 3, 4, 5, 6, 7, 8, 9}, /* side 1 (face) */
{1, 4, 3, 2, 8, 7, 6, 5, 9}, /* side 2 (face) */
{1, 2, 5, 0, 0, 0, 0, 0, 0}, /* side 3 (edge) */
{2, 3, 6, 0, 0, 0, 0, 0, 0}, /* side 4 (edge) */
{3, 4, 7, 0, 0, 0, 0, 0, 0}, /* side 5 (edge) */
{4, 1, 8, 0, 0, 0, 0, 0, 0} /* side 6 (edge) */
};
/* tetra */
static int tetra_table[4][7] = {
{1, 2, 4, 5, 9, 8, 14}, /* Side 1 nodes */
{2, 3, 4, 6, 10, 9, 12}, /* Side 2 nodes */
{1, 4, 3, 8, 10, 7, 13}, /* Side 3 nodes */
{1, 3, 2, 7, 6, 5, 11} /* Side 4 nodes */
};
/* wedge */
/* wedge 6 or 7 */
static int wedge6_table[5][4] = {
{1, 2, 5, 4}, /* Side 1 nodes -- quad */
{2, 3, 6, 5}, /* Side 2 nodes -- quad */
{1, 4, 6, 3}, /* Side 3 nodes -- quad */
{1, 3, 2, 0}, /* Side 4 nodes -- triangle */
{4, 5, 6, 0} /* Side 5 nodes -- triangle */
};
/* wedge 15 or 16 */
static int wedge15_table[5][8] = {
{1, 2, 5, 4, 7, 11, 13, 10}, /* Side 1 nodes -- quad */
{2, 3, 6, 5, 8, 12, 14, 11}, /* Side 2 nodes -- quad */
{1, 4, 6, 3, 10, 15, 12, 9}, /* Side 3 nodes -- quad */
{1, 3, 2, 9, 8, 7, 0, 0}, /* Side 4 nodes -- triangle */
{4, 5, 6, 13, 14, 15, 0, 0} /* Side 5 nodes -- triangle */
};
/* wedge 20 */
static int wedge20_table[5][9] = {
{1, 2, 5, 4, 7, 11, 13, 10, 20}, /* Side 1 nodes -- quad */
{2, 3, 6, 5, 8, 12, 14, 11, 18}, /* Side 2 nodes -- quad */
{1, 4, 6, 3, 10, 15, 12, 9, 19}, /* Side 3 nodes -- quad */
{1, 3, 2, 9, 8, 7, 16, 0, 0}, /* Side 4 nodes -- triangle */
{4, 5, 6, 13, 14, 15, 17, 0, 0} /* Side 5 nodes -- triangle */
};
/* wedge 21 */
static int wedge21_table[5][9] = {
{1, 2, 5, 4, 7, 11, 13, 10, 21}, /* Side 1 nodes -- quad */
{2, 3, 6, 5, 8, 12, 14, 11, 19}, /* Side 2 nodes -- quad */
{1, 4, 6, 3, 10, 15, 12, 9, 20}, /* Side 3 nodes -- quad */
{1, 3, 2, 9, 8, 7, 17, 0, 0}, /* Side 4 nodes -- triangle */
{4, 5, 6, 13, 14, 15, 18, 0, 0} /* Side 5 nodes -- triangle */
};
/* wedge 18 */
static int wedge18_table[5][9] = {
{1, 2, 5, 4, 7, 11, 13, 10, 16}, /* Side 1 nodes -- quad */
{2, 3, 6, 5, 8, 12, 14, 11, 17}, /* Side 2 nodes -- quad */
{1, 4, 6, 3, 10, 15, 12, 9, 18}, /* Side 3 nodes -- quad */
{1, 3, 2, 9, 8, 7, 0, 0, 0}, /* Side 4 nodes -- triangle */
{4, 5, 6, 13, 14, 15, 0, 0, 0} /* Side 5 nodes -- triangle */
};
/* hex */
static int hex_table[6][9] = {
{1, 2, 6, 5, 9, 14, 17, 13, 26}, /* side 1 */
{2, 3, 7, 6, 10, 15, 18, 14, 25}, /* side 2 */
{3, 4, 8, 7, 11, 16, 19, 15, 27}, /* side 3 */
{1, 5, 8, 4, 13, 20, 16, 12, 24}, /* side 4 */
{1, 4, 3, 2, 12, 11, 10, 9, 22}, /* side 5 */
{5, 6, 7, 8, 17, 18, 19, 20, 23} /* side 6 */
};
/* pyramid */
static int pyramid_table[5][9] = {
{1, 2, 5, 0, 6, 11, 10, 0, 15}, /* side 1 (tri) */
{2, 3, 5, 0, 7, 12, 11, 0, 16}, /* side 2 (tri) */
{3, 4, 5, 0, 8, 13, 12, 0, 17}, /* side 3 (tri) */
{1, 5, 4, 0, 10, 13, 9, 0, 18}, /* side 4 (tri) */
{1, 4, 3, 2, 9, 8, 7, 6, 14} /* side 5 (quad) */
};
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS);
if (num_side_sets < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "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) {
snprintf(errmsg, MAX_ERR_LENGTH, "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, EX_SIDE_SET, side_set_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: side set %" PRId64 " is NULL in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_list", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate side set %" PRId64 " 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);
}
num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
if (num_elem_blks < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "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);
}
tot_num_elem = ex_inquire_int(exoid, EX_INQ_ELEM);
if (tot_num_elem < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "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 */
ndim = ex_inquire_int(exoid, EX_INQ_DIM);
if (ndim < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get dimensionality in file id %d", exoid);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
return (EX_FATAL);
}
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
ids_size = sizeof(int);
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
ids_size = sizeof(int64_t);
}
/* First determine the # of elements in the side set*/
if (int_size == sizeof(int64_t)) {
status = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &tot_num_ss_elem, &num_df);
}
else {
int tot, df;
status = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &tot, &df);
tot_num_ss_elem = tot;
num_df = df;
}
if (status != EX_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of elements in side set %" PRId64 " 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 = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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 = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"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);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_set(exoid, EX_SIDE_SET, side_set_id, side_set_elem_list, side_set_side_list) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the ss element index array */
if (!(ss_elem_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
err_stat = EX_FATAL;
goto cleanup;
}
/* Sort side set element list into index array - non-destructive */
if (int_size == sizeof(int64_t)) {
/* Sort side set element list into index array - non-destructive */
int64_t *elems = (int64_t *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort64(side_set_elem_list, ss_elem_ndx, tot_num_ss_elem);
}
else {
/* Sort side set element list into index array - non-destructive */
int *elems = (int *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[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 * ids_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate space for element block ids for file id %d", exoid);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element block ids in file id %d", exoid);
ex_err("ex_get_side_set_node_list", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the element block params */
if (!(elem_blk_parms = malloc(num_elem_blks * sizeof(struct elem_blk_parm)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block params "
"for file id %d",
exoid);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = 0;
for (i = 0; i < num_elem_blks; i++) {
ex_entity_id id;
if (ids_size == sizeof(int64_t)) {
id = ((int64_t *)elem_blk_ids)[i];
}
else {
id = ((int *)elem_blk_ids)[i];
}
err_stat = ex_int_get_block_param(exoid, id, ndim, &elem_blk_parms[i]);
if (err_stat != EX_NOERR) {
goto cleanup;
}
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 * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the ss element to node list index array */
if (!(ss_elem_node_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
err_stat = EX_FATAL;
goto cleanup;
}
/* 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++) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
elem = ((int64_t *)side_set_elem_list)[i];
side = ((int64_t *)side_set_side_list)[i];
}
else {
elem = ((int *)side_set_elem_list)[i];
side = ((int *)side_set_side_list)[i];
}
for (j = 0; j < num_elem_blks; j++) {
if (elem_blk_parms[j].elem_type_val != EX_EL_NULL_ELEMENT) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
}
if (j >= num_elem_blks) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: Invalid element number %" PRId64 " found in side set %" PRId64 " in file %d",
elem, side_set_id, exoid);
ex_err("ex_get_side_set_node_list", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
if (int_size == sizeof(int64_t)) {
((int64_t *)ss_parm_ndx)[i] = j; /* assign parameter block index */
((int64_t *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
}
else {
((int *)ss_parm_ndx)[i] = j; /* assign parameter block index */
((int *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
}
/* Update node_ctr (which points to next node in chain */
node_ctr += elem_blk_parms[j].num_nodes_per_side[side - 1];
}
/* All setup, ready to go ... */
elem_ctr = 0;
for (j = 0; j < tot_num_ss_elem; j++) {
int64_t elem_ndx;
size_t parm_ndx;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
elem_ndx = ((int64_t *)ss_elem_ndx)[j];
elem = ((int64_t *)side_set_elem_list)[elem_ndx];
side = ((int64_t *)side_set_side_list)[elem_ndx];
parm_ndx = ((int64_t *)ss_parm_ndx)[elem_ndx];
}
else {
elem_ndx = ((int *)ss_elem_ndx)[j];
elem = ((int *)side_set_elem_list)[elem_ndx];
side = ((int *)side_set_side_list)[elem_ndx];
parm_ndx = ((int *)ss_parm_ndx)[elem_ndx];
}
if (elem > 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[parm_ndx].num_elem_in_blk *
elem_blk_parms[parm_ndx].num_nodes_per_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for connectivity "
"array for file id %d",
exoid);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* get connectivity array */
if (ex_get_conn(exoid, EX_ELEM_BLOCK, elem_blk_parms[parm_ndx].elem_blk_id, connect, NULL,
NULL) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for connectivity "
"array for file id %d",
exoid);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = elem_blk_parms[parm_ndx].elem_ctr;
}
if (connect == NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: internal error -- connect pointer is NULL for file id %d", exoid);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* For each side in side set, use the appropriate lookup table to
determine the nodes from the connect array. */
elem_num = elem - 1; /* element number 0-based*/
/* calculate the relative element number position in it's block*/
elem_num_pos =
elem_num - (elem_blk_parms[parm_ndx].elem_ctr - elem_blk_parms[parm_ndx].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[parm_ndx].num_nodes_per_elem;
connect_offset = num_nodes_per_elem * elem_num_pos;
side_num = side - 1;
if (int_size == sizeof(int64_t)) {
node_pos = ((int64_t *)ss_elem_node_ndx)[elem_ndx];
}
else {
node_pos = ((int *)ss_elem_node_ndx)[elem_ndx];
}
switch (elem_blk_parms[parm_ndx].elem_type_val) {
case EX_EL_CIRCLE:
case EX_EL_SPHERE: { /* Note: no side-node lookup table is used for this
simple case */
get_nodes(exoid, side_set_node_list, node_pos, connect, connect_offset);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 1); /* 1 node object */
break;
}
case EX_EL_TRUSS:
case EX_EL_BEAM: { /* Note: no side-node lookup table is used for this
simple case */
for (i = 0; i < num_nodes_per_elem; i++) {
get_nodes(exoid, side_set_node_list, node_pos + i, connect, connect_offset + i);
}
set_count(exoid, side_set_node_cnt_list, elem_ndx, num_nodes_per_elem);
break;
}
case EX_EL_TRIANGLE: {
if (ndim == 2) { /* 2d TRIs */
if (check_valid_side(side_num, 3, "triangle", exoid) != EX_NOERR) {
goto cleanup;
}
get_nodes(exoid, side_set_node_list, node_pos, connect,
connect_offset + tri_table[side_num][0] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 1, connect,
connect_offset + tri_table[side_num][1] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */
if (num_nodes_per_elem > 3) /* 6-node TRI */
{
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + tri_table[side_num][2] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */
}
}
else if (ndim == 3) { /* 3d TRIs */
if (check_valid_side(side_num, 5, "triangle", exoid) != EX_NOERR) {
goto cleanup;
}
get_nodes(exoid, side_set_node_list, node_pos, connect,
connect_offset + tri3_table[side_num][0] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 1, connect,
connect_offset + tri3_table[side_num][1] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */
if (side_num + 1 <= 2) /* 3, 4, 6, 7-node face */
{
if (num_nodes_per_elem == 3) /* 3-node face */
{
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + tri3_table[side_num][2] - 1);
}
else if (num_nodes_per_elem == 4) /* 4-node face */
{
set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + tri3_table[side_num][2] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + 4 - 1); /* Center node of 4-noded face */
}
else if (num_nodes_per_elem == 6) /* 6-node face */
{
set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node object */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + tri3_table[side_num][2] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 3, connect,
connect_offset + tri3_table[side_num][3] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 4, connect,
connect_offset + tri3_table[side_num][4] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 5, connect,
connect_offset + tri3_table[side_num][5] - 1);
}
else if (num_nodes_per_elem == 7) /* 7-node face */
{
set_count(exoid, side_set_node_cnt_list, elem_ndx, 7); /* 7 node object */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + tri3_table[side_num][2] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 3, connect,
connect_offset + tri3_table[side_num][3] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 4, connect,
connect_offset + tri3_table[side_num][4] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 5, connect,
connect_offset + tri3_table[side_num][5] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 6, connect,
connect_offset + tri3_table[side_num][6] - 1);
}
else {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: %d is an unsupported number of nodes for the triangle element type",
(int)num_nodes_per_elem);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
}
else /* 2- or 3-node edge */
{
if (num_nodes_per_elem > 3) /* 3-node edge */
{
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + tri3_table[side_num][2] - 1);
}
}
}
break;
}
case EX_EL_QUAD: {
if (check_valid_side(side_num, 4, "quad", exoid) != EX_NOERR) {
goto cleanup;
}
get_nodes(exoid, side_set_node_list, node_pos + 0, connect,
connect_offset + quad_table[side_num][0] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 1, connect,
connect_offset + quad_table[side_num][1] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */
if (num_nodes_per_elem > 5) {
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + quad_table[side_num][2] - 1);
}
break;
}
case EX_EL_SHELL: {
if (check_valid_side(side_num, 6, "shell", exoid) != EX_NOERR) {
goto cleanup;
}
get_nodes(exoid, side_set_node_list, node_pos + 0, connect,
connect_offset + shell_table[side_num][0] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 1, connect,
connect_offset + shell_table[side_num][1] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 2); /* 2 node object */
if (num_nodes_per_elem > 2) { /*** KLUGE for 2D shells ***/
if (side_num + 1 <= 2) { /* 4-node face */
set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + shell_table[side_num][2] - 1);
get_nodes(exoid, 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 */
set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node object */
get_nodes(exoid, side_set_node_list, node_pos + 4, connect,
connect_offset + shell_table[side_num][4] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 5, connect,
connect_offset + shell_table[side_num][5] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 6, connect,
connect_offset + shell_table[side_num][6] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 7, connect,
connect_offset + shell_table[side_num][7] - 1);
}
else {
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node edge */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + shell_table[side_num][2] - 1);
}
}
if (num_nodes_per_elem == 9) {
if (side_num + 1 <= 2) { /* 9-node face */
set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node object */
get_nodes(exoid, side_set_node_list, node_pos + 4, connect,
connect_offset + shell_table[side_num][4] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 5, connect,
connect_offset + shell_table[side_num][5] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 6, connect,
connect_offset + shell_table[side_num][6] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 7, connect,
connect_offset + shell_table[side_num][7] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 8, connect,
connect_offset + shell_table[side_num][8] - 1);
}
else {
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node edge */
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + shell_table[side_num][2] - 1);
}
}
break;
}
case EX_EL_TETRA: {
if (check_valid_side(side_num, 4, "tetra", exoid) != EX_NOERR) {
goto cleanup;
}
get_nodes(exoid, side_set_node_list, node_pos + 0, connect,
connect_offset + tetra_table[side_num][0] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 1, connect,
connect_offset + tetra_table[side_num][1] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + tetra_table[side_num][2] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node object */
if (num_nodes_per_elem == 8) {
set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */
get_nodes(exoid, side_set_node_list, node_pos + 3, connect,
connect_offset + tetra_table[side_num][3] - 1);
}
else if (num_nodes_per_elem > 8) {
set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node object */
get_nodes(exoid, side_set_node_list, node_pos + 3, connect,
connect_offset + tetra_table[side_num][3] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 4, connect,
connect_offset + tetra_table[side_num][4] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 5, connect,
connect_offset + tetra_table[side_num][5] - 1);
}
break;
}
case EX_EL_WEDGE: {
int node_off = 0;
if (check_valid_side(side_num, 5, "wedge", exoid) != EX_NOERR) {
goto cleanup;
}
if (num_nodes_per_elem == 6 || num_nodes_per_elem == 7) {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge6_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge6_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge6_table[side_num][node_off++] - 1);
if (side_num == 3 || side_num == 4) {
/* This is one of the triangular faces */
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node side */
assert(node_off == 3);
}
else {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge6_table[side_num][node_off++] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node side */
assert(node_off == 4);
}
}
else if (num_nodes_per_elem == 15 || num_nodes_per_elem == 16) {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge15_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge15_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge15_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge15_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge15_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge15_table[side_num][node_off++] - 1);
if (side_num == 3 || side_num == 4) {
/* This is one of the triangular faces */
set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node side */
assert(node_off == 6);
}
else {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge15_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge15_table[side_num][node_off++] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node side */
assert(node_off == 8);
}
}
else if (num_nodes_per_elem == 20) {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
if (side_num == 3 || side_num == 4) {
/* This is one of the triangular faces */
set_count(exoid, side_set_node_cnt_list, elem_ndx, 7); /* 7 node side */
assert(node_off == 7);
}
else {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge20_table[side_num][node_off++] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node side */
assert(node_off == 9);
}
}
else if (num_nodes_per_elem == 21) {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
if (side_num == 3 || side_num == 4) {
/* This is one of the triangular faces */
set_count(exoid, side_set_node_cnt_list, elem_ndx, 7); /* 7 node side */
}
else {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge21_table[side_num][node_off++] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node side */
}
}
else if (num_nodes_per_elem == 18) {
/* Wedge 18 - 9-node quad faces (0,1,2) and 6-node tri faces (3,4) */
/* All faces (quad or tri) have at least 6 nodes */
/* This gets nodes 1-6 */
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
if (side_num == 3 || side_num == 4) {
set_count(exoid, side_set_node_cnt_list, elem_ndx, 6); /* 6 node side */
assert(node_off == 6);
}
else {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + wedge18_table[side_num][node_off++] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node side */
assert(node_off == 9);
}
}
break;
}
case EX_EL_PYRAMID: {
/*
* node count: 5 -- 4-node quad, 3-node tri
* 13 8 6
* 14 9 6
* 18 9 7
* 19 9 7 + volume center node.
*/
if (check_valid_side(side_num, 5, "pyramid", exoid) != EX_NOERR) {
goto cleanup;
}
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][0] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][1] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][2] - 1);
if (pyramid_table[side_num][3] == 0) { /* degenerate side? */
set_count(exoid, side_set_node_cnt_list, elem_ndx, 3); /* 3 node side */
}
else {
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][3] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node side */
}
if (num_nodes_per_elem > 5) {
/* This gets the mid-edge nodes for three edges */
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][4] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][5] - 1);
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][6] - 1);
if (side_num == 4) {
int face_node_count = num_nodes_per_elem >= 14 ? 9 : 8;
set_count(exoid, side_set_node_cnt_list, elem_ndx, face_node_count);
/* Get the last mid-edge node if this is quad face topology */
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][7] - 1);
if (num_nodes_per_elem >= 14) {
/* Get the mid-face node for the quad */
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][8] - 1);
}
}
else {
/* Triangular faces... */
int face_node_count = num_nodes_per_elem >= 18 ? 7 : 6;
set_count(exoid, side_set_node_cnt_list, elem_ndx, face_node_count);
if (num_nodes_per_elem >= 18) {
/* Get the mid-face node for the tri */
get_nodes(exoid, side_set_node_list, node_pos++, connect,
connect_offset + pyramid_table[side_num][8] - 1);
}
}
}
break;
}
case EX_EL_HEX: {
if (check_valid_side(side_num, 6, "hex", exoid) != EX_NOERR) {
goto cleanup;
}
get_nodes(exoid, side_set_node_list, node_pos + 0, connect,
connect_offset + hex_table[side_num][0] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 1, connect,
connect_offset + hex_table[side_num][1] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 2, connect,
connect_offset + hex_table[side_num][2] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 3, connect,
connect_offset + hex_table[side_num][3] - 1);
set_count(exoid, side_set_node_cnt_list, elem_ndx, 4); /* 4 node object */
if (num_nodes_per_elem > 12) /* more nodes than HEXSHELL */
{
set_count(exoid, side_set_node_cnt_list, elem_ndx, 8); /* 8 node object */
get_nodes(exoid, side_set_node_list, node_pos + 4, connect,
connect_offset + hex_table[side_num][4] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 5, connect,
connect_offset + hex_table[side_num][5] - 1);
get_nodes(exoid, side_set_node_list, node_pos + 6, connect,
connect_offset + hex_table[side_num][6] - 1);
get_nodes(exoid, 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 */
{
set_count(exoid, side_set_node_cnt_list, elem_ndx, 9); /* 9 node object */
get_nodes(exoid, side_set_node_list, node_pos + 8, connect,
connect_offset + hex_table[side_num][8] - 1);
}
break;
}
default: {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: %s is an unsupported element type",
elem_blk_parms[parm_ndx].elem_type);
ex_err("ex_get_side_set_node_list", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
}
}
/* All done: release connectivity array space, element block ids array,
element block parameters array, and side set element index array */
cleanup:
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 (err_stat);
}
int ex_get_concat_sets (int exoid,
ex_entity_type set_type,
struct ex_set_specs* set_specs)
{
int status, dimid;
void_int *num_entries_per_set = set_specs->num_entries_per_set;
void_int *num_dist_per_set = set_specs->num_dist_per_set;
void_int *sets_entry_index = set_specs->sets_entry_index;
void_int *sets_dist_index = set_specs->sets_dist_index;
void *sets_dist_fact = set_specs->sets_dist_fact;
int num_sets, i;
float *flt_dist_fact;
double *dbl_dist_fact;
char errmsg[MAX_ERR_LENGTH];
ex_inquiry ex_inq_val;
exerrval = 0; /* clear error code */
/* setup pointers based on set_type
NOTE: there is another block that sets more stuff later ... */
if (set_type == EX_NODE_SET) {
ex_inq_val = EX_INQ_NODE_SETS;
}
else if (set_type == EX_EDGE_SET) {
ex_inq_val = EX_INQ_EDGE_SETS;
}
else if (set_type == EX_FACE_SET) {
ex_inq_val = EX_INQ_FACE_SETS;
}
else if (set_type == EX_SIDE_SET) {
ex_inq_val = EX_INQ_SIDE_SETS;
}
else if (set_type == EX_ELEM_SET) {
ex_inq_val = EX_INQ_ELEM_SETS;
}
else {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: invalid set type (%d)", set_type);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_EBADDIM) {
sprintf(errmsg,
"Warning: no %ss defined for file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_get_concat_sets",errmsg,exerrval);
return (EX_WARN);
} else {
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_get_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire how many sets have been stored */
num_sets = ex_inquire_int(exoid, ex_inq_val);
if (num_sets < 0) {
sprintf(errmsg,
"Error: failed to get number of %ss defined for file id %d",
ex_name_of_object(set_type), exoid);
/* use error val from inquire */
ex_err("ex_get_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_ids (exoid, set_type, set_specs->sets_ids) != NC_NOERR) {
sprintf(errmsg,
"Error: failed to get %s ids for file id %d",
ex_name_of_object(set_type), exoid);
/* use error val from inquire */
ex_err("ex_get_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
((int64_t*)sets_entry_index)[0] = 0;
((int64_t*)sets_dist_index)[0] = 0;
} else {
((int*)sets_entry_index)[0] = 0;
((int*)sets_dist_index)[0] = 0;
}
for (i=0; i<num_sets; i++) {
int set_id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
set_id = ((int64_t*)set_specs->sets_ids)[i];
} else {
set_id = ((int*)set_specs->sets_ids)[i];
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
if (ex_get_set_param(exoid, set_type, set_id,
&(((int64_t*)num_entries_per_set)[i]),
&(((int64_t*)num_dist_per_set)[i])) != NC_NOERR)
return(EX_FATAL); /* error will be reported by sub */
if (i < num_sets-1) {
/* fill in entry and dist factor index arrays */
((int64_t*)sets_entry_index)[i+1] = ((int64_t*)sets_entry_index)[i]+((int64_t*)num_entries_per_set)[i];
((int64_t*)sets_dist_index)[i+1] = ((int64_t*)sets_dist_index)[i]+((int64_t*)num_dist_per_set)[i];
}
if (((int64_t*)num_entries_per_set)[i] == 0) /* NULL set? */
continue;
{
/* Now, use ExodusII call to get sets */
int64_t *sets_entry_list = set_specs->sets_entry_list;
int64_t *sets_extra_list = set_specs->sets_extra_list;
int64_t *sets_extra = sets_extra_list ? &((int64_t*)sets_extra_list)[((int64_t*)sets_entry_index)[i]] : NULL;
status = ex_get_set(exoid, set_type, set_id,
&(sets_entry_list[((int64_t*)sets_entry_index)[i]]),
sets_extra);
}
} else {
if (ex_get_set_param(exoid, set_type, set_id,
&(((int*)num_entries_per_set)[i]),
&(((int*)num_dist_per_set)[i])) != NC_NOERR)
return(EX_FATAL); /* error will be reported by sub */
if (i < num_sets-1) {
/* fill in entry and dist factor index arrays */
((int*)sets_entry_index)[i+1] = ((int*)sets_entry_index)[i]+((int*)num_entries_per_set)[i];
((int*)sets_dist_index)[i+1] = ((int*)sets_dist_index)[i]+((int*)num_dist_per_set)[i];
}
if (((int*)num_entries_per_set)[i] == 0) /* NULL set? */
continue;
{
/* Now, use ExodusII call to get sets */
int *sets_entry_list = set_specs->sets_entry_list;
int *sets_extra_list = set_specs->sets_extra_list;
int *sets_extra = sets_extra_list ? &((int*)sets_extra_list)[((int*)sets_entry_index)[i]] : NULL;
status = ex_get_set(exoid, set_type, set_id,
&(sets_entry_list[((int*)sets_entry_index)[i]]),
sets_extra);
}
}
if (status != NC_NOERR)
return(EX_FATAL); /* error will be reported by subroutine */
/* get distribution factors for this set */
if (sets_dist_fact != 0) {
size_t df_idx;
size_t num_dist;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
df_idx = ((int64_t*)sets_dist_index)[i];
num_dist = ((int64_t*)num_dist_per_set)[i];
} else {
df_idx = ((int*)sets_dist_index)[i];
num_dist = ((int*)num_dist_per_set)[i];
}
if (num_dist > 0) { /* only get df if they exist */
if (ex_comp_ws(exoid) == sizeof(float)) {
flt_dist_fact = sets_dist_fact;
status = ex_get_set_dist_fact(exoid, set_type, set_id,
&(flt_dist_fact[df_idx]));
} else {
dbl_dist_fact = sets_dist_fact;
status = ex_get_set_dist_fact(exoid, set_type, set_id,
&(dbl_dist_fact[df_idx]));
}
if (status != NC_NOERR) {
return(EX_FATAL); /* error will be reported by subroutine */
}
}
}
}
return(EX_NOERR);
}
int main (int argc, char *argv[])
{
char *oname = nullptr, *dot = nullptr, *filename = nullptr;
char str[32];
const char* ext=EXT;
int
n, n1,n2,err,
num_axes,num_blocks,
num_side_sets,num_node_sets,num_time_steps,
num_info_lines,num_global_vars,
num_nodal_vars,num_element_vars,num_nodeset_vars, num_sideset_vars;
size_t num_nodes = 0;
size_t num_elements = 0;
int mat_version = 73;
/* process arguments */
for (int j=1; j< argc; j++){
if ( strcmp(argv[j],"-t")==0){ /* write text file (*.m) */
del_arg(&argc,argv,j);
textfile=1;
j--;
continue;
}
if ( strcmp(argv[j],"-h")==0){ /* write help info */
del_arg(&argc,argv,j);
usage();
exit(1);
}
if ( strcmp(argv[j],"-d")==0){ /* write help info */
del_arg(&argc,argv,j);
j--;
debug = 1;
continue;
}
if ( strcmp(argv[j],"-v73")==0){ /* Version 7.3 */
del_arg(&argc,argv,j);
mat_version = 73;
j--;
continue;
}
// This matches the option used in matlab
if ( (strcmp(argv[j],"-v7.3")==0) || (strcmp(argv[j],"-V7.3")==0)){ /* Version 7.3 */
del_arg(&argc,argv,j);
mat_version = 73;
j--;
continue;
}
if ( strcmp(argv[j],"-v5")==0){ /* Version 5 (default) */
del_arg(&argc,argv,j);
mat_version = 50;
j--;
continue;
}
if ( strcmp(argv[j],"-o")==0){ /* specify output file name */
del_arg(&argc,argv,j);
if ( argv[j] ){
oname=(char*)calloc(strlen(argv[j])+10,sizeof(char));
strcpy(oname,argv[j]);
del_arg(&argc,argv,j);
std::cout << "output file: " << oname << "\n";
}
else {
std::cerr << "ERROR: Invalid output file specification.\n";
return 2;
}
j--;
continue;
}
}
/* QA Info */
printf("%s: %s, %s\n", qainfo[0], qainfo[2], qainfo[1]);
/* usage message*/
if (argc != 2){
usage();
exit(1);
}
/* open output file */
if ( textfile )
ext=".m";
if ( !oname ){
filename = (char*)malloc( strlen(argv[1])+10);
strcpy(filename,argv[1]);
dot=strrchr(filename,'.');
if ( dot ) *dot='\0';
strcat(filename,ext);
}
else {
filename=oname;
}
if ( textfile ){
m_file = fopen(filename,"w");
if (!m_file ){
std::cerr << "ERROR: Unable to open " << filename << "\n";
exit(1);
}
}
else {
if (mat_version == 50) {
mat_file = Mat_CreateVer(filename, nullptr, MAT_FT_MAT5);
}
else if (mat_version == 73) {
mat_file = Mat_CreateVer(filename, nullptr, MAT_FT_MAT73);
}
if (mat_file == nullptr) {
std::cerr << "ERROR: Unable to create matlab file " << filename << "\n";
exit(1);
}
}
/* word sizes */
int cpu_word_size=sizeof(double);
int io_word_size=0;
/* open exodus file */
float exo_version;
int exo_file=ex_open(argv[1],EX_READ,&cpu_word_size,&io_word_size,&exo_version);
if (exo_file < 0){
std::cerr << "ERROR: Cannot open " << argv[1] << "\n";
exit(1);
}
/* print */
std::cout << "\ttranslating " << argv[1] << " to " << filename << "...\n";
/* read database paramters */
char *line=(char *) calloc ((MAX_LINE_LENGTH+1),sizeof(char));
ex_get_init(exo_file,line,
&num_axes,&num_nodes,&num_elements,&num_blocks,
&num_node_sets,&num_side_sets);
num_info_lines = ex_inquire_int(exo_file,EX_INQ_INFO);
num_time_steps = ex_inquire_int(exo_file,EX_INQ_TIME);
ex_get_variable_param(exo_file,EX_GLOBAL,&num_global_vars);
ex_get_variable_param(exo_file,EX_NODAL,&num_nodal_vars);
ex_get_variable_param(exo_file,EX_ELEM_BLOCK,&num_element_vars);
ex_get_variable_param(exo_file,EX_NODE_SET,&num_nodeset_vars);
ex_get_variable_param(exo_file,EX_SIDE_SET,&num_sideset_vars);
/* export paramters */
PutInt("naxes", num_axes);
PutInt("nnodes", num_nodes);
PutInt("nelems", num_elements);
PutInt("nblks", num_blocks);
PutInt("nnsets", num_node_sets);
PutInt("nssets", num_side_sets);
PutInt("nsteps", num_time_steps);
PutInt("ngvars", num_global_vars);
PutInt("nnvars", num_nodal_vars);
PutInt("nevars", num_element_vars);
PutInt("nnsvars",num_nodeset_vars);
PutInt("nssvars",num_sideset_vars);
/* allocate -char- scratch space*/
int nstr2 = num_info_lines;
nstr2 = std::max(nstr2, num_blocks);
nstr2 = std::max(nstr2, num_node_sets);
nstr2 = std::max(nstr2, num_side_sets);
char **str2 = get_exodus_names(nstr2, 512);
/* title */
PutStr("Title",line);
/* information records */
if (num_info_lines > 0 ){
ex_get_info(exo_file,str2);
std::string ostr;
for (int i=0;i<num_info_lines;i++) {
if (strlen(str2[i]) > 0) {
ostr += str2[i];
ostr += "\n";
}
}
PutStr("info",ostr.c_str());
ostr = "";
for (int i=0;i<num_info_lines;i++) {
if (strlen(str2[i]) > 0 && strncmp(str2[i],"cavi",4)==0) {
ostr += str2[i];
ostr += "\n";
}
}
PutStr("cvxp",ostr.c_str());
}
/* nodal coordinates */
{
if (debug) {logger("Coordinates");}
std::vector<double> x, y, z;
x.resize(num_nodes);
if (num_axes >= 2) y.resize(num_nodes);
if (num_axes == 3) z.resize(num_nodes);
ex_get_coord(exo_file,TOPTR(x), TOPTR(y), TOPTR(z));
PutDbl("x0", num_nodes, 1, TOPTR(x));
if (num_axes >= 2) {
PutDbl("y0", num_nodes, 1, TOPTR(y));
}
if (num_axes == 3){
PutDbl("z0",num_nodes,1, TOPTR(z));
}
}
/* side sets */
std::vector<int> num_sideset_sides(num_side_sets);
std::vector<int> ids;
if (num_side_sets > 0) {
if (debug) {logger("Side Sets");}
ids.resize(num_side_sets);
ex_get_ids(exo_file,EX_SIDE_SET,TOPTR(ids));
PutInt( "ssids",num_side_sets, 1,TOPTR(ids));
std::vector<int> nssdfac(num_side_sets);
std::vector<int> iscr;
std::vector<int> jscr;
std::vector<double> scr;
std::vector<int> elem_list;
std::vector<int> side_list;
std::vector<int> junk;
for (int i=0;i<num_side_sets;i++) {
ex_get_set_param(exo_file,EX_SIDE_SET, ids[i],&n1,&n2);
num_sideset_sides[i]=n1;
nssdfac[i]=n2;
/*
* the following provision is from Version 1.6 when there are no
* distribution factors in exodus file
*/
bool has_ss_dfac = (n2 != 0);
if (n2==0 || n1==n2){
std::cerr << "WARNING: Exodus II file does not contain distribution factors.\n";
/* n1=number of faces, n2=number of df */
/* using distribution factors to determine number of nodes in the sideset
causes a lot grief since some codes do not output distribution factors
if they are all equal to 1. mkbhard: I am using the function call below
to figure out the total number of nodes in this sideset. Some redundancy
exists, but it works for now */
junk.resize(n1);
ex_get_side_set_node_count(exo_file,ids[i],TOPTR(junk));
n2=0; /* n2 will be equal to the total number of nodes in the sideset */
for (int j=0; j<n1; j++)
n2+=junk[j];
}
iscr.resize(n1);
jscr.resize(n2);
ex_get_side_set_node_list(exo_file,ids[i],TOPTR(iscr),TOPTR(jscr));
/* number-of-nodes-per-side list */
sprintf(str,"ssnum%02d",i+1);
PutInt(str,n1,1,TOPTR(iscr));
/* nodes list */
sprintf(str,"ssnod%02d",i+1);
PutInt(str,n2,1,TOPTR(jscr));
/* distribution-factors list */
scr.resize(n2);
if (has_ss_dfac) {
ex_get_side_set_dist_fact(exo_file,ids[i], TOPTR(scr));
} else {
for (int j=0; j<n2; j++) {
scr[j] = 1.0;
}
}
sprintf(str,"ssfac%02d",i+1);
PutDbl(str,n2,1,TOPTR(scr));
/* element and side list for side sets (dgriffi) */
elem_list.resize(n1);
side_list.resize(n1);
ex_get_set(exo_file,EX_SIDE_SET,ids[i],TOPTR(elem_list),TOPTR(side_list));
sprintf(str,"ssside%02d",i+1);
PutInt(str,n1,1,TOPTR(side_list));
sprintf(str,"sselem%02d",i+1);
PutInt(str,n1,1,TOPTR(elem_list));
}
/* Store # sides and # dis. factors per side set (dgriffi) */
PutInt("nsssides",num_side_sets,1,TOPTR(num_sideset_sides));
PutInt("nssdfac",num_side_sets,1,TOPTR(nssdfac));
}
/* node sets (section by dgriffi) */
std::vector<int> num_nodeset_nodes(num_node_sets);
if (num_node_sets > 0){
if (debug) {logger("Node Sets");}
std::vector<int> iscr;
std::vector<double> scr;
ids.resize(num_node_sets);
ex_get_ids(exo_file,EX_NODE_SET, TOPTR(ids));
PutInt( "nsids",num_node_sets, 1,TOPTR(ids));
std::vector<int> num_nodeset_df(num_node_sets);
for (int i=0;i<num_node_sets;i++){
ex_get_set_param(exo_file,EX_NODE_SET,ids[i],&n1,&n2);
iscr.resize(n1);
ex_get_node_set(exo_file,ids[i],TOPTR(iscr));
/* nodes list */
sprintf(str,"nsnod%02d",i+1);
PutInt(str,n1,1,TOPTR(iscr));
{
/* distribution-factors list */
scr.resize(n2);
ex_get_node_set_dist_fact(exo_file,ids[i],TOPTR(scr));
sprintf(str,"nsfac%02d",i+1);
PutDbl(str,n2,1,TOPTR(scr));
}
num_nodeset_nodes[i]=n1;
num_nodeset_df[i]=n2;
}
/* Store # nodes and # dis. factors per node set */
PutInt("nnsnodes",num_node_sets,1,TOPTR(num_nodeset_nodes));
PutInt("nnsdfac",num_node_sets,1,TOPTR(num_nodeset_df));
}
/* element blocks */
if (debug) {logger("Element Blocks");}
std::vector<int> num_elem_in_block(num_blocks);
{
ids.resize(num_blocks);
std::vector<int> iscr;
ex_get_ids(exo_file,EX_ELEM_BLOCK,TOPTR(ids));
PutInt( "blkids",num_blocks, 1,TOPTR(ids));
for (int i=0;i<num_blocks;i++) {
ex_get_elem_block(exo_file,ids[i],str2[i],&n,&n1,&n2);
num_elem_in_block[i]=n;
iscr.resize(n*n1);
ex_get_conn(exo_file,EX_ELEM_BLOCK,ids[i],TOPTR(iscr), nullptr, nullptr);
sprintf(str,"blk%02d",i+1);
PutInt(str,n1,n,TOPTR(iscr));
}
str[0]='\0';
for (int i=0;i<num_blocks;i++) {
strcat(str, str2[i]);
strcat(str, "\n");
}
PutStr("blknames",str);
}
/* time values */
if (num_time_steps > 0 ) {
if (debug) {logger("Time Steps");}
std::vector<double> scr(num_time_steps);
ex_get_all_times (exo_file, TOPTR(scr));
PutDbl( "time", num_time_steps, 1, TOPTR(scr));
}
/* global variables */
if (num_global_vars > 0 ) {
if (debug) {logger("Global Variables");}
get_put_names(exo_file, EX_GLOBAL, num_global_vars, "gnames");
std::vector<double> scr(num_time_steps);
for (int i=0;i<num_global_vars;i++){
sprintf(str,"gvar%02d",i+1);
ex_get_glob_var_time(exo_file,i+1,1,num_time_steps,TOPTR(scr));
PutDbl(str,num_time_steps,1,TOPTR(scr));
}
}
/* nodal variables */
if (num_nodal_vars > 0 ) {
if (debug) {logger("Nodal Variables");}
if (debug) {logger("\tNames");}
get_put_names(exo_file, EX_NODAL, num_nodal_vars, "nnames");
std::vector<double> scr(num_nodes*num_time_steps);
for (int i=0; i<num_nodal_vars; i++){
sprintf(str,"nvar%02d",i+1);
if (debug) {logger("\tReading");}
for (int j=0; j<num_time_steps; j++) {
ex_get_nodal_var(exo_file,j+1,i+1,num_nodes,
&scr[num_nodes*j]);
}
if (debug) {logger("\tWriting");}
PutDbl(str,num_nodes,num_time_steps,TOPTR(scr));
}
}
/* element variables */
if (num_element_vars > 0 ) {
if (debug) {logger("Element Variables");}
get_put_names(exo_file, EX_ELEM_BLOCK, num_element_vars, "enames");
get_put_vars(exo_file, EX_ELEM_BLOCK,
num_blocks, num_element_vars, num_time_steps, num_elem_in_block, "evar%02d");
}
/* nodeset variables */
if (num_nodeset_vars > 0 ) {
if (debug) {logger("Nodeset Variables");}
get_put_names(exo_file, EX_NODE_SET, num_nodeset_vars, "nsnames");
get_put_vars(exo_file, EX_NODE_SET,
num_node_sets, num_nodeset_vars, num_time_steps, num_nodeset_nodes, "nsvar%02d");
}
/* sideset variables */
if (num_sideset_vars > 0 ) {
if (debug) {logger("Sideset Variables");}
get_put_names(exo_file, EX_SIDE_SET, num_sideset_vars, "ssnames");
get_put_vars(exo_file, EX_SIDE_SET,
num_side_sets, num_sideset_vars, num_time_steps, num_sideset_sides, "ssvar%02d");
}
/* node and element number maps */
if (debug) {logger("Node and Element Number Maps");}
ex_opts(0); /* turn off error reporting. It is not an error to have no map*/
ids.resize(num_nodes);
err = ex_get_node_num_map(exo_file,TOPTR(ids));
if ( err==0 ){
PutInt("node_num_map",num_nodes,1,TOPTR(ids));
}
ids.resize(num_elements);
err = ex_get_elem_num_map(exo_file,TOPTR(ids));
if ( err==0 ){
PutInt("elem_num_map",num_elements,1,TOPTR(ids));
}
if (debug) {logger("Closing file");}
ex_close(exo_file);
if ( textfile )
fclose(m_file);
else
Mat_Close(mat_file);
std::cout << "done...\n";
free(filename);
free(line);
delete_exodus_names(str2, nstr2);
/* exit status */
add_to_log("exo2mat", 0);
return(0);
}
int ex_get_elem_blk_ids(int exoid, void_int *ids)
{
/* ex_get_elem_blk_ids should be deprecated. */
return ex_get_ids(exoid, EX_ELEM_BLOCK, ids);
}
template <typename INT> void ExoII_Read<INT>::Get_Init_Data()
{
SMART_ASSERT(Check_State());
SMART_ASSERT(file_id >= 0);
// Determine max size of entity and variable names on the database
int name_length = ex_inquire_int(file_id, EX_INQ_DB_MAX_USED_NAME_LENGTH);
ex_set_max_name_length(file_id, name_length);
ex_init_params info;
info.title[0] = '\0';
int err = ex_get_init_ext(file_id, &info);
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get init data!"
<< " Error number = " << err << ". Aborting..." << '\n';
exit(1);
}
dimension = info.num_dim;
num_nodes = info.num_nodes;
num_elmts = info.num_elem;
num_elmt_blocks = info.num_elem_blk;
num_node_sets = info.num_node_sets;
num_side_sets = info.num_side_sets;
title = info.title;
if (err > 0 && !interface.quiet_flag)
std::cout << "EXODIFF WARNING: was issued, number = " << err << '\n';
if (dimension < 1 || dimension > 3 || num_elmt_blocks < 0 || num_node_sets < 0 ||
num_side_sets < 0) {
std::cout << "EXODIFF ERROR: Init data appears corrupt:" << '\n'
<< " dimension = " << dimension << '\n'
<< " num_nodes = " << num_nodes << '\n'
<< " num_elmts = " << num_elmts << '\n'
<< " num_elmt_blocks = " << num_elmt_blocks << '\n'
<< " num_node_sets = " << num_node_sets << '\n'
<< " num_side_sets = " << num_side_sets << '\n'
<< " ... Aborting..." << '\n';
exit(1);
}
int num_qa = ex_inquire_int(file_id, EX_INQ_QA);
int num_info = ex_inquire_int(file_id, EX_INQ_INFO);
if (num_qa < 0 || num_info < 0) {
std::cout << "EXODIFF ERROR: inquire data appears corrupt:" << '\n'
<< " num_qa = " << num_qa << '\n'
<< " num_info = " << num_info << '\n'
<< " ... Aborting..." << '\n';
exit(1);
}
// Coordinate Names...
char **coords = get_name_array(3, name_length);
err = ex_get_coord_names(file_id, coords);
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get coordinate"
<< " names! Aborting..." << '\n';
exit(1);
}
coord_names.clear();
for (size_t i = 0; i < dimension; ++i) {
coord_names.push_back(coords[i]);
}
free_name_array(coords, 3);
// Element Block Data...
if (eblocks)
delete[] eblocks;
eblocks = nullptr;
if (num_elmt_blocks > 0) {
eblocks = new Exo_Block<INT>[num_elmt_blocks];
SMART_ASSERT(eblocks != nullptr);
std::vector<INT> ids(num_elmt_blocks);
err = ex_get_ids(file_id, EX_ELEM_BLOCK, TOPTR(ids));
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get element"
<< " block ids! Aborting..." << '\n';
exit(1);
}
size_t e_count = 0;
for (size_t b = 0; b < num_elmt_blocks; ++b) {
if (ids[b] <= EX_INVALID_ID) {
std::cout << "EXODIFF WARNING: Element block Id "
<< "for block index " << b << " is " << ids[b]
<< " which is negative. This was returned by call to ex_get_elem_blk_ids()."
<< '\n';
}
eblocks[b].initialize(file_id, ids[b]);
e_count += eblocks[b].Size();
}
if (e_count != num_elmts && !interface.quiet_flag) {
std::cout << "EXODIFF WARNING: Total number of elements " << num_elmts
<< " does not equal the sum of the number of elements "
<< "in each block " << e_count << '\n';
}
// Gather the attribute names (even though not all attributes are on all blocks)
std::set<std::string> names;
for (size_t b = 0; b < num_elmt_blocks; ++b) {
for (int a = 0; a < eblocks[b].attr_count(); a++) {
names.insert(eblocks[b].Get_Attribute_Name(a));
}
}
elmt_atts.resize(names.size());
std::copy(names.begin(), names.end(), elmt_atts.begin());
}
// Node & Side sets...
if (nsets)
delete[] nsets;
nsets = nullptr;
if (num_node_sets > 0) {
nsets = new Node_Set<INT>[num_node_sets];
SMART_ASSERT(nsets != nullptr);
std::vector<INT> ids(num_node_sets);
err = ex_get_ids(file_id, EX_NODE_SET, TOPTR(ids));
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get "
<< "nodeset ids! Aborting..." << '\n';
exit(1);
}
for (size_t nset = 0; nset < num_node_sets; ++nset) {
if (ids[nset] <= EX_INVALID_ID) {
std::cout << "EXODIFF WARNING: Nodeset Id "
<< "for nodeset index " << nset << " is " << ids[nset]
<< " which is negative. This was returned by call to ex_get_ids()." << '\n';
}
nsets[nset].initialize(file_id, ids[nset]);
}
}
if (ssets)
delete[] ssets;
ssets = nullptr;
if (num_side_sets) {
ssets = new Side_Set<INT>[num_side_sets];
SMART_ASSERT(ssets != nullptr);
std::vector<INT> ids(num_side_sets);
err = ex_get_ids(file_id, EX_SIDE_SET, TOPTR(ids));
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get "
<< "sideset ids! Aborting..." << '\n';
exit(1);
}
for (size_t sset = 0; sset < num_side_sets; ++sset) {
if (ids[sset] <= EX_INVALID_ID) {
std::cout << "EXODIFF WARNING: Sideset Id "
<< "for sideset index " << sset << " is " << ids[sset]
<< " which is negative. This was returned by call to ex_get_ids()." << '\n';
}
ssets[sset].initialize(file_id, ids[sset]);
}
}
// ************** RESULTS info *************** //
int num_global_vars, num_nodal_vars, num_elmt_vars, num_ns_vars, num_ss_vars;
err = ex_get_variable_param(file_id, EX_GLOBAL, &num_global_vars);
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get number of"
<< " global variables! Aborting..." << '\n';
exit(1);
}
err = ex_get_variable_param(file_id, EX_NODAL, &num_nodal_vars);
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get number of"
<< " nodal variables! Aborting..." << '\n';
exit(1);
}
err = ex_get_variable_param(file_id, EX_ELEM_BLOCK, &num_elmt_vars);
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get number of"
<< " element variables! Aborting..." << '\n';
exit(1);
}
err = ex_get_variable_param(file_id, EX_NODE_SET, &num_ns_vars);
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get number of"
<< " nodeset variables! Aborting..." << '\n';
exit(1);
}
err = ex_get_variable_param(file_id, EX_SIDE_SET, &num_ss_vars);
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get number of"
<< " sideset variables! Aborting..." << '\n';
exit(1);
}
if (num_global_vars < 0 || num_nodal_vars < 0 || num_elmt_vars < 0 || num_ns_vars < 0 ||
num_ss_vars < 0) {
std::cout << "EXODIFF ERROR: Data appears corrupt for"
<< " number of variables !" << '\n'
<< "\tnum global vars = " << num_global_vars << '\n'
<< "\tnum nodal vars = " << num_nodal_vars << '\n'
<< "\tnum element vars = " << num_elmt_vars << '\n'
<< " ... Aborting..." << '\n';
exit(1);
}
read_vars(file_id, EX_GLOBAL, "Global", num_global_vars, global_vars);
read_vars(file_id, EX_NODAL, "Nodal", num_nodal_vars, nodal_vars);
read_vars(file_id, EX_ELEM_BLOCK, "Element", num_elmt_vars, elmt_vars);
read_vars(file_id, EX_NODE_SET, "Nodeset", num_ns_vars, ns_vars);
read_vars(file_id, EX_SIDE_SET, "Sideset", num_ss_vars, ss_vars);
// Times:
num_times = ex_inquire_int(file_id, EX_INQ_TIME);
if (num_times < 0) {
std::cout << "EXODIFF ERROR: Number of time steps came"
<< " back negative (" << num_times << ")! Aborting..." << '\n';
exit(1);
}
if ((num_global_vars > 0 || num_nodal_vars > 0 || num_elmt_vars > 0 || num_ns_vars > 0 ||
num_ss_vars > 0) &&
num_times == 0) {
std::cout << "EXODIFF Consistency error -- The database contains transient variables, but no "
"timesteps!"
<< '\n';
exit(1);
}
if (num_times) {
times = new double[num_times];
SMART_ASSERT(times != nullptr);
err = ex_get_all_times(file_id, times);
}
if (num_nodal_vars) {
if (num_times == 0) {
std::cout << "EXODIFF Consistency error--The database contains " << num_nodal_vars
<< " nodal variables, but there are no time steps defined." << '\n';
}
if (num_times) {
results = new double *[num_nodal_vars];
for (int i = 0; i < num_nodal_vars; ++i)
results[i] = nullptr;
}
}
} // End of EXODIFF
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 ex_get_concat_side_set_node_count(int exoid,
int *side_set_node_cnt_list)
{
size_t m;
int ii, i, j, iss, ioff;
int side_set_id;
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 = NULL;
int *side_set_ids = NULL;
int *ss_elem_ndx = NULL;
int *side_set_elem_list = NULL;
int *side_set_side_list = NULL;
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 *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_concat_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_concat_side_set_node_count",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_concat_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_concat_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);
}
/* Allocate space for the element block ids */
if (!(elem_blk_ids=malloc(num_elem_blks*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for element block ids for file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count",errmsg,exerrval);
goto error_ret;
}
if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids) == -1)
{
sprintf(errmsg,
"Error: failed to get element block ids in file id %d",
exoid);
ex_err("ex_get_concat_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))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for element block params for file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count",errmsg,exerrval);
goto error_ret;
}
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) {
sprintf(errmsg,
"Error: failed to get element block %d parameters in file id %d",
elem_blk_ids[i], exoid);
ex_err("ex_get_concat_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; m < strlen(elem_type); m++) {
elem_blk_parms[i].elem_type[m] = toupper(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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_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 = EX_EL_NULL_ELEMENT;
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 = EX_EL_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.
*/
/* Allocate space for the sideset ids */
if (!(side_set_ids=malloc(num_side_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set ids for file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count",errmsg,exerrval);
goto error_ret;
}
if (ex_get_ids(exoid, EX_SIDE_SET, side_set_ids) == -1)
{
sprintf(errmsg,
"Error: failed to get side set ids in file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count",errmsg,EX_MSG);
goto error_ret;
}
/* Lookup index of side set id in VAR_SS_IDS array */
ioff = 0;
for (iss=0; iss<num_side_sets; iss++) {
side_set_id = side_set_ids[iss];
/* First determine the # of elements in the side set*/
if ((ex_get_set_param(exoid,EX_SIDE_SET, 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_concat_side_set_node_count",errmsg,exerrval);
goto error_ret;
}
/* 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_concat_side_set_node_count",errmsg,exerrval);
goto error_ret;
}
/* Allocate space for the side set side list */
if (!(side_set_side_list=malloc(tot_num_ss_elem*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set side list for file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count",errmsg,exerrval);
goto error_ret;
}
if (ex_get_set(exoid, EX_SIDE_SET, side_set_id,
side_set_elem_list, side_set_side_list) == -1)
{
sprintf(errmsg,
"Error: failed to get side set %d in file id %d",
side_set_id, exoid);
ex_err("ex_get_concat_side_set_node_count",errmsg,exerrval);
goto error_ret;
}
/* 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_get_concat_side_set_node_count",errmsg,exerrval);
goto error_ret;
}
/* 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);
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+ioff] = 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);
ex_err("ex_get_concat_side_set_node_count",errmsg,EX_MSG);
goto error_ret;
}
}
ss_elem_ndx = safe_free(ss_elem_ndx);
side_set_elem_list = safe_free(side_set_elem_list);
side_set_side_list = safe_free(side_set_side_list);
ioff += tot_num_ss_elem;
}
/* All done: release allocated memory */
elem_blk_ids = safe_free(elem_blk_ids);
side_set_ids = safe_free(side_set_ids);
return(EX_NOERR);
error_ret:
elem_blk_ids = safe_free(elem_blk_ids);
side_set_ids = safe_free(side_set_ids);
ss_elem_ndx = safe_free(ss_elem_ndx);
side_set_elem_list = safe_free(side_set_elem_list);
side_set_side_list = safe_free(side_set_side_list);
return (EX_FATAL);
}
static exodus_file_t* open_exodus_file(MPI_Comm comm,
const char* filename,
int mode)
{
set_ex_opts();
exodus_file_t* file = polymec_malloc(sizeof(exodus_file_t));
file->last_time_index = 0;
file->comm = comm;
int real_size = (int)sizeof(real_t);
file->ex_real_size = 0;
#if POLYMEC_HAVE_MPI
MPI_Info_create(&file->mpi_info);
if (mode & EX_READ)
{
file->ex_id = ex_open_par(filename, mode, &real_size,
&file->ex_real_size, &file->ex_version,
file->comm, file->mpi_info);
// Did that work? If not, try the serial opener.
if (file->ex_id < 0)
{
file->ex_id = ex_open(filename, mode, &real_size,
&file->ex_real_size, &file->ex_version);
}
}
else
{
ASSERT(mode & EX_CLOBBER);
file->ex_version = EX_API_VERS;
file->ex_id = ex_create_par(filename, mode, &real_size,
&file->ex_real_size,
file->comm, file->mpi_info);
// Did that work? If not, try the serial creator.
if (file->ex_id < 0)
{
exerrval = 0;
file->ex_id = ex_create(filename, mode, &real_size,
&file->ex_real_size);
}
}
#else
if (mode & EX_READ)
{
file->ex_id = ex_open(filename, mode, &real_size,
&file->ex_real_size, &file->ex_version);
}
else
{
ASSERT(mode & EX_CLOBBER);
file->ex_id = ex_create(filename, mode, &real_size, &file->ex_real_size);
file->ex_version = EX_API_VERS;
}
#endif
if (file->ex_id >= 0)
{
file->writing = (mode & EX_CLOBBER);
file->node_var_names = string_array_new();
file->node_set_var_names = string_array_new();
file->edge_var_names = string_array_new();
file->edge_set_var_names = string_array_new();
file->face_var_names = string_array_new();
file->face_set_var_names = string_array_new();
file->elem_var_names = string_array_new();
file->elem_set_var_names = string_array_new();
file->side_set_var_names = string_array_new();
if (!file->writing)
{
// Read all the available variable names.
fetch_all_variable_names(file);
// Get information from the file.
ex_init_params mesh_info;
int status = ex_get_init_ext(file->ex_id, &mesh_info);
if ((status >= 0) && (mesh_info.num_dim == 3))
{
strncpy(file->title, mesh_info.title, MAX_NAME_LENGTH);
file->num_nodes = (int)mesh_info.num_nodes;
file->num_elem = (int)mesh_info.num_elem;
file->num_faces = (int)mesh_info.num_face;
file->num_edges = (int)mesh_info.num_edge;
file->num_elem_blocks = (int)mesh_info.num_elem_blk;
file->elem_block_ids = polymec_malloc(sizeof(int) * file->num_elem_blocks);
if (file->num_elem_blocks > 0)
ex_get_ids(file->ex_id, EX_ELEM_BLOCK, file->elem_block_ids);
file->num_face_blocks = (int)mesh_info.num_face_blk;
file->face_block_ids = polymec_malloc(sizeof(int) * file->num_face_blocks);
if (file->num_face_blocks > 0)
ex_get_ids(file->ex_id, EX_FACE_BLOCK, file->face_block_ids);
file->num_edge_blocks = (int)mesh_info.num_edge_blk;
file->edge_block_ids = polymec_malloc(sizeof(int) * file->num_edge_blocks);
if (file->num_edge_blocks > 0)
ex_get_ids(file->ex_id, EX_EDGE_BLOCK, file->edge_block_ids);
file->num_elem_sets = (int)mesh_info.num_elem_sets;
file->num_face_sets = (int)mesh_info.num_face_sets;
file->num_edge_sets = (int)mesh_info.num_edge_sets;
file->num_node_sets = (int)mesh_info.num_node_sets;
file->num_side_sets = (int)mesh_info.num_side_sets;
}
}
else
{
// By default, the title of the database is its filename.
strncpy(file->title, filename, MAX_NAME_LENGTH);
file->num_nodes = 0;
file->num_edges = 0;
file->num_faces = 0;
file->num_elem = 0;
file->num_elem_blocks = 0;
file->elem_block_ids = NULL;
file->num_face_blocks = 0;
file->face_block_ids = NULL;
file->num_edge_blocks = 0;
file->edge_block_ids = NULL;
file->num_elem_sets = 0;
file->num_face_sets = 0;
file->num_edge_sets = 0;
file->num_node_sets = 0;
file->num_side_sets = 0;
}
}
else
{
polymec_free(file);
file = NULL;
}
return file;
}
bool exodus_file_query(const char* filename,
size_t* real_size,
float* version,
int* num_mpi_processes,
real_array_t* times)
{
set_ex_opts();
if (!file_exists(filename))
return false;
bool valid = true;
bool is_parallel = false;
int my_real_size = (int)sizeof(real_t);
int io_real_size = 0;
#if POLYMEC_HAVE_MPI
MPI_Info info;
MPI_Info_create(&info);
int id = ex_open_par(filename, EX_READ, &my_real_size,
&io_real_size, version,
MPI_COMM_WORLD, info);
// Did that work? If not, try the serial opener.
if (id < 0)
{
MPI_Info_free(&info);
id = ex_open(filename, EX_READ, &my_real_size,
&io_real_size, version);
}
else
is_parallel = true;
#else
int id = ex_open(filename, EX_READ, &my_real_size,
&io_real_size, version);
#endif
if (id < 0)
valid = false;
else
{
*real_size = (size_t)io_real_size;
// Make sure that the file has 3D data.
ex_init_params mesh_info;
int status = ex_get_init_ext(id, &mesh_info);
if ((status < 0) || (mesh_info.num_dim != 3))
valid = false;
else
{
// Make sure that each of the element blocks in this file have
// valid 3D element types.
int num_elem_blocks = (int)mesh_info.num_elem_blk;
int elem_block_ids[num_elem_blocks];
ex_get_ids(id, EX_ELEM_BLOCK, elem_block_ids);
for (int i = 0; i < num_elem_blocks; ++i)
{
int elem_block = elem_block_ids[i];
char elem_type_name[MAX_NAME_LENGTH+1];
int num_elem, num_nodes_per_elem, num_faces_per_elem;
ex_get_block(id, EX_ELEM_BLOCK, elem_block,
elem_type_name, &num_elem,
&num_nodes_per_elem, NULL,
&num_faces_per_elem, NULL);
fe_mesh_element_t elem_type = get_element_type(elem_type_name);
if (elem_type == FE_INVALID)
{
valid = false;
break;
}
}
if (valid)
{
// Query the number of processes for which this file has data.
// Recently, we've had to add guards to check to see whether
// DIM_NUM_PROCS exists in the file. If it doesn't, we assume that
// the file corresponds to a serial data set.
int num_proc_in_file;
char file_type[2];
int dim_id, status1 = nc_inq_dimid(id, DIM_NUM_PROCS, &dim_id);
if (status1 == NC_NOERR)
{
ex_get_init_info(id, num_mpi_processes, &num_proc_in_file, file_type);
if (is_parallel)
{
ASSERT(*num_mpi_processes == num_proc_in_file);
}
}
else
{
*num_mpi_processes = num_proc_in_file = 1;
}
if (times != NULL)
{
// Ask for the times within the file.
int num_times = (int)ex_inquire_int(id, EX_INQ_TIME);
real_array_resize(times, num_times);
if (num_times > 0)
{
ex_get_all_times(id, times->data);
}
}
}
}
ex_close(id);
}
#if POLYMEC_HAVE_MPI
if (is_parallel)
MPI_Info_free(&info);
#endif
return valid;
}
int main(int argc, char **argv)
{
MPI_Comm mpi_comm = MPI_COMM_WORLD;
MPI_Info mpi_info = MPI_INFO_NULL;
int exoid, num_dim, num_nodes, num_elem, num_elem_blk, num_node_sets;
int num_side_sets, error;
int i, j, k, node_ctr;
int *elem_map, *connect, *node_list, *node_ctr_list, *elem_list, *side_list;
int *ids;
int *num_nodes_per_set = NULL;
int *num_elem_per_set = NULL;
int *num_df_per_set = NULL;
int *node_ind = NULL;
int *elem_ind = NULL;
int *df_ind = NULL;
int num_qa_rec, num_info;
int num_glo_vars, num_nod_vars, num_ele_vars;
int num_nset_vars, num_sset_vars;
int *truth_tab;
int num_time_steps;
int *num_elem_in_block = NULL;
int *num_nodes_per_elem = NULL;
int *num_attr = NULL;
int num_nodes_in_set, num_elem_in_set;
int num_sides_in_set, num_df_in_set;
int list_len, elem_list_len, node_list_len, df_list_len;
int node_num, time_step, var_index, beg_time, end_time, elem_num;
int CPU_word_size, IO_word_size;
int num_props, prop_value, *prop_values;
int idum;
float time_value, *time_values, *var_values;
float *x, *y, *z;
float *attrib, *dist_fact;
float version, fdum;
char *coord_names[3], *qa_record[2][4], *info[3], *var_names[3];
char *block_names[10], *nset_names[10], *sset_names[10];
char *attrib_names[10];
char name[MAX_STR_LENGTH + 1];
char title[MAX_LINE_LENGTH + 1], elem_type[MAX_STR_LENGTH + 1];
char title_chk[MAX_LINE_LENGTH + 1];
char *cdum = 0;
char *prop_names[3];
CPU_word_size = 0; /* sizeof(float) */
IO_word_size = 0; /* use what is stored in file */
ex_opts(EX_VERBOSE | EX_ABORT);
/* Initialize MPI. */
MPI_Init(&argc, &argv);
/* open EXODUS II files */
exoid = ex_open_par("test.exo", /* filename path */
EX_READ, /* access mode = READ */
&CPU_word_size, /* CPU word size */
&IO_word_size, /* IO word size */
&version, /* ExodusII library version */
mpi_comm, mpi_info);
printf("\nafter ex_open\n");
if (exoid < 0)
exit(1);
printf("test.exo is an EXODUSII file; version %4.2f\n", version);
/* printf (" CPU word size %1d\n",CPU_word_size); */
printf(" I/O word size %1d\n", IO_word_size);
ex_inquire(exoid, EX_INQ_API_VERS, &idum, &version, cdum);
printf("EXODUSII API; version %4.2f\n", version);
ex_inquire(exoid, EX_INQ_LIB_VERS, &idum, &version, cdum);
printf("EXODUSII Library API; version %4.2f (%d)\n", version, idum);
/* read database parameters */
error = ex_get_init(exoid, title, &num_dim, &num_nodes, &num_elem, &num_elem_blk, &num_node_sets,
&num_side_sets);
printf("after ex_get_init, error = %3d\n", error);
printf("database parameters:\n");
printf("title = '%s'\n", title);
printf("num_dim = %3d\n", num_dim);
printf("num_nodes = %3d\n", num_nodes);
printf("num_elem = %3d\n", num_elem);
printf("num_elem_blk = %3d\n", num_elem_blk);
printf("num_node_sets = %3d\n", num_node_sets);
printf("num_side_sets = %3d\n", num_side_sets);
/* Check that ex_inquire gives same title */
error = ex_inquire(exoid, EX_INQ_TITLE, &idum, &fdum, title_chk);
printf(" after ex_inquire, error = %d\n", error);
if (strcmp(title, title_chk) != 0) {
printf("error in ex_inquire for EX_INQ_TITLE\n");
}
/* read nodal coordinates values and names from database */
x = (float *)calloc(num_nodes, sizeof(float));
if (num_dim >= 2)
y = (float *)calloc(num_nodes, sizeof(float));
else
y = 0;
if (num_dim >= 3)
z = (float *)calloc(num_nodes, sizeof(float));
else
z = 0;
error = ex_get_coord(exoid, x, y, z);
printf("\nafter ex_get_coord, error = %3d\n", error);
printf("x coords = \n");
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\n", x[i]);
}
if (num_dim >= 2) {
printf("y coords = \n");
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\n", y[i]);
}
}
if (num_dim >= 3) {
printf("z coords = \n");
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\n", z[i]);
}
}
/*
error = ex_get_1_coord (exoid, 2, x, y, z);
printf ("\nafter ex_get_1_coord, error = %3d\n", error);
printf ("x coord of node 2 = \n");
printf ("%f \n", x[0]);
printf ("y coord of node 2 = \n");
printf ("%f \n", y[0]);
*/
free(x);
if (num_dim >= 2)
free(y);
if (num_dim >= 3)
free(z);
for (i = 0; i < num_dim; i++) {
coord_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_coord_names(exoid, coord_names);
printf("\nafter ex_get_coord_names, error = %3d\n", error);
printf("x coord name = '%s'\n", coord_names[0]);
if (num_dim > 1)
printf("y coord name = '%s'\n", coord_names[1]);
if (num_dim > 2)
printf("z coord name = '%s'\n", coord_names[2]);
for (i = 0; i < num_dim; i++)
free(coord_names[i]);
{
int num_attrs = 0;
error = ex_get_attr_param(exoid, EX_NODAL, 0, &num_attrs);
printf(" after ex_get_attr_param, error = %d\n", error);
printf("num nodal attributes = %d\n", num_attrs);
if (num_attrs > 0) {
for (j = 0; j < num_attrs; j++) {
attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_attr_names(exoid, EX_NODAL, 0, attrib_names);
printf(" after ex_get_attr_names, error = %d\n", error);
if (error == 0) {
attrib = (float *)calloc(num_nodes, sizeof(float));
for (j = 0; j < num_attrs; j++) {
printf("nodal attribute %d = '%s'\n", j, attrib_names[j]);
error = ex_get_one_attr(exoid, EX_NODAL, 0, j + 1, attrib);
printf(" after ex_get_one_attr, error = %d\n", error);
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\n", attrib[i]);
}
free(attrib_names[j]);
}
free(attrib);
}
}
}
/* read element order map */
elem_map = (int *)calloc(num_elem, sizeof(int));
error = ex_get_map(exoid, elem_map);
printf("\nafter ex_get_map, error = %3d\n", error);
for (i = 0; i < num_elem; i++) {
printf("elem_map(%d) = %d \n", i, elem_map[i]);
}
free(elem_map);
/* read element block parameters */
if (num_elem_blk > 0) {
ids = (int *)calloc(num_elem_blk, sizeof(int));
num_elem_in_block = (int *)calloc(num_elem_blk, sizeof(int));
num_nodes_per_elem = (int *)calloc(num_elem_blk, sizeof(int));
num_attr = (int *)calloc(num_elem_blk, sizeof(int));
error = ex_get_ids(exoid, EX_ELEM_BLOCK, ids);
printf("\nafter ex_get_elem_blk_ids, error = %3d\n", error);
for (i = 0; i < num_elem_blk; i++) {
printf("Block # %d is id %d\n", i, ids[i]);
block_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_names(exoid, EX_ELEM_BLOCK, block_names);
printf("\nafter ex_get_names, error = %3d\n", error);
for (i = 0; i < num_elem_blk; i++) {
ex_get_name(exoid, EX_ELEM_BLOCK, ids[i], name);
if (strcmp(name, block_names[i]) != 0) {
printf("error in ex_get_name for block id %d\n", ids[i]);
}
error = ex_get_block(exoid, EX_ELEM_BLOCK, ids[i], elem_type, &(num_elem_in_block[i]),
&(num_nodes_per_elem[i]), &(num_attr[i]));
printf("\nafter ex_get_elem_block, id = %d, error = %d\n", ids[i], error);
printf("element block id = %2d\n", ids[i]);
printf("element type = '%s'\n", elem_type);
printf("num_elem_in_block = %2d\n", num_elem_in_block[i]);
printf("num_nodes_per_elem = %2d\n", num_nodes_per_elem[i]);
printf("num_attr = %2d\n", num_attr[i]);
printf("name = '%s'\n", block_names[i]);
free(block_names[i]);
}
/* read element block properties */
error = ex_inquire(exoid, EX_INQ_EB_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
printf("\nThere are %2d properties for each element block\n", num_props);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_prop_names(exoid, EX_ELEM_BLOCK, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
for (i = 1; i < num_props; i++) /* Prop 1 is id; skip that here */
{
for (j = 0; j < num_elem_blk; j++) {
error = ex_get_prop(exoid, EX_ELEM_BLOCK, ids[j], prop_names[i], &prop_value);
if (error == 0)
printf("element block %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
prop_value);
else
printf("after ex_get_prop, error = %d\n", error);
}
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
}
/* read element connectivity */
for (i = 0; i < num_elem_blk; i++) {
if (num_elem_in_block[i] > 0) {
connect = (int *)calloc((num_nodes_per_elem[i] * num_elem_in_block[i]), sizeof(int));
error = ex_get_conn(exoid, EX_ELEM_BLOCK, ids[i], connect);
printf("\nafter ex_get_elem_conn, error = %d\n", error);
printf("connect array for elem block %2d\n", ids[i]);
for (j = 0; j < num_nodes_per_elem[i]; j++) {
printf("%3d\n", connect[j]);
}
/*
error = ex_get_1_elem_conn (exoid, 1, ids[i], connect);
printf ("\nafter ex_get_elem_conn, error = %d\n", error);
printf ("node list for first element of element block %d \n ", ids[i]);
for (j=0; j<num_nodes_per_elem[i]; j++)
{
printf ("%d \n", connect[j]);
}
*/
free(connect);
}
}
/* read element block attributes */
for (i = 0; i < num_elem_blk; i++) {
if (num_elem_in_block[i] > 0) {
for (j = 0; j < num_attr[i]; j++)
attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
attrib = (float *)calloc(num_attr[i] * num_elem_in_block[i], sizeof(float));
error = ex_get_attr(exoid, EX_ELEM_BLOCK, ids[i], attrib);
printf("\n after ex_get_elem_attr, error = %d\n", error);
if (error == 0) {
error = ex_get_attr_names(exoid, EX_ELEM_BLOCK, ids[i], attrib_names);
printf(" after ex_get_elem_attr_names, error = %d\n", error);
if (error == 0) {
printf("element block %d attribute '%s' = %6.4f\n", ids[i], attrib_names[0], *attrib);
}
}
free(attrib);
for (j = 0; j < num_attr[i]; j++)
free(attrib_names[j]);
}
}
if (num_elem_blk > 0) {
free(ids);
free(num_nodes_per_elem);
free(num_attr);
}
/* read individual node sets */
if (num_node_sets > 0) {
ids = (int *)calloc(num_node_sets, sizeof(int));
error = ex_get_ids(exoid, EX_NODE_SET, ids);
printf("\nafter ex_get_node_set_ids, error = %3d\n", error);
for (i = 0; i < num_node_sets; i++) {
nset_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_names(exoid, EX_NODE_SET, nset_names);
printf("\nafter ex_get_names, error = %3d\n", error);
for (i = 0; i < num_node_sets; i++) {
ex_get_name(exoid, EX_NODE_SET, ids[i], name);
if (strcmp(name, nset_names[i]) != 0) {
printf("error in ex_get_name for nodeset id %d\n", ids[i]);
}
error = ex_get_set_param(exoid, EX_NODE_SET, ids[i], &num_nodes_in_set, &num_df_in_set);
printf("\nafter ex_get_node_set_param, error = %3d\n", error);
printf("\nnode set %2d parameters: \n", ids[i]);
printf("num_nodes = %2d\n", num_nodes_in_set);
printf("name = '%s'\n", nset_names[i]);
free(nset_names[i]);
node_list = (int *)calloc(num_nodes_in_set, sizeof(int));
dist_fact = (float *)calloc(num_nodes_in_set, sizeof(float));
error = ex_get_set(exoid, EX_NODE_SET, ids[i], node_list);
printf("\nafter ex_get_node_set, error = %3d\n", error);
if (num_df_in_set > 0) {
error = ex_get_set_dist_fact(exoid, EX_NODE_SET, ids[i], dist_fact);
printf("\nafter ex_get_node_set_dist_fact, error = %3d\n", error);
}
printf("\nnode list for node set %2d\n", ids[i]);
for (j = 0; j < num_nodes_in_set; j++) {
printf("%3d\n", node_list[j]);
}
if (num_df_in_set > 0) {
printf("dist factors for node set %2d\n", ids[i]);
for (j = 0; j < num_nodes_in_set; j++) {
printf("%5.2f\n", dist_fact[j]);
}
}
else
printf("no dist factors for node set %2d\n", ids[i]);
free(node_list);
free(dist_fact);
{
int num_attrs = 0;
error = ex_get_attr_param(exoid, EX_NODE_SET, ids[i], &num_attrs);
printf(" after ex_get_attr_param, error = %d\n", error);
printf("num nodeset attributes for nodeset %d = %d\n", ids[i], num_attrs);
if (num_attrs > 0) {
for (j = 0; j < num_attrs; j++) {
attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_attr_names(exoid, EX_NODE_SET, ids[i], attrib_names);
printf(" after ex_get_attr_names, error = %d\n", error);
if (error == 0) {
attrib = (float *)calloc(num_nodes_in_set, sizeof(float));
for (j = 0; j < num_attrs; j++) {
printf("nodeset attribute %d = '%s'\n", j, attrib_names[j]);
error = ex_get_one_attr(exoid, EX_NODE_SET, ids[i], j + 1, attrib);
printf(" after ex_get_one_attr, error = %d\n", error);
for (k = 0; k < num_nodes_in_set; k++) {
printf("%5.1f\n", attrib[k]);
}
free(attrib_names[j]);
}
free(attrib);
}
}
}
}
free(ids);
/* read node set properties */
error = ex_inquire(exoid, EX_INQ_NS_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
printf("\nThere are %2d properties for each node set\n", num_props);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
prop_values = (int *)calloc(num_node_sets, sizeof(int));
error = ex_get_prop_names(exoid, EX_NODE_SET, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
for (i = 0; i < num_props; i++) {
error = ex_get_prop_array(exoid, EX_NODE_SET, prop_names[i], prop_values);
if (error == 0)
for (j = 0; j < num_node_sets; j++)
printf("node set %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
prop_values[j]);
else
printf("after ex_get_prop_array, error = %d\n", error);
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
free(prop_values);
/* read concatenated node sets; this produces the same information as
* the above code which reads individual node sets
*/
error = ex_inquire(exoid, EX_INQ_NODE_SETS, &num_node_sets, &fdum, cdum);
printf("\nafter ex_inquire, error = %3d\n", error);
ids = (int *)calloc(num_node_sets, sizeof(int));
num_nodes_per_set = (int *)calloc(num_node_sets, sizeof(int));
num_df_per_set = (int *)calloc(num_node_sets, sizeof(int));
node_ind = (int *)calloc(num_node_sets, sizeof(int));
df_ind = (int *)calloc(num_node_sets, sizeof(int));
error = ex_inquire(exoid, EX_INQ_NS_NODE_LEN, &list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_NS_NODE_LEN = %d, error = %3d\n", list_len, error);
node_list = (int *)calloc(list_len, sizeof(int));
error = ex_inquire(exoid, EX_INQ_NS_DF_LEN, &list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_NS_DF_LEN = %d, error = %3d\n", list_len, error);
dist_fact = (float *)calloc(list_len, sizeof(float));
error = ex_get_concat_node_sets(exoid, ids, num_nodes_per_set, num_df_per_set, node_ind, df_ind,
node_list, dist_fact);
printf("\nafter ex_get_concat_node_sets, error = %3d\n", error);
printf("\nconcatenated node set info\n");
printf("ids = \n");
for (i = 0; i < num_node_sets; i++)
printf("%3d\n", ids[i]);
printf("num_nodes_per_set = \n");
for (i = 0; i < num_node_sets; i++)
printf("%3d\n", num_nodes_per_set[i]);
printf("node_ind = \n");
for (i = 0; i < num_node_sets; i++)
printf("%3d\n", node_ind[i]);
printf("node_list = \n");
for (i = 0; i < list_len; i++)
printf("%3d\n", node_list[i]);
printf("dist_fact = \n");
for (i = 0; i < list_len; i++)
printf("%5.3f\n", dist_fact[i]);
free(ids);
free(df_ind);
free(node_ind);
free(num_df_per_set);
free(node_list);
free(dist_fact);
}
/* read individual side sets */
if (num_side_sets > 0) {
ids = (int *)calloc(num_side_sets, sizeof(int));
error = ex_get_ids(exoid, EX_SIDE_SET, ids);
printf("\nafter ex_get_side_set_ids, error = %3d\n", error);
for (i = 0; i < num_side_sets; i++) {
sset_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_names(exoid, EX_SIDE_SET, sset_names);
printf("\nafter ex_get_names, error = %3d\n", error);
for (i = 0; i < num_side_sets; i++) {
ex_get_name(exoid, EX_SIDE_SET, ids[i], name);
if (strcmp(name, sset_names[i]) != 0) {
printf("error in ex_get_name for sideset id %d\n", ids[i]);
}
error = ex_get_set_param(exoid, EX_SIDE_SET, ids[i], &num_sides_in_set, &num_df_in_set);
printf("\nafter ex_get_side_set_param, error = %3d\n", error);
printf("side set %2d parameters:\n", ids[i]);
printf("name = '%s'\n", sset_names[i]);
printf("num_sides = %3d\n", num_sides_in_set);
printf("num_dist_factors = %3d\n", num_df_in_set);
free(sset_names[i]);
/* Note: The # of elements is same as # of sides! */
num_elem_in_set = num_sides_in_set;
elem_list = (int *)calloc(num_elem_in_set, sizeof(int));
side_list = (int *)calloc(num_sides_in_set, sizeof(int));
node_ctr_list = (int *)calloc(num_elem_in_set, sizeof(int));
node_list = (int *)calloc(num_elem_in_set * 21, sizeof(int));
dist_fact = (float *)calloc(num_df_in_set, sizeof(float));
error = ex_get_set(exoid, EX_SIDE_SET, ids[i], elem_list, side_list);
printf("\nafter ex_get_side_set, error = %3d\n", error);
error = ex_get_side_set_node_list(exoid, ids[i], node_ctr_list, node_list);
printf("\nafter ex_get_side_set_node_list, error = %3d\n", error);
if (num_df_in_set > 0) {
error = ex_get_set_dist_fact(exoid, EX_SIDE_SET, ids[i], dist_fact);
printf("\nafter ex_get_side_set_dist_fact, error = %3d\n", error);
}
printf("element list for side set %2d\n", ids[i]);
for (j = 0; j < num_elem_in_set; j++) {
printf("%3d\n", elem_list[j]);
}
printf("side list for side set %2d\n", ids[i]);
for (j = 0; j < num_sides_in_set; j++) {
printf("%3d\n", side_list[j]);
}
node_ctr = 0;
printf("node list for side set %2d\n", ids[i]);
for (k = 0; k < num_elem_in_set; k++) {
for (j = 0; j < node_ctr_list[k]; j++) {
printf("%3d\n", node_list[node_ctr + j]);
}
node_ctr += node_ctr_list[k];
}
if (num_df_in_set > 0) {
printf("dist factors for side set %2d\n", ids[i]);
for (j = 0; j < num_df_in_set; j++) {
printf("%5.3f\n", dist_fact[j]);
}
}
else
printf("no dist factors for side set %2d\n", ids[i]);
free(elem_list);
free(side_list);
free(node_ctr_list);
free(node_list);
free(dist_fact);
}
/* read side set properties */
error = ex_inquire(exoid, EX_INQ_SS_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
printf("\nThere are %2d properties for each side set\n", num_props);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_prop_names(exoid, EX_SIDE_SET, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
for (i = 0; i < num_props; i++) {
for (j = 0; j < num_side_sets; j++) {
error = ex_get_prop(exoid, EX_SIDE_SET, ids[j], prop_names[i], &prop_value);
if (error == 0)
printf("side set %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
prop_value);
else
printf("after ex_get_prop, error = %d\n", error);
}
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
free(ids);
error = ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_SIDE_SETS = %d, error = %d\n", num_side_sets, error);
if (num_side_sets > 0) {
error = ex_inquire(exoid, EX_INQ_SS_ELEM_LEN, &elem_list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_SS_ELEM_LEN = %d, error = %d\n", elem_list_len, error);
error = ex_inquire(exoid, EX_INQ_SS_NODE_LEN, &node_list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_SS_NODE_LEN = %d, error = %d\n", node_list_len, error);
error = ex_inquire(exoid, EX_INQ_SS_DF_LEN, &df_list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_SS_DF_LEN = %d, error = %d\n", df_list_len, error);
}
/* read concatenated side sets; this produces the same information as
* the above code which reads individual side sets
*/
/* concatenated side set read */
if (num_side_sets > 0) {
ids = (int *)calloc(num_side_sets, sizeof(int));
num_elem_per_set = (int *)calloc(num_side_sets, sizeof(int));
num_df_per_set = (int *)calloc(num_side_sets, sizeof(int));
elem_ind = (int *)calloc(num_side_sets, sizeof(int));
df_ind = (int *)calloc(num_side_sets, sizeof(int));
elem_list = (int *)calloc(elem_list_len, sizeof(int));
side_list = (int *)calloc(elem_list_len, sizeof(int));
dist_fact = (float *)calloc(df_list_len, sizeof(float));
error = ex_get_concat_side_sets(exoid, ids, num_elem_per_set, num_df_per_set, elem_ind,
df_ind, elem_list, side_list, dist_fact);
printf("\nafter ex_get_concat_side_sets, error = %3d\n", error);
printf("concatenated side set info\n");
printf("ids = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", ids[i]);
printf("num_elem_per_set = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", num_elem_per_set[i]);
printf("num_dist_per_set = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", num_df_per_set[i]);
printf("elem_ind = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", elem_ind[i]);
printf("dist_ind = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", df_ind[i]);
printf("elem_list = \n");
for (i = 0; i < elem_list_len; i++)
printf("%3d\n", elem_list[i]);
printf("side_list = \n");
for (i = 0; i < elem_list_len; i++)
printf("%3d\n", side_list[i]);
printf("dist_fact = \n");
for (i = 0; i < df_list_len; i++)
printf("%5.3f\n", dist_fact[i]);
free(ids);
free(num_df_per_set);
free(df_ind);
free(elem_ind);
free(elem_list);
free(side_list);
free(dist_fact);
}
}
/* end of concatenated side set read */
/* read QA records */
ex_inquire(exoid, EX_INQ_QA, &num_qa_rec, &fdum, cdum);
for (i = 0; i < num_qa_rec; i++) {
for (j = 0; j < 4; j++) {
qa_record[i][j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
}
error = ex_get_qa(exoid, qa_record);
printf("\nafter ex_get_qa, error = %3d\n", error);
printf("QA records = \n");
for (i = 0; i < num_qa_rec; i++) {
for (j = 0; j < 4; j++) {
printf(" '%s'\n", qa_record[i][j]);
free(qa_record[i][j]);
}
}
/* read information records */
error = ex_inquire(exoid, EX_INQ_INFO, &num_info, &fdum, cdum);
printf("\nafter ex_inquire, error = %3d\n", error);
for (i = 0; i < num_info; i++) {
info[i] = (char *)calloc((MAX_LINE_LENGTH + 1), sizeof(char));
}
error = ex_get_info(exoid, info);
printf("\nafter ex_get_info, error = %3d\n", error);
printf("info records = \n");
for (i = 0; i < num_info; i++) {
printf(" '%s'\n", info[i]);
free(info[i]);
}
/* read global variables parameters and names */
error = ex_get_variable_param(exoid, EX_GLOBAL, &num_glo_vars);
printf("\nafter ex_get_variable_param, error = %3d\n", error);
for (i = 0; i < num_glo_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_variable_names(exoid, EX_GLOBAL, num_glo_vars, var_names);
printf("\nafter ex_get_variable_names, error = %3d\n", error);
printf("There are %2d global variables; their names are :\n", num_glo_vars);
for (i = 0; i < num_glo_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
/* read nodal variables parameters and names */
num_nod_vars = 0;
if (num_nodes > 0) {
error = ex_get_variable_param(exoid, EX_NODE_SET, &num_nod_vars);
printf("\nafter ex_get_variable_param, error = %3d\n", error);
for (i = 0; i < num_nod_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_variable_names(exoid, EX_NODAL, num_nod_vars, var_names);
printf("\nafter ex_get_variable_names, error = %3d\n", error);
printf("There are %2d nodal variables; their names are :\n", num_nod_vars);
for (i = 0; i < num_nod_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
}
/* read element variables parameters and names */
num_ele_vars = 0;
if (num_elem > 0) {
error = ex_get_variable_param(exoid, EX_ELEM_BLOCK, &num_ele_vars);
printf("\nafter ex_get_variable_param, error = %3d\n", error);
for (i = 0; i < num_ele_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_variable_names(exoid, EX_ELEM_BLOCK, num_ele_vars, var_names);
printf("\nafter ex_get_variable_names, error = %3d\n", error);
printf("There are %2d element variables; their names are :\n", num_ele_vars);
for (i = 0; i < num_ele_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
/* read element variable truth table */
if (num_ele_vars > 0) {
truth_tab = (int *)calloc((num_elem_blk * num_ele_vars), sizeof(int));
error = ex_get_truth_table(exoid, EX_ELEM_BLOCK, num_elem_blk, num_ele_vars, truth_tab);
printf("\nafter ex_get_elem_var_tab, error = %3d\n", error);
printf("This is the element variable truth table:\n");
k = 0;
for (i = 0; i < num_elem_blk * num_ele_vars; i++) {
printf("%2d\n", truth_tab[k++]);
}
free(truth_tab);
}
}
/* read nodeset variables parameters and names */
num_nset_vars = 0;
if (num_node_sets > 0) {
error = ex_get_variable_param(exoid, "m", &num_nset_vars);
printf("\nafter ex_get_variable_param, error = %3d\n", error);
if (num_nset_vars > 0) {
for (i = 0; i < num_nset_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_variable_names(exoid, "m", num_nset_vars, var_names);
printf("\nafter ex_get_variable_names, error = %3d\n", error);
printf("There are %2d nodeset variables; their names are :\n", num_nset_vars);
for (i = 0; i < num_nset_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
/* read nodeset variable truth table */
if (num_nset_vars > 0) {
truth_tab = (int *)calloc((num_node_sets * num_nset_vars), sizeof(int));
error = ex_get_truth_table(exoid, EX_NODE_SET, num_node_sets, num_nset_vars, truth_tab);
printf("\nafter ex_get_nset_var_tab, error = %3d\n", error);
printf("This is the nodeset variable truth table:\n");
k = 0;
for (i = 0; i < num_node_sets * num_nset_vars; i++) {
printf("%2d\n", truth_tab[k++]);
}
free(truth_tab);
}
}
}
/* read sideset variables parameters and names */
num_sset_vars = 0;
if (num_side_sets > 0) {
error = ex_get_variable_param(exoid, EX_SIDE_SET, &num_sset_vars);
printf("\nafter ex_get_variable_param, error = %3d\n", error);
if (num_sset_vars > 0) {
for (i = 0; i < num_sset_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_variable_names(exoid, EX_SIDE_SET, num_sset_vars, var_names);
printf("\nafter ex_get_variable_names, error = %3d\n", error);
printf("There are %2d sideset variables; their names are :\n", num_sset_vars);
for (i = 0; i < num_sset_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
/* read sideset variable truth table */
if (num_sset_vars > 0) {
truth_tab = (int *)calloc((num_side_sets * num_sset_vars), sizeof(int));
error = ex_get_truth_table(exoid, EX_SIDE_SET, num_side_sets, num_sset_vars, truth_tab);
printf("\nafter ex_get_sset_var_tab, error = %3d\n", error);
printf("This is the sideset variable truth table:\n");
k = 0;
for (i = 0; i < num_side_sets * num_sset_vars; i++) {
printf("%2d\n", truth_tab[k++]);
}
free(truth_tab);
}
}
}
/* determine how many time steps are stored */
error = ex_inquire(exoid, EX_INQ_TIME, &num_time_steps, &fdum, cdum);
printf("\nafter ex_inquire, error = %3d\n", error);
printf("There are %2d time steps in the database.\n", num_time_steps);
/* read time value at one time step */
time_step = 3;
error = ex_get_time(exoid, time_step, &time_value);
printf("\nafter ex_get_time, error = %3d\n", error);
printf("time value at time step %2d = %5.3f\n", time_step, time_value);
/* read time values at all time steps */
time_values = (float *)calloc(num_time_steps, sizeof(float));
error = ex_get_all_times(exoid, time_values);
printf("\nafter ex_get_all_times, error = %3d\n", error);
printf("time values at all time steps are:\n");
for (i = 0; i < num_time_steps; i++)
printf("%5.3f\n", time_values[i]);
free(time_values);
/* read all global variables at one time step */
var_values = (float *)calloc(num_glo_vars, sizeof(float));
error = ex_get_glob_vars(exoid, time_step, num_glo_vars, var_values);
printf("\nafter ex_get_glob_vars, error = %3d\n", error);
printf("global variable values at time step %2d\n", time_step);
for (i = 0; i < num_glo_vars; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
/* read a single global variable through time */
var_index = 1;
beg_time = 1;
end_time = -1;
var_values = (float *)calloc(num_time_steps, sizeof(float));
error = ex_get_glob_var_time(exoid, var_index, beg_time, end_time, var_values);
printf("\nafter ex_get_glob_var_time, error = %3d\n", error);
printf("global variable %2d values through time:\n", var_index);
for (i = 0; i < num_time_steps; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
/* read a nodal variable at one time step */
if (num_nodes > 0) {
var_values = (float *)calloc(num_nodes, sizeof(float));
error = ex_get_var(exoid, time_step, EX_NODAL, var_index, 1, num_nodes, var_values);
printf("\nafter ex_get_nodal_var, error = %3d\n", error);
printf("nodal variable %2d values at time step %2d\n", var_index, time_step);
for (i = 0; i < num_nodes; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
/* read a nodal variable through time */
var_values = (float *)calloc(num_time_steps, sizeof(float));
node_num = 1;
error = ex_get_var_time(exoid, EX_NODAL, var_index, node_num, beg_time, end_time, var_values);
printf("\nafter ex_get_nodal_var_time, error = %3d\n", error);
printf("nodal variable %2d values for node %2d through time:\n", var_index, node_num);
for (i = 0; i < num_time_steps; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
}
/* read an element variable at one time step */
if (num_elem_blk > 0) {
ids = (int *)calloc(num_elem_blk, sizeof(int));
error = ex_get_ids(exoid, EX_ELEM_BLOCK, ids);
printf("\n after ex_get_elem_blk_ids, error = %3d\n", error);
for (i = 0; i < num_elem_blk; i++) {
if (num_elem_in_block[i] > 0) {
var_values = (float *)calloc(num_elem_in_block[i], sizeof(float));
error = ex_get_var(exoid, time_step, EX_ELEM_BLOCK, var_index, ids[i], num_elem_in_block[i],
var_values);
printf("\nafter ex_get_elem_var, error = %3d\n", error);
if (!error) {
printf("element variable %2d values of element block %2d at time step %2d\n", var_index,
ids[i], time_step);
for (j = 0; j < num_elem_in_block[i]; j++)
printf("%5.3f\n", var_values[j]);
}
free(var_values);
}
}
free(num_elem_in_block);
free(ids);
}
/* read an element variable through time */
if (num_ele_vars > 0) {
var_values = (float *)calloc(num_time_steps, sizeof(float));
var_index = 2;
elem_num = 2;
error =
ex_get_var_time(exoid, EX_ELEM_BLOCK, var_index, elem_num, beg_time, end_time, var_values);
printf("\nafter ex_get_elem_var_time, error = %3d\n", error);
printf("element variable %2d values for element %2d through time:\n", var_index, elem_num);
for (i = 0; i < num_time_steps; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
}
/* read a sideset variable at one time step */
if (num_sset_vars > 0) {
ids = (int *)calloc(num_side_sets, sizeof(int));
error = ex_get_ids(exoid, EX_SIDE_SET, ids);
printf("\n after ex_get_side_set_ids, error = %3d\n", error);
for (i = 0; i < num_side_sets; i++) {
var_values = (float *)calloc(num_elem_per_set[i], sizeof(float));
error = ex_get_var(exoid, time_step, EX_SIDE_SET, var_index, ids[i], num_elem_per_set[i],
var_values);
printf("\nafter ex_get_sset_var, error = %3d\n", error);
if (!error) {
printf("sideset variable %2d values of sideset %2d at time step %2d\n", var_index, ids[i],
time_step);
for (j = 0; j < num_elem_per_set[i]; j++)
printf("%5.3f\n", var_values[j]);
}
free(var_values);
}
free(num_elem_per_set);
free(ids);
}
/* read a nodeset variable at one time step */
if (num_nset_vars > 0) {
ids = (int *)calloc(num_node_sets, sizeof(int));
error = ex_get_ids(exoid, EX_NODE_SET, ids);
printf("\n after ex_get_node_set_ids, error = %3d\n", error);
for (i = 0; i < num_node_sets; i++) {
var_values = (float *)calloc(num_nodes_per_set[i], sizeof(float));
error = ex_get_var(exoid, time_step, EX_NODE_SET, var_index, ids[i], num_nodes_per_set[i],
var_values);
printf("\nafter ex_get_nset_var, error = %3d\n", error);
if (!error) {
printf("nodeset variable %2d values of nodeset %2d at time step %2d\n", var_index, ids[i],
time_step);
for (j = 0; j < num_nodes_per_set[i]; j++)
printf("%5.3f\n", var_values[j]);
}
free(var_values);
}
free(ids);
}
if (num_node_sets > 0)
free(num_nodes_per_set);
error = ex_close(exoid);
printf("\nafter ex_close, error = %3d\n", error);
MPI_Finalize();
return 0;
}
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_side_set_node_count(int exoid, ex_entity_id side_set_id, int *side_set_node_cnt_list)
{
int ii, i, j;
int num_side_sets, num_elem_blks, ndim;
size_t tot_num_ss_elem = 0;
int64_t side, elem;
void_int *elem_blk_ids = NULL;
void_int *ss_elem_ndx = NULL;
void_int *side_set_elem_list = NULL;
void_int *side_set_side_list = NULL;
size_t elem_ctr;
struct elem_blk_parm *elem_blk_parms = NULL;
char errmsg[MAX_ERR_LENGTH];
int err_stat = EX_NOERR;
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS);
if (num_side_sets < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "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) {
snprintf(errmsg, MAX_ERR_LENGTH, "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, EX_SIDE_SET, side_set_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: side set %" PRId64 " is NULL in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_count", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate side set %" PRId64 " 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);
}
num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
if (num_elem_blks < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "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);
}
/* get the dimensionality of the coordinates; this is necessary to
distinguish between 2d TRIs and 3d TRIs */
ndim = ex_inquire_int(exoid, EX_INQ_DIM);
if (ndim < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get dimensionality in file id %d", exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
int int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* First determine the # of elements in the side set*/
int err;
if (int_size == sizeof(int64_t)) {
int64_t ss_elem = 0;
int64_t ss_df = 0;
err = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &ss_elem, &ss_df);
tot_num_ss_elem = ss_elem;
}
else {
int ss_elem = 0;
int ss_df = 0;
err = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &ss_elem, &ss_df);
tot_num_ss_elem = ss_elem;
}
if (err == -1) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of elements in side set %" PRId64 " 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 * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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 * int_size))) {
free(side_set_elem_list);
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_set(exoid, EX_SIDE_SET, side_set_id, side_set_elem_list, side_set_side_list) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the ss element index array */
if (!(ss_elem_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
err_stat = EX_FATAL;
goto cleanup;
}
if (int_size == sizeof(int64_t)) {
/* Sort side set element list into index array - non-destructive */
int64_t *elems = (int64_t *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort64(side_set_elem_list, elems, tot_num_ss_elem);
}
else {
/* Sort side set element list into index array - non-destructive */
int *elems = (int *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort(side_set_elem_list, elems, tot_num_ss_elem);
}
}
/* Allocate space for the element block ids */
{
int int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
int_size = sizeof(int64_t);
}
if (!(elem_blk_ids = malloc(num_elem_blks * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block ids "
"for file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element block ids in file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
}
/* Allocate space for the element block params */
if (!(elem_blk_parms = malloc(num_elem_blks * sizeof(struct elem_blk_parm)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block params "
"for file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = 0;
for (i = 0; i < num_elem_blks; i++) {
ex_entity_id id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
id = ((int64_t *)elem_blk_ids)[i];
}
else {
id = ((int *)elem_blk_ids)[i];
}
err_stat = ex_int_get_block_param(exoid, id, ndim, &elem_blk_parms[i]);
if (err_stat != EX_NOERR) {
goto cleanup;
}
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++) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
i = ((int64_t *)ss_elem_ndx)[ii];
elem = ((int64_t *)side_set_elem_list)[i];
side = ((int64_t *)side_set_side_list)[i] - 1; /* Convert to 0-based sides */
}
else {
i = ((int *)ss_elem_ndx)[ii];
elem = ((int *)side_set_elem_list)[i];
side = ((int *)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;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: Invalid element number %" PRId64 " found in side set %" PRId64 " in file %d",
elem, side_set_id, exoid);
ex_err("ex_get_side_set_node_count", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
}
/* All done: release connectivity array space, element block ids
* array, element block parameters array, and side set element index
* array
*/
cleanup:
free(elem_blk_ids);
free(elem_blk_parms);
free(ss_elem_ndx);
free(side_set_side_list);
free(side_set_elem_list);
return (err_stat);
}
void NemSpread<T,INT>::read_restart_data ()
/* Function which reads the restart variable data from the EXODUS II
* database which contains the results information. Then distribute
* it to the processors, and write it to the parallel exodus files.
*
*----------------------------------------------------------------------------
*
* Functions called:
*
* read_vars -- function which reads the variable values from the restart
* file, and then distributes them to the processors
*
* write_var_timestep -- function which writes out the variables for a
* to a parallel ExodusII file.
*
*----------------------------------------------------------------------------
*/
{
const char *yo="read_restart_data";
/* need to get the element block ids and counts */
std::vector<INT> eb_ids_global(globals.Num_Elem_Blk);
std::vector<INT> eb_cnts_global(globals.Num_Elem_Blk);
std::vector<INT> ss_ids_global(globals.Num_Side_Set);
std::vector<INT> ss_cnts_global(globals.Num_Side_Set);
std::vector<INT> ns_ids_global(globals.Num_Node_Set);
std::vector<INT> ns_cnts_global(globals.Num_Node_Set);
INT ***eb_map_ptr = NULL, **eb_cnts_local = NULL;
int exoid=0, *par_exoid = NULL;
float vers;
char cTemp[512];
/* computing precision should be the same as the database precision
*
* EXCEPTION: if the io_ws is smaller than the machine precision,
* ie - database with io_ws == 4 on a Cray (sizeof(float) == 8),
* then the cpu_ws must be the machine precision.
*/
int cpu_ws;
if (io_ws < (int)sizeof(float)) cpu_ws = sizeof(float);
else cpu_ws = io_ws;
/* Open the ExodusII file */
{
cpu_ws = io_ws;
int mode = EX_READ | int64api;
if ((exoid=ex_open(Exo_Res_File, mode, &cpu_ws, &io_ws, &vers)) < 0) {
fprintf(stderr, "%s: Could not open file %s for restart info\n",
yo, Exo_Res_File);
exit(1);
}
}
/* allocate space for the global variables */
Restart_Info.Glob_Vals.resize(Restart_Info.NVar_Glob);
if (Restart_Info.NVar_Elem > 0 ) {
/* allocate storage space */
Restart_Info.Elem_Vals.resize(Proc_Info[2]);
/* now allocate storage for the values */
for (int iproc = 0; iproc <Proc_Info[2]; iproc++) {
size_t array_size = Restart_Info.NVar_Elem *
(globals.Num_Internal_Elems[iproc] + globals.Num_Border_Elems[iproc]);
Restart_Info.Elem_Vals[iproc].resize(array_size);
}
/*
* at this point, I need to broadcast the global element block ids
* and counts to the processors. I know that this is redundant data
* since they will all receive this information in read_mesh, but
* the variables which contain that information are static in
* el_exoII_io.c, and cannot be used here. So, take a second and
* broadcast all of this out.
*
* I want to do this here so that it is done only once no matter
* how many time steps are retrieved
*/
/* Get the Element Block IDs from the input file */
if (ex_get_ids (exoid, EX_ELEM_BLOCK, TOPTR(eb_ids_global)) < 0)
{
fprintf(stderr, "%s: unable to get element block IDs", yo);
exit(1);
}
/* Get the count of elements in each element block */
for (int cnt = 0; cnt < globals.Num_Elem_Blk; cnt++) {
if (ex_get_block(exoid, EX_ELEM_BLOCK, eb_ids_global[cnt], cTemp,
&(eb_cnts_global[cnt]), NULL, NULL, NULL, NULL) < 0) {
fprintf(stderr, "%s: unable to get element count for block id "ST_ZU"",
yo, (size_t)eb_ids_global[cnt]);
exit(1);
}
}
/*
* in order to speed up finding matches in the global element
* number map, set up an array of pointers to the start of
* each element block's global element number map. That way
* only entries for the current element block have to be searched
*/
eb_map_ptr = (INT ***) array_alloc (__FILE__, __LINE__, 2,Proc_Info[2],
globals.Num_Elem_Blk, sizeof(INT *));
if (!eb_map_ptr) {
fprintf(stderr, "[%s]: ERROR, insufficient memory!\n", yo);
exit(1);
}
eb_cnts_local = (INT **) array_alloc (__FILE__, __LINE__, 2,Proc_Info[2],
globals.Num_Elem_Blk, sizeof(INT));
if (!eb_cnts_local) {
fprintf(stderr, "[%s]: ERROR, insufficient memory!\n", yo);
exit(1);
}
/*
* for now, assume that element blocks have been
* stored in the same order as the global blocks
*/
for (int iproc = 0; iproc <Proc_Info[2]; iproc++) {
int ifound = 0;
size_t offset = 0;
int ilocal;
for (int cnt = 0; cnt < globals.Num_Elem_Blk; cnt++) {
for (ilocal = ifound; ilocal < globals.Proc_Num_Elem_Blk[iproc]; ilocal++) {
if (globals.Proc_Elem_Blk_Ids[iproc][ilocal] == eb_ids_global[cnt])
break;
}
if (ilocal < globals.Proc_Num_Elem_Blk[iproc]) {
eb_map_ptr[iproc][cnt] = &globals.GElems[iproc][offset];
eb_cnts_local[iproc][cnt] = globals.Proc_Num_Elem_In_Blk[iproc][ilocal];
offset += globals.Proc_Num_Elem_In_Blk[iproc][ilocal];
ifound = ilocal; /* don't search the same part of the list over */
}
else {
eb_map_ptr[iproc][cnt] = NULL;
eb_cnts_local[iproc][cnt] = 0;
}
}
}
} /* End: "if (Restart_Info.NVar_Elem > 0 )" */
if (Restart_Info.NVar_Node > 0 ) {
/* allocate storage space */
Restart_Info.Node_Vals.resize(Proc_Info[2]);
/* now allocate storage for the values */
for (int iproc = 0; iproc <Proc_Info[2]; iproc++) {
size_t array_size = Restart_Info.NVar_Node * (globals.Num_Internal_Nodes[iproc] +
globals.Num_Border_Nodes[iproc] + globals.Num_External_Nodes[iproc]);
Restart_Info.Node_Vals[iproc].resize(array_size);
}
}
if (Restart_Info.NVar_Sset > 0 ) {
/* allocate storage space */
Restart_Info.Sset_Vals.resize(Proc_Info[2]);
/* now allocate storage for the values */
for (int iproc = 0; iproc <Proc_Info[2]; iproc++) {
size_t array_size = Restart_Info.NVar_Sset * globals.Proc_SS_Elem_List_Length[iproc];
Restart_Info.Sset_Vals[iproc].resize(array_size);
}
/*
* at this point, I need to broadcast the ids and counts to the
* processors. I know that this is redundant data since they will
* all receive this information in read_mesh, but the variables
* which contain that information are static in el_exoII_io.c, and
* cannot be used here. So, take a second and broadcast all of
* this out.
*
* I want to do this here so that it is done only once no matter
* how many time steps are retrieved
*/
/* Get the Sideset IDs from the input file */
if (ex_get_ids (exoid, EX_SIDE_SET, TOPTR(ss_ids_global)) < 0) {
fprintf(stderr, "%s: unable to get sideset IDs", yo);
exit(1);
}
/* Get the count of elements in each sideset */
for (int cnt = 0; cnt < globals.Num_Side_Set; cnt++) {
if (ex_get_set_param(exoid, EX_SIDE_SET,
ss_ids_global[cnt],
&(ss_cnts_global[cnt]), NULL) < 0) {
fprintf(stderr, "%s: unable to get element count for sideset id "ST_ZU"",
yo, (size_t)ss_ids_global[cnt]);
exit(1);
}
}
} /* End: "if (Restart_Info.NVar_Sset > 0 )" */
if (Restart_Info.NVar_Nset > 0 ) {
/* allocate storage space */
Restart_Info.Nset_Vals.resize(Proc_Info[2]);
/* now allocate storage for the values */
for (int iproc = 0; iproc <Proc_Info[2]; iproc++) {
size_t array_size = Restart_Info.NVar_Nset * globals.Proc_NS_List_Length[iproc];
Restart_Info.Nset_Vals[iproc].resize(array_size);
}
/*
* at this point, I need to broadcast the ids and counts to the
* processors. I know that this is redundant data since they will
* all receive this information in read_mesh, but the variables
* which contain that information are static in el_exoII_io.c, and
* cannot be used here. So, take a second and broadcast all of
* this out.
*
* I want to do this here so that it is done only once no matter
* how many time steps are retrieved
*/
/* Get the Nodeset IDs from the input file */
if (ex_get_ids (exoid, EX_NODE_SET, TOPTR(ns_ids_global)) < 0) {
fprintf(stderr, "%s: unable to get nodeset IDs", yo);
exit(1);
}
/* Get the count of elements in each nodeset */
for (int cnt = 0; cnt < globals.Num_Node_Set; cnt++) {
if (ex_get_set_param(exoid, EX_NODE_SET,
ns_ids_global[cnt],
&(ns_cnts_global[cnt]), NULL) < 0) {
fprintf(stderr, "%s: unable to get element count for nodeset id "ST_ZU"",
yo, (size_t)ns_ids_global[cnt]);
exit(1);
}
}
} /* End: "if (Restart_Info.NVar_Nset > 0 )" */
/*
* NOTE: A possible place to speed this up would be to
* get the global node and element lists here, and broadcast
* them out only once.
*/
par_exoid = (int*)malloc(Proc_Info[2] * sizeof(int));
if(!par_exoid) {
fprintf(stderr, "[%s]: ERROR, insufficient memory!\n",
yo);
exit(1);
}
/* See if any '/' in the name. IF present, isolate the basename of the file */
if (strrchr(PIO_Info.Scalar_LB_File_Name, '/') != NULL) {
/* There is a path separator. Get the portion after the
* separator
*/
strcpy(cTemp, strrchr(PIO_Info.Scalar_LB_File_Name, '/')+1);
} else {
/* No separator; this is already just the basename... */
strcpy(cTemp, PIO_Info.Scalar_LB_File_Name);
}
if (strlen(PIO_Info.Exo_Extension) == 0)
add_fname_ext(cTemp, ".par");
else
add_fname_ext(cTemp, PIO_Info.Exo_Extension);
int open_file_count = get_free_descriptor_count();
if (open_file_count >Proc_Info[5]) {
printf("All output files opened simultaneously.\n");
for (int iproc=Proc_Info[4]; iproc <Proc_Info[4]+Proc_Info[5]; iproc++) {
gen_par_filename(cTemp, Par_Nem_File_Name, Proc_Ids[iproc],
Proc_Info[0]);
/* Open the parallel Exodus II file for writing */
cpu_ws = io_ws;
int mode = EX_WRITE | int64api | int64db;
if ((par_exoid[iproc]=ex_open(Par_Nem_File_Name, mode, &cpu_ws,
&io_ws, &vers)) < 0) {
fprintf(stderr,"[%d] %s Could not open parallel Exodus II file: %s\n",
iproc, yo, Par_Nem_File_Name);
exit(1);
}
}
} else {
printf("All output files opened one-at-a-time.\n");
}
/* Now loop over the number of time steps */
for (int time_idx = 0; time_idx < Restart_Info.Num_Times; time_idx++) {
double start_t = second ();
/* read and distribute the variables for this time step */
if (read_vars(exoid, Restart_Info.Time_Idx[time_idx],
TOPTR(eb_ids_global), TOPTR(eb_cnts_global), eb_map_ptr,
eb_cnts_local,
TOPTR(ss_ids_global), TOPTR(ss_cnts_global),
TOPTR(ns_ids_global), TOPTR(ns_cnts_global)) < 0) {
fprintf(stderr, "%s: Error occured while reading variables\n",
yo);
exit(1);
}
double end_t = second () - start_t;
printf ("\tTime to read vars for timestep %d: %f (sec.)\n", (time_idx+1), end_t);
start_t = second ();
for (int iproc=Proc_Info[4]; iproc <Proc_Info[4]+Proc_Info[5]; iproc++) {
if (open_file_count <Proc_Info[5]) {
gen_par_filename(cTemp, Par_Nem_File_Name, Proc_Ids[iproc],
Proc_Info[0]);
/* Open the parallel Exodus II file for writing */
cpu_ws = io_ws;
int mode = EX_WRITE | int64api | int64db;
if ((par_exoid[iproc]=ex_open(Par_Nem_File_Name, mode, &cpu_ws,
&io_ws, &vers)) < 0) {
fprintf(stderr,"[%d] %s Could not open parallel Exodus II file: %s\n",
iproc, yo, Par_Nem_File_Name);
exit(1);
}
}
/*
* Write out the variable data for the time steps in this
* block to each parallel file.
*/
write_var_timestep(par_exoid[iproc], iproc, (time_idx+1),
TOPTR(eb_ids_global), TOPTR(ss_ids_global), TOPTR(ns_ids_global));
if (iproc%10 == 0 || iproc ==Proc_Info[2]-1)
printf("%d", iproc);
else
printf(".");
if (open_file_count <Proc_Info[5]) {
if (ex_close(par_exoid[iproc]) == -1) {
fprintf(stderr, "[%d] %s Could not close the parallel Exodus II file.\n",
iproc, yo);
exit(1);
}
}
} /* End "for (iproc=0; iproc <Proc_Info[2]; iproc++)" */
end_t = second () - start_t;
printf ("\n\tTime to write vars for timestep %d: %f (sec.)\n", (time_idx+1), end_t);
}
if (Restart_Info.NVar_Elem > 0 ) {
safe_free((void **) &eb_map_ptr);
safe_free((void **) &eb_cnts_local);
}
/* Close the restart exodus II file */
if (ex_close(exoid) == -1) {
fprintf(stderr, "%sCould not close the restart Exodus II file\n",
yo);
exit(1);
}
if (open_file_count >Proc_Info[5]) {
for (int iproc=Proc_Info[4]; iproc <Proc_Info[4]+Proc_Info[5]; iproc++) {
/* Close the parallel exodus II file */
if (ex_close(par_exoid[iproc]) == -1) {
fprintf(stderr, "[%d] %s Could not close the parallel Exodus II file.\n",
iproc, yo);
exit(1);
}
}
}
if (par_exoid != NULL) {
free(par_exoid);
par_exoid = NULL;
}
}
int ex_cvt_nodes_to_sides(int exoid, void_int *num_elem_per_set, void_int *num_nodes_per_set,
void_int *side_sets_elem_index, /* unused */
void_int *side_sets_node_index, /* unused */
void_int *side_sets_elem_list, void_int *side_sets_node_list,
void_int *side_sets_side_list)
{
size_t i, j, k, n;
int num_side_sets, num_elem_blks;
int64_t tot_num_elem = 0, tot_num_ss_elem = 0, elem_num = 0, ndim;
void_int *elem_blk_ids = NULL;
void_int *connect = NULL;
void_int *ss_elem_ndx = NULL;
void_int *ss_elem_node_ndx = NULL;
void_int *ss_parm_ndx = NULL;
size_t elem_ctr, node_ctr, elem_num_pos;
int num_nodes_per_elem, num_node_per_side;
int *same_elem_type = NULL;
int el_type = 0;
int int_size;
int ids_size;
struct elem_blk_parm *elem_blk_parms = NULL;
int err_stat = EX_NOERR;
/* 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];
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS);
if (num_side_sets < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "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) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no side sets defined in file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, EX_WARN);
return (EX_WARN);
}
num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
if (num_elem_blks < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "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);
}
tot_num_elem = ex_inquire_int(exoid, EX_INQ_ELEM);
if (tot_num_elem < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "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 */
ndim = ex_inquire_int(exoid, EX_INQ_DIM);
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* First count up # of elements in the side sets*/
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
for (i = 0; i < num_side_sets; i++) {
tot_num_ss_elem += ((int64_t *)num_elem_per_set)[i];
}
}
else {
for (i = 0; i < num_side_sets; i++) {
tot_num_ss_elem += ((int *)num_elem_per_set)[i];
}
}
/* Allocate space for the ss element index array */
if (!(ss_elem_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
err_stat = EX_FATAL;
goto cleanup;
}
if (int_size == sizeof(int64_t)) {
/* Sort side set element list into index array - non-destructive */
int64_t *elems = (int64_t *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort64(side_sets_elem_list, elems, tot_num_ss_elem);
}
else {
/* Sort side set element list into index array - non-destructive */
int *elems = (int *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort(side_sets_elem_list, elems, tot_num_ss_elem);
}
/* Allocate space for the element block ids */
ids_size = sizeof(int);
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
ids_size = sizeof(int64_t);
}
if (!(elem_blk_ids = malloc(num_elem_blks * ids_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate space for element block ids for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids)) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element block ids in file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the element block params */
if (!(elem_blk_parms = malloc(num_elem_blks * sizeof(struct elem_blk_parm)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block params "
"for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = 0;
for (i = 0; i < num_elem_blks; i++) {
ex_entity_id id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
id = ((int64_t *)elem_blk_ids)[i];
}
else {
id = ((int *)elem_blk_ids)[i];
}
err_stat = ex_int_get_block_param(exoid, id, ndim, &elem_blk_parms[i]);
if (err_stat != EX_NOERR) {
goto cleanup;
}
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 * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the ss element to node list index array */
if (!(ss_elem_node_ndx = malloc((tot_num_ss_elem + 1) * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
err_stat = EX_FATAL;
goto cleanup;
}
/* 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)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element type flag "
"array for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
same_elem_type[0] = EX_TRUE;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
elem_ctr = ((int64_t *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int64_t elem = ((int64_t *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
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 += ((int64_t *)num_elem_per_set)[++k];
el_type = elem_blk_parms[j].elem_type_val;
same_elem_type[k] = EX_TRUE;
}
if (el_type != elem_blk_parms[j].elem_type_val) {
same_elem_type[k] = EX_FALSE;
}
}
/* Build side set element to node list index and side set element
parameter index.
*/
node_ctr = 0;
elem_ctr = ((int64_t *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int64_t elem = ((int64_t *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
((int64_t *)ss_parm_ndx)[i] = j; /* assign parameter block index */
((int64_t *)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 (((int64_t *)num_elem_per_set)[++k] == 0) {
;
}
elem_ctr += ((int64_t *)num_elem_per_set)[k];
}
/* determine number of nodes per side */
if (((((int64_t *)num_nodes_per_set)[k] % ((int64_t *)num_elem_per_set)[k]) == 0) &&
(same_elem_type[k] == EX_TRUE)) { /* all side set elements are same type */
node_ctr += ((int64_t *)num_nodes_per_set)[k] / ((int64_t *)num_elem_per_set)[k];
}
else {
node_ctr += elem_blk_parms[j].num_nodes_per_side[0];
}
}
((int64_t *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
}
else {
elem_ctr = ((int *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int elem = ((int *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
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 += ((int *)num_elem_per_set)[++k];
el_type = elem_blk_parms[j].elem_type_val;
same_elem_type[k] = EX_TRUE;
}
if (el_type != elem_blk_parms[j].elem_type_val) {
same_elem_type[k] = EX_FALSE;
}
}
/* Build side set element to node list index and side set element
parameter index.
*/
node_ctr = 0;
elem_ctr = ((int *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int elem = ((int *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
((int *)ss_parm_ndx)[i] = j; /* assign parameter block index */
((int *)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 (((int *)num_elem_per_set)[++k] == 0) {
;
}
elem_ctr += ((int *)num_elem_per_set)[k];
}
/* determine number of nodes per side */
if (((((int *)num_nodes_per_set)[k] % ((int *)num_elem_per_set)[k]) == 0) &&
(same_elem_type[k])) { /* all side set elements are same type */
node_ctr += ((int *)num_nodes_per_set)[k] / ((int *)num_elem_per_set)[k];
}
else {
node_ctr += elem_blk_parms[j].num_nodes_per_side[0];
}
}
((int *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
}
/* All setup, ready to go ... */
elem_ctr = 0;
for (j = 0; j < tot_num_ss_elem; j++) {
int64_t elem;
int64_t idx;
int64_t ss_node0, ss_node1;
int64_t p_ndx;
if (int_size == sizeof(int64_t)) {
idx = ((int64_t *)ss_elem_ndx)[j];
elem = ((int64_t *)side_sets_elem_list)[idx];
ss_node0 = ((int64_t *)side_sets_node_list)[((int64_t *)ss_elem_node_ndx)[idx]];
ss_node1 = ((int64_t *)side_sets_node_list)[((int64_t *)ss_elem_node_ndx)[idx] + 1];
p_ndx = ((int64_t *)ss_parm_ndx)[idx];
}
else {
idx = ((int *)ss_elem_ndx)[j];
elem = ((int *)side_sets_elem_list)[idx];
ss_node0 = ((int *)side_sets_node_list)[((int *)ss_elem_node_ndx)[idx]];
ss_node1 = ((int *)side_sets_node_list)[((int *)ss_elem_node_ndx)[idx] + 1];
p_ndx = ((int *)ss_parm_ndx)[idx];
}
elem_num = elem - 1;
if (elem > 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[p_ndx].num_elem_in_blk *
elem_blk_parms[p_ndx].num_nodes_per_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for connectivity "
"array for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* get connectivity array */
if (ex_get_conn(exoid, EX_ELEM_BLOCK, elem_blk_parms[p_ndx].elem_blk_id, connect, NULL,
NULL) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get connectivity array for elem blk %" PRId64 " for file id %d",
elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = elem_blk_parms[p_ndx].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. */
if (connect == NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: logic error. Connect pointer is null for elem blk %" PRId64
" for file id %d",
elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* calculate the relative element number position in it's block*/
elem_num_pos =
elem_num - (elem_blk_parms[p_ndx].elem_ctr - elem_blk_parms[p_ndx].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[p_ndx].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 (((int_size == sizeof(int64_t)) &&
(ss_node0 == ((int64_t *)connect)[num_nodes_per_elem * (elem_num_pos) + n])) ||
((int_size == sizeof(int)) &&
(ss_node0 == ((int *)connect)[num_nodes_per_elem * (elem_num_pos) + n]))) {
switch (elem_blk_parms[p_ndx].elem_type_val) {
case EX_EL_CIRCLE:
case EX_EL_SPHERE: {
/* simple case: 1st node number is same as side # */
put_side(side_sets_side_list, idx, n + 1, int_size);
break;
}
case EX_EL_QUAD:
case EX_EL_TRIANGLE:
case EX_EL_TRUSS:
case EX_EL_BEAM: {
/* simple case: 1st node number is same as side # */
put_side(side_sets_side_list, idx, n + 1, int_size);
break;
}
case EX_EL_TRISHELL: {
/* use table to find which node to compare to next */
if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n + 1] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n + 2] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find TRIANGULAR SHELL element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_SHELL: {
/* use table to find which node to compare to next */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
num_node_per_side =
((int64_t *)ss_elem_node_ndx)[idx + 1] - ((int64_t *)ss_elem_node_ndx)[idx];
}
else {
num_node_per_side = ((int *)ss_elem_node_ndx)[idx + 1] - ((int *)ss_elem_node_ndx)[idx];
}
if (ss_node1 ==
get_node(connect, num_nodes_per_elem * (elem_num_pos) + (shell_table[0][2 * n] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n], int_size);
}
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(shell_table[0][2 * n + 1] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n + 1], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n + 1], int_size);
}
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(shell_table[0][2 * n + 2] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n + 2], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n + 2], int_size);
}
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find SHELL element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_HEX: {
/* use table to find which node to compare to next */
if (ss_node1 == get_node(connect,
num_nodes_per_elem * (elem_num_pos) + (hex_table[0][3 * n] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(hex_table[0][3 * n + 1] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(hex_table[0][3 * n + 2] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find HEX element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_TETRA: {
/* use table to find which node to compare to next */
if (ss_node1 ==
get_node(connect, num_nodes_per_elem * (elem_num_pos) + (tetra_table[0][3 * n] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(tetra_table[0][3 * n + 1] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(tetra_table[0][3 * n + 2] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find TETRA element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_PYRAMID: {
/* NOTE: PYRAMID elements in side set node lists are currently not
* supported */
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported PYRAMID element found in side "
"set node list in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
case EX_EL_WEDGE: {
/* NOTE: WEDGE elements in side set node lists are currently not
* supported */
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported WEDGE element found in side set "
"node list in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
default: {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: %s is an unsupported element type",
elem_blk_parms[p_ndx].elem_type);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
}
break; /* done with this element */
}
}
if (n >= num_nodes_per_elem) /* did we find the node? */
{
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find element %" PRId64 ", node %" PRId64
" in element block %" PRId64 " for file id %d",
elem_num + 1, ss_node0, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
}
/* All done: release connectivity array space, element block ids array,
element block parameters array, and side set element index array */
cleanup:
free(connect);
free(ss_elem_node_ndx);
free(ss_parm_ndx);
free(elem_blk_parms);
free(elem_blk_ids);
free(ss_elem_ndx);
free(same_elem_type);
return (err_stat);
}
/*! Calculate the number of words of storage required to store the
* header information. Total bytes can be obtained by multiplying
* words by 4. Size is slightly underestimated since it only
* considers the bulk data storage...
*/
size_t ex_header_size(int exoid)
{
const char *routine = NULL;
int iows = 0;
size_t ndim = 0;
size_t num_nodes = 0;
size_t num_elem = 0;
size_t num_eblk = 0;
size_t num_map = 0;
size_t num_nset = 0;
size_t num_sset = 0;
int mapid;
int temp;
size_t size = 0;
/* Get word size (2 = 8-byte reals, 1 = 4-byte reals */
if (nc_flt_code(exoid) == NC_DOUBLE)
iows = 2;
else
iows = 1;
/* coordinates = (ndim * numnp)*iows + maps */
ex_get_dimension(exoid, DIM_NUM_DIM, "dimension", &ndim, &temp, routine);
ex_get_dimension(exoid, DIM_NUM_NODES, "nodes", &num_nodes, &temp, routine);
size += iows * ndim * num_nodes;
/* node maps */
if (nc_inq_varid(exoid, VAR_NODE_NUM_MAP, &mapid) != -1)
size += num_nodes;
ex_get_dimension(exoid, DIM_NUM_NM, "node maps", &num_map, &temp, routine);
size += num_map * num_nodes;
/* Element Data */
ex_get_dimension(exoid, DIM_NUM_ELEM, "elements", &num_elem, &temp, routine);
/* Element order map */
if (nc_inq_varid (exoid, VAR_MAP, &mapid) != -1)
size += num_elem;
if (nc_inq_varid (exoid, VAR_ELEM_NUM_MAP, &mapid) != -1)
size += num_elem;
/* Element map(s) */
ex_get_dimension(exoid, DIM_NUM_EM, "element maps", &num_map, &temp, routine);
size += num_map * num_elem;
/* Element Blocks... */
ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element blocks", &num_eblk, &temp, routine);
if (num_eblk > 0) {
/* Allocate storage for element block parameters... */
int *ids = malloc(num_eblk * sizeof(int));
size_t i;
size += 2*num_eblk; /* status + ids */
ex_get_ids(exoid, EX_ELEM_BLOCK, ids);
for (i=0; i < num_eblk; i++) {
int num_elem_this_blk = 0;
int num_nodes_per_elem = 0;
int num_attr = 0;
char elem_type[MAX_STR_LENGTH+1];
ex_get_elem_block(exoid, ids[i], elem_type, &num_elem_this_blk,
&num_nodes_per_elem, &num_attr);
size += num_elem_this_blk * num_nodes_per_elem;
size += num_elem_this_blk * num_attr * iows;
}
free(ids);
}
/* Nodesets */
ex_get_dimension(exoid, DIM_NUM_NS, "nodesets", &num_nset, &temp, routine);
if (num_nset > 0) {
/* Allocate storage for nodeset parameters... */
int *ids = malloc(num_nset * sizeof(int));
size_t i;
size += 2*num_nset; /* Status + ids */
ex_get_ids(exoid, EX_NODE_SET, ids);
for (i=0; i < num_nset; i++) {
int num_nodes_in_set = 0;
int num_df_in_set = 0;
ex_get_node_set_param(exoid, ids[i], &num_nodes_in_set, &num_df_in_set);
size += num_nodes_in_set;
size += num_df_in_set * iows;
}
free(ids);
}
/* Sidesets */
ex_get_dimension(exoid, DIM_NUM_SS, "sidesets", &num_sset, &temp, routine);
if (num_sset > 0) {
/* Allocate storage for sideset parameters... */
int *ids = malloc(num_sset * sizeof(int));
size_t i;
size += 2*num_sset; /* Status + ids */
ex_get_ids(exoid, EX_SIDE_SET, ids);
for (i=0; i < num_sset; i++) {
int num_sides_in_set = 0;
int num_df_in_set = 0;
ex_get_side_set_param(exoid, ids[i], &num_sides_in_set, &num_df_in_set);
size += num_sides_in_set * 2;
size += num_df_in_set * iows;
}
free(ids);
}
if (ex_large_model(exoid) == 0 && size > (1<<29)) {
fprintf(stderr, "ERROR: Size to store header information exceeds 2GB in file id %d\n File is probably corrupt, rerun with environment variable EXODUS_LARGE_MODEL set.\n", exoid);
}
return size;
}