int ex_get_all_times(int exoid, void *time_values)
{
int varid;
int status;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
if ((status = nc_inq_varid(exoid, VAR_WHOLE_TIME, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate time variable %s in file id %d",
VAR_WHOLE_TIME, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/*read time values */
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, varid, time_values);
}
else {
status = nc_get_var_double(exoid, varid, time_values);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get time values from file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_put_eb_info_global(int exoid, void_int *el_blk_ids, void_int *el_blk_cnts)
{
int varid, status;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* Find the variable ID for the element block IDs */
if ((status = nc_inq_varid(exoid, VAR_ELBLK_IDS_GLOBAL, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_ELBLK_IDS_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Output the global element block IDs */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, varid, el_blk_ids);
}
else {
status = nc_put_var_int(exoid, varid, el_blk_ids);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to output variable \"%s\" in file ID %d",
VAR_ELBLK_IDS_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Find the variable ID for the element block counts */
if ((status = nc_inq_varid(exoid, VAR_ELBLK_CNT_GLOBAL, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_ELBLK_CNT_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Output the global element block counts */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_var_longlong(exoid, varid, el_blk_cnts);
}
else {
status = nc_put_var_int(exoid, varid, el_blk_cnts);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to output variable \"%s\" in file ID %d",
VAR_ELBLK_CNT_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_get_elem_type(int exoid, ex_entity_id elem_blk_id, char *elem_type)
/*
* Reads the element type for a specific element block
* elem_type is assumed to have a length of MAX_STR_LENGTH+1
*/
{
int connid, el_blk_id_ndx, status;
size_t len;
char errmsg[MAX_ERR_LENGTH];
/*****************************************************************************/
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* inquire id's of previously defined dimensions */
if ((el_blk_id_ndx = ex_id_lkup(exoid, EX_ELEM_BLOCK, elem_blk_id)) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find element block ID %" PRId64 " in file %d", elem_blk_id, exoid);
ex_err(__func__, errmsg, EX_LASTERR);
EX_FUNC_LEAVE(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, VAR_CONN(el_blk_id_ndx), &connid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find connectivity variable in file ID %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* get the element type name */
if ((status = nc_inq_attlen(exoid, connid, ATT_NAME_ELB, &len)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find attribute in file ID %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (len > (MAX_STR_LENGTH + 1)) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Element type must be of length %d in file ID %d",
(int)len, exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Make sure the end of the string is terminated with a null character */
elem_type[MAX_STR_LENGTH] = '\0';
if ((status = nc_get_att_text(exoid, connid, ATT_NAME_ELB, elem_type)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get attribute \"%s\" in file ID %d",
ATT_NAME_ELB, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_put_name(int exoid, ex_entity_type obj_type, ex_entity_id entity_id, const char *name)
{
int status;
int varid, ent_ndx;
char errmsg[MAX_ERR_LENGTH];
const char *vobj;
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
switch (obj_type) {
case EX_EDGE_BLOCK: vobj = VAR_NAME_ED_BLK; break;
case EX_FACE_BLOCK: vobj = VAR_NAME_FA_BLK; break;
case EX_ELEM_BLOCK: vobj = VAR_NAME_EL_BLK; break;
case EX_NODE_SET: vobj = VAR_NAME_NS; break;
case EX_SIDE_SET: vobj = VAR_NAME_SS; break;
case EX_EDGE_SET: vobj = VAR_NAME_ES; break;
case EX_FACE_SET: vobj = VAR_NAME_FS; break;
case EX_ELEM_SET: vobj = VAR_NAME_ELS; break;
case EX_NODE_MAP: vobj = VAR_NAME_NM; break;
case EX_EDGE_MAP: vobj = VAR_NAME_EDM; break;
case EX_FACE_MAP: vobj = VAR_NAME_FAM; break;
case EX_ELEM_MAP: vobj = VAR_NAME_EM; break;
default:
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Invalid type specified in file id %d", exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, vobj, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s names in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
ent_ndx = ex_id_lkup(exoid, obj_type, entity_id);
if (ent_ndx == -EX_LOOKUPFAIL) { /* could not find the element block id */
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: %s id %" PRId64 " not found in file id %d",
ex_name_of_object(obj_type), entity_id, exoid);
ex_err(__func__, errmsg, EX_LOOKUPFAIL);
EX_FUNC_LEAVE(EX_FATAL);
}
/* If this is a null entity, then 'ent_ndx' will be negative.
* We don't care in this __func__, so make it positive and continue...
*/
if (ent_ndx < 0) {
ent_ndx = -ent_ndx;
}
/* write EXODUS entityname */
status = ex_put_name_internal(exoid, varid, ent_ndx - 1, name, obj_type, "", __func__);
EX_FUNC_LEAVE(status);
}
int ex_get_map(int exoid, void_int *elem_map)
{
int numelemdim, mapid, status;
size_t num_elem, i;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* inquire id's of previously defined dimensions and variables */
/* See if file contains any elements...*/
if ((status = nc_inq_dimid(exoid, DIM_NUM_ELEM, &numelemdim)) != NC_NOERR) {
EX_FUNC_LEAVE(EX_NOERR);
}
if ((status = nc_inq_dimlen(exoid, numelemdim, &num_elem)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of elements in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (nc_inq_varid(exoid, VAR_MAP, &mapid) != NC_NOERR) {
/* generate default map of 1..n, where n is num_elem */
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
int64_t *lmap = (int64_t *)elem_map;
for (i = 0; i < num_elem; i++) {
lmap[i] = i + 1;
}
}
else {
int *lmap = (int *)elem_map;
for (i = 0; i < num_elem; i++) {
lmap[i] = i + 1;
}
}
EX_FUNC_LEAVE(EX_NOERR);
}
/* read in the element order map */
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_get_var_longlong(exoid, mapid, elem_map);
}
else {
status = nc_get_var_int(exoid, mapid, elem_map);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element order map in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_put_names_internal(int exoid, int varid, size_t num_entity, char **names,
ex_entity_type obj_type, const char *subtype, const char *routine)
{
size_t i;
int status;
char errmsg[MAX_ERR_LENGTH];
int max_name_len = 0;
size_t name_length;
size_t length;
char * int_names = NULL;
size_t idx = 0;
int found_name = 0;
ex_check_valid_file_id(exoid);
/* inquire previously defined dimensions */
name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH) + 1;
int_names = calloc(num_entity * name_length, 1);
for (i = 0; i < num_entity; i++) {
if (names[i] != '\0') {
found_name = 1;
strncpy(&int_names[idx], names[i], name_length - 1);
int_names[idx + name_length - 1] = '\0';
length = strlen(names[i]) + 1;
if (length > name_length) {
fprintf(stderr, "Warning: The %s %s name '%s' is too long.\n\tIt will "
"be truncated from %d to %d characters\n",
ex_name_of_object(obj_type), subtype, names[i], (int)length - 1,
(int)name_length - 1);
length = name_length;
}
if (length > max_name_len) {
max_name_len = length;
}
}
idx += name_length;
}
if (found_name) {
if ((status = nc_put_var_text(exoid, varid, int_names)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store %s names in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
/* Update the maximum_name_length attribute on the file. */
ex_update_max_name_length(exoid, max_name_len - 1);
}
free(int_names);
return (EX_NOERR);
}
int ex_get_glob_vars_int(int exoid, int time_step, int num_glob_vars, void *glob_var_vals)
{
int varid;
int status;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* inquire previously defined variable */
if ((status = nc_inq_varid(exoid, VAR_GLO_VAR, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: failed to locate global variables in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_WARN);
}
/* Verify that time_step is within bounds */
{
int num_time_steps = ex_inquire_int(exoid, EX_INQ_TIME);
if (time_step <= 0 || time_step > num_time_steps) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: time_step is out-of-range. Value = %d, valid "
"range is 1 to %d in file id %d",
time_step, num_time_steps, exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* read values of global variables */
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_glob_vars;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, glob_var_vals);
}
else {
status = nc_get_vara_double(exoid, varid, start, count, glob_var_vals);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get global variable values from file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_get_init(int exoid, char *title, void_int *num_dim, void_int *num_nodes, void_int *num_elem,
void_int *num_elem_blk, void_int *num_node_sets, void_int *num_side_sets)
{
ex_init_params info;
int errval;
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
info.title[0] = '\0';
errval = ex_get_init_ext(exoid, &info);
if (errval < 0) {
EX_FUNC_LEAVE(errval);
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int64_t *n_dim = num_dim;
int64_t *n_nodes = num_nodes;
int64_t *n_elem = num_elem;
int64_t *n_elem_blk = num_elem_blk;
int64_t *n_node_sets = num_node_sets;
int64_t *n_side_sets = num_side_sets;
*n_dim = info.num_dim;
*n_nodes = info.num_nodes;
*n_elem = info.num_elem;
*n_elem_blk = info.num_elem_blk;
*n_node_sets = info.num_node_sets;
*n_side_sets = info.num_side_sets;
}
else {
int *n_dim = num_dim;
int *n_nodes = num_nodes;
int *n_elem = num_elem;
int *n_elem_blk = num_elem_blk;
int *n_node_sets = num_node_sets;
int *n_side_sets = num_side_sets;
*n_dim = info.num_dim;
*n_nodes = info.num_nodes;
*n_elem = info.num_elem;
*n_elem_blk = info.num_elem_blk;
*n_node_sets = info.num_node_sets;
*n_side_sets = info.num_side_sets;
}
strcpy(title, info.title);
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_put_name_internal(int exoid, int varid, size_t index, const char *name,
ex_entity_type obj_type, const char *subtype, const char *routine)
{
int status;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
size_t name_length;
ex_check_valid_file_id(exoid);
/* inquire previously defined dimensions */
name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH) + 1;
if (name != '\0') {
int too_long = 0;
start[0] = index;
start[1] = 0;
count[0] = 1;
count[1] = strlen(name) + 1;
if (count[1] > name_length) {
fprintf(stderr, "Warning: The %s %s name '%s' is too long.\n\tIt will be "
"truncated from %d to %d characters\n",
ex_name_of_object(obj_type), subtype, name, (int)strlen(name), (int)name_length - 1);
count[1] = name_length;
too_long = 1;
}
if ((status = nc_put_vara_text(exoid, varid, start, count, name)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store %s name in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
/* Add the trailing null if the variable name was too long */
if (too_long) {
start[1] = name_length - 1;
nc_put_var1_text(exoid, varid, start, "\0");
}
/* Update the maximum_name_length attribute on the file. */
ex_update_max_name_length(exoid, count[1] - 1);
}
return (EX_NOERR);
}
int ex_set_max_name_length(int exoid, int length)
{
char errmsg[MAX_ERR_LENGTH];
ex_check_valid_file_id(exoid);
if (length <= 0) {
exerrval = NC_EMAXNAME;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Max name length must be positive.");
ex_err("ex_set_max_name_length", errmsg, exerrval);
return (EX_FATAL);
}
if (length > NC_MAX_NAME) {
exerrval = NC_EMAXNAME;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: Max name length (%d) exceeds netcdf max name size (%d).", length, NC_MAX_NAME);
ex_err("ex_set_max_name_length", errmsg, exerrval);
return (EX_FATAL);
}
else {
ex_set_option(exoid, EX_OPT_MAX_NAME_LENGTH, length);
}
return EX_NOERR;
}
void ex_update_max_name_length(int exoid, int length)
{
int status;
int db_length = 0;
int rootid = exoid & EX_FILE_ID_MASK;
ex_check_valid_file_id(exoid);
/* Get current value of the maximum_name_length attribute... */
if ((status = nc_get_att_int(rootid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, &db_length)) != NC_NOERR) {
char errmsg[MAX_ERR_LENGTH];
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to update 'max_name_length' attribute in file id %d", exoid);
ex_err("ex_update_max_name_length", errmsg, exerrval);
}
if (length > db_length) {
/* Update with new value... */
nc_put_att_int(rootid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, NC_INT, 1, &length);
nc_sync(rootid);
}
}
int ex_get_processor_node_maps(int exoid, void_int *node_mapi, void_int *node_mapb,
void_int *node_mape, int processor)
{
const char *func_name = "ex_get_processor_node_maps";
char ftype[2];
int status, varid, dimid;
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);
exerrval = 0; /* clear error code */
/* 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 this node map */
if ((status = nc_inq_varid(exoid, VAR_INT_N_STAT, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "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] = processor;
}
if (nc_get_var1_int(exoid, varid, start, &nmstat) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get status for \"%s\" in file ID %d",
VAR_INT_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* get the index */
if (ex_get_idx(exoid, VAR_NODE_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_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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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_get_vara_longlong(exoid, varid, start, count, node_mapi);
}
else {
status = nc_get_vara_int(exoid, varid, start, count, node_mapi);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get variable \"%s\" from 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;
snprintf(errmsg, MAX_ERR_LENGTH, "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] = processor;
}
if (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 ID %d",
VAR_BOR_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* get the index */
if (ex_get_idx(exoid, VAR_NODE_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_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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
}
start[0] = varidx[0];
count[0] = varidx[1] - varidx[0];
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_get_vara_longlong(exoid, varid, start, count, node_mapb);
}
else {
status = nc_get_vara_int(exoid, varid, start, count, node_mapb);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get variable \"%s\" from 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;
snprintf(errmsg, MAX_ERR_LENGTH, "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] = processor;
}
if (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 ID %d",
VAR_EXT_N_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (nmstat == 1) {
/* get the index */
if (ex_get_idx(exoid, VAR_NODE_MAP_EXT_IDX, varidx, processor) == -1) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
}
start[0] = varidx[0];
count[0] = varidx[1] - varidx[0];
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_get_vara_longlong(exoid, varid, start, count, node_mape);
}
else {
status = nc_get_vara_int(exoid, varid, start, count, node_mape);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get variable \"%s\" from 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_get_partial_coord(int exoid, int64_t start_node_num, int64_t num_nodes, void *x_coor,
void *y_coor, void *z_coor)
{
int status;
int coordid;
int coordidx, coordidy, coordidz;
int numnoddim, ndimdim;
size_t num_nod;
size_t num_dim, start[2], count[2], i;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* inquire id's of previously defined dimensions */
if (nc_inq_dimid(exoid, DIM_NUM_NODES, &numnoddim) != NC_NOERR) {
/* If not found, then this file is storing 0 nodes.
Return immediately */
EX_FUNC_LEAVE(EX_NOERR);
}
if ((status = nc_inq_dimlen(exoid, numnoddim, &num_nod)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of nodes in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
--start_node_num;
if (start_node_num + num_nodes > num_nod) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: start index (%" PRId64 ") + node count (%" PRId64
") is larger than total number of nodes (%" ST_ZU ") in file id %d",
start_node_num, num_nodes, num_nod, exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
if (ex_get_dimension(exoid, DIM_NUM_DIM, "dimension count", &num_dim, &ndimdim, __func__) !=
NC_NOERR) {
EX_FUNC_LEAVE(EX_FATAL);
}
/* read in the coordinates */
if (ex_large_model(exoid) == 0) {
if ((status = nc_inq_varid(exoid, VAR_COORD, &coordid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate nodal coordinates in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
for (i = 0; i < num_dim; i++) {
char *which;
start[0] = i;
start[1] = start_node_num;
count[0] = 1;
count[1] = num_nodes;
if (count[1] == 0) {
start[1] = 0;
}
if (i == 0 && x_coor != NULL) {
which = "X";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, x_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, x_coor);
}
}
else if (i == 1 && y_coor != NULL) {
which = "Y";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, y_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, y_coor);
}
}
else if (i == 2 && z_coor != NULL) {
which = "Z";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, z_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, z_coor);
}
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s coord array in file id %d", which,
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
else {
if ((status = nc_inq_varid(exoid, VAR_COORD_X, &coordidx)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate x nodal coordinates in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (num_dim > 1) {
if ((status = nc_inq_varid(exoid, VAR_COORD_Y, &coordidy)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate y nodal coordinates in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
else {
coordidy = 0;
}
if (num_dim > 2) {
if ((status = nc_inq_varid(exoid, VAR_COORD_Z, &coordidz)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate z nodal coordinates in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
else {
coordidz = 0;
}
/* write out the coordinates */
for (i = 0; i < num_dim; i++) {
void *coor = NULL;
char *which = NULL;
start[0] = start_node_num;
count[0] = num_nodes;
if (count[0] == 0) {
start[0] = 0;
}
if (i == 0) {
coor = x_coor;
which = "X";
coordid = coordidx;
}
else if (i == 1) {
coor = y_coor;
which = "Y";
coordid = coordidy;
}
else if (i == 2) {
coor = z_coor;
which = "Z";
coordid = coordidz;
}
if (coor != NULL && coordid != 0) {
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, coor);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s coord array in file id %d",
which, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_get_var(int exoid, int time_step, ex_entity_type var_type, int var_index,
ex_entity_id obj_id, int64_t num_entry_this_obj, void *var_vals)
{
int status;
int varid, obj_id_ndx;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
ex_check_valid_file_id(exoid);
if (var_type == EX_NODAL) {
/* FIXME: Special case: ignore obj_id, possible large_file complications,
* etc. */
return ex_get_nodal_var_int(exoid, time_step, var_index, num_entry_this_obj, var_vals);
}
if (var_type == EX_GLOBAL) {
/* FIXME: Special case: all vars stored in 2-D single array. */
return ex_get_glob_vars_int(exoid, time_step, num_entry_this_obj, var_vals);
}
exerrval = 0; /* clear error code */
/* Determine index of obj_id in VAR_ID_EL_BLK array */
obj_id_ndx = ex_id_lkup(exoid, var_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no %s variables for NULL block %" PRId64 " in file id %d",
ex_name_of_object(var_type), obj_id, exoid);
ex_err("ex_get_var", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s id %" PRId64 " in id variable in file id %d",
ex_name_of_object(var_type), obj_id, exoid);
ex_err("ex_get_var", errmsg, exerrval);
return (EX_FATAL);
}
/* inquire previously defined variable */
if ((status = nc_inq_varid(exoid, ex_name_var_of_object(var_type, var_index, obj_id_ndx),
&varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s %" PRId64 " var %d in file id %d",
ex_name_of_object(var_type), obj_id, var_index, exoid);
ex_err("ex_get_var", errmsg, exerrval);
return (EX_FATAL);
}
/* Verify that time_step is within bounds */
#ifndef NDEBUG
{
int num_time_steps = ex_inquire_int(exoid, EX_INQ_TIME);
if (time_step <= 0 || time_step > num_time_steps) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: time_step is out-of-range. Value = %d, valid "
"range is 1 to %d in file id %d",
time_step, num_time_steps, exoid);
ex_err("ex_get_var", errmsg, EX_BADPARAM);
return (EX_FATAL);
}
}
#endif
/* read values of element variable */
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_entry_this_obj;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, var_vals);
}
else {
status = nc_get_vara_double(exoid, varid, start, count, var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get %s %" PRId64 " variable %d in file id %d",
ex_name_of_object(var_type), obj_id, var_index, exoid);
ex_err("ex_get_var", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
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_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;
#if NC_HAS_HDF5
int fill = NC_FILL_CHAR;
#endif
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
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))) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: number of maps already defined for file id %d", exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get string length in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* put file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file id %d into define mode", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* node maps: */
if (num_node_maps > 0) {
if ((status = nc_def_dim(exoid, DIM_NUM_NM, num_node_maps, &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define number of node maps in file id %d", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create node maps property array in file id %d", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store node map property name %s in file id %d", "ID", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define node map name array in file id %d", exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* exit define mode and return */
}
#if NC_HAS_HDF5
nc_def_var_fill(exoid, varid, 0, &fill);
#endif
/* determine number of nodes */
if ((status = nc_inq_dimid(exoid, DIM_NUM_NODES, &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: couldn't determine number of nodes in file id %d",
exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: node map %d already defined in file id %d", i,
exoid);
ex_err(__func__, errmsg, status);
}
else {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to create node map %d in file id %d", i,
exoid);
ex_err(__func__, errmsg, status);
}
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define number of element maps in file id %d", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create element maps property array in file id %d", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store element map property name %s in file id %d", "ID", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define element map name array in file id %d", exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* exit define mode and return */
}
#if NC_HAS_HDF5
nc_def_var_fill(exoid, varid, 0, &fill);
#endif
/* determine number of elements */
if ((status = nc_inq_dimid(exoid, DIM_NUM_ELEM, &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: couldn't determine number of elements in file id %d", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: element map %d already defined in file id %d",
i, exoid);
ex_err(__func__, errmsg, status);
}
else {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to create element map %d in file id %d",
i, exoid);
ex_err(__func__, errmsg, status);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
}
}
/* leave define mode */
if ((status = nc_enddef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to complete variable definitions in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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));
if (invalid_ids == NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate memory for invalid id "
"storage in file id %d",
exoid);
ex_err(__func__, errmsg, EX_MEMFAIL);
EX_FUNC_LEAVE(EX_FATAL);
}
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);
}
}
EX_FUNC_LEAVE(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if ((status = 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(__func__, errmsg, status);
}
EX_FUNC_LEAVE(EX_FATAL);
}
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-----------------------------*/
ex_check_valid_file_id(exoid);
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_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];
ex_check_valid_file_id(exoid);
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_put_qa(int exoid, int num_qa_records, char *qa_record[][4])
{
int status;
int i, j, strdim, num_qa_dim, varid, n4dim;
int dims[3];
size_t start[3], count[3];
char errmsg[MAX_ERR_LENGTH];
int rootid = exoid & EX_FILE_ID_MASK;
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
/* only do this if there are records */
if (num_qa_records > 0) {
/* See if the number of qa records has already been defined.
Assume that if the DIM_NUM_QA dimension exists, then the
VAR_QA_TITLE variable also exists...
*/
status = nc_inq_dimid(rootid, DIM_NUM_QA, &num_qa_dim);
if (status != NC_NOERR) {
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(rootid, DIM_STR, &strdim)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate string length in file id %d",
rootid);
ex_err("ex_put_qa", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimid(rootid, DIM_N4, &n4dim)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate record length in file id %d",
rootid);
ex_err("ex_put_qa", errmsg, exerrval);
return (EX_FATAL);
}
/* put file into define mode */
if ((status = nc_redef(rootid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file id %d into define mode",
rootid);
ex_err("ex_put_qa", errmsg, exerrval);
return (EX_FATAL);
}
/* define dimensions */
if ((status = nc_def_dim(rootid, DIM_NUM_QA, num_qa_records, &num_qa_dim)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) { /* duplicate entry? */
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: qa records already exist in file id %d", rootid);
ex_err("ex_put_qa", errmsg, exerrval);
}
else {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define qa record array size in file id %d", rootid);
ex_err("ex_put_qa", errmsg, exerrval);
}
goto error_ret; /* exit define mode and return */
}
/* define variable */
dims[0] = num_qa_dim;
dims[1] = n4dim;
dims[2] = strdim;
if ((status = nc_def_var(rootid, VAR_QA_TITLE, NC_CHAR, 3, dims, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define qa record array in file id %d",
rootid);
ex_err("ex_put_qa", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
/* leave define mode */
if ((status = nc_enddef(rootid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition in file id %d",
rootid);
ex_err("ex_put_qa", errmsg, exerrval);
return (EX_FATAL);
}
}
else {
if ((status = nc_inq_varid(rootid, VAR_QA_TITLE, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find qa records variable in file id %d",
rootid);
ex_err("ex_put_qa", errmsg, exerrval);
return (EX_FATAL);
}
}
if (qa_record != NULL) {
/* write out QA records */
for (i = 0; i < num_qa_records; i++) {
for (j = 0; j < 4; j++) {
start[0] = i;
start[1] = j;
start[2] = 0;
count[0] = 1;
count[1] = 1;
count[2] = strlen(qa_record[i][j]) + 1;
if ((status = nc_put_vara_text(rootid, varid, start, count, qa_record[i][j])) !=
NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store qa record in file id %d",
rootid);
ex_err("ex_put_qa", errmsg, exerrval);
return (EX_FATAL);
}
}
}
}
else if (ex_is_parallel(rootid)) {
/* In case we are in a collective mode, all processors need to call */
const char dummy[] = " ";
for (i = 0; i < num_qa_records; i++) {
for (j = 0; j < 4; j++) {
start[0] = start[1] = start[2] = 0;
count[0] = count[1] = count[2] = 0;
nc_put_vara_text(rootid, varid, start, count, dummy);
}
}
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef(rootid) != NC_NOERR) { /* exit define mode */
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", rootid);
ex_err("ex_put_qa", errmsg, exerrval);
}
return (EX_FATAL);
}
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;
int int_type;
exerrval = 0; /* clear error code */
ex_check_valid_file_id(exoid);
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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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);
}
if (sets[i].id < 0) {
/* We are adding a set with id = -sets[i].id. We want to define
* everything, but we don't
* want to increment the number of sets... Major kluge / proof of concept
*/
needs_define++;
sets_to_define[i] = -1;
}
else {
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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
}
if (sets_to_define[i] > 0) {
/* 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;
}
else {
cur_num_sets = ex_get_file_item(exoid, ex_get_counter_list(sets[i].type));
set_id_ndx = cur_num_sets - set_count + i + 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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"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 {
snprintf(errmsg, MAX_ERR_LENGTH,
"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_type = NC_INT;
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
int_type = NC_INT64;
}
/* create variable array in which to store the entry lists */
dims[0] = dimid;
if ((status = nc_def_var(exoid, entryptr, int_type, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
snprintf(errmsg, MAX_ERR_LENGTH,
"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 {
snprintf(errmsg, MAX_ERR_LENGTH,
"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_type, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
snprintf(errmsg, MAX_ERR_LENGTH,
"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 {
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"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 {
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
long long id = sets[i].id;
if (id < 0) {
id = -id;
}
status = nc_put_var1_longlong(exoid, varid, start, &id);
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
long long id = sets[i].id;
if (id < 0) {
id = -id;
}
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, id, sets[i].entry_list, sets[i].extra_list);
if (stat != EX_NOERR) {
status = EX_FATAL;
}
}
if (sets[i].num_distribution_factor > 0 && 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, 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 */
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid);
ex_err("ex_put_sets", errmsg, exerrval);
}
return (EX_FATAL);
}
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);
}
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_get_partial_set_dist_fact(int exoid, ex_entity_type set_type, ex_entity_id set_id,
int64_t offset, int64_t num_to_put, void *set_dist_fact)
{
int dimid, dist_id, set_id_ndx;
int status;
size_t start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
char * factptr = NULL;
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
/* 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, "Warning: no %s sets stored in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_get_partial_set_dist_fact", errmsg, exerrval);
return (EX_WARN);
}
/* 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: %s set %" PRId64 " is NULL in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_partial_set_dist_fact", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s set %" PRId64 " in VAR_*S_IDS array in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_partial_set_dist_fact", errmsg, exerrval);
return (EX_FATAL);
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, factptr, &dist_id)) != NC_NOERR) {
exerrval = status;
/* not an error for node sets because this is how we check that df's exist
*/
if (set_type == EX_NODE_SET) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: dist factors not stored for %s set %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_partial_set_dist_fact", errmsg, exerrval);
return (EX_WARN); /* complain - but not too loud */
}
/* is an error for other sets */
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate dist factors list for %s set %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_partial_set_dist_fact", errmsg, exerrval);
return (EX_FATAL);
}
/* read in the distribution factors array */
start[0] = offset - 1;
count[0] = num_to_put;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, dist_id, start, count, set_dist_fact);
}
else {
status = nc_get_vara_double(exoid, dist_id, start, count, set_dist_fact);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get dist factors list for %s set %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_partial_set_dist_fact", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_side_set_node_count(int exoid, ex_entity_id side_set_id, int *side_set_node_cnt_list)
{
int ii, i, j;
int num_side_sets, num_elem_blks, ndim;
size_t tot_num_ss_elem = 0;
int64_t side, elem;
void_int *elem_blk_ids = NULL;
void_int *ss_elem_ndx = NULL;
void_int *side_set_elem_list = NULL;
void_int *side_set_side_list = NULL;
size_t elem_ctr;
struct elem_blk_parm *elem_blk_parms = NULL;
char errmsg[MAX_ERR_LENGTH];
int err_stat = EX_NOERR;
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS);
if (num_side_sets < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
if (num_side_sets == 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no side sets defined in file id %d", exoid);
ex_err("ex_get_side_set_node_count", errmsg, EX_WARN);
return (EX_WARN);
}
/* Lookup index of side set id in VAR_SS_IDS array */
ex_id_lkup(exoid, EX_SIDE_SET, side_set_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: side set %" PRId64 " is NULL in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_count", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate side set %" PRId64 " in VAR_SS_IDS array in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
if (num_elem_blks < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
/* get the dimensionality of the coordinates; this is necessary to
distinguish between 2d TRIs and 3d TRIs */
ndim = ex_inquire_int(exoid, EX_INQ_DIM);
if (ndim < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get dimensionality in file id %d", exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
int int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* First determine the # of elements in the side set*/
int err;
if (int_size == sizeof(int64_t)) {
int64_t ss_elem = 0;
int64_t ss_df = 0;
err = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &ss_elem, &ss_df);
tot_num_ss_elem = ss_elem;
}
else {
int ss_elem = 0;
int ss_df = 0;
err = ex_get_set_param(exoid, EX_SIDE_SET, side_set_id, &ss_elem, &ss_df);
tot_num_ss_elem = ss_elem;
}
if (err == -1) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of elements in side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
/* Allocate space for the side set element list */
{
if (!(side_set_elem_list = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set element "
"list for file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
return (EX_FATAL);
}
/* Allocate space for the side set side list */
if (!(side_set_side_list = malloc(tot_num_ss_elem * int_size))) {
free(side_set_elem_list);
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set side list "
"for file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_set(exoid, EX_SIDE_SET, side_set_id, side_set_elem_list, side_set_side_list) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the ss element index array */
if (!(ss_elem_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem sort "
"array for file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (int_size == sizeof(int64_t)) {
/* Sort side set element list into index array - non-destructive */
int64_t *elems = (int64_t *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort64(side_set_elem_list, elems, tot_num_ss_elem);
}
else {
/* Sort side set element list into index array - non-destructive */
int *elems = (int *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort(side_set_elem_list, elems, tot_num_ss_elem);
}
}
/* Allocate space for the element block ids */
{
int int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
int_size = sizeof(int64_t);
}
if (!(elem_blk_ids = malloc(num_elem_blks * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block ids "
"for file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element block ids in file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
}
/* Allocate space for the element block params */
if (!(elem_blk_parms = malloc(num_elem_blks * sizeof(struct elem_blk_parm)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block params "
"for file id %d",
exoid);
ex_err("ex_get_side_set_node_count", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = 0;
for (i = 0; i < num_elem_blks; i++) {
ex_entity_id id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
id = ((int64_t *)elem_blk_ids)[i];
}
else {
id = ((int *)elem_blk_ids)[i];
}
err_stat = ex_int_get_block_param(exoid, id, ndim, &elem_blk_parms[i]);
if (err_stat != EX_NOERR) {
goto cleanup;
}
elem_ctr += elem_blk_parms[i].num_elem_in_blk;
elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */
}
/* Finally... Create the list of node counts for each face in the
* side set.
*/
j = 0; /* The current element block... */
for (ii = 0; ii < tot_num_ss_elem; ii++) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
i = ((int64_t *)ss_elem_ndx)[ii];
elem = ((int64_t *)side_set_elem_list)[i];
side = ((int64_t *)side_set_side_list)[i] - 1; /* Convert to 0-based sides */
}
else {
i = ((int *)ss_elem_ndx)[ii];
elem = ((int *)side_set_elem_list)[i];
side = ((int *)side_set_side_list)[i] - 1; /* Convert to 0-based sides */
}
/*
* Since the elements are being accessed in sorted, order, the
* block that contains the elements must progress sequentially
* from block 0 to block[num_elem_blks-1]. Once we find an element
* not in this block, find a following block that contains it...
*/
for (; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j < num_elem_blks) {
assert(side < elem_blk_parms[j].num_sides);
side_set_node_cnt_list[i] = elem_blk_parms[j].num_nodes_per_side[side];
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: Invalid element number %" PRId64 " found in side set %" PRId64 " in file %d",
elem, side_set_id, exoid);
ex_err("ex_get_side_set_node_count", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
}
/* All done: release connectivity array space, element block ids
* array, element block parameters array, and side set element index
* array
*/
cleanup:
free(elem_blk_ids);
free(elem_blk_parms);
free(ss_elem_ndx);
free(side_set_side_list);
free(side_set_elem_list);
return (err_stat);
}
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_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];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* 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, __func__);
if (status != NC_NOERR) {
EX_FUNC_LEAVE(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:
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property array id in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property name in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to place file id %d into define mode", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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:
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create property array variable in file id %d", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property name %s in file id %d",
prop_name, exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* Exit define mode and return */
}
/* leave define mode */
if ((status = nc_enddef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to leave define mode in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property values in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
if ((status = 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(__func__, errmsg, status);
}
EX_FUNC_LEAVE(EX_FATAL);
}
int ex_get_partial_attr(int exoid, ex_entity_type obj_type, ex_entity_id obj_id, int64_t start_num,
int64_t num_ent, void *attrib)
{
int status;
int attrid, obj_id_ndx;
int temp;
size_t num_entries_this_obj, num_attr;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
const char *dnumobjent;
const char *dnumobjatt;
const char *vattrbname;
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
if (num_ent == 0) {
return 0;
}
/* Determine index of obj_id in vobjids array */
if (obj_type != EX_NODAL) {
obj_id_ndx = ex_id_lkup(exoid, obj_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no attributes found for NULL %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, EX_NULLENTITY);
return (EX_WARN); /* no attributes for this object */
}
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: failed to locate %s id%" PRId64 " in id array in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_WARN);
}
}
switch (obj_type) {
case EX_SIDE_SET:
dnumobjent = DIM_NUM_SIDE_SS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_SS(obj_id_ndx);
vattrbname = VAR_SSATTRIB(obj_id_ndx);
break;
case EX_NODE_SET:
dnumobjent = DIM_NUM_NOD_NS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_NS(obj_id_ndx);
vattrbname = VAR_NSATTRIB(obj_id_ndx);
break;
case EX_EDGE_SET:
dnumobjent = DIM_NUM_EDGE_ES(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_ES(obj_id_ndx);
vattrbname = VAR_ESATTRIB(obj_id_ndx);
break;
case EX_FACE_SET:
dnumobjent = DIM_NUM_FACE_FS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_FS(obj_id_ndx);
vattrbname = VAR_FSATTRIB(obj_id_ndx);
break;
case EX_ELEM_SET:
dnumobjent = DIM_NUM_ELE_ELS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_ELS(obj_id_ndx);
vattrbname = VAR_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
dnumobjent = DIM_NUM_NODES;
dnumobjatt = DIM_NUM_ATT_IN_NBLK;
vattrbname = VAR_NATTRIB;
break;
case EX_EDGE_BLOCK:
dnumobjent = DIM_NUM_ED_IN_EBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
vattrbname = VAR_EATTRIB(obj_id_ndx);
break;
case EX_FACE_BLOCK:
dnumobjent = DIM_NUM_FA_IN_FBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_FBLK(obj_id_ndx);
vattrbname = VAR_FATTRIB(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
dnumobjent = DIM_NUM_EL_IN_BLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_BLK(obj_id_ndx);
vattrbname = VAR_ATTRIB(obj_id_ndx);
break;
default:
exerrval = 1005;
snprintf(errmsg, MAX_ERR_LENGTH,
"Internal ERROR: unrecognized object type in switch: %d in file id %d", obj_type,
exoid);
ex_err("ex_get_partial_attr", errmsg, EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
if (ex_get_dimension(exoid, dnumobjent, "entries", &num_entries_this_obj, &temp,
"ex_get_partial_attr") != NC_NOERR) {
return EX_FATAL;
}
if (start_num + num_ent - 1 > num_entries_this_obj) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: start index (%" PRId64 ") + count (%" PRId64
") is larger than total number of entities (%" ST_ZU ") in file id %d",
start_num, num_ent, num_entries_this_obj, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_FATAL);
}
if (ex_get_dimension(exoid, dnumobjatt, "attributes", &num_attr, &temp, "ex_get_partial_attr") !=
NC_NOERR) {
return EX_FATAL;
}
if ((status = nc_inq_varid(exoid, vattrbname, &attrid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate attributes for %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_FATAL);
}
/* read in the attributes */
start[0] = start_num - 1;
start[1] = 0;
count[0] = num_ent;
count[1] = num_attr;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, attrid, start, count, attrib);
}
else {
status = nc_get_vara_double(exoid, attrid, start, count, attrib);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get attributes for %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", 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];
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
num_side_sets = ex_inquire_int(exoid, EX_INQ_SIDE_SETS);
if (num_side_sets < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
return (EX_FATAL);
}
if (num_side_sets == 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no side sets defined in file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, EX_WARN);
return (EX_WARN);
}
num_elem_blks = ex_inquire_int(exoid, EX_INQ_ELEM_BLK);
if (num_elem_blks < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
return (EX_FATAL);
}
tot_num_elem = ex_inquire_int(exoid, EX_INQ_ELEM);
if (tot_num_elem < 0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get total number of elements in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
return (EX_FATAL);
}
/* get the dimensionality of the coordinates; this is necessary to
distinguish between 2d TRIs and 3d TRIs */
ndim = ex_inquire_int(exoid, EX_INQ_DIM);
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* First count up # of elements in the side sets*/
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
for (i = 0; i < num_side_sets; i++) {
tot_num_ss_elem += ((int64_t *)num_elem_per_set)[i];
}
}
else {
for (i = 0; i < num_side_sets; i++) {
tot_num_ss_elem += ((int *)num_elem_per_set)[i];
}
}
/* Allocate space for the ss element index array */
if (!(ss_elem_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem sort "
"array for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (int_size == sizeof(int64_t)) {
/* Sort side set element list into index array - non-destructive */
int64_t *elems = (int64_t *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort64(side_sets_elem_list, elems, tot_num_ss_elem);
}
else {
/* Sort side set element list into index array - non-destructive */
int *elems = (int *)ss_elem_ndx;
for (i = 0; i < tot_num_ss_elem; i++) {
elems[i] = i; /* init index array to current position */
}
ex_iqsort(side_sets_elem_list, elems, tot_num_ss_elem);
}
/* Allocate space for the element block ids */
ids_size = sizeof(int);
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
ids_size = sizeof(int64_t);
}
if (!(elem_blk_ids = malloc(num_elem_blks * ids_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate space for element block ids for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (ex_get_ids(exoid, EX_ELEM_BLOCK, elem_blk_ids)) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element block ids in file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, EX_MSG);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the element block params */
if (!(elem_blk_parms = malloc(num_elem_blks * sizeof(struct elem_blk_parm)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element block params "
"for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = 0;
for (i = 0; i < num_elem_blks; i++) {
ex_entity_id id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
id = ((int64_t *)elem_blk_ids)[i];
}
else {
id = ((int *)elem_blk_ids)[i];
}
err_stat = ex_int_get_block_param(exoid, id, ndim, &elem_blk_parms[i]);
if (err_stat != EX_NOERR) {
goto cleanup;
}
elem_ctr += elem_blk_parms[i].num_elem_in_blk;
elem_blk_parms[i].elem_ctr = elem_ctr; /* save elem number max */
}
/* Allocate space for the ss element to element block parameter index array */
if (!(ss_parm_ndx = malloc(tot_num_ss_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem parms "
"index for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* Allocate space for the ss element to node list index array */
if (!(ss_elem_node_ndx = malloc((tot_num_ss_elem + 1) * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for side set elem to node "
"index for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* determine if each side set has uniform element types; this will
be used to help determine the stride through the node list
*/
/* Allocate space for same element type flag array*/
if (!(same_elem_type = malloc(num_side_sets * sizeof(int)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for element type flag "
"array for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
same_elem_type[0] = EX_TRUE;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
elem_ctr = ((int64_t *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int64_t elem = ((int64_t *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (i == 0) {
el_type = elem_blk_parms[j].elem_type_val;
}
/* determine which side set this element is in; assign to kth side set */
if (i >= elem_ctr) {
elem_ctr += ((int64_t *)num_elem_per_set)[++k];
el_type = elem_blk_parms[j].elem_type_val;
same_elem_type[k] = EX_TRUE;
}
if (el_type != elem_blk_parms[j].elem_type_val) {
same_elem_type[k] = EX_FALSE;
}
}
/* Build side set element to node list index and side set element
parameter index.
*/
node_ctr = 0;
elem_ctr = ((int64_t *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int64_t elem = ((int64_t *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
((int64_t *)ss_parm_ndx)[i] = j; /* assign parameter block index */
((int64_t *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
/* determine which side set this element is in; assign to kth side set */
if (i >= elem_ctr) {
/* skip over NULL side sets */
while (((int64_t *)num_elem_per_set)[++k] == 0) {
;
}
elem_ctr += ((int64_t *)num_elem_per_set)[k];
}
/* determine number of nodes per side */
if (((((int64_t *)num_nodes_per_set)[k] % ((int64_t *)num_elem_per_set)[k]) == 0) &&
(same_elem_type[k] == EX_TRUE)) { /* all side set elements are same type */
node_ctr += ((int64_t *)num_nodes_per_set)[k] / ((int64_t *)num_elem_per_set)[k];
}
else {
node_ctr += elem_blk_parms[j].num_nodes_per_side[0];
}
}
((int64_t *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
}
else {
elem_ctr = ((int *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int elem = ((int *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
if (i == 0) {
el_type = elem_blk_parms[j].elem_type_val;
}
/* determine which side set this element is in; assign to kth side set */
if (i >= elem_ctr) {
elem_ctr += ((int *)num_elem_per_set)[++k];
el_type = elem_blk_parms[j].elem_type_val;
same_elem_type[k] = EX_TRUE;
}
if (el_type != elem_blk_parms[j].elem_type_val) {
same_elem_type[k] = EX_FALSE;
}
}
/* Build side set element to node list index and side set element
parameter index.
*/
node_ctr = 0;
elem_ctr = ((int *)num_elem_per_set)[0];
for (i = 0, k = 0; i < tot_num_ss_elem; i++) {
int elem = ((int *)side_sets_elem_list)[i];
for (j = 0; j < num_elem_blks; j++) {
if (elem <= elem_blk_parms[j].elem_ctr) {
break;
}
}
if (j >= num_elem_blks) {
exerrval = EX_INTERNAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: internal logic error for file id %d", exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
((int *)ss_parm_ndx)[i] = j; /* assign parameter block index */
((int *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
/* determine which side set this element is in; assign to kth side set */
if (i >= elem_ctr) {
/* skip over NULL side sets */
while (((int *)num_elem_per_set)[++k] == 0) {
;
}
elem_ctr += ((int *)num_elem_per_set)[k];
}
/* determine number of nodes per side */
if (((((int *)num_nodes_per_set)[k] % ((int *)num_elem_per_set)[k]) == 0) &&
(same_elem_type[k])) { /* all side set elements are same type */
node_ctr += ((int *)num_nodes_per_set)[k] / ((int *)num_elem_per_set)[k];
}
else {
node_ctr += elem_blk_parms[j].num_nodes_per_side[0];
}
}
((int *)ss_elem_node_ndx)[i] = node_ctr; /* assign node list index */
}
/* All setup, ready to go ... */
elem_ctr = 0;
for (j = 0; j < tot_num_ss_elem; j++) {
int64_t elem;
int64_t idx;
int64_t ss_node0, ss_node1;
int64_t p_ndx;
if (int_size == sizeof(int64_t)) {
idx = ((int64_t *)ss_elem_ndx)[j];
elem = ((int64_t *)side_sets_elem_list)[idx];
ss_node0 = ((int64_t *)side_sets_node_list)[((int64_t *)ss_elem_node_ndx)[idx]];
ss_node1 = ((int64_t *)side_sets_node_list)[((int64_t *)ss_elem_node_ndx)[idx] + 1];
p_ndx = ((int64_t *)ss_parm_ndx)[idx];
}
else {
idx = ((int *)ss_elem_ndx)[j];
elem = ((int *)side_sets_elem_list)[idx];
ss_node0 = ((int *)side_sets_node_list)[((int *)ss_elem_node_ndx)[idx]];
ss_node1 = ((int *)side_sets_node_list)[((int *)ss_elem_node_ndx)[idx] + 1];
p_ndx = ((int *)ss_parm_ndx)[idx];
}
elem_num = elem - 1;
if (elem > elem_ctr) {
/* release connectivity array space and get next one */
if (elem_ctr > 0) {
free(connect);
}
/* Allocate space for the connectivity array for new element block */
if (!(connect = malloc(elem_blk_parms[p_ndx].num_elem_in_blk *
elem_blk_parms[p_ndx].num_nodes_per_elem * int_size))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate space for connectivity "
"array for file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* get connectivity array */
if (ex_get_conn(exoid, EX_ELEM_BLOCK, elem_blk_parms[p_ndx].elem_blk_id, connect, NULL,
NULL) == -1) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get connectivity array for elem blk %" PRId64 " for file id %d",
elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
elem_ctr = elem_blk_parms[p_ndx].elem_ctr;
}
/* For the first node of each side in side set, using a linear search
(of up to num_nodes_per_elem) of the connectivity array,
locate the node position in the element. The first node position
and the second node position are used with a element type specific
table to determine the side. */
if (connect == NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: logic error. Connect pointer is null for elem blk %" PRId64
" for file id %d",
elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
/* calculate the relative element number position in it's block*/
elem_num_pos =
elem_num - (elem_blk_parms[p_ndx].elem_ctr - elem_blk_parms[p_ndx].num_elem_in_blk);
/* calculate the beginning of the node list for this element by
using the ss_elem_node_ndx index into the side_sets_node_index
and adding the element number position * number of nodes per elem */
num_nodes_per_elem = elem_blk_parms[p_ndx].num_nodes_per_elem;
for (n = 0; n < num_nodes_per_elem; n++) {
/* find node in connectivity array that matches first node in side set */
if (((int_size == sizeof(int64_t)) &&
(ss_node0 == ((int64_t *)connect)[num_nodes_per_elem * (elem_num_pos) + n])) ||
((int_size == sizeof(int)) &&
(ss_node0 == ((int *)connect)[num_nodes_per_elem * (elem_num_pos) + n]))) {
switch (elem_blk_parms[p_ndx].elem_type_val) {
case EX_EL_CIRCLE:
case EX_EL_SPHERE: {
/* simple case: 1st node number is same as side # */
put_side(side_sets_side_list, idx, n + 1, int_size);
break;
}
case EX_EL_QUAD:
case EX_EL_TRIANGLE:
case EX_EL_TRUSS:
case EX_EL_BEAM: {
/* simple case: 1st node number is same as side # */
put_side(side_sets_side_list, idx, n + 1, int_size);
break;
}
case EX_EL_TRISHELL: {
/* use table to find which node to compare to next */
if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n + 1] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(trishell_table[0][2 * n + 2] - 1),
int_size)) {
/* Assume only front or back, no edges... */
put_side(side_sets_side_list, idx, trishell_table[1][2 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find TRIANGULAR SHELL element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_SHELL: {
/* use table to find which node to compare to next */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
num_node_per_side =
((int64_t *)ss_elem_node_ndx)[idx + 1] - ((int64_t *)ss_elem_node_ndx)[idx];
}
else {
num_node_per_side = ((int *)ss_elem_node_ndx)[idx + 1] - ((int *)ss_elem_node_ndx)[idx];
}
if (ss_node1 ==
get_node(connect, num_nodes_per_elem * (elem_num_pos) + (shell_table[0][2 * n] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n], int_size);
}
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(shell_table[0][2 * n + 1] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n + 1], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n + 1], int_size);
}
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(shell_table[0][2 * n + 2] - 1),
int_size)) {
if (num_node_per_side >= 4) {
/* 4- or 8-node side (front or back face) */
put_side(side_sets_side_list, idx, shell_table[1][2 * n + 2], int_size);
}
else {
/* 2- or 3-node side (edge of shell) */
put_side(side_sets_side_list, idx, shell_edge_table[1][2 * n + 2], int_size);
}
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find SHELL element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_HEX: {
/* use table to find which node to compare to next */
if (ss_node1 == get_node(connect,
num_nodes_per_elem * (elem_num_pos) + (hex_table[0][3 * n] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(hex_table[0][3 * n + 1] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(hex_table[0][3 * n + 2] - 1),
int_size)) {
put_side(side_sets_side_list, idx, hex_table[1][3 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find HEX element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_TETRA: {
/* use table to find which node to compare to next */
if (ss_node1 ==
get_node(connect, num_nodes_per_elem * (elem_num_pos) + (tetra_table[0][3 * n] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(tetra_table[0][3 * n + 1] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n + 1], int_size);
}
else if (ss_node1 == get_node(connect, num_nodes_per_elem * (elem_num_pos) +
(tetra_table[0][3 * n + 2] - 1),
int_size)) {
put_side(side_sets_side_list, idx, tetra_table[1][3 * n + 2], int_size);
}
else {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to find TETRA element %" PRId64 ", node %" PRId64
" in connectivity array %" PRId64 " for file id %d",
elem_num + 1, ss_node1, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
break;
}
case EX_EL_PYRAMID: {
/* NOTE: PYRAMID elements in side set node lists are currently not
* supported */
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported PYRAMID element found in side "
"set node list in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
case EX_EL_WEDGE: {
/* NOTE: WEDGE elements in side set node lists are currently not
* supported */
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported WEDGE element found in side set "
"node list in file id %d",
exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
default: {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: %s is an unsupported element type",
elem_blk_parms[p_ndx].elem_type);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
}
break; /* done with this element */
}
}
if (n >= num_nodes_per_elem) /* did we find the node? */
{
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find element %" PRId64 ", node %" PRId64
" in element block %" PRId64 " for file id %d",
elem_num + 1, ss_node0, elem_blk_parms[p_ndx].elem_blk_id, exoid);
ex_err("ex_cvt_nodes_to_sides", errmsg, exerrval);
err_stat = EX_FATAL;
goto cleanup;
}
}
/* All done: release connectivity array space, element block ids array,
element block parameters array, and side set element index array */
cleanup:
free(connect);
free(ss_elem_node_ndx);
free(ss_parm_ndx);
free(elem_blk_parms);
free(elem_blk_ids);
free(ss_elem_ndx);
free(same_elem_type);
return (err_stat);
}
int ex_put_all_var_param_ext(int exoid, const ex_var_params *vp)
{
int in_define = 0;
int status;
int temp;
int time_dim, num_nod_dim, dimid;
size_t num_elem_blk, num_edge_blk, num_face_blk;
size_t num_nset, num_eset, num_fset, num_sset, num_elset;
int numelblkdim, numelvardim, numedvardim, numedblkdim, numfavardim, numfablkdim, numnsetdim,
nsetvardim, numesetdim, esetvardim, numfsetdim, fsetvardim, numssetdim, ssetvardim,
numelsetdim, elsetvardim;
int i;
int edblk_varid, fablk_varid, eblk_varid, nset_varid, eset_varid, fset_varid, sset_varid,
elset_varid, varid;
void_int *eblk_ids = NULL;
void_int *edblk_ids = NULL;
void_int *fablk_ids = NULL;
void_int *nset_ids = NULL;
void_int *eset_ids = NULL;
void_int *fset_ids = NULL;
void_int *sset_ids = NULL;
void_int *elset_ids = NULL;
int *eblk_stat = NULL;
int *edblk_stat = NULL;
int *fablk_stat = NULL;
int *nset_stat = NULL;
int *eset_stat = NULL;
int *fset_stat = NULL;
int *sset_stat = NULL;
int *elset_stat = NULL;
int dims[3];
char errmsg[MAX_ERR_LENGTH];
const char *routine = "ex_put_all_var_param_ext";
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_TIME, &time_dim)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate time dimension in file id %d", exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret;
}
if ((status = nc_inq_dimid(exoid, DIM_NUM_NODES, &num_nod_dim)) != NC_NOERR) {
num_nod_dim = -1; /* There is probably no nodes on this file */
}
/* Check this now so we can use it later without checking for errors */
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &temp)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get string length in file id %d", exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret;
}
EX_GET_IDS_STATUS("edge block", vp->num_edge, DIM_NUM_ED_BLK, numedblkdim, num_edge_blk,
edblk_ids, EX_EDGE_BLOCK, VAR_STAT_ED_BLK, edblk_stat);
EX_GET_IDS_STATUS("face block", vp->num_face, DIM_NUM_FA_BLK, numfablkdim, num_face_blk,
fablk_ids, EX_FACE_BLOCK, VAR_STAT_FA_BLK, fablk_stat);
EX_GET_IDS_STATUS("element block", vp->num_elem, DIM_NUM_EL_BLK, numelblkdim, num_elem_blk,
eblk_ids, EX_ELEM_BLOCK, VAR_STAT_EL_BLK, eblk_stat);
EX_GET_IDS_STATUS("node set", vp->num_nset, DIM_NUM_NS, numnsetdim, num_nset, nset_ids,
EX_NODE_SET, VAR_NS_STAT, nset_stat);
EX_GET_IDS_STATUS("edge set", vp->num_eset, DIM_NUM_ES, numesetdim, num_eset, eset_ids,
EX_EDGE_SET, VAR_ES_STAT, eset_stat);
EX_GET_IDS_STATUS("face set", vp->num_fset, DIM_NUM_FS, numfsetdim, num_fset, fset_ids,
EX_FACE_SET, VAR_FS_STAT, fset_stat);
EX_GET_IDS_STATUS("side set", vp->num_sset, DIM_NUM_SS, numssetdim, num_sset, sset_ids,
EX_SIDE_SET, VAR_SS_STAT, sset_stat);
EX_GET_IDS_STATUS("element set", vp->num_elset, DIM_NUM_ELS, numelsetdim, num_elset, elset_ids,
EX_ELEM_SET, VAR_ELS_STAT, elset_stat);
/* put file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file id %d into define mode", exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret;
}
in_define = 1;
/* define dimensions and variables */
if (vp->num_glob > 0) {
if (define_dimension(exoid, DIM_NUM_GLO_VAR, vp->num_glob, "global", &dimid) != NC_NOERR) {
goto error_ret;
}
dims[0] = time_dim;
dims[1] = dimid;
if ((status = nc_def_var(exoid, VAR_GLO_VAR, nc_flt_code(exoid), 2, dims, &varid)) !=
NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define global variables in file id %d",
exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
/* Now define global variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_GLO_VAR, dimid, "global") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_node > 0) {
/*
* There are two ways to store the nodal variables. The old way *
* was a blob (#times,#vars,#nodes), but that was exceeding the
* netcdf maximum dataset size for large models. The new way is
* to store #vars separate datasets each of size (#times,#nodes)
*
* We want this routine to be capable of storing both formats
* based on some external flag. Since the storage format of the
* coordinates have also been changed, we key off of their
* storage type to decide which method to use for nodal
* variables. If the variable 'coord' is defined, then store old
* way; otherwise store new.
*/
if (define_dimension(exoid, DIM_NUM_NOD_VAR, vp->num_node, "nodal", &dimid) != NC_NOERR) {
goto error_ret;
}
if (num_nod_dim > 0) {
if (ex_large_model(exoid) == 0) { /* Old way */
dims[0] = time_dim;
dims[1] = dimid;
dims[2] = num_nod_dim;
if ((status = nc_def_var(exoid, VAR_NOD_VAR, nc_flt_code(exoid), 3, dims, &varid)) !=
NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define nodal variables in file id %d",
exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
}
else { /* Store new way */
for (i = 1; i <= vp->num_node; i++) {
dims[0] = time_dim;
dims[1] = num_nod_dim;
if ((status = nc_def_var(exoid, VAR_NOD_VAR_NEW(i), nc_flt_code(exoid), 2, dims,
&varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define nodal variable %d in file id %d", i, exoid);
ex_err("ex_put_var_param", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
}
/* Now define nodal variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_NOD_VAR, dimid, "nodal") != NC_NOERR) {
goto error_ret;
}
}
#define EX_DEFINE_VARS(TID, STNAME, TNAME, NUMVAR, DNAME, DID1, DID2, DVAL, VIDS, VNOV, VTV, \
VSTATVAL, VTABVAL, VTABVAR) \
if (NUMVAR > 0) { \
status = define_dimension(exoid, DNAME, NUMVAR, STNAME, &DID2); \
if (status != NC_NOERR) \
goto error_ret; \
\
/* Now define STNAME variable name variable */ \
if (define_variable_name_variable(exoid, VNOV, DID2, STNAME) != NC_NOERR) \
goto error_ret; \
\
if (define_truth_table(TID, exoid, DVAL, NUMVAR, VTABVAL, VSTATVAL, VIDS, TNAME) != NC_NOERR) \
goto error_ret; \
\
free(VSTATVAL); \
VSTATVAL = NULL; \
free(VIDS); \
VIDS = NULL; \
\
/* create a variable array in which to store the STNAME variable truth \
* table \
*/ \
\
dims[0] = DID1; \
dims[1] = DID2; \
\
if ((status = nc_def_var(exoid, VTV, NC_INT, 2, dims, &VTABVAR)) != NC_NOERR) { \
exerrval = status; \
snprintf(errmsg, MAX_ERR_LENGTH, \
"ERROR: failed to define " STNAME " variable truth table in file id %d", exoid); \
ex_err("ex_put_all_var_param_ext", errmsg, exerrval); \
goto error_ret; /* exit define mode and return */ \
} \
}
EX_DEFINE_VARS(EX_EDGE_BLOCK, "edge", "edge block", vp->num_edge, DIM_NUM_EDG_VAR, numedblkdim,
numedvardim, num_edge_blk, edblk_ids, VAR_NAME_EDG_VAR, VAR_EBLK_TAB, edblk_stat,
vp->edge_var_tab, edblk_varid);
EX_DEFINE_VARS(EX_FACE_BLOCK, "face", "face block", vp->num_face, DIM_NUM_FAC_VAR, numfablkdim,
numfavardim, num_face_blk, fablk_ids, VAR_NAME_FAC_VAR, VAR_FBLK_TAB, fablk_stat,
vp->face_var_tab, fablk_varid);
EX_DEFINE_VARS(EX_ELEM_BLOCK, "element", "element block", vp->num_elem, DIM_NUM_ELE_VAR,
numelblkdim, numelvardim, num_elem_blk, eblk_ids, VAR_NAME_ELE_VAR, VAR_ELEM_TAB,
eblk_stat, vp->elem_var_tab, eblk_varid);
EX_DEFINE_VARS(EX_NODE_SET, "nodeset", "node set", vp->num_nset, DIM_NUM_NSET_VAR, numnsetdim,
nsetvardim, num_nset, nset_ids, VAR_NAME_NSET_VAR, VAR_NSET_TAB, nset_stat,
vp->nset_var_tab, nset_varid);
EX_DEFINE_VARS(EX_EDGE_SET, "edgeset", "edge set", vp->num_eset, DIM_NUM_ESET_VAR, numesetdim,
esetvardim, num_eset, eset_ids, VAR_NAME_ESET_VAR, VAR_ESET_TAB, eset_stat,
vp->eset_var_tab, eset_varid);
EX_DEFINE_VARS(EX_FACE_SET, "faceset", "face set", vp->num_fset, DIM_NUM_FSET_VAR, numfsetdim,
fsetvardim, num_fset, fset_ids, VAR_NAME_FSET_VAR, VAR_FSET_TAB, fset_stat,
vp->fset_var_tab, fset_varid);
EX_DEFINE_VARS(EX_SIDE_SET, "sideset", "side set", vp->num_sset, DIM_NUM_SSET_VAR, numssetdim,
ssetvardim, num_sset, sset_ids, VAR_NAME_SSET_VAR, VAR_SSET_TAB, sset_stat,
vp->sset_var_tab, sset_varid);
EX_DEFINE_VARS(EX_ELEM_SET, "elemset", "element set", vp->num_elset, DIM_NUM_ELSET_VAR,
numelsetdim, elsetvardim, num_elset, elset_ids, VAR_NAME_ELSET_VAR, VAR_ELSET_TAB,
elset_stat, vp->elset_var_tab, elset_varid);
/* leave define mode */
in_define = 0;
if ((status = nc_enddef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition in file id %d", exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret;
}
/* write out the variable truth tables */
if (vp->num_edge > 0) {
if (put_truth_table(exoid, edblk_varid, vp->edge_var_tab, "edge") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_face > 0) {
if (put_truth_table(exoid, fablk_varid, vp->face_var_tab, "face") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_elem > 0) {
if (put_truth_table(exoid, eblk_varid, vp->elem_var_tab, "element") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_nset > 0) {
if (put_truth_table(exoid, nset_varid, vp->nset_var_tab, "nodeset") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_eset > 0) {
if (put_truth_table(exoid, eset_varid, vp->eset_var_tab, "edgeset") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_fset > 0) {
if (put_truth_table(exoid, fset_varid, vp->fset_var_tab, "faceset") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_sset > 0) {
if (put_truth_table(exoid, sset_varid, vp->sset_var_tab, "sideset") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_elset > 0) {
if (put_truth_table(exoid, elset_varid, vp->elset_var_tab, "elemset") != NC_NOERR) {
goto error_ret;
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (in_define == 1) {
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_all_var_param_ext", errmsg, exerrval);
}
}
free(eblk_ids);
free(edblk_ids);
free(fablk_ids);
free(nset_ids);
free(eset_ids);
free(fset_ids);
free(sset_ids);
free(elset_ids);
free(eblk_stat);
free(edblk_stat);
free(fablk_stat);
free(nset_stat);
free(eset_stat);
free(fset_stat);
free(sset_stat);
free(elset_stat);
return (EX_FATAL);
}
int ex_put_partial_attr(int exoid, ex_entity_type blk_type, ex_entity_id blk_id,
int64_t start_entity, int64_t num_entity, const void *attrib)
{
int status;
int attrid;
int blk_id_ndx = 0;
int numattrdim;
size_t start[2], count[2];
size_t num_attr;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
if (blk_type != EX_NODAL) {
/* Determine index of blk_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 attributes allowed 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 attributes for this block */
}
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: no %s id %" PRId64 " in 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_SIDE_SET: status = nc_inq_varid(exoid, VAR_SSATTRIB(blk_id_ndx), &attrid); break;
case EX_NODE_SET: status = nc_inq_varid(exoid, VAR_NSATTRIB(blk_id_ndx), &attrid); break;
case EX_EDGE_SET: status = nc_inq_varid(exoid, VAR_ESATTRIB(blk_id_ndx), &attrid); break;
case EX_FACE_SET: status = nc_inq_varid(exoid, VAR_FSATTRIB(blk_id_ndx), &attrid); break;
case EX_ELEM_SET: status = nc_inq_varid(exoid, VAR_ELSATTRIB(blk_id_ndx), &attrid); break;
case EX_NODAL: status = nc_inq_varid(exoid, VAR_NATTRIB, &attrid); break;
case EX_EDGE_BLOCK: status = nc_inq_varid(exoid, VAR_EATTRIB(blk_id_ndx), &attrid); break;
case EX_FACE_BLOCK: status = nc_inq_varid(exoid, VAR_FATTRIB(blk_id_ndx), &attrid); break;
case EX_ELEM_BLOCK: status = nc_inq_varid(exoid, VAR_ATTRIB(blk_id_ndx), &attrid); break;
default:
snprintf(errmsg, MAX_ERR_LENGTH,
"Internal ERROR: unrecognized object 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 */
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate attribute variable 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);
}
/* Determine number of attributes */
switch (blk_type) {
case EX_SIDE_SET: status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_SS(blk_id_ndx), &numattrdim); break;
case EX_NODE_SET: status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_NS(blk_id_ndx), &numattrdim); break;
case EX_EDGE_SET: status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_ES(blk_id_ndx), &numattrdim); break;
case EX_FACE_SET: status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_FS(blk_id_ndx), &numattrdim); break;
case EX_ELEM_SET:
status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_ELS(blk_id_ndx), &numattrdim);
break;
case EX_NODAL: status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_NBLK, &numattrdim); break;
case EX_EDGE_BLOCK:
status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_EBLK(blk_id_ndx), &numattrdim);
break;
case EX_FACE_BLOCK:
status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_FBLK(blk_id_ndx), &numattrdim);
break;
case EX_ELEM_BLOCK:
status = nc_inq_dimid(exoid, DIM_NUM_ATT_IN_BLK(blk_id_ndx), &numattrdim);
break;
default:
/* No need for error message, handled in previous switch; just to quiet
* compiler. */
EX_FUNC_LEAVE(EX_FATAL);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: number of attributes not defined 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); /* number of attributes not defined */
}
if ((status = nc_inq_dimlen(exoid, numattrdim, &num_attr)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of attributes 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);
}
/* write out the attributes */
start[0] = --start_entity;
start[1] = 0;
count[0] = num_entity;
count[1] = num_attr;
if (count[0] == 0) {
start[0] = 0;
}
if (ex_comp_ws(exoid) == 4) {
status = nc_put_vara_float(exoid, attrid, start, count, attrib);
}
else {
status = nc_put_vara_double(exoid, attrid, start, count, attrib);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put attributes 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);
}