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); }