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_partial_set_dist_fact (int exoid,
ex_entity_type set_type,
ex_entity_id set_id,
int64_t offset,
int64_t num_to_put,
const void *set_dist_fact)
{
int status;
int dimid, set_id_ndx;
int dist_id;
size_t start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
char* factptr = NULL;
exerrval = 0; /* clear error code */
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss specified in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
/* Lookup index of set id in VAR_*S_IDS array */
set_id_ndx = ex_id_lkup(exoid,set_type,set_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no data allowed for NULL %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_fact",errmsg,EX_NULLENTITY);
return (EX_WARN);
} else {
sprintf(errmsg,
"Error: failed to locate %s id %"PRId64" in VAR_*S_IDS array in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* find id of distribution factors variable
*/
if ((status = nc_inq_varid(exoid, factptr, &dist_id)) != NC_NOERR) {
/* this test is only needed for node set because we're using
DIM_NUM_NOD_NS instead of DIM_NUM_DF_NS*/
if (status == NC_ENOTVAR) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: no dist factors defined for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set_dist_fact",errmsg,exerrval);
return (EX_WARN);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate dist factors list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
start[0] = offset-1;
count[0] = num_to_put;
if (num_to_put == 0)
start[0] = 0;
/* write out the distribution factors array */
if (ex_comp_ws(exoid) == 4) {
status = nc_put_vara_float(exoid, dist_id, start, count, set_dist_fact);
} else {
status = nc_put_vara_double(exoid, dist_id, start, count, set_dist_fact);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store dist factors for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_partial_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_put_sets (int exoid,
size_t set_count,
const struct ex_set *sets)
{
size_t i;
int needs_define = 0;
int set_stat;
int dimid, varid, status, dims[1];
int set_id_ndx;
size_t start[1];
int cur_num_sets;
char errmsg[MAX_ERR_LENGTH];
int* sets_to_define = NULL;
char* numentryptr = NULL;
char* entryptr = NULL;
char* extraptr = NULL;
char* idsptr = NULL;
char* statptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
size_t int_size;
exerrval = 0; /* clear error code */
sets_to_define = malloc(set_count*sizeof(int));
/* Note that this routine can be called:
1) just define the sets
2) just output the set data (after a previous call to define)
3) define and output the set data in one call.
*/
for (i=0; i < set_count; i++) {
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(sets[i].type), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss defined for file id %d", ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
set_id_ndx = ex_id_lkup(exoid, sets[i].type, sets[i].id);
if (exerrval != EX_LOOKUPFAIL) { /* found the side set id, so set is already defined... */
sets_to_define[i] = 0;
continue;
} else {
needs_define++;
sets_to_define[i] = 1;
}
}
if (needs_define > 0) {
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i < set_count; i++) {
if (sets_to_define[i] == 0)
continue;
/* NOTE: ex_inc_file_item finds the current number of sets defined
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(sets[i].type));
set_id_ndx = cur_num_sets + 1;
sets_to_define[i] = set_id_ndx;
if (sets[i].num_entry == 0)
continue;
/* setup pointers based on set_type */
if (sets[i].type == EX_NODE_SET) {
numentryptr = DIM_NUM_NOD_NS(set_id_ndx);
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (sets[i].type == EX_EDGE_SET) {
numentryptr = DIM_NUM_EDGE_ES(set_id_ndx);
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (sets[i].type == EX_FACE_SET) {
numentryptr = DIM_NUM_FACE_FS(set_id_ndx);
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (sets[i].type == EX_SIDE_SET) {
numentryptr = DIM_NUM_SIDE_SS(set_id_ndx);
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
else if (sets[i].type == EX_ELEM_SET) {
numentryptr = DIM_NUM_ELE_ELS(set_id_ndx);
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* define dimensions and variables */
if ((status = nc_def_dim(exoid, numentryptr,
sets[i].num_entry, &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: %s %"PRId64" -- size already defined in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
else {
sprintf(errmsg,
"Error: failed to define number of entries in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret;
}
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
int_size = sizeof(int64_t);
}
/* create variable array in which to store the entry lists */
dims[0] = dimid;
if ((status = nc_def_var(exoid, entryptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: entry list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create entry list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
if (extraptr) {
if ((status = nc_def_var(exoid, extraptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: extra list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create extra list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
}
/* Create distribution factors variable if required */
if (sets[i].num_distribution_factor > 0) {
if (sets[i].type != EX_SIDE_SET) {
/* but sets[i].num_distribution_factor must equal number of nodes */
if (sets[i].num_distribution_factor != sets[i].num_entry) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%"PRId64") not equal to # nodes (%"PRId64") in node set %"PRId64" file id %d",
sets[i].num_distribution_factor, sets[i].num_entry, sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* resuse dimid from entry lists */
if ((status = nc_def_dim(exoid, numdfptr,
sets[i].num_distribution_factor, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of dist factors in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* create variable array in which to store the set distribution factors
*/
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: dist factors list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create dist factors list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d", exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* Output the set ids and status... */
for (i=0; i < set_count; i++) {
/* setup pointers based on sets[i].type */
if (sets[i].type == EX_NODE_SET) {
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (sets[i].type == EX_EDGE_SET) {
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (sets[i].type == EX_FACE_SET) {
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (sets[i].type == EX_SIDE_SET) {
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (sets[i].type == EX_ELEM_SET) {
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
/* first: get id of set id variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* write out set id */
start[0] = sets_to_define[i]-1;
status = nc_put_var1_longlong(exoid, varid, start, (long long*)&sets[i].id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
set_stat = (sets[i].num_entry == 0) ? 0 : 1;
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d", ex_name_of_object(sets[i].type),
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &set_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s %"PRId64" status to file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
}
free(sets_to_define);
}
/* Sets are now all defined; see if any set data needs to be output... */
status = EX_NOERR;
for (i=0; i < set_count; i++) {
int stat;
if (sets[i].entry_list != NULL || sets[i].extra_list != NULL) {
/* NOTE: ex_put_set will write the warning/error message... */
stat = ex_put_set(exoid, sets[i].type, sets[i].id, sets[i].entry_list, sets[i].extra_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
if (sets[i].distribution_factor_list != NULL) {
/* NOTE: ex_put_set_dist_fact will write the warning/error message... */
stat = ex_put_set_dist_fact(exoid, sets[i].type, sets[i].id, sets[i].distribution_factor_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
}
return (status);
/* Fatal error: exit definition mode and return */
error_ret:
free(sets_to_define);
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_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_get_set_dist_fact (int exoid,
ex_entity_type set_type,
ex_entity_id set_id,
void *set_dist_fact)
{
int dimid, dist_id, set_id_ndx;
int status;
char errmsg[MAX_ERR_LENGTH];
char* factptr = NULL;
exerrval = 0; /* clear error code */
/* first check if any sets are specified */
if ((status = nc_inq_dimid (exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no %s sets stored in file id %d",
ex_name_of_object(set_type), 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,set_type,set_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: %s set %"PRId64" is NULL in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,EX_NULLENTITY);
return (EX_WARN);
} else {
sprintf(errmsg,
"Error: failed to locate %s set %"PRId64" in VAR_*S_IDS array in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, factptr, &dist_id)) != NC_NOERR) {
exerrval = status;
/* not an error for node sets because this is how we check that df's exist */
if (set_type == EX_NODE_SET) {
sprintf(errmsg,
"Warning: dist factors not stored for %s set %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_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 %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
/* read in the distribution factors array */
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, dist_id, set_dist_fact);
} else {
status = nc_get_var_double(exoid, dist_id, set_dist_fact);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get dist factors list for %s set %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
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_partial_set_dist_fact(int exoid, ex_entity_type set_type, ex_entity_id set_id,
int64_t offset, int64_t num_to_put, void *set_dist_fact)
{
int dimid, dist_id, set_id_ndx;
int status;
size_t start[1], count[1];
char errmsg[MAX_ERR_LENGTH];
char * factptr = NULL;
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no %s sets stored in file id %d",
ex_name_of_object(set_type), exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_WARN);
}
/* Lookup index of set id in VAR_*S_IDS array */
set_id_ndx = ex_id_lkup(exoid, set_type, set_id);
if (set_id_ndx <= 0) {
ex_get_err(NULL, NULL, &status);
if (status != 0) {
if (status == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: %s set %" PRId64 " is NULL in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, EX_NULLENTITY);
EX_FUNC_LEAVE(EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s set %" PRId64 " in VAR_*S_IDS array in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, factptr, &dist_id)) != NC_NOERR) {
/* not an error for node sets because this is how we check that df's exist
*/
if (set_type == EX_NODE_SET) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: dist factors not stored for %s set %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_WARN); /* complain - but not too loud */
}
/* is an error for other sets */
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate dist factors list for %s set %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* read in the distribution factors array */
start[0] = offset - 1;
count[0] = num_to_put;
if (count[0] == 0) {
start[0] = 0;
}
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, dist_id, start, count, set_dist_fact);
}
else {
status = nc_get_vara_double(exoid, dist_id, start, count, set_dist_fact);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get dist factors list for %s set %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}