int ex_get_concat_sets(int exoid, ex_entity_type set_type, struct ex_set_specs *set_specs)
{
int status, dimid;
void_int *num_entries_per_set = set_specs->num_entries_per_set;
void_int *num_dist_per_set = set_specs->num_dist_per_set;
void_int *sets_entry_index = set_specs->sets_entry_index;
void_int *sets_dist_index = set_specs->sets_dist_index;
void *sets_dist_fact = set_specs->sets_dist_fact;
int num_sets, i;
float * flt_dist_fact;
double * dbl_dist_fact;
char errmsg[MAX_ERR_LENGTH];
ex_inquiry ex_inq_val;
exerrval = 0; /* clear error code */
/* setup pointers based on set_type
NOTE: there is another block that sets more stuff later ... */
if (set_type == EX_NODE_SET) {
ex_inq_val = EX_INQ_NODE_SETS;
}
else if (set_type == EX_EDGE_SET) {
ex_inq_val = EX_INQ_EDGE_SETS;
}
else if (set_type == EX_FACE_SET) {
ex_inq_val = EX_INQ_FACE_SETS;
}
else if (set_type == EX_SIDE_SET) {
ex_inq_val = EX_INQ_SIDE_SETS;
}
else if (set_type == EX_ELEM_SET) {
ex_inq_val = EX_INQ_ELEM_SETS;
}
else {
exerrval = EX_FATAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: invalid set type (%d)", set_type);
ex_err("ex_get_concat_sets", errmsg, exerrval);
return (EX_FATAL);
}
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_EBADDIM) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no %ss defined for file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_get_concat_sets", errmsg, exerrval);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %ss defined in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_get_concat_sets", errmsg, exerrval);
return (EX_FATAL);
}
/* inquire how many sets have been stored */
num_sets = ex_inquire_int(exoid, ex_inq_val);
if (num_sets < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of %ss defined for file id %d",
ex_name_of_object(set_type), exoid);
/* use error val from inquire */
ex_err("ex_get_concat_sets", errmsg, exerrval);
return (EX_FATAL);
}
if (ex_get_ids(exoid, set_type, set_specs->sets_ids) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s ids for file id %d",
ex_name_of_object(set_type), exoid);
/* use error val from inquire */
ex_err("ex_get_concat_sets", errmsg, exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
((int64_t *)sets_entry_index)[0] = 0;
((int64_t *)sets_dist_index)[0] = 0;
}
else {
((int *)sets_entry_index)[0] = 0;
((int *)sets_dist_index)[0] = 0;
}
for (i = 0; i < num_sets; i++) {
int set_id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
set_id = ((int64_t *)set_specs->sets_ids)[i];
}
else {
set_id = ((int *)set_specs->sets_ids)[i];
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
if (ex_get_set_param(exoid, set_type, set_id, &(((int64_t *)num_entries_per_set)[i]),
&(((int64_t *)num_dist_per_set)[i])) != NC_NOERR) {
return (EX_FATAL); /* error will be reported by sub */
}
if (i < num_sets - 1) {
/* fill in entry and dist factor index arrays */
((int64_t *)sets_entry_index)[i + 1] =
((int64_t *)sets_entry_index)[i] + ((int64_t *)num_entries_per_set)[i];
((int64_t *)sets_dist_index)[i + 1] =
((int64_t *)sets_dist_index)[i] + ((int64_t *)num_dist_per_set)[i];
}
if (((int64_t *)num_entries_per_set)[i] == 0) { /* NULL set? */
continue;
}
{
/* Now, use ExodusII call to get sets */
int64_t *sets_entry_list = set_specs->sets_entry_list;
int64_t *sets_extra_list = set_specs->sets_extra_list;
int64_t *sets_extra = sets_extra_list
? &((int64_t *)sets_extra_list)[((int64_t *)sets_entry_index)[i]]
: NULL;
status = ex_get_set(exoid, set_type, set_id,
&(sets_entry_list[((int64_t *)sets_entry_index)[i]]), sets_extra);
}
}
else {
if (ex_get_set_param(exoid, set_type, set_id, &(((int *)num_entries_per_set)[i]),
&(((int *)num_dist_per_set)[i])) != NC_NOERR) {
return (EX_FATAL); /* error will be reported by sub */
}
if (i < num_sets - 1) {
/* fill in entry and dist factor index arrays */
((int *)sets_entry_index)[i + 1] =
((int *)sets_entry_index)[i] + ((int *)num_entries_per_set)[i];
((int *)sets_dist_index)[i + 1] =
((int *)sets_dist_index)[i] + ((int *)num_dist_per_set)[i];
}
if (((int *)num_entries_per_set)[i] == 0) { /* NULL set? */
continue;
}
{
/* Now, use ExodusII call to get sets */
int *sets_entry_list = set_specs->sets_entry_list;
int *sets_extra_list = set_specs->sets_extra_list;
int *sets_extra =
sets_extra_list ? &((int *)sets_extra_list)[((int *)sets_entry_index)[i]] : NULL;
status = ex_get_set(exoid, set_type, set_id,
&(sets_entry_list[((int *)sets_entry_index)[i]]), sets_extra);
}
}
if (status != NC_NOERR) {
return (EX_FATAL); /* error will be reported by subroutine */
}
/* get distribution factors for this set */
if (sets_dist_fact != 0) {
size_t df_idx;
size_t num_dist;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
df_idx = ((int64_t *)sets_dist_index)[i];
num_dist = ((int64_t *)num_dist_per_set)[i];
}
else {
df_idx = ((int *)sets_dist_index)[i];
num_dist = ((int *)num_dist_per_set)[i];
}
if (num_dist > 0) { /* only get df if they exist */
if (ex_comp_ws(exoid) == sizeof(float)) {
flt_dist_fact = sets_dist_fact;
status = ex_get_set_dist_fact(exoid, set_type, set_id, &(flt_dist_fact[df_idx]));
}
else {
dbl_dist_fact = sets_dist_fact;
status = ex_get_set_dist_fact(exoid, set_type, set_id, &(dbl_dist_fact[df_idx]));
}
if (status != NC_NOERR) {
return (EX_FATAL); /* error will be reported by subroutine */
}
}
}
}
return (EX_NOERR);
}
int ex_get_conn(int exoid, ex_entity_type blk_type, ex_entity_id blk_id, void_int *nodeconn,
void_int *edgeconn, void_int *faceconn)
{
int connid = -1;
int econnid = -1;
int fconnid = -1;
int blk_id_ndx, status;
int numnodperentdim = -1;
int numedgperentdim = -1;
int numfacperentdim = -1;
size_t num_nodes_per_entry = 0;
size_t num_edges_per_entry = 0;
size_t num_faces_per_entry = 0;
char errmsg[MAX_ERR_LENGTH];
const char *dnumnodent = NULL;
const char *dnumedgent = NULL;
const char *dnumfacent = NULL;
const char *vnodeconn = NULL;
const char *vedgeconn = NULL;
const char *vfaceconn = NULL;
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* Should we warn if edgeconn or faceconn are non-NULL?
* No, fail silently so the same code can be used to read any type of block
* info.
* However, we will warn if edgeconn or faceconn are NULL but
* num_edges_per_entry
* or num_faces_per_entry (respectively) are positive.
*/
/* Locate index of element block id in VAR_ID_EL_BLK array */
blk_id_ndx = ex_id_lkup(exoid, blk_type, blk_id);
if (blk_id_ndx <= 0) {
ex_get_err(NULL, NULL, &status);
if (status != 0) {
if (status == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no connectivity array for NULL %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, EX_NULLENTITY);
EX_FUNC_LEAVE(EX_WARN); /* no connectivity array for this element block */
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s id %" PRId64 " in id array in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
switch (blk_type) {
case EX_EDGE_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnumedgent = 0;
dnumfacent = 0;
vnodeconn = VAR_EBCONN(blk_id_ndx);
vedgeconn = 0;
vfaceconn = 0;
break;
case EX_FACE_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnumedgent = 0;
dnumfacent = 0;
vnodeconn = VAR_FBCONN(blk_id_ndx);
vedgeconn = 0;
vfaceconn = 0;
break;
case EX_ELEM_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnumedgent = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnumfacent = DIM_NUM_FAC_PER_EL(blk_id_ndx);
vnodeconn = VAR_CONN(blk_id_ndx);
vedgeconn = VAR_ECONN(blk_id_ndx);
vfaceconn = VAR_FCONN(blk_id_ndx);
break;
default:
snprintf(errmsg, MAX_ERR_LENGTH,
"Internal ERROR: unrecognized block type in switch: %d in file id %d", blk_type,
exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
num_nodes_per_entry = 0;
if (nodeconn && dnumnodent) {
if ((status = nc_inq_dimid(exoid, dnumnodent, &numnodperentdim)) != NC_NOERR) {
numnodperentdim = -1;
}
else {
if ((status = nc_inq_dimlen(exoid, numnodperentdim, &num_nodes_per_entry)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of nodes/entity for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
if (edgeconn && dnumedgent) {
num_edges_per_entry = 0;
if ((status = nc_inq_dimid(exoid, dnumedgent, &numedgperentdim)) != NC_NOERR) {
numedgperentdim = -1;
}
else {
if ((status = nc_inq_dimlen(exoid, numedgperentdim, &num_edges_per_entry)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of edges/entry for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
if (faceconn && dnumfacent) {
num_faces_per_entry = 0;
if ((status = nc_inq_dimid(exoid, dnumfacent, &numfacperentdim)) != NC_NOERR) {
numfacperentdim = -1;
}
else {
if ((status = nc_inq_dimlen(exoid, numfacperentdim, &num_faces_per_entry)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of faces/entry for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
status = 0;
if (nodeconn && (numnodperentdim >= 0) &&
((status = nc_inq_varid(exoid, vnodeconn, &connid)) != NC_NOERR)) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate node connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
status = 0;
if (edgeconn && (numedgperentdim >= 0) &&
((status = nc_inq_varid(exoid, vedgeconn, &econnid)) != NC_NOERR)) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate edge connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (faceconn && (numfacperentdim >= 0) &&
((status = nc_inq_varid(exoid, vfaceconn, &fconnid)) != NC_NOERR)) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate face connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* read in the connectivity array */
if (edgeconn && num_edges_per_entry > 0) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, econnid, edgeconn);
}
else {
status = nc_get_var_int(exoid, econnid, edgeconn);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get edge connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
if (faceconn && num_faces_per_entry > 0) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, fconnid, faceconn);
}
else {
status = nc_get_var_int(exoid, fconnid, faceconn);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get face connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
if (nodeconn && num_nodes_per_entry > 0) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, connid, nodeconn);
}
else {
status = nc_get_var_int(exoid, connid, nodeconn);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get node connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
EX_FUNC_LEAVE(EX_NOERR);
}
/*! \undoc */
int ex_get_concat_side_set_node_count(int exoid, int *side_set_node_cnt_list)
{
int ii, i, j, iss, ioff;
ex_entity_id side_set_id;
int num_side_sets, num_elem_blks, ndim;
int64_t tot_num_elem = 0, tot_num_ss_elem = 0, num_df = 0, side, elem;
void_int * elem_blk_ids = NULL;
void_int * side_set_ids = NULL;
void_int * ss_elem_ndx = NULL;
void_int * side_set_elem_list = NULL;
void_int * side_set_side_list = NULL;
size_t elem_ctr;
int int_size, ids_size;
int status;
struct elem_blk_parm *elem_blk_parms = NULL;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS);
if (num_side_sets < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
if (num_side_sets == 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no side sets defined in file id %d", exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, EX_WARN);
return (EX_WARN);
}
num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
if (num_elem_blks < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
tot_num_elem = ex_inquire_int(exoid, EX_INQ_ELEM);
if (tot_num_elem < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get total number of elements in file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
/* get the dimensionality of the coordinates; this is necessary to
distinguish between 2d TRIs and 3d TRIs */
ndim = ex_inquire_int(exoid, EX_INQ_DIM);
if (ndim < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get dimensionality in file id %d", exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* Allocate space for the element block ids */
ids_size = sizeof(int);
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
ids_size = sizeof(int64_t);
}
if (!(elem_blk_ids = malloc(num_elem_blks * ids_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate space for element block ids for file id %d", exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
goto error_ret;
}
if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids) != EX_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element block ids in file id %d", exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, EX_MSG);
goto error_ret;
}
/* Allocate space for the element block params */
if (!(elem_blk_parms = malloc(num_elem_blks * sizeof(struct elem_blk_parm)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block params "
"for file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
goto error_ret;
}
elem_ctr = 0;
for (i = 0; i < num_elem_blks; i++) {
ex_entity_id id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
id = ((int64_t *)elem_blk_ids)[i];
}
else {
id = ((int *)elem_blk_ids)[i];
}
if (ex_int_get_block_param(exoid, id, ndim, &elem_blk_parms[i]) != EX_NOERR) {
goto error_ret;
}
elem_ctr += elem_blk_parms[i].num_elem_in_blk;
elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */
}
/* Finally... Create the list of node counts for each face in the
* side set.
*/
/* Allocate space for the sideset ids */
if (!(side_set_ids = malloc(num_side_sets * ids_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate space for side set ids for file id %d", exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
goto error_ret;
}
if (ex_get_ids(exoid, EX_SIDE_SET, side_set_ids) != EX_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get side set ids in file id %d", exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, EX_MSG);
goto error_ret;
}
/* Lookup index of side set id in VAR_SS_IDS array */
ioff = 0;
for (iss = 0; iss < num_side_sets; iss++) {
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
side_set_id = ((int64_t *)side_set_ids)[iss];
}
else {
side_set_id = ((int *)side_set_ids)[iss];
}
/* First determine the # of elements in the side set*/
if (int_size == sizeof(int64_t)) {
status = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &tot_num_ss_elem, &num_df);
}
else {
int tot, df;
status = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &tot, &df);
tot_num_ss_elem = tot;
num_df = df;
}
if (status != EX_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of elements in side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
goto error_ret;
}
if (tot_num_ss_elem == 0) {
continue;
}
/* Allocate space for the side set element list */
if (!(side_set_elem_list = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set element "
"list for file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
goto error_ret;
}
/* Allocate space for the side set side list */
if (!(side_set_side_list = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set side list "
"for file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
goto error_ret;
}
if (ex_get_set(exoid, EX_SIDE_SET, side_set_id, side_set_elem_list, side_set_side_list) !=
EX_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
goto error_ret;
}
/* Allocate space for the ss element index array */
if (!(ss_elem_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem sort "
"array for file id %d",
exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, exerrval);
goto error_ret;
}
/* Sort side set element list into index array - non-destructive */
if (int_size == sizeof(int64_t)) {
/* Sort side set element list into index array - non-destructive */
int64_t *elems = (int64_t *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort64(side_set_elem_list, ss_elem_ndx, tot_num_ss_elem);
}
else {
/* Sort side set element list into index array - non-destructive */
int *elems = (int *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort(side_set_elem_list, ss_elem_ndx, tot_num_ss_elem);
}
j = 0; /* The current element block... */
for (ii = 0; ii < tot_num_ss_elem; ii++) {
int64_t elem_ndx;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
elem_ndx = ((int64_t *)ss_elem_ndx)[ii];
elem = ((int64_t *)side_set_elem_list)[elem_ndx];
side = ((int64_t *)side_set_side_list)[elem_ndx] - 1;
}
else {
elem_ndx = ((int *)ss_elem_ndx)[ii];
elem = ((int *)side_set_elem_list)[elem_ndx];
side = ((int *)side_set_side_list)[elem_ndx] - 1;
}
/*
* Since the elements are being accessed in sorted, order, the
* block that contains the elements must progress sequentially
* from block 0 to block[num_elem_blks-1]. Once we find an element
* not in this block, find a following block that contains it...
*/
for (; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j < num_elem_blks) {
assert(side < elem_blk_parms[j].num_sides);
side_set_node_cnt_list[elem_ndx + ioff] = elem_blk_parms[j].num_nodes_per_side[side];
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Invalid element number %" PRId64
" found in side set %" PRId64 " in file %d",
elem, side_set_id, exoid);
ex_err("ex_get_concat_side_set_node_count", errmsg, EX_MSG);
goto error_ret;
}
}
ss_elem_ndx = ex_safe_free(ss_elem_ndx);
side_set_elem_list = ex_safe_free(side_set_elem_list);
side_set_side_list = ex_safe_free(side_set_side_list);
ioff += tot_num_ss_elem;
}
/* All done: release allocated memory */
ex_safe_free(elem_blk_ids);
ex_safe_free(side_set_ids);
ex_safe_free(ss_elem_ndx);
ex_safe_free(side_set_elem_list);
ex_safe_free(side_set_side_list);
ex_safe_free(elem_blk_parms);
return (EX_NOERR);
error_ret:
ex_safe_free(elem_blk_ids);
ex_safe_free(side_set_ids);
ex_safe_free(ss_elem_ndx);
ex_safe_free(side_set_elem_list);
ex_safe_free(side_set_side_list);
ex_safe_free(elem_blk_parms);
return (EX_FATAL);
}
int ex_put_concat_sets (int exoid,
ex_entity_type set_type,
const struct ex_set_specs* set_specs)
{
int status;
int temp;
const void_int *num_entries_per_set = set_specs->num_entries_per_set;
const void_int *num_dist_per_set = set_specs->num_dist_per_set;
const void_int *sets_entry_index = set_specs->sets_entry_index;
const void_int *sets_dist_index = set_specs->sets_dist_index;
const void *sets_dist_fact = set_specs->sets_dist_fact;
size_t i, num_df, num_entry;
int cur_num_sets, num_sets;
int dimid, varid, set_id_ndx, dims[1];
int *set_stat = NULL;
int set_int_type, int_size;
const float *flt_dist_fact = NULL;
const double *dbl_dist_fact = NULL;
char errmsg[MAX_ERR_LENGTH];
char* idsptr = NULL;
char* statptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
char* elemptr = NULL;
char* extraptr = NULL;
ex_inquiry ex_inq_val;
exerrval = 0; /* clear error code */
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* setup pointers based on set_type
NOTE: there is another block that sets more stuff later ... */
if (set_type == EX_NODE_SET) {
ex_inq_val = EX_INQ_NODE_SETS;
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (set_type == EX_EDGE_SET) {
ex_inq_val = EX_INQ_EDGE_SETS;
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (set_type == EX_FACE_SET) {
ex_inq_val = EX_INQ_FACE_SETS;
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (set_type == EX_SIDE_SET) {
ex_inq_val = EX_INQ_SIDE_SETS;
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (set_type == EX_ELEM_SET) {
ex_inq_val = EX_INQ_ELEM_SETS;
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
else {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: invalid set type (%d)", set_type);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &temp)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss defined for file id %d", ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
/* inquire how many sets are to be stored */
num_sets = ex_inquire_int(exoid, ex_inq_val);
if (num_sets < 0) {
sprintf(errmsg,
"Error: failed to get number of %ss defined for file id %d",
ex_name_of_object(set_type), exoid);
/* use error val from inquire */
ex_err("ex_put_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* Fill out set status array */
/* First, allocate space for the status list */
if (!(set_stat= malloc(num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for %s status array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
if (int_size == sizeof(int64_t)) {
for (i=0;i<num_sets;i++) {
set_stat[i] = (((int64_t*)num_entries_per_set)[i] == 0) ? 0 : 1;
}
} else {
for (i=0;i<num_sets;i++) {
set_stat[i] = (((int*)num_entries_per_set)[i] == 0) ? 0 : 1;
}
}
/* Next, get variable id of status array */
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
status = nc_put_var_int(exoid, varid, set_stat);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s status array to file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_set",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* create set definitions */
for (i=0; i<num_sets; i++) {
int64_t set_id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
set_id = ((int64_t*)set_specs->sets_ids)[i];
} else {
set_id = ((int*)set_specs->sets_ids)[i];
}
/* Keep track of the total number of sets defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of sets of type
for a specific file and returns that value.
*/
cur_num_sets=ex_get_file_item(exoid, ex_get_counter_list(set_type));
if (cur_num_sets >= num_sets) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(set_type), num_sets,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
goto error_ret;
}
/* NOTE: ex_inc_file_item is used to find the number of sets
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(set_type));
set_id_ndx = cur_num_sets + 1;
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
elemptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
elemptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
elemptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
elemptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
elemptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* define dimension for number of entries per set */
if (set_stat[i] == 0) /* Is this a NULL set? */
continue; /* Do not create anything for NULL sets! */
if (int_size == sizeof(int)) {
status = nc_def_dim(exoid, ex_dim_num_entries_in_object(set_type, set_id_ndx),
((int*)num_entries_per_set)[i], &dimid);
} else {
status = nc_def_dim(exoid, ex_dim_num_entries_in_object(set_type, set_id_ndx),
((int64_t*)num_entries_per_set)[i], &dimid);
}
if (status != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: %s entry count %"PRId64" already defined in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of entries for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret;
}
/* create element list variable for set */
set_int_type = NC_INT;
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
set_int_type = NC_INT64;
}
dims[0] = dimid;
if ((status = nc_def_var(exoid,elemptr,set_int_type,1,dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: element list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create element list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 1);
/* create extra list variable for set (only for edge, face and side sets) */
if (extraptr) {
if ((status = nc_def_var(exoid,extraptr,set_int_type,1,dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: extra list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create extra list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 1);
}
/* define dimension for number of dist factors per set */
/* NOTE: only define df count if the dist factors exist! */
if (int_size == sizeof(int64_t)) {
num_df = ((int64_t*)num_dist_per_set)[i];
num_entry = ((int64_t*)num_entries_per_set)[i];
} else {
num_df = ((int*)num_dist_per_set)[i];
num_entry = ((int*)num_entries_per_set)[i];
}
if (num_df > 0) {
if (set_type == EX_NODE_SET) {
if (num_df != num_entry) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%"ST_ZU") not equal to # nodes (%"ST_ZU") in node set %"PRId64" file id %d",
num_df, num_entry, set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* resuse dimid from entry lists */
} else {
if ((status = nc_def_dim(exoid, numdfptr,
num_df, &dimid)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: %s df count %"PRId64" already defined in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s df count for set %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret;
}
}
/* create distribution factor list variable for set */
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: dist factor list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create dist factor list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 2);
} /* end define dist factors */
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* Next, fill out set ids array */
/* first get id of set ids array variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* then, write out set id list */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, varid, set_specs->sets_ids);
} else {
status = nc_put_var_int(exoid, varid, set_specs->sets_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* If the sets_entry_index is passed in as a NULL pointer, then
* the user only wants us to define the sets and not populate
* the data structures.
*/
if (sets_entry_index == 0) {
ex_safe_free(set_stat);
return(EX_NOERR);
}
/* Now, use ExodusII call to store sets */
for (i=0; i<num_sets; i++) {
int64_t set_id;
size_t df_ndx;
if (set_stat[i] == 0) /* Is this a NULL set? */
continue; /* Do not create anything for NULL sets! */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
set_id = ((int64_t*)set_specs->sets_ids)[i];
} else {
set_id = ((int*)set_specs->sets_ids)[i];
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int64_t* extra_list = NULL;
/* set extra list */
if (set_type == EX_EDGE_SET || set_type == EX_FACE_SET || set_type == EX_SIDE_SET)
extra_list = &(((int64_t*)set_specs->sets_extra_list)[((int64_t*)sets_entry_index)[i]]);
status = ex_put_set(exoid, set_type, set_id,
&(((int64_t*)set_specs->sets_entry_list)[((int64_t*)sets_entry_index)[i]]),
extra_list);
} else {
int* extra_list = NULL;
/* set extra list */
if (set_type == EX_EDGE_SET || set_type == EX_FACE_SET || set_type == EX_SIDE_SET)
extra_list = &(((int*)set_specs->sets_extra_list)[((int*)sets_entry_index)[i]]);
status = ex_put_set(exoid, set_type, set_id,
&(((int*)set_specs->sets_entry_list)[((int*)sets_entry_index)[i]]),
extra_list);
}
if (status != NC_NOERR) {
ex_safe_free(set_stat);
return(EX_FATAL); /* error will be reported by subroutine */
}
if (int_size == sizeof(int)) {
num_df = ((int*)num_dist_per_set)[i];
df_ndx = ((int*)sets_dist_index)[i];
} else {
num_df = ((int64_t*)num_dist_per_set)[i];
df_ndx = ((int64_t*)sets_dist_index)[i];
}
if (ex_comp_ws(exoid) == sizeof(float)) {
flt_dist_fact = sets_dist_fact;
if (num_df > 0) { /* store dist factors if required */
if (ex_put_set_dist_fact(exoid, set_type, set_id,
&(flt_dist_fact[df_ndx])) == -1) {
sprintf(errmsg,
"Error: failed to store %s %"PRId64" dist factors for file id %d",
ex_name_of_object(set_type), set_id,exoid);
/* use error val from exodusII routine */
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
} else if (ex_comp_ws(exoid) == sizeof(double)) {
dbl_dist_fact = sets_dist_fact;
if (num_df) { /* only store if they exist */
if (ex_put_set_dist_fact(exoid, set_type, set_id,
&(dbl_dist_fact[df_ndx])) == -1) {
sprintf(errmsg,
"Error: failed to store %s %"PRId64" dist factors for file id %d",
ex_name_of_object(set_type), set_id,exoid);
/* use error val from exodusII routine */
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
} else {
/* unknown floating point word size */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: unsupported floating point word size %d for file id %d",
ex_comp_ws(exoid), exoid);
ex_err("ex_put_concat_sets", errmsg, exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
ex_safe_free(set_stat);
return(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
ex_safe_free(set_stat);
if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_prop(int exoid, ex_entity_type obj_type, ex_entity_id obj_id, const char *prop_name,
ex_entity_id value)
{
int status;
int oldfill = 0;
int temp;
int found = EX_FALSE;
int num_props, i, dimid, propid, dims[1];
int int_type;
size_t start[1];
size_t prop_name_len, name_length;
char * name;
char tmpstr[MAX_STR_LENGTH + 1];
char * dim_name;
long long vals[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* check if property has already been created */
num_props = ex_get_num_props(exoid, obj_type);
if (num_props > 1) { /* any properties other than the default 1? */
for (i = 1; i <= num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK: name = VAR_EB_PROP(i); break;
case EX_EDGE_BLOCK: name = VAR_ED_PROP(i); break;
case EX_FACE_BLOCK: name = VAR_FA_PROP(i); break;
case EX_NODE_SET: name = VAR_NS_PROP(i); break;
case EX_EDGE_SET: name = VAR_ES_PROP(i); break;
case EX_FACE_SET: name = VAR_FS_PROP(i); break;
case EX_ELEM_SET: name = VAR_ELS_PROP(i); break;
case EX_SIDE_SET: name = VAR_SS_PROP(i); break;
case EX_ELEM_MAP: name = VAR_EM_PROP(i); break;
case EX_FACE_MAP: name = VAR_FAM_PROP(i); break;
case EX_EDGE_MAP: name = VAR_EDM_PROP(i); break;
case EX_NODE_MAP: name = VAR_NM_PROP(i); break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property array id in file id %d",
exoid);
ex_err("ex_put_prop", errmsg, exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH + 1);
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property name in file id %d", exoid);
ex_err("ex_put_prop", errmsg, exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0) {
found = EX_TRUE;
break;
}
}
}
/* if property array has not been created, create it */
if (!found) {
name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH) + 1;
/* put netcdf file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to place file id %d into define mode", exoid);
ex_err("ex_put_prop", errmsg, exerrval);
return (EX_FATAL);
}
/* create a variable with a name xx_prop#, where # is the new number */
/* of the property */
switch (obj_type) {
case EX_ELEM_BLOCK:
name = VAR_EB_PROP(num_props + 1);
dim_name = DIM_NUM_EL_BLK;
break;
case EX_FACE_BLOCK:
name = VAR_FA_PROP(num_props + 1);
dim_name = DIM_NUM_FA_BLK;
break;
case EX_EDGE_BLOCK:
name = VAR_ED_PROP(num_props + 1);
dim_name = DIM_NUM_ED_BLK;
break;
case EX_NODE_SET:
name = VAR_NS_PROP(num_props + 1);
dim_name = DIM_NUM_NS;
break;
case EX_EDGE_SET:
name = VAR_ES_PROP(num_props + 1);
dim_name = DIM_NUM_ES;
break;
case EX_FACE_SET:
name = VAR_FS_PROP(num_props + 1);
dim_name = DIM_NUM_FS;
break;
case EX_ELEM_SET:
name = VAR_ELS_PROP(num_props + 1);
dim_name = DIM_NUM_ELS;
break;
case EX_SIDE_SET:
name = VAR_SS_PROP(num_props + 1);
dim_name = DIM_NUM_SS;
break;
case EX_ELEM_MAP:
name = VAR_EM_PROP(num_props + 1);
dim_name = DIM_NUM_EM;
break;
case EX_FACE_MAP:
name = VAR_FAM_PROP(num_props + 1);
dim_name = DIM_NUM_FAM;
break;
case EX_EDGE_MAP:
name = VAR_EDM_PROP(num_props + 1);
dim_name = DIM_NUM_EDM;
break;
case EX_NODE_MAP:
name = VAR_NM_PROP(num_props + 1);
dim_name = DIM_NUM_NM;
break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err("ex_put_prop", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
/* inquire id of previously defined dimension (number of objects) */
if ((status = nc_inq_dimid(exoid, dim_name, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate number of objects in file id %d",
exoid);
ex_err("ex_put_prop", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
dims[0] = dimid;
nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */
int_type = NC_INT;
if (ex_int64_status(exoid) & EX_IDS_INT64_DB) {
int_type = NC_INT64;
}
if ((status = nc_def_var(exoid, name, int_type, 1, dims, &propid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create property array variable in file id %d", exoid);
ex_err("ex_put_prop", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
vals[0] = 0; /* fill value */
/* create attribute to cause variable to fill with zeros per routine spec
*/
if ((status = nc_put_att_longlong(exoid, propid, _FillValue, int_type, 1, vals)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create property name fill attribute in file id %d", exoid);
ex_err("ex_put_prop", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
/* Check that the property name length is less than MAX_NAME_LENGTH */
prop_name_len = strlen(prop_name) + 1;
if (prop_name_len > name_length) {
fprintf(stderr, "Warning: The property name '%s' is too long.\n\tIt will "
"be truncated from %d to %d characters\n",
prop_name, (int)prop_name_len - 1, (int)name_length - 1);
prop_name_len = name_length;
}
/* store property name as attribute of property array variable */
if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME, prop_name_len,
(void *)prop_name)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property name %s in file id %d",
prop_name, exoid);
ex_err("ex_put_prop", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
ex_update_max_name_length(exoid, prop_name_len - 1);
/* leave define mode */
if ((status = nc_enddef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to leave define mode in file id %d", exoid);
ex_err("ex_put_prop", errmsg, exerrval);
return (EX_FATAL);
}
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
}
/* find index into property array using obj_id; put value in property */
/* array at proper index; ex_id_lkup returns an index that is 1-based,*/
/* but netcdf expects 0-based arrays so subtract 1 */
/* special case: property name ID - check for duplicate ID assignment */
if (strcmp("ID", prop_name) == 0) {
start[0] = ex_id_lkup(exoid, obj_type, value);
if (exerrval != EX_LOOKUPFAIL) /* found the id */
{
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: attempt to assign duplicate %s ID %" PRId64 " in file id %d",
ex_name_of_object(obj_type), value, exoid);
ex_err("ex_put_prop", errmsg, exerrval);
return (EX_WARN);
}
}
start[0] = ex_id_lkup(exoid, obj_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no properties allowed for NULL %s id %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_put_prop", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find value %" PRId64 " in %s property array in file id %d", obj_id,
ex_name_of_object(obj_type), exoid);
ex_err("ex_put_prop", errmsg, exerrval);
return (EX_FATAL);
}
start[0] = start[0] - 1;
/* value is of type 'ex_entity_id' which is a typedef to int64_t or long long
*/
status = nc_put_var1_longlong(exoid, propid, start, (long long *)&value);
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property value in file id %d", exoid);
ex_err("ex_put_prop", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
if (nc_enddef(exoid) != NC_NOERR) { /* exit define mode */
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid);
ex_err("ex_put_prop", errmsg, exerrval);
}
return (EX_FATAL);
}
int ex_get_partial_conn( int exoid,
ex_entity_type blk_type,
ex_entity_id blk_id,
int64_t start_num,
int64_t num_ent,
void_int* nodeconn,
void_int* edgeconn,
void_int* faceconn )
{
int connid = -1;
int econnid = -1;
int fconnid = -1;
int blk_id_ndx;
int status = 0;
int numnodperentdim = -1;
int numedgperentdim = -1;
int numfacperentdim = -1;
int iexit = (EX_NOERR); /* exit status */
size_t num_nodes_per_entry = 0;
size_t num_edges_per_entry = 0;
size_t num_faces_per_entry = 0;
char errmsg[MAX_ERR_LENGTH];
const char* dnumnodent = NULL;
const char* dnumedgent = NULL;
const char* dnumfacent = NULL;
const char* vnodeconn = NULL;
const char* vedgeconn = NULL;
const char* vfaceconn = NULL;
/* The partial connectivity input function can currently only handle nodal
* connectivity. Print a warning if edgeconn or faceconn is non-NULL
*/
if (edgeconn != NULL || faceconn != NULL) {
exerrval = 1005;
sprintf(errmsg,
"Warning: ex_get_partial_conn only supports nodal connectivity at this time. %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg,EX_MSG);
}
exerrval = 0; /* clear error code */
/* Locate index of element block id in VAR_ID_EL_BLK array */
blk_id_ndx = ex_id_lkup(exoid,blk_type,blk_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no connectivity array for NULL %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg,EX_NULLENTITY);
return (EX_WARN); /* no connectivity array for this element block */
}
else
{
sprintf(errmsg,
"Error: failed to locate %s id %"PRId64" in id array in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg,exerrval);
return (EX_FATAL);
}
}
switch (blk_type) {
case EX_EDGE_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnumedgent = 0;
dnumfacent = 0;
vnodeconn = VAR_EBCONN(blk_id_ndx);
vedgeconn = 0;
vfaceconn = 0;
break;
case EX_FACE_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnumedgent = 0;
dnumfacent = 0;
vnodeconn = VAR_FBCONN(blk_id_ndx);
vedgeconn = 0;
vfaceconn = 0;
break;
case EX_ELEM_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnumedgent = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnumfacent = DIM_NUM_FAC_PER_EL(blk_id_ndx);
vnodeconn = VAR_CONN(blk_id_ndx);
vedgeconn = VAR_ECONN(blk_id_ndx);
vfaceconn = VAR_FCONN(blk_id_ndx);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized block type in switch: %d in file id %d",
blk_type,exoid);
ex_err("ex_get_partial_conn",errmsg,EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
if ((status = nc_inq_dimid (exoid, dnumnodent, &numnodperentdim)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg,exerrval);
return(EX_FATAL);
}
if (nc_inq_dimlen(exoid, numnodperentdim, &num_nodes_per_entry) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
if ( edgeconn && dnumedgent ) {
num_edges_per_entry = 0;
if ((status = nc_inq_dimid(exoid, dnumedgent, &numedgperentdim)) != NC_NOERR) {
numedgperentdim = -1;
} else {
if ((status = nc_inq_dimlen(exoid, numedgperentdim, &num_edges_per_entry)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of edges/entry for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
}
if ( faceconn && dnumfacent ) {
num_faces_per_entry = 0;
if ((status = nc_inq_dimid(exoid, dnumfacent, &numfacperentdim)) != NC_NOERR) {
numfacperentdim = -1;
} else {
if ((status = nc_inq_dimlen(exoid, numfacperentdim, &num_faces_per_entry)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of faces/entry for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
}
if ((status = nc_inq_varid(exoid, vnodeconn, &connid)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
status = 0;
if (edgeconn && (numedgperentdim > 0) &&
((status = nc_inq_varid (exoid, vedgeconn, &econnid)) != NC_NOERR))
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate edge connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
if (faceconn && (numfacperentdim > 0) &&
((status = nc_inq_varid (exoid, vfaceconn, &fconnid)) != NC_NOERR))
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate face connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
/* read in the connectivity array */
if ( edgeconn && num_edges_per_entry > 0) {
size_t start[2], count[2];
start[0] = (start_num-1);
start[1] = 0;
count[0] = num_ent;
count[1] = num_edges_per_entry;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_vara_longlong(exoid, econnid, start, count, edgeconn);
} else {
status = nc_get_vara_int(exoid, econnid, start, count, edgeconn);
}
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get edge connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
if ( faceconn && num_faces_per_entry > 0) {
size_t start[2], count[2];
start[0] = start_num-1;
start[1] = 0;
count[0] = num_ent;
count[1] = num_faces_per_entry;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_vara_longlong(exoid, fconnid, start, count, faceconn);
} else {
status = nc_get_vara_int(exoid, fconnid, start, count, faceconn);
}
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get face connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
if ( nodeconn && num_nodes_per_entry > 0) {
size_t start[2], count[2];
start[0] = start_num-1;
start[1] = 0;
count[0] = num_ent;
count[1] = num_nodes_per_entry;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_vara_longlong(exoid, connid, start, count, nodeconn);
} else {
status = nc_get_vara_int(exoid, connid, start, count, nodeconn);
}
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_partial_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
return iexit;
}
int ex_get_block(int exoid, ex_entity_type blk_type, ex_entity_id blk_id, char *elem_type,
void_int *num_entries_this_blk, void_int *num_nodes_per_entry,
void_int *num_edges_per_entry, void_int *num_faces_per_entry,
void_int *num_attr_per_entry)
{
int err;
ex_block block;
EX_FUNC_ENTER();
block.id = blk_id;
block.type = blk_type;
err = ex_get_block_param(exoid, &block);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int64_t *n_entries_this_blk = num_entries_this_blk;
int64_t *n_nodes_per_entry = num_nodes_per_entry;
int64_t *n_edges_per_entry = num_edges_per_entry;
int64_t *n_faces_per_entry = num_faces_per_entry;
int64_t *n_attr_per_entry = num_attr_per_entry;
if (n_entries_this_blk) {
*n_entries_this_blk = block.num_entry;
}
if (n_nodes_per_entry) {
*n_nodes_per_entry = block.num_nodes_per_entry;
}
if (n_edges_per_entry) {
*n_edges_per_entry = block.num_edges_per_entry;
}
if (n_faces_per_entry) {
*n_faces_per_entry = block.num_faces_per_entry;
}
if (n_attr_per_entry) {
*n_attr_per_entry = block.num_attribute;
}
}
else {
int *n_entries_this_blk = num_entries_this_blk;
int *n_nodes_per_entry = num_nodes_per_entry;
int *n_edges_per_entry = num_edges_per_entry;
int *n_faces_per_entry = num_faces_per_entry;
int *n_attr_per_entry = num_attr_per_entry;
if (n_entries_this_blk) {
*n_entries_this_blk = block.num_entry;
}
if (n_nodes_per_entry) {
*n_nodes_per_entry = block.num_nodes_per_entry;
}
if (n_edges_per_entry) {
*n_edges_per_entry = block.num_edges_per_entry;
}
if (n_faces_per_entry) {
*n_faces_per_entry = block.num_faces_per_entry;
}
if (n_attr_per_entry) {
*n_attr_per_entry = block.num_attribute;
}
}
if (elem_type) {
strcpy(elem_type, block.topology);
}
EX_FUNC_LEAVE(err);
}
int ex_put_block_params( int exoid,
size_t block_count,
const struct ex_block *blocks)
{
size_t i;
int conn_int_type;
int status;
int arbitrary_polyhedra = 0; /* 1 if block is arbitrary 2d polyhedra type; 2 if 3d polyhedra */
int att_name_varid = -1;
int varid, dimid, dims[2], blk_id_ndx, blk_stat, strdim;
size_t start[2];
size_t num_blk;
int cur_num_blk, numblkdim, numattrdim;
int nnodperentdim = -1;
int nedgperentdim = -1;
int nfacperentdim = -1;
int connid;
int npeid;
char errmsg[MAX_ERR_LENGTH];
char entity_type1[5];
char entity_type2[5];
int* blocks_to_define = NULL;
const char* dnumblk = NULL;
const char* vblkids = NULL;
const char* vblksta = NULL;
const char* vnodcon = NULL;
const char* vnpecnt = NULL;
const char* vedgcon = NULL;
const char* vfaccon = NULL;
const char* vconn = NULL;
const char* vattnam = NULL;
const char* vblkatt = NULL;
const char* dneblk = NULL;
const char* dnape = NULL;
const char* dnnpe = NULL;
const char* dnepe = NULL;
const char* dnfpe = NULL;
exerrval = 0; /* clear error code */
blocks_to_define = malloc(block_count*sizeof(int));
for (i=0; i < block_count; i++) {
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
dnumblk = DIM_NUM_ED_BLK;
vblkids = VAR_ID_ED_BLK;
vblksta = VAR_STAT_ED_BLK;
break;
case EX_FACE_BLOCK:
dnumblk = DIM_NUM_FA_BLK;
vblkids = VAR_ID_FA_BLK;
vblksta = VAR_STAT_FA_BLK;
break;
case EX_ELEM_BLOCK:
dnumblk = DIM_NUM_EL_BLK;
vblkids = VAR_ID_EL_BLK;
vblksta = VAR_STAT_EL_BLK;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) specified for entry %d file id %d",
blocks[i].type, (int)i, exoid );
ex_err( "ex_put_block_params", errmsg, exerrval );
free(blocks_to_define);
return (EX_FATAL);
}
/* first check if any blocks of that type are specified */
if ((status = ex_get_dimension(exoid, dnumblk, ex_name_of_object(blocks[i].type),
&num_blk, &dimid, "ex_put_block_params")) != NC_NOERR) {
sprintf(errmsg,
"Error: No %ss defined in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return EX_FATAL;
}
/* Next: Make sure that there are not any duplicate block ids by
searching the vblkids array.
WARNING: This must be done outside of define mode because id_lkup accesses
the database to determine the position
*/
if ((status = nc_inq_varid(exoid, vblkids, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return EX_FATAL;
}
ex_id_lkup(exoid,blocks[i].type,blocks[i].id); /* Error value used, but don't need return value */
if (exerrval != EX_LOOKUPFAIL) { /* found the element block id */
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: %s id %"PRId64" already exists in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
/* Keep track of the total number of element blocks defined using a counter
stored in a linked list keyed by exoid.
NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value.
*/
cur_num_blk=ex_get_file_item(exoid, ex_get_counter_list(blocks[i].type));
if (cur_num_blk >= (int)num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(blocks[i].type), (int)num_blk,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented. */
cur_num_blk=ex_inc_file_item(exoid, ex_get_counter_list(blocks[i].type));
start[0] = cur_num_blk;
/* write out block id to previously defined id array variable*/
status = nc_put_var1_longlong(exoid, varid, start, (long long*)&blocks[i].id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id to file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
blocks_to_define[i] = start[0]+1; /* element id index into vblkids array*/
if (blocks[i].num_entry == 0) /* Is this a NULL element block? */
blk_stat = 0; /* change element block status to NULL */
else
blk_stat = 1; /* change element block status to EX_EX_TRUE */
if ((status = nc_inq_varid (exoid, vblksta, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &blk_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" status to file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
}
/* put netcdf file into define mode */
if ((status=nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
for (i=0; i < block_count; i++) {
if (blocks[i].num_entry == 0) {/* Is this a NULL element block? */
continue;
}
blk_id_ndx = blocks_to_define[i];
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
dneblk = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_EBLK(blk_id_ndx);
vblkatt = VAR_EATTRIB(blk_id_ndx);
vattnam = VAR_NAME_EATTRIB(blk_id_ndx);
vnodcon = VAR_EBCONN(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_FACE_BLOCK:
dneblk = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_FBLK(blk_id_ndx);
vblkatt = VAR_FATTRIB(blk_id_ndx);
vattnam = VAR_NAME_FATTRIB(blk_id_ndx);
vnodcon = VAR_FBCONN(blk_id_ndx);
vnpecnt = VAR_FBEPEC(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_ELEM_BLOCK:
dneblk = DIM_NUM_EL_IN_BLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnepe = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnfpe = DIM_NUM_FAC_PER_EL(blk_id_ndx);
dnape = DIM_NUM_ATT_IN_BLK(blk_id_ndx);
vblkatt = VAR_ATTRIB(blk_id_ndx);
vattnam = VAR_NAME_ATTRIB(blk_id_ndx);
vnodcon = VAR_CONN(blk_id_ndx);
vnpecnt = VAR_EBEPEC(blk_id_ndx);
vedgcon = VAR_ECONN(blk_id_ndx);
vfaccon = VAR_FCONN(blk_id_ndx);
break;
default:
goto error_ret;
}
/* define some dimensions and variables*/
if ((status = nc_def_dim(exoid,dneblk,blocks[i].num_entry, &numblkdim )) != NC_NOERR) {
if (status == NC_ENAMEINUSE) { /* duplicate entry */
exerrval = status;
sprintf(errmsg,
"Error: %s %"PRId64" already defined in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of entities/block for %s %"PRId64" file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if ( dnnpe && blocks[i].num_nodes_per_entry > 0) {
/* A nfaced block would not have any nodes defined... */
if ((status = nc_def_dim(exoid,dnnpe,blocks[i].num_nodes_per_entry, &nnodperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of nodes/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (dnepe && blocks[i].num_edges_per_entry > 0 ) {
if ((status = nc_def_dim (exoid,dnepe,blocks[i].num_edges_per_entry, &nedgperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of edges/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( dnfpe && blocks[i].num_faces_per_entry > 0 ) {
if ((status = nc_def_dim(exoid,dnfpe,blocks[i].num_faces_per_entry, &nfacperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of faces/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* element attribute array */
if (blocks[i].num_attribute > 0) {
if ((status = nc_def_dim(exoid, dnape, blocks[i].num_attribute, &numattrdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of attributes in %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dims[0] = numblkdim;
dims[1] = numattrdim;
if ((status = nc_def_var(exoid, vblkatt, nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define attributes for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &strdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret;
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if ((status = nc_def_var(exoid, vattnam, NC_CHAR, 2, dims, &att_name_varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s attribute name array in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
conn_int_type = NC_INT;
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
conn_int_type = NC_INT64;
}
/* See if storing an 'nsided' element block (arbitrary 2d polyhedra or super element) */
if (strlen(blocks[i].topology) >= 3) {
if ((blocks[i].topology[0] == 'n' || blocks[i].topology[0] == 'N') &&
(blocks[i].topology[1] == 's' || blocks[i].topology[1] == 'S') &&
(blocks[i].topology[2] == 'i' || blocks[i].topology[2] == 'I'))
arbitrary_polyhedra = 1;
else if ((blocks[i].topology[0] == 'n' || blocks[i].topology[0] == 'N') &&
(blocks[i].topology[1] == 'f' || blocks[i].topology[1] == 'F') &&
(blocks[i].topology[2] == 'a' || blocks[i].topology[2] == 'A'))
/* If a FACE_BLOCK, then we are dealing with the faces of the nfaced blocks[i]. */
arbitrary_polyhedra = blocks[i].type == EX_FACE_BLOCK ? 1 : 2;
}
/* element connectivity array */
if (arbitrary_polyhedra > 0) {
if (blocks[i].type != EX_FACE_BLOCK && blocks[i].type != EX_ELEM_BLOCK) {
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) for nsided/nfaced block in file id %d",
blocks[i].type, exoid );
ex_err( "ex_put_block_params", errmsg, exerrval );
goto error_ret;
}
if (arbitrary_polyhedra == 1) {
dims[0] = nnodperentdim;
vconn = vnodcon;
/* store entity types as attribute of npeid variable -- node/elem, node/face, face/elem*/
strcpy(entity_type1, "NODE");
if (blocks[i].type == EX_ELEM_BLOCK)
strcpy(entity_type2, "ELEM");
else
strcpy(entity_type2, "FACE");
} else if (arbitrary_polyhedra == 2) {
dims[0] = nfacperentdim;
vconn = vfaccon;
/* store entity types as attribute of npeid variable -- node/elem, node/face, face/elem*/
strcpy(entity_type1, "FACE");
strcpy(entity_type2, "ELEM");
}
if ((status = nc_def_var(exoid, vconn, conn_int_type, 1, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element face-per-element or node-per-element count array */
dims[0] = numblkdim;
if ((status = nc_def_var(exoid, vnpecnt, conn_int_type, 1, dims, &npeid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create face- or node- per-entity count array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_put_att_text(exoid, npeid, "entity_type1", strlen(entity_type1)+1,
entity_type1)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store entity type attribute text for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_put_att_text(exoid, npeid, "entity_type2", strlen(entity_type2)+1,
entity_type2)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store entity type attribute text for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* "Normal" (non-polyhedra) element block type */
dims[0] = numblkdim;
dims[1] = nnodperentdim;
if ((status = nc_def_var(exoid, vnodcon, conn_int_type, 2, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, connid, 1);
}
/* store element type as attribute of connectivity variable */
if ((status = nc_put_att_text(exoid, connid, ATT_NAME_ELB, strlen(blocks[i].topology)+1,
blocks[i].topology)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s type name %s in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].topology,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if (arbitrary_polyhedra == 0) {
if (vedgcon && blocks[i].num_edges_per_entry ) {
dims[0] = numblkdim;
dims[1] = nedgperentdim;
if ((status = nc_def_var(exoid, vedgcon, conn_int_type, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create edge connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( vfaccon && blocks[i].num_faces_per_entry ) {
dims[0] = numblkdim;
dims[1] = nfacperentdim;
if ((status = nc_def_var(exoid, vfaccon, conn_int_type, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create face connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
}
free(blocks_to_define);
/* leave define mode */
if ((exerrval=nc_enddef (exoid)) != NC_NOERR) {
sprintf(errmsg,
"Error: failed to complete %s definition in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i < block_count; i++) {
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
vblkids = VAR_ID_ED_BLK;
break;
case EX_FACE_BLOCK:
vblkids = VAR_ID_FA_BLK;
break;
case EX_ELEM_BLOCK:
vblkids = VAR_ID_EL_BLK;
break;
default:
return (EX_FATAL); /* should have been handled earlier; quiet compiler here */
}
nc_inq_varid(exoid, vblkids, &att_name_varid);
if (blocks[i].num_attribute > 0 && att_name_varid >= 0) {
/* Output a dummy empty attribute name in case client code doesn't
write anything; avoids corruption in some cases.
*/
size_t count[2];
char *text = "";
size_t j;
count[0] = 1;
start[1] = 0;
count[1] = strlen(text)+1;
for (j = 0; j < blocks[i].num_attribute; j++) {
start[0] = j;
nc_put_vara_text(exoid, att_name_varid, start, count, text);
}
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
free(blocks_to_define);
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_elem_cmap(int exoid,
ex_entity_id map_id,
void_int *elem_ids,
void_int *side_ids,
void_int *proc_ids,
int processor
)
{
const char *func_name="ex_put_elem_cmap";
int map_idx, varid, dimid, status;
size_t start[1], count[1], ret_val;
int64_t varidx[2];
int value;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/* get the index for the comm map information variables */
if (ex_get_idx(exoid, VAR_E_COMM_INFO_IDX, varidx, processor) == -1) {
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_E_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the index for this map_id */
if ((map_idx=ne_id_lkup(exoid, VAR_E_COMM_IDS, varidx, map_id)) == -1) {
sprintf(errmsg,
"Error: failed to find index for variable \"%s\" in file ID %d",
VAR_E_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/*
* Find out if this is a NULL comm map by checking it's entry in
* the status vector.
*/
if ((status = nc_inq_varid(exoid, VAR_E_COMM_STAT, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
start[0] = map_idx;
if ((status = nc_get_var1_int(exoid, varid, start, &value)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_E_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (value == 0) return(EX_NOERR); /* NULL set */
/* now I need to get the comm map data index */
if (ex_get_idx(exoid, VAR_E_COMM_DATA_IDX, varidx, map_idx) == -1) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_E_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* check if I need to get the dimension of the cmap data */
if (varidx[1] == -1) {
/* Get the size of the comm maps */
if ((status = nc_inq_dimid(exoid, DIM_ECNT_CMAP, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get dimension ID for \"%s\" in file ID %d",
DIM_ECNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &ret_val)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get length of dimension \"%s\" in file ID %d",
DIM_ECNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
varidx[1] = ret_val;
} /* "if (varidx[1]==-1)" */
start[0] = varidx[0];
count[0] = varidx[1] - varidx[0];
/* Output the element IDs for this comm map */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_EIDS, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_EIDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, elem_ids);
} else {
status = nc_put_vara_int(exoid, varid, start, count, elem_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output vector \"%s\" in file ID %d",
VAR_E_COMM_EIDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the processor IDs for this map */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_PROC, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_PROC, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, proc_ids);
} else {
status = nc_put_vara_int(exoid, varid, start, count, proc_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable \"%s\" in file ID %d",
VAR_E_COMM_PROC, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, VAR_E_COMM_SIDS, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_SIDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, side_ids);
} else {
status = nc_put_vara_int(exoid, varid, start, count, side_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to ouput variable \"%s\" in file ID %d",
VAR_E_COMM_SIDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_partial_node_num_map (int exoid,
int64_t start_ent,
int64_t num_ents,
void_int *node_map)
{
int numnodedim, mapid, status;
size_t i;
size_t num_nodes, start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_dimid (exoid, DIM_NUM_NODES, &numnodedim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in file id %d",
exoid);
ex_err("ex_get_partial_node_num_map",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, numnodedim, &num_nodes)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in file id %d",
exoid);
ex_err("ex_get_partial_node_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (start_ent < 0 || start_ent > num_nodes) {
fprintf(stderr, "ERROR: Invalid input to function"
" ex_get_partial_node_num_map!\n");
return (EX_FATAL);
}
if (num_ents < 0) {
fprintf(stderr, "ERROR: Invalid number of entries in map!\n");
return (EX_FATAL);
}
/* start_ent now starts at 1, not 0 */
if ((start_ent + num_ents - 1) > num_nodes) {
fprintf(stderr, "ERROR: request range invalid!\n");
return (EX_FATAL);
}
if ((status = nc_inq_varid (exoid, VAR_NODE_NUM_MAP, &mapid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: node numbering map not stored in file id %d; returning default map",
exoid);
ex_err("ex_get_partial_node_num_map",errmsg,exerrval);
/* generate default map of 1..n, where n is num_nodes */
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
int64_t *lmap = (int64_t*)node_map;
for (i=0; i<num_ents; i++) {
lmap[i] = start_ent+i;
}
} else {
int *lmap = (int*)node_map;
for (i=0; i<num_ents; i++) {
lmap[i] = start_ent+i;
}
}
return (EX_WARN);
}
/* read in the node numbering map */
start[0] = --start_ent;
count[0] = num_ents;
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_get_vara_longlong(exoid, mapid, start, count, node_map);
} else {
status = nc_get_vara_int(exoid, mapid, start, count, node_map);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get node numbering map in file id %d",
exoid);
ex_err("ex_get_partial_node_num_map",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
int ex_put_sets (int exoid,
size_t set_count,
const struct ex_set *sets)
{
size_t i;
int needs_define = 0;
int set_stat;
int dimid, varid, status, dims[1];
int set_id_ndx;
size_t start[1];
int cur_num_sets;
char errmsg[MAX_ERR_LENGTH];
int* sets_to_define = NULL;
char* numentryptr = NULL;
char* entryptr = NULL;
char* extraptr = NULL;
char* idsptr = NULL;
char* statptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
size_t int_size;
exerrval = 0; /* clear error code */
sets_to_define = malloc(set_count*sizeof(int));
/* Note that this routine can be called:
1) just define the sets
2) just output the set data (after a previous call to define)
3) define and output the set data in one call.
*/
for (i=0; i < set_count; i++) {
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(sets[i].type), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss defined for file id %d", ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
free(sets_to_define);
return (EX_FATAL);
}
ex_id_lkup(exoid, sets[i].type, sets[i].id);
if (exerrval != EX_LOOKUPFAIL) { /* found the side set id, so set is already defined... */
sets_to_define[i] = 0;
continue;
} else {
needs_define++;
sets_to_define[i] = 1;
}
}
if (needs_define > 0) {
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
free(sets_to_define);
return (EX_FATAL);
}
for (i=0; i < set_count; i++) {
if (sets_to_define[i] == 0)
continue;
/* NOTE: ex_inc_file_item finds the current number of sets defined
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(sets[i].type));
set_id_ndx = cur_num_sets + 1;
sets_to_define[i] = set_id_ndx;
if (sets[i].num_entry == 0)
continue;
/* setup pointers based on set_type */
if (sets[i].type == EX_NODE_SET) {
numentryptr = DIM_NUM_NOD_NS(set_id_ndx);
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (sets[i].type == EX_EDGE_SET) {
numentryptr = DIM_NUM_EDGE_ES(set_id_ndx);
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (sets[i].type == EX_FACE_SET) {
numentryptr = DIM_NUM_FACE_FS(set_id_ndx);
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (sets[i].type == EX_SIDE_SET) {
numentryptr = DIM_NUM_SIDE_SS(set_id_ndx);
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
else if (sets[i].type == EX_ELEM_SET) {
numentryptr = DIM_NUM_ELE_ELS(set_id_ndx);
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* define dimensions and variables */
if ((status = nc_def_dim(exoid, numentryptr,
sets[i].num_entry, &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: %s %"PRId64" -- size already defined in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
else {
sprintf(errmsg,
"Error: failed to define number of entries in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret;
}
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
int_size = sizeof(int64_t);
}
/* create variable array in which to store the entry lists */
dims[0] = dimid;
if ((status = nc_def_var(exoid, entryptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: entry list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create entry list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
if (extraptr) {
if ((status = nc_def_var(exoid, extraptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: extra list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create extra list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
}
/* Create distribution factors variable if required */
if (sets[i].num_distribution_factor > 0) {
if (sets[i].type != EX_SIDE_SET) {
/* but sets[i].num_distribution_factor must equal number of nodes */
if (sets[i].num_distribution_factor != sets[i].num_entry) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%"PRId64") not equal to # nodes (%"PRId64") in node set %"PRId64" file id %d",
sets[i].num_distribution_factor, sets[i].num_entry, sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* resuse dimid from entry lists */
if ((status = nc_def_dim(exoid, numdfptr,
sets[i].num_distribution_factor, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of dist factors in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* create variable array in which to store the set distribution factors
*/
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: dist factors list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create dist factors list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d", exoid);
ex_err("ex_put_sets",errmsg,exerrval);
free(sets_to_define);
return (EX_FATAL);
}
/* Output the set ids and status... */
for (i=0; i < set_count; i++) {
/* setup pointers based on sets[i].type */
if (sets[i].type == EX_NODE_SET) {
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (sets[i].type == EX_EDGE_SET) {
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (sets[i].type == EX_FACE_SET) {
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (sets[i].type == EX_SIDE_SET) {
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (sets[i].type == EX_ELEM_SET) {
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
/* first: get id of set id variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
free(sets_to_define);
return (EX_FATAL);
}
/* write out set id */
start[0] = sets_to_define[i]-1;
status = nc_put_var1_longlong(exoid, varid, start, (long long*)&sets[i].id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
free(sets_to_define);
return (EX_FATAL);
}
set_stat = (sets[i].num_entry == 0) ? 0 : 1;
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d", ex_name_of_object(sets[i].type),
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
free(sets_to_define);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &set_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s %"PRId64" status to file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
free(sets_to_define);
return (EX_FATAL);
}
}
}
free(sets_to_define);
/* Sets are now all defined; see if any set data needs to be output... */
status = EX_NOERR;
for (i=0; i < set_count; i++) {
int stat;
if (sets[i].entry_list != NULL || sets[i].extra_list != NULL) {
/* NOTE: ex_put_set will write the warning/error message... */
stat = ex_put_set(exoid, sets[i].type, sets[i].id, sets[i].entry_list, sets[i].extra_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
if (sets[i].distribution_factor_list != NULL) {
/* NOTE: ex_put_set_dist_fact will write the warning/error message... */
stat = ex_put_set_dist_fact(exoid, sets[i].type, sets[i].id, sets[i].distribution_factor_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
}
return (status);
/* Fatal error: exit definition mode and return */
error_ret:
free(sets_to_define);
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_set(int exoid, ex_entity_type set_type, ex_entity_id set_id, void_int *set_entry_list,
void_int *set_extra_list) /* NULL if dont want to retrieve data */
{
int dimid, entry_list_id, extra_list_id, status;
int set_id_ndx;
char errmsg[MAX_ERR_LENGTH];
char *entryptr = NULL;
char *extraptr = NULL;
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no %ss stored in file id %d",
ex_name_of_object(set_type), exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_WARN);
}
/* Lookup index of set id in VAR_*S_IDS array */
set_id_ndx = ex_id_lkup(exoid, set_type, set_id);
if (set_id_ndx <= 0) {
ex_get_err(NULL, NULL, &status);
if (status != 0) {
if (status == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: %s %" PRId64 " is NULL in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, EX_NULLENTITY);
EX_FUNC_LEAVE(EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s id %" PRId64 " in VAR_*S_IDS array in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
}
else if (set_type == EX_EDGE_SET) {
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, entryptr, &entry_list_id)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate entry list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* If client doet not pass in an array to store the
extra list, don't access it at all */
/* only do extra list for edge, face and side sets */
if (set_extra_list) {
if ((status = nc_inq_varid(exoid, extraptr, &extra_list_id)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate extra list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* read in the entry list and extra list arrays unless they are NULL */
if (set_entry_list) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, entry_list_id, set_entry_list);
}
else {
status = nc_get_var_int(exoid, entry_list_id, set_entry_list);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get entry list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* only do extra list for edge, face and side sets */
if (set_extra_list) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, extra_list_id, set_extra_list);
}
else {
status = nc_get_var_int(exoid, extra_list_id, set_extra_list);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get extra list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_put_processor_elem_maps(int exoid, void_int *elem_mapi, void_int *elem_mapb, int processor)
{
const char *func_name = "ex_put_processor_elem_maps";
char ftype[2];
int status, dimid, varid;
size_t start[1], count[1];
int64_t varidx[2];
int nmstat;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
ex_check_valid_file_id(exoid);
/* Get the file type */
if (ex_get_file_type(exoid, ftype) != EX_NOERR) {
exerrval = EX_MSG;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unable to find file type for file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the status of the internal element map */
if ((status = nc_inq_varid(exoid, VAR_INT_E_STAT, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_INT_E_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (ftype[0] == 's') {
start[0] = processor;
}
else {
start[0] = 0;
}
if ((status = nc_get_var1_int(exoid, varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get variable \"%s\" from file ID %d",
VAR_INT_E_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* get the index */
if (ex_get_idx(exoid, VAR_ELEM_MAP_INT_IDX, varidx, processor) == -1) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find index variable, \"%s\", in file ID %d", VAR_ELEM_MAP_INT_IDX,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (varidx[1] == -1) {
/* Get the size of the internal element map */
if ((status = nc_inq_dimid(exoid, DIM_NUM_INT_ELEMS, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find dimension ID for \"%s\" in file ID %d", DIM_NUM_INT_ELEMS,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_INT_ELEMS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
varidx[1] = count[0];
}
if ((status = nc_inq_varid(exoid, VAR_ELEM_MAP_INT, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_ELEM_MAP_INT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the map */
start[0] = varidx[0];
count[0] = varidx[1] - varidx[0];
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, elem_mapi);
}
else {
status = nc_put_vara_int(exoid, varid, start, count, elem_mapi);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to output variable \"%s\" in file ID %d",
VAR_ELEM_MAP_INT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (nmstat == 1)" */
/* Get the status of the border element map */
if ((status = nc_inq_varid(exoid, VAR_BOR_E_STAT, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_BOR_E_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (ftype[0] == 's') {
start[0] = processor;
}
else {
start[0] = 0;
}
if ((status = nc_get_var1_int(exoid, varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get status for \"%s\" from file %d",
VAR_BOR_E_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* get the index */
if (ex_get_idx(exoid, VAR_ELEM_MAP_BOR_IDX, varidx, processor) == -1) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find index variable, \"%s\", in file ID %d", VAR_ELEM_MAP_BOR_IDX,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (varidx[1] == -1) {
/* Get the size of the border element map */
if ((status = nc_inq_dimid(exoid, DIM_NUM_BOR_ELEMS, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find dimension ID for \"%s\" in file ID %d", DIM_NUM_BOR_ELEMS,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_BOR_ELEMS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
varidx[1] = count[0];
}
if ((status = nc_inq_varid(exoid, VAR_ELEM_MAP_BOR, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_ELEM_MAP_BOR, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the map */
start[0] = varidx[0];
count[0] = varidx[1] - varidx[0];
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, elem_mapb);
}
else {
status = nc_put_vara_int(exoid, varid, start, count, elem_mapb);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to output variable \"%s\" in file ID %d",
VAR_ELEM_MAP_BOR, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (nmstat == 1)" */
return (EX_NOERR);
}
int ex_put_partial_node_set(int exoid, ex_entity_id node_set_id, int64_t start_node_num,
int64_t num_nodes, const void_int *node_set_node_list)
{
int dimid, node_list_id, node_set_id_ndx, status;
size_t num_nodes_in_set, start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any node sets are specified */
if ((status = nc_inq_dimid(exoid, DIM_NUM_NS, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: no node sets specified in file id %d", exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
/* Lookup index of node set id in VAR_NS_IDS array */
if ((node_set_id_ndx = ex_id_lkup(exoid, EX_NODE_SET, node_set_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no data allowed for NULL node set %" PRId64 " in file id %d", node_set_id,
exoid);
ex_err("ex_put_partial_node_set", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate node set id %" PRId64 " in VAR_NS_IDS array in file id %d",
node_set_id, exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
/* inquire id's of previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_NUM_NOD_NS(node_set_id_ndx), &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate number of nodes in set %" PRId64 " in file id %d",
node_set_id, exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_nodes_in_set)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of nodes in set %" PRId64 " in file id %d", node_set_id,
exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (start_node_num < 0 || start_node_num > num_nodes_in_set) {
fprintf(stderr, "ERROR: Invalid input to function ex_get_partial_node_set!\n");
return -1;
}
if (num_nodes < 0) {
fprintf(stderr, "ERROR: Invalid number of nodes in nodes set!\n");
return -1;
}
/* start_node_num now starts at 1, not 0 */
if ((start_node_num + num_nodes - 1) > num_nodes_in_set) {
fprintf(stderr, "ERROR: request larger than number of nodes in set!\n");
return -1;
}
/* inquire if variable for node set node list has been defined */
if ((status = nc_inq_varid(exoid, VAR_NODE_NS(node_set_id_ndx), &node_list_id)) != NC_NOERR) {
/* variable doesn't exist */
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate node set %" PRId64 " node list in file id %d", node_set_id,
exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
/* write out the node list array */
start[0] = --start_node_num;
count[0] = num_nodes;
if (count[0] == 0) {
start[0] = 0;
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_vara_longlong(exoid, node_list_id, start, count, node_set_node_list);
}
else {
status = nc_put_vara_int(exoid, node_list_id, start, count, node_set_node_list);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store node set %" PRId64 " node list in file id %d", node_set_id,
exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_id_lkup(int exoid, ex_entity_type id_type, ex_entity_id num)
{
char * id_table;
char * id_dim;
char * stat_table;
int varid, dimid;
size_t dim_len, i;
int64_t *id_vals = NULL;
int * stat_vals = NULL;
static int filled = EX_FALSE;
struct obj_stats *tmp_stats;
int status;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
switch (id_type) {
case EX_NODAL: return 0;
case EX_GLOBAL: return 0;
case EX_ELEM_BLOCK:
id_table = VAR_ID_EL_BLK; /* id array name */
id_dim = DIM_NUM_EL_BLK; /* id array dimension name*/
stat_table = VAR_STAT_EL_BLK; /* id status array name */
tmp_stats = ex_get_stat_ptr(exoid, &exoII_eb);
break;
case EX_NODE_SET:
id_table = VAR_NS_IDS;
id_dim = DIM_NUM_NS;
stat_table = VAR_NS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ns);
break;
case EX_SIDE_SET:
id_table = VAR_SS_IDS;
id_dim = DIM_NUM_SS;
stat_table = VAR_SS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ss);
break;
case EX_EDGE_BLOCK:
id_table = VAR_ID_ED_BLK;
id_dim = DIM_NUM_ED_BLK;
stat_table = VAR_STAT_ED_BLK;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ed);
break;
case EX_FACE_BLOCK:
id_table = VAR_ID_FA_BLK;
id_dim = DIM_NUM_FA_BLK;
stat_table = VAR_STAT_FA_BLK;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fa);
break;
case EX_EDGE_SET:
id_table = VAR_ES_IDS;
id_dim = DIM_NUM_ES;
stat_table = VAR_ES_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_es);
break;
case EX_FACE_SET:
id_table = VAR_FS_IDS;
id_dim = DIM_NUM_FS;
stat_table = VAR_FS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fs);
break;
case EX_ELEM_SET:
id_table = VAR_ELS_IDS;
id_dim = DIM_NUM_ELS;
stat_table = VAR_ELS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_els);
break;
case EX_NODE_MAP:
id_table = VAR_NM_PROP(1);
id_dim = DIM_NUM_NM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_nm);
break;
case EX_EDGE_MAP:
id_table = VAR_EDM_PROP(1);
id_dim = DIM_NUM_EDM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_edm);
break;
case EX_FACE_MAP:
id_table = VAR_FAM_PROP(1);
id_dim = DIM_NUM_FAM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fam);
break;
case EX_ELEM_MAP:
id_table = VAR_EM_PROP(1);
id_dim = DIM_NUM_EM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_em);
break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported id array type %d for file id %d", id_type,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if ((tmp_stats->id_vals == NULL) || (!(tmp_stats->valid_ids))) {
/* first time thru or id arrays haven't been completely filled yet */
/* get size of id array */
/* First get dimension id of id array */
if ((status = nc_inq_dimid(exoid, id_dim, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate id array dimension in file id %d",
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* Next get value of dimension */
if ((status = nc_inq_dimlen(exoid, dimid, &dim_len)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s array length in file id %d",
id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* get variable id of id array */
if ((status = nc_inq_varid(exoid, id_table, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s array in file id %d", id_table,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* allocate space for id array and initialize to zero to ensure
that the higher bits don't contain garbage while copy from ints */
if (!(id_vals = calloc(dim_len, sizeof(int64_t)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate memory for %s array for file id %d", id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varid, (long long *)id_vals);
}
else {
int *id_vals_int;
if (!(id_vals_int = malloc(dim_len * sizeof(int)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate memory for temporary array "
"id_vals_int for file id %d",
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
free(id_vals);
return (EX_FATAL);
}
status = nc_get_var_int(exoid, varid, (int *)id_vals_int);
if (status == NC_NOERR) {
for (i = 0; i < dim_len; i++) {
id_vals[i] = (int64_t)id_vals_int[i];
}
}
free(id_vals_int);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s array from file id %d", id_table,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
free(id_vals);
return (EX_FATAL);
}
/* check if values in stored arrays are filled with non-zeroes */
filled = EX_TRUE;
for (i = 0; i < dim_len; i++) {
if (id_vals[i] == EX_INVALID_ID || id_vals[i] == NC_FILL_INT) {
filled = EX_FALSE;
break; /* id array hasn't been completely filled with valid ids yet */
}
}
if (filled) {
tmp_stats->valid_ids = EX_TRUE;
tmp_stats->num = dim_len;
tmp_stats->id_vals = id_vals;
}
}
else {
id_vals = tmp_stats->id_vals;
dim_len = tmp_stats->num;
}
/* Do a linear search through the id array to find the array value
corresponding to the passed index number */
for (i = 0; i < dim_len; i++) {
if (id_vals[i] == num) {
break; /* found the id requested */
}
}
if (i >= dim_len) /* failed to find id number */
{
if (!(tmp_stats->valid_ids)) {
free(id_vals);
}
exerrval = EX_LOOKUPFAIL;
return (EX_LOOKUPFAIL); /*if we got here, the id array value doesn't exist */
}
/* Now check status array to see if object is null */
/* get variable id of status array */
if (nc_inq_varid(exoid, stat_table, &varid) == NC_NOERR) {
/* if status array exists, use it, otherwise assume object exists
to be backward compatible */
if ((tmp_stats->stat_vals == NULL) || (!(tmp_stats->valid_stat))) {
/* first time thru or status arrays haven't been filled yet */
/* allocate space for new status array */
if (!(stat_vals = malloc(dim_len * sizeof(int)))) {
exerrval = EX_MEMFAIL;
free(id_vals);
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate memory for %s array for file id %d", id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free(id_vals);
free(stat_vals);
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s array from file id %d",
stat_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if (tmp_stats->valid_ids) {
/* status array is valid only if ids are valid */
tmp_stats->valid_stat = EX_TRUE;
tmp_stats->stat_vals = stat_vals;
}
}
else {
stat_vals = tmp_stats->stat_vals;
}
if (stat_vals[i] == 0) /* is this object null? */ {
exerrval = EX_NULLENTITY;
if (!(tmp_stats->valid_stat)) {
free(stat_vals);
}
if (!(tmp_stats->valid_ids)) {
free(id_vals);
}
return (-((int)i + 1)); /* return index into id array (1-based) */
}
}
if (!(tmp_stats->valid_ids)) {
free(id_vals);
free(stat_vals);
}
return (i + 1); /* return index into id array (1-based) */
}
int ex_put_map_param (int exoid,
int num_node_maps,
int num_elem_maps)
{
int dim[2], dimid, strdim, varid, status;
int var_nm_id, var_em_id;
int i;
char errmsg[MAX_ERR_LENGTH];
int id_type = NC_INT;
int int_type = NC_INT;
exerrval = 0; /* clear error code */
if (ex_int64_status(exoid) & EX_IDS_INT64_DB) {
id_type = NC_INT64;
}
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
int_type = NC_INT64;
}
/* return if these have been defined before */
if ( (num_node_maps > 0 && ((nc_inq_dimid (exoid, DIM_NUM_NM, &dimid)) == NC_NOERR)) ||
(num_elem_maps > 0 && ((nc_inq_dimid (exoid, DIM_NUM_EM, &dimid)) == NC_NOERR)) )
{
exerrval = EX_MSG;
sprintf(errmsg,
"Error: number of maps already defined for file id %d",exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
return (EX_FATAL);
}
if ( (num_node_maps > 0) || (num_elem_maps > 0) ) {
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid (exoid, DIM_STR_NAME, &strdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
return (EX_FATAL);
}
/* put file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode", exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
return (EX_FATAL);
}
/* node maps: */
if (num_node_maps > 0) {
if ((status = nc_def_dim(exoid, DIM_NUM_NM, num_node_maps, &dimid)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of node maps in file id %d",exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* node maps id array: */
dim[0] = dimid;
if ((status = nc_def_var(exoid, VAR_NM_PROP(1), id_type, 1, dim, &var_nm_id)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to create node maps property array in file id %d",
exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store property name as attribute of property array variable */
if ((status=nc_put_att_text(exoid, var_nm_id, ATT_PROP_NAME, 3, "ID")) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to store node map property name %s in file id %d",
"ID",exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* Node map names... */
dim[0] = dimid;
dim[1] = strdim;
if (nc_def_var(exoid, VAR_NAME_NM, NC_CHAR, 2, dim, &varid) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define node map name array in file id %d",exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* determine number of nodes */
if ((status = nc_inq_dimid (exoid, DIM_NUM_NODES, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: couldn't determine number of nodes in file id %d",
exoid);
ex_err("ex_put_node_map",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dim[0] = dimid;
/* create variable array in which to store the node maps */
for (i=0; i < num_node_maps; i++) {
if ((status = nc_def_var(exoid,VAR_NODE_MAP(i+1),int_type,1,dim,&varid)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: node map %d already defined in file id %d",
i,exoid);
ex_err("ex_put_node_map",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create node map %d in file id %d",
i,exoid);
ex_err("ex_put_node_map",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
}
}
/* element maps: */
if (num_elem_maps > 0) {
if ((status = nc_def_dim (exoid, DIM_NUM_EM, num_elem_maps,&dimid)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of element maps in file id %d",
exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element maps id array: */
dim[0] = dimid;
if ((status = nc_def_var(exoid, VAR_EM_PROP(1), id_type, 1, dim, &var_em_id)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create element maps property array in file id %d",
exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store property name as attribute of property array variable */
if ((status=nc_put_att_text(exoid, var_em_id, ATT_PROP_NAME, 3, "ID")) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to store element map property name %s in file id %d",
"ID",exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* Element map names... */
dim[0] = dimid;
dim[1] = strdim;
if ((status = nc_def_var(exoid, VAR_NAME_EM, NC_CHAR, 2, dim, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define element map name array in file id %d",exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* determine number of elements */
if ((status = nc_inq_dimid(exoid, DIM_NUM_ELEM, &dimid)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: couldn't determine number of elements in file id %d",
exoid);
ex_err("ex_put_elem_map",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* create variable array in which to store the element maps */
dim[0] = dimid;
for (i = 0; i < num_elem_maps; i++) {
if ((status = nc_def_var(exoid,VAR_ELEM_MAP(i+1),int_type,1,dim, &varid)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: element map %d already defined in file id %d",
i,exoid);
ex_err("ex_put_elem_map",errmsg,exerrval);
}
else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create element map %d in file id %d",
i,exoid);
ex_err("ex_put_elem_map",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
}
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete variable definitions in file id %d",exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
return (EX_FATAL);
}
/* Fill the id arrays with EX_INVALID_ID */
{
int maxset = num_node_maps > num_elem_maps ? num_node_maps : num_elem_maps;
int *invalid_ids = malloc(maxset*sizeof(int));
for (i=0; i < maxset; i++) {
invalid_ids[i] = EX_INVALID_ID;
}
if (num_node_maps > 0) {
status = nc_put_var_int(exoid, var_nm_id, invalid_ids);
assert(status == NC_NOERR);
}
if (num_elem_maps > 0) {
status = nc_put_var_int(exoid, var_em_id, invalid_ids);
assert(status == NC_NOERR);
}
free(invalid_ids);
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_map_param",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_init_global(int exoid, void_int *num_nodes_g, void_int *num_elems_g,
void_int *num_elem_blks_g, void_int *num_node_sets_g,
void_int *num_side_sets_g)
{
const char *func_name = "ex_get_init_global";
int dimid, status;
size_t nng, neg, nebg, nnsg, nssg;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error flag */
/* Check the file version information */
if ((dimid = ne_check_file_version(exoid)) != EX_NOERR) {
return (dimid);
}
/* Get the dimension ID for the number of global FEM nodes */
if ((status = nc_inq_dimid(exoid, DIM_NUM_NODES_GLOBAL, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find dimension ID for \"%s\" in file ID %d",
DIM_NUM_NODES_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the value of the number of global FEM nodes */
if ((status = nc_inq_dimlen(exoid, dimid, &nng)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find length of dimension \"%s\" in file ID %d", DIM_NUM_NODES_GLOBAL,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the dimension ID for the number of global FEM elements */
if ((status = nc_inq_dimid(exoid, DIM_NUM_ELEMS_GLOBAL, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find dimension ID for \"%s\" in file ID %d",
DIM_NUM_ELEMS_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the value of the number of global FEM elements */
if ((status = nc_inq_dimlen(exoid, dimid, &neg)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find length of dimension \"%s\" in file ID %d", DIM_NUM_ELEMS_GLOBAL,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the dimension ID for the number of global element blocks */
if ((status = nc_inq_dimid(exoid, DIM_NUM_ELBLK_GLOBAL, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find dimension ID for \"%s\" in file ID %d",
DIM_NUM_ELBLK_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the value of the number of global element blocks */
if ((status = nc_inq_dimlen(exoid, dimid, &nebg)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find length of dimension \"%s\" in file ID %d", DIM_NUM_ELBLK_GLOBAL,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the dimension ID for the number of global node sets */
if ((status = nc_inq_dimid(exoid, DIM_NUM_NS_GLOBAL, &dimid)) != NC_NOERR) {
nnsg = 0;
}
else {
/* Get the value of the number of global node sets */
if ((status = nc_inq_dimlen(exoid, dimid, &nnsg)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find length of dimension \"%s\" in file ID %d", DIM_NUM_NS_GLOBAL,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
/* Get the dimension ID for the number of global side sets */
if ((status = nc_inq_dimid(exoid, DIM_NUM_SS_GLOBAL, &dimid)) != NC_NOERR) {
nssg = 0;
}
else {
/* Get the value of the number of global side sets */
if ((status = nc_inq_dimlen(exoid, dimid, &nssg)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find length of dimension \"%s\" in file ID %d", DIM_NUM_SS_GLOBAL,
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
*(int64_t *)num_nodes_g = nng;
*(int64_t *)num_elems_g = neg;
*(int64_t *)num_elem_blks_g = nebg;
*(int64_t *)num_node_sets_g = nnsg;
*(int64_t *)num_side_sets_g = nssg;
}
else {
*(int *)num_nodes_g = nng;
*(int *)num_elems_g = neg;
*(int *)num_elem_blks_g = nebg;
*(int *)num_node_sets_g = nnsg;
*(int *)num_side_sets_g = nssg;
}
return (EX_NOERR);
}
int ex_put_ns_param_global(int exoid, void_int *global_ids, void_int *node_cnts, void_int *df_cnts)
{
const char *func_name = "ex_put_ns_param_global";
int varid, status;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/* Get the variable ID for the vector of global node set IDs */
if ((status = nc_inq_varid(exoid, VAR_NS_IDS_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_NS_IDS_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the vector of global node set IDs */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, varid, global_ids);
}
else {
status = nc_put_var_int(exoid, varid, global_ids);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to output variable \"%s\" to file ID %d",
VAR_NS_IDS_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the variable ID for the vector of global node-set node counts */
if ((status = nc_inq_varid(exoid, VAR_NS_NODE_CNT_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_NS_NODE_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the vector of global node counts in each global node set */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_var_longlong(exoid, varid, node_cnts);
}
else {
status = nc_put_var_int(exoid, varid, node_cnts);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put variable \"%s\" in file ID %d",
VAR_NS_NODE_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the variable ID for the number of dist. factors in each node set */
if ((status = nc_inq_varid(exoid, VAR_NS_DF_CNT_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_NS_DF_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the vector of dist. factor counts */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_var_longlong(exoid, varid, df_cnts);
}
else {
status = nc_put_var_int(exoid, varid, df_cnts);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to output variable \"%s\" in file ID %d",
VAR_NS_DF_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_cvt_nodes_to_sides(int exoid, void_int *num_elem_per_set, void_int *num_nodes_per_set,
void_int *side_sets_elem_index, /* unused */
void_int *side_sets_node_index, /* unused */
void_int *side_sets_elem_list, void_int *side_sets_node_list,
void_int *side_sets_side_list)
{
size_t i, j, k, n;
int num_side_sets, num_elem_blks;
int64_t tot_num_elem = 0, tot_num_ss_elem = 0, elem_num = 0, ndim;
void_int *elem_blk_ids = NULL;
void_int *connect = NULL;
void_int *ss_elem_ndx = NULL;
void_int *ss_elem_node_ndx = NULL;
void_int *ss_parm_ndx = NULL;
size_t elem_ctr, node_ctr, elem_num_pos;
int num_nodes_per_elem, num_node_per_side;
int *same_elem_type = NULL;
int el_type = 0;
int int_size;
int ids_size;
struct elem_blk_parm *elem_blk_parms = NULL;
int err_stat = EX_NOERR;
/* node to side translation tables -
These tables are used to look up the side number based on the
first and second node in the side/face list. The side node order
is found in the original Exodus document, SAND87-2997. The element
node order is found in the ExodusII document, SAND92-2137. These
tables were generated by following the right-hand rule for determining
the outward normal. Note: Only the more complex 3-D shapes require
these tables, the simple shapes are trivial - the first node found
is also the side number.
*/
/* 1 2 3 4 node 1 */
static int shell_table[2][8] = {
{2, 4, 3, 1, 4, 2, 1, 3}, /* node 2 */
{1, 2, 1, 2, 1, 2, 1, 2} /* side # */
};
/* 1 2 3 4 node 1 */
static int shell_edge_table[2][8] = {
{2, 4, 3, 1, 4, 2, 1, 3}, /* node 2 */
{3, 6, 4, 3, 5, 4, 6, 5} /* side # */
};
/* 1 2 3 node 1 */
static int trishell_table[2][6] = {
{2, 3, 3, 1, 1, 2}, /* node 2 */
{1, 2, 1, 2, 1, 2} /* side # */
};
/* 1 2 3 4 node 1 */
static int tetra_table[2][12] = {
{2, 3, 4, 1, 3, 4, 4, 1, 2, 1, 2, 3}, /* node 2 */
{1, 4, 3, 4, 2, 1, 2, 3, 4, 1, 2, 3} /* side # */
};
#if 0
static int wedge_table[2][18] = {
/* 1 2 3 4 5 6 node 1 */
{2,4,3, 5,1,3, 6,1,2, 1,6,5, 6,2,4, 4,3,5}, /* node 2 */
{1,3,4, 1,4,2, 2,3,4, 1,3,5, 5,2,1, 5,3,2} /* side # */
};
#endif
static int hex_table[2][24] = {
/* 1 2 3 4 5 6 7 8 node 1 */
{4, 2, 5, 1, 3, 6, 7, 4, 2, 3, 1, 8, 6, 8, 1, 5, 2, 7, 8, 6, 3, 7, 5, 4}, /* node 2 */
{5, 1, 4, 5, 2, 1, 2, 3, 5, 5, 4, 3, 6, 4, 1, 1, 2, 6, 6, 2, 3, 3, 6, 4} /* side # */
};
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS);
if (num_side_sets < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
return (EX_FATAL);
}
if (num_side_sets == 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no side sets defined in file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, EX_WARN);
return (EX_WARN);
}
num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
if (num_elem_blks < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
return (EX_FATAL);
}
tot_num_elem = ex_inquire_int(exoid, EX_INQ_ELEM);
if (tot_num_elem < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get total number of elements in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
return (EX_FATAL);
}
/* get the dimensionality of the coordinates; this is necessary to
distinguish between 2d TRIs and 3d TRIs */
ndim = ex_inquire_int(exoid, EX_INQ_DIM);
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* First count up # of elements in the side sets*/
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
for (i = 0; i < num_side_sets; i++) {
tot_num_ss_elem += ((int64_t *)num_elem_per_set)[i];
}
}
else {
for (i = 0; i < num_side_sets; i++) {
tot_num_ss_elem += ((int *)num_elem_per_set)[i];
}
}
/* Allocate space for the ss element index array */
if (!(ss_elem_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem sort "
"array for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (int_size == sizeof(int64_t)) {
/* Sort side set element list into index array - non-destructive */
int64_t *elems = (int64_t *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort64(side_sets_elem_list, elems, tot_num_ss_elem);
}
else {
/* Sort side set element list into index array - non-destructive */
int *elems = (int *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort(side_sets_elem_list, elems, tot_num_ss_elem);
}
/* Allocate space for the element block ids */
ids_size = sizeof(int);
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
ids_size = sizeof(int64_t);
}
if (!(elem_blk_ids = malloc(num_elem_blks * ids_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate space for element block ids for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids)) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element block ids in file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the element block params */
if (!(elem_blk_parms = malloc(num_elem_blks * sizeof(struct elem_blk_parm)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block params "
"for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = 0;
for (i = 0; i < num_elem_blks; i++) {
ex_entity_id id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
id = ((int64_t *)elem_blk_ids)[i];
}
else {
id = ((int *)elem_blk_ids)[i];
}
err_stat = ex_int_get_block_param(exoid, id, ndim, &elem_blk_parms[i]);
if (err_stat != EX_NOERR) {
goto cleanup;
}
elem_ctr += elem_blk_parms[i].num_elem_in_blk;
elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */
}
/* Allocate space for the ss element to element block parameter index array */
if (!(ss_parm_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem parms "
"index for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the ss element to node list index array */
if (!(ss_elem_node_ndx = malloc((tot_num_ss_elem + 1) * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem to node "
"index for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* determine if each side set has uniform element types; this will
be used to help determine the stride through the node list
*/
/* Allocate space for same element type flag array*/
if (!(same_elem_type = malloc(num_side_sets * sizeof(int)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element type flag "
"array for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
same_elem_type[0] = EX_TRUE;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
elem_ctr = ((int64_t *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int64_t elem = ((int64_t *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (i == 0) {
el_type = elem_blk_parms[j].elem_type_val;
}
/* determine which side set this element is in; assign to kth side set */
if (i >= elem_ctr) {
elem_ctr += ((int64_t *)num_elem_per_set)[++k];
el_type = elem_blk_parms[j].elem_type_val;
same_elem_type[k] = EX_TRUE;
}
if (el_type != elem_blk_parms[j].elem_type_val) {
same_elem_type[k] = EX_FALSE;
}
}
/* Build side set element to node list index and side set element
parameter index.
*/
node_ctr = 0;
elem_ctr = ((int64_t *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int64_t elem = ((int64_t *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
((int64_t *)ss_parm_ndx)[i] = j; /* assign parameter block index */
((int64_t *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
/* determine which side set this element is in; assign to kth side set */
if (i >= elem_ctr) {
/* skip over NULL side sets */
while (((int64_t *)num_elem_per_set)[++k] == 0) {
;
}
elem_ctr += ((int64_t *)num_elem_per_set)[k];
}
/* determine number of nodes per side */
if (((((int64_t *)num_nodes_per_set)[k] % ((int64_t *)num_elem_per_set)[k]) == 0) &&
(same_elem_type[k] == EX_TRUE)) { /* all side set elements are same type */
node_ctr += ((int64_t *)num_nodes_per_set)[k] / ((int64_t *)num_elem_per_set)[k];
}
else {
node_ctr += elem_blk_parms[j].num_nodes_per_side[0];
}
}
((int64_t *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
}
else {
elem_ctr = ((int *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int elem = ((int *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (i == 0) {
el_type = elem_blk_parms[j].elem_type_val;
}
/* determine which side set this element is in; assign to kth side set */
if (i >= elem_ctr) {
elem_ctr += ((int *)num_elem_per_set)[++k];
el_type = elem_blk_parms[j].elem_type_val;
same_elem_type[k] = EX_TRUE;
}
if (el_type != elem_blk_parms[j].elem_type_val) {
same_elem_type[k] = EX_FALSE;
}
}
/* Build side set element to node list index and side set element
parameter index.
*/
node_ctr = 0;
elem_ctr = ((int *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int elem = ((int *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
((int *)ss_parm_ndx)[i] = j; /* assign parameter block index */
((int *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
/* determine which side set this element is in; assign to kth side set */
if (i >= elem_ctr) {
/* skip over NULL side sets */
while (((int *)num_elem_per_set)[++k] == 0) {
;
}
elem_ctr += ((int *)num_elem_per_set)[k];
}
/* determine number of nodes per side */
if (((((int *)num_nodes_per_set)[k] % ((int *)num_elem_per_set)[k]) == 0) &&
(same_elem_type[k])) { /* all side set elements are same type */
node_ctr += ((int *)num_nodes_per_set)[k] / ((int *)num_elem_per_set)[k];
}
else {
node_ctr += elem_blk_parms[j].num_nodes_per_side[0];
}
}
((int *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
}
/* All setup, ready to go ... */
elem_ctr = 0;
for (j = 0; j < tot_num_ss_elem; j++) {
int64_t elem;
int64_t idx;
int64_t ss_node0, ss_node1;
int64_t p_ndx;
if (int_size == sizeof(int64_t)) {
idx = ((int64_t *)ss_elem_ndx)[j];
elem = ((int64_t *)side_sets_elem_list)[idx];
ss_node0 = ((int64_t *)side_sets_node_list)[((int64_t *)ss_elem_node_ndx)[idx]];
ss_node1 = ((int64_t *)side_sets_node_list)[((int64_t *)ss_elem_node_ndx)[idx] + 1];
p_ndx = ((int64_t *)ss_parm_ndx)[idx];
}
else {
idx = ((int *)ss_elem_ndx)[j];
elem = ((int *)side_sets_elem_list)[idx];
ss_node0 = ((int *)side_sets_node_list)[((int *)ss_elem_node_ndx)[idx]];
ss_node1 = ((int *)side_sets_node_list)[((int *)ss_elem_node_ndx)[idx] + 1];
p_ndx = ((int *)ss_parm_ndx)[idx];
}
elem_num = elem - 1;
if (elem > elem_ctr) {
/* release connectivity array space and get next one */
if (elem_ctr > 0) {
free(connect);
}
/* Allocate space for the connectivity array for new element block */
if (!(connect = malloc(elem_blk_parms[p_ndx].num_elem_in_blk *
elem_blk_parms[p_ndx].num_nodes_per_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for connectivity "
"array for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* get connectivity array */
if (ex_get_conn(exoid, EX_ELEM_BLOCK, elem_blk_parms[p_ndx].elem_blk_id, connect, NULL,
NULL) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get connectivity array for elem blk %" PRId64 " for file id %d",
elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = elem_blk_parms[p_ndx].elem_ctr;
}
/* For the first node of each side in side set, using a linear search
(of up to num_nodes_per_elem) of the connectivity array,
locate the node position in the element. The first node position
and the second node position are used with a element type specific
table to determine the side. */
if (connect == NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: logic error. Connect pointer is null for elem blk %" PRId64
" for file id %d",
elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* calculate the relative element number position in it's block*/
elem_num_pos =
elem_num - (elem_blk_parms[p_ndx].elem_ctr - elem_blk_parms[p_ndx].num_elem_in_blk);
/* calculate the beginning of the node list for this element by
using the ss_elem_node_ndx index into the side_sets_node_index
and adding the element number position * number of nodes per elem */
num_nodes_per_elem = elem_blk_parms[p_ndx].num_nodes_per_elem;
for (n = 0; n < num_nodes_per_elem; n++) {
/* find node in connectivity array that matches first node in side set */
if (((int_size == sizeof(int64_t)) &&
(ss_node0 == ((int64_t *)connect)[num_nodes_per_elem * (elem_num_pos) + n])) ||
((int_size == sizeof(int)) &&
(ss_node0 == ((int *)connect)[num_nodes_per_elem * (elem_num_pos) + n]))) {
switch (elem_blk_parms[p_ndx].elem_type_val) {
case EX_EL_CIRCLE:
case EX_EL_SPHERE: {
/* simple case: 1st node number is same as side # */
put_side(side_sets_side_list, idx, n + 1, int_size);
break;
}
case EX_EL_QUAD:
case EX_EL_TRIANGLE:
case EX_EL_TRUSS:
case EX_EL_BEAM: {
/* simple case: 1st node number is same as side # */
put_side(side_sets_side_list, idx, n + 1, int_size);
break;
}
case EX_EL_TRISHELL: {
/* use table to find which node to compare to next */
if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n + 1] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n + 2] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find TRIANGULAR SHELL element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_SHELL: {
/* use table to find which node to compare to next */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
num_node_per_side =
((int64_t *)ss_elem_node_ndx)[idx + 1] - ((int64_t *)ss_elem_node_ndx)[idx];
}
else {
num_node_per_side = ((int *)ss_elem_node_ndx)[idx + 1] - ((int *)ss_elem_node_ndx)[idx];
}
if (ss_node1 ==
get_node(connect, num_nodes_per_elem * (elem_num_pos) + (shell_table[0][2 * n] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n], int_size);
}
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(shell_table[0][2 * n + 1] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n + 1], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n + 1], int_size);
}
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(shell_table[0][2 * n + 2] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n + 2], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n + 2], int_size);
}
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find SHELL element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_HEX: {
/* use table to find which node to compare to next */
if (ss_node1 == get_node(connect,
num_nodes_per_elem * (elem_num_pos) + (hex_table[0][3 * n] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(hex_table[0][3 * n + 1] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(hex_table[0][3 * n + 2] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find HEX element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_TETRA: {
/* use table to find which node to compare to next */
if (ss_node1 ==
get_node(connect, num_nodes_per_elem * (elem_num_pos) + (tetra_table[0][3 * n] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(tetra_table[0][3 * n + 1] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(tetra_table[0][3 * n + 2] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find TETRA element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_PYRAMID: {
/* NOTE: PYRAMID elements in side set node lists are currently not
* supported */
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported PYRAMID element found in side "
"set node list in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
case EX_EL_WEDGE: {
/* NOTE: WEDGE elements in side set node lists are currently not
* supported */
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported WEDGE element found in side set "
"node list in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
default: {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: %s is an unsupported element type",
elem_blk_parms[p_ndx].elem_type);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
}
break; /* done with this element */
}
}
if (n >= num_nodes_per_elem) /* did we find the node? */
{
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find element %" PRId64 ", node %" PRId64
" in element block %" PRId64 " for file id %d",
elem_num + 1, ss_node0, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
}
/* All done: release connectivity array space, element block ids array,
element block parameters array, and side set element index array */
cleanup:
free(connect);
free(ss_elem_node_ndx);
free(ss_parm_ndx);
free(elem_blk_parms);
free(elem_blk_ids);
free(ss_elem_ndx);
free(same_elem_type);
return (err_stat);
}
int ex_get_coordinate_frames(int exoid, int *nframes, void_int *cf_ids, void *pt_coordinates,
char *tags)
{
int status;
int dimid; /* ID of the dimension of # frames */
char errmsg[MAX_ERR_LENGTH];
int varids; /* variable id for the frame ids */
size_t start = 0; /* start value for varputs */
size_t count = 0; /* number vars to put in varput */
ex_check_valid_file_id(exoid);
/* get the dimensions */
assert(nframes != NULL);
status = nc_inq_dimid(exoid, DIM_NUM_CFRAMES, &dimid);
if (status != NC_NOERR) {
*nframes = 0;
return EX_NOERR;
}
(void)nc_inq_dimlen(exoid, dimid, &count);
*nframes = (int)count;
if (count == 0) {
return (EX_NOERR);
}
if (cf_ids) {
if ((status = nc_inq_varid(exoid, VAR_FRAME_IDS, &varids)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to read number coordinate ids from file id %d", exoid);
ex_err(PROCNAME, errmsg, exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varids, cf_ids);
}
else {
status = nc_get_var_int(exoid, varids, cf_ids);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to read coordinate frame ids from file id %d",
exoid);
ex_err(PROCNAME, errmsg, exerrval);
return (EX_FATAL);
}
}
if (tags) {
if ((status = nc_inq_varid(exoid, VAR_FRAME_TAGS, &varids)) != NC_NOERR ||
(nc_get_vara_text(exoid, varids, &start, &count, tags) != NC_NOERR)) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to read number coordinate tags from file id %d", exoid);
ex_err(PROCNAME, errmsg, exerrval);
return (EX_FATAL);
}
}
if (pt_coordinates) {
if ((status = nc_inq_varid(exoid, VAR_FRAME_COORDS, &varids)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to read number coordinate tags from file id %d", exoid);
ex_err(PROCNAME, errmsg, exerrval);
return (EX_FATAL);
}
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, varids, pt_coordinates);
}
else {
status = nc_get_var_double(exoid, varids, pt_coordinates);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to read number coordinate tags from file id %d", exoid);
ex_err(PROCNAME, errmsg, exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
}
int ex_put_cmap_params_cc(int exoid,
void_int *node_cmap_ids,
void_int *node_cmap_node_cnts,
void_int *node_proc_ptrs,
void_int *elem_cmap_ids,
void_int *elem_cmap_elem_cnts,
void_int *elem_proc_ptrs
)
{
const char *func_name="ex_put_cmap_params_cc";
size_t num_n_comm_maps, num_e_comm_maps, num_procs_in_file;
int status, icm, n_varid[2], e_varid[2], iproc;
int varid, n_dimid[1], e_dimid[1];
int n_varid_idx, e_varid_idx;
int num_icm;
size_t start[1], count[1];
size_t ecnt_cmap, ncnt_cmap;
long long nl_ecnt_cmap, nl_ncnt_cmap;
void_int *n_var_idx = NULL;
void_int *e_var_idx = NULL;
int nmstat;
char errmsg[MAX_ERR_LENGTH];
int format;
int index_type, bulk_type;
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/* See if using NC_FORMAT_NETCDF4 format... */
nc_inq_format(exoid, &format);
if ((ex_int64_status(exoid) & EX_BULK_INT64_DB) || (format == NC_FORMAT_NETCDF4)) {
index_type = NC_INT64;
} else {
index_type = NC_INT;
}
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
bulk_type = NC_INT64;
} else {
bulk_type = NC_INT;
}
/* Get the number of processors in the file */
if ((status = nc_inq_dimid(exoid, DIM_NUM_PROCS_F, &n_dimid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get dimension ID for \"%s\" in file ID %d",
DIM_NUM_PROCS_F, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, n_dimid[0], &num_procs_in_file)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_PROCS_F, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/*
* since I cannot get variables while in define mode, I need to
* get the cmap information index variables before I go into
* define mode
*/
/* Check to see if there are nodal communications maps in the file */
if (nc_inq_dimid(exoid, DIM_NUM_N_CMAPS, &n_dimid[0]) != NC_NOERR) {
num_n_comm_maps = 0;
}
else {
if ((status = nc_inq_dimlen(exoid, n_dimid[0], &num_n_comm_maps)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in \
file ID %d",
DIM_NUM_N_CMAPS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
if (num_n_comm_maps > 0) {
/* Get the variable ID for the comm map index vector */
if ((status = nc_inq_varid(exoid, VAR_N_COMM_INFO_IDX, &n_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_N_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* allocate space for the index variable */
if (index_type == NC_INT64) {
n_var_idx = malloc((num_procs_in_file + 1) * sizeof(long long));
} else {
n_var_idx = malloc((num_procs_in_file + 1) * sizeof(int));
}
if (!n_var_idx) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: insufficient memory to read index variable from file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* and set the last value of the index */
/* get the communication map info index */
if (index_type == NC_INT64) {
((long long*)n_var_idx)[0] = 0;
status = nc_get_var_longlong(exoid, n_varid_idx, &((long long*)n_var_idx)[1]);
} else {
((int*)n_var_idx)[0] = 0;
status = nc_get_var_int(exoid, n_varid_idx, &((int*)n_var_idx)[1]);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_N_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* "if (num_n_comm_maps > 0)" */
/* Check to see if there are elemental communications maps in the file */
if ((status = nc_inq_dimid(exoid, DIM_NUM_E_CMAPS, &e_dimid[0])) != NC_NOERR) {
num_e_comm_maps = 0;
}
else {
if ((status = nc_inq_dimlen(exoid, e_dimid[0], &num_e_comm_maps)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in \
file ID %d",
DIM_NUM_E_CMAPS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
if (num_e_comm_maps > 0) {
/* Get the variable ID for the comm map index vector */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_INFO_IDX, &e_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* allocate space for the index variable */
if (index_type == NC_INT64) {
e_var_idx = malloc((num_procs_in_file + 1) * sizeof(long long));
} else {
e_var_idx = malloc((num_procs_in_file + 1) * sizeof(int));
}
if (!e_var_idx) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: insufficient memory to read index variable from file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* get the communication map info index */
if (index_type == NC_INT64) {
((long long*)e_var_idx)[0] = 0;
status = nc_get_var_longlong(exoid, e_varid_idx, &((long long*)e_var_idx)[1]);
} else {
((int*)e_var_idx)[0] = 0;
status = nc_get_var_int(exoid, e_varid_idx, &((int*)e_var_idx)[1]);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_E_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* "if (num_e_comm_maps >0)" */
/* Put NetCDF file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file ID %d into define mode", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/*
* Add dimensions for the size of the number of nodal
* communication maps.
*/
if (num_n_comm_maps > 0) {
/* add the communications data index variable */
if ((status = nc_def_var(exoid, VAR_N_COMM_DATA_IDX, index_type, 1,
n_dimid, &n_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* now add up all of the nodal communications maps */
ncnt_cmap = 0;
for(iproc=0; iproc < num_procs_in_file; iproc++) {
if (index_type == NC_INT64) {
num_icm = ((int64_t*)n_var_idx)[iproc+1] - ((int64_t*)n_var_idx)[iproc];
} else {
num_icm = ((int*)n_var_idx)[iproc+1] - ((int*)n_var_idx)[iproc];
}
for(icm=0; icm < num_icm; icm++) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
ncnt_cmap += ((int64_t*)node_cmap_node_cnts)[((int64_t*)node_proc_ptrs)[iproc]+icm];
} else {
ncnt_cmap += ((int*)node_cmap_node_cnts)[((int*)node_proc_ptrs)[iproc]+icm];
}
}
}
if ((status = nc_def_dim(exoid, DIM_NCNT_CMAP, ncnt_cmap, &n_dimid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add dimension for \"%s\" of size %"ST_ZU" in file ID %d",
DIM_NCNT_CMAP, ncnt_cmap, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* Define variables for the nodal IDS and processor vectors */
if ((status = nc_def_var(exoid, VAR_N_COMM_NIDS, bulk_type, 1, n_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_NIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_N_COMM_PROC, NC_INT, 1, n_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_PROC, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
} /* End "if (num_n_comm_maps > 0)" */
/*
* Add dimensions for the size of the number of elemental
* communication maps.
*/
if (num_e_comm_maps > 0) {
/* add the communications data index variable */
if ((status = nc_def_var(exoid, VAR_E_COMM_DATA_IDX, index_type, 1,
e_dimid, &e_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* now add up all of the nodal communications maps */
ecnt_cmap = 0;
for(iproc=0; iproc < num_procs_in_file; iproc++) {
if (index_type == NC_INT64) {
num_icm = ((int64_t*)e_var_idx)[iproc+1] - ((int64_t*)e_var_idx)[iproc];
} else {
num_icm = ((int*)e_var_idx)[iproc+1] - ((int*)e_var_idx)[iproc];
}
for(icm=0; icm < num_icm; icm++) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
ecnt_cmap += ((int64_t*)elem_cmap_elem_cnts)[((int64_t*)elem_proc_ptrs)[iproc]+icm];
} else {
ecnt_cmap += ((int*)elem_cmap_elem_cnts)[((int*)elem_proc_ptrs)[iproc]+icm];
}
}
}
/* Add dimensions for elemental communications maps */
if ((status = nc_def_dim(exoid, DIM_ECNT_CMAP, ecnt_cmap, &e_dimid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add dimension for \"%s\" in file ID %d",
DIM_ECNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* Define variables for the element IDS and processor vectors */
if ((status = nc_def_var(exoid, VAR_E_COMM_EIDS, bulk_type, 1, e_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_EIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_E_COMM_PROC, NC_INT, 1, e_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_PROC, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_E_COMM_SIDS, bulk_type, 1, e_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_SIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
} /* End "if (num_e_comm_maps > 0)" */
/* Exit define mode */
ex_leavedef(exoid, func_name);
/* Set the status of the nodal communication maps */
if (num_n_comm_maps > 0) {
/* need to get the two "n_comm_*" variable ids */
if ((status = nc_inq_varid(exoid, VAR_N_COMM_STAT, &n_varid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_N_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the variable ID for the comm map IDs vector */
if ((status = nc_inq_varid(exoid, VAR_N_COMM_IDS, &n_varid[1])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_N_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* reset the index variable */
nl_ncnt_cmap = 0;
for(iproc=0; iproc < num_procs_in_file; iproc++) {
size_t proc_ptr;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
proc_ptr = ((int64_t*)node_proc_ptrs)[iproc];
} else {
proc_ptr = ((int*)node_proc_ptrs)[iproc];
}
if (index_type == NC_INT64) {
num_icm = ((int64_t*)n_var_idx)[iproc+1] - ((int64_t*)n_var_idx)[iproc];
} else {
num_icm = ((int*)n_var_idx)[iproc+1] - ((int*)n_var_idx)[iproc];
}
for(icm=0; icm < num_icm; icm++) {
size_t cnt;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
cnt = ((int64_t*)node_cmap_node_cnts)[proc_ptr+icm];
} else {
cnt = ((int*)node_cmap_node_cnts)[proc_ptr+icm];
}
if (index_type == NC_INT64) {
start[0] = ((int64_t*)n_var_idx)[iproc] + icm;
} else {
start[0] = ((int*)n_var_idx)[iproc] + icm;
}
if (cnt > 0) {
nmstat = 1;
} else {
nmstat = 0;
}
if ((status = nc_put_var1_int(exoid, n_varid[0], start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: unable to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* increment to the next starting position */
nl_ncnt_cmap += cnt;
/* fill the data index variable */
status = nc_put_var1_longlong(exoid, n_varid_idx, start, &nl_ncnt_cmap);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output int elem map index in file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "for(icm=0; icm < num_icm; icm++)" */
if (num_icm > 0) {
/* Output the nodal comm map IDs */
if (index_type == NC_INT64) {
start[0] = ((int64_t*)n_var_idx)[iproc];
} else {
start[0] = ((int*)n_var_idx)[iproc];
}
count[0] = num_icm;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_vara_longlong(exoid, n_varid[1], start, count,
&((long long*)node_cmap_ids)[proc_ptr]);
} else {
status = nc_put_vara_int(exoid, n_varid[1], start, count,
&((int*)node_cmap_ids)[proc_ptr]);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
} /* End "for(iproc=0; iproc < num_procs_in_file; iproc++)" */
/* free up memory for index */
free(n_var_idx);
} /* End "if (num_n_comm_maps > 0)" */
/* Set the status of the elemental communication maps */
if (num_e_comm_maps > 0) {
/* need to get the two "e_comm_*" variables" */
/* Get variable ID for elemental status vector */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_STAT, &e_varid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the variable ID for the elemental comm map IDs vector */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_IDS, &e_varid[1])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* reset the index variable */
nl_ecnt_cmap = 0;
for(iproc=0; iproc < num_procs_in_file; iproc++) {
size_t proc_ptr;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
proc_ptr = ((int64_t*)elem_proc_ptrs)[iproc];
} else {
proc_ptr = ((int*)elem_proc_ptrs)[iproc];
}
if (index_type == NC_INT64) {
num_icm = ((int64_t*)e_var_idx)[iproc+1] - ((int64_t*)e_var_idx)[iproc];
} else {
num_icm = ((int*)e_var_idx)[iproc+1] - ((int*)e_var_idx)[iproc];
}
for(icm=0; icm < num_icm; icm++) {
size_t cnt;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
cnt = ((int64_t*)elem_cmap_elem_cnts)[proc_ptr+icm];
} else {
cnt = ((int*)elem_cmap_elem_cnts)[proc_ptr+icm];
}
if (index_type == NC_INT64) {
start[0] = ((int64_t*)e_var_idx)[iproc] + icm;
} else {
start[0] = ((int*)e_var_idx)[iproc] + icm;
}
if (cnt > 0) {
nmstat = 1;
} else {
nmstat = 0;
}
if ((status = nc_put_var1_int(exoid, e_varid[0], start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: unable to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* increment to the next starting position */
nl_ecnt_cmap += cnt;
/* fill the data index variable */
status = nc_put_var1_longlong(exoid, e_varid_idx, start, &nl_ecnt_cmap);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output int elem map index in file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "for(icm=0; icm < num_icm; icm++)" */
if (num_icm > 0) {
/* Output the elemental comm map IDs */
if (index_type == NC_INT64) {
start[0] = ((int64_t*)e_var_idx)[iproc];
} else {
start[0] = ((int*)e_var_idx)[iproc];
}
count[0] = num_icm;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_vara_longlong(exoid, e_varid[1], start, count,
&((long long*)elem_cmap_ids)[proc_ptr]);
} else {
status = nc_put_vara_int(exoid, e_varid[1], start, count,
&((int*)elem_cmap_ids)[proc_ptr]);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
} /* End "for(iproc=0; iproc < num_procs_in_file; iproc++)" */
free(e_var_idx);
} /* End "if (num_e_comm_maps > 0)" */
return (EX_NOERR);
}
int main(int argc, char *argv[])
{
const char *salsa_cmd_file;
int c;
double g_start_t = second();
bool force_64_bit = false;
int start_proc = 0;
int num_proc = 0;
int subcycles = 0;
int cycle = -1;
while ((c = getopt(argc, argv, "64Vhp:r:s:n:S:c:")) != -1) {
switch (c) {
case 'h':
fprintf(stderr, " usage:\n");
fprintf(stderr, "\tnem_spread [-s <start_proc>] [-n <num_proc>] [-S <subcycles> -c <cycle>] [command_file]\n");
fprintf(stderr, "\t\tDecompose for processors <start_proc> to <start_proc>+<num_proc>\n");
fprintf(stderr, "\t\tDecompose for cycle <cycle> of <subcycle> groups\n");
fprintf(stderr, "\tnem_spread [-V] [-h] (show version or usage info)\n");
fprintf(stderr, "\tnem_spread [command file] [<-p Proc> <-r raid #>]\n");
exit(1);
break;
case 'V':
printf("%s version %s\n", UTIL_NAME, VER_STR);
exit(0);
break;
case 'p': /* Which proc to use? Also for compatability */
break;
case 'r': /* raid number. Seems to be unused; left around for compatability */
break;
case 's': /* Start with processor <x> */
sscanf(optarg, "%d", &start_proc);
break;
case 'n': /* Number of processors to output files for */
sscanf(optarg, "%d", &num_proc);
break;
case '6':
case '4':
force_64_bit = true; /* Force storing output mesh using 64bit integers */
break;
case 'S': /* Number of subcycles to use (see below) */
sscanf(optarg, "%d", &subcycles);
break;
case 'c': /* Which cycle to spread (see below) */
sscanf(optarg, "%d", &cycle);
break;
}
}
if (optind >= argc)
salsa_cmd_file = "nem_spread.inp";
else {
salsa_cmd_file = argv[optind];
}
printf("%s version %s\n", UTIL_NAME, VER_STR);
/* initialize some variables */
ExoFile[0] = '\0';
Exo_LB_File[0] = '\0';
Exo_Res_File[0] = '\0';
Debug_Flag = -1;
Num_Nod_Var = -1;
Num_Elem_Var = -1;
Num_Glob_Var = -1;
Num_Nset_Var = -1;
Num_Sset_Var = -1;
PIO_Info.Dsk_List_Cnt = -1;
PIO_Info.Num_Dsk_Ctrlrs = -1;
PIO_Info.PDsk_Add_Fact = -1;
PIO_Info.Zeros = -1;
PIO_Info.NoSubdirectory = 0;
PIO_Info.Par_Dsk_Root[0] = '\0';
PIO_Info.Par_Dsk_SubDirec[0] = '\0';
PIO_Info.Staged_Writes[0] = '\0';
// Read the ASCII input file and get the name of the mesh file
// so we can determine the floating point and integer word sizes
// needed to instantiate the templates...
if (read_mesh_file_name(salsa_cmd_file) < 0) {
static char yo[] = "nem_spread";
fprintf(stderr,"%s ERROR: Could not read in the the I/O command file"
" \"%s\"!\n", yo, salsa_cmd_file);
exit(1);
}
// Open the mesh file and determine word sizes...
int io_ws = 0;
int cpu_ws = sizeof(float);
float version;
int exoid = ex_open (ExoFile, EX_READ, &cpu_ws, &io_ws, &version);
// See if any 64-bit integers stored on database...
int int64api = 0;
int int64db = ex_int64_status(exoid) & EX_ALL_INT64_DB;
if (int64db != 0) {
int64api = EX_ALL_INT64_API;
}
int status;
if (io_ws == 4) {
if (int64api) {
NemSpread<float, int64_t> spreader;
spreader.io_ws = io_ws;
spreader.int64db = int64db;
spreader.int64api = int64api;
spreader.force64db = force_64_bit;
spreader.Proc_Info[4] = start_proc;
spreader.Proc_Info[5] = num_proc;
status = nem_spread(spreader, salsa_cmd_file, subcycles, cycle);
} else {
NemSpread<float, int> spreader;
spreader.io_ws = io_ws;
spreader.int64db = int64db;
spreader.int64api = int64api;
spreader.force64db = force_64_bit;
spreader.Proc_Info[4] = start_proc;
spreader.Proc_Info[5] = num_proc;
status = nem_spread(spreader, salsa_cmd_file, subcycles, cycle);
}
} else {
if (int64api) {
NemSpread<double, int64_t> spreader;
spreader.io_ws = io_ws;
spreader.int64db = int64db;
spreader.int64api = int64api;
spreader.force64db = force_64_bit;
spreader.Proc_Info[4] = start_proc;
spreader.Proc_Info[5] = num_proc;
status = nem_spread(spreader, salsa_cmd_file, subcycles, cycle);
} else {
NemSpread<double, int> spreader;
spreader.io_ws = io_ws;
spreader.int64db = int64db;
spreader.int64api = int64api;
spreader.force64db = force_64_bit;
spreader.Proc_Info[4] = start_proc;
spreader.Proc_Info[5] = num_proc;
status = nem_spread(spreader, salsa_cmd_file, subcycles, cycle);
}
}
double g_end_t = second() - g_start_t;
printf("The average run time was: %.2fs\n", g_end_t);
ex_close(exoid);
add_to_log(argv[0], g_end_t);
return status;
}
int ex_get_side_set_node_list_len(int exoid,
ex_entity_id side_set_id,
void_int *side_set_node_list_len)
{
size_t i, j;
size_t m;
int64_t num_side_sets, num_elem_blks, num_df, ndim;
size_t list_len = 0;
int64_t tot_num_elem = 0, tot_num_ss_elem = 0;
void_int *elem_blk_ids;
int *ss_elem_ndx = NULL;
int64_t *ss_elem_ndx_64 = NULL;
void_int *side_set_elem_list;
void_int *side_set_side_list;
int elem_ctr;
int status;
struct elem_blk_parm *elem_blk_parms;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
if (ex_int64_status(exoid) & EX_BULK_INT64_API)
*(int64_t*)side_set_node_list_len = 0; /* default value */
else
*(int*)side_set_node_list_len = 0; /* default value */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
/* get the dimensionality of the coordinates; this is necessary to
distinguish between 2d TRIs and 3d TRIs */
ndim = ex_inquire_int(exoid, EX_INQ_DIM);
if (ndim < 0) {
sprintf(errmsg,
"Error: failed to get dimensionality in file id %d",exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return(EX_FATAL);
}
tot_num_elem = ex_inquire_int(exoid, EX_INQ_ELEM);
if (tot_num_elem < 0) {
sprintf(errmsg,
"Error: failed to get total number of elements in file id %d",exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return(EX_FATAL);
}
num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
if (num_elem_blks < 0) {
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return(EX_FATAL);
}
num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS);
if (num_side_sets < 0) {
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return(EX_FATAL);
}
if (num_side_sets == 0) {
sprintf(errmsg,
"Warning: no side sets defined in file id %d",exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,EX_WARN);
return(EX_WARN);
}
/* First determine the # of elements in the side set*/
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = ex_get_side_set_param(exoid,side_set_id,&tot_num_ss_elem,&num_df);
} else {
int tot;
int df;
status = ex_get_side_set_param(exoid,side_set_id,&tot,&df);
tot_num_ss_elem = tot;
num_df = df;
}
if (status != NC_NOERR) {
sprintf(errmsg,
"Error: failed to get number of elements in side set %"PRId64" in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return(EX_FATAL);
}
if (tot_num_ss_elem == 0) /* NULL side set? */
return (EX_NOERR); /* return zero */
/* Minor optimization/kluge -- If num_df is nonzero, or 1 per face
then assume that it matches the number of nodes in the sideset... */
if (num_df > 0 && num_df != tot_num_ss_elem) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API)
*(int64_t*)side_set_node_list_len = num_df;
else
*(int*)side_set_node_list_len = num_df;
return(EX_NOERR);
}
/* Allocate space for the side set element list */
{
int int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API)
int_size = sizeof(int64_t);
if (!(side_set_elem_list=malloc(tot_num_ss_elem*int_size))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set element list for file id %d",
exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return (EX_FATAL);
}
/* Allocate space for the side set side list */
if (!(side_set_side_list=malloc(tot_num_ss_elem*int_size))) {
safe_free(side_set_elem_list);
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set side list for file id %d",
exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set(exoid, side_set_id,
side_set_elem_list, side_set_side_list) != NC_NOERR) {
safe_free(side_set_elem_list);
safe_free(side_set_side_list);
sprintf(errmsg,
"Error: failed to get side set %"PRId64" in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return (EX_FATAL);
}
/* Allocate space for the ss element index array */
if (int_size == sizeof(int64_t)) {
ss_elem_ndx_64=malloc(tot_num_ss_elem*int_size);
} else {
ss_elem_ndx =malloc(tot_num_ss_elem*int_size);
}
if (ss_elem_ndx_64==NULL && ss_elem_ndx == NULL) {
safe_free(side_set_elem_list);
safe_free(side_set_side_list);
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set elem sort array for file id %d",
exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return (EX_FATAL);
}
}
/* Sort side set element list into index array - non-destructive */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
for (i=0;i<tot_num_ss_elem;i++)
ss_elem_ndx_64[i] = i; /* init index array to current position */
ex_iqsort64(side_set_elem_list, ss_elem_ndx_64,tot_num_ss_elem);
} else {
for (i=0;i<tot_num_ss_elem;i++)
ss_elem_ndx[i] = i; /* init index array to current position */
ex_iqsort(side_set_elem_list, ss_elem_ndx,tot_num_ss_elem);
}
/* Allocate space for the element block ids */
{
int int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
int_size = sizeof(int64_t);
}
if (!(elem_blk_ids=malloc(num_elem_blks*int_size))) {
exerrval = EX_MEMFAIL;
safe_free(ss_elem_ndx);
safe_free(ss_elem_ndx_64);
safe_free(side_set_side_list);
safe_free(side_set_elem_list);
sprintf(errmsg,
"Error: failed to allocate space for element block ids for file id %d",
exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return (EX_FATAL);
}
}
if (ex_get_elem_blk_ids(exoid, elem_blk_ids)) {
safe_free(elem_blk_ids);
safe_free(ss_elem_ndx);
safe_free(ss_elem_ndx_64);
safe_free(side_set_side_list);
safe_free(side_set_elem_list);
sprintf(errmsg,
"Error: failed to get element block ids in file id %d",
exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,EX_MSG);
return(EX_FATAL);
}
/* Allocate space for the element block params */
if (!(elem_blk_parms=malloc(num_elem_blks*sizeof(struct elem_blk_parm)))) {
safe_free(elem_blk_ids);
safe_free(ss_elem_ndx);
safe_free(ss_elem_ndx_64);
safe_free(side_set_side_list);
safe_free(side_set_elem_list);
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for element block params for file id %d",
exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,exerrval);
return (EX_FATAL);
}
elem_ctr = 0;
for (i=0; i<num_elem_blks; i++) {
ex_block block;
block.type = EX_ELEM_BLOCK;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
block.id = ((int64_t*)elem_blk_ids)[i];
} else {
block.id = ((int*)elem_blk_ids)[i];
}
/* read in an element block parameter */
if ((ex_get_block_param (exoid, &block)) != NC_NOERR) {
safe_free(elem_blk_parms);
safe_free(elem_blk_ids);
safe_free(ss_elem_ndx);
safe_free(ss_elem_ndx_64);
safe_free(side_set_side_list);
safe_free(side_set_elem_list);
sprintf(errmsg,
"Error: failed to get element block %"PRId64" parameters in file id %d",
block.id, exoid);
ex_err("ex_get_side_set_node_list_len",errmsg,EX_MSG);
return(EX_FATAL);
}
elem_blk_parms[i].num_elem_in_blk = block.num_entry;
elem_blk_parms[i].num_nodes_per_elem = block.num_nodes_per_entry;
elem_blk_parms[i].num_attr = block.num_attribute;
elem_blk_parms[i].elem_blk_id = block.id;
for (m=0; m < strlen(block.topology); m++) {
elem_blk_parms[i].elem_type[m] = toupper(block.topology[m]);
}
elem_blk_parms[i].elem_type[m] = '\0';
if (strncmp(elem_blk_parms[i].elem_type,"CIRCLE",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_CIRCLE;
/* set side set node stride */
elem_blk_parms[i].num_nodes_per_side[0] = 1;
}
else if (strncmp(elem_blk_parms[i].elem_type,"SPHERE",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_SPHERE;
/* set side set node stride */
elem_blk_parms[i].num_nodes_per_side[0] = 1;
}
else if (strncmp(elem_blk_parms[i].elem_type,"QUAD",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_QUAD;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 4)
elem_blk_parms[i].num_nodes_per_side[0] = 2;
else if (elem_blk_parms[i].num_nodes_per_elem == 5)
elem_blk_parms[i].num_nodes_per_side[0] = 2;
else
elem_blk_parms[i].num_nodes_per_side[0] = 3;
}
else if (strncmp(elem_blk_parms[i].elem_type,"TRIANGLE",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_TRIANGLE;
/* determine side set node stride */
if (ndim == 2) /* 2d TRIs */
{
if (elem_blk_parms[i].num_nodes_per_elem == 3)
elem_blk_parms[i].num_nodes_per_side[0] = 2;
else
elem_blk_parms[i].num_nodes_per_side[0] = 3;
}
else if (ndim == 3) /* 3d TRIs */
{ /* set the default number of nodes per side; catch exceptions later */
if (elem_blk_parms[i].num_nodes_per_elem == 3)
elem_blk_parms[i].num_nodes_per_side[0] = 3;
else
elem_blk_parms[i].num_nodes_per_side[0] = 6;
}
}
else if (strncmp(elem_blk_parms[i].elem_type,"SHELL",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_SHELL;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 2) /* KLUDGE for 2D Shells*/
elem_blk_parms[i].num_nodes_per_side[0] = 2;
else if (elem_blk_parms[i].num_nodes_per_elem == 4)
elem_blk_parms[i].num_nodes_per_side[0] = 4;
else
elem_blk_parms[i].num_nodes_per_side[0] = 8;
}
else if (strncmp(elem_blk_parms[i].elem_type,"HEX",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_HEX;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 8)
elem_blk_parms[i].num_nodes_per_side[0] = 4;
else if (elem_blk_parms[i].num_nodes_per_elem == 9)
elem_blk_parms[i].num_nodes_per_side[0] = 4;
else if (elem_blk_parms[i].num_nodes_per_elem == 12) /* HEXSHELL */
elem_blk_parms[i].num_nodes_per_side[0] = 4;
else if (elem_blk_parms[i].num_nodes_per_elem == 27)
elem_blk_parms[i].num_nodes_per_side[0] = 9;
else
elem_blk_parms[i].num_nodes_per_side[0] = 8;
}
else if (strncmp(elem_blk_parms[i].elem_type,"TETRA",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_TETRA;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 4)
elem_blk_parms[i].num_nodes_per_side[0] = 3;
else if (elem_blk_parms[i].num_nodes_per_elem == 8)
elem_blk_parms[i].num_nodes_per_side[0] = 4;
else
elem_blk_parms[i].num_nodes_per_side[0] = 6;
}
else if (strncmp(elem_blk_parms[i].elem_type,"WEDGE",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_WEDGE;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 6)
elem_blk_parms[i].num_nodes_per_side[0] = 4;
else
elem_blk_parms[i].num_nodes_per_side[0] = 8;
}
else if (strncmp(elem_blk_parms[i].elem_type,"PYRAMID",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_PYRAMID;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 5)
elem_blk_parms[i].num_nodes_per_side[0] = 4;
else
elem_blk_parms[i].num_nodes_per_side[0] = 8;
}
else if (strncmp(elem_blk_parms[i].elem_type,"BEAM",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_BEAM;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 2)
elem_blk_parms[i].num_nodes_per_side[0] = 2;
else
elem_blk_parms[i].num_nodes_per_side[0] = 3;
}
else if ( (strncmp(elem_blk_parms[i].elem_type,"TRUSS",3) == 0) ||
(strncmp(elem_blk_parms[i].elem_type,"BAR",3) == 0) ||
(strncmp(elem_blk_parms[i].elem_type,"EDGE",3) == 0))
{
elem_blk_parms[i].elem_type_val = EX_EL_TRUSS;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 2)
elem_blk_parms[i].num_nodes_per_side[0] = 2;
else
elem_blk_parms[i].num_nodes_per_side[0] = 3;
}
else if (strncmp(elem_blk_parms[i].elem_type,"NULL",3) == 0)
{
elem_blk_parms[i].elem_type_val = EX_EL_NULL_ELEMENT;
elem_blk_parms[i].num_nodes_per_side[0] = 0;
elem_blk_parms[i].num_elem_in_blk = 0;
}
else
{ /* unsupported element type; no problem if no sides specified for
this element block */
elem_blk_parms[i].elem_type_val = EX_EL_UNK;
elem_blk_parms[i].num_nodes_per_side[0] = 0;
}
elem_ctr += elem_blk_parms[i].num_elem_in_blk;
elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */
}
/* Walk through element list and keep a running count of the node length */
list_len = 0;
for (i=0;i<tot_num_ss_elem;i++)
{
size_t elem;
size_t side;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
elem = ((int64_t*)side_set_elem_list)[i];
side = ((int64_t*)side_set_side_list)[i];
} else {
elem = ((int*)side_set_elem_list)[i];
side = ((int*)side_set_side_list)[i];
}
for (j=0; j<num_elem_blks; j++)
{
if (elem_blk_parms[j].elem_type_val != EX_EL_NULL_ELEMENT)
if (elem <= elem_blk_parms[j].elem_ctr)
break; /* stop because we found the parameters for this element */
}
if (j >= num_elem_blks)
{
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid element number %"ST_ZU" found in side set %"PRId64" in file %d",
elem, side_set_id, exoid);
safe_free(elem_blk_parms);
safe_free(elem_blk_ids);
safe_free(ss_elem_ndx);
safe_free(ss_elem_ndx_64);
safe_free(side_set_side_list);
safe_free(side_set_elem_list);
ex_err("ex_get_side_set_node_list_len",errmsg,EX_MSG);
return (EX_FATAL);
}
/* Update *side_set_node_list_len (which points to next node in chain */
/* WEDGEs with 3 node sides (side 4 or 5) are special cases */
if (elem_blk_parms[j].elem_type_val == EX_EL_WEDGE &&
(side == 4 || side == 5))
{
if (elem_blk_parms[j].num_nodes_per_elem == 6)
list_len += 3; /* 3 node side */
else
list_len += 6; /* 6 node side */
}
/* PYRAMIDSs with 3 node sides (sides 1,2,3,4) are also special */
else if (elem_blk_parms[j].elem_type_val == EX_EL_PYRAMID &&
(side < 5))
{
if (elem_blk_parms[j].num_nodes_per_elem == 5)
list_len += 3; /* 3 node side */
else
list_len += 6; /* 6 node side */
}
/* side numbers 3,4,5,6 for SHELLs are also special */
else if (elem_blk_parms[j].elem_type_val == EX_EL_SHELL &&
(side > 2 ))
{
if (elem_blk_parms[j].num_nodes_per_elem == 4)
list_len += 2; /* 2 node side */
else
list_len += 3; /* 3 node side */
}
/* sides 3, 4, and 5 of 3d TRIs are special cases */
else if (elem_blk_parms[j].elem_type_val == EX_EL_TRIANGLE &&
ndim == 3 && side > 2 )
{
if (elem_blk_parms[j].num_nodes_per_elem == 3) /* 3-node TRI */
list_len += 2; /* 2 node side */
else /* 6-node TRI */
list_len += 3; /* 3 node side */
}
else if (elem_blk_parms[j].elem_type_val == EX_EL_UNK)
{
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: %s in elem block %"PRId64" is an unsupported element type",
elem_blk_parms[i].elem_type, elem_blk_parms[i].elem_blk_id);
safe_free(elem_blk_parms);
safe_free(elem_blk_ids);
safe_free(ss_elem_ndx);
safe_free(ss_elem_ndx_64);
safe_free(side_set_side_list);
safe_free(side_set_elem_list);
ex_err("ex_get_side_set_node_list_len",errmsg,EX_MSG);
return (EX_FATAL);
}
else /* all other element types */
list_len += elem_blk_parms[j].num_nodes_per_side[0];
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API)
*(int64_t*)side_set_node_list_len = list_len;
else
*(int*)side_set_node_list_len = list_len;
/* All done: release element block ids array,
element block parameters array, and side set element index array */
safe_free(elem_blk_ids);
safe_free(elem_blk_parms);
safe_free(ss_elem_ndx);
safe_free(ss_elem_ndx_64);
safe_free(side_set_side_list);
safe_free(side_set_elem_list);
return(EX_NOERR);
}
int ex_put_processor_node_maps(int exoid,
void_int *node_mapi,
void_int *node_mapb,
void_int *node_mape,
int proc_id
)
{
const char *func_name="ex_put_processor_node_maps";
int status, varid, dimid;
char ftype[2];
size_t start[1], count[1];
int64_t varidx[2];
int nmstat;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/* Get the file type */
if (ex_get_file_type(exoid, ftype) != EX_NOERR) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: unable to find file type for file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the status of this node map */
if ((status = nc_inq_varid(exoid, VAR_INT_N_STAT, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" from file ID %d",
VAR_INT_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (ftype[0] == 'p')
start[0] = 0;
else
start[0] = proc_id;
if ((status = nc_get_var1_int(exoid, varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get status for \"%s\" from file %d",
VAR_INT_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Write out the internal node-number map */
if (nmstat == 1) {
/* get the index */
if (ex_get_idx(exoid, VAR_NODE_MAP_INT_IDX, varidx, proc_id) == -1) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_NODE_MAP_INT_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* check if I need to get the dimension */
if (varidx[1] == -1) {
if ((status = nc_inq_dimid(exoid, DIM_NUM_INT_NODES, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find dimension ID for \"%s\" in file ID %d",
DIM_NUM_INT_NODES, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_INT_NODES, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
varidx[1] = count[0];
}
if ((status = nc_inq_varid(exoid, VAR_NODE_MAP_INT, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_NODE_MAP_INT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
start[0] = varidx[0];
count[0] = varidx[1] - varidx[0];
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, node_mapi);
} else {
status = nc_put_vara_int(exoid, varid, start, count, node_mapi);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable \"%s\" in file ID %d",
VAR_NODE_MAP_INT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (nmstat == 1)" */
/* Get the status of this node map */
if ((status = nc_inq_varid(exoid, VAR_BOR_N_STAT, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" from file ID %d",
VAR_BOR_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (ftype[0] == 'p')
start[0] = 0;
else
start[0] = proc_id;
if ((status = nc_get_var1_int(exoid, varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get status for \"%s\" from file %d",
VAR_BOR_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* Write out the border node-number map */
/* get the index */
if (ex_get_idx(exoid, VAR_NODE_MAP_BOR_IDX, varidx, proc_id) == -1) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_NODE_MAP_BOR_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* check if I need to get the dimension */
if (varidx[1] == -1) {
if ((status = nc_inq_dimid(exoid, DIM_NUM_BOR_NODES, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find dimension ID for \"%s\" in file ID %d",
DIM_NUM_BOR_NODES, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_BOR_NODES, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
varidx[1] = count[0];
}
if ((status = nc_inq_varid(exoid, VAR_NODE_MAP_BOR, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_NODE_MAP_BOR, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the map */
start[0] = varidx[0];
count[0] = varidx[1] - varidx[0];
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, node_mapb);
} else {
status = nc_put_vara_int(exoid, varid, start, count, node_mapb);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable \"%s\" in file ID %d",
VAR_NODE_MAP_BOR, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (nmstat == 1)" */
/* Get the status of this node map */
if ((status = nc_inq_varid(exoid, VAR_EXT_N_STAT, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" from file ID %d",
VAR_EXT_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (ftype[0] == 'p')
start[0] = 0;
else
start[0] = proc_id;
if ((status = nc_get_var1_int(exoid, varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get status for \"%s\" from file %d",
VAR_EXT_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* Write out the external node-number map */
if (ex_get_idx(exoid, VAR_NODE_MAP_EXT_IDX, varidx, proc_id) == -1) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_NODE_MAP_EXT_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* check if I need to get the dimension */
if (varidx[1] == -1) {
if ((status = nc_inq_dimid(exoid, DIM_NUM_EXT_NODES, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find dimension ID for \"%s\" in file ID %d",
DIM_NUM_EXT_NODES, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_EXT_NODES, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
varidx[1] = count[0];
}
if ((status = nc_inq_varid(exoid, VAR_NODE_MAP_EXT, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_NODE_MAP_EXT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the map */
start[0] = varidx[0];
count[0] = varidx[1] - varidx[0];
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, node_mape);
} else {
status = nc_put_vara_int(exoid, varid, start, count, node_mape);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable \"%s\" in file ID %d",
VAR_NODE_MAP_EXT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (nmstat == 1)" */
return (EX_NOERR);
}
int ex_put_set(int exoid, ex_entity_type set_type, ex_entity_id set_id,
const void_int *set_entry_list, const void_int *set_extra_list)
{
int dimid, status;
int entry_list_id, extra_list_id, set_id_ndx;
char errmsg[MAX_ERR_LENGTH];
char *entryptr = NULL;
char *extraptr = NULL;
exerrval = 0; /* clear error code */
ex_check_valid_file_id(exoid);
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: no %ss defined in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_set", errmsg, exerrval);
return (EX_FATAL);
}
/* Lookup index of set id in VAR_*S_IDS array */
set_id_ndx = ex_id_lkup(exoid, set_type, set_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no data allowed for NULL %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s id %" PRId64 " in VAR_*S_IDS array in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set", errmsg, exerrval);
return (EX_FATAL);
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
}
else if (set_type == EX_EDGE_SET) {
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
}
else if (set_type == EX_ELEM_SET) {
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
}
/* inquire id's of previously defined variables */
if ((status = nc_inq_varid(exoid, entryptr, &entry_list_id)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate entry list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set", errmsg, exerrval);
return (EX_FATAL);
}
/* only do for edge, face and side sets */
if (extraptr) {
if ((status = nc_inq_varid(exoid, extraptr, &extra_list_id)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate extra list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set", errmsg, exerrval);
return (EX_FATAL);
}
}
/* write out the entry list and extra list arrays */
if (set_entry_list != NULL) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_var_longlong(exoid, entry_list_id, set_entry_list);
}
else {
status = nc_put_var_int(exoid, entry_list_id, set_entry_list);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store entry list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set", errmsg, exerrval);
return (EX_FATAL);
}
}
/* only do for edge, face and side sets */
if (extraptr && set_extra_list != NULL) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_var_longlong(exoid, extra_list_id, set_extra_list);
}
else {
status = nc_put_var_int(exoid, extra_list_id, set_extra_list);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store extra list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set", errmsg, exerrval);
return (EX_FATAL);
}
}
/* warn if extra data was sent in for node sets and elem sets */
if ((set_type == EX_NODE_SET || set_type == EX_ELEM_SET) && set_extra_list != NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: extra list was ignored for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set", errmsg, EX_MSG);
return (EX_WARN);
}
return (EX_NOERR);
}
int ex_put_prop_array(int exoid, ex_entity_type obj_type, const char *prop_name,
const void_int *values)
{
int oldfill = 0;
int temp;
int num_props, i, propid, dimid, dims[1], status;
int found = EX_FALSE;
int int_type;
size_t num_obj;
char * name;
char tmpstr[MAX_STR_LENGTH + 1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* check if property has already been created */
num_props = ex_get_num_props(exoid, obj_type);
/* inquire id of previously defined dimension (number of objects) */
status = ex_get_dimension(exoid, ex_dim_num_objects(obj_type), ex_name_of_object(obj_type),
&num_obj, &dimid, "ex_put_prop_array");
if (status != NC_NOERR) {
return status;
}
for (i = 1; i <= num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK: name = VAR_EB_PROP(i); break;
case EX_FACE_BLOCK: name = VAR_FA_PROP(i); break;
case EX_EDGE_BLOCK: name = VAR_ED_PROP(i); break;
case EX_NODE_SET: name = VAR_NS_PROP(i); break;
case EX_EDGE_SET: name = VAR_ES_PROP(i); break;
case EX_FACE_SET: name = VAR_FS_PROP(i); break;
case EX_ELEM_SET: name = VAR_ELS_PROP(i); break;
case EX_SIDE_SET: name = VAR_SS_PROP(i); break;
case EX_ELEM_MAP: name = VAR_EM_PROP(i); break;
case EX_FACE_MAP: name = VAR_FAM_PROP(i); break;
case EX_EDGE_MAP: name = VAR_EDM_PROP(i); break;
case EX_NODE_MAP: name = VAR_NM_PROP(i); break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property array id in file id %d",
exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH + 1);
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property name in file id %d", exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0) {
found = EX_TRUE;
break;
}
}
/* if property array has not been created, create it */
if (!found) {
/* put netcdf file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to place file id %d into define mode", exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
/* create a variable with a name xx_prop#, where # is the new number */
/* of properties */
switch (obj_type) {
case EX_ELEM_BLOCK: name = VAR_EB_PROP(num_props + 1); break;
case EX_FACE_BLOCK: name = VAR_FA_PROP(num_props + 1); break;
case EX_EDGE_BLOCK: name = VAR_ED_PROP(num_props + 1); break;
case EX_NODE_SET: name = VAR_NS_PROP(num_props + 1); break;
case EX_EDGE_SET: name = VAR_ES_PROP(num_props + 1); break;
case EX_FACE_SET: name = VAR_FS_PROP(num_props + 1); break;
case EX_ELEM_SET: name = VAR_ELS_PROP(num_props + 1); break;
case EX_SIDE_SET: name = VAR_SS_PROP(num_props + 1); break;
case EX_ELEM_MAP: name = VAR_EM_PROP(num_props + 1); break;
case EX_FACE_MAP: name = VAR_FAM_PROP(num_props + 1); break;
case EX_EDGE_MAP: name = VAR_EDM_PROP(num_props + 1); break;
case EX_NODE_MAP: name = VAR_NM_PROP(num_props + 1); break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
dims[0] = dimid;
nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */
int_type = NC_INT;
if (ex_int64_status(exoid) & EX_IDS_INT64_DB) {
int_type = NC_INT64;
}
if ((status = nc_def_var(exoid, name, int_type, 1, dims, &propid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create property array variable in file id %d", exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
/* store property name as attribute of property array variable */
if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME, strlen(prop_name) + 1,
prop_name)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property name %s in file id %d",
prop_name, exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
/* leave define mode */
if ((status = nc_enddef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to leave define mode in file id %d", exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
}
/* put num_obj values in property array */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, propid, values);
}
else {
status = nc_put_var_int(exoid, propid, values);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property values in file id %d", exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
if (nc_enddef(exoid) != NC_NOERR) { /* exit define mode */
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid);
ex_err("ex_put_prop_array", errmsg, exerrval);
}
return (EX_FATAL);
}
int ex_get_prop (int exoid,
ex_entity_type obj_type,
ex_entity_id obj_id,
const char *prop_name,
void_int *value)
{
int status;
int num_props, i, propid;
int found = EX_FALSE;
size_t start[1];
char name[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_STR_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* open appropriate variable, depending on obj_type and prop_name */
num_props = ex_get_num_props(exoid,obj_type);
for (i=1; i<=num_props; i++) {
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_EDGE_BLOCK:
strcpy (name, VAR_ED_PROP(i));
break;
case EX_FACE_BLOCK:
strcpy (name, VAR_FA_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_EDGE_SET:
strcpy (name, VAR_ES_PROP(i));
break;
case EX_FACE_SET:
strcpy (name, VAR_FS_PROP(i));
break;
case EX_ELEM_SET:
strcpy (name, VAR_ELS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_FACE_MAP:
strcpy (name, VAR_FAM_PROP(i));
break;
case EX_EDGE_MAP:
strcpy (name, VAR_EDM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate property array %s in file id %d",
name, exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH+1);
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0) {
found = EX_TRUE;
break;
}
}
/* if property is not found, return warning */
if (!found) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: %s property %s not defined in file id %d",
ex_name_of_object(obj_type), prop_name, exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_WARN);
}
/* find index into property array using obj_id; read value from property */
/* array at proper index; ex_id_lkup returns an index that is 1-based, */
/* but netcdf expects 0-based arrays so subtract 1 */
start[0] = ex_id_lkup (exoid, obj_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: %s id %"PRId64" is NULL in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_prop",errmsg,EX_NULLENTITY);
return (EX_WARN);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate id %"PRId64" in %s property array in file id %d",
obj_id, ex_name_of_object(obj_type), exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_FATAL);
}
}
start[0] = start[0] - 1;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
long long l_val;
status = nc_get_var1_longlong (exoid, propid, start, &l_val);
if (status == NC_NOERR) {
int64_t *val = (int64_t*)value;
*val = l_val;
}
} else {
int i_val;
status = nc_get_var1_int (exoid, propid, start, &i_val);
if (status == NC_NOERR) {
int *val = (int*)value;
*val = i_val;
}
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to read value in %s property array in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
/*!
* writes a map; this is a vector of integers of length number of mesh
* objects of that type (element, node, face, edge)
*/
int ex_put_partial_num_map (int exoid,
ex_entity_type map_type,
ex_entity_id map_id,
int64_t ent_start,
int64_t ent_count,
const void_int *map)
{
int status;
int dimid, varid, map_ndx, map_exists;
size_t start[1];
size_t num_maps, num_mobj, count[1];
int cur_num_maps;
char errmsg[MAX_ERR_LENGTH];
const char* dnumentries;
const char* dnummaps;
const char* vmapids;
const char* vmap;
exerrval = 0; /* clear error code */
switch ( map_type ) {
case EX_NODE_MAP:
dnumentries = DIM_NUM_NODES;
dnummaps = DIM_NUM_NM;
vmapids = VAR_NM_PROP(1);
break;
case EX_EDGE_MAP:
dnumentries = DIM_NUM_EDGE;
dnummaps = DIM_NUM_EDM;
vmapids = VAR_EDM_PROP(1);
break;
case EX_FACE_MAP:
dnumentries = DIM_NUM_FACE;
dnummaps = DIM_NUM_FAM;
vmapids = VAR_FAM_PROP(1);
break;
case EX_ELEM_MAP:
dnumentries = DIM_NUM_ELEM;
dnummaps = DIM_NUM_EM;
vmapids = VAR_EM_PROP(1);
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg,
"Error: Bad map type (%d) specified for file id %d",
map_type, exoid );
ex_err( "ex_put_num_map", errmsg, exerrval );
return (EX_FATAL);
}
/* Make sure the file contains entries */
if (nc_inq_dimid (exoid, dnumentries, &dimid) != NC_NOERR ) {
return (EX_NOERR);
}
/* first check if any maps are specified */
if ((status = nc_inq_dimid (exoid, dnummaps, &dimid)) != NC_NOERR )
{
exerrval = status;
sprintf(errmsg,
"Error: no %ss specified in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate map id entry */
ex_id_lkup(exoid,map_type,map_id);
if (exerrval == EX_LOOKUPFAIL) { /* did not find the map id */
map_exists = 0; /* Map is being defined */
} else {
map_exists = 1; /* A portion of this map has already been written */
}
/* Check for duplicate map id entry */
if (!map_exists) {
/* Get number of maps initialized for this file */
if ((status = nc_inq_dimlen(exoid,dimid,&num_maps)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of maps defined using a
counter stored in a linked list keyed by exoid. NOTE:
ex_get_file_item is used to find the number of element maps for a
specific file and returns that value.
*/
cur_num_maps = ex_get_file_item(exoid, ex_get_counter_list(map_type));
if (cur_num_maps >= (int)num_maps) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%"ST_ZU") specified in file id %d",
ex_name_of_object(map_type),num_maps,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is used to find the number of element maps
for a specific file and returns that value incremented. */
cur_num_maps = ex_inc_file_item(exoid, ex_get_counter_list(map_type));
} else {
map_ndx = ex_id_lkup(exoid,map_type,map_id);
cur_num_maps = map_ndx-1;
}
/* determine number of elements */
if ((status = nc_inq_dimid(exoid, dnumentries, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: couldn't determine number of mesh objects in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_mobj)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of mesh objects in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (ent_start <= 0 || ent_start > num_mobj) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: start count is invalid in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
if (ent_count < 0) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: Invalid count value in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
if (ent_start+ent_count-1 > num_mobj) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: start+count-1 is larger than mesh object count in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* write out information to previously defined variable */
/* first get id of variable */
if ((status = nc_inq_varid (exoid, vmapids, &varid)) == -1)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out map id */
if (!map_exists) {
start[0] = cur_num_maps;
{
if ((status = nc_put_var1_longlong(exoid, varid, start, (long long*)&map_id)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" in file id %d",
ex_name_of_object(map_type),map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
}
}
switch ( map_type ) {
case EX_NODE_MAP:
vmap = VAR_NODE_MAP(cur_num_maps+1);
break;
case EX_EDGE_MAP:
vmap = VAR_EDGE_MAP(cur_num_maps+1);
break;
case EX_FACE_MAP:
vmap = VAR_FACE_MAP(cur_num_maps+1);
break;
case EX_ELEM_MAP:
vmap = VAR_ELEM_MAP(cur_num_maps+1);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized map type in switch: %d in file id %d",
map_type,exoid);
ex_err("ex_putt_partial_one_attr",errmsg,EX_MSG);
return (EX_FATAL);
}
/* locate variable array in which to store the map */
if ((status = nc_inq_varid(exoid,vmap, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %"PRId64" in file id %d",
ex_name_of_object(map_type),map_id,exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* write out the map */
start[0] = ent_start-1;
count[0] = ent_count;
if (count[0] == 0)
start[0] = 0;
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, map);
} else {
status = nc_put_vara_int(exoid, varid, start, count, map);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_cmap_params(int exoid,
void_int *node_cmap_ids,
void_int *node_cmap_node_cnts,
void_int *elem_cmap_ids,
void_int *elem_cmap_elem_cnts,
int processor
)
{
const char *func_name="ex_get_cmap_params";
size_t cnt, num_n_comm_maps, num_e_comm_maps, start[1], count[1];
int64_t cmap_info_idx[2], cmap_data_idx[2];
int nmstat;
int status, map_idx, varid, dimid;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/*****************************************************************************/
/*****************************************************************************/
/* Nodal communication map(s) */
/*****************************************************************************/
/*****************************************************************************/
/* get the cmap information variables index */
if (ex_get_idx(exoid, VAR_N_COMM_INFO_IDX, cmap_info_idx, processor) == -1) {
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_N_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the number of nodal communications maps in the file */
if ((status = nc_inq_dimid(exoid, DIM_NUM_N_CMAPS, &dimid)) == NC_NOERR) {
/* check if I need to get the dimension of the nodal comm map */
if (cmap_info_idx[1] == -1) {
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_N_CMAPS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* set the end value for the node map */
cmap_info_idx[1] = count[0];
} /* End "if (cmap_info_idx[1] == -1) */
num_n_comm_maps = cmap_info_idx[1] - cmap_info_idx[0];
if (num_n_comm_maps > 0) {
count[0] = num_n_comm_maps;
/* Get the variable ID for the vector of nodal comm map IDs */
if ((status = nc_inq_varid(exoid, VAR_N_COMM_IDS, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable ID for \"%s\" in file ID %d",
VAR_N_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the vector of nodal communication map IDs */
if (node_cmap_ids != NULL) {
start[0] = cmap_info_idx[0];
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_vara_longlong(exoid, varid, start, count, node_cmap_ids);
} else {
status = nc_get_vara_int(exoid, varid, start, count, node_cmap_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_N_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, VAR_N_COMM_STAT, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" from file ID %d",
VAR_N_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (node_cmap_node_cnts != NULL) {
/* Get the node counts in each of the nodal communication maps */
for(cnt=0; cnt < num_n_comm_maps; cnt++) {
int64_t cmap_id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
cmap_id = ((int64_t*)node_cmap_ids)[cnt];
} else {
cmap_id = ((int*)node_cmap_ids)[cnt];
}
if ((map_idx=ne_id_lkup(exoid, VAR_N_COMM_IDS, cmap_info_idx, cmap_id)) < 0) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: failed to find nodal comm map with ID %"PRId64" in file ID %d",
cmap_id, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Check the status of the node map */
start[0] = map_idx;
if ((status = nc_get_var1_int(exoid, varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get status for \"%s\" from file ID %d",
VAR_N_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* get the cmap information variables index */
if (ex_get_idx(exoid, VAR_N_COMM_DATA_IDX, cmap_data_idx,
map_idx) == -1) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_N_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (cmap_data_idx[1] == -1) {
/*
* Find the dimension ID of the variable containing the
* node count
*/
if ((status = nc_inq_dimid(exoid, DIM_NCNT_CMAP, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find dimension ID for \"%s\" in file ID %d",
DIM_NCNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Find the value of the number of nodes in this nodal comm map */
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NCNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
cmap_data_idx[1] = count[0];
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
((int64_t*)node_cmap_node_cnts)[cnt] = cmap_data_idx[1] - cmap_data_idx[0];
} else {
((int*)node_cmap_node_cnts)[cnt] = cmap_data_idx[1] - cmap_data_idx[0];
}
}
else
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
((int64_t*)node_cmap_node_cnts)[cnt] = 0;
} else {
((int*)node_cmap_node_cnts)[cnt] = 0;
}
} /* "for(cnt=0; cnt < num_n_comm_maps; cnt++)" */
} /* "if (node_cmap_node_cnts != NULL)" */
} /* "if (node_cmap_ids != NULL)" */
} /* "if (num_n_comm_maps > 0)" */
} /* End "if ((dimid = nc_inq_dimid(exoid, DIM_NUM_N_CMAPS)) != -1)" */
/*****************************************************************************/
/*****************************************************************************/
/* Elemental communication map(s) */
/*****************************************************************************/
/*****************************************************************************/
/* get the cmap information variables index */
if (ex_get_idx(exoid, VAR_E_COMM_INFO_IDX, cmap_info_idx, processor) == -1) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_E_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the number of elemental communications maps in the file */
if ((status = nc_inq_dimid(exoid, DIM_NUM_E_CMAPS, &dimid)) == NC_NOERR) {
/* check if I need to get the dimension of the nodal comm map */
if (cmap_info_idx[1] == -1) {
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_E_CMAPS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* set the end value for the node map */
cmap_info_idx[1] = count[0];
} /* End "if (cmap_info_idx[1] == -1) */
num_e_comm_maps = cmap_info_idx[1] - cmap_info_idx[0];
if (num_e_comm_maps > 0) {
count[0] = num_e_comm_maps;
/* Get the variable ID for the vector of nodal comm map IDs */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_IDS, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable ID for \"%s\" in file ID %d",
VAR_E_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the vector of elemental communication map IDs */
if (elem_cmap_ids != NULL) {
start[0] = cmap_info_idx[0];
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_vara_longlong(exoid, varid, start, count, elem_cmap_ids);
} else {
status = nc_get_vara_int(exoid, varid, start, count, elem_cmap_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_E_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, VAR_E_COMM_STAT, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" from file ID %d",
VAR_E_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (elem_cmap_elem_cnts != NULL) {
/*
* Get the element counts in each of the elemental
* communication maps
*/
for(cnt=0; cnt < num_e_comm_maps; cnt++) {
int64_t cmap_id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
cmap_id = ((int64_t*)elem_cmap_ids)[cnt];
} else {
cmap_id = ((int*)elem_cmap_ids)[cnt];
}
if ((map_idx=ne_id_lkup(exoid, VAR_E_COMM_IDS, cmap_info_idx,
cmap_id)) < 0) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: failed to find elemental comm map with ID %"PRId64" in file ID %d",
cmap_id, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Check the status of the requested elemental map */
start[0] = map_idx;
if ((status = nc_get_var1_int(exoid, varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get status for \"%s\" from file ID %d",
VAR_E_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* get the cmap information variables index */
if (ex_get_idx(exoid, VAR_E_COMM_DATA_IDX, cmap_data_idx,
map_idx) == -1) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find index variable, \"%s\", in file ID %d",
VAR_E_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (cmap_data_idx[1] == -1) {
/*
* Find the dimension ID of the variable containing the
* element count
*/
if ((status = nc_inq_dimid(exoid, DIM_ECNT_CMAP, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find dimension ID for \"%s\" in file ID %d",
DIM_ECNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/*
* Find the value of the number of elements in this elemental
* comm map
*/
if ((status = nc_inq_dimlen(exoid, dimid, count)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_ECNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
cmap_data_idx[1] = count[0];
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
((int64_t*)elem_cmap_elem_cnts)[cnt] = cmap_data_idx[1] - cmap_data_idx[0];
} else {
((int*)elem_cmap_elem_cnts)[cnt] = cmap_data_idx[1] - cmap_data_idx[0];
}
}
else
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
((int64_t*)elem_cmap_elem_cnts)[cnt] = 0;
} else {
((int*)elem_cmap_elem_cnts)[cnt] = 0;
}
} /* "for(cnt=0; cnt < num_e_comm_maps; cnt++)" */
} /* "if (elem_cmap_elem_cnts != NULL)" */
} /* "if (elem_cmap_ids != NULL)" */
} /* "if (num_e_comm_maps > 0)" */
} /* End "if ((dimid = nc_inq_dimid(exoid, DIM_NUM_E_CMAPS(processor))) != -1)" */
return (EX_NOERR);
}
int ex_get_ns_param_global(int exoid,
void_int *global_ids,
void_int *node_cnts,
void_int *df_cnts
)
{
const char *func_name="ex_get_ns_param_global";
int varid, status;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/* Get the variable ID for the vector of global node set IDs */
if ((status = nc_inq_varid(exoid, VAR_NS_IDS_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_NS_IDS_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the vector of node set IDs */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varid, global_ids);
} else {
status = nc_get_var_int(exoid, varid, global_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_NS_IDS_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the variable ID for the vector of global node set node count */
if (node_cnts != NULL) {
if ((status = nc_inq_varid(exoid, VAR_NS_NODE_CNT_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_NS_NODE_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the vector of node set node counts */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, varid, node_cnts);
} else {
status = nc_get_var_int(exoid, varid, node_cnts);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_NS_NODE_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (node_cnts != NULL)" */
/* Get the variable ID for the vector of global node set dist. fact count */
if (df_cnts != NULL) {
if ((status = nc_inq_varid(exoid, VAR_NS_DF_CNT_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_NS_DF_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the vector of node set dist. fact counts */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, varid, df_cnts);
} else {
status = nc_get_var_int(exoid, varid, df_cnts);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_NS_DF_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (df_cnts != NULL)" */
return (EX_NOERR);
}
