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_put_partial_set_dist_fact (int exoid,
ex_entity_type set_type,
ex_entity_id set_id,
int64_t offset,
int64_t num_to_put,
const void *set_dist_fact)
{
int status;
int dimid, set_id_ndx;
int dist_id;
size_t start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
char* factptr = NULL;
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;
sprintf(errmsg,
"Error: no %ss specified in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_set_dist_fact",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) {
sprintf(errmsg,
"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_fact",errmsg,EX_NULLENTITY);
return (EX_WARN);
} else {
sprintf(errmsg,
"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_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
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);
}
/* find id of distribution factors variable
*/
if ((status = nc_inq_varid(exoid, factptr, &dist_id)) != NC_NOERR) {
/* this test is only needed for node set because we're using
DIM_NUM_NOD_NS instead of DIM_NUM_DF_NS*/
if (status == NC_ENOTVAR) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: no dist factors defined for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set_dist_fact",errmsg,exerrval);
return (EX_WARN);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate dist factors list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
start[0] = offset-1;
count[0] = num_to_put;
if (num_to_put == 0)
start[0] = 0;
/* write out the distribution factors array */
if (ex_comp_ws(exoid) == 4) {
status = nc_put_vara_float(exoid, dist_id, start, count, set_dist_fact);
} else {
status = nc_put_vara_double(exoid, dist_id, start, count, set_dist_fact);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store dist factors for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_partial_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
return (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 *routine = "ex_put_name";
const char *vobj;
exerrval = 0; /* clear error code */
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:
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid type specified in file id %d", exoid);
ex_err(routine,errmsg,exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, vobj, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s names in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
ent_ndx = ex_id_lkup(exoid, obj_type, entity_id);
if (exerrval == EX_LOOKUPFAIL) { /* could not find the element block id */
sprintf(errmsg,
"Error: %s id %"PRId64" not found in file id %d",
ex_name_of_object(obj_type), entity_id, exoid);
ex_err("ex_put_name",errmsg,exerrval);
return (EX_FATAL);
}
/* If this is a null entity, then 'ent_ndx' will be negative.
* We don't care in this routine, 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, "", routine);
return(status);
}
int ex_put_set_param (int exoid,
ex_entity_type set_type,
int set_id,
int num_entries_in_set,
int num_dist_fact_in_set)
{
int status;
size_t temp;
int dimid, varid, set_id_ndx, dims[1];
size_t start[1];
int num_sets;
int ldum;
int cur_num_sets, set_stat;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
char* dimptr;
char* idsptr;
char* statptr;
char* numentryptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
char* entryptr = NULL;
char* extraptr = NULL;
exerrval = 0; /* clear error code */
cdum = 0;
/* setup pointers based on set_type
NOTE: there is another block that sets more stuff later ... */
if (set_type == EX_NODE_SET) {
dimptr = DIM_NUM_NS;
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (set_type == EX_EDGE_SET) {
dimptr = DIM_NUM_ES;
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (set_type == EX_FACE_SET) {
dimptr = DIM_NUM_FS;
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (set_type == EX_SIDE_SET) {
dimptr = DIM_NUM_SS;
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (set_type == EX_ELEM_SET) {
dimptr = DIM_NUM_ELS;
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
else {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: invalid set type (%d)", set_type);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* first check if any of that set type is specified */
if ((status = nc_inq_dimid(exoid, dimptr, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss specified in file id %d", ex_name_of_object(set_type),
exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate set id entry */
ex_id_lkup(exoid, set_type, set_id);
if (exerrval != EX_LOOKUPFAIL) { /* found the side set id */
sprintf(errmsg,
"Error: %s %d already defined in file id %d", ex_name_of_object(set_type),
set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return(EX_FATAL);
}
/* Get number of sets specified for this file */
if ((status = nc_inq_dimlen(exoid,dimid,&temp)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
num_sets = temp;
/* Keep track of the total number of sets defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item finds the maximum number of sets defined
for a specific file and returns that value.
*/
cur_num_sets=ex_get_file_item(exoid, ex_get_counter_list(set_type));
if (cur_num_sets >= num_sets) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(set_type), num_sets,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* 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(set_type));
set_id_ndx = cur_num_sets + 1;
/* setup more pointers based on set_type */
if (set_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 (set_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 (set_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 (set_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);
}
if (set_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);
}
/* write out information to previously defined variable */
/* first: get id of set id variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %d in file id %d", ex_name_of_object(set_type),
set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* write out set id */
start[0] = cur_num_sets;
ldum = (int)set_id;
if ((status = nc_put_var1_int(exoid, varid, start, &ldum)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %d in file id %d", ex_name_of_object(set_type),
set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (num_entries_in_set == 0) /* Is this a NULL set? */
set_stat = 0; /* change set status to NULL */
else
set_stat = 1; /* change set status to TRUE */
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d", ex_name_of_object(set_type),
exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
ldum = (int)set_stat;
if ((status = nc_put_var1_int(exoid, varid, start, &ldum)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s %d status to file id %d", ex_name_of_object(set_type),
set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (num_entries_in_set == 0) {/* Is this a NULL set? */
return(EX_NOERR);
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* define dimensions and variables */
if ((status = nc_def_dim(exoid, numentryptr,
num_entries_in_set, &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE)
{
sprintf(errmsg,
"Error: %s %d size already defined in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
else {
sprintf(errmsg,
"Error: failed to define number of entries in %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
goto error_ret;
}
/* create variable array in which to store the entry lists */
dims[0] = dimid;
if ((status = nc_def_var(exoid, entryptr, NC_INT, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: entry list already exists for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create entry list for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if (extraptr) {
if ((status = nc_def_var(exoid, extraptr, NC_INT, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: extra list already exists for %s %d in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create extra list for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
}
/* Create distribution factors variable if required */
if (num_dist_fact_in_set > 0) {
if (set_type == EX_NODE_SET) {
/* but num_dist_fact_in_set must equal number of nodes */
if (num_dist_fact_in_set != num_entries_in_set) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%d) not equal to # nodes (%d) in node set %d file id %d",
num_dist_fact_in_set, num_entries_in_set, set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* resuse dimid from entry lists */
} else {
if ((status = nc_def_dim(exoid, numdfptr,
num_dist_fact_in_set, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of dist factors in %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* create variable array in which to store the set distribution factors
*/
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: dist factors list already exists for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create dist factors list for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d", exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_set_param",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;
size_t int_size;
exerrval = 0; /* clear error code */
sets_to_define = malloc(set_count*sizeof(int));
/* Note that this routine can be called:
1) just define the sets
2) just output the set data (after a previous call to define)
3) define and output the set data in one call.
*/
for (i=0; i < set_count; i++) {
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(sets[i].type), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss defined for file id %d", ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
set_id_ndx = ex_id_lkup(exoid, sets[i].type, sets[i].id);
if (exerrval != EX_LOOKUPFAIL) { /* found the side set id, so set is already defined... */
sets_to_define[i] = 0;
continue;
} else {
needs_define++;
sets_to_define[i] = 1;
}
}
if (needs_define > 0) {
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i < set_count; i++) {
if (sets_to_define[i] == 0)
continue;
/* NOTE: ex_inc_file_item finds the current number of sets defined
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(sets[i].type));
set_id_ndx = cur_num_sets + 1;
sets_to_define[i] = set_id_ndx;
if (sets[i].num_entry == 0)
continue;
/* setup pointers based on set_type */
if (sets[i].type == EX_NODE_SET) {
numentryptr = DIM_NUM_NOD_NS(set_id_ndx);
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (sets[i].type == EX_EDGE_SET) {
numentryptr = DIM_NUM_EDGE_ES(set_id_ndx);
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (sets[i].type == EX_FACE_SET) {
numentryptr = DIM_NUM_FACE_FS(set_id_ndx);
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (sets[i].type == EX_SIDE_SET) {
numentryptr = DIM_NUM_SIDE_SS(set_id_ndx);
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
else if (sets[i].type == EX_ELEM_SET) {
numentryptr = DIM_NUM_ELE_ELS(set_id_ndx);
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* define dimensions and variables */
if ((status = nc_def_dim(exoid, numentryptr,
sets[i].num_entry, &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: %s %"PRId64" -- size already defined in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
else {
sprintf(errmsg,
"Error: failed to define number of entries in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret;
}
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
int_size = sizeof(int64_t);
}
/* create variable array in which to store the entry lists */
dims[0] = dimid;
if ((status = nc_def_var(exoid, entryptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: entry list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create entry list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
if (extraptr) {
if ((status = nc_def_var(exoid, extraptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: extra list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create extra list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
}
/* Create distribution factors variable if required */
if (sets[i].num_distribution_factor > 0) {
if (sets[i].type != EX_SIDE_SET) {
/* but sets[i].num_distribution_factor must equal number of nodes */
if (sets[i].num_distribution_factor != sets[i].num_entry) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%"PRId64") not equal to # nodes (%"PRId64") in node set %"PRId64" file id %d",
sets[i].num_distribution_factor, sets[i].num_entry, sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* resuse dimid from entry lists */
if ((status = nc_def_dim(exoid, numdfptr,
sets[i].num_distribution_factor, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of dist factors in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* create variable array in which to store the set distribution factors
*/
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: dist factors list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create dist factors list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d", exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* Output the set ids and status... */
for (i=0; i < set_count; i++) {
/* setup pointers based on sets[i].type */
if (sets[i].type == EX_NODE_SET) {
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (sets[i].type == EX_EDGE_SET) {
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (sets[i].type == EX_FACE_SET) {
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (sets[i].type == EX_SIDE_SET) {
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (sets[i].type == EX_ELEM_SET) {
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
/* first: get id of set id variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* write out set id */
start[0] = sets_to_define[i]-1;
status = nc_put_var1_longlong(exoid, varid, start, (long long*)&sets[i].id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
set_stat = (sets[i].num_entry == 0) ? 0 : 1;
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d", ex_name_of_object(sets[i].type),
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &set_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s %"PRId64" status to file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
}
free(sets_to_define);
}
/* Sets are now all defined; see if any set data needs to be output... */
status = EX_NOERR;
for (i=0; i < set_count; i++) {
int stat;
if (sets[i].entry_list != NULL || sets[i].extra_list != NULL) {
/* NOTE: ex_put_set will write the warning/error message... */
stat = ex_put_set(exoid, sets[i].type, sets[i].id, sets[i].entry_list, sets[i].extra_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
if (sets[i].distribution_factor_list != NULL) {
/* NOTE: ex_put_set_dist_fact will write the warning/error message... */
stat = ex_put_set_dist_fact(exoid, sets[i].type, sets[i].id, sets[i].distribution_factor_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
}
return (status);
/* Fatal error: exit definition mode and return */
error_ret:
free(sets_to_define);
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_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_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
*/
{
const char *func_name="ex_get_elem_type";
int connid, el_blk_id_ndx, status;
size_t len;
char errmsg[MAX_ERR_LENGTH];
/*****************************************************************************/
/* inquire id's of previously defined dimensions */
if ((el_blk_id_ndx=ex_id_lkup(exoid, EX_ELEM_BLOCK, elem_blk_id)) == -1) {
sprintf(errmsg,
"Error: failed to find element block ID %"PRId64" in file %d",
elem_blk_id, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, VAR_CONN(el_blk_id_ndx), &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find connectivity variable in file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* get the element type name */
if ((status = nc_inq_attlen(exoid, connid, ATT_NAME_ELB, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find attribute in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if (len > (MAX_STR_LENGTH+1)) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: Element type must be of length %d in file ID %d",
(int)len, exoid);
ex_err(func_name, errmsg, exerrval);
return (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 ) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get attribute \"%s\" in file ID %d",
ATT_NAME_ELB, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_partial_elem_map (int exoid,
int map_id,
int ent_start,
int ent_count,
int *elem_map)
{
int dimid, var_id, id_ndx, iresult;
long num_elem, start[1], count[1];
nclong *longs;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* See if file contains any elements...*/
if ((dimid = ncdimid (exoid, DIM_NUM_ELEM)) == -1)
{
return (EX_NOERR);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_elem) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of elements in file id %d", exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (ent_start <= 0 || ent_start > num_elem) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: start count is invalid in file id %d",
exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_FATAL);
}
if (ent_count < 0) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: Invalid count value in file id %d",
exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_FATAL);
}
if (ent_start+ent_count-1 > num_elem) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: start+count-1 is larger than element count in file id %d",
exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_FATAL);
}
/* first check if any element maps have been defined */
if ((dimid = ncdimid (exoid, DIM_NUM_EM)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no element maps defined in file id %d",
exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_WARN);
}
/* Lookup index of element map id property array */
id_ndx = ex_id_lkup(exoid,VAR_EM_PROP(1),map_id);
if (exerrval != 0)
{
sprintf(errmsg,
"Error: failed to locate element map id %d in %s in file id %d",
map_id,VAR_EM_PROP(1),exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_FATAL);
}
/* inquire id's of previously defined dimensions and variables */
if ((var_id = ncvarid (exoid, VAR_ELEM_MAP(id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element map %d in file id %d",
map_id,exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the element map */
/* application code has allocated an array of ints but netcdf is expecting
a pointer to nclongs; if ints are different sizes than nclongs,
we must allocate an array of nclongs then convert them to ints with ltoi */
start[0] = ent_start-1;
count[0] = ent_count;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarget (exoid, var_id, start, count, elem_map);
} else {
if (!(longs = malloc(ent_count * sizeof(nclong)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for element map for file id %d",
exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_FATAL);
}
iresult = ncvarget (exoid, var_id, start, count, longs);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get element map in file id %d",
exoid);
ex_err("ex_get_partial_elem_map",errmsg,exerrval);
return (EX_FATAL);
}
if (sizeof(int) != sizeof(nclong)) {
ltoi (longs, elem_map, ent_count);
free (longs);
}
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_partial_node_set_df (int exoid,
ex_entity_id node_set_id,
int64_t start_num,
int64_t num_df_to_get,
void *node_set_dist_fact)
{
int status;
int dimid, dist_id, node_set_id_ndx;
size_t num_nodes_in_set, start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any node sets are specified */
if ((status = nc_inq_dimid (exoid, DIM_NUM_NS, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no node sets defined in file id %d",
exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_WARN);
}
/* Lookup index of node set id in VAR_NS_IDS array */
if ((node_set_id_ndx = ex_id_lkup(exoid,EX_NODE_SET,node_set_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: node set %"PRId64" is NULL in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set_df",errmsg,EX_MSG);
return (EX_WARN);
} else {
sprintf(errmsg,
"Error: failed to locate node set %"PRId64" in %s in file id %d",
node_set_id,VAR_NS_IDS,exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_dimid (exoid, DIM_NUM_NOD_NS(node_set_id_ndx), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %"PRId64" in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_nodes_in_set)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in node set %"PRId64" in file id %d",
node_set_id, exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (start_num < 0 || start_num > num_nodes_in_set) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid input");
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
if (num_df_to_get < 0) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid number of nodes in nodes set!");
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
/* start_num now starts at 1, not 0 */
if ((start_num + num_df_to_get - 1) > num_nodes_in_set) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: request larger than number of nodes in set!");
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid (exoid, VAR_FACT_NS(node_set_id_ndx), &dist_id)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: dist factors not stored for node set %"PRId64" in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_WARN); /* complain - but not too loud */
}
/* read in the distribution factors array */
start[0] = --start_num;
count[0] = num_df_to_get;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, dist_id, start, count, node_set_dist_fact);
} else {
status = nc_get_vara_double(exoid, dist_id, start, count, node_set_dist_fact);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get distribution factors in file id %d",
exoid);
ex_err("ex_get_partial_node_set_df",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_put_name (int exoid,
int obj_type,
int entity_id,
const char *name)
{
int varid, ent_ndx;
long start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
const char *routine = "ex_put_name";
exerrval = 0; /* clear error code */
if (obj_type == EX_ELEM_BLOCK) {
if ((varid = ncvarid (exoid, VAR_NAME_EL_BLK)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element block names in file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
ent_ndx = ex_id_lkup(exoid, VAR_ID_EL_BLK, entity_id);
}
else if (obj_type == EX_NODE_SET) {
if ((varid = ncvarid (exoid, VAR_NAME_NS)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate nodeset names in file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
ent_ndx = ex_id_lkup(exoid, VAR_NS_IDS, entity_id);
}
else if (obj_type == EX_SIDE_SET) {
if ((varid = ncvarid (exoid, VAR_NAME_SS)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate sideset names in file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
ent_ndx = ex_id_lkup(exoid, VAR_SS_IDS, entity_id);
}
else if (obj_type == EX_NODE_MAP) {
if ((varid = ncvarid (exoid, VAR_NAME_NM)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate node map names in file id %d", exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
ent_ndx = ex_id_lkup(exoid, VAR_NM_PROP(1), entity_id);
}
else if (obj_type == EX_ELEM_MAP) {
if ((varid = ncvarid (exoid, VAR_NAME_EM)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element map names in file id %d", exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
ent_ndx = ex_id_lkup(exoid, VAR_EM_PROP(1), entity_id);
}
else {/* invalid type */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid type specified in file id %d", exoid);
ex_err(routine,errmsg,exerrval);
return(EX_FATAL);
}
/* If this is a null entity, then 'ent_ndx' will be negative.
* We don't care in this routine, so make it positive and continue...
*/
if (ent_ndx < 0) ent_ndx = -ent_ndx;
/* write EXODUS entityname */
start[0] = ent_ndx-1;
start[1] = 0;
count[0] = 1;
count[1] = strlen(name) + 1;
if (ncvarput (exoid, varid, start, count, (void*)name) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store entity name for id %d in file id %d",
ent_ndx, exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
int ex_get_entity_count_per_polyhedra (int exoid,
ex_entity_type blk_type,
int blk_id,
int *entity_counts)
{
int npeid=-1, blk_id_ndx, status;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
blk_id_ndx = ex_id_lkup(exoid,blk_type,blk_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: entity_counts array not allowed for NULL %s block %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_entity_count_per_polyhedra",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
sprintf(errmsg,
"Error: failed to locate %s block id %d in id array in file id %d",
ex_name_of_object(blk_type),blk_id, exoid);
ex_err("ex_get_entity_count_per_polyhedra",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire id's of previously defined dimensions */
switch (blk_type) {
case EX_ELEM_BLOCK:
status = nc_inq_varid (exoid, VAR_EBEPEC(blk_id_ndx), &npeid);
break;
case EX_FACE_BLOCK:
status = nc_inq_varid (exoid, VAR_FBEPEC(blk_id_ndx), &npeid);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized block type in switch: %d in file id %d",
blk_type,exoid);
ex_err("ex_get_entity_count_per_polyhedra",errmsg,EX_MSG);
return (EX_FATAL);
}
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate entity_counts array for %s block %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_entity_count_per_polyhedra",errmsg, exerrval);
return(EX_FATAL);
}
status = nc_get_var_int(exoid, npeid, entity_counts);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to read node counts array for %s block %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_entity_count_per_polyhedra",errmsg, exerrval);
return(EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_partial_node_set (int exoid,
ex_entity_id node_set_id,
int64_t start_node_num,
int64_t num_nodes,
void_int *node_set_node_list)
{
int dimid, node_list_id, node_set_id_ndx, status;
size_t num_nodes_in_set, start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any node sets are specified */
if ((status = nc_inq_dimid (exoid, DIM_NUM_NS, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no node sets defined in file id %d",
exoid);
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_WARN);
}
/* Lookup index of node set id in VAR_NS_IDS array */
if ((node_set_id_ndx = ex_id_lkup(exoid, EX_NODE_SET, node_set_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: node set %"PRId64" is NULL in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set",errmsg,EX_NULLENTITY);
return (EX_WARN);
}
sprintf(errmsg,
"Error: failed to locate node set %"PRId64" in %s in file id %d",
node_set_id,VAR_NS_IDS,exoid);
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_dimid (exoid, DIM_NUM_NOD_NS(node_set_id_ndx), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %"PRId64" in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_nodes_in_set)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in set %"PRId64" in file id %d",
node_set_id, exoid);
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (start_node_num < 0 || start_node_num > num_nodes_in_set) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid input");
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_FATAL);
}
if (num_nodes < 0) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid number of nodes in nodes set!");
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* start_node_num now starts at 1, not 0 */
if ((start_node_num + num_nodes - 1) > num_nodes_in_set) {
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: request larger than number of nodes in set!");
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid (exoid, VAR_NODE_NS(node_set_id_ndx), &node_list_id)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate node set %"PRId64" node list in file id %d",
node_set_id,exoid);
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the node list array */
start[0] = --start_node_num;
count[0] = num_nodes;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_vara_longlong(exoid, node_list_id, start, count, node_set_node_list);
} else {
status = nc_get_vara_int(exoid, node_list_id, start, count, node_set_node_list);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get node set node list in file id %d",
exoid);
ex_err("ex_get_partial_node_set",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_put_node_set_param (int exoid,
int node_set_id,
int num_nodes_in_set,
int num_dist_in_set)
{
int dimid, varid, dims[1];
long start[1];
nclong ldum;
long num_node_sets;
int cur_num_node_sets, node_set_stat;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
cdum = 0;
/* first check if any node sets are specified */
if ((dimid = (ncdimid (exoid, DIM_NUM_NS))) == -1 )
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no node sets specified in file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate node set id entry */
ex_id_lkup(exoid,VAR_NS_IDS,node_set_id);
if (exerrval != EX_LOOKUPFAIL) /* found the node set id */
{
exerrval = ncerr;
sprintf(errmsg,
"Error: node set %d already defined in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return(EX_FATAL);
}
/* Get number of node sets initialized for this file */
if ((ncdiminq (exoid,dimid,cdum,&num_node_sets)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of node sets defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of node sets
for a specific file and returns that value.
*/
cur_num_node_sets=ex_get_file_item(exoid, &ns_ctr_list );
if (cur_num_node_sets >= num_node_sets)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of node sets (%ld) specified in file id %d",
num_node_sets,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is used to find the number of node sets
for a specific file and returns that value incremented. */
cur_num_node_sets=ex_inc_file_item(exoid, &ns_ctr_list );
/* write out information to previously defined variable */
/* first get id of variable */
if ((varid = ncvarid (exoid, VAR_NS_IDS)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate node set ids in file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out node set id */
start[0] = cur_num_node_sets;
ldum = (nclong)node_set_id;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store node set id %d in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (num_nodes_in_set == 0) /* Is this a NULL side set? */
node_set_stat = 0; /* change node set status to NULL */
else
node_set_stat = 1; /* change node set status to TRUE */
if ((varid = ncvarid (exoid, VAR_NS_STAT)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate node set status in file id %d", exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
ldum = (nclong)node_set_stat;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store node set %d status to file id %d",
node_set_id, exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (num_nodes_in_set == 0) /* Is this a NULL side set? */
{
return(EX_NOERR);
}
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if ((dimid = ncdimdef (exoid, DIM_NUM_NOD_NS(cur_num_node_sets+1),
(long)num_nodes_in_set)) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: node set %d size already defined in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of nodes for set %d in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
goto error_ret;
}
/* create variable array in which to store the node set node list */
dims[0] = dimid;
if (ncvardef(exoid, VAR_NODE_NS(cur_num_node_sets+1), NC_LONG,1,dims) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: node set %d node list already defined in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create node set %d node list in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
/* Create distribution factors variable if required */
if (num_dist_in_set > 0)
{
/* num_dist_in_set should equal num_nodes_in_set */
if (num_dist_in_set != num_nodes_in_set)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%d) not equal to # nodes (%d) in node set %d file id %d",
num_dist_in_set, num_nodes_in_set, node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
else
{
/* create variable for distribution factors */
if (ncvardef (exoid, VAR_FACT_NS(cur_num_node_sets+1),
nc_flt_code(exoid), 1, dims) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: node set %d dist factors already exist in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create node set %d dist factors in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
}
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete definition in file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_side_set_node_count(int exoid,
int side_set_id,
int *side_set_node_cnt_list)
{
int ii, i, j, m;
int num_side_sets, num_elem_blks, num_df, ndim;
int tot_num_elem = 0, tot_num_ss_elem = 0, side, elem;
int *elem_blk_ids;
int *ss_elem_ndx;
int *side_set_elem_list, *side_set_side_list;
int elem_ctr;
int num_elem_in_blk, num_nodes_per_elem, num_attr;
float fdum;
char *cdum, elem_type[MAX_STR_LENGTH+1];
struct elem_blk_parm
{
char elem_type[MAX_STR_LENGTH+1];
int elem_blk_id;
int num_elem_in_blk;
int num_nodes_per_elem;
int num_sides;
int num_nodes_per_side[6];
int num_attr;
int elem_ctr;
int elem_type_val;
} *elem_blk_parms;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
cdum = 0; /* initialize even though it is not used */
/* first check if any side sets are specified */
/* inquire how many side sets have been stored */
if ((ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum)) == -1)
{
sprintf(errmsg,
"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)
{
sprintf(errmsg,
"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,VAR_SS_IDS,side_set_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: side set %d is NULL in file id %d",
side_set_id,exoid);
ex_err("ex_get_side_set_node_count",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
sprintf(errmsg,
"Error: failed to locate side set id %d 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);
}
}
if ((ex_inquire(exoid, EX_INQ_ELEM_BLK, &num_elem_blks, &fdum, cdum)) == -1)
{
sprintf(errmsg,
"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);
}
if ((ex_inquire(exoid, EX_INQ_ELEM, &tot_num_elem, &fdum, cdum)) == -1)
{
sprintf(errmsg,
"Error: failed to get total number of elements 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 */
if ((ex_inquire(exoid, EX_INQ_DIM, &ndim, &fdum, cdum)) == -1)
{
sprintf(errmsg,
"Error: failed to get dimensionality in file id %d",exoid);
ex_err("ex_cvt_nodes_to_sides",errmsg,exerrval);
return(EX_FATAL);
}
/* First determine the # of elements in the side set*/
if ((ex_get_side_set_param(exoid,side_set_id,&tot_num_ss_elem,&num_df)) == -1)
{
sprintf(errmsg,
"Error: failed to get number of elements in side set %d 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*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set element list for file id %d",
exoid);
ex_err("ex_get_side_set_node_count",errmsg,exerrval);
return (EX_FATAL);
}
/* Allocate space for the side set side list */
if (!(side_set_side_list=malloc(tot_num_ss_elem*sizeof(int))))
{
free(side_set_elem_list);
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set side list for file id %d",
exoid);
ex_err("ex_get_side_set_node_count",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set(exoid, side_set_id,
side_set_elem_list, side_set_side_list) == -1)
{
free(side_set_elem_list);
free(side_set_side_list);
sprintf(errmsg,
"Error: failed to get side set %d 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 ss element index array */
if (!(ss_elem_ndx=malloc(tot_num_ss_elem*sizeof(int))))
{
free(side_set_elem_list);
free(side_set_side_list);
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set elem sort array for file id %d",
exoid);
ex_err("ex_get_side_set_node_count",errmsg,exerrval);
return (EX_FATAL);
}
/* Sort side set element list into index array - non-destructive */
for (i=0;i<tot_num_ss_elem;i++) {
ss_elem_ndx[i] = i; /* init index array to current position */
}
ex_iqsort(side_set_elem_list, ss_elem_ndx,tot_num_ss_elem);
/* Allocate space for the element block ids */
if (!(elem_blk_ids=malloc(num_elem_blks*sizeof(int))))
{
exerrval = EX_MEMFAIL;
free(ss_elem_ndx);
free(side_set_side_list);
free(side_set_elem_list);
sprintf(errmsg,
"Error: failed to allocate space for element block ids for file id %d",
exoid);
ex_err("ex_get_side_set_node_count",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_elem_blk_ids(exoid, elem_blk_ids) == -1)
{
free(elem_blk_ids);
free(ss_elem_ndx);
free(side_set_side_list);
free(side_set_elem_list);
sprintf(errmsg,
"Error: failed to get element block ids in file id %d",
exoid);
ex_err("ex_get_side_set_node_count",errmsg,EX_MSG);
return(EX_FATAL);
}
/* Allocate space for the element block params */
if (!(elem_blk_parms=malloc(num_elem_blks*sizeof(struct elem_blk_parm))))
{
free(elem_blk_ids);
free(ss_elem_ndx);
free(side_set_side_list);
free(side_set_elem_list);
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for element block params for file id %d",
exoid);
ex_err("ex_get_side_set_node_count",errmsg,exerrval);
return (EX_FATAL);
}
elem_ctr = 0;
for (i=0; i<num_elem_blks; i++)
{
/* read in an element block parameter */
if ((ex_get_elem_block (exoid, elem_blk_ids[i], elem_type, &num_elem_in_blk,
&num_nodes_per_elem, &num_attr)) == -1) {
free(elem_blk_parms);
free(elem_blk_ids);
free(ss_elem_ndx);
free(side_set_side_list);
free(side_set_elem_list);
sprintf(errmsg,
"Error: failed to get element block %d parameters in file id %d",
elem_blk_ids[i], exoid);
ex_err("ex_get_side_set_node_count",errmsg,EX_MSG);
return(EX_FATAL);
}
elem_blk_parms[i].num_elem_in_blk = num_elem_in_blk;
elem_blk_parms[i].num_nodes_per_elem = num_nodes_per_elem;
elem_blk_parms[i].num_attr = num_attr;
for (m=0; (size_t)m < strlen(elem_type); m++) {
elem_blk_parms[i].elem_type[m] = (char)toupper((int)elem_type[m]);
}
elem_blk_parms[i].elem_type[m] = '\0';
if (strncmp(elem_blk_parms[i].elem_type,"CIRCLE",3) == 0)
{
elem_blk_parms[i].elem_type_val = CIRCLE;
elem_blk_parms[i].num_sides = 1;
elem_blk_parms[i].num_nodes_per_side[0] = 1;
}
else if (strncmp(elem_blk_parms[i].elem_type,"SPHERE",3) == 0)
{
elem_blk_parms[i].elem_type_val = SPHERE;
elem_blk_parms[i].num_sides = 1;
elem_blk_parms[i].num_nodes_per_side[0] = 1;
}
else if (strncmp(elem_blk_parms[i].elem_type,"QUAD",3) == 0)
{
elem_blk_parms[i].elem_type_val = QUAD;
elem_blk_parms[i].num_sides = 4;
if (elem_blk_parms[i].num_nodes_per_elem == 4) {
elem_blk_parms[i].num_nodes_per_side[0] = 2;
elem_blk_parms[i].num_nodes_per_side[1] = 2;
elem_blk_parms[i].num_nodes_per_side[2] = 2;
elem_blk_parms[i].num_nodes_per_side[3] = 2;
} else if (elem_blk_parms[i].num_nodes_per_elem == 5) {
elem_blk_parms[i].num_nodes_per_side[0] = 2;
elem_blk_parms[i].num_nodes_per_side[1] = 2;
elem_blk_parms[i].num_nodes_per_side[2] = 2;
elem_blk_parms[i].num_nodes_per_side[3] = 2;
} else if (elem_blk_parms[i].num_nodes_per_elem == 9 ||
elem_blk_parms[i].num_nodes_per_elem == 8) {
elem_blk_parms[i].num_nodes_per_side[0] = 3;
elem_blk_parms[i].num_nodes_per_side[1] = 3;
elem_blk_parms[i].num_nodes_per_side[2] = 3;
elem_blk_parms[i].num_nodes_per_side[3] = 3;
} else {
EL_NODE_COUNT_ERROR;
}
}
else if (strncmp(elem_blk_parms[i].elem_type,"TRIANGLE",3) == 0)
{
elem_blk_parms[i].elem_type_val = TRIANGLE;
if (ndim == 2) { /* 2d TRIs */
elem_blk_parms[i].num_sides = 3;
if (elem_blk_parms[i].num_nodes_per_elem == 3) {
elem_blk_parms[i].num_nodes_per_side[0] = 2;
elem_blk_parms[i].num_nodes_per_side[1] = 2;
elem_blk_parms[i].num_nodes_per_side[2] = 2;
} else if (elem_blk_parms[i].num_nodes_per_elem == 6) {
elem_blk_parms[i].num_nodes_per_side[0] = 3;
elem_blk_parms[i].num_nodes_per_side[1] = 3;
elem_blk_parms[i].num_nodes_per_side[2] = 3;
}
} else if (ndim == 3) { /* 3d TRIs -- triangular shell*/
elem_blk_parms[i].num_sides = 5; /* 2 Faces and 3 Edges */
if (elem_blk_parms[i].num_nodes_per_elem == 3) {
elem_blk_parms[i].num_nodes_per_side[0] = 3;
elem_blk_parms[i].num_nodes_per_side[1] = 3;
elem_blk_parms[i].num_nodes_per_side[2] = 2;
elem_blk_parms[i].num_nodes_per_side[3] = 2;
elem_blk_parms[i].num_nodes_per_side[4] = 2;
} else if (elem_blk_parms[i].num_nodes_per_elem == 6) {
elem_blk_parms[i].num_nodes_per_side[0] = 6;
elem_blk_parms[i].num_nodes_per_side[1] = 6;
elem_blk_parms[i].num_nodes_per_side[2] = 3;
elem_blk_parms[i].num_nodes_per_side[3] = 3;
elem_blk_parms[i].num_nodes_per_side[4] = 3;
} else {
EL_NODE_COUNT_ERROR;
}
}
}
else if (strncmp(elem_blk_parms[i].elem_type,"SHELL",3) == 0)
{
elem_blk_parms[i].elem_type_val = SHELL;
if (elem_blk_parms[i].num_nodes_per_elem == 2) {/* KLUDGE for 2D Shells*/
elem_blk_parms[i].num_sides = 2;
elem_blk_parms[i].num_nodes_per_side[0] = 2;
elem_blk_parms[i].num_nodes_per_side[1] = 2;
} else if (elem_blk_parms[i].num_nodes_per_elem == 4) {
elem_blk_parms[i].num_sides = 6; /* 2 Faces, 4 Edges */
elem_blk_parms[i].num_nodes_per_side[0] = 4;
elem_blk_parms[i].num_nodes_per_side[1] = 4;
elem_blk_parms[i].num_nodes_per_side[2] = 2;
elem_blk_parms[i].num_nodes_per_side[3] = 2;
elem_blk_parms[i].num_nodes_per_side[4] = 2;
elem_blk_parms[i].num_nodes_per_side[5] = 2;
} else if (elem_blk_parms[i].num_nodes_per_elem == 8 ||
elem_blk_parms[i].num_nodes_per_elem == 9) {
elem_blk_parms[i].num_sides = 6; /* 2 Faces, 4 Edges */
elem_blk_parms[i].num_nodes_per_side[0] =
elem_blk_parms[i].num_nodes_per_elem; /* 8 or 9 */
elem_blk_parms[i].num_nodes_per_side[1] =
elem_blk_parms[i].num_nodes_per_elem; /* 8 or 9 */
elem_blk_parms[i].num_nodes_per_side[2] = 3;
elem_blk_parms[i].num_nodes_per_side[3] = 3;
elem_blk_parms[i].num_nodes_per_side[4] = 3;
elem_blk_parms[i].num_nodes_per_side[5] = 3;
} else {
EL_NODE_COUNT_ERROR;
}
}
else if (strncmp(elem_blk_parms[i].elem_type,"HEX",3) == 0)
{
elem_blk_parms[i].elem_type_val = HEX;
elem_blk_parms[i].num_sides = 6;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 8) { /* 8-node bricks */
elem_blk_parms[i].num_nodes_per_side[0] = 4;
elem_blk_parms[i].num_nodes_per_side[1] = 4;
elem_blk_parms[i].num_nodes_per_side[2] = 4;
elem_blk_parms[i].num_nodes_per_side[3] = 4;
elem_blk_parms[i].num_nodes_per_side[4] = 4;
elem_blk_parms[i].num_nodes_per_side[5] = 4;
} else if (elem_blk_parms[i].num_nodes_per_elem == 9) { /* 9-node bricks */
elem_blk_parms[i].num_nodes_per_side[0] = 4;
elem_blk_parms[i].num_nodes_per_side[1] = 4;
elem_blk_parms[i].num_nodes_per_side[2] = 4;
elem_blk_parms[i].num_nodes_per_side[3] = 4;
elem_blk_parms[i].num_nodes_per_side[4] = 4;
elem_blk_parms[i].num_nodes_per_side[5] = 4;
} else if (elem_blk_parms[i].num_nodes_per_elem == 12) { /* HEXSHELLS */
elem_blk_parms[i].num_nodes_per_side[0] = 6;
elem_blk_parms[i].num_nodes_per_side[1] = 6;
elem_blk_parms[i].num_nodes_per_side[2] = 6;
elem_blk_parms[i].num_nodes_per_side[3] = 6;
elem_blk_parms[i].num_nodes_per_side[4] = 4;
elem_blk_parms[i].num_nodes_per_side[5] = 4;
} else if (elem_blk_parms[i].num_nodes_per_elem == 20) { /* 20-node bricks */
elem_blk_parms[i].num_nodes_per_side[0] = 8;
elem_blk_parms[i].num_nodes_per_side[1] = 8;
elem_blk_parms[i].num_nodes_per_side[2] = 8;
elem_blk_parms[i].num_nodes_per_side[3] = 8;
elem_blk_parms[i].num_nodes_per_side[4] = 8;
elem_blk_parms[i].num_nodes_per_side[5] = 8;
} else if (elem_blk_parms[i].num_nodes_per_elem == 27) { /* 27-node bricks */
elem_blk_parms[i].num_nodes_per_side[0] = 9;
elem_blk_parms[i].num_nodes_per_side[1] = 9;
elem_blk_parms[i].num_nodes_per_side[2] = 9;
elem_blk_parms[i].num_nodes_per_side[3] = 9;
elem_blk_parms[i].num_nodes_per_side[4] = 9;
elem_blk_parms[i].num_nodes_per_side[5] = 9;
} else {
EL_NODE_COUNT_ERROR;
}
}
else if (strncmp(elem_blk_parms[i].elem_type,"TETRA",3) == 0)
{
elem_blk_parms[i].elem_type_val = TETRA;
elem_blk_parms[i].num_sides = 4;
/* determine side set node stride */
if (elem_blk_parms[i].num_nodes_per_elem == 4) {
elem_blk_parms[i].num_nodes_per_side[0] = 3;
elem_blk_parms[i].num_nodes_per_side[1] = 3;
elem_blk_parms[i].num_nodes_per_side[2] = 3;
elem_blk_parms[i].num_nodes_per_side[3] = 3;
} else if (elem_blk_parms[i].num_nodes_per_elem == 8) {
elem_blk_parms[i].num_nodes_per_side[0] = 4;
elem_blk_parms[i].num_nodes_per_side[1] = 4;
elem_blk_parms[i].num_nodes_per_side[2] = 4;
elem_blk_parms[i].num_nodes_per_side[3] = 4;
} else if (elem_blk_parms[i].num_nodes_per_elem == 10) {
elem_blk_parms[i].num_nodes_per_side[0] = 6;
elem_blk_parms[i].num_nodes_per_side[1] = 6;
elem_blk_parms[i].num_nodes_per_side[2] = 6;
elem_blk_parms[i].num_nodes_per_side[3] = 6;
} else {
EL_NODE_COUNT_ERROR;
}
}
else if (strncmp(elem_blk_parms[i].elem_type,"WEDGE",3) == 0)
{
elem_blk_parms[i].elem_type_val = WEDGE;
elem_blk_parms[i].num_sides = 5;
if (elem_blk_parms[i].num_nodes_per_elem == 6) {
elem_blk_parms[i].num_nodes_per_side[0] = 4;
elem_blk_parms[i].num_nodes_per_side[1] = 4;
elem_blk_parms[i].num_nodes_per_side[2] = 4;
elem_blk_parms[i].num_nodes_per_side[3] = 3;
elem_blk_parms[i].num_nodes_per_side[4] = 3;
} else if (elem_blk_parms[i].num_nodes_per_elem == 15){
elem_blk_parms[i].num_nodes_per_side[0] = 8;
elem_blk_parms[i].num_nodes_per_side[1] = 8;
elem_blk_parms[i].num_nodes_per_side[2] = 8;
elem_blk_parms[i].num_nodes_per_side[3] = 6;
elem_blk_parms[i].num_nodes_per_side[4] = 6;
} else {
EL_NODE_COUNT_ERROR;
}
}
else if (strncmp(elem_blk_parms[i].elem_type,"PYRAMID",3) == 0)
{
elem_blk_parms[i].elem_type_val = PYRAMID;
elem_blk_parms[i].num_sides = 5;
if (elem_blk_parms[i].num_nodes_per_elem == 5) {
elem_blk_parms[i].num_nodes_per_side[0] = 3;
elem_blk_parms[i].num_nodes_per_side[1] = 3;
elem_blk_parms[i].num_nodes_per_side[2] = 3;
elem_blk_parms[i].num_nodes_per_side[3] = 3;
elem_blk_parms[i].num_nodes_per_side[4] = 4;
} else if (elem_blk_parms[i].num_nodes_per_elem == 13){
elem_blk_parms[i].num_nodes_per_side[0] = 6;
elem_blk_parms[i].num_nodes_per_side[1] = 6;
elem_blk_parms[i].num_nodes_per_side[2] = 6;
elem_blk_parms[i].num_nodes_per_side[3] = 6;
elem_blk_parms[i].num_nodes_per_side[4] = 8;
} else {
EL_NODE_COUNT_ERROR;
}
}
else if (strncmp(elem_blk_parms[i].elem_type,"BEAM",3) == 0)
{
elem_blk_parms[i].elem_type_val = BEAM;
elem_blk_parms[i].num_sides = 2;
if (elem_blk_parms[i].num_nodes_per_elem == 2) {
elem_blk_parms[i].num_nodes_per_side[0] = 2;
elem_blk_parms[i].num_nodes_per_side[1] = 2;
} else if (elem_blk_parms[i].num_nodes_per_elem == 3){
elem_blk_parms[i].num_nodes_per_side[0] = 3;
elem_blk_parms[i].num_nodes_per_side[1] = 3;
} else {
EL_NODE_COUNT_ERROR;
}
}
else if ( (strncmp(elem_blk_parms[i].elem_type,"TRUSS",3) == 0) ||
(strncmp(elem_blk_parms[i].elem_type,"BAR",3) == 0) ||
(strncmp(elem_blk_parms[i].elem_type,"EDGE",3) == 0) )
{
elem_blk_parms[i].elem_type_val = TRUSS;
elem_blk_parms[i].num_sides = 2;
if (elem_blk_parms[i].num_nodes_per_elem == 2) {
elem_blk_parms[i].num_nodes_per_side[0] = 2;
elem_blk_parms[i].num_nodes_per_side[1] = 2;
} else if (elem_blk_parms[i].num_nodes_per_elem == 3) {
elem_blk_parms[i].num_nodes_per_side[0] = 3;
elem_blk_parms[i].num_nodes_per_side[1] = 3;
} else {
EL_NODE_COUNT_ERROR;
}
}
/* Used for an empty block in a parallel decomposition */
else if (strncmp(elem_blk_parms[i].elem_type,"NULL",3) == 0) {
elem_blk_parms[i].elem_type_val = '\0';
elem_blk_parms[i].num_sides = 0;
elem_blk_parms[i].num_nodes_per_side[0] = 0;
elem_blk_parms[i].num_elem_in_blk = 0;
} else {
/* unsupported element type; no problem if no sides specified for
this element block */
elem_blk_parms[i].elem_type_val = UNK;
elem_blk_parms[i].num_sides = 0;
elem_blk_parms[i].num_nodes_per_side[0] = 0;
}
elem_blk_parms[i].elem_blk_id = elem_blk_ids[i]; /* save id */
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++) {
i = ss_elem_ndx[ii];
elem = side_set_elem_list[i];
side = 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;
sprintf(errmsg,
"Error: Invalid element number %d found in side set %d in file %d",
side_set_elem_list[i], side_set_id, exoid);
free(elem_blk_parms);
free(elem_blk_ids);
free(ss_elem_ndx);
free(side_set_side_list);
free(side_set_elem_list);
ex_err("ex_get_side_set_node_count",errmsg,EX_MSG);
return (EX_FATAL);
}
}
/* All done: release connectivity array space, element block ids
* array, element block parameters array, and side set element index
* array
*/
free(elem_blk_ids);
free(elem_blk_parms);
free(ss_elem_ndx);
free(side_set_side_list);
free(side_set_elem_list);
return(EX_NOERR);
}
int ex_put_num_map ( int exoid,
ex_entity_type map_type,
int map_id,
const int *map )
{
int dimid, varid;
size_t start[1];
int ldum;
int num_maps;
size_t num_entries;
int cur_num_maps;
char errmsg[MAX_ERR_LENGTH];
const char* dnumentries;
const char* dnummaps;
const char* vmapids;
const char* vmap;
int status;
exerrval = 0; /* clear error code */
switch ( map_type ) {
case EX_NODE_MAP:
dnumentries = DIM_NUM_NODES;
dnummaps = DIM_NUM_NM;
vmapids = VAR_NM_PROP(1);
break;
case EX_EDGE_MAP:
dnumentries = DIM_NUM_EDGE;
dnummaps = DIM_NUM_EDM;
vmapids = VAR_EDM_PROP(1);
break;
case EX_FACE_MAP:
dnumentries = DIM_NUM_FACE;
dnummaps = DIM_NUM_FAM;
vmapids = VAR_FAM_PROP(1);
break;
case EX_ELEM_MAP:
dnumentries = DIM_NUM_ELEM;
dnummaps = DIM_NUM_EM;
vmapids = VAR_EM_PROP(1);
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg,
"Error: Bad map type (%d) specified for file id %d",
map_type, exoid );
ex_err( "ex_put_num_map", errmsg, exerrval );
return (EX_FATAL);
}
/* Make sure the file contains entries */
if (nc_inq_dimid (exoid, dnumentries, &dimid) != NC_NOERR )
{
return (EX_NOERR);
}
/* first check if any maps are specified */
if ((status = nc_inq_dimid (exoid, dnummaps, &dimid)) != NC_NOERR )
{
exerrval = status;
sprintf(errmsg,
"Error: no %ss specified in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate map id entry */
ex_id_lkup(exoid,map_type,map_id);
if (exerrval != EX_LOOKUPFAIL) /* found the map id */
{
sprintf(errmsg,
"Error: %s %d already defined in file id %d",
ex_name_of_object(map_type),map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return(EX_FATAL);
}
/* Get number of maps initialized for this file */
if ((status = nc_inq_dimlen(exoid,dimid,&num_entries)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
num_maps = num_entries;
/* Keep track of the total number of maps defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of maps
for a specific file and returns that value.
*/
cur_num_maps = ex_get_file_item(exoid, ex_get_counter_list(map_type));
if (cur_num_maps >= num_maps) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) specified in file id %d",
ex_name_of_object(map_type),num_maps,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is used to find the number of maps
for a specific file and returns that value incremented. */
cur_num_maps = ex_inc_file_item(exoid, ex_get_counter_list(map_type));
/* write out information to previously defined variable */
/* first get id of variable */
if ((status = nc_inq_varid (exoid, vmapids, &varid)) == -1)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out map id */
start[0] = cur_num_maps;
ldum = (int)map_id;
if ((status = nc_put_var1_int(exoid, varid, start, &ldum)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %d in file id %d",
ex_name_of_object(map_type),map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
switch ( map_type ) {
case EX_NODE_MAP:
vmap = VAR_NODE_MAP(cur_num_maps+1);
break;
case EX_EDGE_MAP:
vmap = VAR_EDGE_MAP(cur_num_maps+1);
break;
case EX_FACE_MAP:
vmap = VAR_FACE_MAP(cur_num_maps+1);
break;
case EX_ELEM_MAP:
vmap = VAR_ELEM_MAP(cur_num_maps+1);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized map type in switch: %d in file id %d",
map_type,exoid);
ex_err("ex_putt_n_one_attr",errmsg,EX_MSG);
return (EX_FATAL);
}
/* locate variable array in which to store the map */
if ((status = nc_inq_varid(exoid,vmap,&varid)) != NC_NOERR)
{
int dims[2];
/* determine number of entries */
if ((status = nc_inq_dimid (exoid, dnumentries, &dimid)) == -1 )
{
exerrval = status;
sprintf(errmsg,
"Error: couldn't determine number of %s entries in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
status = 0;
if ((status = nc_redef( exoid )) != NC_NOERR ) {
exerrval = status;
sprintf(errmsg, "Error: failed to place file id %d into define mode", exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
dims[0] = dimid;
if ((status = nc_def_var( exoid, vmap, NC_INT, 1, dims, &varid )) == -1 ) {
exerrval = status;
sprintf(errmsg, "Error: failed to define map %s in file id %d", vmap, exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
}
if ((status = nc_enddef(exoid)) != NC_NOERR ) { /* exit define mode */
sprintf( errmsg, "Error: failed to complete definition for file id %d", exoid );
ex_err( "ex_put_num_map", errmsg, exerrval );
varid = -1; /* force early exit */
}
if ( varid == -1 ) /* we couldn't define variable and have prepared error message. */
return (EX_FATAL);
}
/* write out the map */
if ((status = nc_put_var_int(exoid, varid, map)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_put_attr (int exoid,
ex_entity_type blk_type,
int blk_id,
const void *attrib)
{
int status;
int attrid, blk_id_ndx = 0;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
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 (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no attributes allowed for NULL %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_put_attr",errmsg,EX_MSG);
return (EX_WARN); /* no attributes for this block */
} else {
sprintf(errmsg,
"Error: no %s id %d in in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_put_attr",errmsg,exerrval);
return (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:
sprintf(errmsg,
"Error: Called with invalid blk_type %d", blk_type );
ex_err("ex_put_attr",errmsg,exerrval);
return (EX_FATAL);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate attribute variable for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_put_attr",errmsg,exerrval);
return (EX_FATAL);
}
/* write out the attributes */
if (ex_comp_ws(exoid) == 4) {
status = nc_put_var_float(exoid, attrid, attrib);
} else {
status = nc_put_var_double(exoid, attrid, attrib);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put attributes for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_put_attr",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
int ex_get_set_param (int exoid,
ex_entity_type set_type,
int set_id,
int *num_entry_in_set,
int *num_dist_fact_in_set)
{
int status;
int varid, dimid, set_id_ndx;
size_t lnum_entry_in_set;
size_t lnum_dist_fact_in_set;
char errmsg[MAX_ERR_LENGTH];
char* numentryptr = NULL;
char* numdfptr = NULL;
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;
sprintf(errmsg,
"Warning: no %ss stored in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_get_set_param",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) /* NULL set? */
{
*num_entry_in_set = 0;
*num_dist_fact_in_set = 0;
return (EX_NOERR);
} else {
sprintf(errmsg,
"Error: failed to locate %s id %d in id array in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_param",errmsg,exerrval);
return (EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
numentryptr = DIM_NUM_NOD_NS(set_id_ndx);
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
numentryptr = DIM_NUM_EDGE_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
numentryptr = DIM_NUM_FACE_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
numentryptr = DIM_NUM_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
numentryptr = DIM_NUM_ELE_ELS(set_id_ndx);
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
}
/* inquire values of dimension for number of entities in set */
if (ex_get_dimension(exoid, numentryptr,"entries", &lnum_entry_in_set,
&dimid, "ex_get_set_param") != NC_NOERR)
return EX_FATAL;
*num_entry_in_set = lnum_entry_in_set;
/* Inquire value of dimension of number of dist factors for this set.
NOTE: For node sets, because DIM_NUM_DF_NS is not used, we check to see
if the dist factor variable for a node set index exits. If it does not,
the dist factor count is assumed to be zero, otherwise the dist factor
count will be the same as the number of nodes in the set. */
if (set_type == EX_NODE_SET) {
if ((status = nc_inq_varid(exoid, VAR_FACT_NS(set_id_ndx), &varid)) != NC_NOERR) {
*num_dist_fact_in_set = 0; /* signal dist factor doesn't exist */
if (status == NC_ENOTVAR)
return (EX_NOERR);
else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate the dist factors for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_param",errmsg,exerrval);
return (EX_FATAL);
}
}
*num_dist_fact_in_set = lnum_entry_in_set; /* # of df = # of nodes */
}
else {/* all other set types */
if ((status = nc_inq_dimid(exoid, numdfptr, &dimid)) != NC_NOERR) {
*num_dist_fact_in_set = 0; /* no distribution factors for this set*/
if (status == NC_EBADDIM)
return (EX_NOERR);
else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist factors in %s %d in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_set_param",errmsg,exerrval);
return (EX_FATAL);
}
}
if ((status = nc_inq_dimlen(exoid, dimid, &lnum_dist_fact_in_set)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of dist factors in %s %d in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_set_param",errmsg,exerrval);
return (EX_FATAL);
}
*num_dist_fact_in_set = lnum_dist_fact_in_set;
}
return (EX_NOERR);
}
int ex_put_elem_block (int exoid,
int elem_blk_id,
const char *elem_type,
int num_elem_this_blk,
int num_nodes_per_elem,
int num_attr)
{
int varid, dimid, dims[2], elem_blk_id_ndx, elem_blk_stat, strdim;
long start[2], num_elem_blk;
nclong ldum;
int cur_num_elem_blk, nelnoddim, numelbdim, numattrdim, connid;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
cdum = 0;
/* first check if any element blocks are specified */
if ((dimid = (ncdimid (exoid, DIM_NUM_EL_BLK))) == -1 )
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no element blocks defined in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Get number of element blocks defined for this file */
if ((ncdiminq (exoid,dimid,cdum,&num_elem_blk)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Next: Make sure that this is not a duplicate element block id by
searching the VAR_ID_EL_BLK array.
WARNING: This must be done outside of define mode because id_lkup accesses
the database to determine the position
*/
if ((varid = ncvarid (exoid, VAR_ID_EL_BLK)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element block ids in file id %d", exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
elem_blk_id_ndx = ex_id_lkup(exoid,VAR_ID_EL_BLK,elem_blk_id);
if (exerrval != EX_LOOKUPFAIL) /* found the element block id */
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: element block id %d already exists in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of element blocks defined using a counter
stored in a linked list keyed by exoid.
NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented.
*/
cur_num_elem_blk=ex_get_file_item(exoid, &eb_ctr_list);
if (cur_num_elem_blk >= num_elem_blk)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of element blocks (%ld) defined in file id %d",
num_elem_blk,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented. */
cur_num_elem_blk=ex_inc_file_item(exoid, &eb_ctr_list);
start[0] = (long)cur_num_elem_blk;
/* write out element block id to previously defined id array variable*/
ldum = (nclong)elem_blk_id;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element block id to file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
elem_blk_id_ndx = start[0]+1; /* element id index into VAR_ID_EL_BLK array*/
if (num_elem_this_blk == 0) /* Is this a NULL element block? */
elem_blk_stat = 0; /* change element block status to NULL */
else
elem_blk_stat = 1; /* change element block status to TRUE */
if ((varid = ncvarid (exoid, VAR_STAT_EL_BLK)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element block status in file id %d", exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
ldum = (nclong)elem_blk_stat;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element id %d status to file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
if (num_elem_this_blk == 0) /* Is this a NULL element block? */
{
return(EX_NOERR);
}
/*
* Check that storage required for connectivity array is less
* than 2GB which is maximum size permitted by netcdf
* (in large file mode). 1<<29 == max number of integer items.
*/
if (num_elem_this_blk * num_nodes_per_elem > (1<<29)) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Size to store connectivity for element block %d exceeds 2GB in file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* define some dimensions and variables*/
if ((numelbdim = ncdimdef (exoid,
DIM_NUM_EL_IN_BLK(elem_blk_id_ndx), (long)num_elem_this_blk)) == -1)
{
if (ncerr == NC_ENAMEINUSE) /* duplicate entry */
{
exerrval = ncerr;
sprintf(errmsg,
"Error: element block %d already defined in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of elements/block for block %d file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if ((nelnoddim = ncdimdef (exoid,
DIM_NUM_NOD_PER_EL(elem_blk_id_ndx), (long)num_nodes_per_elem)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of nodes/element for block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element attribute array */
if (num_attr > 0)
{
if ((numattrdim = ncdimdef (exoid,
DIM_NUM_ATT_IN_BLK(elem_blk_id_ndx), (long)num_attr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of attributes in block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dims[0] = numelbdim;
dims[1] = numattrdim;
if ((ncvardef (exoid,
VAR_ATTRIB(elem_blk_id_ndx), nc_flt_code(exoid), 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define attributes for element block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* inquire previously defined dimensions */
if ((strdim = ncdimid (exoid, DIM_STR)) < 0) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if (ncvardef (exoid, VAR_NAME_ATTRIB(elem_blk_id_ndx), NC_CHAR, 2, dims) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define element attribute name array in file id %d",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* element connectivity array */
dims[0] = numelbdim;
dims[1] = nelnoddim;
if ((connid = ncvardef (exoid,
VAR_CONN(elem_blk_id_ndx), NC_LONG, 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create connectivity array for block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store element type as attribute of connectivity variable */
if ((ncattput (exoid, connid, ATT_NAME_ELB, NC_CHAR, strlen(elem_type)+1,
(void*) elem_type)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element type name %s in file id %d",
elem_type,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete element block definition in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
return (EX_FATAL);
}
/*
* reads the attribute names for an element block
*/
int ex_get_attr_names( int exoid,
ex_entity_type obj_type,
ex_entity_id obj_id,
char **names)
{
int status;
int varid, numattrdim, obj_id_ndx;
size_t num_attr, i;
char errmsg[MAX_ERR_LENGTH];
const char* dnumobjatt;
const char* vattrbname;
exerrval = 0; /* clear error code */
/* 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) {
sprintf(errmsg,
"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_attr_names",errmsg,EX_NULLENTITY);
return (EX_WARN); /* no attributes for this object */
} else {
sprintf(errmsg,
"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_attr_names",errmsg,exerrval);
return (EX_WARN);
}
}
}
switch (obj_type) {
case EX_NODE_SET:
dnumobjatt = DIM_NUM_ATT_IN_NS(obj_id_ndx);
vattrbname = VAR_NAME_NSATTRIB(obj_id_ndx);
break;
case EX_SIDE_SET:
dnumobjatt = DIM_NUM_ATT_IN_SS(obj_id_ndx);
vattrbname = VAR_NAME_SSATTRIB(obj_id_ndx);
break;
case EX_EDGE_SET:
dnumobjatt = DIM_NUM_ATT_IN_ES(obj_id_ndx);
vattrbname = VAR_NAME_ESATTRIB(obj_id_ndx);
break;
case EX_FACE_SET:
dnumobjatt = DIM_NUM_ATT_IN_FS(obj_id_ndx);
vattrbname = VAR_NAME_FSATTRIB(obj_id_ndx);
break;
case EX_ELEM_SET:
dnumobjatt = DIM_NUM_ATT_IN_ELS(obj_id_ndx);
vattrbname = VAR_NAME_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
dnumobjatt = DIM_NUM_ATT_IN_NBLK;
vattrbname = VAR_NAME_NATTRIB;
break;
case EX_EDGE_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
vattrbname = VAR_NAME_EATTRIB(obj_id_ndx);
break;
case EX_FACE_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_FBLK(obj_id_ndx);
vattrbname = VAR_NAME_FATTRIB(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_BLK(obj_id_ndx);
vattrbname = VAR_NAME_ATTRIB(obj_id_ndx);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized object type in switch: %d in file id %d",
obj_type,exoid);
ex_err("ex_get_attr_names",errmsg,EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
if ((status = nc_inq_dimid(exoid, dnumobjatt, &numattrdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no attributes found for %s %"PRId64" in file id %d",
ex_name_of_object(obj_type),obj_id,exoid);
ex_err("ex_get_attr_names",errmsg,EX_MSG);
return (EX_WARN); /* no attributes for this object */
}
if ((status = nc_inq_dimlen(exoid, numattrdim, &num_attr)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of attributes for %s %"PRId64" in file id %d",
ex_name_of_object(obj_type),obj_id,exoid);
ex_err("ex_get_attr_names",errmsg,exerrval);
return (EX_FATAL);
}
/* It is OK if we don't find the attribute names since they were
added at version 4.26; earlier databases won't have the names.
*/
status = nc_inq_varid(exoid, vattrbname, &varid);
/* read in the attributes */
if (status == NC_NOERR) {
/* read the names */
status = ex_get_names_internal(exoid, varid, num_attr, names, obj_type, "ex_get_attr_names");
if (status != NC_NOERR) {
return (EX_FATAL);
}
} else {
/* Names variable does not exist on the database; probably since this is an
* older version of the database. Return an empty array...
*/
for (i=0; i<num_attr; i++) {
names[i][0] = '\0';
}
}
return(EX_NOERR);
}
int ex_get_set (int exoid,
int set_type,
int set_id,
int *set_entry_list,
int *set_extra_list)
{
int dimid, entry_list_id, extra_list_id, iresult;
int set_id_ndx;
long num_entry_in_set, count[1], start[1];
nclong *longs;
char errmsg[MAX_ERR_LENGTH];
char* typeName;
char* dimptr;
char* idsptr;
char* numentryptr;
char* entryptr;
char* extraptr;
exerrval = 0; /* clear error code */
/* setup pointers based on set_type
NOTE: there is another block that sets more stuff later ... */
if (set_type == EX_NODE_SET) {
typeName = "node";
dimptr = DIM_NUM_NS;
idsptr = VAR_NS_IDS;
}
else if (set_type == EX_EDGE_SET) {
typeName = "edge";
dimptr = DIM_NUM_ES;
idsptr = VAR_ES_IDS;
}
else if (set_type == EX_FACE_SET) {
typeName = "face";
dimptr = DIM_NUM_FS;
idsptr = VAR_FS_IDS;
}
else if (set_type == EX_SIDE_SET) {
typeName = "side";
dimptr = DIM_NUM_SS;
idsptr = VAR_SS_IDS;
}
else if (set_type == EX_ELEM_SET) {
typeName = "elem";
dimptr = DIM_NUM_ELS;
idsptr = VAR_ELS_IDS;
}
else {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: invalid set type (%d)", set_type);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* first check if any sets are specified */
if ((dimid = ncdimid (exoid, dimptr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no %s sets stored in file id %d",
typeName, exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_WARN);
}
/* Lookup index of set id in VAR_*S_IDS array */
set_id_ndx = ex_id_lkup(exoid,idsptr,set_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: %s set %d is NULL in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
sprintf(errmsg,
"Error: failed to locate %s set id %d in VAR_*S_IDS array in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
numentryptr = DIM_NUM_NOD_NS(set_id_ndx);
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
}
else if (set_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);
}
else if (set_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);
}
else if (set_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);
}
if (set_type == EX_ELEM_SET) {
numentryptr = DIM_NUM_ELE_ELS(set_id_ndx);
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
}
/* inquire id's of previously defined dimensions and variables */
if ((dimid = ncdimid (exoid, numentryptr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of entries in %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_entry_in_set) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of entries in %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_FATAL);
}
if ((entry_list_id = ncvarid (exoid, entryptr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate entry list for %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_FATAL);
}
/* only do extra list for edge, face and side sets */
if (extraptr)
{
if ((extra_list_id = ncvarid (exoid, extraptr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate extra list for %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_FATAL);
}
}
/* read in the entry list and extra list arrays */
/* application code has allocated an array of ints but netcdf is expecting
a pointer to nclongs; if ints are different sizes than nclongs,
we must allocate an array of nclongs then convert them to ints with ltoi */
start[0] = 0;
count[0] = num_entry_in_set;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarget(exoid, entry_list_id, start, count, set_entry_list);
} else {
if (!(longs = malloc(num_entry_in_set * sizeof(nclong)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for entry list for %s set %d for file id %d",
typeName, set_id, exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_FATAL);
}
iresult = ncvarget (exoid, entry_list_id, start, count, longs);
}
if (iresult)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get entry list for %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_FATAL);
}
/* only do extra list for edge, face and side sets */
if (extraptr)
{
if (sizeof(int) != sizeof(nclong)) {
ltoi (longs, set_entry_list, num_entry_in_set);
}
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarget(exoid, extra_list_id, start, count, set_extra_list);
} else {
iresult = ncvarget (exoid, extra_list_id, start, count, longs);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get extra list for %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set",errmsg,exerrval);
return (EX_FATAL);
}
}
if (sizeof(int) != sizeof(nclong)) {
ltoi (longs, set_extra_list, num_entry_in_set);
free (longs);
}
return (EX_NOERR);
}
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_put_elem_var_slab (int exoid,
int time_step,
int elem_var_index,
ex_entity_id elem_blk_id,
int64_t start_pos,
int64_t num_vals,
void *elem_var_vals)
{
int status;
int varid, dimid,time_dim, numelbdim, dims[2], elem_blk_id_ndx;
size_t num_elem_blk, num_elem_var, start[2], count[2];
int *elem_var_tab;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* Determine index of elem_blk_id in VAR_ID_EL_BLK array */
if ((elem_blk_id_ndx = ex_id_lkup(exoid, EX_ELEM_BLOCK, elem_blk_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no variables allowed for NULL block %"PRId64" in file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_var_slab", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
sprintf(errmsg,
"Error: failed to locate element block id %"PRId64" in %s array in file id %d",
elem_blk_id, VAR_ID_EL_BLK, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid (exoid,
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx), &varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) { /* variable doesn't exist, create it! */
/* inquire previously defined dimensions */
/* check for the existance of an element variable truth table */
if ((status = nc_inq_varid (exoid, VAR_ELEM_TAB, &varid)) == NC_NOERR) {
/* find out number of element blocks and element variables */
if ((status = nc_inq_dimid (exoid, DIM_NUM_EL_BLK, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of element blocks in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_elem_blk)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimid (exoid, DIM_NUM_ELE_VAR, &dimid)) != NC_NOERR) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: no element variables stored in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_elem_var)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of element variables in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if (!(elem_var_tab =
(int *)malloc(num_elem_blk*num_elem_var*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for element variable truth table in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
/* read in the element variable truth table */
if ((status = nc_get_var_int(exoid, varid, elem_var_tab)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get truth table from file id %d", exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if (elem_var_tab[num_elem_var*(elem_blk_id_ndx-1)+elem_var_index-1] == 0L) {
free(elem_var_tab);
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid element variable %d, block %"PRId64" in file id %d",
elem_var_index, elem_blk_id, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
free(elem_var_tab);
}
if ((status = nc_inq_dimid (exoid, DIM_TIME, &time_dim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate time dimension in file id %d", exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_inq_dimid(exoid, DIM_NUM_EL_IN_BLK(elem_blk_id_ndx), &numelbdim)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: number of elements in element block %"PRId64" not defined in file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of elements in element block %"PRId64" in file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
}
goto error_ret;
}
/* variable doesn't exist so put file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode", exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
/* define netCDF variable to store element variable values */
dims[0] = time_dim;
dims[1] = numelbdim;
if ((status = nc_def_var(exoid, VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx),
nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define element variable %d in file id %d",
elem_var_index, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
goto error_ret;
}
ex_compress_variable(exoid, varid, 2);
/* leave define mode */
if ((status = nc_enddef(exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete element variable %s definition to file id %d",
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx), exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate element variable %s in file id %d",
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx),exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
}
/* store element variable values */
start[0] = --time_step;
start[1] = --start_pos;
count[0] = 1;
count[1] = num_vals;
if (ex_comp_ws(exoid) == 4) {
status = nc_put_vara_float(exoid, varid, start, count, elem_var_vals);
} else {
status = nc_put_vara_double(exoid, varid, start, count, elem_var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store element variable %d in file id %d",
elem_var_index, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d", exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
}
return (EX_FATAL);
}
int ex_get_attr_param (int exoid,
ex_entity_type obj_type,
ex_entity_id obj_id,
int* num_attrs)
{
int status;
int dimid;
char errmsg[MAX_ERR_LENGTH];
const char *dnumobjatt;
int obj_id_ndx;
size_t lnum_attr_per_entry;
/* Determine index of obj_id in vobjids array */
if (obj_type == EX_NODAL) {
obj_id_ndx = 0;
} else {
obj_id_ndx = ex_id_lkup(exoid,obj_type,obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
*num_attrs = 0;
return (EX_NOERR);
}
sprintf(errmsg,
"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_attr_param",errmsg,exerrval);
return (EX_WARN);
}
}
switch (obj_type) {
case EX_SIDE_SET:
dnumobjatt = DIM_NUM_ATT_IN_SS(obj_id_ndx);
break;
case EX_NODE_SET:
dnumobjatt = DIM_NUM_ATT_IN_NS(obj_id_ndx);
break;
case EX_EDGE_SET:
dnumobjatt = DIM_NUM_ATT_IN_ES(obj_id_ndx);
break;
case EX_FACE_SET:
dnumobjatt = DIM_NUM_ATT_IN_FS(obj_id_ndx);
break;
case EX_ELEM_SET:
dnumobjatt = DIM_NUM_ATT_IN_ELS(obj_id_ndx);
break;
case EX_NODAL:
dnumobjatt = DIM_NUM_ATT_IN_NBLK;
break;
case EX_EDGE_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
break;
case EX_FACE_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_FBLK(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
dnumobjatt = DIM_NUM_ATT_IN_BLK(obj_id_ndx);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Bad block type (%d) specified for file id %d",
obj_type, exoid );
ex_err("ex_get_attr_param",errmsg,exerrval);
return (EX_FATAL);
}
exerrval = 0; /* clear error code */
if ((status = nc_inq_dimid(exoid, dnumobjatt, &dimid)) != NC_NOERR) {
/* dimension is undefined */
*num_attrs = 0;
} else {
if ((status = nc_inq_dimlen(exoid, dimid, &lnum_attr_per_entry)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of attributes in %s %"PRId64" in file id %d",
ex_name_of_object(obj_type),obj_id, exoid);
ex_err("ex_get_attr_param",errmsg, exerrval);
return(EX_FATAL);
}
*num_attrs = lnum_attr_per_entry;
}
return (EX_NOERR);
}
int ex_get_block_param( int exoid,
ex_block *block )
{
int dimid, connid, blk_id_ndx;
size_t len, i;
char errmsg[MAX_ERR_LENGTH];
int status;
const char* dnument;
const char* dnumnod;
const char* dnumedg;
const char* dnumfac;
const char* dnumatt;
const char* ablknam;
const char* vblkcon;
struct ex_file_item* file = ex_find_file_item(exoid);
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d in ex_get_block_param().",exoid);
ex_err("ex_get_block_param",errmsg,exerrval);
}
exerrval = 0;
/* First, locate index of element block id in VAR_ID_EL_BLK array */
blk_id_ndx = ex_id_lkup(exoid,block->type,block->id);
if (exerrval != 0) {
strcpy(block->topology, "NULL"); /* NULL element type name */
block->num_entry = 0; /* no elements */
block->num_nodes_per_entry = 0; /* no nodes */
block->num_edges_per_entry = 0;
block->num_faces_per_entry = 0;
block->num_attribute = 0; /* no attributes */
if (exerrval == EX_NULLENTITY) { /* NULL element block? */
return (EX_NOERR);
}
sprintf(errmsg,
"Error: failed to locate %s id %"PRId64" in id array in file id %d",
ex_name_of_object(block->type), block->id,exoid);
ex_err("ex_get_block_param",errmsg,exerrval);
return (EX_FATAL);
}
switch (block->type) {
case EX_EDGE_BLOCK:
dnument = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnumedg = 0;
dnumfac = 0;
dnumatt = DIM_NUM_ATT_IN_EBLK(blk_id_ndx);
vblkcon = VAR_EBCONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
case EX_FACE_BLOCK:
dnument = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnumedg = 0; /* it is possible this might be non-NULL some day */
dnumfac = 0;
dnumatt = DIM_NUM_ATT_IN_FBLK(blk_id_ndx);
vblkcon = VAR_FBCONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
case EX_ELEM_BLOCK:
dnument = DIM_NUM_EL_IN_BLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnumedg = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnumfac = DIM_NUM_FAC_PER_EL(blk_id_ndx);
dnumatt = DIM_NUM_ATT_IN_BLK(blk_id_ndx);
vblkcon = VAR_CONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Bad block type parameter (%d) specified for file id %d.",
block->type, exoid );
return (EX_FATAL);
}
/* inquire values of some dimensions */
if ((status = nc_inq_dimid (exoid, dnument, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of entities in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id,exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_dimlen (exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in block %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
block->num_entry = len;
if ((status = nc_inq_dimid (exoid, dnumnod, &dimid)) != NC_NOERR) {
/* undefined => no node entries per element */
len = 0;
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes/entity in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
}
block->num_nodes_per_entry = len;
if (!file->has_edges || block->type != EX_ELEM_BLOCK) {
block->num_edges_per_entry = 0;
} else {
if ((status = nc_inq_dimid (exoid, dnumedg, &dimid)) != NC_NOERR) {
/* undefined => no edge entries per element */
len = 0;
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of edges/entry in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
}
block->num_edges_per_entry = len;
}
if (!file->has_faces || block->type != EX_ELEM_BLOCK ) {
block->num_faces_per_entry = 0;
} else {
if ((status = nc_inq_dimid (exoid, dnumfac, &dimid)) != NC_NOERR) {
/* undefined => no face entries per element */
len = 0;
} else {
if ((status = nc_inq_dimlen(exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of faces/entity in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
}
block->num_faces_per_entry = len;
}
if ((status = nc_inq_dimid (exoid, dnumatt, &dimid)) != NC_NOERR) {
/* dimension is undefined */
block->num_attribute = 0;
} else {
if ((status = nc_inq_dimlen(exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of attributes in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
block->num_attribute = len;
}
if (block->num_nodes_per_entry > 0) {
; /* Do nothing, vblkcon should be correctly set already */
} else if (block->num_edges_per_entry > 0) {
vblkcon = VAR_EBCONN(blk_id_ndx);
} else if (block->num_faces_per_entry > 0) {
vblkcon = VAR_FCONN(blk_id_ndx);
}
if (vblkcon) {
/* look up connectivity array for this element block id */
if ((status = nc_inq_varid (exoid, vblkcon, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(block->type), block->id,exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_attlen (exoid, connid, ablknam, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s %"PRId64" type in file id %d",
ex_name_of_object(block->type), block->id,exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
if (len > (MAX_STR_LENGTH+1)) {
len = MAX_STR_LENGTH;
sprintf (errmsg,
"Warning: %s %"PRId64" type will be truncated to %ld chars",
ex_name_of_object(block->type), block->id, (long)len);
ex_err("ex_get_block_param",errmsg,EX_MSG);
}
for (i=0; i < MAX_STR_LENGTH+1; i++) {
block->topology[i] = '\0';
/* get the element type name */
}if ((status = nc_get_att_text (exoid, connid, ablknam, block->topology)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to get %s %"PRId64" type in file id %d",
ex_name_of_object(block->type), block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
/* get rid of trailing blanks */
ex_trim_internal(block->topology);
}
return (EX_NOERR);
}
int ex_get_attr( int exoid,
ex_entity_type obj_type,
ex_entity_id obj_id,
void* attrib )
{
int status;
int attrid, obj_id_ndx;
char errmsg[MAX_ERR_LENGTH];
const char* vattrbname;
exerrval = 0; /* clear error code */
/* Determine index of obj_id in vobjids array */
if (obj_type == EX_NODAL) {
obj_id_ndx = 0;
} else {
obj_id_ndx = ex_id_lkup(exoid,obj_type,obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"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_attr",errmsg,EX_NULLENTITY);
return (EX_WARN); /* no attributes for this object */
}
sprintf(errmsg,
"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_attr",errmsg,exerrval);
return (EX_WARN);
}
}
switch (obj_type) {
case EX_SIDE_SET:
vattrbname = VAR_SSATTRIB(obj_id_ndx);
break;
case EX_NODE_SET:
vattrbname = VAR_NSATTRIB(obj_id_ndx);
break;
case EX_EDGE_SET:
vattrbname = VAR_ESATTRIB(obj_id_ndx);
break;
case EX_FACE_SET:
vattrbname = VAR_FSATTRIB(obj_id_ndx);
break;
case EX_ELEM_SET:
vattrbname = VAR_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
vattrbname = VAR_NATTRIB;
break;
case EX_EDGE_BLOCK:
vattrbname = VAR_EATTRIB(obj_id_ndx);
break;
case EX_FACE_BLOCK:
vattrbname = VAR_FATTRIB(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
vattrbname = VAR_ATTRIB(obj_id_ndx);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized object type in switch: %d in file id %d",
obj_type,exoid);
ex_err("ex_get_attr",errmsg,EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
if ((status = nc_inq_varid(exoid, vattrbname, &attrid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"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_attr",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the attributes */
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, attrid, attrib);
} else {
status = nc_get_var_double(exoid, attrid, attrib);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"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_attr",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
int ex_put_partial_side_set_df(int exoid, ex_entity_id side_set_id, int64_t start_num,
int64_t num_df_to_get, void *side_set_dist_fact)
{
int status;
int dimid, side_set_id_ndx;
int dist_id;
size_t num_df_in_set, start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any side sets are specified */
if ((status = nc_inq_dimid(exoid, DIM_NUM_SS, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: no side sets specified in file id %d", exoid);
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
/* Lookup index of side set id in VAR_SS_IDS array */
if ((side_set_id_ndx = ex_id_lkup(exoid, EX_SIDE_SET, side_set_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no data allowed for NULL side set %" PRId64 " in file id %d", side_set_id,
exoid);
ex_err("ex_put_side_set_fact", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate side set id %" PRId64 " in VAR_SS_IDS array in file id %d",
side_set_id, exoid);
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
/* inquire id's of previously defined dimension and variable */
if ((status = nc_inq_dimid(exoid, DIM_NUM_DF_SS(side_set_id_ndx), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no dist factors defined for side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_WARN);
}
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate number of dist factors in side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_df_in_set)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of dist factors in side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (start_num < 0 || (num_df_to_get > 0 && start_num > num_df_in_set)) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Invalid input");
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
if (num_df_to_get < 0) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Invalid number of df's to put!");
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
/* start_num now starts at 1, not 0 */
if ((start_num + num_df_to_get) > num_df_in_set + 1) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: request larger than number of df's in set!");
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, VAR_FACT_SS(side_set_id_ndx), &dist_id)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate dist factors list for side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
/* write out the distribution factors array */
start[0] = --start_num;
count[0] = num_df_to_get;
if (num_df_to_get == 0) {
start[0] = 0;
}
if (ex_comp_ws(exoid) == 4) {
status = nc_put_vara_float(exoid, dist_id, start, count, side_set_dist_fact);
}
else {
status = nc_put_vara_double(exoid, dist_id, start, count, side_set_dist_fact);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store dist factors for side set %" PRId64 " in file id %d",
side_set_id, exoid);
ex_err("ex_put_partial_side_set_df", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_conn( int exoid,
ex_entity_type blk_type,
int blk_id,
int* nodeconn,
int* edgeconn,
int* faceconn )
{
int connid, econnid, fconnid, blk_id_ndx, status;
int numnodperentdim, numedgperentdim, numfacperentdim;
int iexit = (EX_NOERR); /* exit status */
size_t num_nodes_per_entry, num_edges_per_entry, num_faces_per_entry;
char errmsg[MAX_ERR_LENGTH];
const char* dnumblkent;
const char* dnumnodent;
const char* dnumedgent;
const char* dnumfacent;
const char* vnodeconn;
const char* vedgeconn;
const char* vfaceconn;
/* 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.
*/
exerrval = 0; /* clear error code */
/* Locate index of element block id in VAR_ID_EL_BLK array */
blk_id_ndx = ex_id_lkup(exoid,blk_type,blk_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no connectivity array for NULL %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg,EX_MSG);
return (EX_WARN); /* no connectivity array for this element block */
}
else
{
sprintf(errmsg,
"Error: failed to locate %s id %d in id array in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg,exerrval);
return (EX_FATAL);
}
}
switch (blk_type) {
case EX_EDGE_BLOCK:
dnumblkent = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
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:
dnumblkent = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
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:
dnumblkent = DIM_NUM_EL_IN_BLK(blk_id_ndx);
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:
sprintf(errmsg,
"Error: Called with invalid blk_type %d", blk_type );
ex_err("ex_get_conn",errmsg,exerrval);
return (EX_FATAL);
break;
}
/* inquire id's of previously defined dimensions */
if ((status = nc_inq_dimid (exoid, dnumnodent, &numnodperentdim)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes/entity for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg,exerrval);
return(EX_FATAL);
}
if (nc_inq_dimlen(exoid, numnodperentdim, &num_nodes_per_entry) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes/entity for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
if ( dnumedgent ) {
num_edges_per_entry = 0;
if ((status = nc_inq_dimid(exoid, dnumedgent, &numedgperentdim)) != NC_NOERR) {
numedgperentdim = -1;
} else {
if ((status = nc_inq_dimlen(exoid, numedgperentdim, &num_edges_per_entry)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of edges/entry for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
}
if ( dnumfacent ) {
num_faces_per_entry = 0;
if ((status = nc_inq_dimid(exoid, dnumfacent, &numfacperentdim)) != NC_NOERR) {
numfacperentdim = -1;
} else {
if ((status = nc_inq_dimlen(exoid, numfacperentdim, &num_faces_per_entry)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of faces/entry for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
}
if ((status = nc_inq_varid(exoid, vnodeconn, &connid)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
status = 0;
if (edgeconn && (numedgperentdim > 0) &&
((status = nc_inq_varid (exoid, vedgeconn, &econnid)) != NC_NOERR))
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate edge connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
if (faceconn && (numfacperentdim > 0) &&
((status = nc_inq_varid (exoid, vfaceconn, &fconnid)) != NC_NOERR))
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate face connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
/* read in the connectivity array */
if ( edgeconn && num_edges_per_entry > 0) {
status = nc_get_var_int(exoid, econnid, edgeconn);
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get edge connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
if ( faceconn && num_faces_per_entry > 0) {
status = nc_get_var_int(exoid, fconnid, faceconn);
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get face connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
if ( nodeconn && num_nodes_per_entry > 0) {
status = nc_get_var_int(exoid, connid, nodeconn);
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
return iexit;
}
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 */
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"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) {
sprintf(errmsg,
"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);
} else {
sprintf(errmsg,
"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;
sprintf(errmsg,
"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;
sprintf(errmsg,
"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;
sprintf(errmsg,
"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;
sprintf(errmsg,
"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) {
sprintf(errmsg,
"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);
}