char* ex_dim_num_entries_in_object( ex_entity_type obj_type,
int idx )
{
switch (obj_type) {
case EX_NODAL:
return DIM_NUM_NODES;
case EX_EDGE_BLOCK:
return DIM_NUM_ED_IN_EBLK(idx);
case EX_FACE_BLOCK:
return DIM_NUM_FA_IN_FBLK(idx);
case EX_ELEM_BLOCK:
return DIM_NUM_EL_IN_BLK(idx);
case EX_NODE_SET:
return DIM_NUM_NOD_NS(idx);
case EX_EDGE_SET:
return DIM_NUM_EDGE_ES(idx);
case EX_FACE_SET:
return DIM_NUM_FACE_FS(idx);
case EX_SIDE_SET:
return DIM_NUM_SIDE_SS(idx);
case EX_ELEM_SET:
return DIM_NUM_ELE_ELS(idx);
default:
return 0;
}
}
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_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_set_dist_fact (int exoid,
int set_type,
int set_id,
void *set_dist_fact)
{
int dimid, dist_id, set_id_ndx;
long num_df_in_set, count[1], start[1];
char errmsg[MAX_ERR_LENGTH];
char* typeName;
char* dimptr;
char* idsptr;
char* numdfptr;
char* factptr;
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_dist_fact",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_dist_fact",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_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 */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* inquire id's of previously defined dimensions and variables */
if ((dimid = ncdimid (exoid, numdfptr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: dist factors not stored for %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_WARN); /* complain - but not too loud */
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_df_in_set) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of dist factors in %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
if ((dist_id = ncvarid (exoid, factptr)) == -1)
{
exerrval = ncerr;
/* not an error for node sets because this is how we check that df's exist */
if (set_type == EX_NODE_SET)
{
sprintf(errmsg,
"Warning: dist factors not stored for %s set %d in file id %d",
typeName, set_id, exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_WARN); /* complain - but not too loud */
}
/* is an error for other sets */
else
{
sprintf(errmsg,
"Error: failed to locate dist factors list for %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
/* read in the distribution factors array */
start[0] = 0;
count[0] = num_df_in_set;
if (ncvarget (exoid, dist_id, start, count,
ex_conv_array(exoid,RTN_ADDRESS,set_dist_fact,
(int)num_df_in_set)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get dist factors list for %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
ex_conv_array( exoid, READ_CONVERT, set_dist_fact, num_df_in_set );
return (EX_NOERR);
}
int ex_put_attr_param (int exoid,
ex_entity_type obj_type,
int obj_id,
int num_attrs)
{
int status;
int dims[2];
int strdim, varid;
char errmsg[MAX_ERR_LENGTH];
const char *dnumobjent;
const char *dnumobjatt;
const char *vobjatt;
const char *vattnam;
int numobjentdim;
int obj_id_ndx;
int numattrdim;
/* Determine index of obj_id in obj_type id 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 %d in file id %d",
ex_name_of_object(obj_type),obj_id,exoid);
ex_err("ex_put_attr_param",errmsg,EX_MSG);
return (EX_WARN); /* no attributes for this object */
} else {
sprintf(errmsg,
"Warning: failed to locate %s id %d in id array in file id %d",
ex_name_of_object(obj_type),obj_id, exoid);
ex_err("ex_put_attr_param",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);
vobjatt = VAR_SSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_NSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_ESATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_FSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_ELSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
dnumobjent = DIM_NUM_NODES;
dnumobjatt = DIM_NUM_ATT_IN_NBLK;
vobjatt = VAR_NATTRIB;
vattnam = VAR_NAME_NATTRIB;
break;
case EX_EDGE_BLOCK:
dnumobjent = DIM_NUM_ED_IN_EBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
vobjatt = VAR_EATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_FATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_ATTRIB(obj_id_ndx);
vattnam = VAR_NAME_ATTRIB(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_put_attr_param",errmsg,exerrval);
return (EX_FATAL);
}
exerrval = 0; /* clear error code */
if ((status = nc_inq_dimid(exoid, dnumobjent, &numobjentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of entries for %s %d in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_put_attr_param",errmsg,exerrval);
return (EX_FATAL);
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_attr_param",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_def_dim(exoid, dnumobjatt, num_attrs, &numattrdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of attributes in %s %d in file id %d",
ex_name_of_object(obj_type), obj_id,exoid);
ex_err("ex_put_attr_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dims[0] = numobjentdim;
dims[1] = numattrdim;
if ((status = nc_def_var(exoid, vobjatt, nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define attributes for %s %d in file id %d",
ex_name_of_object(obj_type), obj_id,exoid);
ex_err("ex_put_attr_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &strdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_attr_param",errmsg,exerrval);
return (EX_FATAL);
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if ((status = nc_def_var(exoid, vattnam, NC_CHAR, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s attribute name array in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_put_attr_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 %s attribute parameter definition in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_put_attr_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_attr_param",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_partial_attr(int exoid, ex_entity_type obj_type, ex_entity_id obj_id, int64_t start_num,
int64_t num_ent, void *attrib)
{
int status;
int attrid, obj_id_ndx;
int temp;
size_t num_entries_this_obj, num_attr;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
const char *dnumobjent;
const char *dnumobjatt;
const char *vattrbname;
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
if (num_ent == 0) {
return 0;
}
/* Determine index of obj_id in vobjids array */
if (obj_type != EX_NODAL) {
obj_id_ndx = ex_id_lkup(exoid, obj_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no attributes found for NULL %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, EX_NULLENTITY);
return (EX_WARN); /* no attributes for this object */
}
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: failed to locate %s id%" PRId64 " in id array in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_WARN);
}
}
switch (obj_type) {
case EX_SIDE_SET:
dnumobjent = DIM_NUM_SIDE_SS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_SS(obj_id_ndx);
vattrbname = VAR_SSATTRIB(obj_id_ndx);
break;
case EX_NODE_SET:
dnumobjent = DIM_NUM_NOD_NS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_NS(obj_id_ndx);
vattrbname = VAR_NSATTRIB(obj_id_ndx);
break;
case EX_EDGE_SET:
dnumobjent = DIM_NUM_EDGE_ES(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_ES(obj_id_ndx);
vattrbname = VAR_ESATTRIB(obj_id_ndx);
break;
case EX_FACE_SET:
dnumobjent = DIM_NUM_FACE_FS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_FS(obj_id_ndx);
vattrbname = VAR_FSATTRIB(obj_id_ndx);
break;
case EX_ELEM_SET:
dnumobjent = DIM_NUM_ELE_ELS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_ELS(obj_id_ndx);
vattrbname = VAR_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
dnumobjent = DIM_NUM_NODES;
dnumobjatt = DIM_NUM_ATT_IN_NBLK;
vattrbname = VAR_NATTRIB;
break;
case EX_EDGE_BLOCK:
dnumobjent = DIM_NUM_ED_IN_EBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
vattrbname = VAR_EATTRIB(obj_id_ndx);
break;
case EX_FACE_BLOCK:
dnumobjent = DIM_NUM_FA_IN_FBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_FBLK(obj_id_ndx);
vattrbname = VAR_FATTRIB(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
dnumobjent = DIM_NUM_EL_IN_BLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_BLK(obj_id_ndx);
vattrbname = VAR_ATTRIB(obj_id_ndx);
break;
default:
exerrval = 1005;
snprintf(errmsg, MAX_ERR_LENGTH,
"Internal ERROR: unrecognized object type in switch: %d in file id %d", obj_type,
exoid);
ex_err("ex_get_partial_attr", errmsg, EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
if (ex_get_dimension(exoid, dnumobjent, "entries", &num_entries_this_obj, &temp,
"ex_get_partial_attr") != NC_NOERR) {
return EX_FATAL;
}
if (start_num + num_ent - 1 > num_entries_this_obj) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: start index (%" PRId64 ") + count (%" PRId64
") is larger than total number of entities (%" ST_ZU ") in file id %d",
start_num, num_ent, num_entries_this_obj, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_FATAL);
}
if (ex_get_dimension(exoid, dnumobjatt, "attributes", &num_attr, &temp, "ex_get_partial_attr") !=
NC_NOERR) {
return EX_FATAL;
}
if ((status = nc_inq_varid(exoid, vattrbname, &attrid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate attributes for %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_FATAL);
}
/* read in the attributes */
start[0] = start_num - 1;
start[1] = 0;
count[0] = num_ent;
count[1] = num_attr;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, attrid, start, count, attrib);
}
else {
status = nc_get_vara_double(exoid, attrid, start, count, attrib);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get attributes for %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_partial_attr", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_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_concat_sets (int exoid,
ex_entity_type set_type,
const struct ex_set_specs* set_specs)
{
int status;
int temp;
const void_int *num_entries_per_set = set_specs->num_entries_per_set;
const void_int *num_dist_per_set = set_specs->num_dist_per_set;
const void_int *sets_entry_index = set_specs->sets_entry_index;
const void_int *sets_dist_index = set_specs->sets_dist_index;
const void *sets_dist_fact = set_specs->sets_dist_fact;
size_t i, num_df, num_entry;
int cur_num_sets, num_sets;
int dimid, varid, set_id_ndx, dims[1];
int *set_stat = NULL;
int set_int_type, int_size;
const float *flt_dist_fact = NULL;
const double *dbl_dist_fact = NULL;
char errmsg[MAX_ERR_LENGTH];
char* idsptr = NULL;
char* statptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
char* elemptr = NULL;
char* extraptr = NULL;
ex_inquiry ex_inq_val;
exerrval = 0; /* clear error code */
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* setup pointers based on set_type
NOTE: there is another block that sets more stuff later ... */
if (set_type == EX_NODE_SET) {
ex_inq_val = EX_INQ_NODE_SETS;
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (set_type == EX_EDGE_SET) {
ex_inq_val = EX_INQ_EDGE_SETS;
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (set_type == EX_FACE_SET) {
ex_inq_val = EX_INQ_FACE_SETS;
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (set_type == EX_SIDE_SET) {
ex_inq_val = EX_INQ_SIDE_SETS;
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (set_type == EX_ELEM_SET) {
ex_inq_val = EX_INQ_ELEM_SETS;
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
else {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: invalid set type (%d)", set_type);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &temp)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss defined for file id %d", ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
/* inquire how many sets are to be stored */
num_sets = ex_inquire_int(exoid, ex_inq_val);
if (num_sets < 0) {
sprintf(errmsg,
"Error: failed to get number of %ss defined for file id %d",
ex_name_of_object(set_type), exoid);
/* use error val from inquire */
ex_err("ex_put_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* Fill out set status array */
/* First, allocate space for the status list */
if (!(set_stat= malloc(num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for %s status array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
if (int_size == sizeof(int64_t)) {
for (i=0;i<num_sets;i++) {
set_stat[i] = (((int64_t*)num_entries_per_set)[i] == 0) ? 0 : 1;
}
} else {
for (i=0;i<num_sets;i++) {
set_stat[i] = (((int*)num_entries_per_set)[i] == 0) ? 0 : 1;
}
}
/* Next, get variable id of status array */
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
status = nc_put_var_int(exoid, varid, set_stat);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s status array to file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_set",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* create set definitions */
for (i=0; i<num_sets; i++) {
int64_t set_id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
set_id = ((int64_t*)set_specs->sets_ids)[i];
} else {
set_id = ((int*)set_specs->sets_ids)[i];
}
/* Keep track of the total number of sets defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of sets of type
for a specific file and returns that value.
*/
cur_num_sets=ex_get_file_item(exoid, ex_get_counter_list(set_type));
if (cur_num_sets >= num_sets) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(set_type), num_sets,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
goto error_ret;
}
/* NOTE: ex_inc_file_item is used to find the number of sets
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(set_type));
set_id_ndx = cur_num_sets + 1;
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
elemptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
elemptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
elemptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
elemptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
elemptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* define dimension for number of entries per set */
if (set_stat[i] == 0) /* Is this a NULL set? */
continue; /* Do not create anything for NULL sets! */
if (int_size == sizeof(int)) {
status = nc_def_dim(exoid, ex_dim_num_entries_in_object(set_type, set_id_ndx),
((int*)num_entries_per_set)[i], &dimid);
} else {
status = nc_def_dim(exoid, ex_dim_num_entries_in_object(set_type, set_id_ndx),
((int64_t*)num_entries_per_set)[i], &dimid);
}
if (status != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: %s entry count %"PRId64" already defined in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of entries for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret;
}
/* create element list variable for set */
set_int_type = NC_INT;
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
set_int_type = NC_INT64;
}
dims[0] = dimid;
if ((status = nc_def_var(exoid,elemptr,set_int_type,1,dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: element list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create element list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 1);
/* create extra list variable for set (only for edge, face and side sets) */
if (extraptr) {
if ((status = nc_def_var(exoid,extraptr,set_int_type,1,dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: extra list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create extra list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 1);
}
/* define dimension for number of dist factors per set */
/* NOTE: only define df count if the dist factors exist! */
if (int_size == sizeof(int64_t)) {
num_df = ((int64_t*)num_dist_per_set)[i];
num_entry = ((int64_t*)num_entries_per_set)[i];
} else {
num_df = ((int*)num_dist_per_set)[i];
num_entry = ((int*)num_entries_per_set)[i];
}
if (num_df > 0) {
if (set_type == EX_NODE_SET) {
if (num_df != num_entry) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%"ST_ZU") not equal to # nodes (%"ST_ZU") in node set %"PRId64" file id %d",
num_df, num_entry, set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* resuse dimid from entry lists */
} else {
if ((status = nc_def_dim(exoid, numdfptr,
num_df, &dimid)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: %s df count %"PRId64" already defined in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s df count for set %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret;
}
}
/* create distribution factor list variable for set */
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: dist factor list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create dist factor list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 2);
} /* end define dist factors */
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* Next, fill out set ids array */
/* first get id of set ids array variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* then, write out set id list */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, varid, set_specs->sets_ids);
} else {
status = nc_put_var_int(exoid, varid, set_specs->sets_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* If the sets_entry_index is passed in as a NULL pointer, then
* the user only wants us to define the sets and not populate
* the data structures.
*/
if (sets_entry_index == 0) {
ex_safe_free(set_stat);
return(EX_NOERR);
}
/* Now, use ExodusII call to store sets */
for (i=0; i<num_sets; i++) {
int64_t set_id;
size_t df_ndx;
if (set_stat[i] == 0) /* Is this a NULL set? */
continue; /* Do not create anything for NULL sets! */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
set_id = ((int64_t*)set_specs->sets_ids)[i];
} else {
set_id = ((int*)set_specs->sets_ids)[i];
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int64_t* extra_list = NULL;
/* set extra list */
if (set_type == EX_EDGE_SET || set_type == EX_FACE_SET || set_type == EX_SIDE_SET)
extra_list = &(((int64_t*)set_specs->sets_extra_list)[((int64_t*)sets_entry_index)[i]]);
status = ex_put_set(exoid, set_type, set_id,
&(((int64_t*)set_specs->sets_entry_list)[((int64_t*)sets_entry_index)[i]]),
extra_list);
} else {
int* extra_list = NULL;
/* set extra list */
if (set_type == EX_EDGE_SET || set_type == EX_FACE_SET || set_type == EX_SIDE_SET)
extra_list = &(((int*)set_specs->sets_extra_list)[((int*)sets_entry_index)[i]]);
status = ex_put_set(exoid, set_type, set_id,
&(((int*)set_specs->sets_entry_list)[((int*)sets_entry_index)[i]]),
extra_list);
}
if (status != NC_NOERR) {
ex_safe_free(set_stat);
return(EX_FATAL); /* error will be reported by subroutine */
}
if (int_size == sizeof(int)) {
num_df = ((int*)num_dist_per_set)[i];
df_ndx = ((int*)sets_dist_index)[i];
} else {
num_df = ((int64_t*)num_dist_per_set)[i];
df_ndx = ((int64_t*)sets_dist_index)[i];
}
if (ex_comp_ws(exoid) == sizeof(float)) {
flt_dist_fact = sets_dist_fact;
if (num_df > 0) { /* store dist factors if required */
if (ex_put_set_dist_fact(exoid, set_type, set_id,
&(flt_dist_fact[df_ndx])) == -1) {
sprintf(errmsg,
"Error: failed to store %s %"PRId64" dist factors for file id %d",
ex_name_of_object(set_type), set_id,exoid);
/* use error val from exodusII routine */
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
} else if (ex_comp_ws(exoid) == sizeof(double)) {
dbl_dist_fact = sets_dist_fact;
if (num_df) { /* only store if they exist */
if (ex_put_set_dist_fact(exoid, set_type, set_id,
&(dbl_dist_fact[df_ndx])) == -1) {
sprintf(errmsg,
"Error: failed to store %s %"PRId64" dist factors for file id %d",
ex_name_of_object(set_type), set_id,exoid);
/* use error val from exodusII routine */
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
} else {
/* unknown floating point word size */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: unsupported floating point word size %d for file id %d",
ex_comp_ws(exoid), exoid);
ex_err("ex_put_concat_sets", errmsg, exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
ex_safe_free(set_stat);
return(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
ex_safe_free(set_stat);
if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_node_set (int exoid,
int node_set_id,
int *node_set_node_list)
{
int dimid, node_list_id, node_set_id_ndx, iresult;
long num_nodes_in_set, start[1], count[1];
nclong *longs;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any node sets are specified */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no node sets defined in file id %d",
exoid);
ex_err("ex_get_node_set",errmsg,exerrval);
return (EX_WARN);
}
/* Lookup index of node set id in VAR_NS_IDS array */
node_set_id_ndx = ex_id_lkup(exoid,VAR_NS_IDS,node_set_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: node set %d is NULL in file id %d",
node_set_id,exoid);
ex_err("ex_get_node_set",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
sprintf(errmsg,
"Error: failed to locate node set id %d in %s in file id %d",
node_set_id,VAR_NS_IDS,exoid);
ex_err("ex_get_node_set",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire id's of previously defined dimensions and variables */
if ((dimid = ncdimid (exoid, DIM_NUM_NOD_NS(node_set_id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %d in file id %d",
node_set_id,exoid);
ex_err("ex_get_node_set",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_nodes_in_set) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes in set %d in file id %d",
node_set_id, exoid);
ex_err("ex_get_node_set",errmsg,exerrval);
return (EX_FATAL);
}
if ((node_list_id = ncvarid (exoid, VAR_NODE_NS(node_set_id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate node set %d node list in file id %d",
node_set_id,exoid);
ex_err("ex_get_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the node list array */
/* 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_nodes_in_set;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarget (exoid, node_list_id, start, count, node_set_node_list);
} else {
if (!(longs = malloc(num_nodes_in_set * sizeof(nclong)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for node set node list for file id %d",
exoid);
ex_err("ex_get_node_set",errmsg,exerrval);
return (EX_FATAL);
}
iresult = ncvarget (exoid, node_list_id, start, count, longs);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get node set node list in file id %d",
exoid);
ex_err("ex_get_node_set",errmsg,exerrval);
return (EX_FATAL);
}
if (sizeof(int) != sizeof(nclong)) {
ltoi (longs, node_set_node_list, num_nodes_in_set);
free (longs);
}
return (EX_NOERR);
}
/*
* reads the attributes for an edge, face, or element block
*/
int ex_get_one_attr( int exoid,
ex_entity_type obj_type,
ex_entity_id obj_id,
int attrib_index,
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];
ptrdiff_t stride[2];
char errmsg[MAX_ERR_LENGTH];
const char* dnumobjent;
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_one_attr",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_one_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;
sprintf(errmsg,
"Internal Error: unrecognized object type in switch: %d in file id %d",
obj_type,exoid);
ex_err("ex_get_one_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_one_attr") != NC_NOERR)
return EX_FATAL;
if (ex_get_dimension(exoid, dnumobjatt,"attributes", &num_attr, &temp, "ex_get_one_attr") != NC_NOERR)
return EX_FATAL;
if (attrib_index < 1 || attrib_index > (int)num_attr) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: Invalid attribute index specified: %d. Valid range is 1 to %d for %s %"PRId64" in file id %d",
attrib_index, (int)num_attr, ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_one_attr",errmsg,exerrval);
return (EX_FATAL);
}
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_one_attr",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the attributes */
start[0] = 0;
start[1] = attrib_index-1;
count[0] = num_entries_this_obj;
count[1] = 1;
stride[0] = 1;
stride[1] = num_attr;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vars_float(exoid, attrid, start, count, stride, attrib);
} else {
status = nc_get_vars_double(exoid, attrid, start, count, stride, attrib);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get attribute %d for %s %"PRId64" in file id %d",
attrib_index, ex_name_of_object(obj_type), obj_id,exoid);
ex_err("ex_get_one_attr",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
int ex_put_partial_node_set(int exoid, ex_entity_id node_set_id, int64_t start_node_num,
int64_t num_nodes, const void_int *node_set_node_list)
{
int dimid, node_list_id, node_set_id_ndx, status;
size_t num_nodes_in_set, start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any node sets are specified */
if ((status = nc_inq_dimid(exoid, DIM_NUM_NS, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: no node sets specified in file id %d", exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
/* Lookup index of node set id in VAR_NS_IDS array */
if ((node_set_id_ndx = ex_id_lkup(exoid, EX_NODE_SET, node_set_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no data allowed for NULL node set %" PRId64 " in file id %d", node_set_id,
exoid);
ex_err("ex_put_partial_node_set", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate node set id %" PRId64 " in VAR_NS_IDS array in file id %d",
node_set_id, exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
/* inquire id's of previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_NUM_NOD_NS(node_set_id_ndx), &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate number of nodes in set %" PRId64 " in file id %d",
node_set_id, exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_nodes_in_set)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of nodes in set %" PRId64 " in file id %d", node_set_id,
exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (start_node_num < 0 || start_node_num > num_nodes_in_set) {
fprintf(stderr, "ERROR: Invalid input to function ex_get_partial_node_set!\n");
return -1;
}
if (num_nodes < 0) {
fprintf(stderr, "ERROR: Invalid number of nodes in nodes set!\n");
return -1;
}
/* start_node_num now starts at 1, not 0 */
if ((start_node_num + num_nodes - 1) > num_nodes_in_set) {
fprintf(stderr, "ERROR: request larger than number of nodes in set!\n");
return -1;
}
/* inquire if variable for node set node list has been defined */
if ((status = nc_inq_varid(exoid, VAR_NODE_NS(node_set_id_ndx), &node_list_id)) != NC_NOERR) {
/* variable doesn't exist */
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate node set %" PRId64 " node list in file id %d", node_set_id,
exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
/* write out the node list array */
start[0] = --start_node_num;
count[0] = num_nodes;
if (count[0] == 0) {
start[0] = 0;
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_put_vara_longlong(exoid, node_list_id, start, count, node_set_node_list);
}
else {
status = nc_put_vara_int(exoid, node_list_id, start, count, node_set_node_list);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store node set %" PRId64 " node list in file id %d", node_set_id,
exoid);
ex_err("ex_put_partial_node_set", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int define_truth_table(char type, int exoid, int num_ent, int num_var,
int *var_tab, int *status, int *ids, const char *label)
{
char errmsg[MAX_ERR_LENGTH];
int k = 0;
int i, j;
int time_dim;
int dims[2];
int varid;
time_dim = ncdimid (exoid, DIM_TIME);
if (var_tab == NULL) {
exerrval = EX_NULLENTITY;
sprintf(errmsg,
"Error: %s variable truth table is NULL in file id %d", label, exoid);
ex_err("ex_put_all_var_param",errmsg, exerrval);
return -1;
}
for (i=0; i<num_ent; i++) {
for (j=1; j<=num_var; j++) {
/* check if variables are to be put out for this block */
if (var_tab[k] != 0) {
if (status[i] == 0) {/* check for NULL entity */
var_tab[k] = 0;
#if 0
exerrval = EX_NULLENTITY;
sprintf(errmsg,
"Warning: %s variable truth table specifies invalid entry for NULL %s %d, variable %d in file id %d",
label, label, ids[i], j, exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
#endif
} else {
dims[0] = time_dim;
/* Determine number of entities in entity */
/* Need way to make this more generic... */
if (type == 'e')
dims[1] = ncdimid (exoid, DIM_NUM_EL_IN_BLK(i+1));
else if (type == 'm')
dims[1] = ncdimid (exoid, DIM_NUM_NOD_NS(i+1));
else if (type == 's')
dims[1] = ncdimid (exoid, DIM_NUM_SIDE_SS(i+1));
if (dims[1] == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of entities in %s %d in file id %d",
label, ids[i], exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
return -1;
}
/* define netCDF variable to store variable values;
* the j index cycles from 1 through the number of variables so
* that the index of the EXODUS II variable (which is part of
* the name of the netCDF variable) will begin at 1 instead of 0
*/
if (type == 'e')
varid = ncvardef(exoid, VAR_ELEM_VAR(j,i+1), nc_flt_code(exoid), 2, dims);
else if (type == 'm')
varid = ncvardef(exoid, VAR_NS_VAR(j,i+1), nc_flt_code(exoid), 2, dims);
else if (type == 's')
varid = ncvardef(exoid, VAR_SS_VAR(j,i+1), nc_flt_code(exoid), 2, dims);
if (varid == -1) {
if (ncerr != NC_ENAMEINUSE) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define %s variable for %s %d in file id %d",
label, label, ids[i], exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
return -1;
}
}
}
} /* if */
k++; /* increment truth table pointer */
} /* for j */
} /* for i */
return 0;
}
int ex_get_node_set_param (int exoid,
int node_set_id,
int *num_nodes_in_set,
int *num_df_in_set)
{
int dimid, node_set_id_ndx;
long lnum_nodes_in_set, lnum_df_in_set;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any node sets are specified */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Warning: no node sets defined in file id %d",
exoid);
ex_err("ex_get_node_set_param",errmsg,exerrval);
return (EX_WARN);
}
/* Lookup index of node set id in VAR_NS_IDS array */
node_set_id_ndx = ex_id_lkup(exoid,VAR_NS_IDS,node_set_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY) /* NULL node set ? */
{
*num_nodes_in_set = 0;
*num_df_in_set = 0;
return (EX_NOERR);
}
else
{
sprintf(errmsg,
"Error: failed to locate node set id %d in VAR_NS_IDS array in file id %d",
node_set_id,exoid);
ex_err("ex_get_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire value of dimension of number of nodes for this node set */
if ((dimid = ncdimid (exoid, DIM_NUM_NOD_NS(node_set_id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %d in file id %d",
node_set_id,exoid);
ex_err("ex_get_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_nodes_in_set) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes in node set %d in file id %d",
node_set_id,exoid);
ex_err("ex_get_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
*num_nodes_in_set = lnum_nodes_in_set;
/* Inquire if the dist factors variable have been defined for this node set.
NOTE: If the dist factor variable for this node set index doesn't exist,
it is assumed to be zero, otherwise the dist factor count will be
the same as the number of nodes in the set. */
if ((ncvarid (exoid, VAR_FACT_NS(node_set_id_ndx))) == -1)
{
*num_df_in_set = 0; /* signal dist factor doesn't exist */
if (ncerr == NC_ENOTVAR)
return (EX_NOERR);
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate the dist factors for node set %d in file id %d",
node_set_id,exoid);
ex_err("ex_get_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
}
else
{
/* dimension exists, retrieve value */
if (ncdiminq (exoid, dimid, (char *) 0, &lnum_df_in_set) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of dist fact in node set %d in file id %d",
node_set_id,exoid);
ex_err("ex_get_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
*num_df_in_set = lnum_nodes_in_set; /* # of df = # of nodes */
}
return (EX_NOERR);
}
int ex_put_set (int exoid,
int set_type,
int set_id,
const int *set_entry_list,
const int *set_extra_list)
{
int dimid, iresult;
int entry_list_id, extra_list_id, set_id_ndx;
long num_entries_in_set, start[1], count[1];
nclong *lptr;
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)) < 0)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no %s sets defined in file id %d",
typeName, 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,idsptr,set_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no data allowed for NULL %s set %d in file id %d",
typeName,set_id,exoid);
ex_err("ex_put_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_put_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 */
if ((dimid = ncdimid (exoid, numentryptr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of entities in %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_put_set",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_entries_in_set) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of entities in %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_put_set",errmsg,exerrval);
return (EX_FATAL);
}
/* inquire id's of previously defined variables */
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_put_set",errmsg,exerrval);
return (EX_FATAL);
}
/* only do 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_put_set",errmsg,exerrval);
return (EX_FATAL);
}
}
/* write out the entry list and extra list arrays */
/* this contortion is necessary because netCDF is expecting nclongs; fortunately
it's necessary only when ints and nclongs aren't the same size */
start[0] = 0;
count[0] = num_entries_in_set;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarput(exoid, entry_list_id, start, count, set_entry_list);
} else {
lptr = itol (set_entry_list, (int)num_entries_in_set);
iresult = ncvarput (exoid, entry_list_id, start, count, lptr);
free(lptr);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store entry list for %s set %d in file id %d",
typeName, set_id,exoid);
ex_err("ex_put_set",errmsg,exerrval);
return (EX_FATAL);
}
/* this contortion is necessary because netCDF is expecting nclongs; fortunately
it's necessary only when ints and nclongs aren't the same size */
/* only do for edge, face and side sets */
if (extraptr)
{
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarput(exoid, extra_list_id, start, count, set_extra_list);
} else {
lptr = itol (set_extra_list, (int)num_entries_in_set);
iresult = ncvarput (exoid, extra_list_id, start, count, lptr);
free(lptr);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store extra list for %s set %d in file id %d",
typeName, 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 set %d in file id %d",
typeName, set_id, exoid);
ex_err("ex_put_set",errmsg,EX_MSG);
return(EX_WARN);
}
return (EX_NOERR);
}
int ex_inquire (int exoid,
int req_info,
int *ret_int,
void *ret_float,
char *ret_char)
{
int dimid, varid, i, tmp_num, *ids;
long ldum, num_sets, start[2], count[2];
nclong *stat_vals;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
switch (req_info)
{
case EX_INQ_FILE_TYPE:
/* obsolete call */
/*returns "r" for regular EXODUS II file or "h" for history EXODUS file*/
*ret_char = '\0';
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: file type inquire is obsolete");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_WARN);
case EX_INQ_API_VERS:
/* returns the EXODUS II API version number */
if (ncattget (exoid, NC_GLOBAL, ATT_API_VERSION, ret_float) == -1)
{ /* try old (prior to db version 2.02) attribute name */
if (ncattget (exoid, NC_GLOBAL, ATT_API_VERSION_BLANK,ret_float) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get EXODUS API version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
break;
case EX_INQ_DB_VERS:
/* returns the EXODUS II database version number */
if (ncattget (exoid, NC_GLOBAL, ATT_VERSION, ret_float) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get EXODUS database version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_LIB_VERS:
/* returns the EXODUS II Library version number */
flt_cvt((float *)ret_float, EX_API_VERS);
break;
case EX_INQ_TITLE:
/* returns the title of the database */
if (ncattget (exoid, NC_GLOBAL, ATT_TITLE, ret_char) == -1)
{
*ret_char = '\0';
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get database title for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_DIM:
/* returns the dimensionality (2 or 3, for 2-d or 3-d) of the database */
if ((dimid = ncdimid (exoid, DIM_NUM_DIM)) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate database dimensionality in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get database dimensionality for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
break;
case EX_INQ_NODES:
/* returns the number of nodes */
if ((dimid = ncdimid (exoid, DIM_NUM_NODES)) == -1)
{
*ret_int = 0;
} else {
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_ELEM:
/* returns the number of elements */
if ((dimid = ncdimid (exoid, DIM_NUM_ELEM)) == -1)
{
*ret_int = 0;
} else {
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of elements for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_ELEM_BLK:
/* returns the number of element blocks */
if ((dimid = ncdimid (exoid, DIM_NUM_EL_BLK)) == -1)
{
*ret_int = 0;
} else {
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element blocks for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_NODE_SETS:
/* returns the number of node sets */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) < 0)
*ret_int = 0; /* no node sets defined */
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_NS_NODE_LEN:
/* returns the length of the concatenated node sets node list */
*ret_int = 0; /* default value if no node sets are defined */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) != -1 )
{
if (ncdiminq (exoid, dimid, (char *) 0, &num_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for node set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_node_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get node sets in file id %d",
exoid);
/* pass back error code from ex_get_node_set_ids (in exerrval) */
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(nclong))))
{
exerrval = EX_MEMFAIL;
free (ids);
sprintf(errmsg,
"Error: failed to allocate memory for node set status array for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((varid = ncvarid (exoid, VAR_NS_STAT)) != -1)
{
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
start[0] = 0;
start[1] = 0;
count[0] = num_sets;
count[1] = 0;
if (ncvarget (exoid, varid, start, count, (void *)stat_vals) == -1)
{
exerrval = ncerr;
free (ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get node set status array from file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
for (i=0; i<num_sets; i++)
{
if (stat_vals[i] == 0) /* is this object null? */
continue;
if ((dimid = ncdimid (exoid, DIM_NUM_NOD_NS(i+1))) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %d in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
free (stat_vals);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes in node set %d in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (stat_vals);
free (ids);
return (EX_FATAL);
}
*ret_int += ldum;
}
free (stat_vals);
free (ids);
}
break;
case EX_INQ_NS_DF_LEN:
/* returns the length of the concatenated node sets dist factor list */
/*
Determine the concatenated node sets distribution factor length:
1. Get the node set ids list.
2. Check see if the dist factor variable for a node set id exists.
3. If it exists, goto step 4, else the length is zero.
4. Get the dimension of the number of nodes in the node set -0
use this value as the length as by definition they are the same.
5. Sum the individual lengths for the total list length.
*/
*ret_int = 0; /* default value if no node sets defined */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) != -1)
{
if (ncdiminq (exoid, dimid, (char *) 0, &num_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for node set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_node_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get node sets in file id %d",
exoid);
/* pass back error code from ex_get_node_set_ids (in exerrval) */
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++)
{
if (ncvarid (exoid, VAR_FACT_NS(i+1)) == -1)
{
if (ncerr == NC_ENOTVAR)
{
ldum = 0; /* this dist factor doesn't exist */
}
else
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of dist fact for node set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
}
else
{
if ((dimid = ncdimid (exoid, DIM_NUM_NOD_NS(i+1))) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes in node set %d in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
}
*ret_int += ldum;
}
free(ids);
}
break;
case EX_INQ_SIDE_SETS:
/* returns the number of side sets */
*ret_int = 0; /* default return value */
if ((dimid = ncdimid (exoid, DIM_NUM_SS)) != -1)
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_SS_NODE_LEN:
/* returns the length of the concatenated side sets node list */
*ret_int = 0; /* default return value */
if ((dimid = ncdimid (exoid, DIM_NUM_SS)) != -1)
{
if (ncdiminq (exoid, dimid, (char *) 0, &num_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get side set ids in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(nclong))))
{
exerrval = EX_MEMFAIL;
free (ids);
sprintf(errmsg,
"Error: failed to allocate memory for side set status array for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((varid = ncvarid (exoid, VAR_SS_STAT)) != -1)
{
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
start[0] = 0;
start[1] = 0;
count[0] = num_sets;
count[1] = 0;
if (ncvarget (exoid, varid, start, count, (void *)stat_vals) == -1)
{
exerrval = ncerr;
free (ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get element block status array from file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
/* walk id list, get each side set node length and sum for total */
for (i=0; i<num_sets; i++)
{
if (stat_vals[i] == 0) /* is this object null? */
continue;
if (ex_get_side_set_node_list_len(exoid, ids[i], &tmp_num) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to side set %d node length in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(stat_vals);
free(ids);
return (EX_FATAL);
}
*ret_int += tmp_num;
}
free(stat_vals);
free (ids);
}
break;
case EX_INQ_SS_ELEM_LEN:
/* returns the length of the concatenated side sets element list */
EX_GET_CONCAT_SET_LEN(ret_int,"side",EX_SIDE_SET,DIM_NUM_SS,VAR_SS_STAT,DIM_NUM_SIDE_SS,0);
break;
case EX_INQ_SS_DF_LEN:
/* returns the length of the concatenated side sets dist factor list */
/*
Determine the concatenated side sets distribution factor length:
1. Get the side set ids list.
2. Check see if the dist factor dimension for a side set id exists.
3. If it exists, goto step 4, else set the individual length to zero.
4. Sum the dimension value into the running total length.
*/
*ret_int = 0;
/* first check see if any side sets exist */
if ((dimid = ncdimid (exoid, DIM_NUM_SS)) != -1)
{
if (ncdiminq (exoid, dimid, (char *) 0, &num_sets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get side sets in file id %d",
exoid);
/* pass back error code from ex_get_side_set_ids (in exerrval) */
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++)
{
if ((dimid = ncdimid (exoid, DIM_NUM_DF_SS(i+1))) == -1)
{
if (ncerr == NC_EBADDIM)
{
ldum = 0; /* this dist factor doesn't exist */
}
else
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of dist fact for side set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
}
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of dist factors in side set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
}
*ret_int += ldum;
}
free (ids);
}
break;
case EX_INQ_QA:
/* returns the number of QA records */
if ((dimid = ncdimid (exoid, DIM_NUM_QA)) < 0)
*ret_int = 0; /* no QA records stored */
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of QA records in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_INFO:
/* returns the number of information records */
if ((dimid = ncdimid (exoid, DIM_NUM_INFO)) < 0)
*ret_int = 0; /* no information records stored */
else
{
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of info records in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
}
break;
case EX_INQ_TIME:
/* returns the number of time steps stored in the database; we find
* this out by inquiring the maximum record number of the "unlimited"
* dimension
*/
if ((dimid = ncdimid (exoid, DIM_TIME)) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate time dimension in file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get time dimension in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
break;
case EX_INQ_EB_PROP:
/* returns the number of element block properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_BLOCK);
break;
case EX_INQ_NS_PROP:
/* returns the number of node set properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_SET);
break;
case EX_INQ_SS_PROP:
/* returns the number of side set properties */
*ret_int = ex_get_num_props (exoid, EX_SIDE_SET);
break;
case EX_INQ_ELEM_MAP:
/* returns the number of element maps */
if ((dimid = ncdimid (exoid, DIM_NUM_EM)) == -1)
{
/* no element maps so return 0 */
*ret_int = 0;
return (EX_NOERR);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element maps for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
break;
case EX_INQ_EM_PROP:
/* returns the number of element map properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_MAP);
break;
case EX_INQ_NODE_MAP:
/* returns the number of node maps */
if ((dimid = ncdimid (exoid, DIM_NUM_NM)) == -1)
{
/* no node maps so return 0 */
*ret_int = 0;
return (EX_NOERR);
}
if (ncdiminq (exoid, dimid, (char *) 0, &ldum) == -1)
{
*ret_int = 0;
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node maps for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
*ret_int = ldum;
break;
case EX_INQ_NM_PROP:
/* returns the number of element map properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_MAP);
break;
case EX_INQ_EDGE:
/* returns the number of edges (defined across all edge blocks). */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_EDGE, 1);
break;
case EX_INQ_EDGE_BLK:
/* returns the number of edge blocks. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ED_BLK, 1);
break;
case EX_INQ_EDGE_SETS:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ES, 1);
break;
case EX_INQ_ES_LEN:
/* returns the length of the concatenated edge set edge list. */
EX_GET_CONCAT_SET_LEN(ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,DIM_NUM_EDGE_ES,0);
break;
case EX_INQ_ES_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,DIM_NUM_DF_ES,1);
break;
case EX_INQ_EDGE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_EDGE_BLOCK );
break;
case EX_INQ_ES_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_EDGE_SET );
break;
case EX_INQ_FACE:
/* returns the number of faces (defined across all face blocks). */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FACE, 1);
break;
case EX_INQ_FACE_BLK:
/* returns the number of edge blocks. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FA_BLK, 1);
break;
case EX_INQ_FACE_SETS:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FS, 1);
break;
case EX_INQ_FS_LEN:
/* returns the length of the concatenated edge set edge list. */
EX_GET_CONCAT_SET_LEN(ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,DIM_NUM_FACE_FS,0);
break;
case EX_INQ_FS_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,DIM_NUM_DF_FS,1);
break;
case EX_INQ_FACE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_FACE_BLOCK );
break;
case EX_INQ_FS_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_FACE_SET );
break;
case EX_INQ_ELEM_SETS:
/* returns the number of element sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ELS, 1);
break;
case EX_INQ_ELS_LEN:
/* returns the length of the concatenated element set element list. */
EX_GET_CONCAT_SET_LEN(ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,DIM_NUM_ELE_ELS,0);
break;
case EX_INQ_ELS_DF_LEN:
/* returns the length of the concatenated element set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,DIM_NUM_DF_ELS,1);
break;
case EX_INQ_ELS_PROP:
/* returns the number of integer properties stored for each element set. */
*ret_int = ex_get_num_props( exoid, EX_ELEM_SET );
break;
case EX_INQ_EDGE_MAP:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_EDM, 1);
break;
case EX_INQ_FACE_MAP:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FAM, 1);
break;
default:
*ret_int = 0;
exerrval = EX_FATAL;
sprintf(errmsg, "Error: invalid inquiry %d", req_info);
ex_err("ex_inquire",errmsg,exerrval);
return(EX_FATAL);
}
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_add_attr(int exoid, ex_entity_type obj_type, ex_entity_id obj_id, int64_t num_attr_per_entry)
{
int status;
int dims[2];
int strdim, varid, att_name_varid;
size_t num_obj;
char errmsg[MAX_ERR_LENGTH];
const char *dnumobjent;
const char *dnumobjatt;
const char *vobjatt;
const char *vattnam;
int numobjentdim;
int obj_id_ndx;
int numattrdim;
exerrval = 0; /* clear error code */
if (num_attr_per_entry <= 0) {
return (EX_NOERR);
}
/* Determine index of obj_id in obj_type id 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) {
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_add_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_add_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);
vobjatt = VAR_SSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_NSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_ESATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_FSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_ELSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
dnumobjent = DIM_NUM_NODES;
dnumobjatt = DIM_NUM_ATT_IN_NBLK;
vobjatt = VAR_NATTRIB;
vattnam = VAR_NAME_NATTRIB;
break;
case EX_EDGE_BLOCK:
dnumobjent = DIM_NUM_ED_IN_EBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
vobjatt = VAR_EATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_FATTRIB(obj_id_ndx);
vattnam = VAR_NAME_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);
vobjatt = VAR_ATTRIB(obj_id_ndx);
vattnam = VAR_NAME_ATTRIB(obj_id_ndx);
break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Bad block type (%d) specified for file id %d",
obj_type, exoid);
ex_err("ex_put_attr_param", errmsg, exerrval);
return (EX_FATAL);
}
/* element attribute array */
/* put netcdf file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to place file id %d into define mode", exoid);
ex_err("ex_add_attr", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_def_dim(exoid, dnumobjatt, num_attr_per_entry, &numattrdim)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define number of attributes in %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_add_attr", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
ex_get_dimension(exoid, dnumobjent, ex_name_of_object(obj_type), &num_obj, &numobjentdim,
"ex_add_attr");
dims[0] = numobjentdim;
dims[1] = numattrdim;
if ((status = nc_def_var(exoid, vobjatt, nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define attributes for %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_add_attr", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &strdim)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get string length in file id %d", exoid);
ex_err("ex_add_attr", errmsg, exerrval);
return (EX_FATAL);
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if ((status = nc_def_var(exoid, vattnam, NC_CHAR, 2, dims, &att_name_varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define %s attribute name array in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_add_attr", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
/* leave define mode */
if ((exerrval = nc_enddef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete %s definition in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_add_attr", errmsg, exerrval);
return (EX_FATAL);
}
/* Output a dummy empty attribute name in case client code doesn't
write anything; avoids corruption in some cases.
*/
if (att_name_varid >= 0) {
size_t count[2];
size_t start[2];
char * text = "";
size_t i;
count[0] = 1;
start[1] = 0;
count[1] = strlen(text) + 1;
for (i = 0; i < num_attr_per_entry; i++) {
start[0] = i;
nc_put_vara_text(exoid, att_name_varid, start, count, text);
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef(exoid) != NC_NOERR) { /* exit define mode */
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid);
ex_err("ex_add_attr", 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);
}
static int ex_inquire_internal (int exoid,
int req_info,
int64_t *ret_int,
float *ret_float,
char *ret_char)
{
int dimid, varid, tmp_num;
void_int *ids = NULL;
size_t i;
size_t ldum = 0;
size_t num_sets, idum;
int *stat_vals;
char errmsg[MAX_ERR_LENGTH];
int status;
char tmp_title[2048];
exerrval = 0; /* clear error code */
if (ret_char) *ret_char = '\0'; /* Only needs to be non-null for TITLE */
if (!ret_int) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: integer argument is NULL which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
switch (req_info) {
case EX_INQ_FILE_TYPE:
/* obsolete call */
/*returns "r" for regular EXODUS II file or "h" for history EXODUS file*/
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: file type inquire is obsolete");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_WARN);
case EX_INQ_API_VERS:
/* returns the EXODUS II API version number */
if (!ret_float) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: float argument is NULL for EX_INQ_API_VERS which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (nc_get_att_float(exoid, NC_GLOBAL, ATT_API_VERSION, ret_float) != NC_NOERR)
{ /* try old (prior to db version 2.02) attribute name */
if ((status = nc_get_att_float (exoid, NC_GLOBAL, ATT_API_VERSION_BLANK,ret_float)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get EXODUS API version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
break;
case EX_INQ_DB_VERS:
/* returns the EXODUS II database version number */
if (!ret_float) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: float argument is NULL for EX_INQ_DB_VERS which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_get_att_float (exoid, NC_GLOBAL, ATT_VERSION, ret_float)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get EXODUS database version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_LIB_VERS:
/* returns the EXODUS II Library version number */
if (ret_float)
flt_cvt(ret_float, EX_API_VERS);
*ret_int = EX_API_VERS_NODOT;
break;
case EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH:
/* Return the MAX_NAME_LENGTH size for this database
It will not include the space for the trailing null, so if it
is defined as 33 on the database, 32 will be returned.
*/
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &dimid)) != NC_NOERR) {
/* If not found, then an older database */
*ret_int = 32;
}
else {
/* Get the name string length */
size_t name_length = 0;
if ((status = nc_inq_dimlen(exoid,dimid,&name_length)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get name string length in file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
else {
*ret_int = name_length-1;
}
}
break;
case EX_INQ_DB_MAX_USED_NAME_LENGTH:
/* Return the value of the ATT_MAX_NAME_LENGTH attribute (if it
exists) which is the maximum length of any entity, variable,
attribute, property name written to this database. If the
attribute does not exist, then '32' is returned. The length
does not include the trailing null.
*/
{
nc_type att_type = NC_NAT;
size_t att_len = 0;
*ret_int = 32; /* Default size consistent with older databases */
status = nc_inq_att(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, &att_type, &att_len);
if (status == NC_NOERR && att_type == NC_INT) {
/* The attribute exists, return it... */
nc_get_att_longlong(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, (long long*)ret_int);
}
}
break;
case EX_INQ_MAX_READ_NAME_LENGTH:
{
/* Returns the user-specified maximum size of names that will be
* returned to the user by any of the ex_get_ routines. If the
* name is longer than this value, it will be truncated. The
* default if not set by the client is 32 characters. The value
* does not include the trailing null.
*/
struct file_item* file = ex_find_file_item(exoid);
if (!file ) {
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d for ex_inquire_int().",exoid);
ex_err("ex_intquire",errmsg,exerrval);
*ret_int = 0;
}
else {
*ret_int = file->maximum_name_length;
}
}
break;
case EX_INQ_TITLE:
if (!ret_char) {
sprintf(errmsg,
"Error: Requested title, but character pointer was null for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
} else {
/* returns the title of the database */
if ((status = nc_get_att_text (exoid, NC_GLOBAL, ATT_TITLE, tmp_title)) != NC_NOERR) {
*ret_char = '\0';
exerrval = status;
sprintf(errmsg,
"Error: failed to get database title for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
} else {
strncpy(ret_char, tmp_title, MAX_LINE_LENGTH+1);
ret_char[MAX_LINE_LENGTH] = '\0';
}
}
break;
case EX_INQ_DIM:
/* returns the dimensionality (2 or 3, for 2-d or 3-d) of the database */
if (ex_get_dimension(exoid, DIM_NUM_DIM, "database dimensionality", &ldum, &dimid, "ex_inquire") != NC_NOERR)
return EX_FATAL;
*ret_int = ldum;
break;
case EX_INQ_NODES:
/* returns the number of nodes */
if (ex_get_dimension(exoid, DIM_NUM_NODES, "nodes", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_ELEM:
/* returns the number of elements */
if (ex_get_dimension(exoid, DIM_NUM_ELEM, "elements", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_ELEM_BLK:
/* returns the number of element blocks */
if (ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element blocks", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NODE_SETS:
/* returns the number of node sets */
if (ex_get_dimension(exoid, DIM_NUM_NS, "node sets", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NS_NODE_LEN:
/* returns the length of the concatenated node sets node list */
ex_get_concat_set_len(exoid, ret_int,"node",EX_NODE_SET,DIM_NUM_NS,VAR_NS_STAT,"num_nod_ns",0);
break;
case EX_INQ_NS_DF_LEN:
/* returns the length of the concatenated node sets dist factor list */
/*
Determine the concatenated node sets distribution factor length:
2. Check see if the dist factor variable for a node set id exists.
3. If it exists, goto step 4, else the length is zero.
4. Get the dimension of the number of nodes in the node set -0
use this value as the length as by definition they are the same.
5. Sum the individual lengths for the total list length.
*/
*ret_int = 0; /* default value if no node sets defined */
if (nc_inq_dimid (exoid, DIM_NUM_NS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++) {
if ((status = nc_inq_varid (exoid, VAR_FACT_NS(i+1), &varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) {
idum = 0; /* this dist factor doesn't exist */
} else {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist fact for %"ST_ZU"'th node set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimid (exoid, DIM_NUM_NOD_NS(i+1), &dimid)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in %"ST_ZU"'th node set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen (exoid, dimid, &idum)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in %"ST_ZU"'th node set in file id %d",
i,exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
*ret_int += idum;
}
}
break;
case EX_INQ_SIDE_SETS:
/* returns the number of side sets */
if (ex_get_dimension(exoid, DIM_NUM_SS, "side sets", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_SS_NODE_LEN:
/* returns the length of the concatenated side sets node list */
*ret_int = 0; /* default return value */
if (nc_inq_dimid (exoid, DIM_NUM_SS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int64_t)))) { /* May be getting 2x what is needed, but should be OK */
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL) {
sprintf(errmsg,
"Error: failed to get side set ids in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
free (ids);
sprintf(errmsg,
"Error: failed to allocate memory for side set status array for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((status = nc_inq_varid (exoid, VAR_SS_STAT, &varid)) == NC_NOERR) {
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free (ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get element block status array from file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
/* walk id list, get each side set node length and sum for total */
for (i=0; i<num_sets; i++) {
ex_entity_id id;
if (stat_vals[i] == 0) /* is this object null? */
continue;
if (ex_int64_status(exoid) & EX_IDS_INT64_API)
id = ((int64_t*)ids)[i];
else
id = ((int*)ids)[i];
if ((status = ex_get_side_set_node_list_len(exoid, id, &tmp_num)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to side set %"PRId64" node length in file id %d",
id,exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(stat_vals);
free(ids);
return (EX_FATAL);
}
*ret_int += tmp_num;
}
free(stat_vals);
free (ids);
}
break;
case EX_INQ_SS_ELEM_LEN:
/* returns the length of the concatenated side sets element list */
ex_get_concat_set_len(exoid, ret_int,"side",EX_SIDE_SET,DIM_NUM_SS,VAR_SS_STAT,"num_side_ss",0);
break;
case EX_INQ_SS_DF_LEN:
/* returns the length of the concatenated side sets dist factor list */
/*
Determine the concatenated side sets distribution factor length:
1. Get the side set ids list.
2. Check see if the dist factor dimension for a side set id exists.
3. If it exists, goto step 4, else set the individual length to zero.
4. Sum the dimension value into the running total length.
*/
*ret_int = 0;
/* first check see if any side sets exist */
if (nc_inq_dimid (exoid, DIM_NUM_SS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen (exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++) {
if ((status = nc_inq_dimid (exoid, DIM_NUM_DF_SS(i+1), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
ldum = 0; /* this dist factor doesn't exist */
} else {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist fact for %"ST_ZU"'th side set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &ldum)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of dist factors in %"ST_ZU"'th side set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
*ret_int += ldum;
}
}
break;
case EX_INQ_QA:
/* returns the number of QA records */
if (ex_get_dimension(exoid, DIM_NUM_QA, "QA records", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_INFO:
/* returns the number of information records */
if (ex_get_dimension(exoid, DIM_NUM_INFO, "info records", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_TIME:
/* returns the number of time steps stored in the database */
if (ex_get_dimension(exoid, DIM_TIME, "time dimension", &ldum, &dimid, "ex_inquire") != NC_NOERR)
return EX_FATAL;
*ret_int = ldum;
break;
case EX_INQ_EB_PROP:
/* returns the number of element block properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_BLOCK);
break;
case EX_INQ_NS_PROP:
/* returns the number of node set properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_SET);
break;
case EX_INQ_SS_PROP:
/* returns the number of side set properties */
*ret_int = ex_get_num_props (exoid, EX_SIDE_SET);
break;
case EX_INQ_ELEM_MAP:
/* returns the number of element maps */
if (ex_get_dimension(exoid, DIM_NUM_EM, "element maps", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_EM_PROP:
/* returns the number of element map properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_MAP);
break;
case EX_INQ_NODE_MAP:
/* returns the number of node maps */
if (ex_get_dimension(exoid, DIM_NUM_NM, "node maps", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NM_PROP:
/* returns the number of node map properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_MAP);
break;
case EX_INQ_EDGE:
/* returns the number of edges (defined across all edge blocks). */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_EDGE, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_EDGE_BLK:
/* returns the number of edge blocks. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ED_BLK, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_EDGE_SETS:
/* returns the number of edge sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ES, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_ES_LEN:
/* returns the length of the concatenated edge set edge list. */
ex_get_concat_set_len(exoid, ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,"num_edge_es",0);
break;
case EX_INQ_ES_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,"num_df_es",1);
break;
case EX_INQ_EDGE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_EDGE_BLOCK );
break;
case EX_INQ_ES_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_EDGE_SET );
break;
case EX_INQ_FACE:
/* returns the number of faces (defined across all face blocks). */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FACE, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_BLK:
/* returns the number of face blocks. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FA_BLK, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_SETS:
/* returns the number of face sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FS, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FS_LEN:
/* returns the length of the concatenated edge set edge list. */
ex_get_concat_set_len(exoid, ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,"num_face_fs",0);
break;
case EX_INQ_FS_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,"num_df_fs",1);
break;
case EX_INQ_FACE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_FACE_BLOCK );
break;
case EX_INQ_FS_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_FACE_SET );
break;
case EX_INQ_ELEM_SETS:
/* returns the number of element sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ELS, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_ELS_LEN:
/* returns the length of the concatenated element set element list. */
ex_get_concat_set_len(exoid, ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,"num_ele_els",0);
break;
case EX_INQ_ELS_DF_LEN:
/* returns the length of the concatenated element set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,"num_df_els",1);
break;
case EX_INQ_ELS_PROP:
/* returns the number of integer properties stored for each element set. */
*ret_int = ex_get_num_props( exoid, EX_ELEM_SET );
break;
case EX_INQ_EDGE_MAP:
/* returns the number of edge maps. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_EDM, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_MAP:
/* returns the number of face maps. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FAM, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_COORD_FRAMES:
/* return the number of coordinate frames */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_CFRAMES, 1) != EX_NOERR) return EX_FATAL;
break;
default:
*ret_int = 0;
exerrval = EX_FATAL;
sprintf(errmsg, "Error: invalid inquiry %d", req_info);
ex_err("ex_inquire",errmsg,exerrval);
return(EX_FATAL);
}
return (EX_NOERR);
}
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_node_set (int exoid,
int node_set_id,
const int *node_set_node_list)
{
int dimid, node_list_id, node_set_id_ndx, iresult;
long num_nodes_in_set, start[1], count[1];
nclong *lptr;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any node sets are specified */
if ((dimid = ncdimid (exoid, DIM_NUM_NS)) < 0)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no node sets specified in file id %d",
exoid);
ex_err("ex_put_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* Lookup index of node set id in VAR_NS_IDS array */
node_set_id_ndx = ex_id_lkup(exoid,VAR_NS_IDS,node_set_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no data allowed for NULL node set %d in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
sprintf(errmsg,
"Error: failed to locate node set id %d in VAR_NS_IDS array in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire id's of previously defined dimensions */
if ((dimid = ncdimid (exoid, DIM_NUM_NOD_NS(node_set_id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes in set %d in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_nodes_in_set) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of nodes in set %d in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* inquire if variable for node set node list has been defined */
if ((node_list_id = ncvarid (exoid, VAR_NODE_NS(node_set_id_ndx))) == -1)
{
/* variable doesn't exist */
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate node set %d node list in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* write out the node list array */
/* this contortion is necessary because netCDF is expecting nclongs; fortunately
it's necessary only when ints and nclongs aren't the same size */
start[0] = 0;
count[0] = num_nodes_in_set;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarput(exoid, node_list_id, start, count, node_set_node_list);
} else {
lptr = itol (node_set_node_list, (int)num_nodes_in_set);
iresult = ncvarput (exoid, node_list_id, start, count, lptr);
free(lptr);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store node set %d node list in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
