int ex_set_int64_status(int exoid, int mode)
{
/* ex_set_int64_status() sets the value of the INT64_API flags
which specify how integer types are passed/returned as int64 types in the API
Mode can be one of:
0 All are passed as int32_t values.
EX_MAPS_INT64_API All maps (id, order, ...) passed as int64_t values
EX_IDS_INT64_API All entity ids (sets, blocks, maps) are passed as int64_t values
EX_BULK_INT64_API
EX_ALL_INT64_API (EX_MAPS_INT64_API|EX_IDS_INT64_API|EX_BULK_INT64_API)
*/
int api_mode = 0;
int db_mode = 0;
struct ex_file_item* file = ex_find_file_item(exoid);
exerrval = 0; /* clear error code */
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d for ex_int64_status().",exoid);
ex_err("ex_int64_status",errmsg,exerrval);
return 0;
}
/* Strip of all non-INT64_API values */
api_mode = mode & EX_ALL_INT64_API;
db_mode = file->int64_status & EX_ALL_INT64_DB;
file->int64_status = api_mode | db_mode;
return file->int64_status;
}
/* type = 1 for integer, 2 for real, 3 for character */
void ex_compress_variable(int exoid, int varid, int type)
{
#if NC_HAS_HDF5
struct ex_file_item *file = ex_find_file_item(exoid);
if (!file) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unknown file id %d for ex_compress_variable().",
exoid);
ex_err("ex_compress_variable", errmsg, exerrval);
}
else {
int deflate_level = file->compression_level;
int compress = 1;
int shuffle = file->shuffle;
if (!file->is_parallel && deflate_level > 0 && (file->file_type == 2 || file->file_type == 3)) {
nc_def_var_deflate(exoid, varid, shuffle, compress, deflate_level);
}
#if defined(PARALLEL_AWARE_EXODUS)
if (type != 3 && file->is_parallel && file->is_mpiio) {
nc_var_par_access(exoid, varid, NC_COLLECTIVE);
}
#endif
}
#endif
}
/* type = 1 for integer, 2 for real, 3 for character */
void ex_compress_variable(int exoid, int varid, int type)
{
#if !defined(NOT_NETCDF4)
struct file_item* file = ex_find_file_item(exoid);
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d for ex_compress_variable().",exoid);
ex_err("ex_compress_variable",errmsg,exerrval);
}
else {
int deflate_level = file->compression_level;
int compress = 1;
int shuffle = file->shuffle;
#if 0
if (type == 2)
shuffle = 0;
#endif
if (deflate_level > 0 && (file->file_type == 2 || file->file_type == 3)) {
nc_def_var_deflate(exoid, varid, shuffle, compress, deflate_level);
}
}
#endif
}
int ex_int64_status(int exoid)
{
/* ex_int64_status() returns an int that can be tested
against the defines listed below to determine which, if any,
'types' in the database are to be stored as int64 types and which, if any,
types are passed/returned as int64 types in the API
Defines:
EX_MAPS_INT64_DB All maps (id, order, ...) store int64_t values
EX_IDS_INT64_DB All entity ids (sets, blocks, maps) are int64_t values
EX_BULK_INT64_DB
EX_ALL_INT64_DB (EX_MAPS_INT64_DB|EX_IDS_INT64_DB|EX_BULK_INT64_DB)
EX_MAPS_INT64_API All maps (id, order, ...) passed as int64_t values
EX_IDS_INT64_API All entity ids (sets, blocks, maps) are passed as int64_t values
EX_BULK_INT64_API
EX_ALL_INT64_API (EX_MAPS_INT64_API|EX_IDS_INT64_API|EX_BULK_INT64_API)
*/
struct ex_file_item* file = ex_find_file_item(exoid);
exerrval = 0; /* clear error code */
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d for ex_int64_status().",exoid);
ex_err("ex_int64_status",errmsg,exerrval);
return 0;
}
return file->int64_status;
}
int ex_set_option(int exoid, ex_option_type option, int option_value)
{
struct ex_file_item* file = ex_find_file_item(exoid);
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d for ex_set_option().",exoid);
ex_err("ex_set_option",errmsg,exerrval);
return EX_FATAL;
}
exerrval = 0; /* clear error code */
switch (option) {
case EX_OPT_MAX_NAME_LENGTH:
file->maximum_name_length = option_value;
break;
case EX_OPT_COMPRESSION_TYPE: /* Currently not used. GZip by default */
break;
case EX_OPT_COMPRESSION_LEVEL: /* 0 (disabled/fastest) ... 9 (best/slowest) */
/* Check whether file type supports compression... */
if (file->file_type == 2 || file->file_type == 3) {
int value = option_value;
if (value > 9) value = 9;
if (value < 0) value = 0;
file->compression_level = value;
}
else {
file->compression_level = 0;
}
break;
case EX_OPT_COMPRESSION_SHUFFLE: /* 0 (disabled); 1 (enabled) */
file->shuffle = option_value != 0 ? 1 : 0;
break;
case EX_OPT_INTEGER_SIZE_API: /* See *_INT64_* values above */
ex_set_int64_status(exoid, option_value);
break;
case EX_OPT_INTEGER_SIZE_DB: /* (query only) */
break;
default:
{
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_FATAL;
sprintf(errmsg,"Error: invalid option %d for ex_set_option().",(int)option);
ex_err("ex_set_option",errmsg,exerrval);
return EX_FATAL;
}
}
return EX_NOERR;
}
int ex_is_parallel(int exoid)
{
/*! ex_is_parallel() returns 1 (true) or 0 (false) depending on whether
* the file was opened in parallel or serial/file-per-processor mode.
* Note that in this case parallel assumes the output of a single file,
* not a parallel run using file-per-processor.
*/
struct ex_file_item* file = ex_find_file_item(exoid);
exerrval = 0; /* clear error code */
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d",exoid);
ex_err("ex_is_parallel",errmsg,exerrval);
return(EX_FATAL);
}
/* Stored as 1 for parallel, 0 for serial or file-per-processor */
return file->is_parallel;
}
nc_type nc_flt_code( int exoid )
{
/* nc_flt_code() returns either NC_FLOAT or NC_DOUBLE, based on the parameters
* with which ex_conv_ini() was called. nc_flt_code() is used as the nc_type
* parameter on ncvardef() calls that define floating point variables.
*
* "exoid" is some integer which uniquely identifies the file of interest.
*/
struct ex_file_item* file = ex_find_file_item(exoid);
exerrval = 0; /* clear error code */
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d for nc_flt_code().",exoid);
ex_err("nc_flt_code",errmsg,exerrval);
return (nc_type) -1;
}
return file->netcdf_type_code;
}
int ex_comp_ws( int exoid )
{
/*!
* ex_comp_ws() returns 4 (i.e. sizeof(float)) or 8 (i.e. sizeof(double)),
* depending on the value of floating point word size used to initialize
* the conversion facility for this file id (exoid).
* \param exoid integer which uniquely identifies the file of interest.
*/
struct ex_file_item* file = ex_find_file_item(exoid);
exerrval = 0; /* clear error code */
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d",exoid);
ex_err("ex_comp_ws",errmsg,exerrval);
return(EX_FATAL);
}
/* Stored as 0 for 4-byte; 1 for 8-byte */
return (file->user_compute_wordsize+1)*4;
}
int ex_get_block_param( int exoid,
ex_block *block )
{
int dimid, connid, blk_id_ndx;
size_t len, i;
char errmsg[MAX_ERR_LENGTH];
int status;
const char* dnument;
const char* dnumnod;
const char* dnumedg;
const char* dnumfac;
const char* dnumatt;
const char* ablknam;
const char* vblkcon;
struct ex_file_item* file = ex_find_file_item(exoid);
if (!file ) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d in ex_get_block_param().",exoid);
ex_err("ex_get_block_param",errmsg,exerrval);
}
exerrval = 0;
/* First, locate index of element block id in VAR_ID_EL_BLK array */
blk_id_ndx = ex_id_lkup(exoid,block->type,block->id);
if (exerrval != 0) {
strcpy(block->topology, "NULL"); /* NULL element type name */
block->num_entry = 0; /* no elements */
block->num_nodes_per_entry = 0; /* no nodes */
block->num_edges_per_entry = 0;
block->num_faces_per_entry = 0;
block->num_attribute = 0; /* no attributes */
if (exerrval == EX_NULLENTITY) { /* NULL element block? */
return (EX_NOERR);
}
sprintf(errmsg,
"Error: failed to locate %s id %"PRId64" in id array in file id %d",
ex_name_of_object(block->type), block->id,exoid);
ex_err("ex_get_block_param",errmsg,exerrval);
return (EX_FATAL);
}
switch (block->type) {
case EX_EDGE_BLOCK:
dnument = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnumedg = 0;
dnumfac = 0;
dnumatt = DIM_NUM_ATT_IN_EBLK(blk_id_ndx);
vblkcon = VAR_EBCONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
case EX_FACE_BLOCK:
dnument = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnumedg = 0; /* it is possible this might be non-NULL some day */
dnumfac = 0;
dnumatt = DIM_NUM_ATT_IN_FBLK(blk_id_ndx);
vblkcon = VAR_FBCONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
case EX_ELEM_BLOCK:
dnument = DIM_NUM_EL_IN_BLK(blk_id_ndx);
dnumnod = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnumedg = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnumfac = DIM_NUM_FAC_PER_EL(blk_id_ndx);
dnumatt = DIM_NUM_ATT_IN_BLK(blk_id_ndx);
vblkcon = VAR_CONN(blk_id_ndx);
ablknam = ATT_NAME_ELB;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Bad block type parameter (%d) specified for file id %d.",
block->type, exoid );
return (EX_FATAL);
}
/* inquire values of some dimensions */
if ((status = nc_inq_dimid (exoid, dnument, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of entities in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id,exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_dimlen (exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in block %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
block->num_entry = len;
if ((status = nc_inq_dimid (exoid, dnumnod, &dimid)) != NC_NOERR) {
/* undefined => no node entries per element */
len = 0;
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes/entity in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
}
block->num_nodes_per_entry = len;
if (!file->has_edges || block->type != EX_ELEM_BLOCK) {
block->num_edges_per_entry = 0;
} else {
if ((status = nc_inq_dimid (exoid, dnumedg, &dimid)) != NC_NOERR) {
/* undefined => no edge entries per element */
len = 0;
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of edges/entry in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
}
block->num_edges_per_entry = len;
}
if (!file->has_faces || block->type != EX_ELEM_BLOCK ) {
block->num_faces_per_entry = 0;
} else {
if ((status = nc_inq_dimid (exoid, dnumfac, &dimid)) != NC_NOERR) {
/* undefined => no face entries per element */
len = 0;
} else {
if ((status = nc_inq_dimlen(exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of faces/entity in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
}
block->num_faces_per_entry = len;
}
if ((status = nc_inq_dimid (exoid, dnumatt, &dimid)) != NC_NOERR) {
/* dimension is undefined */
block->num_attribute = 0;
} else {
if ((status = nc_inq_dimlen(exoid, dimid, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of attributes in %s %"PRId64" in file id %d",
ex_name_of_object(block->type),block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
block->num_attribute = len;
}
if (block->num_nodes_per_entry > 0) {
; /* Do nothing, vblkcon should be correctly set already */
} else if (block->num_edges_per_entry > 0) {
vblkcon = VAR_EBCONN(blk_id_ndx);
} else if (block->num_faces_per_entry > 0) {
vblkcon = VAR_FCONN(blk_id_ndx);
}
if (vblkcon) {
/* look up connectivity array for this element block id */
if ((status = nc_inq_varid (exoid, vblkcon, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(block->type), block->id,exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_attlen (exoid, connid, ablknam, &len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s %"PRId64" type in file id %d",
ex_name_of_object(block->type), block->id,exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
if (len > (MAX_STR_LENGTH+1)) {
len = MAX_STR_LENGTH;
sprintf (errmsg,
"Warning: %s %"PRId64" type will be truncated to %ld chars",
ex_name_of_object(block->type), block->id, (long)len);
ex_err("ex_get_block_param",errmsg,EX_MSG);
}
for (i=0; i < MAX_STR_LENGTH+1; i++) {
block->topology[i] = '\0';
/* get the element type name */
}if ((status = nc_get_att_text (exoid, connid, ablknam, block->topology)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to get %s %"PRId64" type in file id %d",
ex_name_of_object(block->type), block->id, exoid);
ex_err("ex_get_block_param",errmsg, exerrval);
return(EX_FATAL);
}
/* get rid of trailing blanks */
ex_trim_internal(block->topology);
}
return (EX_NOERR);
}
int ex_open_int(const char *path, int mode, int *comp_ws, int *io_ws, float *version,
int run_version)
{
int exoid;
int status, stat_att, stat_dim;
nc_type att_type = NC_NAT;
size_t att_len = 0;
int old_fill;
int file_wordsize;
int dim_str_name;
int int64_status = 0;
int nc_mode = 0;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
/* set error handling mode to no messages, non-fatal errors */
ex_opts(exoptval); /* call required to set ncopts first time through */
if (run_version != EX_API_VERS_NODOT && warning_output == 0) {
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,
"EXODUS: Warning: This code was compiled with exodus "
"version %d.%02d,\n but was linked with exodus "
"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);
warning_output = 1;
}
if ((mode & EX_READ) && (mode & EX_WRITE)) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Cannot specify both EX_READ and EX_WRITE");
ex_err(__func__, errmsg, EX_BADFILEMODE);
EX_FUNC_LEAVE(EX_FATAL);
}
/* The EX_READ mode is the default if EX_WRITE is not specified... */
if (!(mode & EX_WRITE)) { /* READ ONLY */
nc_mode = NC_NOWRITE | NC_SHARE;
#if NC_HAS_DISKLESS
if (mode & EX_DISKLESS) {
nc_mode |= NC_DISKLESS;
}
#endif
if ((status = nc_open(path, nc_mode, &exoid)) != NC_NOERR) {
/* NOTE: netCDF returns an id of -1 on an error - but no error code! */
/* It is possible that the user is trying to open a netcdf4
file, but the netcdf4 capabilities aren't available in the
netcdf linked to this library. Note that we can't just use a
compile-time define since we could be using a shareable
netcdf library, so the netcdf4 capabilities aren't known
until runtime...
Later versions of netcdf-4.X have a function that can be
queried to determine whether the library being used was
compiled with --enable-netcdf4, but not everyone is using that
version yet, so we may have to do some guessing...
At this time, query the beginning of the file and see if it
is an HDF-5 file and if it is assume that the open failure
is due to the netcdf library not enabling netcdf4 features unless
we have the define that shows it is enabled, then assume other error...
*/
int type = 0;
ex_check_file_type(path, &type);
if (type == 5) {
#if NC_HAS_HDF5
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the netcdf-4 "
"file:\n\t'%s'\n\t failed. The netcdf library supports "
"netcdf-4 so there must be a filesystem or some other "
"issue \n",
path);
#else
/* This is an hdf5 (netcdf4) file. If NC_HAS_HDF5 is not defined,
then we either don't have hdf5 support in this netcdf version,
OR this is an older netcdf version that doesn't provide that define.
In either case, we don't have enough information, so we
assume that the netcdf doesn't have netcdf4 capabilities
enabled. Tell the user...
*/
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the netcdf-4 "
"file:\n\t'%s'\n\t. Either the netcdf library does not "
"support netcdf-4 or there is a filesystem or some "
"other issue \n",
path);
#endif
}
else if (type == 4) {
#if defined(NC_64BIT_DATA)
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the CDF5 "
"file:\n\t'%s'\n\t failed. The netcdf library supports "
"CDF5-type files so there must be a filesystem or some other "
"issue \n",
path);
#else
/* This is an cdf5 (64BIT_DATA) file. If NC_64BIT_DATA is not defined,
then we either don't have cdf5 support in this netcdf version,
OR this is an older netcdf version that doesn't provide that define.
In either case, we don't have enough information, so we
assume that the netcdf doesn't have cdf5 capabilities
enabled. Tell the user...
*/
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the CDF5 "
"file:\n\t'%s'\n\t. Either the netcdf library does not "
"support CDF5 or there is a filesystem or some "
"other issue \n",
path);
#endif
}
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to open %s read only", path);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
else { /* (mode & EX_WRITE) READ/WRITE */
nc_mode = NC_WRITE | NC_SHARE;
#if NC_HAS_DISKLESS
if (mode & EX_DISKLESS) {
nc_mode |= NC_DISKLESS;
}
#endif
if ((status = nc_open(path, nc_mode, &exoid)) != NC_NOERR) {
/* NOTE: netCDF returns an id of -1 on an error - but no error code! */
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to open %s write only", path);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* turn off automatic filling of netCDF variables */
if ((status = nc_set_fill(exoid, NC_NOFILL, &old_fill)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to set nofill mode in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
stat_att = nc_inq_att(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, &att_type, &att_len);
stat_dim = nc_inq_dimid(exoid, DIM_STR_NAME, &dim_str_name);
if (stat_att != NC_NOERR || stat_dim != NC_NOERR) {
if ((status = nc_redef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to place file id %d into define mode",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (stat_att != NC_NOERR) {
int max_so_far = 32;
nc_put_att_int(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, NC_INT, 1, &max_so_far);
}
/* If the DIM_STR_NAME variable does not exist on the database, we need to
* add it now. */
if (stat_dim != NC_NOERR) {
/* Not found; set to default value of 32+1. */
int max_name = ex_default_max_name_length < 32 ? 32 : ex_default_max_name_length;
if ((status = nc_def_dim(exoid, DIM_STR_NAME, max_name + 1, &dim_str_name)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define string name dimension in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
if ((status = nc_enddef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
/* determine version of EXODUS file, and the word size of
* floating point and integer values stored in the file
*/
if ((status = nc_get_att_float(exoid, NC_GLOBAL, ATT_VERSION, version)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get database version for file id: %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* check ExodusII file version - old version 1.x files are not supported */
if (*version < 2.0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Unsupported file version %.2f in file id: %d",
*version, exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
if (nc_get_att_int(exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, &file_wordsize) != NC_NOERR) {
/* try old (prior to db version 2.02) attribute name */
if ((status = nc_get_att_int(exoid, NC_GLOBAL, ATT_FLT_WORDSIZE_BLANK, &file_wordsize)) !=
NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get file wordsize from file id: %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* See if int64 status attribute exists and if so, what data is stored as
* int64
* Older files don't have the attribute, so it is not an error if it is
* missing
*/
if (nc_get_att_int(exoid, NC_GLOBAL, ATT_INT64_STATUS, &int64_status) != NC_NOERR) {
int64_status = 0; /* Just in case it gets munged by a failed get_att_int call */
}
/* Merge in API int64 status flags as specified by caller of function... */
int64_status |= (mode & EX_ALL_INT64_API);
/* Verify that there is not an existing file_item struct for this
exoid This could happen (and has) when application calls
ex_open(), but then closes file using nc_close() and then reopens
file. NetCDF will possibly reuse the exoid which results in
internal corruption in exodus data structures since exodus does
not know that file was closed and possibly new file opened for
this exoid
*/
if (ex_find_file_item(exoid) != NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: There is an existing file already using the file "
"id %d which was also assigned to file %s.\n\tWas "
"nc_close() called instead of ex_close() on an open Exodus "
"file?\n",
exoid, path);
ex_err(__func__, errmsg, EX_BADFILEID);
nc_close(exoid);
EX_FUNC_LEAVE(EX_FATAL);
}
/* initialize floating point and integer size conversion. */
if (ex_conv_ini(exoid, comp_ws, io_ws, file_wordsize, int64_status, 0, 0, 0) != EX_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to initialize conversion routines in file id %d", exoid);
ex_err(__func__, errmsg, EX_LASTERR);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(exoid);
}
static int ex_inquire_internal (int exoid,
int req_info,
int64_t *ret_int,
float *ret_float,
char *ret_char)
{
int dimid, varid, tmp_num;
void_int *ids = NULL;
size_t i;
size_t ldum = 0;
size_t num_sets, idum;
int *stat_vals;
char errmsg[MAX_ERR_LENGTH];
int status;
char tmp_title[2048];
exerrval = 0; /* clear error code */
if (ret_char) *ret_char = '\0'; /* Only needs to be non-null for TITLE */
if (!ret_int) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: integer argument is NULL which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
switch (req_info) {
case EX_INQ_FILE_TYPE:
/* obsolete call */
/*returns "r" for regular EXODUS II file or "h" for history EXODUS file*/
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: file type inquire is obsolete");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_WARN);
case EX_INQ_API_VERS:
/* returns the EXODUS II API version number */
if (!ret_float) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: float argument is NULL for EX_INQ_API_VERS which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (nc_get_att_float(exoid, NC_GLOBAL, ATT_API_VERSION, ret_float) != NC_NOERR)
{ /* try old (prior to db version 2.02) attribute name */
if ((status = nc_get_att_float (exoid, NC_GLOBAL, ATT_API_VERSION_BLANK,ret_float)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get EXODUS API version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
break;
case EX_INQ_DB_VERS:
/* returns the EXODUS II database version number */
if (!ret_float) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: float argument is NULL for EX_INQ_DB_VERS which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_get_att_float (exoid, NC_GLOBAL, ATT_VERSION, ret_float)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get EXODUS database version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_LIB_VERS:
/* returns the EXODUS II Library version number */
if (ret_float)
flt_cvt(ret_float, EX_API_VERS);
*ret_int = EX_API_VERS_NODOT;
break;
case EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH:
/* Return the MAX_NAME_LENGTH size for this database
It will not include the space for the trailing null, so if it
is defined as 33 on the database, 32 will be returned.
*/
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &dimid)) != NC_NOERR) {
/* If not found, then an older database */
*ret_int = 32;
}
else {
/* Get the name string length */
size_t name_length = 0;
if ((status = nc_inq_dimlen(exoid,dimid,&name_length)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get name string length in file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
else {
*ret_int = name_length-1;
}
}
break;
case EX_INQ_DB_MAX_USED_NAME_LENGTH:
/* Return the value of the ATT_MAX_NAME_LENGTH attribute (if it
exists) which is the maximum length of any entity, variable,
attribute, property name written to this database. If the
attribute does not exist, then '32' is returned. The length
does not include the trailing null.
*/
{
nc_type att_type = NC_NAT;
size_t att_len = 0;
*ret_int = 32; /* Default size consistent with older databases */
status = nc_inq_att(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, &att_type, &att_len);
if (status == NC_NOERR && att_type == NC_INT) {
/* The attribute exists, return it... */
nc_get_att_longlong(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, (long long*)ret_int);
}
}
break;
case EX_INQ_MAX_READ_NAME_LENGTH:
{
/* Returns the user-specified maximum size of names that will be
* returned to the user by any of the ex_get_ routines. If the
* name is longer than this value, it will be truncated. The
* default if not set by the client is 32 characters. The value
* does not include the trailing null.
*/
struct file_item* file = ex_find_file_item(exoid);
if (!file ) {
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d for ex_inquire_int().",exoid);
ex_err("ex_intquire",errmsg,exerrval);
*ret_int = 0;
}
else {
*ret_int = file->maximum_name_length;
}
}
break;
case EX_INQ_TITLE:
if (!ret_char) {
sprintf(errmsg,
"Error: Requested title, but character pointer was null for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
} else {
/* returns the title of the database */
if ((status = nc_get_att_text (exoid, NC_GLOBAL, ATT_TITLE, tmp_title)) != NC_NOERR) {
*ret_char = '\0';
exerrval = status;
sprintf(errmsg,
"Error: failed to get database title for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
} else {
strncpy(ret_char, tmp_title, MAX_LINE_LENGTH+1);
ret_char[MAX_LINE_LENGTH] = '\0';
}
}
break;
case EX_INQ_DIM:
/* returns the dimensionality (2 or 3, for 2-d or 3-d) of the database */
if (ex_get_dimension(exoid, DIM_NUM_DIM, "database dimensionality", &ldum, &dimid, "ex_inquire") != NC_NOERR)
return EX_FATAL;
*ret_int = ldum;
break;
case EX_INQ_NODES:
/* returns the number of nodes */
if (ex_get_dimension(exoid, DIM_NUM_NODES, "nodes", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_ELEM:
/* returns the number of elements */
if (ex_get_dimension(exoid, DIM_NUM_ELEM, "elements", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_ELEM_BLK:
/* returns the number of element blocks */
if (ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element blocks", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NODE_SETS:
/* returns the number of node sets */
if (ex_get_dimension(exoid, DIM_NUM_NS, "node sets", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NS_NODE_LEN:
/* returns the length of the concatenated node sets node list */
ex_get_concat_set_len(exoid, ret_int,"node",EX_NODE_SET,DIM_NUM_NS,VAR_NS_STAT,"num_nod_ns",0);
break;
case EX_INQ_NS_DF_LEN:
/* returns the length of the concatenated node sets dist factor list */
/*
Determine the concatenated node sets distribution factor length:
2. Check see if the dist factor variable for a node set id exists.
3. If it exists, goto step 4, else the length is zero.
4. Get the dimension of the number of nodes in the node set -0
use this value as the length as by definition they are the same.
5. Sum the individual lengths for the total list length.
*/
*ret_int = 0; /* default value if no node sets defined */
if (nc_inq_dimid (exoid, DIM_NUM_NS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++) {
if ((status = nc_inq_varid (exoid, VAR_FACT_NS(i+1), &varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) {
idum = 0; /* this dist factor doesn't exist */
} else {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist fact for %"ST_ZU"'th node set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimid (exoid, DIM_NUM_NOD_NS(i+1), &dimid)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in %"ST_ZU"'th node set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen (exoid, dimid, &idum)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in %"ST_ZU"'th node set in file id %d",
i,exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
*ret_int += idum;
}
}
break;
case EX_INQ_SIDE_SETS:
/* returns the number of side sets */
if (ex_get_dimension(exoid, DIM_NUM_SS, "side sets", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_SS_NODE_LEN:
/* returns the length of the concatenated side sets node list */
*ret_int = 0; /* default return value */
if (nc_inq_dimid (exoid, DIM_NUM_SS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int64_t)))) { /* May be getting 2x what is needed, but should be OK */
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL) {
sprintf(errmsg,
"Error: failed to get side set ids in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
free (ids);
sprintf(errmsg,
"Error: failed to allocate memory for side set status array for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((status = nc_inq_varid (exoid, VAR_SS_STAT, &varid)) == NC_NOERR) {
/* if status array exists, 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 (ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get element block status array from file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
/* walk id list, get each side set node length and sum for total */
for (i=0; i<num_sets; i++) {
ex_entity_id id;
if (stat_vals[i] == 0) /* is this object null? */
continue;
if (ex_int64_status(exoid) & EX_IDS_INT64_API)
id = ((int64_t*)ids)[i];
else
id = ((int*)ids)[i];
if ((status = ex_get_side_set_node_list_len(exoid, id, &tmp_num)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to side set %"PRId64" node length in file id %d",
id,exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(stat_vals);
free(ids);
return (EX_FATAL);
}
*ret_int += tmp_num;
}
free(stat_vals);
free (ids);
}
break;
case EX_INQ_SS_ELEM_LEN:
/* returns the length of the concatenated side sets element list */
ex_get_concat_set_len(exoid, ret_int,"side",EX_SIDE_SET,DIM_NUM_SS,VAR_SS_STAT,"num_side_ss",0);
break;
case EX_INQ_SS_DF_LEN:
/* returns the length of the concatenated side sets dist factor list */
/*
Determine the concatenated side sets distribution factor length:
1. Get the side set ids list.
2. Check see if the dist factor dimension for a side set id exists.
3. If it exists, goto step 4, else set the individual length to zero.
4. Sum the dimension value into the running total length.
*/
*ret_int = 0;
/* first check see if any side sets exist */
if (nc_inq_dimid (exoid, DIM_NUM_SS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen (exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++) {
if ((status = nc_inq_dimid (exoid, DIM_NUM_DF_SS(i+1), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
ldum = 0; /* this dist factor doesn't exist */
} else {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist fact for %"ST_ZU"'th side set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &ldum)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of dist factors in %"ST_ZU"'th side set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
*ret_int += ldum;
}
}
break;
case EX_INQ_QA:
/* returns the number of QA records */
if (ex_get_dimension(exoid, DIM_NUM_QA, "QA records", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_INFO:
/* returns the number of information records */
if (ex_get_dimension(exoid, DIM_NUM_INFO, "info records", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_TIME:
/* returns the number of time steps stored in the database */
if (ex_get_dimension(exoid, DIM_TIME, "time dimension", &ldum, &dimid, "ex_inquire") != NC_NOERR)
return EX_FATAL;
*ret_int = ldum;
break;
case EX_INQ_EB_PROP:
/* returns the number of element block properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_BLOCK);
break;
case EX_INQ_NS_PROP:
/* returns the number of node set properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_SET);
break;
case EX_INQ_SS_PROP:
/* returns the number of side set properties */
*ret_int = ex_get_num_props (exoid, EX_SIDE_SET);
break;
case EX_INQ_ELEM_MAP:
/* returns the number of element maps */
if (ex_get_dimension(exoid, DIM_NUM_EM, "element maps", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_EM_PROP:
/* returns the number of element map properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_MAP);
break;
case EX_INQ_NODE_MAP:
/* returns the number of node maps */
if (ex_get_dimension(exoid, DIM_NUM_NM, "node maps", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NM_PROP:
/* returns the number of node map properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_MAP);
break;
case EX_INQ_EDGE:
/* returns the number of edges (defined across all edge blocks). */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_EDGE, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_EDGE_BLK:
/* returns the number of edge blocks. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ED_BLK, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_EDGE_SETS:
/* returns the number of edge sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ES, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_ES_LEN:
/* returns the length of the concatenated edge set edge list. */
ex_get_concat_set_len(exoid, ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,"num_edge_es",0);
break;
case EX_INQ_ES_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,"num_df_es",1);
break;
case EX_INQ_EDGE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_EDGE_BLOCK );
break;
case EX_INQ_ES_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_EDGE_SET );
break;
case EX_INQ_FACE:
/* returns the number of faces (defined across all face blocks). */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FACE, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_BLK:
/* returns the number of face blocks. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FA_BLK, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_SETS:
/* returns the number of face sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FS, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FS_LEN:
/* returns the length of the concatenated edge set edge list. */
ex_get_concat_set_len(exoid, ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,"num_face_fs",0);
break;
case EX_INQ_FS_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,"num_df_fs",1);
break;
case EX_INQ_FACE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_FACE_BLOCK );
break;
case EX_INQ_FS_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_FACE_SET );
break;
case EX_INQ_ELEM_SETS:
/* returns the number of element sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ELS, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_ELS_LEN:
/* returns the length of the concatenated element set element list. */
ex_get_concat_set_len(exoid, ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,"num_ele_els",0);
break;
case EX_INQ_ELS_DF_LEN:
/* returns the length of the concatenated element set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,"num_df_els",1);
break;
case EX_INQ_ELS_PROP:
/* returns the number of integer properties stored for each element set. */
*ret_int = ex_get_num_props( exoid, EX_ELEM_SET );
break;
case EX_INQ_EDGE_MAP:
/* returns the number of edge maps. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_EDM, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_MAP:
/* returns the number of face maps. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FAM, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_COORD_FRAMES:
/* return the number of coordinate frames */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_CFRAMES, 1) != EX_NOERR) return EX_FATAL;
break;
default:
*ret_int = 0;
exerrval = EX_FATAL;
sprintf(errmsg, "Error: invalid inquiry %d", req_info);
ex_err("ex_inquire",errmsg,exerrval);
return(EX_FATAL);
}
return (EX_NOERR);
}
int ex_create_par_int(const char *path, int cmode, int *comp_ws, int *io_ws, MPI_Comm comm,
MPI_Info info, int run_version)
{
int exoid;
int status;
int dimid;
int old_fill;
int lio_ws;
int filesiz;
float vers;
char errmsg[MAX_ERR_LENGTH];
char *mode_name;
int nc_mode = 0;
int int64_status;
const char *routine = "ex_create_par";
int pariomode = 0;
int is_mpiio = 0;
int is_pnetcdf = 0;
unsigned int my_mode = cmode;
/* Contains a 1 in all bits corresponding to file modes */
static unsigned int all_modes = EX_NORMAL_MODEL | EX_64BIT_OFFSET | EX_64BIT_DATA | EX_NETCDF4;
exerrval = 0; /* clear error code */
#if !NC_HAS_PARALLEL
/* Library does NOT support parallel output via netcdf-4 or pnetcdf */
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "EXODUS: ERROR: Parallel output requires the netcdf-4 and/or "
"pnetcdf library format, but this netcdf library does not "
"support either.\n");
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
#endif
if (run_version != EX_API_VERS_NODOT && warning_output == 0) {
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, "EXODUS: 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);
warning_output = 1;
}
/*
* See if specified mode is supported in the version of netcdf we
* are using
*/
#if !NC_HAS_HDF5
if (my_mode & EX_NETCDF4) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "EXODUS: ERROR: File format specified as netcdf-4, but the "
"NetCDF library being used was not configured to enable "
"this format\n");
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
#endif
#if !defined(NC_64BIT_DATA)
if (my_mode & EX_64BIT_DATA) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "EXODUS: ERROR: File format specified as 64bit_data, but "
"the NetCDF library being used does not support this "
"format\n");
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
#endif
/* Check that one and only one format mode is specified... */
{
unsigned int set_modes = all_modes & my_mode;
if (set_modes == 0) {
my_mode |= EX_64BIT_OFFSET; /* Default if nothing specified */
}
else {
/* Checks that only a single bit is set */
set_modes = set_modes && !(set_modes & (set_modes - 1));
if (!set_modes) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "EXODUS: ERROR: More than 1 file format "
"(EX_NORMAL_MODEL, EX_LARGE_MODEL, EX_64BIT_OFFSET, "
"EX_64BIT_DATA, or EX_NETCDF4)\nwas specified in the "
"mode argument of the ex_create call. Only a single "
"format can be specified.\n");
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
}
}
/*
* See if any integer data is to be stored as int64 (long long). If
* so, then need to set NC_NETCDF4 and unset NC_CLASSIC_MODEL (or
* set EX_NOCLASSIC. Output meaningful error message if the library
* is not NetCDF-4 enabled...
*
* As of netcdf-4.4.0, can also use NC_64BIT_DATA (CDF5) mode for this...
*/
int64_status = my_mode & (EX_ALL_INT64_DB | EX_ALL_INT64_API);
if ((int64_status & EX_ALL_INT64_DB) != 0) {
#if NC_HAS_HDF5 || defined(NC_64BIT_DATA)
/* Library DOES support netcdf4 and/or cdf5 ... See if user
* specified either of these and use that one; if not, pick
* netcdf4, non-classic as default.
*/
if (my_mode & EX_NETCDF4) {
my_mode |= EX_NOCLASSIC;
}
#if defined(NC_64BIT_DATA)
else if (my_mode & EX_64BIT_DATA) {
; /* Do nothing, already set */
}
#endif
else {
/* Unset the current mode so we don't have multiples specified */
/* ~all_modes sets to 1 all bits not associated with file format */
my_mode &= ~all_modes;
#if NC_HAS_HDF5
/* Pick netcdf4 as default mode for 64-bit integers */
my_mode |= EX_NOCLASSIC;
my_mode |= EX_NETCDF4;
#else
/* Pick 64bit_data as default mode for 64-bit integers */
my_mode |= EX_64BIT_DATA;
#endif
}
#else
/* Library does NOT support netcdf4 or cdf5 */
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "EXODUS: ERROR: 64-bit integer storage requested, but the "
"netcdf library does not support the required netcdf-4 or "
"64BIT_DATA extensions.\n");
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
#endif
}
/* Check parallel io mode. Valid is NC_MPIPOSIX or NC_MPIIO or NC_PNETCDF
* Exodus uses different flag values; map to netcdf values
*/
{
int tmp_mode = 0;
if (my_mode & EX_MPIPOSIX) {
pariomode = NC_MPIPOSIX;
tmp_mode = EX_NETCDF4;
#if !NC_HAS_HDF5
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "EXODUS: ERROR: EX_MPIPOSIX parallel output requested "
"which requires NetCDF-4 support, but the library does "
"not have that option enabled.\n");
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
#endif
}
else if (my_mode & EX_MPIIO) {
pariomode = NC_MPIIO;
is_mpiio = 1;
tmp_mode = EX_NETCDF4;
#if !NC_HAS_HDF5
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "EXODUS: ERROR: EX_MPIIO parallel output requested which "
"requires NetCDF-4 support, but the library does not "
"have that option enabled.\n");
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
#endif
}
else if (my_mode & EX_PNETCDF) {
pariomode = NC_PNETCDF;
is_pnetcdf = 1;
/* See if client specified 64-bit or not... */
if ((int64_status & EX_ALL_INT64_DB) != 0) {
tmp_mode = EX_64BIT_DATA;
}
else {
tmp_mode = EX_64BIT_OFFSET;
}
#if !NC_HAS_PNETCDF
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "EXODUS: ERROR: EX_PNETCDF parallel output requested "
"which requires PNetCDF support, but the library does "
"not have that option enabled.\n");
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
#endif
}
/* If tmp_mode was set here, then need to clear any other mode that
was potentially already set in my_mode... */
my_mode &= ~all_modes;
my_mode |= tmp_mode;
}
if (my_mode & EX_NETCDF4) {
nc_mode |= NC_NETCDF4;
}
if (!(my_mode & EX_NOCLASSIC)) {
nc_mode |= NC_CLASSIC_MODEL;
}
/*
* See if "large file" mode was specified in a ex_create my_mode. If
* so, then pass the NC_64BIT_OFFSET flag down to netcdf.
* If netcdf4 mode specified, don't use NC_64BIT_OFFSET mode.
*/
if (my_mode & EX_NORMAL_MODEL) {
filesiz = 0;
#if NC_HAS_HDF5
}
else if (nc_mode & NC_NETCDF4) {
filesiz = 1;
#endif
#if defined(NC_64BIT_DATA)
}
else if (nc_mode & NC_64BIT_DATA) {
filesiz = 1;
#endif
}
else {
filesiz = (int)((my_mode & EX_64BIT_OFFSET) || (ex_large_model(-1) == 1));
}
if (
#if NC_HAS_HDF5
!(nc_mode & NC_NETCDF4) &&
#endif
#if defined(NC_64BIT_DATA)
!(nc_mode & NC_64BIT_DATA) &&
#endif
filesiz == 1) {
nc_mode |= NC_64BIT_OFFSET;
}
if (my_mode & EX_SHARE) {
nc_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 (my_mode & EX_CLOBBER) {
nc_mode |= NC_CLOBBER;
mode_name = "CLOBBER";
}
else {
nc_mode |= NC_NOCLOBBER;
mode_name = "NOCLOBBER";
}
#if defined NC_IGNORE_MAX_DIMS
nc_mode |= NC_IGNORE_MAX_DIMS;
#endif
#if defined NC_IGNORE_MAX_VARS
nc_mode |= NC_IGNORE_MAX_VARS;
#endif
if ((status = nc_create_par(path, nc_mode | pariomode, comm, info, &exoid)) != NC_NOERR) {
exerrval = status;
#if NC_HAS_HDF5
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: file create failed for %s, mode: %s", path, mode_name);
#else
if (my_mode & EX_NETCDF4) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: file create failed for %s in NETCDF4 and %s "
"mode.\n\tThis library does not support netcdf-4 files.",
path, mode_name);
}
else {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: file create failed for %s, mode: %s", path,
mode_name);
}
#endif
ex_err(routine, 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;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to set nofill mode in file id %d", exoid);
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
/* Verify that there is not an existing file_item struct for this
exoid This could happen (and has) when application calls
ex_open(), but then closes file using nc_close() and then reopens
file. NetCDF will possibly reuse the exoid which results in
internal corruption in exodus data structures since exodus does
not know that file was closed and possibly new file opened for
this exoid
*/
if (ex_find_file_item(exoid) != NULL) {
char errmsg[MAX_ERR_LENGTH];
exerrval = EX_BADFILEID;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: There is an existing file already using the file "
"id %d which was also assigned to file %s.\n\tWas "
"nc_close() called instead of ex_close() on an open Exodus "
"file?\n",
exoid, path);
ex_err(routine, errmsg, exerrval);
nc_close(exoid);
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, int64_status, 1, is_mpiio, is_pnetcdf) != EX_NOERR) {
exerrval = EX_FATAL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to init conversion routines in file id %d",
exoid);
ex_err(routine, 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;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store Exodus II API version attribute in file id %d", exoid);
ex_err(routine, 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;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store Exodus II file version attribute in file id %d", exoid);
ex_err(routine, 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;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store Exodus II file float word size "
"attribute in file id %d",
exoid);
ex_err(routine, 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;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store Exodus II file size attribute in file id %d", exoid);
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
{
int max_so_far = 32;
if ((status = nc_put_att_int(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, NC_INT, 1, &max_so_far)) !=
NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to add maximum_name_length attribute in file id %d", exoid);
ex_err(routine, 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;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define string length in file id %d", exoid);
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
/* The name string length dimension is delayed until the ex_put_init function
*/
/* create line length dimension */
if ((status = nc_def_dim(exoid, DIM_LIN, (MAX_LINE_LENGTH + 1), &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define line length in file id %d", exoid);
ex_err(routine, 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;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number \"4\" dimension in file id %d",
exoid);
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
{
int int64_db_status = int64_status & EX_ALL_INT64_DB;
if ((status = nc_put_att_int(exoid, NC_GLOBAL, ATT_INT64_STATUS, NC_INT, 1,
&int64_db_status)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to add int64_status attribute in file id %d",
exoid);
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
}
if ((status = nc_enddef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid);
ex_err(routine, errmsg, exerrval);
return (EX_FATAL);
}
return (exoid);
}
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];
EX_FUNC_ENTER();
int rootid = exoid & EX_FILE_ID_MASK;
ex_check_valid_file_id(exoid, __func__);
if (rootid == exoid && nc_inq_dimid(exoid, DIM_NUM_DIM, &temp) == NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: initialization already done for file id %d", exoid);
ex_err(__func__, errmsg, EX_MSG);
EX_FUNC_LEAVE(EX_FATAL);
}
/* put file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file id %d into define mode", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define model->title attribute to file id %d",
rootid);
ex_err(__func__, errmsg, status);
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) {
if ((status = nc_def_dim(rootid, DIM_STR_NAME, NC_MAX_NAME, &dim_str_name)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define name string length in file id %d",
rootid);
ex_err(__func__, errmsg, status);
goto error_ret;
}
}
if ((status = nc_def_dim(exoid, DIM_TIME, NC_UNLIMITED, &timedim)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define time dimension in file id %d", exoid);
ex_err(__func__, errmsg, status);
goto error_ret;
}
dim[0] = timedim;
if ((status = nc_def_var(exoid, VAR_WHOLE_TIME, nc_flt_code(exoid), 1, dim, &temp)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define whole time step variable in file id %d", exoid);
ex_err(__func__, errmsg, status);
goto error_ret;
}
{
struct ex_file_item *file = ex_find_file_item(exoid);
file->time_varid = temp;
}
ex_compress_variable(exoid, temp, 2);
if ((status = nc_def_dim(exoid, DIM_NUM_DIM, model->num_dim, &numdimdim)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of dimensions in file id %d",
exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of nodes in file id %d",
exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* exit define mode and return */
}
}
if (model->num_elem > 0) {
if (model->num_nodes <= 0) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: Cannot have non-zero element count if node count "
"is zero.in file id %d",
exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_def_dim(exoid, DIM_NUM_ELEM, model->num_elem, &temp)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of elements in file id %d",
exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* exit define mode and return */
}
}
if (model->num_edge > 0) {
if (model->num_nodes <= 0) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: Cannot have non-zero edge count if node count is "
"zero.in file id %d",
exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_def_dim(exoid, DIM_NUM_EDGE, model->num_edge, &temp)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of edges in file id %d",
exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* exit define mode and return */
}
}
if (model->num_face > 0) {
if (model->num_nodes <= 0) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: Cannot have non-zero face count if node count is "
"zero.in file id %d",
exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_def_dim(exoid, DIM_NUM_FACE, model->num_face, &temp)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define number of faces in file id %d",
exoid);
ex_err(__func__, errmsg, status);
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;
}
if (model->num_nodes > 0) {
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define node x coordinate array in file id %d", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define node y coordinate array in file id %d", exoid);
ex_err(__func__, errmsg, status);
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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to define node z coordinate array in file id %d", exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, temp, 2);
}
}
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) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete variable definitions in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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)))) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate memory for id/status array for file id %d", exoid);
ex_err(__func__, errmsg, EX_MEMFAIL);
EX_FUNC_LEAVE(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 */
write_dummy_names(exoid, EX_ELEM_BLOCK, model->num_elem_blk);
write_dummy_names(exoid, EX_EDGE_BLOCK, model->num_edge_blk);
write_dummy_names(exoid, EX_FACE_BLOCK, model->num_face_blk);
write_dummy_names(exoid, EX_NODE_SET, model->num_node_sets);
write_dummy_names(exoid, EX_EDGE_SET, model->num_edge_sets);
write_dummy_names(exoid, EX_FACE_SET, model->num_face_sets);
write_dummy_names(exoid, EX_SIDE_SET, model->num_side_sets);
write_dummy_names(exoid, EX_ELEM_SET, model->num_elem_sets);
write_dummy_names(exoid, EX_NODE_MAP, model->num_node_maps);
write_dummy_names(exoid, EX_EDGE_MAP, model->num_edge_maps);
write_dummy_names(exoid, EX_FACE_MAP, model->num_face_maps);
write_dummy_names(exoid, EX_ELEM_MAP, model->num_elem_maps);
EX_FUNC_LEAVE(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if ((status = 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(__func__, errmsg, status);
}
EX_FUNC_LEAVE(EX_FATAL);
}
int ex_open_par_int(const char *path, int mode, int *comp_ws, int *io_ws, float *version,
MPI_Comm comm, MPI_Info info, int run_version)
{
int exoid;
int status, stat_att, stat_dim;
nc_type att_type = NC_NAT;
size_t att_len = 0;
int nc_mode = 0;
int old_fill;
int file_wordsize;
int dim_str_name;
int int64_status = 0;
int is_hdf5 = 0;
int is_pnetcdf = 0;
int in_redef = 0;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
/* set error handling mode to no messages, non-fatal errors */
ex_opts(exoptval); /* call required to set ncopts first time through */
if (run_version != EX_API_VERS_NODOT && warning_output == 0) {
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,
"EXODUS: Warning: This code was compiled with exodus "
"version %d.%02d,\n but was linked with exodus "
"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);
warning_output = 1;
}
if ((mode & EX_READ) && (mode & EX_WRITE)) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Cannot specify both EX_READ and EX_WRITE");
ex_err(__func__, errmsg, EX_BADFILEMODE);
EX_FUNC_LEAVE(EX_FATAL);
}
if (mode & EX_WRITE) {
nc_mode = (NC_WRITE | NC_MPIIO);
}
else {
nc_mode = (NC_NOWRITE | NC_SHARE | NC_MPIIO);
}
if ((status = nc_open_par(path, nc_mode, comm, info, &exoid)) != NC_NOERR) {
/* It is possible that the user is trying to open a netcdf4
file, but the netcdf4 capabilities aren't available in the
netcdf linked to this library. Note that we can't just use a
compile-time define since we could be using a shareable
netcdf library, so the netcdf4 capabilities aren't known
until runtime...
Later versions of netcdf-4.X have a function that can be
queried to determine whether the library being used was
compiled with --enable-netcdf4, but not everyone is using that
version yet, so we may have to do some guessing...
At this time, query the beginning of the file and see if it
is an HDF-5 file and if it is assume that the open failure
is due to the netcdf library not enabling netcdf4 features unless
we have the define that shows it is enabled, then assume other error...
*/
int type = 0;
ex_check_file_type(path, &type);
if (type == 5) {
#if NC_HAS_HDF5
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the netcdf-4 "
"file:\n\t'%s'\n\t failed. The netcdf library supports "
"netcdf-4 so there must be a filesystem or some other "
"issue \n",
path);
#else
/* This is an hdf5 (netcdf4) file. If NC_HAS_HDF5 is not defined,
then we either don't have hdf5 support in this netcdf version,
OR this is an older netcdf version that doesn't provide that define.
In either case, we don't have enough information, so we
assume that the netcdf doesn't have netcdf4 capabilities
enabled. Tell the user...
*/
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the netcdf-4 "
"file:\n\t'%s'\n\tEither the netcdf library does not "
"support netcdf-4 or there is a filesystem or some "
"other issue \n",
path);
#endif
}
else if (type == 4) {
#if defined(NC_64BIT_DATA)
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the CDF5 "
"file:\n\t'%s'\n\t failed. The netcdf library supports "
"CDF5-type files so there must be a filesystem or some other "
"issue \n",
path);
#else
/* This is an cdf5 (64BIT_DATA) file. If NC_64BIT_DATA is not defined,
then we either don't have cdf5 support in this netcdf version,
OR this is an older netcdf version that doesn't provide that define.
In either case, we don't have enough information, so we
assume that the netcdf doesn't have cdf5 capabilities
enabled. Tell the user...
*/
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the CDF5 "
"file:\n\t'%s'\n\tEither the netcdf library does not "
"support CDF5 or there is a filesystem or some "
"other issue \n",
path);
#endif
}
else if (type == 1 || type == 2) {
#if NC_HAS_PNETCDF
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the classic NetCDF "
"file:\n\t'%s'\n\t failed. The netcdf library supports "
"PNetCDF files as required for parallel readinf of this "
"file type, so there must be a filesystem or some other "
"issue \n",
path);
#else
/* This is an normal NetCDF format file, for parallel reading, the PNetCDF
library is required but that is not compiled into this version.
*/
fprintf(stderr,
"EXODUS: ERROR: Attempting to open the NetCDF "
"file:\n\t'%s'\n\tThe NetCDF library was not "
"built with PNetCDF support as required for parallel access to this file.\n",
path);
#endif
}
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to open %s of type %d read only", path, type);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* File opened correctly */
int type = 0;
ex_check_file_type(path, &type);
if (type == 5) {
is_hdf5 = 1;
}
else if (type == 1 || type == 2 || type == 4) {
is_pnetcdf = 1;
}
if (mode & EX_WRITE) { /* Appending */
/* turn off automatic filling of netCDF variables */
if (is_pnetcdf) {
if ((status = nc_redef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file id %d into define mode", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
in_redef = 1;
}
if ((status = nc_set_fill(exoid, NC_NOFILL, &old_fill)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to set nofill mode in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
stat_att = nc_inq_att(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, &att_type, &att_len);
stat_dim = nc_inq_dimid(exoid, DIM_STR_NAME, &dim_str_name);
if (stat_att != NC_NOERR || stat_dim != NC_NOERR) {
if (!in_redef) {
if ((status = nc_redef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file id %d into define mode",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
in_redef = 1;
}
if (stat_att != NC_NOERR) {
int max_so_far = 32;
nc_put_att_int(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, NC_INT, 1, &max_so_far);
}
/* If the DIM_STR_NAME variable does not exist on the database, we need to
* add it now. */
if (stat_dim != NC_NOERR) {
/* Not found; set to default value of 32+1. */
int max_name = ex_default_max_name_length < 32 ? 32 : ex_default_max_name_length;
nc_def_dim(exoid, DIM_STR_NAME, max_name + 1, &dim_str_name);
}
}
if (in_redef) {
if ((status = nc_enddef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
in_redef = 0;
}
/* If this is a parallel execution and we are appending, then we
* need to set the parallel access method for all transient variables to NC_COLLECTIVE since
* they will be being extended.
*/
int ndims; /* number of dimensions */
int nvars; /* number of variables */
int ngatts; /* number of global attributes */
int recdimid; /* id of unlimited dimension */
int varid;
/* Determine number of variables on the database... */
nc_inq(exoid, &ndims, &nvars, &ngatts, &recdimid);
for (varid = 0; varid < nvars; varid++) {
struct ncvar var;
nc_inq_var(exoid, varid, var.name, &var.type, &var.ndims, var.dims, &var.natts);
if ((strcmp(var.name, VAR_GLO_VAR) == 0) || (strncmp(var.name, "vals_elset_var", 14) == 0) ||
(strncmp(var.name, "vals_sset_var", 13) == 0) ||
(strncmp(var.name, "vals_fset_var", 13) == 0) ||
(strncmp(var.name, "vals_eset_var", 13) == 0) ||
(strncmp(var.name, "vals_nset_var", 13) == 0) ||
(strncmp(var.name, "vals_nod_var", 12) == 0) ||
(strncmp(var.name, "vals_edge_var", 13) == 0) ||
(strncmp(var.name, "vals_face_var", 13) == 0) ||
(strncmp(var.name, "vals_elem_var", 13) == 0) ||
(strcmp(var.name, VAR_WHOLE_TIME) == 0)) {
nc_var_par_access(exoid, varid, NC_COLLECTIVE);
}
}
} /* End of (mode & EX_WRITE) */
/* determine version of EXODUS file, and the word size of
* floating point and integer values stored in the file
*/
if ((status = nc_get_att_float(exoid, NC_GLOBAL, ATT_VERSION, version)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get database version for file id: %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* check ExodusII file version - old version 1.x files are not supported */
if (*version < 2.0) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: Unsupported file version %.2f in file id: %d",
*version, exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
if (nc_get_att_int(exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, &file_wordsize) !=
NC_NOERR) { /* try old (prior to db version 2.02) attribute name */
if ((status = nc_get_att_int(exoid, NC_GLOBAL, ATT_FLT_WORDSIZE_BLANK, &file_wordsize)) !=
NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get file wordsize from file id: %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* See if int64 status attribute exists and if so, what data is stored as
* int64
* Older files don't have the attribute, so it is not an error if it is
* missing
*/
if (nc_get_att_int(exoid, NC_GLOBAL, ATT_INT64_STATUS, &int64_status) != NC_NOERR) {
int64_status = 0; /* Just in case it gets munged by a failed get_att_int call */
}
/* Merge in API int64 status flags as specified by caller of function... */
int64_status |= (mode & EX_ALL_INT64_API);
/* Verify that there is not an existing file_item struct for this
exoid This could happen (and has) when application calls
ex_open(), but then closes file using nc_close() and then reopens
file. NetCDF will possibly reuse the exoid which results in
internal corruption in exodus data structures since exodus does
not know that file was closed and possibly new file opened for
this exoid
*/
if (ex_find_file_item(exoid) != NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: There is an existing file already using the file "
"id %d which was also assigned to file %s.\n\tWas "
"nc_close() called instead of ex_close() on an open Exodus "
"file?\n",
exoid, path);
ex_err(__func__, errmsg, EX_BADFILEID);
nc_close(exoid);
EX_FUNC_LEAVE(EX_FATAL);
}
/* initialize floating point and integer size conversion. */
if (ex_conv_ini(exoid, comp_ws, io_ws, file_wordsize, int64_status, 1, is_hdf5, is_pnetcdf) !=
EX_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to initialize conversion routines in file id %d", exoid);
ex_err(__func__, errmsg, EX_LASTERR);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(exoid);
}
/* NOTE: Do *not* call `ex_create_int()` directly. The public API
* function name is `ex_create()` which is a wrapper that calls
* `ex_create_int` with an additional argument to make sure
* library and include file are consistent
*/
int ex_create_int(const char *path, int cmode, int *comp_ws, int *io_ws, int run_version)
{
int exoid;
int status;
int old_fill;
int lio_ws;
int filesiz = 1;
float vers;
char errmsg[MAX_ERR_LENGTH];
char *mode_name;
int nc_mode = 0;
#if NC_HAS_HDF5
static int netcdf4_mode = -1;
#endif /* NC_NETCDF4 */
#if defined(NC_64BIT_DATA)
static int netcdf5_mode = -1;
#endif
int int64_status;
unsigned int my_mode = cmode;
/* Contains a 1 in all bits corresponding to file modes */
static unsigned int all_modes = EX_NORMAL_MODEL | EX_64BIT_OFFSET | EX_64BIT_DATA | EX_NETCDF4;
EX_FUNC_ENTER();
if (run_version != EX_API_VERS_NODOT && warning_output == 0) {
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,
"EXODUS: 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);
warning_output = 1;
}
/*
* See if specified mode is supported in the version of netcdf we
* are using
*/
#if !NC_HAS_HDF5
if (my_mode & EX_NETCDF4) {
snprintf(errmsg, MAX_ERR_LENGTH,
"EXODUS: ERROR: File format specified as netcdf-4, but the "
"NetCDF library being used was not configured to enable "
"this format\n");
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
#endif
#if !defined(NC_64BIT_DATA)
if (my_mode & EX_64BIT_DATA) {
snprintf(errmsg, MAX_ERR_LENGTH,
"EXODUS: ERROR: File format specified as 64bit_data, but "
"the NetCDF library being used does not support this "
"format\n");
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
#endif
/* Check that one and only one format mode is specified... */
{
unsigned int set_modes = all_modes & my_mode;
if (set_modes == 0) {
my_mode |= EX_64BIT_OFFSET; /* Default if nothing specified */
}
else {
/* Checks that only a single bit is set */
set_modes = set_modes && !(set_modes & (set_modes - 1));
if (!set_modes) {
snprintf(errmsg, MAX_ERR_LENGTH,
"EXODUS: ERROR: More than 1 file format "
"(EX_NORMAL_MODEL, EX_LARGE_MODEL, EX_64BIT_OFFSET, "
"EX_64BIT_DATA, or EX_NETCDF4)\nwas specified in the "
"mode argument of the ex_create call. Only a single "
"format can be specified.\n");
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
/*
* See if any integer data is to be stored as int64 (long long). If
* so, then need to set NC_NETCDF4 and unset NC_CLASSIC_MODEL (or
* set EX_NOCLASSIC. Output meaningful error message if the library
* is not NetCDF-4 enabled...
*
* As of netcdf-4.4.0, can also use NC_64BIT_DATA (CDF5) mode for this...
*/
int64_status = my_mode & (EX_ALL_INT64_DB | EX_ALL_INT64_API);
if ((int64_status & EX_ALL_INT64_DB) != 0) {
#if NC_HAS_HDF5 || defined(NC_64BIT_DATA)
/* Library DOES support netcdf4 and/or cdf5 ... See if user
* specified either of these and use that one; if not, pick
* netcdf4, non-classic as default.
*/
if (my_mode & EX_NETCDF4) {
my_mode |= EX_NOCLASSIC;
}
#if defined(NC_64BIT_DATA)
else if (my_mode & EX_64BIT_DATA) {
; /* Do nothing, already set */
}
#endif
else {
/* Unset the current mode so we don't have multiples specified */
/* ~all_modes sets to 1 all bits not associated with file format */
my_mode &= ~all_modes;
#if NC_HAS_HDF5
/* Pick netcdf4 as default mode for 64-bit integers */
my_mode |= EX_NOCLASSIC;
my_mode |= EX_NETCDF4;
#else
/* Pick 64bit_data as default mode for 64-bit integers */
my_mode |= EX_64BIT_DATA;
#endif
}
#else
/* Library does NOT support netcdf4 or cdf5 */
snprintf(errmsg, MAX_ERR_LENGTH,
"EXODUS: ERROR: 64-bit integer storage requested, but the "
"netcdf library does not support the required netcdf-4 or "
"64BIT_DATA extensions.\n");
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
#endif
}
#if NC_HAS_HDF5
if (my_mode & EX_NETCDF4) {
nc_mode |= (NC_NETCDF4);
}
else {
if (netcdf4_mode == -1) {
char *option = getenv("EXODUS_NETCDF4");
if (option != NULL) {
netcdf4_mode = NC_NETCDF4;
if (option[0] != 'q') {
fprintf(stderr, "EXODUS: Using netcdf version 4 selected via "
"EXODUS_NETCDF4 environment variable\n");
}
}
else {
netcdf4_mode = 0;
}
}
nc_mode |= netcdf4_mode;
}
if (!(my_mode & EX_NOCLASSIC)) {
nc_mode |= NC_CLASSIC_MODEL;
}
#endif
#if defined(NC_64BIT_DATA)
if (my_mode & EX_64BIT_DATA) {
nc_mode |= (NC_64BIT_DATA);
}
else {
if (netcdf5_mode == -1) {
char *option = getenv("EXODUS_NETCDF5");
if (option != NULL) {
netcdf5_mode = NC_64BIT_DATA;
if (option[0] != 'q') {
fprintf(stderr, "EXODUS: Using netcdf version 5 (CDF5) selected via "
"EXODUS_NETCDF5 environment variable\n");
}
}
else {
netcdf5_mode = 0;
}
}
nc_mode |= netcdf5_mode;
}
#endif
/*
* Hardwire filesiz to 1 for all created files. Reduce complexity in nodal output routines.
* has been default for a decade or so, but still support it on read...
*/
if (
#if NC_HAS_HDF5
!(nc_mode & NC_NETCDF4) &&
#endif
#if defined(NC_64BIT_DATA)
!(nc_mode & NC_64BIT_DATA) &&
#endif
filesiz == 1) {
nc_mode |= NC_64BIT_OFFSET;
}
if (my_mode & EX_SHARE) {
nc_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 (my_mode & EX_CLOBBER) {
nc_mode |= NC_CLOBBER;
mode_name = "CLOBBER";
}
else {
nc_mode |= NC_NOCLOBBER;
mode_name = "NOCLOBBER";
}
#if NC_HAS_DISKLESS
if (my_mode & EX_DISKLESS) {
nc_mode |= NC_DISKLESS;
nc_mode |= NC_WRITE;
}
#endif
if ((status = nc_create(path, nc_mode, &exoid)) != NC_NOERR) {
#if NC_HAS_HDF5
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: file create failed for %s, mode: %s", path, mode_name);
#else
if (my_mode & EX_NETCDF4) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: file create failed for %s in NETCDF4 and %s "
"mode.\n\tThis library does not support netcdf-4 files.",
path, mode_name);
}
else {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: file create failed for %s, mode: %s", path,
mode_name);
}
#endif
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* turn off automatic filling of netCDF variables */
if ((status = nc_set_fill(exoid, NC_NOFILL, &old_fill)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to set nofill mode in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Verify that there is not an existing file_item struct for this
exoid This could happen (and has) when application calls
ex_open(), but then closes file using nc_close() and then reopens
file. NetCDF will possibly reuse the exoid which results in
internal corruption in exodus data structures since exodus does
not know that file was closed and possibly new file opened for
this exoid
*/
if (ex_find_file_item(exoid) != NULL) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: There is an existing file already using the file "
"id %d which was also assigned to file %s.\n\tWas "
"nc_close() called instead of ex_close() on an open Exodus "
"file?\n",
exoid, path);
ex_err(__func__, errmsg, EX_BADFILEID);
nc_close(exoid);
EX_FUNC_LEAVE(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, int64_status, 0, 0, 0) != EX_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to init conversion routines in file id %d",
exoid);
ex_err(__func__, errmsg, EX_LASTERR);
EX_FUNC_LEAVE(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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store Exodus II API version attribute in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store Exodus II file version attribute in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* store Exodus file float word size as an attribute */
lio_ws = (*io_ws);
if ((status = nc_put_att_int(exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, NC_INT, 1, &lio_ws)) !=
NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store Exodus II file float word size "
"attribute in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(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) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to store Exodus II file size attribute in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
{
int max_so_far = 32;
if ((status = nc_put_att_int(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, NC_INT, 1, &max_so_far)) !=
NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to add maximum_name_length attribute in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
{
int int64_db_status = int64_status & EX_ALL_INT64_DB;
if ((status = nc_put_att_int(exoid, NC_GLOBAL, ATT_INT64_STATUS, NC_INT, 1,
&int64_db_status)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to add int64_status attribute in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
if ((status = nc_enddef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to complete definition for file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(exoid);
}
