int ex_put_all_var_param_ext(int exoid, const ex_var_params *vp)
{
int in_define = 0;
int status;
int temp;
int time_dim, num_nod_dim, dimid;
size_t num_elem_blk, num_edge_blk, num_face_blk;
size_t num_nset, num_eset, num_fset, num_sset, num_elset;
int numelblkdim, numelvardim, numedvardim, numedblkdim, numfavardim, numfablkdim, numnsetdim,
nsetvardim, numesetdim, esetvardim, numfsetdim, fsetvardim, numssetdim, ssetvardim,
numelsetdim, elsetvardim;
int i;
int edblk_varid, fablk_varid, eblk_varid, nset_varid, eset_varid, fset_varid, sset_varid,
elset_varid, varid;
void_int *eblk_ids = NULL;
void_int *edblk_ids = NULL;
void_int *fablk_ids = NULL;
void_int *nset_ids = NULL;
void_int *eset_ids = NULL;
void_int *fset_ids = NULL;
void_int *sset_ids = NULL;
void_int *elset_ids = NULL;
int *eblk_stat = NULL;
int *edblk_stat = NULL;
int *fablk_stat = NULL;
int *nset_stat = NULL;
int *eset_stat = NULL;
int *fset_stat = NULL;
int *sset_stat = NULL;
int *elset_stat = NULL;
int dims[3];
char errmsg[MAX_ERR_LENGTH];
const char *routine = "ex_put_all_var_param_ext";
ex_check_valid_file_id(exoid);
exerrval = 0; /* clear error code */
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_TIME, &time_dim)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate time dimension in file id %d", exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret;
}
if ((status = nc_inq_dimid(exoid, DIM_NUM_NODES, &num_nod_dim)) != NC_NOERR) {
num_nod_dim = -1; /* There is probably no nodes on this file */
}
/* Check this now so we can use it later without checking for errors */
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &temp)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get string length in file id %d", exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret;
}
EX_GET_IDS_STATUS("edge block", vp->num_edge, DIM_NUM_ED_BLK, numedblkdim, num_edge_blk,
edblk_ids, EX_EDGE_BLOCK, VAR_STAT_ED_BLK, edblk_stat);
EX_GET_IDS_STATUS("face block", vp->num_face, DIM_NUM_FA_BLK, numfablkdim, num_face_blk,
fablk_ids, EX_FACE_BLOCK, VAR_STAT_FA_BLK, fablk_stat);
EX_GET_IDS_STATUS("element block", vp->num_elem, DIM_NUM_EL_BLK, numelblkdim, num_elem_blk,
eblk_ids, EX_ELEM_BLOCK, VAR_STAT_EL_BLK, eblk_stat);
EX_GET_IDS_STATUS("node set", vp->num_nset, DIM_NUM_NS, numnsetdim, num_nset, nset_ids,
EX_NODE_SET, VAR_NS_STAT, nset_stat);
EX_GET_IDS_STATUS("edge set", vp->num_eset, DIM_NUM_ES, numesetdim, num_eset, eset_ids,
EX_EDGE_SET, VAR_ES_STAT, eset_stat);
EX_GET_IDS_STATUS("face set", vp->num_fset, DIM_NUM_FS, numfsetdim, num_fset, fset_ids,
EX_FACE_SET, VAR_FS_STAT, fset_stat);
EX_GET_IDS_STATUS("side set", vp->num_sset, DIM_NUM_SS, numssetdim, num_sset, sset_ids,
EX_SIDE_SET, VAR_SS_STAT, sset_stat);
EX_GET_IDS_STATUS("element set", vp->num_elset, DIM_NUM_ELS, numelsetdim, num_elset, elset_ids,
EX_ELEM_SET, VAR_ELS_STAT, elset_stat);
/* put file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file id %d into define mode", exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret;
}
in_define = 1;
/* define dimensions and variables */
if (vp->num_glob > 0) {
if (define_dimension(exoid, DIM_NUM_GLO_VAR, vp->num_glob, "global", &dimid) != NC_NOERR) {
goto error_ret;
}
dims[0] = time_dim;
dims[1] = dimid;
if ((status = nc_def_var(exoid, VAR_GLO_VAR, nc_flt_code(exoid), 2, dims, &varid)) !=
NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define global variables in file id %d",
exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
/* Now define global variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_GLO_VAR, dimid, "global") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_node > 0) {
/*
* There are two ways to store the nodal variables. The old way *
* was a blob (#times,#vars,#nodes), but that was exceeding the
* netcdf maximum dataset size for large models. The new way is
* to store #vars separate datasets each of size (#times,#nodes)
*
* We want this routine to be capable of storing both formats
* based on some external flag. Since the storage format of the
* coordinates have also been changed, we key off of their
* storage type to decide which method to use for nodal
* variables. If the variable 'coord' is defined, then store old
* way; otherwise store new.
*/
if (define_dimension(exoid, DIM_NUM_NOD_VAR, vp->num_node, "nodal", &dimid) != NC_NOERR) {
goto error_ret;
}
if (num_nod_dim > 0) {
if (ex_large_model(exoid) == 0) { /* Old way */
dims[0] = time_dim;
dims[1] = dimid;
dims[2] = num_nod_dim;
if ((status = nc_def_var(exoid, VAR_NOD_VAR, nc_flt_code(exoid), 3, dims, &varid)) !=
NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define nodal variables in file id %d",
exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
}
else { /* Store new way */
for (i = 1; i <= vp->num_node; i++) {
dims[0] = time_dim;
dims[1] = num_nod_dim;
if ((status = nc_def_var(exoid, VAR_NOD_VAR_NEW(i), nc_flt_code(exoid), 2, dims,
&varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define nodal variable %d in file id %d", i, exoid);
ex_err("ex_put_var_param", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
}
/* Now define nodal variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_NOD_VAR, dimid, "nodal") != NC_NOERR) {
goto error_ret;
}
}
#define EX_DEFINE_VARS(TID, STNAME, TNAME, NUMVAR, DNAME, DID1, DID2, DVAL, VIDS, VNOV, VTV, \
VSTATVAL, VTABVAL, VTABVAR) \
if (NUMVAR > 0) { \
status = define_dimension(exoid, DNAME, NUMVAR, STNAME, &DID2); \
if (status != NC_NOERR) \
goto error_ret; \
\
/* Now define STNAME variable name variable */ \
if (define_variable_name_variable(exoid, VNOV, DID2, STNAME) != NC_NOERR) \
goto error_ret; \
\
if (define_truth_table(TID, exoid, DVAL, NUMVAR, VTABVAL, VSTATVAL, VIDS, TNAME) != NC_NOERR) \
goto error_ret; \
\
free(VSTATVAL); \
VSTATVAL = NULL; \
free(VIDS); \
VIDS = NULL; \
\
/* create a variable array in which to store the STNAME variable truth \
* table \
*/ \
\
dims[0] = DID1; \
dims[1] = DID2; \
\
if ((status = nc_def_var(exoid, VTV, NC_INT, 2, dims, &VTABVAR)) != NC_NOERR) { \
exerrval = status; \
snprintf(errmsg, MAX_ERR_LENGTH, \
"ERROR: failed to define " STNAME " variable truth table in file id %d", exoid); \
ex_err("ex_put_all_var_param_ext", errmsg, exerrval); \
goto error_ret; /* exit define mode and return */ \
} \
}
EX_DEFINE_VARS(EX_EDGE_BLOCK, "edge", "edge block", vp->num_edge, DIM_NUM_EDG_VAR, numedblkdim,
numedvardim, num_edge_blk, edblk_ids, VAR_NAME_EDG_VAR, VAR_EBLK_TAB, edblk_stat,
vp->edge_var_tab, edblk_varid);
EX_DEFINE_VARS(EX_FACE_BLOCK, "face", "face block", vp->num_face, DIM_NUM_FAC_VAR, numfablkdim,
numfavardim, num_face_blk, fablk_ids, VAR_NAME_FAC_VAR, VAR_FBLK_TAB, fablk_stat,
vp->face_var_tab, fablk_varid);
EX_DEFINE_VARS(EX_ELEM_BLOCK, "element", "element block", vp->num_elem, DIM_NUM_ELE_VAR,
numelblkdim, numelvardim, num_elem_blk, eblk_ids, VAR_NAME_ELE_VAR, VAR_ELEM_TAB,
eblk_stat, vp->elem_var_tab, eblk_varid);
EX_DEFINE_VARS(EX_NODE_SET, "nodeset", "node set", vp->num_nset, DIM_NUM_NSET_VAR, numnsetdim,
nsetvardim, num_nset, nset_ids, VAR_NAME_NSET_VAR, VAR_NSET_TAB, nset_stat,
vp->nset_var_tab, nset_varid);
EX_DEFINE_VARS(EX_EDGE_SET, "edgeset", "edge set", vp->num_eset, DIM_NUM_ESET_VAR, numesetdim,
esetvardim, num_eset, eset_ids, VAR_NAME_ESET_VAR, VAR_ESET_TAB, eset_stat,
vp->eset_var_tab, eset_varid);
EX_DEFINE_VARS(EX_FACE_SET, "faceset", "face set", vp->num_fset, DIM_NUM_FSET_VAR, numfsetdim,
fsetvardim, num_fset, fset_ids, VAR_NAME_FSET_VAR, VAR_FSET_TAB, fset_stat,
vp->fset_var_tab, fset_varid);
EX_DEFINE_VARS(EX_SIDE_SET, "sideset", "side set", vp->num_sset, DIM_NUM_SSET_VAR, numssetdim,
ssetvardim, num_sset, sset_ids, VAR_NAME_SSET_VAR, VAR_SSET_TAB, sset_stat,
vp->sset_var_tab, sset_varid);
EX_DEFINE_VARS(EX_ELEM_SET, "elemset", "element set", vp->num_elset, DIM_NUM_ELSET_VAR,
numelsetdim, elsetvardim, num_elset, elset_ids, VAR_NAME_ELSET_VAR, VAR_ELSET_TAB,
elset_stat, vp->elset_var_tab, elset_varid);
/* leave define mode */
in_define = 0;
if ((status = nc_enddef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition in file id %d", exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
goto error_ret;
}
/* write out the variable truth tables */
if (vp->num_edge > 0) {
if (put_truth_table(exoid, edblk_varid, vp->edge_var_tab, "edge") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_face > 0) {
if (put_truth_table(exoid, fablk_varid, vp->face_var_tab, "face") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_elem > 0) {
if (put_truth_table(exoid, eblk_varid, vp->elem_var_tab, "element") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_nset > 0) {
if (put_truth_table(exoid, nset_varid, vp->nset_var_tab, "nodeset") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_eset > 0) {
if (put_truth_table(exoid, eset_varid, vp->eset_var_tab, "edgeset") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_fset > 0) {
if (put_truth_table(exoid, fset_varid, vp->fset_var_tab, "faceset") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_sset > 0) {
if (put_truth_table(exoid, sset_varid, vp->sset_var_tab, "sideset") != NC_NOERR) {
goto error_ret;
}
}
if (vp->num_elset > 0) {
if (put_truth_table(exoid, elset_varid, vp->elset_var_tab, "elemset") != NC_NOERR) {
goto error_ret;
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (in_define == 1) {
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_put_all_var_param_ext", errmsg, exerrval);
}
}
free(eblk_ids);
free(edblk_ids);
free(fablk_ids);
free(nset_ids);
free(eset_ids);
free(fset_ids);
free(sset_ids);
free(elset_ids);
free(eblk_stat);
free(edblk_stat);
free(fablk_stat);
free(nset_stat);
free(eset_stat);
free(fset_stat);
free(sset_stat);
free(elset_stat);
return (EX_FATAL);
}
int ex_put_all_var_param (int exoid,
int num_g,
int num_n,
int num_e,
int *elem_var_tab,
int num_m,
int *nset_var_tab,
int num_s,
int *sset_var_tab)
{
int in_define = 0;
int time_dim, num_nod_dim, dimid, iresult;
long num_elem_blk, num_nset, num_sset;
int numelblkdim, numelvardim, numnsetdim, nsetvardim, numssetdim, ssetvardim;
int i;
int eblk_varid, nset_varid, sset_varid;
int *eblk_ids = 0;
int *nset_ids = 0;
int *sset_ids = 0;
nclong *eblk_stat = 0;
nclong *nset_stat = 0;
nclong *sset_stat = 0;
int dims[3];
char errmsg[MAX_ERR_LENGTH];
const char* routine = "ex_put_all_var_param";
exerrval = 0; /* clear error code */
/* inquire previously defined dimensions */
if ((time_dim = ncdimid (exoid, DIM_TIME)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate time dimension in file id %d", exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret;
}
if ((num_nod_dim = ncdimid (exoid, DIM_NUM_NODES)) == -1) {
if (num_n > 0) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of nodes in file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret;
}
}
/* Check this now so we can use it later without checking for errors */
if (ncdimid (exoid, DIM_STR) < 0) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret;
}
if (num_e > 0) {
numelblkdim = ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element blocks", &num_elem_blk, routine);
if (numelblkdim == -1)
goto error_ret;
/* get element block IDs */
if (!(eblk_ids = static_cast<int*>(malloc(num_elem_blk*sizeof(int))))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for element block id array for file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret;
}
ex_get_elem_blk_ids (exoid, eblk_ids);
/* Get element block status array for later use (allocates memory) */
eblk_stat = get_status_array(exoid, num_elem_blk, VAR_STAT_EL_BLK, "element block");
if (eblk_stat == NULL) {
goto error_ret;
}
}
if (num_m > 0) {
numnsetdim = ex_get_dimension(exoid, DIM_NUM_NS, "nodesets", &num_nset, routine);
if (numnsetdim == -1)
goto error_ret;
/* get nodeset IDs */
if (!(nset_ids = static_cast<int*>(malloc(num_nset*sizeof(int))))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for nodeset id array for file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret;
}
ex_get_node_set_ids (exoid, nset_ids);
/* Get nodeset status array for later use (allocates memory) */
nset_stat = get_status_array(exoid, num_nset, VAR_NS_STAT, "nodeset");
if (nset_stat == NULL) {
goto error_ret;
}
}
if (num_s > 0) {
numssetdim = ex_get_dimension(exoid, DIM_NUM_SS, "sidesets", &num_sset, routine);
if (numssetdim == -1)
goto error_ret;
/* get sideset IDs */
if (!(sset_ids = static_cast<int*>(malloc(num_sset*sizeof(int))))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for sideset id array for file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret;
}
ex_get_side_set_ids (exoid, sset_ids);
/* Get sideset status array for later use (allocates memory) */
sset_stat = get_status_array(exoid, num_sset, VAR_SS_STAT, "sideset");
if (sset_stat == NULL) {
goto error_ret;
}
}
/* put 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_all_var_param",errmsg,exerrval);
goto error_ret;
}
in_define = 1;
/* define dimensions and variables */
if (num_g > 0)
{
dimid = define_dimension(exoid, DIM_NUM_GLO_VAR, num_g, "global");
if (dimid == -1) goto error_ret;
dims[0] = time_dim;
dims[1] = dimid;
if ((ncvardef (exoid, VAR_GLO_VAR,
nc_flt_code(exoid), 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define global variables in file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* Now define global variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_GLO_VAR, dimid, "global") == -1)
goto error_ret;
}
if (num_n > 0)
{
/*
* There are two ways to store the nodal variables. The old way *
* was a blob (#times,#vars,#nodes), but that was exceeding the
* netcdf maximum dataset size for large models. The new way is
* to store #vars separate datasets each of size (#times,#nodes)
*
* We want this routine to be capable of storing both formats
* based on some external flag. Since the storage format of the
* coordinates have also been changed, we key off of their
* storage type to decide which method to use for nodal
* variables. If the variable 'coord' is defined, then store old
* way; otherwise store new.
*/
dimid = define_dimension(exoid, DIM_NUM_NOD_VAR, num_n, "nodal");
if (dimid == -1) goto error_ret;
if (ex_large_model(exoid) == 0) { /* Old way */
dims[0] = time_dim;
dims[1] = dimid;
dims[2] = num_nod_dim;
if ((ncvardef (exoid, VAR_NOD_VAR,
nc_flt_code(exoid), 3, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define nodal variables in file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else { /* Store new way */
for (i = 1; i <= num_n; i++) {
dims[0] = time_dim;
dims[1] = num_nod_dim;
if ((ncvardef (exoid, VAR_NOD_VAR_NEW(i),
nc_flt_code(exoid), 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define nodal variable %d in file id %d",
i, exoid);
ex_err("ex_put_var_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
/* Now define nodal variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_NOD_VAR, dimid, "nodal") == -1)
goto error_ret;
}
if (num_e > 0) {
numelvardim = define_dimension(exoid, DIM_NUM_ELE_VAR, num_e, "element");
if (numelvardim == -1) goto error_ret;
/* Now define element variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_ELE_VAR, numelvardim, "element") == -1)
goto error_ret;
if (define_truth_table('e', exoid, num_elem_blk, num_e, elem_var_tab, eblk_stat, eblk_ids, "element block") == -1)
goto error_ret;
eblk_stat = static_cast<nclong*>(safe_free (eblk_stat));
eblk_ids = static_cast<int*>( safe_free (eblk_ids));
/* create a variable array in which to store the element variable truth
* table
*/
dims[0] = numelblkdim;
dims[1] = numelvardim;
if ((eblk_varid = ncvardef (exoid, VAR_ELEM_TAB, NC_LONG, 2, dims)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define element variable truth table in file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (num_m > 0) {
nsetvardim = define_dimension(exoid, DIM_NUM_NSET_VAR, num_m, "nodeset");
if (nsetvardim == -1) goto error_ret;
/* Now define nodeset variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_NSET_VAR, nsetvardim, "nodeset") == -1)
goto error_ret;
if (define_truth_table('m', exoid, num_nset, num_m, nset_var_tab, nset_stat, nset_ids, "nodeset") == -1)
goto error_ret;
nset_stat = static_cast<nclong*>(safe_free (nset_stat));
nset_ids = static_cast<int*>(safe_free (nset_ids));
/* create a variable array in which to store the truth table
*/
dims[0] = numnsetdim;
dims[1] = nsetvardim;
if ((nset_varid = ncvardef (exoid, VAR_NSET_TAB, NC_LONG, 2, dims)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define nodeset variable truth table in file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (num_s > 0) {
ssetvardim = define_dimension(exoid, DIM_NUM_SSET_VAR, num_s, "sideset");
if (ssetvardim == -1) goto error_ret;
/* Now define sideset variable name variable */
if (define_variable_name_variable(exoid, VAR_NAME_SSET_VAR, ssetvardim, "sideset") == -1)
goto error_ret;
if (define_truth_table('s', exoid, num_sset, num_s, sset_var_tab, sset_stat, sset_ids, "sideset") == -1)
goto error_ret;
sset_stat = static_cast<nclong*>(safe_free (sset_stat));
sset_ids = static_cast<int*>(safe_free (sset_ids));
/* create a variable array in which to store the truth table
*/
dims[0] = numssetdim;
dims[1] = ssetvardim;
if ((sset_varid = ncvardef (exoid, VAR_SSET_TAB, NC_LONG, 2, dims)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define sideset variable truth table in file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* leave define mode */
in_define = 0;
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete definition in file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
goto error_ret;
}
/* write out the variable truth tables */
if (num_e > 0) {
iresult = put_truth_table(exoid, num_elem_blk, num_e, eblk_varid, elem_var_tab, "element");
if (iresult == -1) goto error_ret;
}
if (num_m > 0) {
iresult = put_truth_table(exoid, num_nset, num_m, nset_varid, nset_var_tab, "nodeset");
if (iresult == -1) goto error_ret;
}
if (num_s > 0) {
iresult = put_truth_table(exoid, num_sset, num_s, sset_varid, sset_var_tab, "sideset");
if (iresult == -1) goto error_ret;
}
return(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (in_define == 1) {
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_all_var_param",errmsg,exerrval);
}
}
safe_free(eblk_ids);
safe_free(nset_ids);
safe_free(sset_ids);
safe_free(eblk_stat);
safe_free(nset_stat);
safe_free(sset_stat);
return(EX_FATAL);
}
