int ex_put_block_params( int exoid,
size_t block_count,
const struct ex_block *blocks)
{
size_t i;
int conn_int_type;
int status;
int arbitrary_polyhedra = 0; /* 1 if block is arbitrary 2d polyhedra type; 2 if 3d polyhedra */
int att_name_varid = -1;
int varid, dimid, dims[2], blk_id_ndx, blk_stat, strdim;
size_t start[2];
size_t num_blk;
int cur_num_blk, numblkdim, numattrdim;
int nnodperentdim = -1;
int nedgperentdim = -1;
int nfacperentdim = -1;
int connid;
int npeid;
char errmsg[MAX_ERR_LENGTH];
char entity_type1[5];
char entity_type2[5];
int* blocks_to_define = NULL;
const char* dnumblk = NULL;
const char* vblkids = NULL;
const char* vblksta = NULL;
const char* vnodcon = NULL;
const char* vnpecnt = NULL;
const char* vedgcon = NULL;
const char* vfaccon = NULL;
const char* vconn = NULL;
const char* vattnam = NULL;
const char* vblkatt = NULL;
const char* dneblk = NULL;
const char* dnape = NULL;
const char* dnnpe = NULL;
const char* dnepe = NULL;
const char* dnfpe = NULL;
exerrval = 0; /* clear error code */
blocks_to_define = malloc(block_count*sizeof(int));
for (i=0; i < block_count; i++) {
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
dnumblk = DIM_NUM_ED_BLK;
vblkids = VAR_ID_ED_BLK;
vblksta = VAR_STAT_ED_BLK;
break;
case EX_FACE_BLOCK:
dnumblk = DIM_NUM_FA_BLK;
vblkids = VAR_ID_FA_BLK;
vblksta = VAR_STAT_FA_BLK;
break;
case EX_ELEM_BLOCK:
dnumblk = DIM_NUM_EL_BLK;
vblkids = VAR_ID_EL_BLK;
vblksta = VAR_STAT_EL_BLK;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) specified for entry %d file id %d",
blocks[i].type, (int)i, exoid );
ex_err( "ex_put_block_params", errmsg, exerrval );
free(blocks_to_define);
return (EX_FATAL);
}
/* first check if any blocks of that type are specified */
if ((status = ex_get_dimension(exoid, dnumblk, ex_name_of_object(blocks[i].type),
&num_blk, &dimid, "ex_put_block_params")) != NC_NOERR) {
sprintf(errmsg,
"Error: No %ss defined in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return EX_FATAL;
}
/* Next: Make sure that there are not any duplicate block ids by
searching the vblkids array.
WARNING: This must be done outside of define mode because id_lkup accesses
the database to determine the position
*/
if ((status = nc_inq_varid(exoid, vblkids, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return EX_FATAL;
}
ex_id_lkup(exoid,blocks[i].type,blocks[i].id); /* Error value used, but don't need return value */
if (exerrval != EX_LOOKUPFAIL) { /* found the element block id */
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: %s id %"PRId64" already exists in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
/* Keep track of the total number of element blocks defined using a counter
stored in a linked list keyed by exoid.
NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value.
*/
cur_num_blk=ex_get_file_item(exoid, ex_get_counter_list(blocks[i].type));
if (cur_num_blk >= (int)num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(blocks[i].type), (int)num_blk,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented. */
cur_num_blk=ex_inc_file_item(exoid, ex_get_counter_list(blocks[i].type));
start[0] = cur_num_blk;
/* write out block id to previously defined id array variable*/
status = nc_put_var1_longlong(exoid, varid, start, (long long*)&blocks[i].id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id to file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
blocks_to_define[i] = start[0]+1; /* element id index into vblkids array*/
if (blocks[i].num_entry == 0) /* Is this a NULL element block? */
blk_stat = 0; /* change element block status to NULL */
else
blk_stat = 1; /* change element block status to EX_EX_TRUE */
if ((status = nc_inq_varid (exoid, vblksta, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &blk_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" status to file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
}
/* put netcdf file into define mode */
if ((status=nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
for (i=0; i < block_count; i++) {
if (blocks[i].num_entry == 0) {/* Is this a NULL element block? */
continue;
}
blk_id_ndx = blocks_to_define[i];
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
dneblk = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_EBLK(blk_id_ndx);
vblkatt = VAR_EATTRIB(blk_id_ndx);
vattnam = VAR_NAME_EATTRIB(blk_id_ndx);
vnodcon = VAR_EBCONN(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_FACE_BLOCK:
dneblk = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_FBLK(blk_id_ndx);
vblkatt = VAR_FATTRIB(blk_id_ndx);
vattnam = VAR_NAME_FATTRIB(blk_id_ndx);
vnodcon = VAR_FBCONN(blk_id_ndx);
vnpecnt = VAR_FBEPEC(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_ELEM_BLOCK:
dneblk = DIM_NUM_EL_IN_BLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnepe = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnfpe = DIM_NUM_FAC_PER_EL(blk_id_ndx);
dnape = DIM_NUM_ATT_IN_BLK(blk_id_ndx);
vblkatt = VAR_ATTRIB(blk_id_ndx);
vattnam = VAR_NAME_ATTRIB(blk_id_ndx);
vnodcon = VAR_CONN(blk_id_ndx);
vnpecnt = VAR_EBEPEC(blk_id_ndx);
vedgcon = VAR_ECONN(blk_id_ndx);
vfaccon = VAR_FCONN(blk_id_ndx);
break;
default:
goto error_ret;
}
/* define some dimensions and variables*/
if ((status = nc_def_dim(exoid,dneblk,blocks[i].num_entry, &numblkdim )) != NC_NOERR) {
if (status == NC_ENAMEINUSE) { /* duplicate entry */
exerrval = status;
sprintf(errmsg,
"Error: %s %"PRId64" already defined in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of entities/block for %s %"PRId64" file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if ( dnnpe && blocks[i].num_nodes_per_entry > 0) {
/* A nfaced block would not have any nodes defined... */
if ((status = nc_def_dim(exoid,dnnpe,blocks[i].num_nodes_per_entry, &nnodperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of nodes/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (dnepe && blocks[i].num_edges_per_entry > 0 ) {
if ((status = nc_def_dim (exoid,dnepe,blocks[i].num_edges_per_entry, &nedgperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of edges/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( dnfpe && blocks[i].num_faces_per_entry > 0 ) {
if ((status = nc_def_dim(exoid,dnfpe,blocks[i].num_faces_per_entry, &nfacperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of faces/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* element attribute array */
if (blocks[i].num_attribute > 0) {
if ((status = nc_def_dim(exoid, dnape, blocks[i].num_attribute, &numattrdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of attributes in %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dims[0] = numblkdim;
dims[1] = numattrdim;
if ((status = nc_def_var(exoid, vblkatt, nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define attributes for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &strdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret;
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if ((status = nc_def_var(exoid, vattnam, NC_CHAR, 2, dims, &att_name_varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s attribute name array in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
conn_int_type = NC_INT;
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
conn_int_type = NC_INT64;
}
/* See if storing an 'nsided' element block (arbitrary 2d polyhedra or super element) */
if (strlen(blocks[i].topology) >= 3) {
if ((blocks[i].topology[0] == 'n' || blocks[i].topology[0] == 'N') &&
(blocks[i].topology[1] == 's' || blocks[i].topology[1] == 'S') &&
(blocks[i].topology[2] == 'i' || blocks[i].topology[2] == 'I'))
arbitrary_polyhedra = 1;
else if ((blocks[i].topology[0] == 'n' || blocks[i].topology[0] == 'N') &&
(blocks[i].topology[1] == 'f' || blocks[i].topology[1] == 'F') &&
(blocks[i].topology[2] == 'a' || blocks[i].topology[2] == 'A'))
/* If a FACE_BLOCK, then we are dealing with the faces of the nfaced blocks[i]. */
arbitrary_polyhedra = blocks[i].type == EX_FACE_BLOCK ? 1 : 2;
}
/* element connectivity array */
if (arbitrary_polyhedra > 0) {
if (blocks[i].type != EX_FACE_BLOCK && blocks[i].type != EX_ELEM_BLOCK) {
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) for nsided/nfaced block in file id %d",
blocks[i].type, exoid );
ex_err( "ex_put_block_params", errmsg, exerrval );
goto error_ret;
}
if (arbitrary_polyhedra == 1) {
dims[0] = nnodperentdim;
vconn = vnodcon;
/* store entity types as attribute of npeid variable -- node/elem, node/face, face/elem*/
strcpy(entity_type1, "NODE");
if (blocks[i].type == EX_ELEM_BLOCK)
strcpy(entity_type2, "ELEM");
else
strcpy(entity_type2, "FACE");
} else if (arbitrary_polyhedra == 2) {
dims[0] = nfacperentdim;
vconn = vfaccon;
/* store entity types as attribute of npeid variable -- node/elem, node/face, face/elem*/
strcpy(entity_type1, "FACE");
strcpy(entity_type2, "ELEM");
}
if ((status = nc_def_var(exoid, vconn, conn_int_type, 1, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element face-per-element or node-per-element count array */
dims[0] = numblkdim;
if ((status = nc_def_var(exoid, vnpecnt, conn_int_type, 1, dims, &npeid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create face- or node- per-entity count array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_put_att_text(exoid, npeid, "entity_type1", strlen(entity_type1)+1,
entity_type1)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store entity type attribute text for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_put_att_text(exoid, npeid, "entity_type2", strlen(entity_type2)+1,
entity_type2)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store entity type attribute text for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* "Normal" (non-polyhedra) element block type */
dims[0] = numblkdim;
dims[1] = nnodperentdim;
if ((status = nc_def_var(exoid, vnodcon, conn_int_type, 2, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, connid, 1);
}
/* store element type as attribute of connectivity variable */
if ((status = nc_put_att_text(exoid, connid, ATT_NAME_ELB, strlen(blocks[i].topology)+1,
blocks[i].topology)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s type name %s in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].topology,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if (arbitrary_polyhedra == 0) {
if (vedgcon && blocks[i].num_edges_per_entry ) {
dims[0] = numblkdim;
dims[1] = nedgperentdim;
if ((status = nc_def_var(exoid, vedgcon, conn_int_type, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create edge connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( vfaccon && blocks[i].num_faces_per_entry ) {
dims[0] = numblkdim;
dims[1] = nfacperentdim;
if ((status = nc_def_var(exoid, vfaccon, conn_int_type, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create face connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
}
free(blocks_to_define);
/* leave define mode */
if ((exerrval=nc_enddef (exoid)) != NC_NOERR) {
sprintf(errmsg,
"Error: failed to complete %s definition in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i < block_count; i++) {
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
vblkids = VAR_ID_ED_BLK;
break;
case EX_FACE_BLOCK:
vblkids = VAR_ID_FA_BLK;
break;
case EX_ELEM_BLOCK:
vblkids = VAR_ID_EL_BLK;
break;
default:
return (EX_FATAL); /* should have been handled earlier; quiet compiler here */
}
nc_inq_varid(exoid, vblkids, &att_name_varid);
if (blocks[i].num_attribute > 0 && att_name_varid >= 0) {
/* Output a dummy empty attribute name in case client code doesn't
write anything; avoids corruption in some cases.
*/
size_t count[2];
char *text = "";
size_t j;
count[0] = 1;
start[1] = 0;
count[1] = strlen(text)+1;
for (j = 0; j < blocks[i].num_attribute; j++) {
start[0] = j;
nc_put_vara_text(exoid, att_name_varid, start, count, text);
}
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
free(blocks_to_define);
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_sets (int exoid,
size_t set_count,
const struct ex_set *sets)
{
size_t i;
int needs_define = 0;
int set_stat;
int dimid, varid, status, dims[1];
int set_id_ndx;
size_t start[1];
int cur_num_sets;
char errmsg[MAX_ERR_LENGTH];
int* sets_to_define = NULL;
char* numentryptr = NULL;
char* entryptr = NULL;
char* extraptr = NULL;
char* idsptr = NULL;
char* statptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
size_t int_size;
exerrval = 0; /* clear error code */
sets_to_define = malloc(set_count*sizeof(int));
/* Note that this routine can be called:
1) just define the sets
2) just output the set data (after a previous call to define)
3) define and output the set data in one call.
*/
for (i=0; i < set_count; i++) {
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(sets[i].type), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss defined for file id %d", ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
set_id_ndx = ex_id_lkup(exoid, sets[i].type, sets[i].id);
if (exerrval != EX_LOOKUPFAIL) { /* found the side set id, so set is already defined... */
sets_to_define[i] = 0;
continue;
} else {
needs_define++;
sets_to_define[i] = 1;
}
}
if (needs_define > 0) {
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i < set_count; i++) {
if (sets_to_define[i] == 0)
continue;
/* NOTE: ex_inc_file_item finds the current number of sets defined
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(sets[i].type));
set_id_ndx = cur_num_sets + 1;
sets_to_define[i] = set_id_ndx;
if (sets[i].num_entry == 0)
continue;
/* setup pointers based on set_type */
if (sets[i].type == EX_NODE_SET) {
numentryptr = DIM_NUM_NOD_NS(set_id_ndx);
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (sets[i].type == EX_EDGE_SET) {
numentryptr = DIM_NUM_EDGE_ES(set_id_ndx);
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (sets[i].type == EX_FACE_SET) {
numentryptr = DIM_NUM_FACE_FS(set_id_ndx);
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (sets[i].type == EX_SIDE_SET) {
numentryptr = DIM_NUM_SIDE_SS(set_id_ndx);
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
else if (sets[i].type == EX_ELEM_SET) {
numentryptr = DIM_NUM_ELE_ELS(set_id_ndx);
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* define dimensions and variables */
if ((status = nc_def_dim(exoid, numentryptr,
sets[i].num_entry, &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: %s %"PRId64" -- size already defined in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
else {
sprintf(errmsg,
"Error: failed to define number of entries in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret;
}
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
int_size = sizeof(int64_t);
}
/* create variable array in which to store the entry lists */
dims[0] = dimid;
if ((status = nc_def_var(exoid, entryptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: entry list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create entry list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
if (extraptr) {
if ((status = nc_def_var(exoid, extraptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: extra list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create extra list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
}
/* Create distribution factors variable if required */
if (sets[i].num_distribution_factor > 0) {
if (sets[i].type != EX_SIDE_SET) {
/* but sets[i].num_distribution_factor must equal number of nodes */
if (sets[i].num_distribution_factor != sets[i].num_entry) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%"PRId64") not equal to # nodes (%"PRId64") in node set %"PRId64" file id %d",
sets[i].num_distribution_factor, sets[i].num_entry, sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* resuse dimid from entry lists */
if ((status = nc_def_dim(exoid, numdfptr,
sets[i].num_distribution_factor, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of dist factors in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* create variable array in which to store the set distribution factors
*/
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: dist factors list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create dist factors list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d", exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* Output the set ids and status... */
for (i=0; i < set_count; i++) {
/* setup pointers based on sets[i].type */
if (sets[i].type == EX_NODE_SET) {
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (sets[i].type == EX_EDGE_SET) {
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (sets[i].type == EX_FACE_SET) {
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (sets[i].type == EX_SIDE_SET) {
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (sets[i].type == EX_ELEM_SET) {
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
/* first: get id of set id variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* write out set id */
start[0] = sets_to_define[i]-1;
status = nc_put_var1_longlong(exoid, varid, start, (long long*)&sets[i].id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
set_stat = (sets[i].num_entry == 0) ? 0 : 1;
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d", ex_name_of_object(sets[i].type),
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &set_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s %"PRId64" status to file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
}
free(sets_to_define);
}
/* Sets are now all defined; see if any set data needs to be output... */
status = EX_NOERR;
for (i=0; i < set_count; i++) {
int stat;
if (sets[i].entry_list != NULL || sets[i].extra_list != NULL) {
/* NOTE: ex_put_set will write the warning/error message... */
stat = ex_put_set(exoid, sets[i].type, sets[i].id, sets[i].entry_list, sets[i].extra_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
if (sets[i].distribution_factor_list != NULL) {
/* NOTE: ex_put_set_dist_fact will write the warning/error message... */
stat = ex_put_set_dist_fact(exoid, sets[i].type, sets[i].id, sets[i].distribution_factor_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
}
return (status);
/* Fatal error: exit definition mode and return */
error_ret:
free(sets_to_define);
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int
cpy_var_def(int in_id,int out_id,int rec_dim_id,char *var_nm)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
int rec_dim_id: input input-file record dimension ID
char *var_nm: input variable name
int cpy_var_def(): output output-file variable ID
*/
{
/* Routine to copy the variable metadata from an input netCDF file
* to an output netCDF file.
*/
int *dim_in_id;
int *dim_out_id;
int idx;
int nbr_dim;
int var_in_id;
int var_out_id;
int temp;
extern int ncopts;
nc_type var_type;
/* See if the requested variable is already in the output file. */
temp = ncopts;
ncopts=0;
var_out_id=ncvarid(out_id,var_nm);
ncopts = temp;
if(var_out_id != -1) return var_out_id;
/* See if the requested variable is in the input file. */
var_in_id=ncvarid(in_id,var_nm);
/* Get the type of the variable and the number of dimensions. */
ncvarinq(in_id,var_in_id,(char *)NULL,&var_type,&nbr_dim,
(int *)NULL,(int *)NULL);
/* Recall:
1. The dimensions must be defined before the variable.
2. The variable must be defined before the attributes. */
/* Allocate space to hold the dimension IDs */
dim_in_id=malloc(nbr_dim*sizeof(int));
dim_out_id=malloc(nbr_dim*sizeof(int));
/* Get the dimension IDs */
ncvarinq(in_id,var_in_id,(char *)NULL,(nc_type *)NULL,
(int *)NULL,dim_in_id,(int *)NULL);
/* Get the dimension sizes and names */
for(idx=0;idx<nbr_dim;idx++){
char dim_nm[MAX_NC_NAME];
long dim_sz;
ncdiminq(in_id,dim_in_id[idx],dim_nm,&dim_sz);
/* See if the dimension has already been defined */
temp = ncopts;
ncopts = 0;
dim_out_id[idx]=ncdimid(out_id,dim_nm);
ncopts = temp;
/* If the dimension hasn't been defined, copy it */
if(dim_out_id[idx] == -1){
if(dim_in_id[idx] != rec_dim_id){
dim_out_id[idx]=ncdimdef(out_id,dim_nm,dim_sz);
}else{
dim_out_id[idx]=ncdimdef(out_id,dim_nm,NC_UNLIMITED);
} /* end else */
} /* end if */
} /* end loop over dim */
/* Define the variable in the output file */
/* If variable is float or double, define it according to the EXODUS
file's IO_word_size */
if ((var_type == NC_FLOAT) || (var_type == NC_DOUBLE)) {
var_out_id=ncvardef(out_id,var_nm,nc_flt_code(out_id),
nbr_dim,dim_out_id);
} else {
var_out_id=ncvardef(out_id,var_nm,var_type,nbr_dim,dim_out_id);
}
/* Free the space holding the dimension IDs */
(void)free(dim_in_id);
(void)free(dim_out_id);
return var_out_id;
} /* end cpy_var_def() */
/* -------------------- end of local defines -------------------- */
int ex_put_coordinate_frames( int exoid, int nframes, const int cf_ids[],
void* pt_coordinates, const char* tags)
{
int dim, dim9; /* dimension id for nframes, nframes*9 */
char errmsg[MAX_ERR_LENGTH]; /* buffer for error messages */
int exerrval; /* returned error value */
int varcoords; /* variable id for the coordinates */
int varids; /* variable id for the frame ids */
int vartags; /* variable id for the frame tags */
long int start=0; /* start value for varputs */
long int count=nframes; /* number vars to put in varput */
long int count9=nframes*9; /* ditto, but for coordinates */
int i; /* general indices */
void* pt_c=0; /* pointer to size converted array */
if ( exoid < 0 )
return exoid;
if ( nframes == 0 ) /* write nothing */
return (EX_NOERR);
if ( nframes<0 )
return 1;
assert( cf_ids!=0 );
assert( pt_coordinates !=0 );
assert( tags != 0 );
/* make the definitions */
/* go into define mode. define num_frames, num_frames9 */
if (ncredef (exoid) == -1){
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
if ( (dim=ncdimdef (exoid, NUM_CFRAMES, nframes)) == -1 ||
(dim9=ncdimdef (exoid, NUM_CFRAME9, nframes*9))== -1 ){
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of coordinate frames in file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
goto error_ret;
}
/* define the variables. coordinates, tags and ids */
if ((varcoords=ncvardef (exoid, FRAME_COORDS,
nc_flt_code(exoid), 1, &dim9)) == -1 ||
(varids=ncvardef (exoid, FRAME_IDS,NC_INT, 1, &dim)) == -1 ||
(vartags=ncvardef(exoid, FRAME_TAGS,NC_CHAR,1,&dim)) == -1 ) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define coordinate frames in file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* leave define mode */
if (ncendef (exoid) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete coordinate frame definition in file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
/* check variables consistency */
exerrval = EX_NOERR;
for (i=0;i<nframes;i++)
if ( strchr("RrCcSs",tags[i])==0 ){
sprintf(errmsg,"Warning: Unrecognized coordinate frame tag: '%c'.",
tags[i]);
exerrval=2;
ex_err(PROCNAME,errmsg,exerrval);
}
/* could also check vectors. Leave this up to the application */
/* put the variables into the file */
pt_c = ex_conv_array(exoid,RTN_ADDRESS,pt_coordinates,count9);
if ( ncvarput (exoid, vartags, &start, &count, tags) == -1 ||
ncvarput (exoid, varids, &start, &count, cf_ids) == -1 ||
ncvarput (exoid, varcoords, &start, &count9, pt_c )==-1 ){
exerrval = ncerr;
sprintf(errmsg,
"Error: failed writing frame data in file id %d",exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete frame definition for file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_elem_block (int exoid,
int elem_blk_id,
const char *elem_type,
int num_elem_this_blk,
int num_nodes_per_elem,
int num_attr)
{
int varid, dimid, dims[2], elem_blk_id_ndx, elem_blk_stat, strdim;
long start[2], num_elem_blk;
nclong ldum;
int cur_num_elem_blk, nelnoddim, numelbdim, numattrdim, connid;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
cdum = 0;
/* first check if any element blocks are specified */
if ((dimid = (ncdimid (exoid, DIM_NUM_EL_BLK))) == -1 )
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no element blocks defined in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Get number of element blocks defined for this file */
if ((ncdiminq (exoid,dimid,cdum,&num_elem_blk)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Next: Make sure that this is not a duplicate element block id by
searching the VAR_ID_EL_BLK array.
WARNING: This must be done outside of define mode because id_lkup accesses
the database to determine the position
*/
if ((varid = ncvarid (exoid, VAR_ID_EL_BLK)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element block ids in file id %d", exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
elem_blk_id_ndx = ex_id_lkup(exoid,VAR_ID_EL_BLK,elem_blk_id);
if (exerrval != EX_LOOKUPFAIL) /* found the element block id */
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: element block id %d already exists in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of element blocks defined using a counter
stored in a linked list keyed by exoid.
NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented.
*/
cur_num_elem_blk=ex_get_file_item(exoid, &eb_ctr_list);
if (cur_num_elem_blk >= num_elem_blk)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of element blocks (%ld) defined in file id %d",
num_elem_blk,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented. */
cur_num_elem_blk=ex_inc_file_item(exoid, &eb_ctr_list);
start[0] = (long)cur_num_elem_blk;
/* write out element block id to previously defined id array variable*/
ldum = (nclong)elem_blk_id;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element block id to file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
elem_blk_id_ndx = start[0]+1; /* element id index into VAR_ID_EL_BLK array*/
if (num_elem_this_blk == 0) /* Is this a NULL element block? */
elem_blk_stat = 0; /* change element block status to NULL */
else
elem_blk_stat = 1; /* change element block status to TRUE */
if ((varid = ncvarid (exoid, VAR_STAT_EL_BLK)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element block status in file id %d", exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
ldum = (nclong)elem_blk_stat;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element id %d status to file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
if (num_elem_this_blk == 0) /* Is this a NULL element block? */
{
return(EX_NOERR);
}
/*
* Check that storage required for connectivity array is less
* than 2GB which is maximum size permitted by netcdf
* (in large file mode). 1<<29 == max number of integer items.
*/
if (num_elem_this_blk * num_nodes_per_elem > (1<<29)) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Size to store connectivity for element block %d exceeds 2GB in file id %d",
elem_blk_id, exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* define some dimensions and variables*/
if ((numelbdim = ncdimdef (exoid,
DIM_NUM_EL_IN_BLK(elem_blk_id_ndx), (long)num_elem_this_blk)) == -1)
{
if (ncerr == NC_ENAMEINUSE) /* duplicate entry */
{
exerrval = ncerr;
sprintf(errmsg,
"Error: element block %d already defined in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of elements/block for block %d file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if ((nelnoddim = ncdimdef (exoid,
DIM_NUM_NOD_PER_EL(elem_blk_id_ndx), (long)num_nodes_per_elem)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of nodes/element for block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element attribute array */
if (num_attr > 0)
{
if ((numattrdim = ncdimdef (exoid,
DIM_NUM_ATT_IN_BLK(elem_blk_id_ndx), (long)num_attr)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of attributes in block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dims[0] = numelbdim;
dims[1] = numattrdim;
if ((ncvardef (exoid,
VAR_ATTRIB(elem_blk_id_ndx), nc_flt_code(exoid), 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define attributes for element block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* inquire previously defined dimensions */
if ((strdim = ncdimid (exoid, DIM_STR)) < 0) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if (ncvardef (exoid, VAR_NAME_ATTRIB(elem_blk_id_ndx), NC_CHAR, 2, dims) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define element attribute name array in file id %d",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* element connectivity array */
dims[0] = numelbdim;
dims[1] = nelnoddim;
if ((connid = ncvardef (exoid,
VAR_CONN(elem_blk_id_ndx), NC_LONG, 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create connectivity array for block %d in file id %d",
elem_blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store element type as attribute of connectivity variable */
if ((ncattput (exoid, connid, ATT_NAME_ELB, NC_CHAR, strlen(elem_type)+1,
(void*) elem_type)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element type name %s in file id %d",
elem_type,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete element block definition in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
return (EX_FATAL);
}
static int define_truth_table(ex_entity_type obj_type, int exoid, int num_ent, int num_var,
int *var_tab, int *status_tab, void_int *ids, const char *label)
{
char errmsg[MAX_ERR_LENGTH];
int k = 0;
int i, j;
int time_dim;
int dims[2];
int varid;
int status;
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);
return -1;
}
if (var_tab == NULL) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: %s variable truth table is NULL in file id %d", label,
exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
return -1;
}
for (i = 0; i < num_ent; i++) {
int64_t id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
id = ((int64_t *)ids)[i];
}
else {
id = ((int *)ids)[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_tab[i] != 0) { /* only define variable if active */
dims[0] = time_dim;
/* Determine number of entities in entity */
/* Need way to make this more generic... */
status = nc_inq_dimid(exoid, ex_dim_num_entries_in_object(obj_type, i + 1), &dims[1]);
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate number of entities in %s %" PRId64 " in file id %d",
label, id, exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
return status;
}
/* 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 variable (which is part of
* the name of the netCDF variable) will begin at 1 instead of 0
*/
status = nc_def_var(exoid, ex_name_var_of_object(obj_type, j, i + 1), nc_flt_code(exoid),
2, dims, &varid);
if (status != NC_NOERR) {
if (status != NC_ENAMEINUSE) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define %s variable for %s %" PRId64 " in file id %d",
label, label, id, exoid);
ex_err("ex_put_all_var_param_ext", errmsg, exerrval);
return status;
}
}
ex_compress_variable(exoid, varid, 2);
}
} /* if */
k++; /* increment truth table pointer */
} /* for j */
} /* for i */
return NC_NOERR;
}
/*! \internal */
int cpy_coord_def(int in_id,int out_id,int rec_dim_id,char *var_nm,
int in_large, int out_large)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
int rec_dim_id: input input-file record dimension ID
char *var_nm: input variable name
int in_large: large file setting for input file
int out_large: large file setting for output file
int cpy_var_def(): output output-file variable ID
*/
{
const char *routine = NULL;
int status;
size_t spatial_dim;
int nbr_dim;
int temp;
int dim_out_id[2];
int var_out_id = -1;
/* Handle easiest situation first: in_large matches out_large */
if (in_large == out_large) {
return cpy_var_def(in_id, out_id, rec_dim_id, var_nm);
}
/* At this point, know that in_large != out_large, so some change to
the coord variable definition is needed. Also will need the
spatial dimension, so get that now.*/
ex_get_dimension(in_id, DIM_NUM_DIM, "dimension", &spatial_dim, &temp, routine);
if (in_large == 0 && out_large == 1) {
/* output file will have coordx, coordy, coordz (if 3d). See if
they are already defined in output file. Assume either all or
none are defined. */
{
int var_out_idx, var_out_idy, var_out_idz;
int status1 = nc_inq_varid(out_id, VAR_COORD_X, &var_out_idx);
int status2 = nc_inq_varid(out_id, VAR_COORD_Y, &var_out_idy);
int status3 = nc_inq_varid(out_id, VAR_COORD_Y, &var_out_idz);
if (status1 == NC_NOERR && status2 == NC_NOERR &&
(spatial_dim == 2 || status3 == NC_NOERR)) {
return NC_NOERR; /* already defined in output file */
}
}
/* Get dimid of the num_nodes dimension in output file... */
(void)nc_inq_dimid(out_id, DIM_NUM_NODES, &dim_out_id[0]);
/* Define the variables in the output file */
/* Define according to the EXODUS file's IO_word_size */
nbr_dim = 1;
(void)nc_def_var(out_id, VAR_COORD_X, nc_flt_code(out_id), nbr_dim, dim_out_id, &var_out_id);
ex_compress_variable(out_id, var_out_id, 2);
if (spatial_dim > 1) {
(void)nc_def_var(out_id, VAR_COORD_Y, nc_flt_code(out_id), nbr_dim, dim_out_id, &var_out_id);
ex_compress_variable(out_id, var_out_id, 2);
}
if (spatial_dim > 2) {
(void)nc_def_var(out_id, VAR_COORD_Z, nc_flt_code(out_id), nbr_dim, dim_out_id, &var_out_id);
ex_compress_variable(out_id, var_out_id, 2);
}
}
if (in_large == 1 && out_large == 0) {
/* input file has coordx, coordy, coordz (if 3d); output will only
have "coord". See if is already defined in output file. */
status = nc_inq_varid(out_id, VAR_COORD, &var_out_id);
if (status == NC_NOERR)
return NC_NOERR; /* already defined in output file */
/* Get dimid of the spatial dimension and num_nodes dimensions in output file... */
(void)nc_inq_dimid(out_id, DIM_NUM_DIM, &dim_out_id[0]);
(void)nc_inq_dimid(out_id, DIM_NUM_NODES, &dim_out_id[1]);
/* Define the variable in the output file */
/* Define according to the EXODUS file's IO_word_size */
nbr_dim = 2;
(void)nc_def_var(out_id, VAR_COORD, nc_flt_code(out_id), nbr_dim, dim_out_id, &var_out_id);
}
return var_out_id;
}
/* -------------------- end of local defines -------------------- */
int ex_put_coordinate_frames( int exoid, int nframes, const int cf_ids[],
void* pt_coordinates, const char* tags)
{
int status;
int dim, dim9; /* dimension id for nframes, nframes*9 */
char errmsg[MAX_ERR_LENGTH]; /* buffer for error messages */
int varcoords; /* variable id for the coordinates */
int varids; /* variable id for the frame ids */
int vartags; /* variable id for the frame tags */
int i; /* general indices */
if ( exoid < 0 )
return exoid;
if ( nframes == 0 ) /* write nothing */
return (EX_NOERR);
if ( nframes<0 )
return 1;
assert( cf_ids!=0 );
assert( pt_coordinates !=0 );
assert( tags != 0 );
/* make the definitions */
/* go into define mode. define num_frames, num_frames9 */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to place file id %d into define mode",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_def_dim(exoid, NUM_CFRAMES, nframes, &dim)) != NC_NOERR ||
(nc_def_dim(exoid, NUM_CFRAME9, nframes*9, &dim9) != NC_NOERR)) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of coordinate frames in file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
goto error_ret;
}
/* define the variables. coordinates, tags and ids */
if (nc_def_var (exoid, FRAME_COORDS,
nc_flt_code(exoid), 1, &dim9, &varcoords) != NC_NOERR ||
(nc_def_var(exoid, FRAME_IDS,NC_INT, 1, &dim, &varids) != NC_NOERR) ||
(nc_def_var(exoid, FRAME_TAGS,NC_CHAR,1,&dim, &vartags) != NC_NOERR) ) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: failed to define coordinate frames in file id %d",
exoid);
ex_err(PROCNAME,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 coordinate frame definition in file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
/* check variables consistency */
exerrval = EX_NOERR;
for (i=0;i<nframes;i++)
if ( strchr("RrCcSs",tags[i])==0 ){
sprintf(errmsg,"Warning: Unrecognized coordinate frame tag: '%c'.",
tags[i]);
exerrval=2;
ex_err(PROCNAME,errmsg,exerrval);
}
/* could also check vectors. Leave this up to the application */
/* put the variables into the file */
if ( nc_put_var_text(exoid, vartags, tags) != NC_NOERR ||
nc_put_var_int(exoid, varids, cf_ids) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed writing frame data in file id %d",exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
if (ex_comp_ws(exoid) == 4) {
status = nc_put_var_float(exoid, varcoords, pt_coordinates);
} else {
status = nc_put_var_double(exoid, varcoords, pt_coordinates);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed writing frame data in file id %d",exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
error_ret:
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete frame definition for file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_concat_side_sets (int exoid,
const int *side_set_ids,
const int *num_elem_per_set,
const int *num_dist_per_set,
const int *side_sets_elem_index,
const int *side_sets_dist_index,
const int *side_sets_elem_list,
const int *side_sets_side_list,
const void *side_sets_dist_fact)
{
char *cdum;
int i, num_side_sets, cur_num_side_sets, dimid, varid, dims[1], *ss_stat;
int iresult;
long start[1], count[1];
nclong *lptr;
float fdum;
const float *flt_dist_fact;
const double *dbl_dist_fact;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
cdum = 0; /* initialize even though it is not used */
/* first check if any side sets are specified */
if (ncdimid (exoid, DIM_NUM_SS) == -1)
{
if (ncerr == NC_EBADDIM)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no side sets defined for file id %d", exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate side sets defined in file id %d", exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
/* inquire how many side sets are to be stored */
if (ex_inquire(exoid, EX_INQ_SIDE_SETS, &num_side_sets, &fdum, cdum) == -1)
{
sprintf(errmsg,
"Error: failed to get number of side sets defined for file id %d",
exoid);
/* use error val from inquire */
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* fill out side set status array */
/* First, allocate space for the side set status list */
if (!(ss_stat= malloc(num_side_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for side set status array in file id %d",
exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0;i<num_side_sets;i++)
{
if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */
ss_stat[i] = 0; /* change side set status to NULL */
else
ss_stat[i] = 1; /* change side set status to TRUE */
}
/* Next, get variable id of status array */
if ((varid = ncvarid (exoid, VAR_SS_STAT)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate side set status in file id %d", exoid);
ex_err("ex_put_concat_node_set",errmsg,exerrval);
return (EX_FATAL);
}
/* this contortion is necessary because netCDF is expecting nclongs; fortunately
it's necessary only when ints and nclongs aren't the same size */
start[0] = 0;
count[0] = num_side_sets;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarput (exoid, varid, start, count, ss_stat);
} else {
lptr = itol (ss_stat, num_side_sets);
iresult = ncvarput (exoid, varid, start, count, lptr);
free(lptr);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store side set status array to file id %d",
exoid);
ex_err("ex_put_concat_side_set",errmsg,exerrval);
return (EX_FATAL);
}
free(ss_stat);
/* put netcdf 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_concat_side_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* create side set definitions */
for (i=0; i<num_side_sets; i++)
{
/* Keep track of the total number of side sets defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of side sets
for a specific file and returns that value.
*/
cur_num_side_sets=ex_get_file_item(exoid, &ss_ctr_list );
if (cur_num_side_sets >= num_side_sets)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of side sets (%d) defined in file id %d",
num_side_sets,exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
goto error_ret;
}
/* NOTE: ex_inc_file_item is used to find the number of side sets
for a specific file and returns that value incremented. */
cur_num_side_sets=ex_inc_file_item(exoid, &ss_ctr_list );
/* define dimension for number of sides/elements per side set */
if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */
continue; /* Do not create anything for NULL side sets! */
if ((dimid = ncdimdef (exoid, DIM_NUM_SIDE_SS(cur_num_side_sets+1),
(long)num_elem_per_set[i])) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: side set side count %d already defined in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of sides for set %d in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
goto error_ret;
}
/* create element list variable for side set */
dims[0] = dimid;
if (ncvardef (exoid,VAR_ELEM_SS(cur_num_side_sets+1),NC_LONG,1,dims) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: element list already exists for side set %d in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create element list for side set %d in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
/* create side list variable for side set */
if (ncvardef (exoid,VAR_SIDE_SS(cur_num_side_sets+1),NC_LONG,1,dims) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: side list already exists for side set %d in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create side list for side set %d in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
/* define dimension for number of dist factors/nodes per side set */
/* NOTE: only define df count if the dist factors exist! */
if (num_dist_per_set[i] > 0)
{
if ((dimid = ncdimdef (exoid, DIM_NUM_DF_SS(cur_num_side_sets+1),
(long)num_dist_per_set[i])) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: side set df count %d already defined in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define side set df count for set %d in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
goto error_ret;
}
/* create distribution factor list variable for side set */
dims[0] = dimid;
if (ncvardef (exoid, VAR_FACT_SS(cur_num_side_sets+1),
nc_flt_code(exoid), 1, dims) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: dist factor list already exists for side set %d in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create dist factor list for side set %d in file id %d",
side_set_ids[i],exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
} /* end define dist factors */
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete definition in file id %d",
exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* Next, fill out side set ids array */
/* first get id of side set ids array variable */
if ((varid = ncvarid (exoid, VAR_SS_IDS)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate side set ids array in file id %d",
exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out side set id list */
/* this contortion is necessary because netCDF is expecting nclongs; fortunately
it's necessary only when ints and nclongs aren't the same size */
start[0] = 0;
count[0] = num_side_sets;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarput (exoid, varid, start, count, side_set_ids);
} else {
lptr = itol (side_set_ids, num_side_sets);
iresult = ncvarput (exoid, varid, start, count, lptr);
free(lptr);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store side set id array in file id %d",
exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* If the side_sets_elem_index is passed in as a NULL pointer, then
* the user only wants us to define the sidesets and not populate
* the data structures.
*/
if (side_sets_elem_index == 0)
return(EX_NOERR);
/* Now, use ExodusII call to store side sets */
for (i=0; i<num_side_sets; i++)
{
if (num_elem_per_set[i] == 0) /* Is this a NULL side set? */
continue; /* Do not create anything for NULL side sets! */
if (ex_comp_ws(exoid) == sizeof(float))
{
flt_dist_fact = side_sets_dist_fact;
if (ex_put_side_set(exoid, side_set_ids[i],
&(side_sets_elem_list[side_sets_elem_index[i]]),
&(side_sets_side_list[side_sets_elem_index[i]])) == -1)
return(EX_FATAL); /* error will be reported by subroutine */
if (num_dist_per_set[i] > 0) /* store dist factors if required */
{
if (ex_put_side_set_dist_fact(exoid, side_set_ids[i],
&(flt_dist_fact[side_sets_dist_index[i]])) == -1)
{
sprintf(errmsg,
"Error: failed to store side set %d dist factors for file id %d",
side_set_ids[i],exoid);
/* use error val from exodusII routine */
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
return (EX_FATAL);
}
}
}
else if (ex_comp_ws(exoid) == sizeof(double))
{
dbl_dist_fact = side_sets_dist_fact;
if (ex_put_side_set(exoid, side_set_ids[i],
&(side_sets_elem_list[side_sets_elem_index[i]]),
&(side_sets_side_list[side_sets_elem_index[i]])) == -1)
return(EX_FATAL); /* error will be reported by subroutine */
if (num_dist_per_set[i] > 0) /* only store if they exist */
{
if (ex_put_side_set_dist_fact(exoid, side_set_ids[i],
&(dbl_dist_fact[side_sets_dist_index[i]])) == -1)
{
sprintf(errmsg,
"Error: failed to store side set %d dist factors for file id %d",
side_set_ids[i],exoid);
/* use error val from exodusII routine */
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
return (EX_FATAL);
}
}
}
else
{
/* unknown floating point word size */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: unsupported floating point word size %d for file id %d",
ex_comp_ws(exoid), exoid);
ex_err("ex_put_concat_side_sets", errmsg, exerrval);
return (EX_FATAL);
}
}
return(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_concat_side_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_create_int (const char *path,
int cmode,
int *comp_ws,
int *io_ws,
int run_version)
{
int exoid, time_dim, dims[1];
int status;
int dimid;
int old_fill;
int lio_ws;
int filesiz;
float vers;
char errmsg[MAX_ERR_LENGTH];
char *mode_name;
int mode = 0;
#if defined(NC_NETCDF4)
static int netcdf4_mode = -1;
char *option;
#endif /* NC_NETCDF4 */
exerrval = 0; /* clear error code */
if (run_version != EX_API_VERS_NODOT) {
int run_version_major = run_version / 100;
int run_version_minor = run_version % 100;
int lib_version_major = EX_API_VERS_NODOT / 100;
int lib_version_minor = EX_API_VERS_NODOT % 100;
fprintf(stderr, "EXODUSII: Warning: This code was compiled with exodusII version %d.%02d,\n but was linked with exodusII library version %d.%02d\n This is probably an error in the build process of this code.\n",
run_version_major, run_version_minor, lib_version_major, lib_version_minor);
}
#if defined(NC_NETCDF4)
if (cmode & EX_NETCDF4) {
mode |= (NC_NETCDF4|NC_CLASSIC_MODEL);
} else {
if (netcdf4_mode == -1) {
option = getenv("EXODUS_NETCDF4");
if (option != NULL) {
fprintf(stderr, "EXODUSII: Using netcdf version 4 selected via EXODUS_NETCDF4 environment variable\n");
netcdf4_mode = NC_NETCDF4|NC_CLASSIC_MODEL;
} else {
netcdf4_mode = 0;
}
}
mode |= netcdf4_mode;
}
#endif
/*
* See if "large file" mode was specified in a ex_create cmode. If
* so, then pass the NC_64BIT_OFFSET flag down to netcdf.
* If netcdf4 mode specified, don't use NC_64BIT_OFFSET mode.
*/
if ( (cmode & EX_LARGE_MODEL) && (cmode & EX_NORMAL_MODEL)) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: conflicting mode specification for file %s, mode %d. Using normal",
path, cmode);
ex_err("ex_create",errmsg,exerrval);
}
if ((cmode & EX_NORMAL_MODEL) != 0)
filesiz = 0;
#if defined(NC_NETCDF4)
else if ((mode & NC_NETCDF4) != 0)
filesiz = 1;
#endif
else
filesiz = (int)(((cmode & EX_LARGE_MODEL) != 0) || (ex_large_model(-1) == 1));
if (
#if defined(NC_NETCDF4)
!(mode & NC_NETCDF4) &&
#endif
filesiz == 1) {
mode |= NC_64BIT_OFFSET;
}
if (cmode & EX_SHARE) {
mode |= NC_SHARE;
}
/*
* set error handling mode to no messages, non-fatal errors
*/
ex_opts(exoptval); /* call required to set ncopts first time through */
if (cmode & EX_CLOBBER) {
mode |= NC_CLOBBER;
mode_name = "CLOBBER";
} else {
mode |= NC_NOCLOBBER;
mode_name = "NOCLOBBER";
}
if ((status = nc_create (path, mode, &exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: file create failed for %s, mode: %s",
path, mode_name);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* turn off automatic filling of netCDF variables
*/
if ((status = nc_set_fill (exoid, NC_NOFILL, &old_fill)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to set nofill mode in file id %d",
exoid);
ex_err("ex_create", errmsg, exerrval);
return (EX_FATAL);
}
/* initialize floating point size conversion. since creating new file,
* i/o wordsize attribute from file is zero.
*/
if (ex_conv_ini( exoid, comp_ws, io_ws, 0 ) != EX_NOERR) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: failed to init conversion routines in file id %d",
exoid);
ex_err("ex_create", errmsg, exerrval);
return (EX_FATAL);
}
/* put the EXODUS version number, and i/o floating point word size as
* netcdf global attributes
*/
/* store Exodus API version # as an attribute */
vers = EX_API_VERS;
if ((status=nc_put_att_float(exoid, NC_GLOBAL, ATT_API_VERSION,
NC_FLOAT, 1, &vers)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store Exodus II API version attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file version # as an attribute */
vers = EX_VERS;
if ((status=nc_put_att_float(exoid, NC_GLOBAL, ATT_VERSION, NC_FLOAT, 1, &vers)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store Exodus II file version attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file float word size as an attribute */
lio_ws = (int)(*io_ws);
if ((status=nc_put_att_int (exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, NC_INT, 1, &lio_ws)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store Exodus II file float word size attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file size (1=large, 0=normal) as an attribute */
if ((status = nc_put_att_int (exoid, NC_GLOBAL, ATT_FILESIZE, NC_INT, 1, &filesiz)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store Exodus II file size attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* define some dimensions and variables
*/
/* create string length dimension */
if ((status=nc_def_dim (exoid, DIM_STR, (MAX_STR_LENGTH+1), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define string length in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* create line length dimension */
if ((status = nc_def_dim(exoid, DIM_LIN, (MAX_LINE_LENGTH+1), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define line length in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* create number "4" dimension; must be of type long */
if ((status = nc_def_dim(exoid, DIM_N4, 4L, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number \"4\" dimension in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_def_dim(exoid, DIM_TIME, NC_UNLIMITED, &time_dim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define time dimension in file id %d", exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
dims[0] = time_dim;
if ((status = nc_def_var(exoid, VAR_WHOLE_TIME, nc_flt_code(exoid), 1, dims, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define whole time step variable in file id %d",
exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition for file id %d", exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
return (exoid);
}
int ex_put_concat_sets (int exoid,
ex_entity_type set_type,
const struct ex_set_specs* set_specs)
{
int status;
int temp;
const void_int *num_entries_per_set = set_specs->num_entries_per_set;
const void_int *num_dist_per_set = set_specs->num_dist_per_set;
const void_int *sets_entry_index = set_specs->sets_entry_index;
const void_int *sets_dist_index = set_specs->sets_dist_index;
const void *sets_dist_fact = set_specs->sets_dist_fact;
size_t i, num_df, num_entry;
int cur_num_sets, num_sets;
int dimid, varid, set_id_ndx, dims[1];
int *set_stat = NULL;
int set_int_type, int_size;
const float *flt_dist_fact = NULL;
const double *dbl_dist_fact = NULL;
char errmsg[MAX_ERR_LENGTH];
char* idsptr = NULL;
char* statptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
char* elemptr = NULL;
char* extraptr = NULL;
ex_inquiry ex_inq_val;
exerrval = 0; /* clear error code */
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int_size = sizeof(int64_t);
}
/* setup pointers based on set_type
NOTE: there is another block that sets more stuff later ... */
if (set_type == EX_NODE_SET) {
ex_inq_val = EX_INQ_NODE_SETS;
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (set_type == EX_EDGE_SET) {
ex_inq_val = EX_INQ_EDGE_SETS;
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (set_type == EX_FACE_SET) {
ex_inq_val = EX_INQ_FACE_SETS;
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (set_type == EX_SIDE_SET) {
ex_inq_val = EX_INQ_SIDE_SETS;
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (set_type == EX_ELEM_SET) {
ex_inq_val = EX_INQ_ELEM_SETS;
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
else {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: invalid set type (%d)", set_type);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &temp)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss defined for file id %d", ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
/* inquire how many sets are to be stored */
num_sets = ex_inquire_int(exoid, ex_inq_val);
if (num_sets < 0) {
sprintf(errmsg,
"Error: failed to get number of %ss defined for file id %d",
ex_name_of_object(set_type), exoid);
/* use error val from inquire */
ex_err("ex_put_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* Fill out set status array */
/* First, allocate space for the status list */
if (!(set_stat= malloc(num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for %s status array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
return (EX_FATAL);
}
if (int_size == sizeof(int64_t)) {
for (i=0;i<num_sets;i++) {
set_stat[i] = (((int64_t*)num_entries_per_set)[i] == 0) ? 0 : 1;
}
} else {
for (i=0;i<num_sets;i++) {
set_stat[i] = (((int*)num_entries_per_set)[i] == 0) ? 0 : 1;
}
}
/* Next, get variable id of status array */
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
status = nc_put_var_int(exoid, varid, set_stat);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s status array to file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_set",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* create set definitions */
for (i=0; i<num_sets; i++) {
int64_t set_id;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
set_id = ((int64_t*)set_specs->sets_ids)[i];
} else {
set_id = ((int*)set_specs->sets_ids)[i];
}
/* Keep track of the total number of sets defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of sets of type
for a specific file and returns that value.
*/
cur_num_sets=ex_get_file_item(exoid, ex_get_counter_list(set_type));
if (cur_num_sets >= num_sets) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(set_type), num_sets,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
goto error_ret;
}
/* NOTE: ex_inc_file_item is used to find the number of sets
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(set_type));
set_id_ndx = cur_num_sets + 1;
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
elemptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
elemptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
elemptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
elemptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
elemptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* define dimension for number of entries per set */
if (set_stat[i] == 0) /* Is this a NULL set? */
continue; /* Do not create anything for NULL sets! */
if (int_size == sizeof(int)) {
status = nc_def_dim(exoid, ex_dim_num_entries_in_object(set_type, set_id_ndx),
((int*)num_entries_per_set)[i], &dimid);
} else {
status = nc_def_dim(exoid, ex_dim_num_entries_in_object(set_type, set_id_ndx),
((int64_t*)num_entries_per_set)[i], &dimid);
}
if (status != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: %s entry count %"PRId64" already defined in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of entries for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret;
}
/* create element list variable for set */
set_int_type = NC_INT;
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
set_int_type = NC_INT64;
}
dims[0] = dimid;
if ((status = nc_def_var(exoid,elemptr,set_int_type,1,dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: element list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create element list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 1);
/* create extra list variable for set (only for edge, face and side sets) */
if (extraptr) {
if ((status = nc_def_var(exoid,extraptr,set_int_type,1,dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: extra list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create extra list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 1);
}
/* define dimension for number of dist factors per set */
/* NOTE: only define df count if the dist factors exist! */
if (int_size == sizeof(int64_t)) {
num_df = ((int64_t*)num_dist_per_set)[i];
num_entry = ((int64_t*)num_entries_per_set)[i];
} else {
num_df = ((int*)num_dist_per_set)[i];
num_entry = ((int*)num_entries_per_set)[i];
}
if (num_df > 0) {
if (set_type == EX_NODE_SET) {
if (num_df != num_entry) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%"ST_ZU") not equal to # nodes (%"ST_ZU") in node set %"PRId64" file id %d",
num_df, num_entry, set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* resuse dimid from entry lists */
} else {
if ((status = nc_def_dim(exoid, numdfptr,
num_df, &dimid)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: %s df count %"PRId64" already defined in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s df count for set %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret;
}
}
/* create distribution factor list variable for set */
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &temp)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: dist factor list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to create dist factor list for %s %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 2);
} /* end define dist factors */
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* Next, fill out set ids array */
/* first get id of set ids array variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* then, write out set id list */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, varid, set_specs->sets_ids);
} else {
status = nc_put_var_int(exoid, varid, set_specs->sets_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id array in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
/* If the sets_entry_index is passed in as a NULL pointer, then
* the user only wants us to define the sets and not populate
* the data structures.
*/
if (sets_entry_index == 0) {
ex_safe_free(set_stat);
return(EX_NOERR);
}
/* Now, use ExodusII call to store sets */
for (i=0; i<num_sets; i++) {
int64_t set_id;
size_t df_ndx;
if (set_stat[i] == 0) /* Is this a NULL set? */
continue; /* Do not create anything for NULL sets! */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
set_id = ((int64_t*)set_specs->sets_ids)[i];
} else {
set_id = ((int*)set_specs->sets_ids)[i];
}
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
int64_t* extra_list = NULL;
/* set extra list */
if (set_type == EX_EDGE_SET || set_type == EX_FACE_SET || set_type == EX_SIDE_SET)
extra_list = &(((int64_t*)set_specs->sets_extra_list)[((int64_t*)sets_entry_index)[i]]);
status = ex_put_set(exoid, set_type, set_id,
&(((int64_t*)set_specs->sets_entry_list)[((int64_t*)sets_entry_index)[i]]),
extra_list);
} else {
int* extra_list = NULL;
/* set extra list */
if (set_type == EX_EDGE_SET || set_type == EX_FACE_SET || set_type == EX_SIDE_SET)
extra_list = &(((int*)set_specs->sets_extra_list)[((int*)sets_entry_index)[i]]);
status = ex_put_set(exoid, set_type, set_id,
&(((int*)set_specs->sets_entry_list)[((int*)sets_entry_index)[i]]),
extra_list);
}
if (status != NC_NOERR) {
ex_safe_free(set_stat);
return(EX_FATAL); /* error will be reported by subroutine */
}
if (int_size == sizeof(int)) {
num_df = ((int*)num_dist_per_set)[i];
df_ndx = ((int*)sets_dist_index)[i];
} else {
num_df = ((int64_t*)num_dist_per_set)[i];
df_ndx = ((int64_t*)sets_dist_index)[i];
}
if (ex_comp_ws(exoid) == sizeof(float)) {
flt_dist_fact = sets_dist_fact;
if (num_df > 0) { /* store dist factors if required */
if (ex_put_set_dist_fact(exoid, set_type, set_id,
&(flt_dist_fact[df_ndx])) == -1) {
sprintf(errmsg,
"Error: failed to store %s %"PRId64" dist factors for file id %d",
ex_name_of_object(set_type), set_id,exoid);
/* use error val from exodusII routine */
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
} else if (ex_comp_ws(exoid) == sizeof(double)) {
dbl_dist_fact = sets_dist_fact;
if (num_df) { /* only store if they exist */
if (ex_put_set_dist_fact(exoid, set_type, set_id,
&(dbl_dist_fact[df_ndx])) == -1) {
sprintf(errmsg,
"Error: failed to store %s %"PRId64" dist factors for file id %d",
ex_name_of_object(set_type), set_id,exoid);
/* use error val from exodusII routine */
ex_err("ex_put_concat_sets",errmsg,exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
} else {
/* unknown floating point word size */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: unsupported floating point word size %d for file id %d",
ex_comp_ws(exoid), exoid);
ex_err("ex_put_concat_sets", errmsg, exerrval);
ex_safe_free(set_stat);
return (EX_FATAL);
}
}
ex_safe_free(set_stat);
return(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
ex_safe_free(set_stat);
if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_concat_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_variable_param (int exoid,
ex_entity_type obj_type,
int num_vars)
{
int time_dim, num_nod_dim, dimid, strdim, varid;
int dims[3];
char errmsg[MAX_ERR_LENGTH];
int status;
exerrval = 0; /* clear error code */
/* if no variables are to be stored, return with warning */
if (num_vars == 0) {
exerrval = EX_MSG;
sprintf(errmsg,
"Warning: zero %s variables specified for file id %d",
ex_name_of_object(obj_type),exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
return (EX_WARN);
}
if ( obj_type != EX_NODAL &&
obj_type != EX_NODE_SET &&
obj_type != EX_EDGE_BLOCK &&
obj_type != EX_EDGE_SET &&
obj_type != EX_FACE_BLOCK &&
obj_type != EX_FACE_SET &&
obj_type != EX_ELEM_BLOCK &&
obj_type != EX_ELEM_SET &&
obj_type != EX_SIDE_SET &&
obj_type != EX_GLOBAL) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %d specified in file id %d",
obj_type, exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
return (EX_WARN);
}
/* inquire previously defined dimensions */
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_variable_param",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimid (exoid, DIM_NUM_NODES, &num_nod_dim)) != NC_NOERR) {
if (obj_type == EX_NODAL) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in file id %d", exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
return (EX_FATAL);
}
}
if ((status = nc_inq_dimid (exoid, DIM_STR, &strdim)) < 0) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
return (EX_FATAL);
}
/* 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_get_var_param",errmsg,exerrval);
return (EX_FATAL);
}
/* define dimensions and variables */
if (obj_type == EX_GLOBAL) {
EX_PREPARE_RESULT_VAR("global",DIM_NUM_GLO_VAR,VAR_NAME_GLO_VAR);
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;
sprintf(errmsg,
"Error: failed to define global variables in file id %d",
exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
else if (obj_type == EX_NODAL) {
/*
* 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 ((status = nc_def_dim(exoid, DIM_NUM_NOD_VAR, num_vars, &dimid)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: nodal variable name parameters are already defined in file id %d",
exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of nodal variables in file id %d",
exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
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;
sprintf(errmsg,
"Error: failed to define nodal variables in file id %d",
exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else { /* New way */
int i;
for (i = 1; i <= num_vars; 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;
sprintf(errmsg,
"Error: failed to define nodal variable %d in file id %d",
i, exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
/* Now define nodal variable name variable */
dims[0] = dimid;
dims[1] = strdim;
if ((status = nc_def_var(exoid, VAR_NAME_NOD_VAR, NC_CHAR, 2, dims, &varid)) != NC_NOERR) {
if (status == NC_ENAMEINUSE) {
exerrval = status;
sprintf(errmsg,
"Error: nodal variable names are already defined in file id %d",
exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define nodal variable names in file id %d",
exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
}
/* netCDF variables in which to store the EXODUS obj_type variable values will
* be defined in ex_put_*_var_tab or ex_put_*_var; at this point, we
* don't know what obj_type variables are valid for which obj_type blocks
* (the info that is stored in the obj_type variable truth table)
*/
else if (obj_type == EX_ELEM_BLOCK) {
EX_PREPARE_RESULT_VAR("element",DIM_NUM_ELE_VAR,VAR_NAME_ELE_VAR);
}
else if (obj_type == EX_NODE_SET) {
EX_PREPARE_RESULT_VAR("nodeset",DIM_NUM_NSET_VAR,VAR_NAME_NSET_VAR);
}
else if (obj_type == EX_SIDE_SET) {
EX_PREPARE_RESULT_VAR("sideset",DIM_NUM_SSET_VAR,VAR_NAME_SSET_VAR);
}
else if (obj_type == EX_EDGE_BLOCK) {
EX_PREPARE_RESULT_VAR("edge",DIM_NUM_EDG_VAR,VAR_NAME_EDG_VAR);
}
else if (obj_type == EX_FACE_BLOCK) {
EX_PREPARE_RESULT_VAR("face",DIM_NUM_FAC_VAR,VAR_NAME_FAC_VAR);
}
else if (obj_type == EX_EDGE_SET) {
EX_PREPARE_RESULT_VAR("edgeset",DIM_NUM_ESET_VAR,VAR_NAME_ESET_VAR);
}
else if (obj_type == EX_FACE_SET) {
EX_PREPARE_RESULT_VAR("faceset",DIM_NUM_FSET_VAR,VAR_NAME_FSET_VAR);
}
else if (obj_type == EX_ELEM_SET) {
EX_PREPARE_RESULT_VAR("elementset",DIM_NUM_ELSET_VAR,VAR_NAME_ELSET_VAR);
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d",
exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if ((status = nc_enddef(exoid)) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_variable_param",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_init_ext (int exoid,
const ex_init_params *model)
{
int numdimdim, numnoddim, elblkdim, edblkdim, fablkdim, esetdim,
fsetdim, elsetdim, nsetdim, ssetdim, dim_str_name, dim[2], temp;
int nmapdim,edmapdim,famapdim,emapdim,timedim;
int status;
int title_len;
#if 0
/* used for header size calculations which are turned off for now */
int header_size, fixed_var_size, iows;
#endif
char errmsg[MAX_ERR_LENGTH];
int rootid = exoid & EX_FILE_ID_MASK;
exerrval = 0; /* clear error code */
if (rootid == exoid && nc_inq_dimid (exoid, DIM_NUM_DIM, &temp) == NC_NOERR)
{
exerrval = EX_MSG;
sprintf(errmsg,
"Error: initialization already done for file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
return (EX_FATAL);
}
/* 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_init_ext",errmsg,exerrval);
return (EX_FATAL);
}
/* define some attributes... */
title_len = strlen(model->title) < MAX_LINE_LENGTH ? strlen(model->title) : MAX_LINE_LENGTH;
if ((status = nc_put_att_text(rootid, NC_GLOBAL, (const char*)ATT_TITLE,
title_len+1, model->title)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define model->title attribute to file id %d", rootid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* ...and some dimensions... */
/* create name string length dimension */
if (nc_inq_dimid (rootid, DIM_STR_NAME, &dim_str_name) != NC_NOERR) {
int max_name = ex_inquire_int(exoid, EX_INQ_MAX_READ_NAME_LENGTH);
if (max_name < ex_default_max_name_length) { max_name = ex_default_max_name_length;
}
if ((status=nc_def_dim (rootid, DIM_STR_NAME, max_name+1, &dim_str_name)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define name string length in file id %d",rootid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret;
}
}
if ((status = nc_def_dim(exoid, DIM_TIME, NC_UNLIMITED, &timedim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define time dimension in file id %d", exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
dim[0] = timedim;
if ((status = nc_def_var(exoid, VAR_WHOLE_TIME, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define whole time step variable in file id %d",
exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
ex_compress_variable(exoid, temp, 2);
if ((status = nc_def_dim(exoid, DIM_NUM_DIM, model->num_dim, &numdimdim)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of dimensions in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/*
* Need to handle "empty file" that may be the result of a strange
* load balance or some other strange run. Note that if num_node
* == 0, then model->num_elem must be zero since you cannot have elements
* with no nodes. It *is* permissible to have zero elements with
* non-zero node count.
*/
if (model->num_nodes > 0) {
if ((status = nc_def_dim(exoid, DIM_NUM_NODES, model->num_nodes, &numnoddim)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of nodes in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (model->num_elem > 0) {
if (model->num_nodes <= 0) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: Cannot have non-zero element count if node count is zero.in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_def_dim(exoid, DIM_NUM_ELEM, model->num_elem, &temp)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of elements in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (model->num_edge > 0) {
if (model->num_nodes <= 0) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: Cannot have non-zero edge count if node count is zero.in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_def_dim(exoid, DIM_NUM_EDGE, model->num_edge, &temp)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of edges in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (model->num_face > 0) {
if (model->num_nodes <= 0) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: Cannot have non-zero face count if node count is zero.in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_def_dim(exoid, DIM_NUM_FACE, model->num_face, &temp)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of faces in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (ex_write_object_params(exoid, "element block", DIM_NUM_EL_BLK, VAR_STAT_EL_BLK, VAR_ID_EL_BLK, model->num_elem_blk, &elblkdim)) { goto error_ret;
}
if (ex_write_object_params(exoid, "edge block", DIM_NUM_ED_BLK, VAR_STAT_ED_BLK, VAR_ID_ED_BLK, model->num_edge_blk, &edblkdim)) { goto error_ret;
}
if (ex_write_object_params(exoid, "face block", DIM_NUM_FA_BLK, VAR_STAT_FA_BLK, VAR_ID_FA_BLK, model->num_face_blk, &fablkdim)) { goto error_ret;
}
if (ex_write_object_params(exoid, "node set", DIM_NUM_NS, VAR_NS_STAT, VAR_NS_IDS, model->num_node_sets, &nsetdim)) { goto error_ret;
}
if (ex_write_object_params(exoid, "edge set", DIM_NUM_ES, VAR_ES_STAT, VAR_ES_IDS, model->num_edge_sets, &esetdim)) { goto error_ret;
}
if (ex_write_object_params(exoid, "face set", DIM_NUM_FS, VAR_FS_STAT, VAR_FS_IDS, model->num_face_sets, &fsetdim)) { goto error_ret;
}
if (ex_write_object_params(exoid, "side set", DIM_NUM_SS, VAR_SS_STAT, VAR_SS_IDS, model->num_side_sets, &ssetdim)) { goto error_ret;
}
if (ex_write_object_params(exoid, "elem set", DIM_NUM_ELS, VAR_ELS_STAT, VAR_ELS_IDS, model->num_elem_sets, &elsetdim)) { goto error_ret;
}
if (ex_write_map_params(exoid, "node map", DIM_NUM_NM, VAR_NM_PROP(1), model->num_node_maps, &nmapdim) != NC_NOERR) { goto error_ret;
}
if (ex_write_map_params(exoid, "edge map", DIM_NUM_EDM, VAR_EDM_PROP(1), model->num_edge_maps, &edmapdim) != NC_NOERR) { goto error_ret;
}
if (ex_write_map_params(exoid, "face map", DIM_NUM_FAM, VAR_FAM_PROP(1), model->num_face_maps, &famapdim) != NC_NOERR) { goto error_ret;
}
if (ex_write_map_params(exoid, "element map", DIM_NUM_EM, VAR_EM_PROP(1), model->num_elem_maps, &emapdim) != NC_NOERR) { goto error_ret;
}
/*
* To reduce the maximum dataset sizes, the storage of the nodal
* coordinates and the nodal variables was changed from a single
* dataset to a dataset per component or variable. However, we
* want to maintain some form of compatability with the old
* exodusII version. It is easy to do this on read; however, we
* also want to be able to store in the old format using the new
* library.
*
* The mode is set in the ex_create call. The setting can be checked
* via the ATT_FILESIZE attribute in the file (1=large,
* 0=normal). Also handle old files that do not contain this
* attribute.
*/
if (model->num_nodes > 0) {
if (ex_large_model(exoid) == 1) {
/* node coordinate arrays -- separate storage... */
dim[0] = numnoddim;
if (model->num_dim > 0) {
if ((status = nc_def_var (exoid, VAR_COORD_X, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define node x coordinate array in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 2);
}
if (model->num_dim > 1) {
if ((status = nc_def_var(exoid, VAR_COORD_Y, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define node y coordinate array in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 2);
}
if (model->num_dim > 2) {
if ((status = nc_def_var(exoid, VAR_COORD_Z, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define node z coordinate array in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 2);
}
} else {
/* node coordinate arrays: -- all stored together (old method) */
dim[0] = numdimdim;
dim[1] = numnoddim;
if ((status = nc_def_var(exoid, VAR_COORD, nc_flt_code(exoid), 2, dim, &temp)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to define node coordinate array in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
if (ex_write_object_names(exoid, "element block",VAR_NAME_EL_BLK,elblkdim, dim_str_name, model->num_elem_blk) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "edge block", VAR_NAME_ED_BLK,edblkdim, dim_str_name, model->num_edge_blk) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "face block", VAR_NAME_FA_BLK,fablkdim, dim_str_name, model->num_face_blk) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "node set", VAR_NAME_NS, nsetdim, dim_str_name, model->num_node_sets) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "edge set", VAR_NAME_ES, esetdim, dim_str_name, model->num_edge_sets) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "face set", VAR_NAME_FS, fsetdim, dim_str_name, model->num_face_sets) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "side set", VAR_NAME_SS, ssetdim, dim_str_name, model->num_side_sets) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "element set", VAR_NAME_ELS, elsetdim, dim_str_name, model->num_elem_sets) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "node map", VAR_NAME_NM, nmapdim, dim_str_name, model->num_node_maps) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "edge map", VAR_NAME_EDM, edmapdim, dim_str_name, model->num_edge_maps) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "face map", VAR_NAME_FAM, famapdim, dim_str_name, model->num_face_maps) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "element map", VAR_NAME_EM, emapdim, dim_str_name, model->num_elem_maps) != NC_NOERR) { goto error_ret;
}
if (ex_write_object_names(exoid, "coordinate", VAR_NAME_COOR, numdimdim,dim_str_name, model->num_dim) != NC_NOERR) { goto error_ret;
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete variable definitions in file id %d",exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
return (EX_FATAL);
}
/* Fill the id and status arrays with EX_INVALID_ID */
{
int *invalid_ids = NULL;
int maxset = model->num_elem_blk;
if (maxset < model->num_edge_blk) { maxset = model->num_edge_blk;
}
if (maxset < model->num_face_blk) { maxset = model->num_face_blk;
}
if (maxset < model->num_node_sets) { maxset = model->num_node_sets;
}
if (maxset < model->num_edge_sets) { maxset = model->num_edge_sets;
}
if (maxset < model->num_face_sets) { maxset = model->num_face_sets;
}
if (maxset < model->num_side_sets) { maxset = model->num_side_sets;
}
if (maxset < model->num_elem_sets) { maxset = model->num_elem_sets;
}
if (maxset < model->num_node_maps) { maxset = model->num_node_maps;
}
if (maxset < model->num_edge_maps) { maxset = model->num_edge_maps;
}
if (maxset < model->num_face_maps) { maxset = model->num_face_maps;
}
if (maxset < model->num_elem_maps) { maxset = model->num_elem_maps;
}
/* allocate space for id/status array */
if (!(invalid_ids = malloc(maxset*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for id/status array for file id %d", exoid);
ex_err("ex_put_init_ext",errmsg,exerrval);
return (EX_FATAL);
}
invalidate_id_status(exoid, VAR_STAT_EL_BLK, VAR_ID_EL_BLK,
model->num_elem_blk, invalid_ids);
invalidate_id_status(exoid, VAR_STAT_ED_BLK, VAR_ID_ED_BLK,
model->num_edge_blk, invalid_ids);
invalidate_id_status(exoid, VAR_STAT_FA_BLK, VAR_ID_FA_BLK,
model->num_face_blk, invalid_ids);
invalidate_id_status(exoid, VAR_NS_STAT, VAR_NS_IDS,
model->num_node_sets, invalid_ids);
invalidate_id_status(exoid, VAR_ES_STAT, VAR_ES_IDS,
model->num_edge_sets, invalid_ids);
invalidate_id_status(exoid, VAR_FS_STAT, VAR_FS_IDS,
model->num_face_sets, invalid_ids);
invalidate_id_status(exoid, VAR_SS_STAT, VAR_SS_IDS,
model->num_side_sets, invalid_ids);
invalidate_id_status(exoid, VAR_ELS_STAT, VAR_ELS_IDS,
model->num_elem_sets, invalid_ids);
invalidate_id_status(exoid, 0, VAR_NM_PROP(1), model->num_node_maps, invalid_ids);
invalidate_id_status(exoid, 0, VAR_EDM_PROP(1), model->num_edge_maps, invalid_ids);
invalidate_id_status(exoid, 0, VAR_FAM_PROP(1), model->num_face_maps, invalid_ids);
invalidate_id_status(exoid, 0, VAR_EM_PROP(1), model->num_elem_maps, invalid_ids);
if (invalid_ids != NULL) {
free(invalid_ids);
invalid_ids = NULL;
}
}
/* Write dummy values to the names arrays to avoid corruption issues on some platforms */
if (model->num_elem_blk > 0) { write_dummy_names(exoid, EX_ELEM_BLOCK);
}
if (model->num_edge_blk > 0) { write_dummy_names(exoid, EX_EDGE_BLOCK);
}
if (model->num_face_blk > 0) { write_dummy_names(exoid, EX_FACE_BLOCK);
}
if (model->num_node_sets> 0) { write_dummy_names(exoid, EX_NODE_SET);
}
if (model->num_edge_sets> 0) { write_dummy_names(exoid, EX_EDGE_SET);
}
if (model->num_face_sets> 0) { write_dummy_names(exoid, EX_FACE_SET);
}
if (model->num_side_sets> 0) { write_dummy_names(exoid, EX_SIDE_SET);
}
if (model->num_elem_sets> 0) { write_dummy_names(exoid, EX_ELEM_SET);
}
if (model->num_node_maps> 0) { write_dummy_names(exoid, EX_NODE_MAP);
}
if (model->num_edge_maps> 0) { write_dummy_names(exoid, EX_EDGE_MAP);
}
if (model->num_face_maps> 0) { write_dummy_names(exoid, EX_FACE_MAP);
}
if (model->num_elem_maps> 0) { write_dummy_names(exoid, EX_ELEM_MAP);
}
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_init_ext",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_sset_var (int exoid,
int time_step,
int sset_var_index,
int sset_id,
int num_faces_this_sset,
const void *sset_var_vals)
{
int varid, dimid,time_dim, numelbdim, dims[2], sset_id_ndx;
long num_ssets, num_sset_var, start[2], count[2];
nclong *sset_var_tab;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* Determine index of sset_id in VAR_SS_ID array */
sset_id_ndx = ex_id_lkup(exoid,VAR_SS_IDS,sset_id);
if (exerrval != 0)
{
if (exerrval == EX_NULLENTITY)
{
sprintf(errmsg,
"Warning: no variables allowed for NULL sideset %d in file id %d",
sset_id,exoid);
ex_err("ex_put_sset_var",errmsg,EX_MSG);
return (EX_WARN);
}
else
{
sprintf(errmsg,
"Error: failed to locate sideset id %d in %s array in file id %d",
sset_id, VAR_SS_IDS, exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
}
if ((varid = ncvarid (exoid,
VAR_SS_VAR(sset_var_index,sset_id_ndx))) == -1)
{
if (ncerr == NC_ENOTVAR) /* variable doesn't exist, create it! */
{
/* inquire previously defined dimensions */
/* check for the existance of an sideset variable truth table */
if ((varid = ncvarid (exoid, VAR_SSET_TAB)) != -1)
{
/* find out number of sidesets and sideset variables */
if ((dimid = ncdimid (exoid, DIM_NUM_SS)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of sidesets in file id %d",
exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_ssets) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of sidesets in file id %d",
exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
if ((dimid = ncdimid (exoid, DIM_NUM_SSET_VAR)) == -1)
{
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: no sideset variables stored in file id %d",
exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_sset_var) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of sideset variables in file id %d",
exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
if (!(sset_var_tab = malloc(num_ssets*num_sset_var*sizeof(nclong))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for sideset variable truth table in file id %d",
exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the sideset variable truth table */
start[0] = 0;
start[1] = 0;
count[0] = num_ssets;
count[1] = num_sset_var;
if (ncvarget (exoid, varid, start, count, sset_var_tab) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get truth table from file id %d", exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
if(sset_var_tab[num_sset_var*(sset_id_ndx-1)+sset_var_index-1]
== 0L)
{
free(sset_var_tab);
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid sideset variable %d, sideset %d in file id %d",
sset_var_index, sset_id, exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
free(sset_var_tab);
}
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_sset_var",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((numelbdim=ncdimid(exoid, DIM_NUM_SIDE_SS(sset_id_ndx))) == -1)
{
if (ncerr == NC_EBADDIM)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: number of faces in sideset %d not defined in file id %d",
sset_id, exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of sides in sideset %d in file id %d",
sset_id, exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
}
goto error_ret;
}
/* variable doesn't exist so 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_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
/* define netCDF variable to store sideset variable values */
dims[0] = time_dim;
dims[1] = numelbdim;
if ((varid = ncvardef(exoid,VAR_SS_VAR(sset_var_index,sset_id_ndx),
nc_flt_code(exoid), 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define sideset variable %d in file id %d",
sset_var_index,exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
goto error_ret;
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete sideset variable %s definition to file id %d",
VAR_SS_VAR(sset_var_index,sset_id_ndx), exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate sideset variable %s in file id %d",
VAR_SS_VAR(sset_var_index,sset_id_ndx),exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
}
/* store sideset variable values */
start[0] = --time_step;
start[1] = 0;
count[0] = 1;
count[1] = num_faces_this_sset;
if (ncvarput (exoid, varid, start, count,
ex_conv_array(exoid,WRITE_CONVERT,sset_var_vals,
num_faces_this_sset)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store sideset variable %d in file id %d",
sset_var_index,exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_sset_var",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_add_attr(int exoid, ex_entity_type obj_type, ex_entity_id obj_id, int64_t num_attr_per_entry)
{
int status;
int dims[2];
int strdim, varid, att_name_varid;
size_t num_obj;
char errmsg[MAX_ERR_LENGTH];
const char *dnumobjent;
const char *dnumobjatt;
const char *vobjatt;
const char *vattnam;
int numobjentdim;
int obj_id_ndx;
int numattrdim;
exerrval = 0; /* clear error code */
if (num_attr_per_entry <= 0) {
return (EX_NOERR);
}
/* Determine index of obj_id in obj_type id array */
if (obj_type == EX_NODAL) {
obj_id_ndx = 0;
}
else {
obj_id_ndx = ex_id_lkup(exoid, obj_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no attributes found for NULL %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_add_attr", errmsg, EX_NULLENTITY);
return (EX_WARN); /* no attributes for this object */
}
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: failed to locate %s id %" PRId64 " in id array in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_add_attr", errmsg, exerrval);
return (EX_WARN);
}
}
switch (obj_type) {
case EX_SIDE_SET:
dnumobjent = DIM_NUM_SIDE_SS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_SS(obj_id_ndx);
vobjatt = VAR_SSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_SSATTRIB(obj_id_ndx);
break;
case EX_NODE_SET:
dnumobjent = DIM_NUM_NOD_NS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_NS(obj_id_ndx);
vobjatt = VAR_NSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_NSATTRIB(obj_id_ndx);
break;
case EX_EDGE_SET:
dnumobjent = DIM_NUM_EDGE_ES(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_ES(obj_id_ndx);
vobjatt = VAR_ESATTRIB(obj_id_ndx);
vattnam = VAR_NAME_ESATTRIB(obj_id_ndx);
break;
case EX_FACE_SET:
dnumobjent = DIM_NUM_FACE_FS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_FS(obj_id_ndx);
vobjatt = VAR_FSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_FSATTRIB(obj_id_ndx);
break;
case EX_ELEM_SET:
dnumobjent = DIM_NUM_ELE_ELS(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_ELS(obj_id_ndx);
vobjatt = VAR_ELSATTRIB(obj_id_ndx);
vattnam = VAR_NAME_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
dnumobjent = DIM_NUM_NODES;
dnumobjatt = DIM_NUM_ATT_IN_NBLK;
vobjatt = VAR_NATTRIB;
vattnam = VAR_NAME_NATTRIB;
break;
case EX_EDGE_BLOCK:
dnumobjent = DIM_NUM_ED_IN_EBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_EBLK(obj_id_ndx);
vobjatt = VAR_EATTRIB(obj_id_ndx);
vattnam = VAR_NAME_EATTRIB(obj_id_ndx);
break;
case EX_FACE_BLOCK:
dnumobjent = DIM_NUM_FA_IN_FBLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_FBLK(obj_id_ndx);
vobjatt = VAR_FATTRIB(obj_id_ndx);
vattnam = VAR_NAME_FATTRIB(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
dnumobjent = DIM_NUM_EL_IN_BLK(obj_id_ndx);
dnumobjatt = DIM_NUM_ATT_IN_BLK(obj_id_ndx);
vobjatt = VAR_ATTRIB(obj_id_ndx);
vattnam = VAR_NAME_ATTRIB(obj_id_ndx);
break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Bad block type (%d) specified for file id %d",
obj_type, exoid);
ex_err("ex_put_attr_param", errmsg, exerrval);
return (EX_FATAL);
}
/* element attribute array */
/* put netcdf file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to place file id %d into define mode", exoid);
ex_err("ex_add_attr", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_def_dim(exoid, dnumobjatt, num_attr_per_entry, &numattrdim)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define number of attributes in %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_add_attr", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
ex_get_dimension(exoid, dnumobjent, ex_name_of_object(obj_type), &num_obj, &numobjentdim,
"ex_add_attr");
dims[0] = numobjentdim;
dims[1] = numattrdim;
if ((status = nc_def_var(exoid, vobjatt, nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define attributes for %s %" PRId64 " in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_add_attr", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &strdim)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get string length in file id %d", exoid);
ex_err("ex_add_attr", errmsg, exerrval);
return (EX_FATAL);
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if ((status = nc_def_var(exoid, vattnam, NC_CHAR, 2, dims, &att_name_varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define %s attribute name array in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_add_attr", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
/* leave define mode */
if ((exerrval = nc_enddef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete %s definition in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_add_attr", errmsg, exerrval);
return (EX_FATAL);
}
/* Output a dummy empty attribute name in case client code doesn't
write anything; avoids corruption in some cases.
*/
if (att_name_varid >= 0) {
size_t count[2];
size_t start[2];
char * text = "";
size_t i;
count[0] = 1;
start[1] = 0;
count[1] = strlen(text) + 1;
for (i = 0; i < num_attr_per_entry; i++) {
start[0] = i;
nc_put_vara_text(exoid, att_name_varid, start, count, text);
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
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_add_attr", errmsg, exerrval);
}
return (EX_FATAL);
}
int ex_put_block( int exoid,
ex_entity_type blk_type,
int blk_id,
const char* entry_descrip,
int num_entries_this_blk,
int num_nodes_per_entry,
int num_edges_per_entry,
int num_faces_per_entry,
int num_attr_per_entry )
{
int status;
int arbitrary_polyhedra = 0; /* 1 if block is arbitrary 2d polyhedra type; 2 if 3d polyhedra */
int varid, dimid, dims[2], blk_id_ndx, blk_stat, strdim;
size_t start[2];
int num_blk;
size_t temp;
int cur_num_blk, numblkdim, numattrdim;
int nnodperentdim, nedgperentdim, nfacperentdim;
int connid;
int npeid;
char errmsg[MAX_ERR_LENGTH];
char entity_type1[5];
char entity_type2[5];
const char* dnumblk = NULL;
const char* vblkids = NULL;
const char* vblksta = NULL;
const char* vnodcon = NULL;
const char* vnpecnt = NULL;
const char* vedgcon = NULL;
const char* vfaccon = NULL;
const char* vconn = NULL;
const char* vattnam = NULL;
const char* vblkatt = NULL;
const char* dneblk = NULL;
const char* dnape = NULL;
const char* dnnpe = NULL;
const char* dnepe = NULL;
const char* dnfpe = NULL;
exerrval = 0; /* clear error code */
switch (blk_type) {
case EX_EDGE_BLOCK:
dnumblk = DIM_NUM_ED_BLK;
vblkids = VAR_ID_ED_BLK;
vblksta = VAR_STAT_ED_BLK;
break;
case EX_FACE_BLOCK:
dnumblk = DIM_NUM_FA_BLK;
vblkids = VAR_ID_FA_BLK;
vblksta = VAR_STAT_FA_BLK;
break;
case EX_ELEM_BLOCK:
dnumblk = DIM_NUM_EL_BLK;
vblkids = VAR_ID_EL_BLK;
vblksta = VAR_STAT_EL_BLK;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) specified for file id %d",
blk_type, exoid );
ex_err( "ex_put_block", errmsg, exerrval );
return (EX_FATAL);
}
/* first check if any element blocks are specified */
if ((status = ex_get_dimension(exoid, dnumblk, ex_name_of_object(blk_type),
&temp, &dimid, "ex_put_block")) != NC_NOERR) {
return EX_FATAL;
}
num_blk = (int)temp;
/* Next: Make sure that this is not a duplicate element block id by
searching the vblkids array.
WARNING: This must be done outside of define mode because id_lkup accesses
the database to determine the position
*/
if ((status = nc_inq_varid(exoid, vblkids, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(blk_type), exoid);
ex_err("ex_put_block",errmsg,exerrval);
}
blk_id_ndx = ex_id_lkup(exoid,blk_type,blk_id);
if (exerrval != EX_LOOKUPFAIL) { /* found the element block id */
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: %s id %d already exists in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of element blocks defined using a counter
stored in a linked list keyed by exoid.
NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented.
*/
cur_num_blk=ex_get_file_item(exoid, ex_get_counter_list(blk_type));
if (cur_num_blk >= num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(blk_type), num_blk,exoid);
ex_err("ex_put_block",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented. */
cur_num_blk=ex_inc_file_item(exoid, ex_get_counter_list(blk_type));
start[0] = cur_num_blk;
/* write out element block id to previously defined id array variable*/
if ((status = nc_put_var1_int(exoid, varid, start, &blk_id)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id to file id %d",
ex_name_of_object(blk_type), exoid);
ex_err("ex_put_block",errmsg,exerrval);
return (EX_FATAL);
}
blk_id_ndx = ((int)start[0])+1; /* element id index into vblkids array*/
if (num_entries_this_blk == 0) /* Is this a NULL element block? */
blk_stat = 0; /* change element block status to NULL */
else
blk_stat = 1; /* change element block status to TRUE */
if ((status = nc_inq_varid (exoid, vblksta, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d",
ex_name_of_object(blk_type), exoid);
ex_err("ex_put_block",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &blk_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %d status to file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_put_block",errmsg,exerrval);
return (EX_FATAL);
}
if (num_entries_this_blk == 0) {/* Is this a NULL element block? */
return(EX_NOERR);
}
/* put netcdf file into define mode */
if ((status=nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_block",errmsg,exerrval);
return (EX_FATAL);
}
switch (blk_type) {
case EX_EDGE_BLOCK:
dneblk = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_EBLK(blk_id_ndx);
vblkatt = VAR_EATTRIB(blk_id_ndx);
vattnam = VAR_NAME_EATTRIB(blk_id_ndx);
vnodcon = VAR_EBCONN(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_FACE_BLOCK:
dneblk = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_FBLK(blk_id_ndx);
vblkatt = VAR_FATTRIB(blk_id_ndx);
vattnam = VAR_NAME_FATTRIB(blk_id_ndx);
vnodcon = VAR_FBCONN(blk_id_ndx);
vnpecnt = VAR_FBEPEC(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_ELEM_BLOCK:
dneblk = DIM_NUM_EL_IN_BLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnepe = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnfpe = DIM_NUM_FAC_PER_EL(blk_id_ndx);
dnape = DIM_NUM_ATT_IN_BLK(blk_id_ndx);
vblkatt = VAR_ATTRIB(blk_id_ndx);
vattnam = VAR_NAME_ATTRIB(blk_id_ndx);
vnodcon = VAR_CONN(blk_id_ndx);
vnpecnt = VAR_EBEPEC(blk_id_ndx);
vedgcon = VAR_ECONN(blk_id_ndx);
vfaccon = VAR_FCONN(blk_id_ndx);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized block type in switch: %d in file id %d",
blk_type,exoid);
ex_err("ex_put_block",errmsg,EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* define some dimensions and variables*/
if ((status = nc_def_dim(exoid,dneblk,num_entries_this_blk, &numblkdim )) != NC_NOERR) {
if (status == NC_ENAMEINUSE) { /* duplicate entry */
exerrval = status;
sprintf(errmsg,
"Error: %s %d already defined in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of entities/block for %s %d file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if ( dnnpe && num_nodes_per_entry > 0) {
/* A nfaced block would not have any nodes defined... */
if ((status = nc_def_dim(exoid,dnnpe,num_nodes_per_entry, &nnodperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of nodes/entity for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (dnepe && num_edges_per_entry > 0 ) {
if ((status = nc_def_dim (exoid,dnepe,num_edges_per_entry, &nedgperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of edges/entity for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( dnfpe && num_faces_per_entry > 0 ) {
if ((status = nc_def_dim(exoid,dnfpe,num_faces_per_entry, &nfacperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of faces/entity for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* element attribute array */
if (num_attr_per_entry > 0) {
if ((status = nc_def_dim(exoid, dnape, num_attr_per_entry, &numattrdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of attributes in %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dims[0] = numblkdim;
dims[1] = numattrdim;
if ((status = nc_def_var(exoid, vblkatt, nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define attributes for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_STR, &strdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if ((status = nc_def_var(exoid, vattnam, NC_CHAR, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s attribute name array in file id %d",
ex_name_of_object(blk_type), exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* See if storing an 'nsided' element block (arbitrary 2d polyhedra or super element) */
if (strlen(entry_descrip) >= 3) {
if ((entry_descrip[0] == 'n' || entry_descrip[0] == 'N') &&
(entry_descrip[1] == 's' || entry_descrip[1] == 'S') &&
(entry_descrip[2] == 'i' || entry_descrip[2] == 'I'))
arbitrary_polyhedra = 1;
else if ((entry_descrip[0] == 'n' || entry_descrip[0] == 'N') &&
(entry_descrip[1] == 'f' || entry_descrip[1] == 'F') &&
(entry_descrip[2] == 'a' || entry_descrip[2] == 'A'))
/* If a FACE_BLOCK, then we are dealing with the faces of the nfaced block. */
arbitrary_polyhedra = blk_type == EX_FACE_BLOCK ? 1 : 2;
}
/* element connectivity array */
if (arbitrary_polyhedra > 0) {
if (blk_type != EX_FACE_BLOCK && blk_type != EX_ELEM_BLOCK) {
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) for nsided/nfaced block in file id %d",
blk_type, exoid );
ex_err( "ex_put_block", errmsg, exerrval );
return (EX_FATAL);
}
if (arbitrary_polyhedra == 1) {
dims[0] = nnodperentdim;
vconn = vnodcon;
/* store entity types as attribute of npeid variable -- node/elem, node/face, face/elem*/
strcpy(entity_type1, "NODE");
if (blk_type == EX_ELEM_BLOCK)
strcpy(entity_type2, "ELEM");
else
strcpy(entity_type2, "FACE");
} else if (arbitrary_polyhedra == 2) {
dims[0] = nfacperentdim;
vconn = vfaccon;
/* store entity types as attribute of npeid variable -- node/elem, node/face, face/elem*/
strcpy(entity_type1, "FACE");
strcpy(entity_type2, "ELEM");
}
if ((status = nc_def_var(exoid, vconn, NC_INT, 1, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element face-per-element or node-per-element count array */
dims[0] = numblkdim;
if ((status = nc_def_var(exoid, vnpecnt, NC_INT, 1, dims, &npeid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create face- or node- per-entity count array for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_put_att_text(exoid, npeid, "entity_type1", strlen(entity_type1)+1,
entity_type1)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store entity type attribute text for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_put_att_text(exoid, npeid, "entity_type2", strlen(entity_type2)+1,
entity_type2)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store entity type attribute text for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* "Normal" (non-polyhedra) element block type */
dims[0] = numblkdim;
dims[1] = nnodperentdim;
if ((status = nc_def_var(exoid, vnodcon, NC_INT, 2, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* store element type as attribute of connectivity variable */
if ((status = nc_put_att_text(exoid, connid, ATT_NAME_ELB, strlen(entry_descrip)+1,
entry_descrip)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s type name %s in file id %d",
ex_name_of_object(blk_type), entry_descrip,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if (arbitrary_polyhedra == 0) {
if (vedgcon && num_edges_per_entry ) {
dims[0] = numblkdim;
dims[1] = nedgperentdim;
if ((status = nc_def_var(exoid, vedgcon, NC_INT, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create edge connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( vfaccon && num_faces_per_entry ) {
dims[0] = numblkdim;
dims[1] = nfacperentdim;
if ((status = nc_def_var(exoid, vfaccon, NC_INT, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create face connectivity array for %s %d in file id %d",
ex_name_of_object(blk_type), blk_id,exoid);
ex_err("ex_put_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
/* leave define mode */
if ((exerrval=nc_enddef (exoid)) != NC_NOERR) {
sprintf(errmsg,
"Error: failed to complete %s definition in file id %d",
ex_name_of_object(blk_type), exoid);
ex_err("ex_put_block",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_block",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_block( int exoid,
int blk_type,
int blk_id,
const char* entry_descrip,
int num_entries_this_blk,
int num_nodes_per_entry,
int num_edges_per_entry,
int num_faces_per_entry,
int num_attr_per_entry )
{
int varid, dimid, dims[2], blk_id_ndx, blk_stat, strdim;
long start[2], num_blk;
nclong ldum;
int cur_num_blk, numblkdim, numattrdim;
int nnodperentdim, nedgperentdim = -1, nfacperentdim = -1;
int connid, econnid, fconnid;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
const char* tname;
const char* dnumblk;
const char* vblkids;
const char* vblksta;
const char* vnodcon = 0;
const char* vedgcon = 0;
const char* vfaccon = 0;
const char* vattnam = 0;
const char* vblkatt = 0;
const char* dneblk = 0;
const char* dnape = 0;
const char* dnnpe = 0;
const char* dnepe = 0;
const char* dnfpe = 0;
struct list_item** ctr_list;
exerrval = 0; /* clear error code */
cdum = 0;
switch (blk_type) {
case EX_EDGE_BLOCK:
tname = "edge";
dnumblk = DIM_NUM_ED_BLK;
vblkids = VAR_ID_ED_BLK;
vblksta = VAR_STAT_ED_BLK;
ctr_list = &ed_ctr_list;
break;
case EX_FACE_BLOCK:
tname = "face";
dnumblk = DIM_NUM_FA_BLK;
vblkids = VAR_ID_FA_BLK;
vblksta = VAR_STAT_FA_BLK;
ctr_list = &fa_ctr_list;
break;
case EX_ELEM_BLOCK:
tname = "element";
dnumblk = DIM_NUM_EL_BLK;
vblkids = VAR_ID_EL_BLK;
vblksta = VAR_STAT_EL_BLK;
ctr_list = &eb_ctr_list;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) specified for file id %d",
blk_type, exoid );
ex_err( "ex_put_block", errmsg, exerrval );
return (EX_FATAL);
}
/* first check if any element blocks are specified */
if ((dimid = (ncdimid (exoid, dnumblk))) == -1 )
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no element blocks defined in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Get number of element blocks defined for this file */
if ((ncdiminq (exoid,dimid,cdum,&num_blk)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Next: Make sure that this is not a duplicate element block id by
searching the vblkids array.
WARNING: This must be done outside of define mode because id_lkup accesses
the database to determine the position
*/
if ((varid = ncvarid (exoid, vblkids)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element block ids in file id %d", exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
blk_id_ndx = ex_id_lkup(exoid,vblkids,blk_id);
if (exerrval != EX_LOOKUPFAIL) /* found the element block id */
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: element block id %d already exists in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of element blocks defined using a counter
stored in a linked list keyed by exoid.
NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented.
*/
cur_num_blk=ex_get_file_item(exoid, ctr_list);
if (cur_num_blk >= num_blk)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of element blocks (%ld) defined in file id %d",
num_blk,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented. */
cur_num_blk=ex_inc_file_item(exoid, ctr_list);
start[0] = (long)cur_num_blk;
/* write out element block id to previously defined id array variable*/
ldum = (nclong)blk_id;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element block id to file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
blk_id_ndx = start[0]+1; /* element id index into vblkids array*/
if (num_entries_this_blk == 0) /* Is this a NULL element block? */
blk_stat = 0; /* change element block status to NULL */
else
blk_stat = 1; /* change element block status to TRUE */
if ((varid = ncvarid (exoid, vblksta)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate element block status in file id %d", exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
ldum = (nclong)blk_stat;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element id %d status to file id %d",
blk_id, exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
if (num_entries_this_blk == 0) /* Is this a NULL element block? */
{
return(EX_NOERR);
}
/*
* Check that storage required for connectivity array is less
* than 2GB which is maximum size permitted by netcdf
* (in large file mode). 1<<29 == max number of integer items.
*/
if (num_entries_this_blk * num_nodes_per_entry > (1<<29)) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Size to store connectivity for element block %d exceeds 2GB in file id %d",
blk_id, exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* put netcdf file into define mode */
if (ncredef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
switch (blk_type) {
case EX_EDGE_BLOCK:
dneblk = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_EBLK(blk_id_ndx);
vblkatt = VAR_EATTRIB(blk_id_ndx);
vattnam = VAR_NAME_EATTRIB(blk_id_ndx);
vnodcon = VAR_EBCONN(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_FACE_BLOCK:
dneblk = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_FBLK(blk_id_ndx);
vblkatt = VAR_FATTRIB(blk_id_ndx);
vattnam = VAR_NAME_FATTRIB(blk_id_ndx);
vnodcon = VAR_FBCONN(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_ELEM_BLOCK:
dneblk = DIM_NUM_EL_IN_BLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnepe = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnfpe = DIM_NUM_FAC_PER_EL(blk_id_ndx);
dnape = DIM_NUM_ATT_IN_BLK(blk_id_ndx);
vblkatt = VAR_ATTRIB(blk_id_ndx);
vattnam = VAR_NAME_ATTRIB(blk_id_ndx);
vnodcon = VAR_CONN(blk_id_ndx);
vedgcon = VAR_ECONN(blk_id_ndx);
vfaccon = VAR_FCONN(blk_id_ndx);
break;
}
/* define some dimensions and variables*/
if ((numblkdim = ncdimdef (exoid,dneblk,(long)num_entries_this_blk)) == -1)
{
if (ncerr == NC_ENAMEINUSE) /* duplicate entry */
{
exerrval = ncerr;
sprintf(errmsg,
"Error: element block %d already defined in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of elements/block for block %d file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if ((nnodperentdim = ncdimdef (exoid,dnnpe,(long)num_nodes_per_entry)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of nodes/element for block %d in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ( dnepe && num_edges_per_entry > 0 ) {
if ((nedgperentdim = ncdimdef (exoid,dnepe,(long)num_edges_per_entry)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of edges/element for block %d in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( dnfpe && num_faces_per_entry > 0 ) {
if ((nfacperentdim = ncdimdef (exoid,dnfpe,(long)num_faces_per_entry)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of faces/element for block %d in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* element attribute array */
if (num_attr_per_entry > 0)
{
if ((numattrdim = ncdimdef (exoid, dnape, (long)num_attr_per_entry)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of attributes in block %d in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dims[0] = numblkdim;
dims[1] = numattrdim;
if ((ncvardef (exoid, vblkatt, nc_flt_code(exoid), 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define attributes for element block %d in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* inquire previously defined dimensions */
if ((strdim = ncdimid (exoid, DIM_STR)) < 0) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if (ncvardef (exoid, vattnam, NC_CHAR, 2, dims) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define element attribute name array in file id %d",exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* element connectivity array */
dims[0] = numblkdim;
dims[1] = nnodperentdim;
if ((connid = ncvardef (exoid, vnodcon, NC_LONG, 2, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create connectivity array for block %d in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store element type as attribute of connectivity variable */
if ((ncattput (exoid, connid, ATT_NAME_ELB, NC_CHAR, strlen(entry_descrip)+1,
(void*) entry_descrip)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element type name %s in file id %d",
entry_descrip,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ( vedgcon && num_edges_per_entry ) {
dims[0] = numblkdim;
dims[1] = nedgperentdim;
if ((econnid = ncvardef (exoid, vedgcon, NC_LONG, 2, dims)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create edge connectivity array for block %d in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( vfaccon && num_faces_per_entry ) {
dims[0] = numblkdim;
dims[1] = nfacperentdim;
if ((fconnid = ncvardef (exoid, vfaccon, NC_LONG, 2, dims)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create face connectivity array for block %d in file id %d",
blk_id,exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete element block definition in file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_elem_block",errmsg,exerrval);
}
return (EX_FATAL);
}
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_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);
}
static int
ex_look_up_var(int exoid, ex_entity_type var_type, int var_index, ex_entity_id obj_id,
const char *VOBJID, const char *VOBJTAB, const char *DNUMOBJ,
const char *DNUMOBJVAR, int *varid)
{
int status;
int obj_id_ndx;
int dimid,time_dim, numobjdim, dims[2];
size_t num_obj;
size_t num_obj_var;
size_t num_entity;
int *obj_var_truth_tab;
char errmsg[MAX_ERR_LENGTH];
/* Determine index of obj_id in VOBJID array */
obj_id_ndx = ex_id_lkup(exoid,var_type,obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no variables allowed for NULL block %"PRId64" in file id %d",
obj_id,exoid);
ex_err("ex_put_var",errmsg,EX_MSG);
return (EX_WARN);
}
else {
sprintf(errmsg,
"Error: failed to locate %s id %"PRId64" in %s array in file id %d",
ex_name_of_object(var_type), obj_id, VOBJID, exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
}
if ((status = nc_inq_varid (exoid, ex_name_var_of_object(var_type, var_index, obj_id_ndx), varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) {/* variable doesn't exist, create it! */
/* check for the existance of an TNAME variable truth table */
if (nc_inq_varid(exoid, VOBJTAB, varid) == NC_NOERR) {
/* find out number of TNAMEs and TNAME variables */
status = ex_get_dimension(exoid, DNUMOBJ, ex_name_of_object(var_type), &num_obj, &dimid, "ex_put_var");
if (status != NC_NOERR) return status;
status = ex_get_dimension(exoid, DNUMOBJVAR, ex_name_of_object(var_type), &num_obj_var, &dimid, "ex_put_var");
if (status != NC_NOERR) return status;
if (!(obj_var_truth_tab = malloc(num_obj*num_obj_var*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s variable truth table in file id %d",
ex_name_of_object(var_type), exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the TNAME variable truth table */
if ((status = nc_get_var_int (exoid, *varid, obj_var_truth_tab)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get truth table from file id %d", exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
if(obj_var_truth_tab[num_obj_var*(obj_id_ndx-1)+var_index-1] == 0L) {
free(obj_var_truth_tab);
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid %s variable %d, %s %"PRId64" in file id %d",
ex_name_of_object(var_type), var_index, ex_name_of_object(var_type), obj_id, exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
free(obj_var_truth_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_var",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_get_dimension(exoid, ex_dim_num_entries_in_object(var_type, obj_id_ndx),
ex_name_of_object(var_type), &num_entity, &numobjdim, "ex_put_var");
/* 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_var",errmsg,exerrval);
return (EX_FATAL);
}
/* define netCDF variable to store TNAME variable values */
dims[0] = time_dim;
dims[1] = numobjdim;
if ((status = nc_def_var(exoid, ex_name_var_of_object(var_type, var_index, obj_id_ndx),
nc_flt_code(exoid), 2, dims, varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s variable %d in file id %d",
ex_name_of_object(var_type), var_index,exoid);
ex_err("ex_put_var",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 %s variable %s definition to file id %d",
ex_name_of_object(var_type), ex_name_var_of_object(var_type, var_index, obj_id_ndx), exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
}
else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s variable %s in file id %d",
ex_name_of_object(var_type), ex_name_var_of_object(var_type, var_index, obj_id_ndx), exoid);
ex_err("ex_put_var",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_var",errmsg,exerrval);
}
return (EX_FATAL);
}
/*! \internal */
int cpy_var_def(int in_id,int out_id,int rec_dim_id,char *var_nm)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
int rec_dim_id: input input-file record dimension ID
char *var_nm: input variable name
int cpy_var_def(): output output-file variable ID
*/
{
/* Routine to copy the variable metadata from an input netCDF file
* to an output netCDF file.
*/
int status;
int *dim_in_id;
int *dim_out_id;
int idx;
int nbr_dim;
int var_in_id;
int var_out_id;
nc_type var_type;
/* See if the requested variable is already in the output file. */
status = nc_inq_varid(out_id, var_nm, &var_out_id);
if(status == NC_NOERR)
return var_out_id;
/* See if the requested variable is in the input file. */
(void)nc_inq_varid(in_id, var_nm, &var_in_id);
/* Get the type of the variable and the number of dimensions. */
(void)nc_inq_vartype (in_id, var_in_id, &var_type);
(void)nc_inq_varndims(in_id, var_in_id, &nbr_dim);
/* Recall:
1. The dimensions must be defined before the variable.
2. The variable must be defined before the attributes. */
/* Allocate space to hold the dimension IDs */
dim_in_id=malloc(nbr_dim*sizeof(int));
dim_out_id=malloc(nbr_dim*sizeof(int));
/* Get the dimension IDs */
(void)nc_inq_vardimid(in_id, var_in_id, dim_in_id);
/* Get the dimension sizes and names */
for(idx=0;idx<nbr_dim;idx++){
char dim_nm[NC_MAX_NAME];
size_t dim_sz;
(void)nc_inq_dim(in_id, dim_in_id[idx], dim_nm, &dim_sz);
/* See if the dimension has already been defined */
status = nc_inq_dimid(out_id, dim_nm, &dim_out_id[idx]);
/* If the dimension hasn't been defined, copy it */
if (status != NC_NOERR) {
if (dim_in_id[idx] != rec_dim_id) {
(void)nc_def_dim(out_id, dim_nm, dim_sz, &dim_out_id[idx]);
} else {
(void)nc_def_dim(out_id, dim_nm, NC_UNLIMITED, &dim_out_id[idx]);
}
}
}
/* Define the variable in the output file */
/* If variable is float or double, define it according to the EXODUS
file's IO_word_size */
if ((var_type == NC_FLOAT) || (var_type == NC_DOUBLE)) {
(void)nc_def_var(out_id, var_nm, nc_flt_code(out_id), nbr_dim, dim_out_id, &var_out_id);
ex_compress_variable(out_id, var_out_id, 2);
} else {
(void)nc_def_var(out_id, var_nm, var_type, nbr_dim, dim_out_id, &var_out_id);
ex_compress_variable(out_id, var_out_id, 1);
}
/* Free the space holding the dimension IDs */
(void)free(dim_in_id);
(void)free(dim_out_id);
return var_out_id;
} /* end cpy_var_def() */
/*! Calculate the number of words of storage required to store the
* header information. Total bytes can be obtained by multiplying
* words by 4. Size is slightly underestimated since it only
* considers the bulk data storage...
*/
size_t ex_header_size(int exoid)
{
const char *routine = NULL;
int iows = 0;
size_t ndim = 0;
size_t num_nodes = 0;
size_t num_elem = 0;
size_t num_eblk = 0;
size_t num_map = 0;
size_t num_nset = 0;
size_t num_sset = 0;
int mapid;
int temp;
size_t size = 0;
/* Get word size (2 = 8-byte reals, 1 = 4-byte reals */
if (nc_flt_code(exoid) == NC_DOUBLE)
iows = 2;
else
iows = 1;
/* coordinates = (ndim * numnp)*iows + maps */
ex_get_dimension(exoid, DIM_NUM_DIM, "dimension", &ndim, &temp, routine);
ex_get_dimension(exoid, DIM_NUM_NODES, "nodes", &num_nodes, &temp, routine);
size += iows * ndim * num_nodes;
/* node maps */
if (nc_inq_varid(exoid, VAR_NODE_NUM_MAP, &mapid) != -1)
size += num_nodes;
ex_get_dimension(exoid, DIM_NUM_NM, "node maps", &num_map, &temp, routine);
size += num_map * num_nodes;
/* Element Data */
ex_get_dimension(exoid, DIM_NUM_ELEM, "elements", &num_elem, &temp, routine);
/* Element order map */
if (nc_inq_varid (exoid, VAR_MAP, &mapid) != -1)
size += num_elem;
if (nc_inq_varid (exoid, VAR_ELEM_NUM_MAP, &mapid) != -1)
size += num_elem;
/* Element map(s) */
ex_get_dimension(exoid, DIM_NUM_EM, "element maps", &num_map, &temp, routine);
size += num_map * num_elem;
/* Element Blocks... */
ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element blocks", &num_eblk, &temp, routine);
if (num_eblk > 0) {
/* Allocate storage for element block parameters... */
int *ids = malloc(num_eblk * sizeof(int));
size_t i;
size += 2*num_eblk; /* status + ids */
ex_get_ids(exoid, EX_ELEM_BLOCK, ids);
for (i=0; i < num_eblk; i++) {
int num_elem_this_blk = 0;
int num_nodes_per_elem = 0;
int num_attr = 0;
char elem_type[MAX_STR_LENGTH+1];
ex_get_elem_block(exoid, ids[i], elem_type, &num_elem_this_blk,
&num_nodes_per_elem, &num_attr);
size += num_elem_this_blk * num_nodes_per_elem;
size += num_elem_this_blk * num_attr * iows;
}
free(ids);
}
/* Nodesets */
ex_get_dimension(exoid, DIM_NUM_NS, "nodesets", &num_nset, &temp, routine);
if (num_nset > 0) {
/* Allocate storage for nodeset parameters... */
int *ids = malloc(num_nset * sizeof(int));
size_t i;
size += 2*num_nset; /* Status + ids */
ex_get_ids(exoid, EX_NODE_SET, ids);
for (i=0; i < num_nset; i++) {
int num_nodes_in_set = 0;
int num_df_in_set = 0;
ex_get_node_set_param(exoid, ids[i], &num_nodes_in_set, &num_df_in_set);
size += num_nodes_in_set;
size += num_df_in_set * iows;
}
free(ids);
}
/* Sidesets */
ex_get_dimension(exoid, DIM_NUM_SS, "sidesets", &num_sset, &temp, routine);
if (num_sset > 0) {
/* Allocate storage for sideset parameters... */
int *ids = malloc(num_sset * sizeof(int));
size_t i;
size += 2*num_sset; /* Status + ids */
ex_get_ids(exoid, EX_SIDE_SET, ids);
for (i=0; i < num_sset; i++) {
int num_sides_in_set = 0;
int num_df_in_set = 0;
ex_get_side_set_param(exoid, ids[i], &num_sides_in_set, &num_df_in_set);
size += num_sides_in_set * 2;
size += num_df_in_set * iows;
}
free(ids);
}
if (ex_large_model(exoid) == 0 && size > (1<<29)) {
fprintf(stderr, "ERROR: Size to store header information exceeds 2GB in file id %d\n File is probably corrupt, rerun with environment variable EXODUS_LARGE_MODEL set.\n", exoid);
}
return size;
}
int ex_put_node_set_param (int exoid,
int node_set_id,
int num_nodes_in_set,
int num_dist_in_set)
{
int dimid, varid, dims[1];
long start[1];
nclong ldum;
long num_node_sets;
int cur_num_node_sets, node_set_stat;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
cdum = 0;
/* first check if any node sets are specified */
if ((dimid = (ncdimid (exoid, DIM_NUM_NS))) == -1 )
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no node sets specified in file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate node set id entry */
ex_id_lkup(exoid,VAR_NS_IDS,node_set_id);
if (exerrval != EX_LOOKUPFAIL) /* found the node set id */
{
exerrval = ncerr;
sprintf(errmsg,
"Error: node set %d already defined in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return(EX_FATAL);
}
/* Get number of node sets initialized for this file */
if ((ncdiminq (exoid,dimid,cdum,&num_node_sets)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of node sets defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of node sets
for a specific file and returns that value.
*/
cur_num_node_sets=ex_get_file_item(exoid, &ns_ctr_list );
if (cur_num_node_sets >= num_node_sets)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of node sets (%ld) specified in file id %d",
num_node_sets,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is used to find the number of node sets
for a specific file and returns that value incremented. */
cur_num_node_sets=ex_inc_file_item(exoid, &ns_ctr_list );
/* write out information to previously defined variable */
/* first get id of variable */
if ((varid = ncvarid (exoid, VAR_NS_IDS)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate node set ids in file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out node set id */
start[0] = cur_num_node_sets;
ldum = (nclong)node_set_id;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store node set id %d in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (num_nodes_in_set == 0) /* Is this a NULL side set? */
node_set_stat = 0; /* change node set status to NULL */
else
node_set_stat = 1; /* change node set status to TRUE */
if ((varid = ncvarid (exoid, VAR_NS_STAT)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate node set status in file id %d", exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
ldum = (nclong)node_set_stat;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store node set %d status to file id %d",
node_set_id, exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (num_nodes_in_set == 0) /* Is this a NULL side set? */
{
return(EX_NOERR);
}
/* put netcdf 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_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if ((dimid = ncdimdef (exoid, DIM_NUM_NOD_NS(cur_num_node_sets+1),
(long)num_nodes_in_set)) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: node set %d size already defined in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of nodes for set %d in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
goto error_ret;
}
/* create variable array in which to store the node set node list */
dims[0] = dimid;
if (ncvardef(exoid, VAR_NODE_NS(cur_num_node_sets+1), NC_LONG,1,dims) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: node set %d node list already defined in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create node set %d node list in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
/* Create distribution factors variable if required */
if (num_dist_in_set > 0)
{
/* num_dist_in_set should equal num_nodes_in_set */
if (num_dist_in_set != num_nodes_in_set)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%d) not equal to # nodes (%d) in node set %d file id %d",
num_dist_in_set, num_nodes_in_set, node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
else
{
/* create variable for distribution factors */
if (ncvardef (exoid, VAR_FACT_NS(cur_num_node_sets+1),
nc_flt_code(exoid), 1, dims) == -1)
{
if (ncerr == NC_ENAMEINUSE)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: node set %d dist factors already exist in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
else
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create node set %d dist factors in file id %d",
node_set_id,exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
}
}
/* leave define mode */
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete definition in file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_node_set_param",errmsg,exerrval);
}
return (EX_FATAL);
}
/*!
* writes the parameters used to describe an element block
* \param exoid exodus file id
* \param elem_blk_id element block id
* \param elem_type element type string
* \param num_elem_this_blk number of elements in the element blk
* \param num_nodes_per_elem number of nodes per element block
* \param num_attr number of attributes
* \param define_maps if != 0, write maps, else don't
*/
int ex_put_concat_elem_block (int exoid,
const int* elem_blk_id,
char *elem_type[],
const int* num_elem_this_blk,
const int* num_nodes_per_elem,
const int* num_attr,
int define_maps)
{
int i, varid, dimid, dims[2], strdim, *eb_array;
int temp;
int iblk;
int status;
int num_elem_blk;
size_t length;
int cur_num_elem_blk, nelnoddim, numelbdim, numattrdim, connid, numelemdim, numnodedim;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* first check if any element blocks are specified
* OK if zero...
*/
if (nc_inq_dimid(exoid, DIM_NUM_EL_BLK, &dimid) != NC_NOERR) {
return (EX_NOERR);
}
/* Get number of element blocks defined for this file */
if ((status = nc_inq_dimlen(exoid,dimid,&length)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
num_elem_blk = length;
/* Fill out the element block status array */
if (!(eb_array = malloc(num_elem_blk*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate space for element block status array in file id %d",
exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0;i<num_elem_blk;i++) {
if (num_elem_this_blk[i] == 0) /* Is this a NULL element block? */
eb_array[i] = 0; /* change element block status to NULL */
else
eb_array[i] = 1; /* change element block status to TRUE */
}
/* Next, get variable id of status array */
if ((status = nc_inq_varid(exoid, VAR_STAT_EL_BLK, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate element block status in file id %d",
exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
status = nc_put_var_int(exoid, varid, eb_array);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store element block status array to file id %d",
exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Next, fill out ids array */
/* first get id of ids array variable */
if ((status = nc_inq_varid(exoid, VAR_ID_EL_BLK, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate element block ids array in file id %d",
exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out id list */
status = nc_put_var_int(exoid, varid, elem_blk_id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store element block id array in file id %d",
exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_STR, &strdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
/* Iterate over element blocks ... */
for (iblk = 0; iblk < num_elem_blk; iblk++) {
cur_num_elem_blk=ex_get_file_item(exoid, ex_get_counter_list(EX_ELEM_BLOCK));
if (cur_num_elem_blk >= num_elem_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of element blocks (%d) defined in file id %d",
num_elem_blk,exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret;
}
/* NOTE: ex_inc_file_item is used to find the number of element blocks
for a specific file and returns that value incremented. */
cur_num_elem_blk=ex_inc_file_item(exoid, ex_get_counter_list(EX_ELEM_BLOCK));
if (num_elem_this_blk[iblk] == 0) /* Is this a NULL element block? */
continue;
/* define some dimensions and variables*/
if ((status = nc_def_dim(exoid,
DIM_NUM_EL_IN_BLK(cur_num_elem_blk+1),
num_elem_this_blk[iblk], &numelbdim)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) { /* duplicate entry */
sprintf(errmsg,
"Error: element block %d already defined in file id %d",
elem_blk_id[iblk],exoid);
} else {
sprintf(errmsg,
"Error: failed to define number of elements/block for block %d file id %d",
elem_blk_id[iblk],exoid);
}
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_def_dim(exoid,
DIM_NUM_NOD_PER_EL(cur_num_elem_blk+1),
num_nodes_per_elem[iblk], &nelnoddim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of nodes/element for block %d in file id %d",
elem_blk_id[iblk],exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element connectivity array */
dims[0] = numelbdim;
dims[1] = nelnoddim;
if ((status = nc_def_var (exoid, VAR_CONN(cur_num_elem_blk+1),
NC_INT, 2, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for block %d in file id %d",
elem_blk_id[iblk],exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store element type as attribute of connectivity variable */
if ((status = nc_put_att_text(exoid, connid, ATT_NAME_ELB, strlen(elem_type[iblk])+1,
(void*)elem_type[iblk])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store element type name %s in file id %d",
elem_type[iblk],exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element attribute array */
if (num_attr[iblk] > 0) {
if ((status = nc_def_dim (exoid,
DIM_NUM_ATT_IN_BLK(cur_num_elem_blk+1),
num_attr[iblk], &numattrdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of attributes in block %d in file id %d",
elem_blk_id[iblk],exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if ((status = nc_def_var(exoid, VAR_NAME_ATTRIB(cur_num_elem_blk+1),
NC_CHAR, 2, dims, &temp)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define element attribute name array in file id %d",exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
eb_array[iblk] = temp;
dims[0] = numelbdim;
dims[1] = numattrdim;
if ((status = nc_def_var(exoid, VAR_ATTRIB(cur_num_elem_blk+1),
nc_flt_code(exoid), 2, dims, &temp)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define attributes for element block %d in file id %d",
elem_blk_id[iblk],exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
/* Define the element map here to avoid a later redefine call */
if (define_maps != 0) {
if (nc_inq_varid(exoid, VAR_ELEM_NUM_MAP, &temp) != NC_NOERR) {
/* Map does not exist */
/* Possible to have zero elements but >0 element blocks.
* Only define map if there are nonzero elements
*/
if (nc_inq_dimid(exoid, DIM_NUM_ELEM, &numelemdim) == NC_NOERR) {
dims[0] = numelemdim;
if ((status = nc_def_var(exoid, VAR_ELEM_NUM_MAP, NC_INT, 1, dims, &temp)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: element numbering map already exists in file id %d",
exoid);
} else {
sprintf(errmsg,
"Error: failed to create element numbering map in file id %d",
exoid);
}
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
/* Do the same for the node numbering map */
if (nc_inq_varid(exoid, VAR_NODE_NUM_MAP, &temp) != NC_NOERR) {
/* Map does not exist */
if ((nc_inq_dimid(exoid, DIM_NUM_NODES, &numnodedim)) == NC_NOERR) {
dims[0] = numnodedim;
if ((status = nc_def_var(exoid, VAR_NODE_NUM_MAP, NC_INT, 1, dims, &temp)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: node numbering map already exists in file id %d",
exoid);
} else {
sprintf(errmsg,
"Error: failed to create node numbering map array in file id %d",
exoid);
}
ex_err("ex_put_concat_elem_block",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 element block definition in file id %d",
exoid);
ex_err("ex_put_concat_elem_block",errmsg,exerrval);
return (EX_FATAL);
}
{
/* Write dummy attribute name. Without this we get corruption in the
* attribute name.
*/
size_t start[2], count[2];
char *text = "";
count[0] = 1;
start[1] = 0;
count[1] = strlen(text)+1;
for (iblk = 0; iblk < num_elem_blk; iblk++) {
if (num_elem_this_blk[iblk] == 0) /* Is this a NULL element block? */
continue;
for (i = 0; i < num_attr[iblk]; i++) {
start[0] = i;
nc_put_vara_text(exoid, eb_array[iblk], start, count, text);
}
}
}
free(eb_array);
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_concat_elem_block",errmsg,exerrval);
}
return (EX_FATAL);
}
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 ex_put_coord (int exoid,
const void *x_coor,
const void *y_coor,
const void *z_coor)
{
int coordid;
int coordidx, coordidy, coordidz;
int numnoddim, ndimdim, i;
long num_nod, num_dim, start[2], count[2];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire id's of previously defined dimensions */
if ((numnoddim = ncdimid (exoid, DIM_NUM_NODES)) == -1)
{
/* If not found, then this file is storing 0 nodes.
Return immediately */
return (EX_NOERR);
}
if (ncdiminq (exoid, numnoddim, NULL, &num_nod) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: inquire failed to return number of nodes in file id %d",
exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
if ((ndimdim = ncdimid (exoid, DIM_NUM_DIM)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate number of dimensions in file id %d",
exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, ndimdim, NULL, &num_dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of dimensions in file id %d",
exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
/* write out the coordinates */
if (ex_large_model(exoid) == 0) {
if ((coordid = ncvarid (exoid, VAR_COORD)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate nodal coordinates in file id %d", exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i<num_dim; i++)
{
start[0] = i;
start[1] = 0;
count[0] = 1;
count[1] = num_nod;
if (i == 0 && x_coor != NULL)
{
if (ncvarput (exoid, coordid, start, count,
ex_conv_array(exoid,WRITE_CONVERT,x_coor,(int)num_nod)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to put X coord array in file id %d", exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
}
else if (i == 1 && y_coor != NULL)
{
if (ncvarput (exoid, coordid, start, count,
ex_conv_array(exoid,WRITE_CONVERT,y_coor,(int)num_nod)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to put Y coord array in file id %d", exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
}
else if (i == 2 && z_coor != NULL)
{
if (ncvarput (exoid, coordid, start, count,
ex_conv_array(exoid,WRITE_CONVERT,z_coor,(int)num_nod)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to put Z coord array in file id %d", exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
}
}
} else {
if ((coordidx = ncvarid (exoid, VAR_COORD_X)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate x nodal coordinates in file id %d", exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
if (num_dim > 1) {
if ((coordidy = ncvarid (exoid, VAR_COORD_Y)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate y nodal coordinates in file id %d", exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
} else {
coordidy = 0;
}
if (num_dim > 2) {
if ((coordidz = ncvarid (exoid, VAR_COORD_Z)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate z nodal coordinates in file id %d", exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
} else {
coordidz = 0;
}
/* write out the coordinates */
for (i=0; i<num_dim; i++)
{
const void *coor;
char *which;
int status;
if (i == 0) {
coor = x_coor;
which = "X";
coordid = coordidx;
} else if (i == 1) {
coor = y_coor;
which = "Y";
coordid = coordidy;
} else if (i == 2) {
coor = z_coor;
which = "Z";
coordid = coordidz;
}
if (coor != NULL) {
if (nc_flt_code(exoid) == NC_FLOAT) {
status = nc_put_var_float(exoid, coordid,
ex_conv_array(exoid,WRITE_CONVERT,
coor,(int)num_nod));
} else {
status = nc_put_var_double(exoid, coordid,
ex_conv_array(exoid,WRITE_CONVERT,
coor,(int)num_nod));
}
if (status == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to put %s coord array in file id %d", which, exoid);
ex_err("ex_put_coord",errmsg,exerrval);
return (EX_FATAL);
}
}
}
}
return (EX_NOERR);
}
int
cpy_coord_def(int in_id,int out_id,int rec_dim_id,char *var_nm,
int in_large, int out_large)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
int rec_dim_id: input input-file record dimension ID
char *var_nm: input variable name
int in_large: large file setting for input file
int out_large: large file setting for output file
int cpy_var_def(): output output-file variable ID
*/
{
const char *routine = NULL;
long spatial_dim;
int nbr_dim;
int temp;
int dim_out_id[2];
int var_out_id = -1;
/* Handle easiest situation first: in_large matches out_large */
if (in_large == out_large) {
return cpy_var_def(in_id, out_id, rec_dim_id, var_nm);
}
/* At this point, know that in_large != out_large, so some change to
the coord variable definition is needed. Also will need the
spatial dimension, so get that now.*/
ex_get_dimension(in_id, DIM_NUM_DIM, "dimension", &spatial_dim, routine);
if (in_large == 0 && out_large == 1) {
/* output file will have coordx, coordy, coordz (if 3d). See if
they are already defined in output file. Assume either all or
none are defined. */
temp = ncopts;
ncopts=0;
{
int var_out_idx = ncvarid(out_id, VAR_COORD_X);
int var_out_idy = ncvarid(out_id, VAR_COORD_Y);
int var_out_idz = ncvarid(out_id, VAR_COORD_Z);
ncopts = temp;
if (var_out_idx != -1 && var_out_idy != -1 &&
(spatial_dim == 2 || var_out_idz != -1)) {
return var_out_idx;
}
}
/* Get dimid of the num_nodes dimension in output file... */
dim_out_id[0]=ncdimid(out_id,DIM_NUM_NODES);
/* Define the variables in the output file */
/* Define according to the EXODUS file's IO_word_size */
nbr_dim = 1;
var_out_id=ncvardef(out_id,VAR_COORD_X,nc_flt_code(out_id),
nbr_dim, dim_out_id);
var_out_id=ncvardef(out_id,VAR_COORD_Y,nc_flt_code(out_id),
nbr_dim, dim_out_id);
if (spatial_dim == 3)
var_out_id=ncvardef(out_id,VAR_COORD_Z,nc_flt_code(out_id),
nbr_dim, dim_out_id);
}
if (in_large == 1 && out_large == 0) {
/* input file has coordx, coordy, coordz (if 3d); output will only
have "coord". See if is already defined in output file. */
temp = ncopts;
ncopts=0;
var_out_id = ncvarid(out_id, VAR_COORD);
ncopts = temp;
if (var_out_id != -1)
return var_out_id;
/* Get dimid of the spatial dimension and num_nodes dimensions in output file... */
dim_out_id[0]=ncdimid(out_id,DIM_NUM_DIM);
dim_out_id[1]=ncdimid(out_id,DIM_NUM_NODES);
/* Define the variable in the output file */
/* Define according to the EXODUS file's IO_word_size */
nbr_dim = 2;
var_out_id=ncvardef(out_id,VAR_COORD,nc_flt_code(out_id),
nbr_dim, dim_out_id);
}
return var_out_id;
}
int ex_create (const char *path,
int cmode,
int *comp_ws,
int *io_ws)
{
int exoid, time_dim, dims[1];
nclong lio_ws;
nclong filesiz;
float vers;
char errmsg[MAX_ERR_LENGTH];
char *mode_name;
int mode = 0;
exerrval = 0; /* clear error code */
/*
* See if "large file" mode was specified in a ex_create cmode. If
* so, then pass the NC_64BIT_OFFSET flag down to netcdf.
*/
if (cmode & EX_LARGE_MODEL || ex_large_model(-1) == 1) {
mode |= NC_64BIT_OFFSET;
}
/*
* set error handling mode to no messages, non-fatal errors
*/
ex_opts(exoptval); /* call required to set ncopts first time through */
if (cmode & EX_NOCLOBBER) {
mode |= NC_NOCLOBBER;
mode_name = "NOCLOBBER";
} else if (cmode & EX_CLOBBER) {
mode |= NC_CLOBBER;
mode_name = "CLOBBER";
} else {
exerrval = EX_BADFILEMODE;
sprintf(errmsg,"Error: invalid file create mode: %d, for file %s",
cmode,path);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
#ifndef TFLOP
mode |= NC_SHARE;
#endif
if ((exoid = nccreate (path, mode)) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: file create failed for %s, mode: %s",
path, mode_name);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* turn off automatic filling of netCDF variables
*/
if (ncsetfill (exoid, NC_NOFILL) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to set nofill mode in file id %d",
exoid);
ex_err("ex_create", errmsg, exerrval);
return (EX_FATAL);
}
/* initialize floating point size conversion. since creating new file,
* i/o wordsize attribute from file is zero.
*/
if (ex_conv_ini( exoid, comp_ws, io_ws, 0 ) != EX_NOERR) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: failed to init conversion routines in file id %d",
exoid);
ex_err("ex_create", errmsg, exerrval);
return (EX_FATAL);
}
/* put the EXODUS version number, and i/o floating point word size as
* netcdf global attributes
*/
/* store Exodus API version # as an attribute */
vers = (float)(EX_API_VERS);
if (ncattput (exoid, NC_GLOBAL, ATT_API_VERSION, NC_FLOAT, 1, &vers) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store Exodus II API version attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file version # as an attribute */
vers = (float)(EX_VERS);
if (ncattput (exoid, NC_GLOBAL, ATT_VERSION, NC_FLOAT, 1, &vers) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store Exodus II file version attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file float word size as an attribute */
lio_ws = (nclong)(*io_ws);
if (ncattput (exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, NC_LONG, 1, &lio_ws) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store Exodus II file float word size attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* store Exodus file size (1=large, 0=normal) as an attribute */
filesiz = (nclong)(((cmode & EX_LARGE_MODEL) != 0) || (ex_large_model(-1) == 1));
if (ncattput (exoid, NC_GLOBAL, ATT_FILESIZE, NC_LONG, 1, &filesiz) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store Exodus II file size attribute in file id %d",
exoid);
ex_err("ex_create",errmsg, exerrval);
return (EX_FATAL);
}
/* define some dimensions and variables
*/
/* create string length dimension */
if (ncdimdef (exoid, DIM_STR, (MAX_STR_LENGTH+1)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define string length in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* create line length dimension */
if (ncdimdef (exoid, DIM_LIN, (MAX_LINE_LENGTH+1)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define line length in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
/* create number "4" dimension; must be of type long */
if (ncdimdef (exoid, DIM_N4, 4L) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number \"4\" dimension in file id %d",exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
if ((time_dim = ncdimdef (exoid, DIM_TIME, NC_UNLIMITED)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define time dimension in file id %d", exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
dims[0] = time_dim;
if ((ncvardef (exoid, VAR_WHOLE_TIME, nc_flt_code(exoid), 1, dims)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define whole time step variable in file id %d",
exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete definition for file id %d", exoid);
ex_err("ex_create",errmsg,exerrval);
return (EX_FATAL);
}
return (exoid);
}
int ex_put_set_param (int exoid,
ex_entity_type set_type,
int set_id,
int num_entries_in_set,
int num_dist_fact_in_set)
{
int status;
size_t temp;
int dimid, varid, set_id_ndx, dims[1];
size_t start[1];
int num_sets;
int ldum;
int cur_num_sets, set_stat;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
char* dimptr;
char* idsptr;
char* statptr;
char* numentryptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
char* entryptr = NULL;
char* extraptr = NULL;
exerrval = 0; /* clear error code */
cdum = 0;
/* setup pointers based on set_type
NOTE: there is another block that sets more stuff later ... */
if (set_type == EX_NODE_SET) {
dimptr = DIM_NUM_NS;
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (set_type == EX_EDGE_SET) {
dimptr = DIM_NUM_ES;
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (set_type == EX_FACE_SET) {
dimptr = DIM_NUM_FS;
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (set_type == EX_SIDE_SET) {
dimptr = DIM_NUM_SS;
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (set_type == EX_ELEM_SET) {
dimptr = DIM_NUM_ELS;
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
else {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: invalid set type (%d)", set_type);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* first check if any of that set type is specified */
if ((status = nc_inq_dimid(exoid, dimptr, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss specified in file id %d", ex_name_of_object(set_type),
exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate set id entry */
ex_id_lkup(exoid, set_type, set_id);
if (exerrval != EX_LOOKUPFAIL) { /* found the side set id */
sprintf(errmsg,
"Error: %s %d already defined in file id %d", ex_name_of_object(set_type),
set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return(EX_FATAL);
}
/* Get number of sets specified for this file */
if ((status = nc_inq_dimlen(exoid,dimid,&temp)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
num_sets = temp;
/* Keep track of the total number of sets defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item finds the maximum number of sets defined
for a specific file and returns that value.
*/
cur_num_sets=ex_get_file_item(exoid, ex_get_counter_list(set_type));
if (cur_num_sets >= num_sets) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(set_type), num_sets,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item finds the current number of sets defined
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(set_type));
set_id_ndx = cur_num_sets + 1;
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
numentryptr = DIM_NUM_NOD_NS(set_id_ndx);
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
numentryptr = DIM_NUM_EDGE_ES(set_id_ndx);
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
numentryptr = DIM_NUM_FACE_FS(set_id_ndx);
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
numentryptr = DIM_NUM_SIDE_SS(set_id_ndx);
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
numentryptr = DIM_NUM_ELE_ELS(set_id_ndx);
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* write out information to previously defined variable */
/* first: get id of set id variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %d in file id %d", ex_name_of_object(set_type),
set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* write out set id */
start[0] = cur_num_sets;
ldum = (int)set_id;
if ((status = nc_put_var1_int(exoid, varid, start, &ldum)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %d in file id %d", ex_name_of_object(set_type),
set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (num_entries_in_set == 0) /* Is this a NULL set? */
set_stat = 0; /* change set status to NULL */
else
set_stat = 1; /* change set status to TRUE */
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d", ex_name_of_object(set_type),
exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
ldum = (int)set_stat;
if ((status = nc_put_var1_int(exoid, varid, start, &ldum)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s %d status to file id %d", ex_name_of_object(set_type),
set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
if (num_entries_in_set == 0) {/* Is this a NULL set? */
return(EX_NOERR);
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
/* define dimensions and variables */
if ((status = nc_def_dim(exoid, numentryptr,
num_entries_in_set, &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE)
{
sprintf(errmsg,
"Error: %s %d size already defined in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
else {
sprintf(errmsg,
"Error: failed to define number of entries in %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
goto error_ret;
}
/* create variable array in which to store the entry lists */
dims[0] = dimid;
if ((status = nc_def_var(exoid, entryptr, NC_INT, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: entry list already exists for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create entry list for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if (extraptr) {
if ((status = nc_def_var(exoid, extraptr, NC_INT, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: extra list already exists for %s %d in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create extra list for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
}
/* Create distribution factors variable if required */
if (num_dist_fact_in_set > 0) {
if (set_type == EX_NODE_SET) {
/* but num_dist_fact_in_set must equal number of nodes */
if (num_dist_fact_in_set != num_entries_in_set) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%d) not equal to # nodes (%d) in node set %d file id %d",
num_dist_fact_in_set, num_entries_in_set, set_id, exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* resuse dimid from entry lists */
} else {
if ((status = nc_def_dim(exoid, numdfptr,
num_dist_fact_in_set, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of dist factors in %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* create variable array in which to store the set distribution factors
*/
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: dist factors list already exists for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create dist factors list for %s %d in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d", exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_set_param",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_init (int exoid,
const char *title,
int num_dim,
int num_nodes,
int num_elem,
int num_elem_blk,
int num_node_sets,
int num_side_sets)
{
int numdimdim, numnoddim, elblkdim, nsetdim, ssetdim, strdim, dim[2], varid;
#if 0
/* used for header size calculations which are turned off for now */
int header_size, fixed_var_size, iows;
#endif
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
if ((ncdimid (exoid, DIM_NUM_DIM)) != -1)
{
exerrval = EX_MSG;
sprintf(errmsg,
"Error: initialization already done for file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
/* 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_init",errmsg,exerrval);
return (EX_FATAL);
}
/* define some attributes... */
if (ncattput (exoid, NC_GLOBAL, (const char*) ATT_TITLE,
NC_CHAR, strlen(title)+1, (void *)title) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define title attribute to file id %d", exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* ...and some dimensions... */
if ((numdimdim = ncdimdef (exoid, DIM_NUM_DIM, (long)num_dim)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of dimensions in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/*
* Need to handle "empty file" that may be the result of a strange
* load balance or some other strange run. Note that if num_node
* == 0, then num_elem must be zero since you cannot have elements
* with no nodes. It *is* permissible to have zero elements with
* non-zero node count.
*/
if (num_nodes > 0) {
if ((numnoddim = ncdimdef (exoid, DIM_NUM_NODES, (long)num_nodes)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of nodes in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (num_elem > 0) {
if (num_nodes <= 0) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: Cannot have non-zero element count if node count is zero.in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((ncdimdef (exoid, DIM_NUM_ELEM, (long)num_elem)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of elements in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* Can have nonzero num_elem_blk even if num_elem == 0 */
if (num_elem_blk > 0) {
if ((elblkdim = ncdimdef (exoid, DIM_NUM_EL_BLK, (long)num_elem_blk)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of element blocks in file id %d",
exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* ...and some variables */
/* element block id status array */
dim[0] = elblkdim;
if ((varid = ncvardef (exoid, VAR_STAT_EL_BLK, NC_LONG, 1, dim)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define element block status array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
#if 0
/* store property name as attribute of property array variable */
if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 7, "STATUS")) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element block property name %s in file id %d",
"STATUS",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
#endif
/* element block id array */
if ((varid = ncvardef (exoid, VAR_ID_EL_BLK, NC_LONG, 1, dim)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define element block id array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store property name as attribute of property array variable */
if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 3, "ID")) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store element block property name %s in file id %d",
"ID",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
}
/* node set id array: */
nsetdim = 0;
if (num_node_sets > 0) {
if ((nsetdim = ncdimdef (exoid, DIM_NUM_NS, (long)num_node_sets)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of node sets in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* node set id status array: */
dim[0] = nsetdim;
if ((varid = ncvardef (exoid, VAR_NS_STAT, NC_LONG, 1, dim)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create node sets status array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
#if 0
/* store property name as attribute of property array variable */
if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 7, "STATUS")) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store node set property name %s in file id %d",
"ID",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
#endif
/* node set id array: */
dim[0] = nsetdim;
if ((varid = ncvardef (exoid, VAR_NS_IDS, NC_LONG, 1, dim)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to create node sets property array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store property name as attribute of property array variable */
if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 3, "ID")) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store node set property name %s in file id %d",
"ID",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
}
/* side set id array: */
ssetdim = 0;
if (num_side_sets > 0) {
if ((ssetdim = ncdimdef (exoid, DIM_NUM_SS, (long)num_side_sets)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define number of side sets in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* side set id status array: */
dim[0] = ssetdim;
if ((varid = ncvardef (exoid, VAR_SS_STAT, NC_LONG, 1, dim)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define side set status in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
#if 0
/* store property name as attribute of property array variable */
if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 7, "STATUS")) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store side set property name %s in file id %d",
"ID",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
#endif
/* side set id array: */
if ((varid = ncvardef (exoid, VAR_SS_IDS, NC_LONG, 1, dim)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define side set property in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* store property name as attribute of property array variable */
if ((ncattput (exoid, varid, ATT_PROP_NAME, NC_CHAR, 3, "ID")) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store side set property name %s in file id %d",
"ID",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
}
/*
* To reduce the maximum dataset sizes, the storage of the nodal
* coordinates and the nodal variables was changed from a single
* dataset to a dataset per component or variable. However, we
* want to maintain some form of compatability with the old
* exodusII version. It is easy to do this on read; however, we
* also want to be able to store in the old format using the new
* library.
*
* The mode is set in the ex_create call. The setting can be checked
* via the ATT_FILESIZE attribute in the file (1=large,
* 0=normal). Also handle old files that do not contain this
* attribute.
*/
if (num_nodes > 0) {
if (ex_large_model(exoid) == 1) {
/* node coordinate arrays -- separate storage... */
/*
* Check that storage required for coordinates is less
* than 2GB which is maximum size permitted by netcdf
* (in large file mode). 1<<29 == max number of integer items.
*/
int shift = nc_flt_code(exoid) == NC_DOUBLE ? 28 : 29;
if (num_nodes > (1<<shift)) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Size to store nodal coordinates exceeds 2GB in file id %d",
exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
dim[0] = numnoddim;
if (num_dim > 0) {
if (ncvardef (exoid, VAR_COORD_X, nc_flt_code(exoid), 1, dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define node x coordinate array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (num_dim > 1) {
if (ncvardef (exoid, VAR_COORD_Y, nc_flt_code(exoid), 1, dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define node y coordinate array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (num_dim > 2) {
if (ncvardef (exoid, VAR_COORD_Z, nc_flt_code(exoid), 1, dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define node z coordinate array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
} else {
/* node coordinate arrays: -- all stored together (old method) */
dim[0] = numdimdim;
dim[1] = numnoddim;
if (ncvardef (exoid, VAR_COORD, nc_flt_code(exoid), 2, dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define node coordinate array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
/* inquire previously defined dimensions */
if ((strdim = ncdimid (exoid, DIM_STR)) < 0)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* coordinate names array */
dim[0] = numdimdim;
dim[1] = strdim;
if (ncvardef (exoid, VAR_NAME_COOR, NC_CHAR, 2, dim) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define coordinate name array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* Element block names... */
if (num_elem_blk > 0) {
dim[0] = elblkdim;
dim[1] = strdim;
if (ncvardef (exoid, VAR_NAME_EL_BLK, NC_CHAR, 2, dim) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define element block name array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* Nodeset names... */
if (num_node_sets > 0) {
dim[0] = nsetdim;
dim[1] = strdim;
if (ncvardef (exoid, VAR_NAME_NS, NC_CHAR, 2, dim) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define nodeset name array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* Sideset names... */
if (num_side_sets > 0) {
dim[0] = ssetdim;
dim[1] = strdim;
if (ncvardef (exoid, VAR_NAME_SS, NC_CHAR, 2, dim) == -1) {
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to define sideset name array in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* leave define mode */
#if 1
if (ncendef (exoid) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete variable definitions in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
#else
/* estimate (guess) size of header of netCDF file */
header_size = 1200 +
num_elem_blk * 800 +
num_node_sets * 220 +
num_side_sets * 300;
if (header_size > MAX_HEADER_SIZE) header_size = MAX_HEADER_SIZE;
/* estimate (guess) size of fixed size variable section of netCDF file */
if (nc_flt_code(exoid) == NC_DOUBLE)
iows = 8;
else
iows = 4;
fixed_var_size = num_dim * num_nodes * iows +
num_nodes * sizeof(int) +
num_elem * 16 * sizeof(int) +
num_elem_blk * sizeof(int) +
num_node_sets * num_nodes/100 * sizeof(int) +
num_node_sets * num_nodes/100 * iows +
num_node_sets * sizeof(int) +
num_side_sets * num_elem/100 * 2 * sizeof(int) +
num_side_sets * num_elem/100 * iows +
num_side_sets * sizeof(int);
/* With netcdf-3.4, this produces very large files on the
* SGI. Also with netcdf-3.5beta3
*/
/*
* This is also causing other problems on other systems .. disable for now
*/
if (nc__enddef (exoid,
header_size, NC_ALIGN_CHUNK,
fixed_var_size, NC_ALIGN_CHUNK) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to complete variable definitions in file id %d",exoid);
ex_err("ex_put_init",errmsg,exerrval);
return (EX_FATAL);
}
#endif
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (ncendef (exoid) == -1) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_init",errmsg,exerrval);
}
return (EX_FATAL);
}
