char *ex_name_var_of_object(ex_entity_type obj_type, int i, int j)
{
switch (obj_type) {
case EX_EDGE_BLOCK: return VAR_EDGE_VAR(i, j);
case EX_FACE_BLOCK: return VAR_FACE_VAR(i, j);
case EX_ELEM_BLOCK: return VAR_ELEM_VAR(i, j);
case EX_NODE_SET: return VAR_NS_VAR(i, j);
case EX_EDGE_SET: return VAR_ES_VAR(i, j);
case EX_FACE_SET: return VAR_FS_VAR(i, j);
case EX_SIDE_SET: return VAR_SS_VAR(i, j);
case EX_ELEM_SET: return VAR_ELS_VAR(i, j);
default: return 0;
}
}
int ex_put_elem_var_slab (int exoid,
int time_step,
int elem_var_index,
ex_entity_id elem_blk_id,
int64_t start_pos,
int64_t num_vals,
void *elem_var_vals)
{
int status;
int varid, dimid,time_dim, numelbdim, dims[2], elem_blk_id_ndx;
size_t num_elem_blk, num_elem_var, start[2], count[2];
int *elem_var_tab;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* Determine index of elem_blk_id in VAR_ID_EL_BLK array */
if ((elem_blk_id_ndx = ex_id_lkup(exoid, EX_ELEM_BLOCK, elem_blk_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no variables allowed for NULL block %"PRId64" in file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_var_slab", errmsg, EX_NULLENTITY);
return (EX_WARN);
}
sprintf(errmsg,
"Error: failed to locate element block id %"PRId64" in %s array in file id %d",
elem_blk_id, VAR_ID_EL_BLK, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid (exoid,
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx), &varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) { /* variable doesn't exist, create it! */
/* inquire previously defined dimensions */
/* check for the existance of an element variable truth table */
if ((status = nc_inq_varid (exoid, VAR_ELEM_TAB, &varid)) == NC_NOERR) {
/* find out number of element blocks and element variables */
if ((status = nc_inq_dimid (exoid, DIM_NUM_EL_BLK, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of element blocks in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_elem_blk)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimid (exoid, DIM_NUM_ELE_VAR, &dimid)) != NC_NOERR) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: no element variables stored in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_elem_var)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of element variables in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if (!(elem_var_tab =
(int *)malloc(num_elem_blk*num_elem_var*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for element variable truth table in file id %d",
exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
/* read in the element variable truth table */
if ((status = nc_get_var_int(exoid, varid, elem_var_tab)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get truth table from file id %d", exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if (elem_var_tab[num_elem_var*(elem_blk_id_ndx-1)+elem_var_index-1] == 0L) {
free(elem_var_tab);
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid element variable %d, block %"PRId64" in file id %d",
elem_var_index, elem_blk_id, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
free(elem_var_tab);
}
if ((status = nc_inq_dimid (exoid, DIM_TIME, &time_dim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate time dimension in file id %d", exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_inq_dimid(exoid, DIM_NUM_EL_IN_BLK(elem_blk_id_ndx), &numelbdim)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: number of elements in element block %"PRId64" not defined in file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of elements in element block %"PRId64" in file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
}
goto error_ret;
}
/* variable doesn't exist so put file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode", exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
/* define netCDF variable to store element variable values */
dims[0] = time_dim;
dims[1] = numelbdim;
if ((status = nc_def_var(exoid, VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx),
nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define element variable %d in file id %d",
elem_var_index, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
goto error_ret;
}
ex_compress_variable(exoid, varid, 2);
/* leave define mode */
if ((status = nc_enddef(exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete element variable %s definition to file id %d",
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx), exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate element variable %s in file id %d",
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx),exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
}
/* store element variable values */
start[0] = --time_step;
start[1] = --start_pos;
count[0] = 1;
count[1] = num_vals;
if (ex_comp_ws(exoid) == 4) {
status = nc_put_vara_float(exoid, varid, start, count, elem_var_vals);
} else {
status = nc_put_vara_double(exoid, varid, start, count, elem_var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store element variable %d in file id %d",
elem_var_index, exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d", exoid);
ex_err("ex_put_elem_var_slab", errmsg, exerrval);
}
return (EX_FATAL);
}
int 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_elem_var (int exoid,
int time_step,
int elem_var_index,
int elem_blk_id,
int num_elem_this_blk,
void *elem_var_vals)
{
int varid, elem_blk_id_ndx;
long start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* Determine index of elem_blk_id in VAR_ID_EL_BLK array */
elem_blk_id_ndx = ex_id_lkup(exoid,VAR_ID_EL_BLK,elem_blk_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no element variables for NULL block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_get_elem_var",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
sprintf(errmsg,
"Error: failed to locate element block id %d in %s variable in file id %d",
elem_blk_id, VAR_ID_EL_BLK, exoid);
ex_err("ex_get_elem_var",errmsg,exerrval);
return (EX_FATAL);
}
}
/* inquire previously defined variable */
if((varid=ncvarid(exoid,VAR_ELEM_VAR(elem_var_index,elem_blk_id_ndx))) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate elem var %d for elem block %d in file id %d",
elem_var_index,elem_blk_id,exoid); /* this msg needs to be improved */
ex_err("ex_get_elem_var",errmsg,exerrval);
return (EX_FATAL);
}
/* read values of element variable */
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_elem_this_blk;
if (ncvarget (exoid, varid, start, count,
ex_conv_array(exoid,RTN_ADDRESS,elem_var_vals,num_elem_this_blk)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get elem var %d for block %d in file id %d",
elem_var_index,elem_blk_id,exoid);/*this msg needs to be improved*/
ex_err("ex_get_elem_var",errmsg,exerrval);
return (EX_FATAL);
}
ex_conv_array( exoid, READ_CONVERT, elem_var_vals, num_elem_this_blk );
return (EX_NOERR);
}
int ex_get_elem_varid (int exoid,
int *varid)
{
int dimid, evarid, i, j;
long num_elem_blk, num_elem_var;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire id's of previously defined dimensions */
if ((dimid = ncdimid (exoid, DIM_NUM_EL_BLK)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of element blocks in file id %d",
exoid);
ex_err("ex_get_elem_varid",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_elem_blk) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_get_elem_varid",errmsg,exerrval);
return (EX_FATAL);
}
if ((dimid = ncdimid (exoid, DIM_NUM_ELE_VAR)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Warning: no element variables stored in file id %d",
exoid);
ex_err("ex_get_elem_varid",errmsg,exerrval);
return (EX_WARN);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_elem_var) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element variables in file id %d",
exoid);
ex_err("ex_get_elem_varid",errmsg,exerrval);
return (EX_FATAL);
}
/* since truth table isn't stored in the data file, derive it dynamically */
for (j=0; j<num_elem_blk; j++) {
for (i=0; i<num_elem_var; i++) {
/* NOTE: names are 1-based */
if ((evarid = ncvarid (exoid, VAR_ELEM_VAR(i+1,j+1))) == -1)
/* variable doesn't exist; put a 0 in the varid table */
varid[j*num_elem_var+i] = 0;
else
/* variable exists; put varid in the table */
varid[j*num_elem_var+i] = evarid;
}
}
return (EX_NOERR);
}
