/* read node coordinates */
int c_ex_get_coord(int *exoid, float *x,float *y,float *z)
{
int error=0;
#ifdef HAVE_LIBEXOIIV2C
error = ex_get_coord(*exoid, x, y, z);
#else
FLExit("Fluidity was not configured with exodusII, reconfigure with '--with-exodusii'!");
#endif
return(error);
}
void ExodusModel::readCoordinates() {
try {
mNodalX.resize(mNumberVertices);
mNodalY.resize(mNumberVertices);
if (mNumberDimension > 2) { mNodalZ.resize(mNumberVertices); }
if (mNumberDimension == 2) {
exodusError(ex_get_coord(
mExodusId, mNodalX.data(), mNodalY.data(), NULL),
"ex_get_coord");
} else {
exodusError(ex_get_coord(
mExodusId, mNodalX.data(), mNodalY.data(), mNodalZ.data()),
"ex_get_coord");
}
} catch (std::exception &e) {
utilities::print_from_root_mpi(e.what());
MPI_Abort(PETSC_COMM_WORLD, -1);
}
}
PetscErrorCode MyPetscReadExodusII(MPI_Comm comm,const char filename[],DM dmBody,DM dmFS)
{
ALE::Obj<PETSC_MESH_TYPE> meshBody,meshFS;
typedef ALE::Mesh<PetscInt,PetscScalar> FlexMesh;
//typedef std::set<FlexMesh::point_type> PointSet;
//ALE::Obj<FlexMesh> boundarymesh;
PetscMPIInt rank;
int CPU_word_size = 0;
int IO_word_size = 0;
PetscBool interpolate = PETSC_FALSE;
int **connect = PETSC_NULL;
int exoid;
char title[MAX_LINE_LENGTH+1];
float version;
int num_dim,num_nodes = 0,num_elem = 0;
int num_eb = 0,num_ns = 0,num_ss = 0;
PetscErrorCode ierr;
//const char known_elements[] = "tri,tri3,triangle,triangle3,quad,quad4,tet,tet4,tetra,tetra4,hex,hex8";
float *x = PETSC_NULL,*y = PETSC_NULL,*z = PETSC_NULL;
PetscBool debug = PETSC_FALSE;
PetscFunctionBegin;
ierr = PetscOptionsGetBool(PETSC_NULL,"-interpolate",&interpolate,PETSC_NULL);CHKERRQ(ierr);
/*
Get the sieve meshes from the dms
*/
ierr = DMMeshGetMesh(dmBody,meshBody);CHKERRQ(ierr);
ierr = DMMeshGetMesh(dmFS,meshFS);CHKERRQ(ierr);
rank = meshBody->commRank();
/*
Open EXODUS II file and read basic informations on rank 0,
then broadcast to all nodes
*/
if (rank == 0) {
exoid = ex_open(filename,EX_READ,&CPU_word_size,&IO_word_size,&version);CHKERRQ(!exoid);
ierr = ex_get_init(exoid,title,&num_dim,&num_nodes,&num_elem,&num_eb,&num_ns,&num_ss);CHKERRQ(ierr);
if (num_eb == 0) {
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Exodus file does not contain any element block\n");
}
ierr = PetscMalloc3(num_nodes,float,&x,num_nodes,float,&y,num_nodes,float,&z);CHKERRQ(ierr);
ierr = ex_get_coord(exoid,x,y,z);CHKERRQ(ierr);
}
template <typename INT> std::string ExoII_Read<INT>::Load_Nodal_Coordinates()
{
SMART_ASSERT(Check_State());
if (!Open())
return "WARNING: File not open!";
if (num_nodes) {
size_t count = num_nodes * dimension;
nodes = new double[count];
SMART_ASSERT(nodes != nullptr);
double *x = nodes, *y = nodes, *z = nodes;
if (dimension > 1)
y = nodes + num_nodes;
if (dimension > 2)
z = nodes + (2 * num_nodes);
int err = ex_get_coord(file_id, x, y, z);
if (err < 0) {
std::cout << "EXODIFF ERROR: Failed to get "
<< "nodal coordinates! Aborting..." << '\n';
exit(1);
}
else if (err > 0) {
delete[] nodes;
nodes = nullptr;
std::ostringstream oss;
oss << "EXODIFF WARNING: "
<< "Exodus issued warning \"" << err << "\" on call to ex_get_coord()!"
<< " I'm not going to keep what it gave me for coordinates.";
return oss.str();
}
}
else
return "WARNING: There are no nodes!";
return "";
}
int main(int argc, char **argv)
{
int exoid, num_dim, num_nodes, num_elem, num_elem_blk, num_node_sets;
int num_side_sets, error;
int i, j, k, node_ctr;
int *elem_map, *connect, *node_list, *node_ctr_list, *elem_list, *side_list;
int *ids;
int *num_nodes_per_set = NULL;
int *num_elem_per_set = NULL;
int *num_df_per_set = NULL;
int *node_ind = NULL;
int *elem_ind = NULL;
int *df_ind = NULL;
int num_qa_rec, num_info;
int num_glo_vars, num_nod_vars, num_ele_vars;
int num_nset_vars, num_sset_vars;
int *truth_tab;
int num_time_steps;
int *num_elem_in_block = NULL;
int *num_nodes_per_elem = NULL;
int *num_attr = NULL;
int num_nodes_in_set, num_elem_in_set;
int num_sides_in_set, num_df_in_set;
int list_len, elem_list_len, node_list_len, df_list_len;
int node_num, time_step, var_index, beg_time, end_time, elem_num;
int CPU_word_size, IO_word_size;
int num_props, prop_value, *prop_values;
int idum;
float time_value, *time_values, *var_values;
float *x, *y, *z;
float *attrib, *dist_fact;
float version, fdum;
char *coord_names[3], *qa_record[2][4], *info[3], *var_names[3];
char *block_names[10], *nset_names[10], *sset_names[10];
char *attrib_names[10];
char name[MAX_STR_LENGTH + 1];
char title[MAX_LINE_LENGTH + 1], elem_type[MAX_STR_LENGTH + 1];
char title_chk[MAX_LINE_LENGTH + 1];
char *cdum = 0;
char *prop_names[3];
CPU_word_size = 0; /* sizeof(float) */
IO_word_size = 0; /* use what is stored in file */
ex_opts(EX_VERBOSE | EX_ABORT);
/* open EXODUS II files */
exoid = ex_open("test.exo", /* filename path */
EX_READ, /* access mode = READ */
&CPU_word_size, /* CPU word size */
&IO_word_size, /* IO word size */
&version); /* ExodusII library version */
printf("\nafter ex_open\n");
if (exoid < 0)
exit(1);
printf("test.exo is an EXODUSII file; version %4.2f\n", version);
/* printf (" CPU word size %1d\n",CPU_word_size); */
printf(" I/O word size %1d\n", IO_word_size);
ex_inquire(exoid, EX_INQ_API_VERS, &idum, &version, cdum);
printf("EXODUSII API; version %4.2f\n", version);
ex_inquire(exoid, EX_INQ_LIB_VERS, &idum, &version, cdum);
printf("EXODUSII Library API; version %4.2f (%d)\n", version, idum);
/* read database parameters */
error = ex_get_init(exoid, title, &num_dim, &num_nodes, &num_elem, &num_elem_blk, &num_node_sets,
&num_side_sets);
printf("after ex_get_init, error = %3d\n", error);
printf("database parameters:\n");
printf("title = '%s'\n", title);
printf("num_dim = %3d\n", num_dim);
printf("num_nodes = %3d\n", num_nodes);
printf("num_elem = %3d\n", num_elem);
printf("num_elem_blk = %3d\n", num_elem_blk);
printf("num_node_sets = %3d\n", num_node_sets);
printf("num_side_sets = %3d\n", num_side_sets);
/* Check that ex_inquire gives same title */
error = ex_inquire(exoid, EX_INQ_TITLE, &idum, &fdum, title_chk);
printf(" after ex_inquire, error = %d\n", error);
if (strcmp(title, title_chk) != 0) {
printf("error in ex_inquire for EX_INQ_TITLE\n");
}
/* read nodal coordinates values and names from database */
x = (float *)calloc(num_nodes, sizeof(float));
if (num_dim >= 2)
y = (float *)calloc(num_nodes, sizeof(float));
else
y = 0;
if (num_dim >= 3)
z = (float *)calloc(num_nodes, sizeof(float));
else
z = 0;
error = ex_get_coord(exoid, x, y, z);
printf("\nafter ex_get_coord, error = %3d\n", error);
printf("x coords = \n");
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\n", x[i]);
}
if (num_dim >= 2) {
printf("y coords = \n");
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\n", y[i]);
}
}
if (num_dim >= 3) {
printf("z coords = \n");
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\n", z[i]);
}
}
/*
error = ex_get_1_coord (exoid, 2, x, y, z);
printf ("\nafter ex_get_1_coord, error = %3d\n", error);
printf ("x coord of node 2 = \n");
printf ("%f \n", x[0]);
printf ("y coord of node 2 = \n");
printf ("%f \n", y[0]);
*/
free(x);
if (num_dim >= 2)
free(y);
if (num_dim >= 3)
free(z);
for (i = 0; i < num_dim; i++) {
coord_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_coord_names(exoid, coord_names);
printf("\nafter ex_get_coord_names, error = %3d\n", error);
printf("x coord name = '%s'\n", coord_names[0]);
if (num_dim > 1)
printf("y coord name = '%s'\n", coord_names[1]);
if (num_dim > 2)
printf("z coord name = '%s'\n", coord_names[2]);
for (i = 0; i < num_dim; i++)
free(coord_names[i]);
{
int num_attrs = 0;
error = ex_get_attr_param(exoid, EX_NODAL, 0, &num_attrs);
printf(" after ex_get_attr_param, error = %d\n", error);
printf("num nodal attributes = %d\n", num_attrs);
if (num_attrs > 0) {
for (j = 0; j < num_attrs; j++) {
attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_attr_names(exoid, EX_NODAL, 0, attrib_names);
printf(" after ex_get_attr_names, error = %d\n", error);
if (error == 0) {
attrib = (float *)calloc(num_nodes, sizeof(float));
for (j = 0; j < num_attrs; j++) {
printf("nodal attribute %d = '%s'\n", j, attrib_names[j]);
error = ex_get_one_attr(exoid, EX_NODAL, 0, j + 1, attrib);
printf(" after ex_get_one_attr, error = %d\n", error);
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\n", attrib[i]);
}
free(attrib_names[j]);
}
free(attrib);
}
}
}
/* read element order map */
elem_map = (int *)calloc(num_elem, sizeof(int));
error = ex_get_map(exoid, elem_map);
printf("\nafter ex_get_map, error = %3d\n", error);
for (i = 0; i < num_elem; i++) {
printf("elem_map(%d) = %d \n", i, elem_map[i]);
}
free(elem_map);
/* read element block parameters */
if (num_elem_blk > 0) {
ids = (int *)calloc(num_elem_blk, sizeof(int));
num_elem_in_block = (int *)calloc(num_elem_blk, sizeof(int));
num_nodes_per_elem = (int *)calloc(num_elem_blk, sizeof(int));
num_attr = (int *)calloc(num_elem_blk, sizeof(int));
error = ex_get_elem_blk_ids(exoid, ids);
printf("\nafter ex_get_elem_blk_ids, error = %3d\n", error);
for (i = 0; i < num_elem_blk; i++) {
block_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_names(exoid, EX_ELEM_BLOCK, block_names);
printf("\nafter ex_get_names, error = %3d\n", error);
for (i = 0; i < num_elem_blk; i++) {
ex_get_name(exoid, EX_ELEM_BLOCK, ids[i], name);
if (strcmp(name, block_names[i]) != 0) {
printf("error in ex_get_name for block id %d\n", ids[i]);
}
error = ex_get_elem_block(exoid, ids[i], elem_type, &(num_elem_in_block[i]),
&(num_nodes_per_elem[i]), &(num_attr[i]));
printf("\nafter ex_get_elem_block, error = %d\n", error);
printf("element block id = %2d\n", ids[i]);
printf("element type = '%s'\n", elem_type);
printf("num_elem_in_block = %2d\n", num_elem_in_block[i]);
printf("num_nodes_per_elem = %2d\n", num_nodes_per_elem[i]);
printf("num_attr = %2d\n", num_attr[i]);
printf("name = '%s'\n", block_names[i]);
free(block_names[i]);
}
/* read element block properties */
error = ex_inquire(exoid, EX_INQ_EB_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
printf("\nThere are %2d properties for each element block\n", num_props);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_prop_names(exoid, EX_ELEM_BLOCK, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
for (i = 1; i < num_props; i++) /* Prop 1 is id; skip that here */
{
for (j = 0; j < num_elem_blk; j++) {
error = ex_get_prop(exoid, EX_ELEM_BLOCK, ids[j], prop_names[i], &prop_value);
if (error == 0)
printf("element block %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
prop_value);
else
printf("after ex_get_prop, error = %d\n", error);
}
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
}
/* read element connectivity */
for (i = 0; i < num_elem_blk; i++) {
if (num_elem_in_block[i] > 0) {
connect = (int *)calloc((num_nodes_per_elem[i] * num_elem_in_block[i]), sizeof(int));
error = ex_get_elem_conn(exoid, ids[i], connect);
printf("\nafter ex_get_elem_conn, error = %d\n", error);
printf("connect array for elem block %2d\n", ids[i]);
for (j = 0; j < num_nodes_per_elem[i]; j++) {
printf("%3d\n", connect[j]);
}
/*
error = ex_get_1_elem_conn (exoid, 1, ids[i], connect);
printf ("\nafter ex_get_elem_conn, error = %d\n", error);
printf ("node list for first element of element block %d \n ", ids[i]);
for (j=0; j<num_nodes_per_elem[i]; j++)
{
printf ("%d \n", connect[j]);
}
*/
free(connect);
}
}
/* read element block attributes */
for (i = 0; i < num_elem_blk; i++) {
if (num_elem_in_block[i] > 0) {
for (j = 0; j < num_attr[i]; j++)
attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
attrib = (float *)calloc(num_attr[i] * num_elem_in_block[i], sizeof(float));
error = ex_get_elem_attr(exoid, ids[i], attrib);
printf("\n after ex_get_elem_attr, error = %d\n", error);
if (error == 0) {
error = ex_get_elem_attr_names(exoid, ids[i], attrib_names);
printf(" after ex_get_elem_attr_names, error = %d\n", error);
if (error == 0) {
printf("element block %d attribute '%s' = %6.4f\n", ids[i], attrib_names[0], *attrib);
}
}
free(attrib);
for (j = 0; j < num_attr[i]; j++)
free(attrib_names[j]);
}
}
if (num_elem_blk > 0) {
free(ids);
free(num_nodes_per_elem);
free(num_attr);
}
/* read individual node sets */
if (num_node_sets > 0) {
ids = (int *)calloc(num_node_sets, sizeof(int));
error = ex_get_node_set_ids(exoid, ids);
printf("\nafter ex_get_node_set_ids, error = %3d\n", error);
for (i = 0; i < num_node_sets; i++) {
nset_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_names(exoid, EX_NODE_SET, nset_names);
printf("\nafter ex_get_names, error = %3d\n", error);
for (i = 0; i < num_node_sets; i++) {
ex_get_name(exoid, EX_NODE_SET, ids[i], name);
if (strcmp(name, nset_names[i]) != 0) {
printf("error in ex_get_name for nodeset id %d\n", ids[i]);
}
error = ex_get_node_set_param(exoid, ids[i], &num_nodes_in_set, &num_df_in_set);
printf("\nafter ex_get_node_set_param, error = %3d\n", error);
printf("\nnode set %2d parameters: \n", ids[i]);
printf("num_nodes = %2d\n", num_nodes_in_set);
printf("name = '%s'\n", nset_names[i]);
free(nset_names[i]);
node_list = (int *)calloc(num_nodes_in_set, sizeof(int));
dist_fact = (float *)calloc(num_nodes_in_set, sizeof(float));
error = ex_get_node_set(exoid, ids[i], node_list);
printf("\nafter ex_get_node_set, error = %3d\n", error);
if (num_df_in_set > 0) {
error = ex_get_node_set_dist_fact(exoid, ids[i], dist_fact);
printf("\nafter ex_get_node_set_dist_fact, error = %3d\n", error);
}
printf("\nnode list for node set %2d\n", ids[i]);
for (j = 0; j < num_nodes_in_set; j++) {
printf("%3d\n", node_list[j]);
}
if (num_df_in_set > 0) {
printf("dist factors for node set %2d\n", ids[i]);
for (j = 0; j < num_df_in_set; j++) {
printf("%5.2f\n", dist_fact[j]);
}
}
else
printf("no dist factors for node set %2d\n", ids[i]);
free(node_list);
free(dist_fact);
{
int num_attrs = 0;
error = ex_get_attr_param(exoid, EX_NODE_SET, ids[i], &num_attrs);
printf(" after ex_get_attr_param, error = %d\n", error);
printf("num nodeset attributes for nodeset %d = %d\n", ids[i], num_attrs);
if (num_attrs > 0) {
for (j = 0; j < num_attrs; j++) {
attrib_names[j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_attr_names(exoid, EX_NODE_SET, ids[i], attrib_names);
printf(" after ex_get_attr_names, error = %d\n", error);
if (error == 0) {
attrib = (float *)calloc(num_nodes_in_set, sizeof(float));
for (j = 0; j < num_attrs; j++) {
printf("nodeset attribute %d = '%s'\n", j, attrib_names[j]);
error = ex_get_one_attr(exoid, EX_NODE_SET, ids[i], j + 1, attrib);
printf(" after ex_get_one_attr, error = %d\n", error);
for (k = 0; k < num_nodes_in_set; k++) {
printf("%5.1f\n", attrib[k]);
}
free(attrib_names[j]);
}
free(attrib);
}
}
}
}
free(ids);
/* read node set properties */
error = ex_inquire(exoid, EX_INQ_NS_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
printf("\nThere are %2d properties for each node set\n", num_props);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
prop_values = (int *)calloc(num_node_sets, sizeof(int));
error = ex_get_prop_names(exoid, EX_NODE_SET, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
for (i = 0; i < num_props; i++) {
error = ex_get_prop_array(exoid, EX_NODE_SET, prop_names[i], prop_values);
if (error == 0)
for (j = 0; j < num_node_sets; j++)
printf("node set %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
prop_values[j]);
else
printf("after ex_get_prop_array, error = %d\n", error);
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
free(prop_values);
/* read concatenated node sets; this produces the same information as
* the above code which reads individual node sets
*/
error = ex_inquire(exoid, EX_INQ_NODE_SETS, &num_node_sets, &fdum, cdum);
printf("\nafter ex_inquire, error = %3d\n", error);
ids = (int *)calloc(num_node_sets, sizeof(int));
num_nodes_per_set = (int *)calloc(num_node_sets, sizeof(int));
num_df_per_set = (int *)calloc(num_node_sets, sizeof(int));
node_ind = (int *)calloc(num_node_sets, sizeof(int));
df_ind = (int *)calloc(num_node_sets, sizeof(int));
error = ex_inquire(exoid, EX_INQ_NS_NODE_LEN, &list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_NS_NODE_LEN = %d, error = %3d\n", list_len, error);
node_list = (int *)calloc(list_len, sizeof(int));
error = ex_inquire(exoid, EX_INQ_NS_DF_LEN, &list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_NS_DF_LEN = %d, error = %3d\n", list_len, error);
dist_fact = (float *)calloc(list_len, sizeof(float));
error = ex_get_concat_node_sets(exoid, ids, num_nodes_per_set, num_df_per_set, node_ind, df_ind,
node_list, dist_fact);
printf("\nafter ex_get_concat_node_sets, error = %3d\n", error);
printf("\nconcatenated node set info\n");
printf("ids = \n");
for (i = 0; i < num_node_sets; i++)
printf("%3d\n", ids[i]);
printf("num_nodes_per_set = \n");
for (i = 0; i < num_node_sets; i++)
printf("%3d\n", num_nodes_per_set[i]);
printf("node_ind = \n");
for (i = 0; i < num_node_sets; i++)
printf("%3d\n", node_ind[i]);
printf("node_list = \n");
for (i = 0; i < list_len; i++)
printf("%3d\n", node_list[i]);
printf("dist_fact = \n");
for (i = 0; i < list_len; i++)
printf("%5.3f\n", dist_fact[i]);
free(ids);
free(df_ind);
free(node_ind);
free(num_df_per_set);
free(node_list);
free(dist_fact);
}
/* read individual side sets */
if (num_side_sets > 0) {
ids = (int *)calloc(num_side_sets, sizeof(int));
error = ex_get_side_set_ids(exoid, ids);
printf("\nafter ex_get_side_set_ids, error = %3d\n", error);
for (i = 0; i < num_side_sets; i++) {
sset_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_names(exoid, EX_SIDE_SET, sset_names);
printf("\nafter ex_get_names, error = %3d\n", error);
for (i = 0; i < num_side_sets; i++) {
ex_get_name(exoid, EX_SIDE_SET, ids[i], name);
if (strcmp(name, sset_names[i]) != 0) {
printf("error in ex_get_name for sideset id %d\n", ids[i]);
}
error = ex_get_side_set_param(exoid, ids[i], &num_sides_in_set, &num_df_in_set);
printf("\nafter ex_get_side_set_param, error = %3d\n", error);
printf("side set %2d parameters:\n", ids[i]);
printf("name = '%s'\n", sset_names[i]);
printf("num_sides = %3d\n", num_sides_in_set);
printf("num_dist_factors = %3d\n", num_df_in_set);
free(sset_names[i]);
/* Note: The # of elements is same as # of sides! */
num_elem_in_set = num_sides_in_set;
elem_list = (int *)calloc(num_elem_in_set, sizeof(int));
side_list = (int *)calloc(num_sides_in_set, sizeof(int));
node_ctr_list = (int *)calloc(num_elem_in_set, sizeof(int));
node_list = (int *)calloc(num_elem_in_set * 21, sizeof(int));
dist_fact = (float *)calloc(num_df_in_set, sizeof(float));
error = ex_get_side_set(exoid, ids[i], elem_list, side_list);
printf("\nafter ex_get_side_set, error = %3d\n", error);
error = ex_get_side_set_node_list(exoid, ids[i], node_ctr_list, node_list);
printf("\nafter ex_get_side_set_node_list, error = %3d\n", error);
if (num_df_in_set > 0) {
error = ex_get_side_set_dist_fact(exoid, ids[i], dist_fact);
printf("\nafter ex_get_side_set_dist_fact, error = %3d\n", error);
}
printf("element list for side set %2d\n", ids[i]);
for (j = 0; j < num_elem_in_set; j++) {
printf("%3d\n", elem_list[j]);
}
printf("side list for side set %2d\n", ids[i]);
for (j = 0; j < num_sides_in_set; j++) {
printf("%3d\n", side_list[j]);
}
node_ctr = 0;
printf("node list for side set %2d\n", ids[i]);
for (k = 0; k < num_elem_in_set; k++) {
for (j = 0; j < node_ctr_list[k]; j++) {
printf("%3d\n", node_list[node_ctr + j]);
}
node_ctr += node_ctr_list[k];
}
if (num_df_in_set > 0) {
printf("dist factors for side set %2d\n", ids[i]);
for (j = 0; j < num_df_in_set; j++) {
printf("%5.3f\n", dist_fact[j]);
}
}
else
printf("no dist factors for side set %2d\n", ids[i]);
free(elem_list);
free(side_list);
free(node_ctr_list);
free(node_list);
free(dist_fact);
}
/* read side set properties */
error = ex_inquire(exoid, EX_INQ_SS_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
printf("\nThere are %2d properties for each side set\n", num_props);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_prop_names(exoid, EX_SIDE_SET, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
for (i = 0; i < num_props; i++) {
for (j = 0; j < num_side_sets; j++) {
error = ex_get_prop(exoid, EX_SIDE_SET, ids[j], prop_names[i], &prop_value);
if (error == 0)
printf("side set %2d, property(%2d): '%s'= %5d\n", j + 1, i + 1, prop_names[i],
prop_value);
else
printf("after ex_get_prop, error = %d\n", error);
}
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
free(ids);
error = ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_SIDE_SETS = %d, error = %d\n", num_side_sets, error);
if (num_side_sets > 0) {
error = ex_inquire(exoid, EX_INQ_SS_ELEM_LEN, &elem_list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_SS_ELEM_LEN = %d, error = %d\n", elem_list_len, error);
error = ex_inquire(exoid, EX_INQ_SS_NODE_LEN, &node_list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_SS_NODE_LEN = %d, error = %d\n", node_list_len, error);
error = ex_inquire(exoid, EX_INQ_SS_DF_LEN, &df_list_len, &fdum, cdum);
printf("\nafter ex_inquire: EX_INQ_SS_DF_LEN = %d, error = %d\n", df_list_len, error);
}
/* read concatenated side sets; this produces the same information as
* the above code which reads individual side sets
*/
/* concatenated side set read */
if (num_side_sets > 0) {
ids = (int *)calloc(num_side_sets, sizeof(int));
num_elem_per_set = (int *)calloc(num_side_sets, sizeof(int));
num_df_per_set = (int *)calloc(num_side_sets, sizeof(int));
elem_ind = (int *)calloc(num_side_sets, sizeof(int));
df_ind = (int *)calloc(num_side_sets, sizeof(int));
elem_list = (int *)calloc(elem_list_len, sizeof(int));
side_list = (int *)calloc(elem_list_len, sizeof(int));
dist_fact = (float *)calloc(df_list_len, sizeof(float));
error = ex_get_concat_side_sets(exoid, ids, num_elem_per_set, num_df_per_set, elem_ind,
df_ind, elem_list, side_list, dist_fact);
printf("\nafter ex_get_concat_side_sets, error = %3d\n", error);
printf("concatenated side set info\n");
printf("ids = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", ids[i]);
printf("num_elem_per_set = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", num_elem_per_set[i]);
printf("num_dist_per_set = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", num_df_per_set[i]);
printf("elem_ind = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", elem_ind[i]);
printf("dist_ind = \n");
for (i = 0; i < num_side_sets; i++)
printf("%3d\n", df_ind[i]);
printf("elem_list = \n");
for (i = 0; i < elem_list_len; i++)
printf("%3d\n", elem_list[i]);
printf("side_list = \n");
for (i = 0; i < elem_list_len; i++)
printf("%3d\n", side_list[i]);
printf("dist_fact = \n");
for (i = 0; i < df_list_len; i++)
printf("%5.3f\n", dist_fact[i]);
free(ids);
free(num_df_per_set);
free(df_ind);
free(elem_ind);
free(elem_list);
free(side_list);
free(dist_fact);
}
}
/* end of concatenated side set read */
/* read QA records */
ex_inquire(exoid, EX_INQ_QA, &num_qa_rec, &fdum, cdum);
for (i = 0; i < num_qa_rec; i++) {
for (j = 0; j < 4; j++) {
qa_record[i][j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
}
error = ex_get_qa(exoid, qa_record);
printf("\nafter ex_get_qa, error = %3d\n", error);
printf("QA records = \n");
for (i = 0; i < num_qa_rec; i++) {
for (j = 0; j < 4; j++) {
printf(" '%s'\n", qa_record[i][j]);
free(qa_record[i][j]);
}
}
/* read information records */
error = ex_inquire(exoid, EX_INQ_INFO, &num_info, &fdum, cdum);
printf("\nafter ex_inquire, error = %3d\n", error);
for (i = 0; i < num_info; i++) {
info[i] = (char *)calloc((MAX_LINE_LENGTH + 1), sizeof(char));
}
error = ex_get_info(exoid, info);
printf("\nafter ex_get_info, error = %3d\n", error);
printf("info records = \n");
for (i = 0; i < num_info; i++) {
printf(" '%s'\n", info[i]);
free(info[i]);
}
/* read global variables parameters and names */
error = ex_get_var_param(exoid, "g", &num_glo_vars);
printf("\nafter ex_get_var_param, error = %3d\n", error);
for (i = 0; i < num_glo_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_var_names(exoid, "g", num_glo_vars, var_names);
printf("\nafter ex_get_var_names, error = %3d\n", error);
printf("There are %2d global variables; their names are :\n", num_glo_vars);
for (i = 0; i < num_glo_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
/* read nodal variables parameters and names */
num_nod_vars = 0;
if (num_nodes > 0) {
error = ex_get_var_param(exoid, "n", &num_nod_vars);
printf("\nafter ex_get_var_param, error = %3d\n", error);
for (i = 0; i < num_nod_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_var_names(exoid, "n", num_nod_vars, var_names);
printf("\nafter ex_get_var_names, error = %3d\n", error);
printf("There are %2d nodal variables; their names are :\n", num_nod_vars);
for (i = 0; i < num_nod_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
}
/* read element variables parameters and names */
num_ele_vars = 0;
if (num_elem > 0) {
error = ex_get_var_param(exoid, "e", &num_ele_vars);
printf("\nafter ex_get_var_param, error = %3d\n", error);
for (i = 0; i < num_ele_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_var_names(exoid, "e", num_ele_vars, var_names);
printf("\nafter ex_get_var_names, error = %3d\n", error);
printf("There are %2d element variables; their names are :\n", num_ele_vars);
for (i = 0; i < num_ele_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
/* read element variable truth table */
if (num_ele_vars > 0) {
truth_tab = (int *)calloc((num_elem_blk * num_ele_vars), sizeof(int));
error = ex_get_elem_var_tab(exoid, num_elem_blk, num_ele_vars, truth_tab);
printf("\nafter ex_get_elem_var_tab, error = %3d\n", error);
printf("This is the element variable truth table:\n");
k = 0;
for (i = 0; i < num_elem_blk * num_ele_vars; i++) {
printf("%2d\n", truth_tab[k++]);
}
free(truth_tab);
}
}
/* read nodeset variables parameters and names */
num_nset_vars = 0;
if (num_node_sets > 0) {
error = ex_get_var_param(exoid, "m", &num_nset_vars);
printf("\nafter ex_get_var_param, error = %3d\n", error);
if (num_nset_vars > 0) {
for (i = 0; i < num_nset_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_var_names(exoid, "m", num_nset_vars, var_names);
printf("\nafter ex_get_var_names, error = %3d\n", error);
printf("There are %2d nodeset variables; their names are :\n", num_nset_vars);
for (i = 0; i < num_nset_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
/* read nodeset variable truth table */
if (num_nset_vars > 0) {
truth_tab = (int *)calloc((num_node_sets * num_nset_vars), sizeof(int));
error = ex_get_nset_var_tab(exoid, num_node_sets, num_nset_vars, truth_tab);
printf("\nafter ex_get_nset_var_tab, error = %3d\n", error);
printf("This is the nodeset variable truth table:\n");
k = 0;
for (i = 0; i < num_node_sets * num_nset_vars; i++) {
printf("%2d\n", truth_tab[k++]);
}
free(truth_tab);
}
}
}
/* read sideset variables parameters and names */
num_sset_vars = 0;
if (num_side_sets > 0) {
error = ex_get_var_param(exoid, "s", &num_sset_vars);
printf("\nafter ex_get_var_param, error = %3d\n", error);
if (num_sset_vars > 0) {
for (i = 0; i < num_sset_vars; i++) {
var_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_var_names(exoid, "s", num_sset_vars, var_names);
printf("\nafter ex_get_var_names, error = %3d\n", error);
printf("There are %2d sideset variables; their names are :\n", num_sset_vars);
for (i = 0; i < num_sset_vars; i++) {
printf(" '%s'\n", var_names[i]);
free(var_names[i]);
}
/* read sideset variable truth table */
if (num_sset_vars > 0) {
truth_tab = (int *)calloc((num_side_sets * num_sset_vars), sizeof(int));
error = ex_get_sset_var_tab(exoid, num_side_sets, num_sset_vars, truth_tab);
printf("\nafter ex_get_sset_var_tab, error = %3d\n", error);
printf("This is the sideset variable truth table:\n");
k = 0;
for (i = 0; i < num_side_sets * num_sset_vars; i++) {
printf("%2d\n", truth_tab[k++]);
}
free(truth_tab);
}
}
}
/* determine how many time steps are stored */
error = ex_inquire(exoid, EX_INQ_TIME, &num_time_steps, &fdum, cdum);
printf("\nafter ex_inquire, error = %3d\n", error);
printf("There are %2d time steps in the database.\n", num_time_steps);
/* read time value at one time step */
time_step = 3;
error = ex_get_time(exoid, time_step, &time_value);
printf("\nafter ex_get_time, error = %3d\n", error);
printf("time value at time step %2d = %5.3f\n", time_step, time_value);
/* read time values at all time steps */
time_values = (float *)calloc(num_time_steps, sizeof(float));
error = ex_get_all_times(exoid, time_values);
printf("\nafter ex_get_all_times, error = %3d\n", error);
printf("time values at all time steps are:\n");
for (i = 0; i < num_time_steps; i++)
printf("%5.3f\n", time_values[i]);
free(time_values);
/* read all global variables at one time step */
var_values = (float *)calloc(num_glo_vars, sizeof(float));
error = ex_get_glob_vars(exoid, time_step, num_glo_vars, var_values);
printf("\nafter ex_get_glob_vars, error = %3d\n", error);
printf("global variable values at time step %2d\n", time_step);
for (i = 0; i < num_glo_vars; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
/* read a single global variable through time */
var_index = 1;
beg_time = 1;
end_time = -1;
var_values = (float *)calloc(num_time_steps, sizeof(float));
error = ex_get_glob_var_time(exoid, var_index, beg_time, end_time, var_values);
printf("\nafter ex_get_glob_var_time, error = %3d\n", error);
printf("global variable %2d values through time:\n", var_index);
for (i = 0; i < num_time_steps; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
/* read a nodal variable at one time step */
if (num_nodes > 0) {
var_values = (float *)calloc(num_nodes, sizeof(float));
error = ex_get_nodal_var(exoid, time_step, var_index, num_nodes, var_values);
printf("\nafter ex_get_nodal_var, error = %3d\n", error);
printf("nodal variable %2d values at time step %2d\n", var_index, time_step);
for (i = 0; i < num_nodes; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
/* read a nodal variable through time */
var_values = (float *)calloc(num_time_steps, sizeof(float));
node_num = 1;
error = ex_get_nodal_var_time(exoid, var_index, node_num, beg_time, end_time, var_values);
printf("\nafter ex_get_nodal_var_time, error = %3d\n", error);
printf("nodal variable %2d values for node %2d through time:\n", var_index, node_num);
for (i = 0; i < num_time_steps; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
}
/* read an element variable at one time step */
if (num_elem_blk > 0) {
ids = (int *)calloc(num_elem_blk, sizeof(int));
error = ex_get_elem_blk_ids(exoid, ids);
printf("\n after ex_get_elem_blk_ids, error = %3d\n", error);
for (i = 0; i < num_elem_blk; i++) {
if (num_elem_in_block[i] > 0) {
var_values = (float *)calloc(num_elem_in_block[i], sizeof(float));
error =
ex_get_elem_var(exoid, time_step, var_index, ids[i], num_elem_in_block[i], var_values);
printf("\nafter ex_get_elem_var, error = %3d\n", error);
if (!error) {
printf("element variable %2d values of element block %2d at time step %2d\n", var_index,
ids[i], time_step);
for (j = 0; j < num_elem_in_block[i]; j++)
printf("%5.3f\n", var_values[j]);
}
free(var_values);
}
}
free(num_elem_in_block);
free(ids);
}
/* read an element variable through time */
if (num_ele_vars > 0) {
var_values = (float *)calloc(num_time_steps, sizeof(float));
var_index = 2;
elem_num = 2;
error = ex_get_elem_var_time(exoid, var_index, elem_num, beg_time, end_time, var_values);
printf("\nafter ex_get_elem_var_time, error = %3d\n", error);
printf("element variable %2d values for element %2d through time:\n", var_index, elem_num);
for (i = 0; i < num_time_steps; i++)
printf("%5.3f\n", var_values[i]);
free(var_values);
}
/* read a sideset variable at one time step */
if (num_sset_vars > 0) {
ids = (int *)calloc(num_side_sets, sizeof(int));
error = ex_get_side_set_ids(exoid, ids);
printf("\n after ex_get_side_set_ids, error = %3d\n", error);
for (i = 0; i < num_side_sets; i++) {
var_values = (float *)calloc(num_elem_per_set[i], sizeof(float));
error = ex_get_sset_var(exoid, time_step, var_index, ids[i], num_elem_per_set[i], var_values);
printf("\nafter ex_get_sset_var, error = %3d\n", error);
if (!error) {
printf("sideset variable %2d values of sideset %2d at time step %2d\n", var_index, ids[i],
time_step);
for (j = 0; j < num_elem_per_set[i]; j++)
printf("%5.3f\n", var_values[j]);
}
free(var_values);
}
free(num_elem_per_set);
free(ids);
}
/* read a nodeset variable at one time step */
if (num_nset_vars > 0) {
ids = (int *)calloc(num_node_sets, sizeof(int));
error = ex_get_node_set_ids(exoid, ids);
printf("\n after ex_get_node_set_ids, error = %3d\n", error);
for (i = 0; i < num_node_sets; i++) {
var_values = (float *)calloc(num_nodes_per_set[i], sizeof(float));
error =
ex_get_nset_var(exoid, time_step, var_index, ids[i], num_nodes_per_set[i], var_values);
printf("\nafter ex_get_nset_var, error = %3d\n", error);
if (!error) {
printf("nodeset variable %2d values of nodeset %2d at time step %2d\n", var_index, ids[i],
time_step);
for (j = 0; j < num_nodes_per_set[i]; j++)
printf("%5.3f\n", var_values[j]);
}
free(var_values);
}
free(ids);
}
if (num_node_sets > 0)
free(num_nodes_per_set);
error = ex_close(exoid);
printf("\nafter ex_close, error = %3d\n", error);
return 0;
}
int 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_mesh(const std::string &exo_file,
Problem_Description* problem,
Mesh_Description<INT>* mesh,
Weight_Description<INT>* weight
)
{
float version, *xptr, *yptr, *zptr;
char elem_type[MAX_STR_LENGTH+1];
E_Type blk_elem_type;
/*---------------------------Execution Begins--------------------------------*/
/* Open the ExodusII file */
int exoid, cpu_ws=0, io_ws=0;
int mode = EX_READ | problem->int64api;
if((exoid=ex_open(exo_file.c_str(), mode, &cpu_ws, &io_ws, &version)) < 0)
{
Gen_Error(0, "fatal: unable to open ExodusII mesh file");
return 0;
}
/* Read the coordinates, if desired */
xptr = yptr = zptr = NULL;
if(problem->read_coords == ELB_TRUE)
{
switch(mesh->num_dims)
{
case 3:
zptr = (mesh->coords)+2*(mesh->num_nodes);
/* FALLTHRU */
case 2:
yptr = (mesh->coords)+(mesh->num_nodes);
/* FALLTHRU */
case 1:
xptr = mesh->coords;
}
if(ex_get_coord(exoid, xptr, yptr, zptr) < 0)
{
Gen_Error(0, "fatal: unable to read coordinate values for mesh");
return 0;
}
} /* End "if(problem->read_coords == ELB_TRUE)" */
/* Read the element block IDs */
std::vector<INT> el_blk_ids(mesh->num_el_blks);
std::vector<INT> el_blk_cnts(mesh->num_el_blks);
if(ex_get_elem_blk_ids(exoid, &el_blk_ids[0]) < 0)
{
Gen_Error(0, "fatal: unable to read element block IDs");
return 0;
}
/* Read the element connectivity */
size_t gelem_cnt=0;
for(size_t cnt=0; cnt < mesh->num_el_blks; cnt++) {
INT nodes_per_elem, num_attr;
if(ex_get_elem_block(exoid, el_blk_ids[cnt], elem_type,
&(el_blk_cnts[cnt]), &nodes_per_elem,
&num_attr) < 0)
{
Gen_Error(0, "fatal: unable to read element block");
return 0;
}
blk_elem_type = get_elem_type(elem_type, nodes_per_elem, mesh->num_dims);
INT *blk_connect = (INT*)malloc(sizeof(INT)*el_blk_cnts[cnt]*nodes_per_elem);
if(!blk_connect)
{
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
/* Get the connectivity for this element block */
if(ex_get_elem_conn(exoid, el_blk_ids[cnt], blk_connect) < 0)
{
Gen_Error(0, "fatal: failed to get element connectivity");
return 0;
}
/* find out if this element block is weighted */
int wgt = -1;
if (weight->type & EL_BLK)
wgt = in_list(el_blk_ids[cnt], weight->elemblk);
/* Fill the 2D global connectivity array */
if (((problem->type == ELEMENTAL) && (weight->type & EL_BLK)) ||
((problem->type == NODAL) && (weight->type & EL_BLK))) {
for(int64_t cnt2=0; cnt2 < el_blk_cnts[cnt]; cnt2++) {
mesh->elem_type[gelem_cnt] = blk_elem_type;
/* while going through the blocks, take care of the weighting */
if ((problem->type == ELEMENTAL) && (weight->type & EL_BLK)) {
/* is this block weighted */
if (wgt >= 0) {
/* check if there is a read value */
if (weight->vertices[gelem_cnt] >= 1) {
/* and if it should be overwritten */
if (weight->ow_read)
weight->vertices[gelem_cnt] = weight->elemblk_wgt[wgt];
}
else
weight->vertices[gelem_cnt] = weight->elemblk_wgt[wgt];
}
else {
/* now check if this weight has been initialized */
if (weight->vertices[gelem_cnt] < 1)
weight->vertices[gelem_cnt] = 1;
}
}
for(int64_t cnt3=0; cnt3 < nodes_per_elem; cnt3++) {
INT node = blk_connect[cnt3 + cnt2*nodes_per_elem] - 1;
assert(node >= 0);
mesh->connect[gelem_cnt][cnt3] = node;
/* deal with the weighting if necessary */
if ((problem->type == NODAL) && (weight->type & EL_BLK)) {
/* is this block weighted */
if (wgt >= 0) {
/* check if I read an exodus file */
if (weight->type & READ_EXO) {
/* check if it can be overwritten */
if (weight->ow_read) {
/* check if it has been overwritten already */
if (weight->ow[node]) {
weight->vertices[node] =
MAX(weight->vertices[node], weight->elemblk_wgt[wgt]);
}
else {
weight->vertices[node] = weight->elemblk_wgt[wgt];
weight->ow[node] = 1; /* read value has been overwritten */
}
}
}
else {
weight->vertices[node] =
MAX(weight->vertices[node], weight->elemblk_wgt[wgt]);
}
}
else {
/* now check if this weight has been initialized */
if (weight->vertices[node] < 1)
weight->vertices[node] = 1;
}
}
}
gelem_cnt++;
}
} else {
// No weights...
for (int64_t cnt2=0; cnt2 < el_blk_cnts[cnt]; cnt2++) {
mesh->elem_type[gelem_cnt] = blk_elem_type;
for (int64_t cnt3=0; cnt3 < nodes_per_elem; cnt3++) {
INT node = blk_connect[cnt2*nodes_per_elem + cnt3] - 1;
assert(node >= 0);
mesh->connect[gelem_cnt][cnt3] = node;
}
gelem_cnt++;
}
}
/* Free up memory */
free(blk_connect);
} /* End "for(cnt=0; cnt < mesh->num_el_blks; cnt++)" */
/* if there is a group designator, then parse it here */
if (problem->groups != NULL) {
if (!parse_groups(&el_blk_ids[0], &el_blk_cnts[0], mesh, problem)) {
Gen_Error(0, "fatal: unable to parse group designator");
ex_close(exoid);
return 0;
}
}
else problem->num_groups = 1; /* there is always one group */
/* Close the ExodusII file */
if(ex_close(exoid) < 0)
Gen_Error(0, "warning: failed to close ExodusII mesh file");
return 1;
} /*---------------------------End read_mesh()-------------------------------*/
int main(int argc, char **argv)
{
int exoid, exoid2, num_dim, num_nodes, num_elem, num_elem_blk;
int num_elem_in_block, num_node_sets, num_nodes_per_elem, num_attr;
int num_side_sets, error;
int i, j;
int *elem_map, *connect, *node_list, *node_ctr_list, *elem_list, *side_list;
int *ids;
int num_nodes_in_set, num_elem_in_set;
int num_sides_in_set, num_df_in_set;
int num_qa_rec, num_info;
int CPU_word_size, IO_word_size;
int num_props, prop_value, *prop_values;
float *x, *y, *z;
float *dist_fact;
float version, fdum;
float attrib[1];
char *coord_names[3], *qa_record[2][4], *info[3];
char title[MAX_LINE_LENGTH + 1], elem_type[MAX_STR_LENGTH + 1];
char *prop_names[3];
char *cdum = 0;
/* Specify compute and i/o word size */
CPU_word_size = 0; /* sizeof(float) */
IO_word_size = 4; /* float */
/* open EXODUS II file for reading */
ex_opts(EX_VERBOSE | EX_ABORT);
exoid = ex_open("test.exo", /* filename path */
EX_READ, /* access mode */
&CPU_word_size, /* CPU float word size in bytes */
&IO_word_size, /* I/O float word size in bytes */
&version); /* returned version number */
printf("after ex_open for test.exo\n");
printf(" cpu word size: %d io word size: %d\n", CPU_word_size, IO_word_size);
/* create EXODUS II file for writing */
exoid2 = ex_create("test2.exo", /* filename path */
EX_CLOBBER, /* create mode */
&CPU_word_size, /* CPU float word size in bytes */
&IO_word_size); /* I/O float word size in bytes */
printf("after ex_create for test2.exo, exoid = %d\n", exoid2);
/* read initialization parameters */
error = ex_get_init(exoid, title, &num_dim, &num_nodes, &num_elem, &num_elem_blk, &num_node_sets,
&num_side_sets);
printf("after ex_get_init, error = %d\n", error);
/* write initialization parameters */
error = ex_put_init(exoid2, title, num_dim, num_nodes, num_elem, num_elem_blk, num_node_sets,
num_side_sets);
printf("after ex_put_init, error = %d\n", error);
/* read nodal coordinate values */
x = (float *)calloc(num_nodes, sizeof(float));
y = (float *)calloc(num_nodes, sizeof(float));
if (num_dim >= 3)
z = (float *)calloc(num_nodes, sizeof(float));
else
z = 0;
error = ex_get_coord(exoid, x, y, z);
printf("\nafter ex_get_coord, error = %3d\n", error);
/* write nodal coordinate values */
error = ex_put_coord(exoid2, x, y, z);
printf("after ex_put_coord, error = %d\n", error);
free(x);
free(y);
if (num_dim >= 3)
free(z);
/* read nodal coordinate names */
for (i = 0; i < num_dim; i++) {
coord_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_coord_names(exoid, coord_names);
printf("\nafter ex_get_coord_names, error = %3d\n", error);
/* write nodal coordinate names */
error = ex_put_coord_names(exoid2, coord_names);
printf("after ex_put_coord_names, error = %d\n", error);
for (i = 0; i < num_dim; i++) {
free(coord_names[i]);
}
/* read element order map */
elem_map = (int *)calloc(num_elem, sizeof(int));
error = ex_get_map(exoid, elem_map);
printf("\nafter ex_get_map, error = %3d\n", error);
/* write element order map */
error = ex_put_map(exoid2, elem_map);
printf("after ex_put_map, error = %d\n", error);
free(elem_map);
/* read and write element block parameters and element connectivity */
ids = (int *)calloc(num_elem_blk, sizeof(int));
error = ex_get_elem_blk_ids(exoid, ids);
printf("\nafter ex_get_elem_blk_ids, error = %3d\n", error);
attrib[0] = 3.14159;
for (i = 0; i < num_elem_blk; i++) {
error = ex_get_elem_block(exoid, ids[i], elem_type, &num_elem_in_block, &num_nodes_per_elem,
&num_attr);
printf("\nafter ex_get_elem_block, error = %d\n", error);
error = ex_put_elem_block(exoid2, ids[i], elem_type, num_elem_in_block, num_nodes_per_elem,
num_attr);
printf("after ex_put_elem_block, error = %d\n", error);
connect = (int *)calloc((num_nodes_per_elem * num_elem_in_block), sizeof(int));
error = ex_get_elem_conn(exoid, ids[i], connect);
printf("\nafter ex_get_elem_conn, error = %d\n", error);
error = ex_put_elem_conn(exoid2, ids[i], connect);
printf("after ex_put_elem_conn, error = %d\n", error);
/* write element block attributes */
error = ex_put_attr(exoid2, EX_ELEM_BLOCK, ids[i], attrib);
printf("after ex_put_elem_attr, error = %d\n", error);
free(connect);
}
/* read and write element block properties */
error = ex_inquire(exoid, EX_INQ_EB_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_prop_names(exoid, EX_ELEM_BLOCK, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
error = ex_put_prop_names(exoid2, EX_ELEM_BLOCK, num_props, prop_names);
printf("after ex_put_prop_names, error = %d\n", error);
for (i = 0; i < num_props; i++) {
for (j = 0; j < num_elem_blk; j++) {
error = ex_get_prop(exoid, EX_ELEM_BLOCK, ids[j], prop_names[i], &prop_value);
printf("after ex_get_prop, error = %d\n", error);
if (i > 0) { /* first property is the ID which is already stored */
error = ex_put_prop(exoid2, EX_ELEM_BLOCK, ids[j], prop_names[i], prop_value);
printf("after ex_put_prop, error = %d\n", error);
}
}
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
free(ids);
/* read and write individual node sets */
ids = (int *)calloc(num_node_sets, sizeof(int));
error = ex_get_node_set_ids(exoid, ids);
printf("\nafter ex_get_node_set_ids, error = %3d\n", error);
for (i = 0; i < num_node_sets; i++) {
error = ex_get_node_set_param(exoid, ids[i], &num_nodes_in_set, &num_df_in_set);
printf("\nafter ex_get_node_set_param, error = %3d\n", error);
error = ex_put_node_set_param(exoid2, ids[i], num_nodes_in_set, num_df_in_set);
printf("after ex_put_node_set_param, error = %d\n", error);
node_list = (int *)calloc(num_nodes_in_set, sizeof(int));
dist_fact = (float *)calloc(num_nodes_in_set, sizeof(float));
error = ex_get_node_set(exoid, ids[i], node_list);
printf("\nafter ex_get_node_set, error = %3d\n", error);
error = ex_put_node_set(exoid2, ids[i], node_list);
printf("after ex_put_node_set, error = %d\n", error);
if (num_df_in_set > 0) {
error = ex_get_node_set_dist_fact(exoid, ids[i], dist_fact);
printf("\nafter ex_get_node_set_dist_fact, error = %3d\n", error);
error = ex_put_node_set_dist_fact(exoid2, ids[i], dist_fact);
printf("after ex_put_node_set, error = %d\n", error);
}
free(node_list);
free(dist_fact);
}
free(ids);
/* read node set properties */
error = ex_inquire(exoid, EX_INQ_NS_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
prop_values = (int *)calloc(num_node_sets, sizeof(int));
error = ex_get_prop_names(exoid, EX_NODE_SET, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
error = ex_put_prop_names(exoid2, EX_NODE_SET, num_props, prop_names);
printf("after ex_put_prop_names, error = %d\n", error);
for (i = 0; i < num_props; i++) {
error = ex_get_prop_array(exoid, EX_NODE_SET, prop_names[i], prop_values);
printf("after ex_get_prop_array, error = %d\n", error);
error = ex_put_prop_array(exoid2, EX_NODE_SET, prop_names[i], prop_values);
printf("after ex_put_prop_array, error = %d\n", error);
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
free(prop_values);
/* read and write individual side sets */
ids = (int *)calloc(num_side_sets, sizeof(int));
error = ex_get_side_set_ids(exoid, ids);
printf("\nafter ex_get_side_set_ids, error = %3d\n", error);
for (i = 0; i < num_side_sets; i++) {
error = ex_get_side_set_param(exoid, ids[i], &num_sides_in_set, &num_df_in_set);
printf("\nafter ex_get_side_set_param, error = %3d\n", error);
error = ex_put_side_set_param(exoid2, ids[i], num_sides_in_set, num_df_in_set);
printf("after ex_put_side_set_param, error = %d\n", error);
/* Note: The # of elements is same as # of sides! */
num_elem_in_set = num_sides_in_set;
elem_list = (int *)calloc(num_elem_in_set, sizeof(int));
side_list = (int *)calloc(num_sides_in_set, sizeof(int));
node_ctr_list = (int *)calloc(num_elem_in_set, sizeof(int));
node_list = (int *)calloc(num_elem_in_set * 21, sizeof(int));
dist_fact = (float *)calloc(num_df_in_set, sizeof(float));
error = ex_get_side_set(exoid, ids[i], elem_list, side_list);
printf("\nafter ex_get_side_set, error = %3d\n", error);
error = ex_put_side_set(exoid2, ids[i], elem_list, side_list);
printf("after ex_put_side_set, error = %d\n", error);
error = ex_get_side_set_node_list(exoid, ids[i], node_ctr_list, node_list);
printf("\nafter ex_get_side_set_node_list, error = %3d\n", error);
if (num_df_in_set > 0) {
error = ex_get_side_set_dist_fact(exoid, ids[i], dist_fact);
printf("\nafter ex_get_side_set_dist_fact, error = %3d\n", error);
error = ex_put_side_set_dist_fact(exoid2, ids[i], dist_fact);
printf("after ex_put_side_set_dist_fact, error = %d\n", error);
}
free(elem_list);
free(side_list);
free(node_ctr_list);
free(node_list);
free(dist_fact);
}
/* read side set properties */
error = ex_inquire(exoid, EX_INQ_SS_PROP, &num_props, &fdum, cdum);
printf("\nafter ex_inquire, error = %d\n", error);
for (i = 0; i < num_props; i++) {
prop_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_prop_names(exoid, EX_SIDE_SET, prop_names);
printf("after ex_get_prop_names, error = %d\n", error);
for (i = 0; i < num_props; i++) {
for (j = 0; j < num_side_sets; j++) {
error = ex_get_prop(exoid, EX_SIDE_SET, ids[j], prop_names[i], &prop_value);
printf("after ex_get_prop, error = %d\n", error);
if (i > 0) { /* first property is ID so it is already stored */
error = ex_put_prop(exoid2, EX_SIDE_SET, ids[j], prop_names[i], prop_value);
printf("after ex_put_prop, error = %d\n", error);
}
}
}
for (i = 0; i < num_props; i++)
free(prop_names[i]);
free(ids);
/* read and write QA records */
ex_inquire(exoid, EX_INQ_QA, &num_qa_rec, &fdum, cdum);
for (i = 0; i < num_qa_rec; i++) {
for (j = 0; j < 4; j++) {
qa_record[i][j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
}
error = ex_get_qa(exoid, qa_record);
printf("\nafter ex_get_qa, error = %3d\n", error);
error = ex_put_qa(exoid2, num_qa_rec, qa_record);
printf("after ex_put_qa, error = %d\n", error);
for (i = 0; i < num_qa_rec; i++) {
for (j = 0; j < 4; j++) {
free(qa_record[i][j]);
}
}
/* read and write information records */
error = ex_inquire(exoid, EX_INQ_INFO, &num_info, &fdum, cdum);
printf("\nafter ex_inquire, error = %3d\n", error);
for (i = 0; i < num_info; i++) {
info[i] = (char *)calloc((MAX_LINE_LENGTH + 1), sizeof(char));
}
error = ex_get_info(exoid, info);
printf("\nafter ex_get_info, error = %3d\n", error);
error = ex_put_info(exoid2, num_info, info);
printf("after ex_put_info, error = %d\n", error);
for (i = 0; i < num_info; i++) {
free(info[i]);
}
/* close the EXODUS files */
error = ex_close(exoid);
printf("after ex_close, error = %d\n", error);
error = ex_close(exoid2);
printf("after ex_close (2), error = %d\n", error);
return 0;
}
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;
}
//----------------------------------------------------------------------------
//
// Modifications:
// Kathleen Bonnell, Mon Oct 29 15:27:41 PST 2001
// Use vtkIdType for outPtCount to match VTK 4.0 API.
//
//----------------------------------------------------------------------------
void vtkExodusReader::ReadPoints(int exoid)
{
float *x, *y, *z;
vtkUnstructuredGrid *output = this->GetOutput();
vtkPoints *newPoints;
int inId, outId;
vtkIdType outPtCount;
// Read points
x = new float[this->NumberOfNodes];
y = new float[this->NumberOfNodes];
if (this->Dimensionality >= 3)
{
z = new float[this->NumberOfNodes];
}
else
{
z = NULL;
}
ex_get_coord(exoid, x, y, z);
// Do we need to reorder these axes based on name? Probably not.
newPoints = vtkPoints::New();
// Although we have to read all of the points,
// we are only going to save the points the points that we used.
outPtCount = this->PointMapOutIn->GetNumberOfIds();
newPoints->SetNumberOfPoints(outPtCount);
for (outId = 0; outId < outPtCount; ++outId)
{
inId = this->PointMapOutIn->GetId(outId);
// Sanity check
if (inId < 0 || inId >= this->NumberOfNodes)
{
vtkErrorMacro("Point id out of range.");
}
if (z == NULL)
{
newPoints->InsertPoint(outId, x[inId], y[inId], 0.0);
}
else
{
newPoints->InsertPoint(outId, x[inId], y[inId], z[inId]);
}
}
output->SetPoints(newPoints);
delete [] x;
delete [] y;
if (z)
{
delete [] z;
}
newPoints->Delete();
newPoints = NULL;
if (output->GetReleaseDataFlag() == 0)
{
this->SetGeometryFileName(this->FileName);
this->GeometryCache->ShallowCopy(output);
}
}
/*@
DMPlexCreateExodus - Create a DMPlex mesh from an ExodusII file ID.
Collective on comm
Input Parameters:
+ comm - The MPI communicator
. exoid - The ExodusII id associated with a exodus file and obtained using ex_open
- interpolate - Create faces and edges in the mesh
Output Parameter:
. dm - The DM object representing the mesh
Level: beginner
.keywords: mesh,ExodusII
.seealso: DMPLEX, DMCreate()
@*/
PetscErrorCode DMPlexCreateExodus(MPI_Comm comm, PetscInt exoid, PetscBool interpolate, DM *dm)
{
#if defined(PETSC_HAVE_EXODUSII)
PetscMPIInt num_proc, rank;
PetscSection coordSection;
Vec coordinates;
PetscScalar *coords;
PetscInt coordSize, v;
PetscErrorCode ierr;
/* Read from ex_get_init() */
char title[PETSC_MAX_PATH_LEN+1];
int dim = 0, numVertices = 0, numCells = 0;
int num_cs = 0, num_vs = 0, num_fs = 0;
#endif
PetscFunctionBegin;
#if defined(PETSC_HAVE_EXODUSII)
ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr);
ierr = MPI_Comm_size(comm, &num_proc);CHKERRQ(ierr);
ierr = DMCreate(comm, dm);CHKERRQ(ierr);
ierr = DMSetType(*dm, DMPLEX);CHKERRQ(ierr);
/* Open EXODUS II file and read basic informations on rank 0, then broadcast to all processors */
if (!rank) {
ierr = PetscMemzero(title,(PETSC_MAX_PATH_LEN+1)*sizeof(char));CHKERRQ(ierr);
ierr = ex_get_init(exoid, title, &dim, &numVertices, &numCells, &num_cs, &num_vs, &num_fs);
if (ierr) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"ExodusII ex_get_init() failed with error code %D\n",ierr);
if (!num_cs) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP,"Exodus file does not contain any cell set\n");
}
ierr = MPI_Bcast(title, PETSC_MAX_PATH_LEN+1, MPI_CHAR, 0, comm);CHKERRQ(ierr);
ierr = MPI_Bcast(&dim, 1, MPI_INT, 0, comm);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) *dm, title);CHKERRQ(ierr);
ierr = DMSetDimension(*dm, dim);CHKERRQ(ierr);
ierr = DMPlexSetChart(*dm, 0, numCells+numVertices);CHKERRQ(ierr);
/* Read cell sets information */
if (!rank) {
PetscInt *cone;
int c, cs, c_loc, v, v_loc;
/* Read from ex_get_elem_blk_ids() */
int *cs_id;
/* Read from ex_get_elem_block() */
char buffer[PETSC_MAX_PATH_LEN+1];
int num_cell_in_set, num_vertex_per_cell, num_attr;
/* Read from ex_get_elem_conn() */
int *cs_connect;
/* Get cell sets IDs */
ierr = PetscMalloc1(num_cs, &cs_id);CHKERRQ(ierr);
ierr = ex_get_elem_blk_ids(exoid, cs_id);CHKERRQ(ierr);
/* Read the cell set connectivity table and build mesh topology
EXO standard requires that cells in cell sets be numbered sequentially and be pairwise disjoint. */
/* First set sizes */
for (cs = 0, c = 0; cs < num_cs; cs++) {
ierr = ex_get_elem_block(exoid, cs_id[cs], buffer, &num_cell_in_set, &num_vertex_per_cell, &num_attr);CHKERRQ(ierr);
for (c_loc = 0; c_loc < num_cell_in_set; ++c_loc, ++c) {
ierr = DMPlexSetConeSize(*dm, c, num_vertex_per_cell);CHKERRQ(ierr);
}
}
ierr = DMSetUp(*dm);CHKERRQ(ierr);
for (cs = 0, c = 0; cs < num_cs; cs++) {
ierr = ex_get_elem_block(exoid, cs_id[cs], buffer, &num_cell_in_set, &num_vertex_per_cell, &num_attr);CHKERRQ(ierr);
ierr = PetscMalloc2(num_vertex_per_cell*num_cell_in_set,&cs_connect,num_vertex_per_cell,&cone);CHKERRQ(ierr);
ierr = ex_get_elem_conn(exoid, cs_id[cs], cs_connect);CHKERRQ(ierr);
/* EXO uses Fortran-based indexing, sieve uses C-style and numbers cell first then vertices. */
for (c_loc = 0, v = 0; c_loc < num_cell_in_set; ++c_loc, ++c) {
for (v_loc = 0; v_loc < num_vertex_per_cell; ++v_loc, ++v) {
cone[v_loc] = cs_connect[v]+numCells-1;
}
if (dim == 3) {
/* Tetrahedra are inverted */
if (num_vertex_per_cell == 4) {
PetscInt tmp = cone[0];
cone[0] = cone[1];
cone[1] = tmp;
}
/* Hexahedra are inverted */
if (num_vertex_per_cell == 8) {
PetscInt tmp = cone[1];
cone[1] = cone[3];
cone[3] = tmp;
}
}
ierr = DMPlexSetCone(*dm, c, cone);CHKERRQ(ierr);
ierr = DMSetLabelValue(*dm, "Cell Sets", c, cs_id[cs]);CHKERRQ(ierr);
}
ierr = PetscFree2(cs_connect,cone);CHKERRQ(ierr);
}
ierr = PetscFree(cs_id);CHKERRQ(ierr);
}
ierr = DMPlexSymmetrize(*dm);CHKERRQ(ierr);
ierr = DMPlexStratify(*dm);CHKERRQ(ierr);
if (interpolate) {
DM idm = NULL;
ierr = DMPlexInterpolate(*dm, &idm);CHKERRQ(ierr);
/* Maintain Cell Sets label */
{
DMLabel label;
ierr = DMRemoveLabel(*dm, "Cell Sets", &label);CHKERRQ(ierr);
if (label) {ierr = DMAddLabel(idm, label);CHKERRQ(ierr);}
}
ierr = DMDestroy(dm);CHKERRQ(ierr);
*dm = idm;
}
/* Create vertex set label */
if (!rank && (num_vs > 0)) {
int vs, v;
/* Read from ex_get_node_set_ids() */
int *vs_id;
/* Read from ex_get_node_set_param() */
int num_vertex_in_set, num_attr;
/* Read from ex_get_node_set() */
int *vs_vertex_list;
/* Get vertex set ids */
ierr = PetscMalloc1(num_vs, &vs_id);CHKERRQ(ierr);
ierr = ex_get_node_set_ids(exoid, vs_id);CHKERRQ(ierr);
for (vs = 0; vs < num_vs; ++vs) {
ierr = ex_get_node_set_param(exoid, vs_id[vs], &num_vertex_in_set, &num_attr);CHKERRQ(ierr);
ierr = PetscMalloc1(num_vertex_in_set, &vs_vertex_list);CHKERRQ(ierr);
ierr = ex_get_node_set(exoid, vs_id[vs], vs_vertex_list);CHKERRQ(ierr);
for (v = 0; v < num_vertex_in_set; ++v) {
ierr = DMSetLabelValue(*dm, "Vertex Sets", vs_vertex_list[v]+numCells-1, vs_id[vs]);CHKERRQ(ierr);
}
ierr = PetscFree(vs_vertex_list);CHKERRQ(ierr);
}
ierr = PetscFree(vs_id);CHKERRQ(ierr);
}
/* Read coordinates */
ierr = DMGetCoordinateSection(*dm, &coordSection);CHKERRQ(ierr);
ierr = PetscSectionSetNumFields(coordSection, 1);CHKERRQ(ierr);
ierr = PetscSectionSetFieldComponents(coordSection, 0, dim);CHKERRQ(ierr);
ierr = PetscSectionSetChart(coordSection, numCells, numCells + numVertices);CHKERRQ(ierr);
for (v = numCells; v < numCells+numVertices; ++v) {
ierr = PetscSectionSetDof(coordSection, v, dim);CHKERRQ(ierr);
ierr = PetscSectionSetFieldDof(coordSection, v, 0, dim);CHKERRQ(ierr);
}
ierr = PetscSectionSetUp(coordSection);CHKERRQ(ierr);
ierr = PetscSectionGetStorageSize(coordSection, &coordSize);CHKERRQ(ierr);
ierr = VecCreate(PETSC_COMM_SELF, &coordinates);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) coordinates, "coordinates");CHKERRQ(ierr);
ierr = VecSetSizes(coordinates, coordSize, PETSC_DETERMINE);CHKERRQ(ierr);
ierr = VecSetBlockSize(coordinates, dim);CHKERRQ(ierr);
ierr = VecSetType(coordinates,VECSTANDARD);CHKERRQ(ierr);
ierr = VecGetArray(coordinates, &coords);CHKERRQ(ierr);
if (!rank) {
float *x, *y, *z;
ierr = PetscMalloc3(numVertices,&x,numVertices,&y,numVertices,&z);CHKERRQ(ierr);
ierr = ex_get_coord(exoid, x, y, z);CHKERRQ(ierr);
if (dim > 0) {
for (v = 0; v < numVertices; ++v) coords[v*dim+0] = x[v];
}
if (dim > 1) {
for (v = 0; v < numVertices; ++v) coords[v*dim+1] = y[v];
}
if (dim > 2) {
for (v = 0; v < numVertices; ++v) coords[v*dim+2] = z[v];
}
ierr = PetscFree3(x,y,z);CHKERRQ(ierr);
}
ierr = VecRestoreArray(coordinates, &coords);CHKERRQ(ierr);
ierr = DMSetCoordinatesLocal(*dm, coordinates);CHKERRQ(ierr);
ierr = VecDestroy(&coordinates);CHKERRQ(ierr);
/* Create side set label */
if (!rank && interpolate && (num_fs > 0)) {
int fs, f, voff;
/* Read from ex_get_side_set_ids() */
int *fs_id;
/* Read from ex_get_side_set_param() */
int num_side_in_set, num_dist_fact_in_set;
/* Read from ex_get_side_set_node_list() */
int *fs_vertex_count_list, *fs_vertex_list;
/* Get side set ids */
ierr = PetscMalloc1(num_fs, &fs_id);CHKERRQ(ierr);
ierr = ex_get_side_set_ids(exoid, fs_id);CHKERRQ(ierr);
for (fs = 0; fs < num_fs; ++fs) {
ierr = ex_get_side_set_param(exoid, fs_id[fs], &num_side_in_set, &num_dist_fact_in_set);CHKERRQ(ierr);
ierr = PetscMalloc2(num_side_in_set,&fs_vertex_count_list,num_side_in_set*4,&fs_vertex_list);CHKERRQ(ierr);
ierr = ex_get_side_set_node_list(exoid, fs_id[fs], fs_vertex_count_list, fs_vertex_list);CHKERRQ(ierr);
for (f = 0, voff = 0; f < num_side_in_set; ++f) {
const PetscInt *faces = NULL;
PetscInt faceSize = fs_vertex_count_list[f], numFaces;
PetscInt faceVertices[4], v;
if (faceSize > 4) SETERRQ1(comm, PETSC_ERR_ARG_WRONG, "ExodusII side cannot have %d > 4 vertices", faceSize);
for (v = 0; v < faceSize; ++v, ++voff) {
faceVertices[v] = fs_vertex_list[voff]+numCells-1;
}
ierr = DMPlexGetFullJoin(*dm, faceSize, faceVertices, &numFaces, &faces);CHKERRQ(ierr);
if (numFaces != 1) SETERRQ3(comm, PETSC_ERR_ARG_WRONG, "Invalid ExodusII side %d in set %d maps to %d faces", f, fs, numFaces);
ierr = DMSetLabelValue(*dm, "Face Sets", faces[0], fs_id[fs]);CHKERRQ(ierr);
ierr = DMPlexRestoreJoin(*dm, faceSize, faceVertices, &numFaces, &faces);CHKERRQ(ierr);
}
ierr = PetscFree2(fs_vertex_count_list,fs_vertex_list);CHKERRQ(ierr);
}
ierr = PetscFree(fs_id);CHKERRQ(ierr);
}
#else
SETERRQ(comm, PETSC_ERR_SUP, "This method requires ExodusII support. Reconfigure using --download-exodusii");
#endif
PetscFunctionReturn(0);
}
int main(int argc, char **argv)
{
int exoid, num_dim, num_nodes, num_elem_blk;
int *num_elem_in_block, *num_face_in_block, *num_nodes_per_elem, *num_edges_per_elem,
*num_faces_per_elem, *num_attr;
int error, nnodes;
int i, j, k;
int *connect, *fconnect;
int *ids, *nnpe, *nnpf;
int num_qa_rec, num_info;
int CPU_word_size, IO_word_size;
int idum;
float *x, *y, *z;
float version, fdum;
char *coord_names[3], *qa_record[2][4], *info[3];
char *block_names[10];
char *elem_type[10];
char name[MAX_STR_LENGTH + 1];
char *cdum = 0;
CPU_word_size = 0; /* sizeof(float) */
IO_word_size = 0; /* use what is stored in file */
ex_opts(EX_VERBOSE | EX_ABORT);
/* open EXODUS II files */
exoid = ex_open("test-nfaced.exo", /* filename path */
EX_READ, /* access mode = READ */
&CPU_word_size, /* CPU word size */
&IO_word_size, /* IO word size */
&version); /* ExodusII library version */
printf("\nafter ex_open\n");
if (exoid < 0)
exit(1);
printf("test.exo is an EXODUSII file; version %4.2f\n", version);
printf(" I/O word size %1d\n", IO_word_size);
ex_inquire(exoid, EX_INQ_LIB_VERS, &idum, &version, cdum);
printf("EXODUSII Library API; version %4.2f (%d)\n", version, idum);
/* read database parameters */
{
ex_init_params par;
error = ex_get_init_ext(exoid, &par);
printf("after ex_get_init, error = %3d\n", error);
printf("database parameters:\n");
printf("title = '%s'\n", par.title);
printf("num_dim = %" PRId64 "\n", par.num_dim);
printf("num_nodes = %" PRId64 "\n", par.num_nodes);
printf("num_edge = %" PRId64 "\n", par.num_edge);
printf("num_face = %" PRId64 "\n", par.num_face);
printf("num_elem = %" PRId64 "\n", par.num_elem);
printf("num_elem_blk = %" PRId64 "\n", par.num_elem_blk);
printf("num_node_sets = %" PRId64 "\n", par.num_node_sets);
printf("num_side_sets = %" PRId64 "\n", par.num_side_sets);
num_dim = par.num_dim;
num_nodes = par.num_nodes;
num_elem_blk = par.num_elem_blk;
}
assert(num_dim == 3);
/* read nodal coordinates values and names from database */
x = (float *)calloc(num_nodes, sizeof(float));
y = (float *)calloc(num_nodes, sizeof(float));
z = (float *)calloc(num_nodes, sizeof(float));
error = ex_get_coord(exoid, x, y, z);
printf("\nafter ex_get_coord, error = %3d\n", error);
printf("x, y, z coords = \n");
for (i = 0; i < num_nodes; i++) {
printf("%5.1f\t%5.1f\t%5.1f\n", x[i], y[i], z[i]);
}
free(x);
free(y);
free(z);
for (i = 0; i < num_dim; i++) {
coord_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_coord_names(exoid, coord_names);
printf("\nafter ex_get_coord_names, error = %3d\n", error);
printf("x coord name = '%s'\n", coord_names[0]);
printf("y coord name = '%s'\n", coord_names[1]);
printf("z coord name = '%s'\n", coord_names[2]);
for (i = 0; i < num_dim; i++)
free(coord_names[i]);
/* read element block parameters */
if (num_elem_blk > 0) {
ids = (int *)calloc(num_elem_blk, sizeof(int));
num_elem_in_block = (int *)calloc(num_elem_blk, sizeof(int));
num_face_in_block = (int *)calloc(num_elem_blk, sizeof(int));
num_nodes_per_elem = (int *)calloc(num_elem_blk, sizeof(int));
num_edges_per_elem = (int *)calloc(num_elem_blk, sizeof(int));
num_faces_per_elem = (int *)calloc(num_elem_blk, sizeof(int));
num_attr = (int *)calloc(num_elem_blk, sizeof(int));
for (i = 0; i < num_elem_blk; i++) {
elem_type[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
block_names[i] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
error = ex_get_elem_blk_ids(exoid, ids);
printf("\nafter ex_get_elem_blk_ids, error = %3d\n", error);
error = ex_get_names(exoid, EX_ELEM_BLOCK, block_names);
printf("\nafter ex_get_names, error = %3d\n", error);
for (i = 0; i < num_elem_blk; i++) {
ex_get_name(exoid, EX_ELEM_BLOCK, ids[i], name);
if (strcmp(name, block_names[i]) != 0) {
printf("error in ex_get_name for block id %d\n", ids[i]);
}
error = ex_get_block(exoid, EX_ELEM_BLOCK, ids[i], elem_type[i], &(num_elem_in_block[i]),
&(num_nodes_per_elem[i]), &(num_edges_per_elem[i]),
&(num_faces_per_elem[i]), &(num_attr[i]));
printf("\nafter ex_get_elem_block, error = %d\n", error);
printf("element block id = %2d\n", ids[i]);
printf("element block type = '%s'\n", elem_type[i]);
printf("num_elem_in_block = %2d\n", num_elem_in_block[i]);
printf("num_total_nodes_per_block = %2d\n", num_nodes_per_elem[i]);
printf("num_total_edges_per_block = %2d\n", num_edges_per_elem[i]);
printf("num_total_faces_per_block = %2d\n", num_faces_per_elem[i]);
printf("num_attr = %2d\n", num_attr[i]);
printf("name = '%s'\n", block_names[i]);
}
}
/* read connectivity */
for (i = 0; i < num_elem_blk; i++) {
if (num_elem_in_block[i] > 0) {
if (strcmp(elem_type[i], "NFACED") == 0 || strcmp(elem_type[i], "nfaced") == 0) {
int nfaces = 0;
connect = (int *)calloc((num_faces_per_elem[i]), sizeof(int));
nnpe = (int *)calloc(num_elem_in_block[i], sizeof(int));
error = ex_get_entity_count_per_polyhedra(exoid, EX_ELEM_BLOCK, ids[i], nnpe);
printf("\nafter ex_get_entity_count_per_polyhedra, error = %d\n", error);
for (j = 0; j < num_elem_in_block[i]; j++) {
nfaces += nnpe[j];
}
assert(nfaces == num_faces_per_elem[i]);
error = ex_get_conn(exoid, EX_ELEM_BLOCK, ids[i], NULL, NULL, connect);
printf("\nafter ex_get_conn, error = %d\n", error);
printf("face connectivity array for elem block %2d\n", ids[i]);
nfaces = 0;
for (j = 0; j < num_elem_in_block[i]; j++) {
printf("Element %d, %d faces:\t", j + 1, nnpe[j]);
for (k = 0; k < nnpe[j]; k++) {
printf("%3d ", connect[nfaces + k]);
}
printf("\n");
nfaces += nnpe[j];
}
/* Now get the faces and their connectivity... */
/*
* Convention is that the faces for an nfaced block are in a
* face block which has the same id as the element block...
* (Or, at least let's try that for awhile and see if it works...)
*/
/* NOTE: We are overwriting the element block data here... */
error = ex_get_block(exoid, EX_FACE_BLOCK, ids[i], elem_type[i], &(num_face_in_block[i]),
&(num_nodes_per_elem[i]), NULL, NULL, &(num_attr[i]));
printf("\nafter ex_get_block (EX_FACE_BLOCK), error = %d\n", error);
error = ex_get_names(exoid, EX_FACE_BLOCK, block_names);
printf("\nafter ex_get_names, error = %3d\n", error);
printf("\tface block id = %2d\n", ids[i]);
printf("\tface block type = '%s'\n", elem_type[i]);
printf("\tnum_face_in_block = %2d\n", num_face_in_block[i]);
printf("\tnum_total_nodes_per_block = %2d\n", num_nodes_per_elem[i]);
printf("\tnum_attr = %2d\n", num_attr[i]);
printf("\tname = '%s'\n", block_names[i]);
fconnect = (int *)calloc((num_nodes_per_elem[i]), sizeof(int));
nnpf = (int *)calloc(num_face_in_block[i], sizeof(int));
error = ex_get_entity_count_per_polyhedra(exoid, EX_FACE_BLOCK, ids[i], nnpf);
printf("\nafter ex_get_entity_count_per_polyhedra, error = %d\n", error);
nnodes = 0;
for (j = 0; j < num_face_in_block[i]; j++) {
nnodes += nnpf[j];
}
assert(nnodes == num_nodes_per_elem[i]);
error = ex_get_conn(exoid, EX_FACE_BLOCK, ids[i], fconnect, NULL, NULL);
printf("\nafter ex_get_conn, error = %d\n", error);
printf("node connectivity array for face block %2d\n", ids[i]);
nnodes = 0;
for (j = 0; j < num_face_in_block[i]; j++) {
printf("Face %d, %d nodes:\t", j + 1, nnpf[j]);
for (k = 0; k < nnpf[j]; k++) {
printf("%3d ", fconnect[nnodes + k]);
}
printf("\n");
nnodes += nnpf[j];
}
free(fconnect);
free(nnpe);
free(nnpf);
}
else {
connect = (int *)calloc((num_nodes_per_elem[i] * num_elem_in_block[i]), sizeof(int));
error = ex_get_elem_conn(exoid, ids[i], connect);
printf("\nafter ex_get_elem_conn, error = %d\n", error);
printf("connect array for elem block %2d\n", ids[i]);
for (j = 0; j < num_nodes_per_elem[i]; j++) {
printf("%3d\n", connect[j]);
}
}
free(connect);
}
}
for (i = 0; i < num_elem_blk; i++) {
free(elem_type[i]);
free(block_names[i]);
}
if (num_elem_blk > 0) {
free(ids);
free(num_nodes_per_elem);
free(num_edges_per_elem);
free(num_faces_per_elem);
free(num_attr);
}
/* read QA records */
ex_inquire(exoid, EX_INQ_QA, &num_qa_rec, &fdum, cdum);
for (i = 0; i < num_qa_rec; i++) {
for (j = 0; j < 4; j++) {
qa_record[i][j] = (char *)calloc((MAX_STR_LENGTH + 1), sizeof(char));
}
}
error = ex_get_qa(exoid, qa_record);
printf("\nafter ex_get_qa, error = %3d\n", error);
printf("QA records = \n");
for (i = 0; i < num_qa_rec; i++) {
for (j = 0; j < 4; j++) {
printf(" '%s'\n", qa_record[i][j]);
free(qa_record[i][j]);
}
}
/* read information records */
error = ex_inquire(exoid, EX_INQ_INFO, &num_info, &fdum, cdum);
printf("\nafter ex_inquire, error = %3d\n", error);
for (i = 0; i < num_info; i++) {
info[i] = (char *)calloc((MAX_LINE_LENGTH + 1), sizeof(char));
}
error = ex_get_info(exoid, info);
printf("\nafter ex_get_info, error = %3d\n", error);
printf("info records = \n");
for (i = 0; i < num_info; i++) {
printf(" '%s'\n", info[i]);
free(info[i]);
}
error = ex_close(exoid);
printf("\nafter ex_close, error = %3d\n", error);
return 0;
}
/*
// Read and EXODUSII database and return a TECPLOT file
*/
void tec(int exoid, const char *filename)
{
int i, j, k, idum;
int ndim, nnode, nelem, nblk, nnset, neset, nvar, ntime, itime;
char title[MAX_LINE_LENGTH + 1];
char * nameco[3], **varnames = NULL;
double *x[3], **q = NULL, *time;
int * elem_id = NULL, *node_per_elem = NULL, *elem_per_blk = NULL, *attr_per_blk = NULL;
int ** icon = NULL, *ic = NULL, izone;
char ** elem_type = NULL;
int name_size = 0;
FILE * tecfile = NULL;
void teczone(int, int, int, char *, int, int, int *, int, double **, int, double **, FILE *);
/*
* FIRST, READ THE EXODUS DATA BASE
*/
/*
* Open the output file, if we can
*/
tecfile = fopen(filename, "w");
if (tecfile == NULL) {
printf("\nCannot open file %s for writing\n\n", filename);
exit(1);
}
/*
* Determine max name size used in databsae...
*/
name_size = ex_inquire_int(exoid, EX_INQ_DB_MAX_USED_NAME_LENGTH);
ex_set_max_name_length(exoid, name_size);
/*
* Read database size, get coordinates and connectivity
*/
memset(title, 0, MAX_LINE_LENGTH + 1);
ex_get_init(exoid, title, &ndim, &nnode, &nelem, &nblk, &nnset, &neset);
x[0] = x[1] = x[2] = NULL;
for (i = 0; i < ndim; i++) {
nameco[i] = (char *)malloc((name_size + 1) * sizeof(char));
x[i] = (double *)malloc(nnode * sizeof(double));
}
ex_get_coord_names(exoid, nameco);
if (strlen(nameco[0]) == 0)
strcpy(nameco[0], "X");
if (strlen(nameco[1]) == 0)
strcpy(nameco[1], "Y");
if (ndim > 2)
if (strlen(nameco[2]) == 0)
strcpy(nameco[2], "Z");
ex_get_coord(exoid, x[0], x[1], x[2]);
elem_id = (int *)malloc(nblk * sizeof(int));
node_per_elem = (int *)malloc(nblk * sizeof(int));
elem_per_blk = (int *)malloc(nblk * sizeof(int));
attr_per_blk = (int *)malloc(nblk * sizeof(int));
elem_type = (char **)malloc(nblk * sizeof(char *));
icon = (int **)malloc(nblk * sizeof(int *));
for (i = 0; i < nblk; i++)
elem_type[i] = (char *)malloc((name_size + 1) * sizeof(char));
ex_get_elem_blk_ids(exoid, elem_id);
for (i = 0; i < nblk; i++) {
ex_get_elem_block(exoid, elem_id[i], elem_type[i], &elem_per_blk[i], &node_per_elem[i],
&attr_per_blk[i]);
icon[i] = (int *)malloc(elem_per_blk[i] * node_per_elem[i] * sizeof(int));
ex_get_elem_conn(exoid, elem_id[i], icon[i]);
}
/*
* Read time step information
*/
ntime = ex_inquire_int(exoid, EX_INQ_TIME);
if (ntime > 0) {
time = (double *)malloc(ntime * sizeof(double));
ex_get_all_times(exoid, time);
}
/*
* Read number of nodal variables and save space
*/
nvar = 0;
ex_get_var_param(exoid, "n", &nvar);
if (nvar > 0) {
varnames = (char **)malloc(nvar * sizeof(char *));
q = (double **)malloc(nvar * sizeof(double *));
for (i = 0; i < nvar; i++) {
varnames[i] = (char *)malloc((name_size + 1) * sizeof(char));
q[i] = (double *)malloc(nnode * sizeof(double));
}
ex_get_var_names(exoid, "n", nvar, varnames);
}
/* /////////////////////////////////////////////////////////////////////
// PROMPT USER FOR INFO AND WRITE TECPLOT FILE
/////////////////////////////////////////////////////////////////////
*/
/*
* Write the TECPLOT header information
*/
assert(strlen(title) < (MAX_LINE_LENGTH + 1));
fprintf(tecfile, "TITLE = \"%s\"\n", title);
fprintf(tecfile, "VARIABLES = ");
for (i = 0; i < ndim; i++) {
fprintf(tecfile, "\"%s\"", nameco[i]);
if (i < (ndim - 1))
fprintf(tecfile, ", ");
}
if (nvar == 0)
fprintf(tecfile, "\n");
else
fprintf(tecfile, ",\n ");
idum = 0;
for (i = 0; i < nvar; i++) {
idum += strlen(varnames[i]);
assert(idum < 1022);
fprintf(tecfile, "\"%s\"", varnames[i]);
if (i < (nvar - 1)) {
if ((i + 1) % 4 == 0) {
idum = 0;
fprintf(tecfile, ",\n ");
}
else
fprintf(tecfile, ", ");
}
}
fprintf(tecfile, "\n");
/*
* Select a time step
*/
izone = 0;
if (ntime == 0) {
printf("\nNo solution variables available, saving mesh only\n\n");
izone = 1;
}
else {
printf("\nTime step information:\n\n");
for (i = 0; i < ntime; i++)
printf(" Time step %5d, time = %e\n", i + 1, time[i]);
do {
printf("\nSelect time step number to save,\n");
printf(" or 0 for zone animation of all time steps: ");
scanf("%d", &itime);
printf("\n");
} while (itime < 0 || itime > ntime);
printf("\n");
if (itime == 0)
izone = 0;
else
izone = 1;
}
/*
* Write time steps
*/
if (izone == 0) {
/*
* Collapse the zones into one
*/
/*
* Make sure we are using all the same element types
* Create one master connectivity array
*/
for (i = 1; i < nblk; i++)
if (strcmp(elem_type[0], elem_type[i]) != 0) {
printf("\nCannot create zone animation because\n");
;
printf("\n there are multiple element types.");
exit(1);
}
ic = (int *)malloc(nelem * node_per_elem[0] * sizeof(int));
k = 0;
for (j = 0; j < nblk; j++)
for (i = 0; i < node_per_elem[j] * elem_per_blk[j]; i++)
ic[k++] = icon[j][i];
assert(k == nelem * node_per_elem[0]);
if (itime == 0) {
for (j = 0; j < ntime; j++) {
for (i = 0; i < nvar; i++)
ex_get_nodal_var(exoid, j + 1, i + 1, nnode, q[i]);
i = 0;
teczone(1, nnode, j + 1, elem_type[i], node_per_elem[i], nelem, ic, ndim, x, nvar, q,
tecfile);
}
printf("\n");
}
free(ic);
}
else if (izone == 1) {
/*
|| Write out each zone individually
*/
for (i = 0; i < nvar; i++)
ex_get_nodal_var(exoid, itime, i + 1, nnode, q[i]);
for (i = 0; i < nblk; i++)
teczone(nblk, nnode, elem_id[i], elem_type[i], node_per_elem[i], elem_per_blk[i], icon[i],
ndim, x, nvar, q, tecfile);
printf("\n");
}
/* /////////////////////////////////////////////////////////////////////
// CLEAN UP
/////////////////////////////////////////////////////////////////////
*/
fclose(tecfile);
/*
* Free up allocated memory
*/
for (i = 0; i < ndim; i++) {
free(nameco[i]);
free(x[i]);
}
free(elem_id);
free(node_per_elem);
free(elem_per_blk);
free(attr_per_blk);
if (elem_type != NULL) {
for (i = 0; i < nblk; i++) {
free(elem_type[i]);
}
free(elem_type);
}
if (icon != NULL) {
for (i = 0; i < nblk; i++) {
free(icon[i]);
}
free(icon);
}
if (nvar > 0) {
if (varnames != NULL) {
for (i = 0; i < nvar; i++) {
free(varnames[i]);
}
free(varnames);
}
if (q != NULL) {
for (i = 0; i < nvar; i++) {
free(q[i]);
}
free(q);
}
}
}
fe_mesh_t* exodus_file_read_mesh(exodus_file_t* file)
{
// Create the "host" FE mesh.
fe_mesh_t* mesh = fe_mesh_new(file->comm, file->num_nodes);
// Count up the number of polyhedral blocks.
int num_poly_blocks = 0;
for (int i = 0; i < file->num_elem_blocks; ++i)
{
int elem_block = file->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(file->ex_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_POLYHEDRON)
++num_poly_blocks;
}
// If we have any polyhedral element blocks, we read a single face
// block that incorporates all of the polyhedral elements.
if (num_poly_blocks > 0)
{
// Dig up the face block corresponding to this element block.
char face_type[MAX_NAME_LENGTH+1];
int num_faces, num_nodes;
ex_get_block(file->ex_id, EX_FACE_BLOCK, file->face_block_ids[0], face_type, &num_faces,
&num_nodes, NULL, NULL, NULL);
if (string_ncasecmp(face_type, "nsided", 6) != 0)
{
fe_mesh_free(mesh);
ex_close(file->ex_id);
polymec_error("Invalid face type for polyhedral element block.");
}
// Find the number of nodes for each face in the block.
int* num_face_nodes = polymec_malloc(sizeof(int) * num_faces);
ex_get_entity_count_per_polyhedra(file->ex_id, EX_FACE_BLOCK,
file->face_block_ids[0],
num_face_nodes);
// Read face->node connectivity information.
int face_node_size = 0;
for (int i = 0; i < num_faces; ++i)
face_node_size += num_face_nodes[i];
int* face_nodes = polymec_malloc(sizeof(int) * face_node_size);
ex_get_conn(file->ex_id, EX_FACE_BLOCK, 1, face_nodes, NULL, NULL);
for (int i = 0; i < face_node_size; ++i)
face_nodes[i] -= 1;
fe_mesh_set_face_nodes(mesh, num_faces, num_face_nodes, face_nodes);
// Clean up.
polymec_free(num_face_nodes);
}
// Go over the element blocks and feel out the data.
for (int i = 0; i < file->num_elem_blocks; ++i)
{
int elem_block = file->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(file->ex_id, EX_ELEM_BLOCK, elem_block,
elem_type_name, &num_elem,
&num_nodes_per_elem, NULL,
&num_faces_per_elem, NULL);
// Get the type of element for this block.
fe_mesh_element_t elem_type = get_element_type(elem_type_name);
fe_block_t* block = NULL;
char block_name[MAX_NAME_LENGTH+1];
if (elem_type == FE_POLYHEDRON)
{
// Find the number of faces for each element in the block.
int* num_elem_faces = polymec_malloc(sizeof(int) * num_elem);
ex_get_entity_count_per_polyhedra(file->ex_id, EX_ELEM_BLOCK, elem_block,
num_elem_faces);
// Get the element->face connectivity.
int elem_face_size = 0;
for (int j = 0; j < num_elem; ++j)
elem_face_size += num_elem_faces[j];
int* elem_faces = polymec_malloc(sizeof(int) * elem_face_size);
ex_get_conn(file->ex_id, EX_ELEM_BLOCK, elem_block, NULL, NULL, elem_faces);
// Subtract 1 from each element face.
for (int j = 0; j < elem_face_size; ++j)
elem_faces[j] -= 1;
// Create the element block.
block = polyhedral_fe_block_new(num_elem, num_elem_faces, elem_faces);
}
else if (elem_type != FE_INVALID)
{
// Get the element's nodal mapping.
int* node_conn = polymec_malloc(sizeof(int) * num_elem * num_nodes_per_elem);
ex_get_conn(file->ex_id, EX_ELEM_BLOCK, elem_block, node_conn, NULL, NULL);
// Subtract 1 from each element node.
for (int j = 0; j < num_elem * num_nodes_per_elem; ++j)
node_conn[j] -= 1;
// Build the element block.
block = fe_block_new(num_elem, elem_type, num_nodes_per_elem, node_conn);
}
else
{
fe_mesh_free(mesh);
ex_close(file->ex_id);
polymec_error("Block %d contains an invalid (3D) element type.", elem_block);
}
// Fish out the element block name if it has one, or make a default.
ex_get_name(file->ex_id, EX_ELEM_BLOCK, elem_block, block_name);
if (strlen(block_name) == 0)
sprintf(block_name, "block_%d", elem_block);
// Add the element block to the mesh.
fe_mesh_add_block(mesh, block_name, block);
}
// Fetch node positions and compute geometry.
real_t x[file->num_nodes], y[file->num_nodes], z[file->num_nodes];
ex_get_coord(file->ex_id, x, y, z);
point_t* X = fe_mesh_node_positions(mesh);
for (int n = 0; n < file->num_nodes; ++n)
{
X[n].x = x[n];
X[n].y = y[n];
X[n].z = z[n];
}
// Fetch sets of entities.
for (int i = 1; i <= file->num_elem_sets; ++i)
fetch_set(file, EX_ELEM_SET, i, mesh, fe_mesh_create_element_set);
for (int i = 1; i <= file->num_face_sets; ++i)
fetch_set(file, EX_FACE_SET, i, mesh, fe_mesh_create_face_set);
for (int i = 1; i <= file->num_edge_sets; ++i)
fetch_set(file, EX_EDGE_SET, i, mesh, fe_mesh_create_edge_set);
for (int i = 1; i <= file->num_node_sets; ++i)
fetch_set(file, EX_NODE_SET, i, mesh, fe_mesh_create_node_set);
for (int i = 1; i <= file->num_side_sets; ++i)
fetch_set(file, EX_SIDE_SET, i, mesh, fe_mesh_create_side_set);
return mesh;
}
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);
}