int
wr_dpi(Dpi *d,
char *filename,
int verbosity)
{
int err = 0;
int status = 0;
int u = 0; /* short hand for unit... */
struct Shadow_Identifiers si;
memset(&si, 0, sizeof(struct Shadow_Identifiers));
/*
* From the C interface guide the basic calling sequence is given
* for the case of adding new dimensions, variables and attributes to
* an existing netCDF dataset.
*
* nc_open();
* nc_redef();
* nc_def_dim();
* nc_def_var();
* nc_put_att();
* nc_enddef();
* nc_put_var();
* nc_close();
*
*/
/*
* Open the file.
*/
#ifdef NETCDF_3
err = nc_open(filename, NC_WRITE, &u);
if ( err != NC_NOERR )
{
EH(-1, "nc_open() problem.");
}
#endif
#ifdef NETCDF_2
err = ncopen(filename, NC_WRITE);
EH(err, "ncopen() problem.");
u = err;
#endif
/*
* Go into define mode.
*/
#ifdef NETCDF_3
err = nc_redef(u);
if ( err != NC_NOERR )
{
EH(-1, "nc_redef() problem.");
}
#endif
#ifdef NETCDF_2
err = ncredef(u);
EH(err, "ncredef() problem.");
#endif
/*
* Define each of the netCDF dimensions that will be needed to describe
* the extent of netCDF variables that are arrays.
*/
define_dimension(u, DIM_LEN_EB_NUM_PRIVATE_ELEMS,
d->len_eb_num_private_elems,
&si.len_eb_num_private_elems);
define_dimension(u, DIM_LEN_ELEM_VAR_TAB_GLOBAL,
d->len_elem_var_tab_global,
&si.len_elem_var_tab_global);
define_dimension(u, DIM_LEN_ELEM_ELEM_LIST, /* new e-e */
d->len_elem_elem_list,
&si.len_elem_elem_list);
define_dimension(u, DIM_LEN_NODE_DESCRIPTION,
d->len_node_description,
&si.len_node_description);
define_dimension(u, DIM_LEN_NS_NODE_LIST,
d->len_ns_node_list,
&si.len_ns_node_list);
define_dimension(u, DIM_LEN_NS_DISTFACT_LIST,
d->len_ns_distfact_list,
&si.len_ns_distfact_list);
define_dimension(u, DIM_LEN_SS_ELEM_LIST,
d->len_ss_elem_list,
&si.len_ss_elem_list);
define_dimension(u, DIM_LEN_SS_DISTFACT_LIST,
d->len_ss_distfact_list,
&si.len_ss_distfact_list);
define_dimension(u, DIM_LEN_STRING,
d->len_string,
&si.len_string);
define_dimension(u, DIM_LEN_PTR_SET_MEMBERSHIP,
d->len_ptr_set_membership,
&si.len_ptr_set_membership);
define_dimension(u, DIM_LEN_SET_MEMBERSHIP,
d->len_set_membership,
&si.len_set_membership);
define_dimension(u, DIM_NUM_ELEM_BLOCKS,
d->num_elem_blocks,
&si.num_elem_blocks);
define_dimension(u, DIM_NUM_ELEM_BLOCKS_GLOBAL,
d->num_elem_blocks_global,
&si.num_elem_blocks_global);
define_dimension(u, DIM_NUM_ELEMS,
d->num_elems,
&si.num_elems);
define_dimension(u, DIM_NUM_GLOBAL_NODE_DESCRIPTIONS,
d->num_global_node_descriptions,
&si.num_global_node_descriptions);
define_dimension(u, DIM_NUM_NEIGHBORS,
d->num_neighbors,
&si.num_neighbors);
define_dimension(u, DIM_NUM_NODE_SETS,
d->num_node_sets,
&si.num_node_sets);
define_dimension(u, DIM_NUM_NODE_SETS_GLOBAL,
d->num_node_sets_global,
&si.num_node_sets_global);
define_dimension(u, DIM_NUM_NODES,
d->num_nodes,
&si.num_nodes);
define_dimension(u, DIM_NUM_PROPS_EB, d->num_props_eb,
&si.num_props_eb);
define_dimension(u, DIM_NUM_PROPS_NS,
d->num_props_ns,
&si.num_props_ns);
define_dimension(u, DIM_NUM_PROPS_SS,
d->num_props_ss,
&si.num_props_ss);
define_dimension(u, DIM_NUM_SIDE_SETS,
d->num_side_sets,
&si.num_side_sets);
define_dimension(u, DIM_NUM_SIDE_SETS_GLOBAL,
d->num_side_sets_global,
&si.num_side_sets_global);
define_dimension(u, DIM_NUM_UNIVERSE_NODES,
d->num_universe_nodes,
&si.num_universe_nodes);
if (d->num_side_sets_global > 0) {
define_dimension(u, DIM_LEN_SS_BLOCK_INDEX_GLOBAL,
d->num_side_sets_global + 1,
&si.len_ss_block_index_global);
define_dimension(u, DIM_LEN_SS_BLOCK_LIST_GLOBAL,
d->ss_block_index_global[d->num_side_sets_global],
&si.len_ss_block_list_global);
} else {
define_dimension(u, DIM_LEN_SS_BLOCK_INDEX_GLOBAL,
0,
&si.len_ss_block_index_global);
define_dimension(u, DIM_LEN_SS_BLOCK_LIST_GLOBAL,
0,
&si.len_ss_block_list_global);
}
/*
* Define variables. Arrays only get defined if their respective dimensions
* are greater than zero.
*
* Also, this handy routine uses two arguments for the possibility of
* up to 2D arrays. Dummy arguments of "-1" are inserted for 1D arrays
* or for scalar variables ( zero dimensional arrays).
*/
define_variable(u, VAR_DPI_VERSION_STRING, NC_CHAR, 1,
si.len_string, -1,
d->len_string, -1,
&si.dpi_version_string);
define_variable(u, VAR_EB_ELEM_TYPE_GLOBAL, NC_CHAR, 2,
si.num_elem_blocks_global, si.len_string,
d->num_elem_blocks_global, d->len_string,
&si.eb_elem_type_global);
define_variable(u, VAR_EB_ID_GLOBAL, NC_INT, 1,
si.num_elem_blocks_global, -1,
d->num_elem_blocks_global, -1,
&si.eb_id_global);
define_variable(u, VAR_EB_INDEX_GLOBAL, NC_INT, 1,
si.num_elem_blocks, -1,
d->num_elem_blocks, -1,
&si.eb_index_global);
define_variable(u, VAR_EB_NUM_ATTR_GLOBAL, NC_INT, 1,
si.num_elem_blocks_global, -1,
d->num_elem_blocks_global, -1,
&si.eb_num_attr_global);
define_variable(u, VAR_EB_NUM_ELEMS_GLOBAL, NC_INT, 1,
si.num_elem_blocks_global, -1,
d->num_elem_blocks_global, -1,
&si.eb_num_elems_global);
define_variable(u, VAR_EB_NUM_NODES_PER_ELEM_GLOBAL, NC_INT, 1,
si.num_elem_blocks_global, -1,
d->num_elem_blocks_global, -1,
&si.eb_num_nodes_per_elem_global);
define_variable(u, VAR_EB_NUM_PRIVATE_ELEMS, NC_INT, 1,
si.num_elem_blocks, -1,
d->num_elem_blocks, -1,
&si.eb_num_private_elems);
if ( d->num_props_eb > 1 ) /* Properties are weird, recall. */
{
define_variable(u, VAR_EB_PROP_GLOBAL, NC_INT, 2,
si.num_props_eb, si.num_elem_blocks_global,
d->num_props_eb, d->num_elem_blocks_global,
&si.eb_prop_global);
}
if ( d->num_elems > 0 )
{
define_variable(u, VAR_ELEM_INDEX_GLOBAL, NC_INT, 1,
si.num_elems, -1,
d->num_elems, -1,
&si.elem_index_global);
}
if ( d->len_elem_var_tab_global > 0 )
{
define_variable(u, VAR_ELEM_VAR_TAB_GLOBAL, NC_INT, 1,
si.len_elem_var_tab_global, -1,
d->len_elem_var_tab_global, -1,
&si.elem_var_tab_global);
}
if ( d->len_elem_elem_list > 0 )
{
define_variable(u, VAR_ELEM_OWNER, NC_INT, 1,
si.num_elems, -1,
d->num_elems, -1,
&si.elem_owner);
define_variable(u, VAR_ELEM_ELEM_LIST_GLOBAL, NC_INT, 1,
si.len_elem_elem_list, -1,
d->len_elem_elem_list, -1,
&si.elem_elem_list_global);
define_variable(u, VAR_ELEM_ELEM_TWST_GLOBAL, NC_INT, 1,
si.len_elem_elem_list, -1,
d->len_elem_elem_list, -1,
&si.elem_elem_twst_global);
define_variable(u, VAR_ELEM_ELEM_FACE_GLOBAL, NC_INT, 1,
si.len_elem_elem_list, -1,
d->len_elem_elem_list, -1,
&si.elem_elem_face_global);
define_variable(u, VAR_ELEM_ELEM_PROC_GLOBAL, NC_INT, 1,
si.len_elem_elem_list, -1,
d->len_elem_elem_list, -1,
&si.elem_elem_proc_global);
}
define_variable(u, VAR_GLOBAL_NODE_DESCRIPTION, NC_INT, 2,
si.num_global_node_descriptions, si.len_node_description,
d->num_global_node_descriptions, d->len_node_description,
&si.global_node_description);
define_variable(u, VAR_MY_NAME, NC_INT, 0,
-1, -1,
-1, -1,
&si.my_name);
define_variable(u, VAR_NEIGHBOR, NC_INT, 1,
si.num_neighbors, -1,
d->num_neighbors, -1,
&si.neighbor);
if ( d->num_nodes > 0 )
{
define_variable(u, VAR_NODE_INDEX_GLOBAL, NC_INT, 1,
si.num_nodes, -1,
d->num_nodes, -1,
&si.node_index_global);
}
define_variable(u, VAR_NS_DISTFACT_INDEX_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_distfact_index_global);
define_variable(u, VAR_NS_DISTFACT_LEN_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.ns_distfact_len_global);
define_variable(u, VAR_NS_DISTFACT_LIST_INDEX_GLOBAL, NC_INT, 1,
si.len_ns_distfact_list, -1,
d->len_ns_distfact_list, -1,
&si.ns_distfact_list_index_global);
define_variable(u, VAR_NS_ID_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_id_global);
define_variable(u, VAR_NS_INDEX_GLOBAL, NC_INT, 1,
si.num_node_sets, -1,
d->num_node_sets, -1,
&si.ns_index_global);
define_variable(u, VAR_NS_NODE_INDEX_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_node_index_global);
define_variable(u, VAR_NS_NODE_LEN_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.ns_node_len_global);
define_variable(u, VAR_NS_NODE_LIST_INDEX_GLOBAL, NC_INT, 1,
si.len_ns_node_list, -1,
d->len_ns_node_list, -1,
&si.ns_node_list_index_global);
define_variable(u, VAR_NS_NUM_DISTFACTS_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_num_distfacts_global);
define_variable(u, VAR_NS_NUM_NODES_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_num_nodes_global);
if ( d->num_props_ns > 1 )
{
define_variable(u, VAR_NS_PROP_GLOBAL, NC_INT, 2,
si.num_props_ns, si.num_node_sets_global,
d->num_props_ns, d->num_node_sets_global,
&si.ns_prop_global);
}
define_variable(u, VAR_NUM_BOUNDARY_NODES, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_boundary_nodes);
define_variable(u, VAR_NUM_DOFS_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_dofs_global);
define_variable(u, VAR_NUM_ELEMS_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_elems_global);
define_variable(u, VAR_NUM_EXTERNAL_NODES, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_external_nodes);
define_variable(u, VAR_NUM_INTERNAL_NODES, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_internal_nodes);
define_variable(u, VAR_NUM_NODES_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_nodes_global);
define_variable(u, VAR_PTR_SET_MEMBERSHIP, NC_INT, 1,
si.len_ptr_set_membership, -1,
d->len_ptr_set_membership, -1,
&si.ptr_set_membership);
define_variable(u, VAR_SET_MEMBERSHIP, NC_INT, 1,
si.len_set_membership, -1,
d->len_set_membership, -1,
&si.set_membership);
define_variable(u, VAR_SS_DISTFACT_INDEX_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_distfact_index_global);
define_variable(u, VAR_SS_DISTFACT_LIST_INDEX_GLOBAL, NC_INT, 1,
si.len_ss_distfact_list, -1,
d->len_ss_distfact_list, -1,
&si.ss_distfact_list_index_global);
define_variable(u, VAR_SS_DISTFACT_LEN_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.ss_distfact_len_global);
define_variable(u, VAR_SS_ELEM_INDEX_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_elem_index_global);
define_variable(u, VAR_SS_ELEM_LEN_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.ss_elem_len_global);
define_variable(u, VAR_SS_ELEM_LIST_INDEX_GLOBAL, NC_INT, 1,
si.len_ss_elem_list, -1,
d->len_ss_elem_list, -1,
&si.ss_elem_list_index_global);
define_variable(u, VAR_SS_ID_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_id_global);
define_variable(u, VAR_SS_INDEX_GLOBAL, NC_INT, 1,
si.num_side_sets, -1,
d->num_side_sets, -1,
&si.ss_index_global);
define_variable(u, VAR_SS_NUM_DISTFACTS_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_num_distfacts_global);
define_variable(u, VAR_SS_NUM_SIDES_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_num_sides_global);
if ( d->num_props_ss > 1 )
{
define_variable(u, VAR_SS_PROP_GLOBAL, NC_INT, 2,
si.num_props_ss, si.num_side_sets_global,
d->num_props_ss, d->num_side_sets_global,
&si.ss_prop_global);
}
if ( d->num_side_sets_global > 0 )
{
define_variable(u, VAR_SS_INTERNAL_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_internal_global);
define_variable(u, VAR_SS_BLOCK_INDEX_GLOBAL, NC_INT, 1,
si.len_ss_block_index_global, -1,
d->num_side_sets_global + 1, -1,
&si.ss_block_index_global);
define_variable(u, VAR_SS_BLOCK_LIST_GLOBAL, NC_INT, 1,
si.len_ss_block_list_global, -1,
d->ss_block_index_global[d->num_side_sets_global], -1,
&si.ss_block_list_global);
}
define_variable(u, VAR_UNDEFINED_BASIC_EQNVAR_ID, NC_INT, 0,
-1, -1,
-1, -1,
&si.undefined_basic_eqnvar_id);
/*
* Leave define mode.
*/
#ifdef NETCDF_3
err = nc_enddef(u);
if ( err != NC_NOERR )
{
EH(-1, "nc_enddef() problem.");
}
#endif
#ifdef NETCDF_2
err = ncendef(u);
EH(err, "ncendef() problem.");
#endif
/*
* Put variable values.
*
* This form is good for scalars, 1d arrays and 2d arrays. Any more and
* you'll need to add another argument to the list for the backward
* compatible to netCDF implementation to work properly. We'll assume
* that start[] arrays that ncvarput() uses will be full of zeroes.
* If not, then you'll need to do that case by hand.
*/
put_variable(u, NC_CHAR, 1,
d->len_string, -1,
si.dpi_version_string, d->dpi_version_string);
put_variable(u, NC_CHAR, 2,
d->num_elem_blocks_global, d->len_string,
si.eb_elem_type_global, &(d->eb_elem_type_global[0][0]));
put_variable(u, NC_INT, 1,
d->num_elem_blocks_global, -1,
si.eb_id_global, d->eb_id_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks, -1,
si.eb_index_global, d->eb_index_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks_global, -1,
si.eb_num_attr_global, d->eb_num_attr_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks_global, -1,
si.eb_num_elems_global, d->eb_num_elems_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks_global, -1,
si.eb_num_nodes_per_elem_global,
d->eb_num_nodes_per_elem_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks, -1,
si.eb_num_private_elems, d->eb_num_private_elems);
if ( d->num_props_eb > 1 )
{
put_variable(u, NC_INT, 2,
d->num_props_eb, d->num_elem_blocks_global,
si.eb_prop_global, &(d->eb_prop_global[0][0]));
}
if ( d->num_elems > 0 )
{
put_variable(u, NC_INT, 1,
d->num_elems, -1,
si.elem_index_global, d->elem_index_global);
put_variable(u, NC_INT, 1, d->num_elems, -1, si.elem_owner,
d->elem_owner);
}
if ( d->len_elem_var_tab_global > 0 )
{
put_variable(u, NC_INT, 1,
d->len_elem_var_tab_global, -1,
si.elem_var_tab_global, d->elem_var_tab_global);
}
if ( d->len_elem_elem_list > 0 )
{
put_variable(u, NC_INT, 1, d->len_elem_elem_list, -1,
si.elem_elem_list_global, d->elem_elem_list_global);
put_variable(u, NC_INT, 1, d->len_elem_elem_list, -1,
si.elem_elem_face_global, d->elem_elem_face_global);
put_variable(u, NC_INT, 1, d->len_elem_elem_list, -1,
si.elem_elem_twst_global, d->elem_elem_twst_global);
put_variable(u, NC_INT, 1, d->len_elem_elem_list, -1,
si.elem_elem_proc_global, d->elem_elem_proc_global);
}
put_variable(u, NC_INT, 2,
d->num_global_node_descriptions, d->len_node_description,
si.global_node_description,&(d->global_node_description[0][0]));
put_variable(u, NC_INT, 0,
-1, -1,
si.my_name, &(d->my_name));
put_variable(u, NC_INT, 1,
d->num_neighbors, -1,
si.neighbor, d->neighbor);
if ( d->num_nodes > 0 )
{
put_variable(u, NC_INT, 1,
d->num_nodes, -1,
si.node_index_global, d->node_index_global);
}
put_variable(u, NC_INT, 0,
-1, -1,
si.ns_distfact_len_global, &(d->ns_distfact_len_global));
put_variable(u, NC_INT, 0,
-1, -1,
si.ns_node_len_global, &(d->ns_node_len_global));
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_id_global, d->ns_id_global);
put_variable(u, NC_INT, 1,
d->num_node_sets, -1,
si.ns_index_global, d->ns_index_global);
put_variable(u, NC_INT, 1,
d->len_ns_distfact_list, -1,
si.ns_distfact_list_index_global,
d->ns_distfact_list_index_global);
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_distfact_index_global, d->ns_distfact_index_global);
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_node_index_global, d->ns_node_index_global);
put_variable(u, NC_INT, 1,
d->len_ns_node_list, -1,
si.ns_node_list_index_global,
d->ns_node_list_index_global);
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_num_distfacts_global, d->ns_num_distfacts_global);
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_num_nodes_global, d->ns_num_nodes_global);
if ( d->num_props_ns > 1 )
{
put_variable(u, NC_INT, 2,
d->num_props_ns, d->num_node_sets_global,
si.ns_prop_global, &(d->ns_prop_global[0][0]));
}
put_variable(u, NC_INT, 0,
-1, -1,
si.num_boundary_nodes, &(d->num_boundary_nodes));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_dofs_global, &(d->num_dofs_global));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_elems_global, &(d->num_elems_global));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_external_nodes, &(d->num_external_nodes));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_internal_nodes, &(d->num_internal_nodes));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_nodes_global, &(d->num_nodes_global));
put_variable(u, NC_INT, 1,
d->len_ptr_set_membership, -1,
si.ptr_set_membership, d->ptr_set_membership);
put_variable(u, NC_INT, 1,
d->len_set_membership, -1,
si.set_membership, d->set_membership);
put_variable(u, NC_INT, 1, d->num_side_sets_global, -1,
si.ss_distfact_index_global, d->ss_distfact_index_global);
put_variable(u, NC_INT, 0, -1, -1,
si.ss_distfact_len_global, &(d->ss_distfact_len_global));
if ( d->len_ss_distfact_list > 0 )
{
put_variable(u, NC_INT, 1, d->len_ss_distfact_list, -1,
si.ss_distfact_list_index_global,
d->ss_distfact_list_index_global);
}
put_variable(u, NC_INT, 1, d->num_side_sets_global, -1,
si.ss_elem_index_global, d->ss_elem_index_global);
put_variable(u, NC_INT, 0, -1, -1,
si.ss_elem_len_global, &(d->ss_elem_len_global));
if ( d->len_ss_elem_list > 0 )
{
put_variable(u, NC_INT, 1, d->len_ss_elem_list, -1,
si.ss_elem_list_index_global, d->ss_elem_list_index_global);
}
put_variable(u, NC_INT, 1,
d->num_side_sets_global, -1,
si.ss_id_global, d->ss_id_global);
if ( d->num_side_sets > 0 )
{
put_variable(u, NC_INT, 1,
d->num_side_sets, -1,
si.ss_index_global, d->ss_index_global);
}
put_variable(u, NC_INT, 1,
d->num_side_sets_global, -1,
si.ss_num_distfacts_global, d->ss_num_distfacts_global);
put_variable(u, NC_INT, 1,
d->num_side_sets_global, -1,
si.ss_num_sides_global, d->ss_num_sides_global);
if ( d->num_props_ss > 1 )
{
put_variable(u, NC_INT, 2,
d->num_props_ss, d->num_side_sets_global,
si.ss_prop_global, &(d->ss_prop_global[0][0]));
}
put_variable(u, NC_INT, 0,
-1, -1,
si.undefined_basic_eqnvar_id, &(d->undefined_basic_eqnvar_id));
if (d->num_side_sets_global > 0) {
put_variable(u, NC_INT, 1,
d->num_side_sets_global, -1,
si.ss_internal_global, d->ss_internal_global);
put_variable(u, NC_INT, 1,
d->num_side_sets_global+1, -1,
si.ss_block_index_global, d->ss_block_index_global);
put_variable(u, NC_INT, 1,
d->ss_block_index_global[d->num_side_sets_global], -1,
si.ss_block_list_global, d->ss_block_list_global);
}
/*
* Close the file (flush buffers).
*/
#ifdef NETCDF_3
err = nc_close(u);
if ( err != NC_NOERR )
{
EH(-1, "nc_close() problem.");
}
#endif
#ifdef NETCDF_2
err = ncclose(u);
EH(err, "ncclose()");
#endif
return(status);
}
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);
}
