template <typename INT> std::string ExoII_Read<INT>::Load_Elmt_Map()
{
SMART_ASSERT(Check_State());
if (!Open())
return "WARNING: File not open!";
delete[] elmt_map;
elmt_map = nullptr;
if (num_elmts == 0)
return "WARNING: There are no elements!";
elmt_map = new INT[num_elmts];
SMART_ASSERT(elmt_map != nullptr);
ex_opts(0); // Temporarily turn off error reporting in case map isn't stored.
int err = ex_get_elem_num_map(file_id, elmt_map);
ex_opts(EX_VERBOSE);
if (err < 0) {
std::cout << "EXODIFF ERROR: Unable to load element map; "
<< "Exodus error = " << err << ". Aborting..." << '\n';
exit(1);
}
else if (err > 0)
return "WARNING: Default element map being used.";
return "";
}
/* read element number map */
int c_ex_get_elem_num_map(int *exoid, int *elem_num_map)
{
int error=0;
#ifdef HAVE_LIBEXOIIV2C
error = ex_get_elem_num_map(*exoid, elem_num_map);
#else
FLExit("Fluidity was not configured with exodusII, reconfigure with '--with-exodusii'!");
#endif
return (error);
}
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);
}
static int read_elem_info(int pexoid, int Proc, PROB_INFO_PTR prob,
MESH_INFO_PTR mesh)
{
/* Local declarations. */
char *yo = "read_elem_info";
int iblk, ielem, inode, lnode, cnode, iplace, len;
int max_nsur = 0;
int i;
int *nmap, *emap, *connect;
int **sur_elem, *nsurnd;
ELEM_INFO_PTR elements = mesh->elements;
double tmp0, tmp1, tmp2;
float *xptr = NULL, *yptr = NULL, *zptr = NULL;
/***************************** BEGIN EXECUTION ******************************/
DEBUG_TRACE_START(Proc, yo);
/* allocate memory for the global number maps */
nmap = (int *) malloc ((mesh->num_nodes + mesh->num_elems) * sizeof(int));
if (!nmap) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
emap = nmap + mesh->num_nodes;
/*
* get the global maps
*/
if (ex_get_elem_num_map(pexoid, emap) < 0) {
Gen_Error(0, "fatal: Error returned from ex_get_elem_num_map");
return 0;
}
if (ex_get_node_num_map(pexoid, nmap) < 0) {
Gen_Error(0, "fatal: Error returned from ex_get_node_num_map");
return 0;
}
/* allocate memory for the coordinates */
xptr = (float *) malloc (mesh->num_dims * mesh->num_nodes * sizeof(float));
if (!xptr) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
switch (mesh->num_dims) {
case 3:
zptr = xptr + 2 * mesh->num_nodes;
/* FALLTHRU */
case 2:
yptr = xptr + mesh->num_nodes;
}
if (ex_get_coord(pexoid, xptr, yptr, zptr) < 0) {
Gen_Error(0, "fatal: Error returned from ex_get_coord");
return 0;
}
/*
* figure out which element block needs
* the most space for its connect table
*/
len = 0;
for (iblk = 0; iblk < mesh->num_el_blks; iblk++)
if ((iplace = mesh->eb_cnts[iblk] * mesh->eb_nnodes[iblk]) > len)
len = iplace;
connect = (int *) malloc (len * sizeof(int));
if (!connect) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
/***************************************************************************/
/* Fill the Connect table, Coordinates, Global Ids for each element */
/***************************************************************************/
iplace = 0;
for (iblk = 0; iblk < mesh->num_el_blks; iblk++) {
if (mesh->eb_cnts[iblk] > 0) {
if (ex_get_elem_conn(pexoid, mesh->eb_ids[iblk], connect) < 0) {
Gen_Error(0, "fatal: Error returned from ex_get_elem_conn");
return 0;
}
cnode = 0;
for (ielem = 0; ielem < mesh->eb_cnts[iblk]; ielem++) {
/* set some fields in the element structure */
elements[iplace].border = 0;
elements[iplace].globalID = emap[iplace];
elements[iplace].elem_blk = iblk;
elements[iplace].my_part = Proc;
elements[iplace].perm_value = -1;
elements[iplace].invperm_value = -1;
elements[iplace].nadj = 0;
elements[iplace].adj_len = 0;
/* first weights are all 1 for now */
elements[iplace].cpu_wgt[0] = 1.0;
if (MAX_CPU_WGTS>1){
/* second weights will be set later */
elements[iplace].cpu_wgt[1] = 0.0;
/* make artificial data for more multi-weights */
for (i = 2; i < MAX_CPU_WGTS; i++)
elements[iplace].cpu_wgt[i] = elements[iplace].my_part +
0.5*((elements[iplace].globalID)%i);
}
elements[iplace].mem_wgt = 1.0;
/* allocate space for the connect list and the coordinates */
elements[iplace].connect = (int *) malloc(mesh->eb_nnodes[iblk] *
sizeof(int));
if (!(elements[iplace].connect)) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
elements[iplace].coord = (float **) malloc(mesh->eb_nnodes[iblk] *
sizeof(float *));
if (!(elements[iplace].coord)) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
/* save the connect table as local numbers for the moment */
tmp0 = tmp1 = tmp2 = 0.;
for (inode = 0; inode < mesh->eb_nnodes[iblk]; inode++) {
lnode = connect[cnode] - 1;
elements[iplace].connect[inode] = lnode;
cnode++;
elements[iplace].coord[inode] = (float *) calloc(mesh->num_dims,
sizeof(float));
if (!(elements[iplace].coord[inode])) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
switch (mesh->num_dims) {
case 3:
elements[iplace].coord[inode][2] = zptr[lnode];
tmp2 += zptr[lnode];
/* FALLTHRU */
case 2:
elements[iplace].coord[inode][1] = yptr[lnode];
tmp1 += yptr[lnode];
/* FALLTHRU */
case 1:
elements[iplace].coord[inode][0] = xptr[lnode];
tmp0 += xptr[lnode];
}
} /* End: "for (inode = 0; inode < mesh->eb_nnodes[iblk]; inode++)" */
elements[iplace].avg_coord[0] = tmp0 / mesh->eb_nnodes[iblk];
elements[iplace].avg_coord[1] = tmp1 / mesh->eb_nnodes[iblk];
elements[iplace].avg_coord[2] = tmp2 / mesh->eb_nnodes[iblk];
iplace++;
} /* End: "for (ielem = 0; ielem < mesh->eb_cnts[iblk]; ielem++)" */
} /* End: "if (mesh->eb_cnts[iblk] > 0)" */
} /* End: "for (iblk = 0; iblk < mesh->num_el_blks; iblk++)" */
/* free some memory */
free(connect);
free(xptr);
/*************************************************************************/
/* Find the adjacency list for each element */
/* Part one: find the surrounding elements for each node */
/*************************************************************************/
sur_elem = (int **) malloc(mesh->num_nodes * sizeof(int *));
if (!sur_elem) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
nsurnd = (int *) malloc(mesh->num_nodes * sizeof(int));
if (!nsurnd) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
if (!find_surnd_elem(mesh, sur_elem, nsurnd, &max_nsur)) {
Gen_Error(0, "fatal: Error returned from find_surnd_elems");
return 0;
}
/*************************************************************************/
/* Part two: Find the adjacencies on this processor */
/* and get the edge weights */
/*************************************************************************/
if (!find_adjacency(Proc, mesh, sur_elem, nsurnd, max_nsur)) {
Gen_Error(0, "fatal: Error returned from find_adjacency");
return 0;
}
/*
* convert the node numbers in the connect lists to Global IDs
* since they will be much easier to work with
*/
for (ielem = 0; ielem < mesh->num_elems; ielem++) {
iblk = elements[ielem].elem_blk;
for (inode = 0; inode < mesh->eb_nnodes[iblk]; inode++) {
elements[ielem].connect[inode] = nmap[elements[ielem].connect[inode]];
}
}
/*
* let cpu_wgt[1] be the number of sides (surfaces) not
* connected to other elements. (useful test case for multi-weight
* load balancing).
*/
if (MAX_CPU_WGTS>1){
for (ielem = 0; ielem < mesh->num_elems; ielem++) {
elements[ielem].cpu_wgt[1] = elements[ielem].adj_len - elements[ielem].nadj;
/* EBEB Strangely, nadj is often one less than expected so subtract one from the wgt to compensate. */
if (elements[ielem].cpu_wgt[1] >= 1.0)
elements[ielem].cpu_wgt[1] -= 1.0;
}
}
for (inode = 0; inode < mesh->num_nodes; inode++) free(sur_elem[inode]);
free(sur_elem);
free(nsurnd);
free(nmap);
DEBUG_TRACE_END(Proc, yo);
return 1;
}
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);
}
