int ex_get_truth_table (int exoid,
ex_entity_type obj_type,
int num_blk,
int num_var,
int *var_tab)
{
int dimid, varid, tabid, i, j, status, status1;
size_t num_entity = 0;
size_t num_var_db = 0;
char errmsg[MAX_ERR_LENGTH];
const char* routine = "ex_get_truth_table";
/*
* The ent_type and the var_name are used to build the netcdf
* variables name. Normally this is done via a macro defined in
* exodusII_int.h
*/
const char* ent_type = NULL;
const char* var_name = NULL;
exerrval = 0; /* clear error code */
switch (obj_type) {
case EX_EDGE_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_EDG_VAR, "edge variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_EBLK_TAB, &tabid);
var_name = "vals_edge_var";
ent_type = "eb";
break;
case EX_FACE_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_FAC_VAR, "face variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_FBLK_TAB, &tabid);
var_name = "vals_face_var";
ent_type = "fb";
break;
case EX_ELEM_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_ELE_VAR, "element variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_ELEM_TAB, &tabid);
var_name = "vals_elem_var";
ent_type = "eb";
break;
case EX_NODE_SET:
status = ex_get_dimension(exoid, DIM_NUM_NSET_VAR, "nodeset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_NSET_TAB, &tabid);
var_name = "vals_nset_var";
ent_type = "ns";
break;
case EX_EDGE_SET:
status = ex_get_dimension(exoid, DIM_NUM_ESET_VAR, "edgeset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_ESET_TAB, &tabid);
var_name = "vals_eset_var";
ent_type = "es";
break;
case EX_FACE_SET:
status = ex_get_dimension(exoid, DIM_NUM_FSET_VAR, "faceset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_FSET_TAB, &tabid);
var_name = "vals_fset_var";
ent_type = "fs";
break;
case EX_SIDE_SET:
status = ex_get_dimension(exoid, DIM_NUM_SSET_VAR, "sideset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_SSET_TAB, &tabid);
var_name = "vals_sset_var";
ent_type = "ss";
break;
case EX_ELEM_SET:
status = ex_get_dimension(exoid, DIM_NUM_ELSET_VAR, "elemset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_ELSET_TAB, &tabid);
var_name = "vals_elset_var";
ent_type = "es";
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %d specified in file id %d",
obj_type, exoid);
ex_err(routine,errmsg,exerrval);
return (EX_WARN);
}
if (status != NC_NOERR) {
exerrval = status;
return (EX_WARN);
}
status = ex_get_dimension(exoid, ex_dim_num_objects(obj_type),
ex_name_of_object(obj_type), &num_entity, &dimid, routine);
if (status != NC_NOERR) {
exerrval = status;
return (EX_FATAL);
}
if (num_entity != (size_t)num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of %s doesn't match those defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
if (num_var_db != (size_t)num_var) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of %s variables doesn't match those defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
if (status1 != NC_NOERR) {
/* since truth table isn't stored in the data file, derive it dynamically */
for (j=0; j<num_blk; j++) {
for (i=0; i<num_var; i++) {
/* NOTE: names are 1-based */
if (nc_inq_varid (exoid, ex_catstr2(var_name, i+1, ent_type, j+1), &tabid) == NC_NOERR) {
/* variable exists; put a 1 in the truth table */
var_tab[j*num_var+i] = 1;
} else {
/* variable doesn't exist; put a 0 in the truth table */
var_tab[j*num_var+i] = 0;
}
}
}
} else {
/* read in the truth table */
status = nc_get_var_int(exoid, tabid, var_tab);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s truth table from file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
}
int ex_put_truth_table (int exoid,
ex_entity_type obj_type,
int num_blk,
int num_var,
int *var_tab)
{
int numelblkdim, numelvardim, timedim, dims[2], varid;
char *sta_type, *tab_type;
size_t num_entity = 0;
size_t num_var_db = 0;
int *stat_vals;
int i, j, k;
int status;
char errmsg[MAX_ERR_LENGTH];
const char* routine = "ex_put_truth_table";
/*
* The ent_type and the var_name are used to build the netcdf
* variables name. Normally this is done via a macro defined in
* exodusII_int.h
*/
const char* ent_type = NULL;
const char* var_name = NULL;
const char* ent_size = NULL;
exerrval = 0; /* clear error code */
ex_get_dimension(exoid, ex_dim_num_objects(obj_type),
ex_name_of_object(obj_type), &num_entity, &numelblkdim, routine);
if (obj_type == EX_ELEM_BLOCK) {
ex_get_dimension(exoid, DIM_NUM_ELE_VAR, "element variables",
&num_var_db, &numelvardim, routine);
var_name = "vals_elem_var";
ent_type = "eb";
ent_size = "num_el_in_blk";
sta_type = VAR_STAT_EL_BLK;
tab_type = VAR_ELEM_TAB;
}
else if (obj_type == EX_EDGE_BLOCK) {
ex_get_dimension(exoid, DIM_NUM_EDG_VAR, "edge block variables",
&num_var_db, &numelvardim, routine);
var_name = "vals_edge_var";
ent_type = "eb";
ent_size = "num_ed_in_blk";
sta_type = VAR_STAT_ED_BLK;
tab_type = VAR_EBLK_TAB;
}
else if (obj_type == EX_FACE_BLOCK) {
ex_get_dimension(exoid, DIM_NUM_FAC_VAR, "face block variables",
&num_var_db, &numelvardim, routine);
var_name = "vals_face_var";
ent_type = "fb";
ent_size = "num_fa_in_blk";
sta_type = VAR_STAT_FA_BLK;
tab_type = VAR_FBLK_TAB;
}
else if (obj_type == EX_SIDE_SET) {
ex_get_dimension(exoid, DIM_NUM_SSET_VAR, "sideset variables",
&num_var_db, &numelvardim, routine);
var_name = "vals_sset_var";
ent_type = "ss";
ent_size = "num_side_ss";
sta_type = VAR_SS_STAT;
tab_type = VAR_SSET_TAB;
}
else if (obj_type == EX_NODE_SET) {
ex_get_dimension(exoid, DIM_NUM_NSET_VAR, "nodeset variables",
&num_var_db, &numelvardim, routine);
var_name = "vals_nset_var";
ent_type = "ns";
ent_size = "num_nod_ns";
sta_type = VAR_NS_STAT;
tab_type = VAR_NSET_TAB;
}
else if (obj_type == EX_EDGE_SET) {
ex_get_dimension(exoid, DIM_NUM_ESET_VAR, "edge set variables",
&num_var_db, &numelvardim, routine);
var_name = "vals_eset_var";
ent_type = "es";
ent_size = "num_edge_es";
sta_type = VAR_ES_STAT;
tab_type = VAR_ESET_TAB;
}
else if (obj_type == EX_FACE_SET) {
ex_get_dimension(exoid, DIM_NUM_FSET_VAR, "face set variables",
&num_var_db, &numelvardim, routine);
var_name = "vals_fset_var";
ent_type = "fs";
ent_size = "num_face_fs";
sta_type = VAR_FS_STAT;
tab_type = VAR_FSET_TAB;
}
else if (obj_type == EX_ELEM_SET) {
ex_get_dimension(exoid, DIM_NUM_ELSET_VAR, "element set variables",
&num_var_db, &numelvardim, routine);
var_name = "vals_elset_var";
ent_type = "es";
ent_size = "num_ele_els";
sta_type = VAR_ELS_STAT;
tab_type = VAR_ELSET_TAB;
}
else { /* invalid variable type */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %d specified in file id %d",
obj_type, exoid);
ex_err("ex_get_varid",errmsg,exerrval);
return (EX_WARN);
}
if ((int)num_entity != num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of %s doesn't match those defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
if ((int)num_var_db != num_var) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of %s variables doesn't match those defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
/* Get status array for later use */
if (!(stat_vals = malloc(num_blk*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s status array for file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
status = nc_inq_varid (exoid, sta_type, &varid);
/* get variable id of status array */
if (status == NC_NOERR) {
/* if status array exists (V 2.01+), 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(stat_vals);
sprintf(errmsg,
"Error: failed to get %s status array from file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("put_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
} else {
/* status array doesn't exist (V2.00), dummy one up for later checking */
for(i=0;i<num_blk;i++)
stat_vals[i] = 1;
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
free(stat_vals);
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid (exoid, DIM_TIME, &timedim)) != NC_NOERR) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to locate time variable in file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* define netCDF variables in which to store EXODUS II element
* variable values
*/
k = 0;
for (i=0; i<num_blk; i++) {
for (j=1; j<=num_var; j++) {
/* check if variables are to be put out for this entity */
if (var_tab[k] != 0) {
if (stat_vals[i] != 0) {/* check for NULL entity */
/* NOTE: This code used to zero out the var_tab entry
if the stat_vals[i] value was zero. However, in some
cases it is good to know that a variable was assigned to
an entity even if that entity is empty. The code was
changed to not modify the truth table.
*/
dims[0] = timedim;
/* Determine number of entities in block */
if ((status = nc_inq_dimid(exoid, ex_catstr(ent_size, (i+1)), &dims[1])) != NC_NOERR) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to locate number of entities in %d'th %s in file id %d",
i+1, ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* 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 ((status = nc_def_var(exoid, ex_catstr2(var_name, j, ent_type, i+1),
nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
if (status != NC_ENAMEINUSE) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to define variable for %d'th %s in file id %d",
i+1, ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
} /* if */
k++; /* increment element truth table pointer */
} /* for j */
} /* for i */
free (stat_vals);
/* create a variable array in which to store the truth table
*/
dims[0] = numelblkdim;
dims[1] = numelvardim;
status = nc_def_var (exoid, tab_type, NC_INT, 2, dims, &varid);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s variable truth table in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,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 definitions in file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
/* write out the element variable truth table */
status = nc_put_var_int(exoid, varid, var_tab);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store variable truth table in file id %d",
exoid);
ex_err(routine,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(routine,errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_var_tab (int exoid,
const char *var_type,
int num_blk,
int num_var,
int *var_tab)
{
int dimid, varid, tabid, i, j, iresult;
long num_entity = -1;
long num_var_db = -1;
long start[2], count[2];
nclong *longs;
char errmsg[MAX_ERR_LENGTH];
const char* routine = "ex_get_var_tab";
/*
* The ent_type and the var_name are used to build the netcdf
* variables name. Normally this is done via a macro defined in
* exodusII_int.h
*/
const char* ent_type = NULL;
const char* var_name = NULL;
exerrval = 0; /* clear error code */
if (*var_type == 'e' || *var_type == 'E') {
dimid = ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element", &num_entity, routine);
varid = ex_get_dimension(exoid, DIM_NUM_ELE_VAR, "element variables", &num_var_db, routine);
tabid = ncvarid (exoid, VAR_ELEM_TAB);
var_name = "vals_elem_var";
ent_type = "eb";
}
else if (*var_type == 'm' || *var_type == 'M') {
dimid = ex_get_dimension(exoid, DIM_NUM_NS, "nodeset", &num_entity, routine);
varid = ex_get_dimension(exoid, DIM_NUM_NSET_VAR, "nodeset variables", &num_var_db, routine);
tabid = ncvarid (exoid, VAR_NSET_TAB);
var_name = "vals_nset_var";
ent_type = "ns";
}
else if (*var_type == 's' || *var_type == 'S') {
dimid = ex_get_dimension(exoid, DIM_NUM_SS, "sideset", &num_entity, routine);
varid = ex_get_dimension(exoid, DIM_NUM_SSET_VAR, "sideset variables", &num_var_db, routine);
tabid = ncvarid (exoid, VAR_SSET_TAB);
var_name = "vals_sset_var";
ent_type = "ss";
}
else { /* invalid variable type */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %c specified in file id %d",
*var_type, exoid);
ex_err("ex_get_varid",errmsg,exerrval);
return (EX_WARN);
}
if (dimid == -1) {
exerrval = ncerr;
return (EX_FATAL);
}
if (varid == -1) {
exerrval = ncerr;
return (EX_WARN);
}
if (num_entity != num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of blocks doesn't match those defined in file id %d", exoid);
ex_err("ex_get_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
if (num_var_db != num_var) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of variables doesn't match those defined in file id %d", exoid);
ex_err("ex_get_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
if (tabid == -1) {
/* since truth table isn't stored in the data file, derive it dynamically */
for (j=0; j<num_blk; j++) {
for (i=0; i<num_var; i++) {
/* NOTE: names are 1-based */
if ((tabid = ncvarid (exoid, ex_catstr2(var_name, i+1, ent_type, j+1))) == -1) {
/* variable doesn't exist; put a 0 in the truth table */
var_tab[j*num_var+i] = 0;
} else {
/* variable exists; put a 1 in the truth table */
var_tab[j*num_var+i] = 1;
}
}
}
} else {
/* read in the truth table */
/*
* 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;
start[1] = 0;
count[0] = num_blk;
count[1] = num_var;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarget (exoid, tabid, start, count, var_tab);
} else {
if (!(longs = static_cast<nclong*>(malloc (num_blk*num_var * sizeof(nclong))))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for truth table for file id %d",
exoid);
ex_err("ex_get_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
iresult = ncvarget (exoid, tabid, start, count, longs);
}
if (iresult == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get truth table from file id %d", exoid);
ex_err("ex_get_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
if (sizeof(int) != sizeof(nclong)) {
ltoi (longs, var_tab, num_blk*num_var);
free (longs);
}
}
return (EX_NOERR);
}
int ex_get_object_truth_vector (int exoid,
const char *obj_type,
int entity_id,
int num_var,
int *var_vec)
{
int varid, tabid, i, iresult, ent_ndx;
long num_var_db = -1;
long start[2], count[2];
nclong *longs;
char errmsg[MAX_ERR_LENGTH];
const char* routine = "ex_get_object_truth_vector";
/*
* The ent_type and the var_name are used to build the netcdf
* variables name. Normally this is done via a macro defined in
* exodusII_int.h
*/
const char* ent_type = NULL;
const char* var_name = NULL;
exerrval = 0; /* clear error code */
if (*obj_type == 'e' || *obj_type == 'E') {
varid = ex_get_dimension(exoid, DIM_NUM_ELE_VAR, "element variables", &num_var_db, routine);
tabid = ncvarid (exoid, VAR_ELEM_TAB);
var_name = "vals_elem_var";
ent_ndx = ex_id_lkup(exoid, VAR_ID_EL_BLK, entity_id);
ent_type = "eb";
}
else if (*obj_type == 'm' || *obj_type == 'M') {
varid = ex_get_dimension(exoid, DIM_NUM_NSET_VAR, "nodeset variables", &num_var_db, routine);
tabid = ncvarid (exoid, VAR_NSET_TAB);
var_name = "vals_nset_var";
ent_ndx = ex_id_lkup(exoid, VAR_NS_IDS, entity_id);
ent_type = "ns";
}
else if (*obj_type == 's' || *obj_type == 'S') {
varid = ex_get_dimension(exoid, DIM_NUM_SSET_VAR, "sideset variables", &num_var_db, routine);
tabid = ncvarid (exoid, VAR_SSET_TAB);
var_name = "vals_sset_var";
ent_ndx = ex_id_lkup(exoid, VAR_SS_IDS, entity_id);
ent_type = "ss";
}
else { /* invalid variable type */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %c specified in file id %d",
*obj_type, exoid);
ex_err("ex_get_varid",errmsg,exerrval);
return (EX_WARN);
}
if (varid == -1) {
exerrval = ncerr;
return (EX_WARN);
}
if (num_var_db != num_var) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of variables doesn't match those defined in file id %d", exoid);
ex_err("ex_get_object_truth_vector",errmsg,exerrval);
return (EX_FATAL);
}
if (tabid == -1) {
/* since truth vector isn't stored in the data file, derive it dynamically */
for (i=0; i<num_var; i++) {
/* NOTE: names are 1-based */
if ((tabid = ncvarid (exoid, ex_catstr2(var_name, i+1, ent_type, ent_ndx))) == -1) {
/* variable doesn't exist; put a 0 in the truth vector */
var_vec[i] = 0;
} else {
/* variable exists; put a 1 in the truth vector */
var_vec[i] = 1;
}
}
} else {
/* read in the truth vector */
/*
* 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
*/
/* If this is a null entity, then 'ent_ndx' will be negative.
* We don't care in this routine, so make it positive and continue...
*/
if (ent_ndx < 0) ent_ndx = -ent_ndx;
start[0] = ent_ndx-1;
start[1] = 0;
count[0] = 1;
count[1] = num_var;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarget (exoid, tabid, start, count, var_vec);
} else {
if (!(longs = malloc (num_var * sizeof(nclong)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for truth vector for file id %d",
exoid);
ex_err("ex_get_object_truth_vector",errmsg,exerrval);
return (EX_FATAL);
}
iresult = ncvarget (exoid, tabid, start, count, longs);
}
if (iresult == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get truth vector from file id %d", exoid);
ex_err("ex_get_object_truth_vector",errmsg,exerrval);
return (EX_FATAL);
}
if (sizeof(int) != sizeof(nclong)) {
ltoi (longs, var_vec, num_var);
free (longs);
}
}
return (EX_NOERR);
}
int ex_get_object_truth_vector (int exoid,
ex_entity_type obj_type,
ex_entity_id entity_id,
int num_var,
int *var_vec)
{
int statust;
int varid, tabid, i, status, ent_ndx;
size_t num_var_db = 0;
size_t start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
const char* routine = "ex_get_object_truth_vector";
/*
* The ent_type and the var_name are used to build the netcdf
* variables name. Normally this is done via a macro defined in
* exodusII_int.h
*/
const char* ent_type = NULL;
const char* var_name = NULL;
exerrval = 0; /* clear error code */
switch (obj_type) {
case EX_EDGE_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_EDG_VAR, "edge variables", &num_var_db, &varid, routine);
statust = nc_inq_varid(exoid, VAR_EBLK_TAB, &tabid);
var_name = "vals_edge_var";
ent_type = "eb";
break;
case EX_FACE_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_FAC_VAR, "face variables", &num_var_db, &varid, routine);
statust = nc_inq_varid (exoid, VAR_FBLK_TAB, &tabid);
var_name = "vals_face_var";
ent_type = "fb";
break;
case EX_ELEM_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_ELE_VAR, "element variables", &num_var_db, &varid, routine);
statust = nc_inq_varid (exoid, VAR_ELEM_TAB, &tabid);
var_name = "vals_elem_var";
ent_type = "eb";
break;
case EX_NODE_SET:
status = ex_get_dimension(exoid, DIM_NUM_NSET_VAR, "nodeset variables", &num_var_db, &varid, routine);
statust = nc_inq_varid (exoid, VAR_NSET_TAB, &tabid);
var_name = "vals_nset_var";
ent_type = "ns";
break;
case EX_EDGE_SET:
status = ex_get_dimension(exoid, DIM_NUM_ESET_VAR, "edgeset variables", &num_var_db, &varid, routine);
statust = nc_inq_varid (exoid, VAR_ESET_TAB, &tabid);
var_name = "vals_eset_var";
ent_type = "es";
break;
case EX_FACE_SET:
status = ex_get_dimension(exoid, DIM_NUM_FSET_VAR, "faceset variables", &num_var_db, &varid, routine);
statust = nc_inq_varid (exoid, VAR_FSET_TAB, &tabid);
var_name = "vals_fset_var";
ent_type = "fs";
break;
case EX_SIDE_SET:
status = ex_get_dimension(exoid, DIM_NUM_SSET_VAR, "sideset variables", &num_var_db, &varid, routine);
statust = nc_inq_varid (exoid, VAR_SSET_TAB, &tabid);
var_name = "vals_sset_var";
ent_type = "ss";
break;
case EX_ELEM_SET:
status = ex_get_dimension(exoid, DIM_NUM_ELSET_VAR, "elemset variables", &num_var_db, &varid, routine);
statust = nc_inq_varid (exoid, VAR_ELSET_TAB, &tabid);
var_name = "vals_elset_var";
ent_type = "es";
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %d specified in file id %d",
obj_type, exoid);
ex_err(routine,errmsg,exerrval);
return (EX_WARN);
}
if (status != NC_NOERR) {
exerrval = status;
return (EX_WARN);
}
/* Determine index of entity_id in id array */
ent_ndx = ex_id_lkup(exoid,obj_type,entity_id);
if (exerrval != 0) {
if (exerrval != EX_NULLENTITY) {
sprintf(errmsg,
"Error: failed to locate %s id %"PRId64" in id variable in file id %d",
ex_name_of_object(obj_type), entity_id, exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
}
/* If this is a null entity, then 'ent_ndx' will be negative.
* We don't care in this routine, so make it positive and continue...
*/
if (ent_ndx < 0) ent_ndx = -ent_ndx;
if ((int)num_var_db != num_var) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of variables doesn't match those defined in file id %d", exoid);
ex_err("ex_get_object_truth_vector",errmsg,exerrval);
return (EX_FATAL);
}
if (statust != NC_NOERR) {
/* since truth vector isn't stored in the data file, derive it dynamically */
for (i=0; i<num_var; i++) {
/* NOTE: names are 1-based */
if (nc_inq_varid(exoid, ex_catstr2(var_name, i+1, ent_type, ent_ndx), &tabid) != NC_NOERR) {
/* variable doesn't exist; put a 0 in the truth vector */
var_vec[i] = 0;
} else {
/* variable exists; put a 1 in the truth vector */
var_vec[i] = 1;
}
}
} else {
/* read in the truth vector */
start[0] = ent_ndx-1;
start[1] = 0;
count[0] = 1;
count[1] = num_var;
status = nc_get_vara_int(exoid, tabid, start, count, var_vec);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get truth vector from file id %d", exoid);
ex_err("ex_get_object_truth_vector",errmsg,exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
}
