/*****************************************************************************
*
* ex_get_num_props - get number of properties
*
*****************************************************************************/
int ex_get_num_props(int exoid, ex_entity_type obj_type)
{
int cntr, varid;
char *var_name;
char errmsg[MAX_ERR_LENGTH];
cntr = 0;
/* loop until there is not a property variable defined; the name of */
/* the variables begin with an increment of 1 ("xx_prop1") so use cntr+1 */
while (EX_TRUE) {
switch (obj_type) {
case EX_ELEM_BLOCK: var_name = VAR_EB_PROP(cntr + 1); break;
case EX_EDGE_BLOCK: var_name = VAR_ED_PROP(cntr + 1); break;
case EX_FACE_BLOCK: var_name = VAR_FA_PROP(cntr + 1); break;
case EX_NODE_SET: var_name = VAR_NS_PROP(cntr + 1); break;
case EX_EDGE_SET: var_name = VAR_ES_PROP(cntr + 1); break;
case EX_FACE_SET: var_name = VAR_FS_PROP(cntr + 1); break;
case EX_SIDE_SET: var_name = VAR_SS_PROP(cntr + 1); break;
case EX_ELEM_SET: var_name = VAR_ELS_PROP(cntr + 1); break;
case EX_ELEM_MAP: var_name = VAR_EM_PROP(cntr + 1); break;
case EX_FACE_MAP: var_name = VAR_FAM_PROP(cntr + 1); break;
case EX_EDGE_MAP: var_name = VAR_EDM_PROP(cntr + 1); break;
case EX_NODE_MAP: var_name = VAR_NM_PROP(cntr + 1); break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err("ex_get_prop_names", errmsg, exerrval);
return (EX_FATAL);
}
if (nc_inq_varid(exoid, var_name, &varid) != NC_NOERR) {
/* no variable with this name; return cntr which is now the number of */
/* properties for this type of entity */
return (cntr);
}
cntr++;
}
}
int ex_get_prop_array(int exoid, ex_entity_type obj_type, const char *prop_name, void_int *values)
{
int num_props, i, propid, status;
int found = EX_FALSE;
char *name;
char tmpstr[MAX_STR_LENGTH + 1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* open appropriate variable, depending on obj_type and prop_name */
num_props = ex_get_num_props(exoid, obj_type);
for (i = 1; i <= num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK: name = VAR_EB_PROP(i); break;
case EX_EDGE_BLOCK: name = VAR_ED_PROP(i); break;
case EX_FACE_BLOCK: name = VAR_FA_PROP(i); break;
case EX_NODE_SET: name = VAR_NS_PROP(i); break;
case EX_EDGE_SET: name = VAR_ES_PROP(i); break;
case EX_FACE_SET: name = VAR_FS_PROP(i); break;
case EX_ELEM_SET: name = VAR_ELS_PROP(i); break;
case EX_SIDE_SET: name = VAR_SS_PROP(i); break;
case EX_ELEM_MAP: name = VAR_EM_PROP(i); break;
case EX_FACE_MAP: name = VAR_FAM_PROP(i); break;
case EX_EDGE_MAP: name = VAR_EDM_PROP(i); break;
case EX_NODE_MAP: name = VAR_NM_PROP(i); break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate property array %s in file id %d",
name, exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH + 1);
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property name in file id %d", exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0) {
found = EX_TRUE;
break;
}
}
/* if property is not found, return warning */
if (!found) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: object type %d, property %s not defined in file id %d", obj_type, prop_name,
exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_WARN);
}
/* read num_obj values from property variable */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, propid, values);
}
else {
status = nc_get_var_int(exoid, propid, values);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to read values in %s property array in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_id_lkup(int exoid, ex_entity_type id_type, ex_entity_id num)
{
char * id_table;
char * id_dim;
char * stat_table;
int varid, dimid;
size_t dim_len, i;
int64_t *id_vals = NULL;
int * stat_vals = NULL;
static int filled = EX_FALSE;
struct obj_stats *tmp_stats;
int status;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
switch (id_type) {
case EX_NODAL: return 0;
case EX_GLOBAL: return 0;
case EX_ELEM_BLOCK:
id_table = VAR_ID_EL_BLK; /* id array name */
id_dim = DIM_NUM_EL_BLK; /* id array dimension name*/
stat_table = VAR_STAT_EL_BLK; /* id status array name */
tmp_stats = ex_get_stat_ptr(exoid, &exoII_eb);
break;
case EX_NODE_SET:
id_table = VAR_NS_IDS;
id_dim = DIM_NUM_NS;
stat_table = VAR_NS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ns);
break;
case EX_SIDE_SET:
id_table = VAR_SS_IDS;
id_dim = DIM_NUM_SS;
stat_table = VAR_SS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ss);
break;
case EX_EDGE_BLOCK:
id_table = VAR_ID_ED_BLK;
id_dim = DIM_NUM_ED_BLK;
stat_table = VAR_STAT_ED_BLK;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ed);
break;
case EX_FACE_BLOCK:
id_table = VAR_ID_FA_BLK;
id_dim = DIM_NUM_FA_BLK;
stat_table = VAR_STAT_FA_BLK;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fa);
break;
case EX_EDGE_SET:
id_table = VAR_ES_IDS;
id_dim = DIM_NUM_ES;
stat_table = VAR_ES_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_es);
break;
case EX_FACE_SET:
id_table = VAR_FS_IDS;
id_dim = DIM_NUM_FS;
stat_table = VAR_FS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fs);
break;
case EX_ELEM_SET:
id_table = VAR_ELS_IDS;
id_dim = DIM_NUM_ELS;
stat_table = VAR_ELS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_els);
break;
case EX_NODE_MAP:
id_table = VAR_NM_PROP(1);
id_dim = DIM_NUM_NM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_nm);
break;
case EX_EDGE_MAP:
id_table = VAR_EDM_PROP(1);
id_dim = DIM_NUM_EDM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_edm);
break;
case EX_FACE_MAP:
id_table = VAR_FAM_PROP(1);
id_dim = DIM_NUM_FAM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fam);
break;
case EX_ELEM_MAP:
id_table = VAR_EM_PROP(1);
id_dim = DIM_NUM_EM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_em);
break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported id array type %d for file id %d", id_type,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if ((tmp_stats->id_vals == NULL) || (!(tmp_stats->valid_ids))) {
/* first time thru or id arrays haven't been completely filled yet */
/* get size of id array */
/* First get dimension id of id array */
if ((status = nc_inq_dimid(exoid, id_dim, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate id array dimension in file id %d",
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* Next get value of dimension */
if ((status = nc_inq_dimlen(exoid, dimid, &dim_len)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s array length in file id %d",
id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* get variable id of id array */
if ((status = nc_inq_varid(exoid, id_table, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s array in file id %d", id_table,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* allocate space for id array and initialize to zero to ensure
that the higher bits don't contain garbage while copy from ints */
if (!(id_vals = calloc(dim_len, sizeof(int64_t)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate memory for %s array for file id %d", id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varid, (long long *)id_vals);
}
else {
int *id_vals_int;
if (!(id_vals_int = malloc(dim_len * sizeof(int)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate memory for temporary array "
"id_vals_int for file id %d",
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
free(id_vals);
return (EX_FATAL);
}
status = nc_get_var_int(exoid, varid, (int *)id_vals_int);
if (status == NC_NOERR) {
for (i = 0; i < dim_len; i++) {
id_vals[i] = (int64_t)id_vals_int[i];
}
}
free(id_vals_int);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s array from file id %d", id_table,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
free(id_vals);
return (EX_FATAL);
}
/* check if values in stored arrays are filled with non-zeroes */
filled = EX_TRUE;
for (i = 0; i < dim_len; i++) {
if (id_vals[i] == EX_INVALID_ID || id_vals[i] == NC_FILL_INT) {
filled = EX_FALSE;
break; /* id array hasn't been completely filled with valid ids yet */
}
}
if (filled) {
tmp_stats->valid_ids = EX_TRUE;
tmp_stats->num = dim_len;
tmp_stats->id_vals = id_vals;
}
}
else {
id_vals = tmp_stats->id_vals;
dim_len = tmp_stats->num;
}
/* Do a linear search through the id array to find the array value
corresponding to the passed index number */
for (i = 0; i < dim_len; i++) {
if (id_vals[i] == num) {
break; /* found the id requested */
}
}
if (i >= dim_len) /* failed to find id number */
{
if (!(tmp_stats->valid_ids)) {
free(id_vals);
}
exerrval = EX_LOOKUPFAIL;
return (EX_LOOKUPFAIL); /*if we got here, the id array value doesn't exist */
}
/* Now check status array to see if object is null */
/* get variable id of status array */
if (nc_inq_varid(exoid, stat_table, &varid) == NC_NOERR) {
/* if status array exists, use it, otherwise assume object exists
to be backward compatible */
if ((tmp_stats->stat_vals == NULL) || (!(tmp_stats->valid_stat))) {
/* first time thru or status arrays haven't been filled yet */
/* allocate space for new status array */
if (!(stat_vals = malloc(dim_len * sizeof(int)))) {
exerrval = EX_MEMFAIL;
free(id_vals);
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate memory for %s array for file id %d", id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free(id_vals);
free(stat_vals);
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s array from file id %d",
stat_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if (tmp_stats->valid_ids) {
/* status array is valid only if ids are valid */
tmp_stats->valid_stat = EX_TRUE;
tmp_stats->stat_vals = stat_vals;
}
}
else {
stat_vals = tmp_stats->stat_vals;
}
if (stat_vals[i] == 0) /* is this object null? */ {
exerrval = EX_NULLENTITY;
if (!(tmp_stats->valid_stat)) {
free(stat_vals);
}
if (!(tmp_stats->valid_ids)) {
free(id_vals);
}
return (-((int)i + 1)); /* return index into id array (1-based) */
}
}
if (!(tmp_stats->valid_ids)) {
free(id_vals);
free(stat_vals);
}
return (i + 1); /* return index into id array (1-based) */
}
int ex_put_num_map ( int exoid,
ex_entity_type map_type,
int map_id,
const int *map )
{
int dimid, varid;
size_t start[1];
int ldum;
int num_maps;
size_t num_entries;
int cur_num_maps;
char errmsg[MAX_ERR_LENGTH];
const char* dnumentries;
const char* dnummaps;
const char* vmapids;
const char* vmap;
int status;
exerrval = 0; /* clear error code */
switch ( map_type ) {
case EX_NODE_MAP:
dnumentries = DIM_NUM_NODES;
dnummaps = DIM_NUM_NM;
vmapids = VAR_NM_PROP(1);
break;
case EX_EDGE_MAP:
dnumentries = DIM_NUM_EDGE;
dnummaps = DIM_NUM_EDM;
vmapids = VAR_EDM_PROP(1);
break;
case EX_FACE_MAP:
dnumentries = DIM_NUM_FACE;
dnummaps = DIM_NUM_FAM;
vmapids = VAR_FAM_PROP(1);
break;
case EX_ELEM_MAP:
dnumentries = DIM_NUM_ELEM;
dnummaps = DIM_NUM_EM;
vmapids = VAR_EM_PROP(1);
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg,
"Error: Bad map type (%d) specified for file id %d",
map_type, exoid );
ex_err( "ex_put_num_map", errmsg, exerrval );
return (EX_FATAL);
}
/* Make sure the file contains entries */
if (nc_inq_dimid (exoid, dnumentries, &dimid) != NC_NOERR )
{
return (EX_NOERR);
}
/* first check if any maps are specified */
if ((status = nc_inq_dimid (exoid, dnummaps, &dimid)) != NC_NOERR )
{
exerrval = status;
sprintf(errmsg,
"Error: no %ss specified in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate map id entry */
ex_id_lkup(exoid,map_type,map_id);
if (exerrval != EX_LOOKUPFAIL) /* found the map id */
{
sprintf(errmsg,
"Error: %s %d already defined in file id %d",
ex_name_of_object(map_type),map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return(EX_FATAL);
}
/* Get number of maps initialized for this file */
if ((status = nc_inq_dimlen(exoid,dimid,&num_entries)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
num_maps = num_entries;
/* Keep track of the total number of maps defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of maps
for a specific file and returns that value.
*/
cur_num_maps = ex_get_file_item(exoid, ex_get_counter_list(map_type));
if (cur_num_maps >= num_maps) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) specified in file id %d",
ex_name_of_object(map_type),num_maps,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is used to find the number of maps
for a specific file and returns that value incremented. */
cur_num_maps = ex_inc_file_item(exoid, ex_get_counter_list(map_type));
/* write out information to previously defined variable */
/* first get id of variable */
if ((status = nc_inq_varid (exoid, vmapids, &varid)) == -1)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out map id */
start[0] = cur_num_maps;
ldum = (int)map_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(map_type),map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
switch ( map_type ) {
case EX_NODE_MAP:
vmap = VAR_NODE_MAP(cur_num_maps+1);
break;
case EX_EDGE_MAP:
vmap = VAR_EDGE_MAP(cur_num_maps+1);
break;
case EX_FACE_MAP:
vmap = VAR_FACE_MAP(cur_num_maps+1);
break;
case EX_ELEM_MAP:
vmap = VAR_ELEM_MAP(cur_num_maps+1);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized map type in switch: %d in file id %d",
map_type,exoid);
ex_err("ex_putt_n_one_attr",errmsg,EX_MSG);
return (EX_FATAL);
}
/* locate variable array in which to store the map */
if ((status = nc_inq_varid(exoid,vmap,&varid)) != NC_NOERR)
{
int dims[2];
/* determine number of entries */
if ((status = nc_inq_dimid (exoid, dnumentries, &dimid)) == -1 )
{
exerrval = status;
sprintf(errmsg,
"Error: couldn't determine number of %s entries in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
status = 0;
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_num_map",errmsg,exerrval);
return (EX_FATAL);
}
dims[0] = dimid;
if ((status = nc_def_var( exoid, vmap, NC_INT, 1, dims, &varid )) == -1 ) {
exerrval = status;
sprintf(errmsg, "Error: failed to define map %s in file id %d", vmap, exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
}
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_num_map", errmsg, exerrval );
varid = -1; /* force early exit */
}
if ( varid == -1 ) /* we couldn't define variable and have prepared error message. */
return (EX_FATAL);
}
/* write out the map */
if ((status = nc_put_var_int(exoid, varid, map)) != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_put_prop_names(int exoid, ex_entity_type obj_type, int num_props, char **prop_names)
{
int status;
int oldfill, temp;
int i, propid, dimid, dims[1];
size_t name_length, prop_name_len;
char * name;
long long vals[1];
int max_name_len = 0;
int int_type = NC_INT;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
if (ex_int64_status(exoid) & EX_IDS_INT64_DB) {
int_type = NC_INT64;
}
/* Get the name string length */
name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH) + 1;
/* inquire id of previously defined dimension (number of objects) */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(obj_type), &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate number of %s in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_put_prop_names", errmsg, exerrval);
return (EX_FATAL);
}
nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */
/* 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_put_prop_names", errmsg, exerrval);
return (EX_FATAL);
}
/* define num_props variables; we postpend the netcdf variable name with */
/* a counter starting at 2 because "xx_prop1" is reserved for the id array*/
dims[0] = dimid;
for (i = 0; i < num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK: name = VAR_EB_PROP(i + 2); break;
case EX_FACE_BLOCK: name = VAR_FA_PROP(i + 2); break;
case EX_EDGE_BLOCK: name = VAR_ED_PROP(i + 2); break;
case EX_NODE_SET: name = VAR_NS_PROP(i + 2); break;
case EX_SIDE_SET: name = VAR_SS_PROP(i + 2); break;
case EX_EDGE_SET: name = VAR_ES_PROP(i + 2); break;
case EX_FACE_SET: name = VAR_FS_PROP(i + 2); break;
case EX_ELEM_SET: name = VAR_ELS_PROP(i + 2); break;
case EX_ELEM_MAP: name = VAR_EM_PROP(i + 2); break;
case EX_FACE_MAP: name = VAR_FAM_PROP(i + 2); break;
case EX_EDGE_MAP: name = VAR_EDM_PROP(i + 2); break;
case EX_NODE_MAP: name = VAR_NM_PROP(i + 2); break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err("ex_put_prop_names", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
if ((status = nc_def_var(exoid, name, int_type, 1, dims, &propid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create property array variable in file id %d", exoid);
ex_err("ex_put_prop_names", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
vals[0] = 0; /* fill value */
/* create attribute to cause variable to fill with zeros per routine spec
*/
if ((status = nc_put_att_longlong(exoid, propid, _FillValue, int_type, 1, vals)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create property name fill attribute in file id %d", exoid);
ex_err("ex_put_prop_names", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
/* Check that the property name length is less than MAX_NAME_LENGTH */
prop_name_len = strlen(prop_names[i]) + 1;
if (prop_name_len > name_length) {
fprintf(stderr, "Warning: The property name '%s' is too long.\n\tIt will "
"be truncated from %d to %d characters\n",
prop_names[i], (int)prop_name_len - 1, (int)name_length - 1);
prop_name_len = name_length;
}
if (prop_name_len > max_name_len) {
max_name_len = prop_name_len;
}
/* store property name as attribute of property array variable */
if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME, prop_name_len, prop_names[i])) !=
NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property name %s in file id %d",
prop_names[i], exoid);
ex_err("ex_put_prop_names", errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
}
/* leave define mode */
if ((status = nc_enddef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to leave define mode in file id %d", exoid);
ex_err("ex_put_prop_names", errmsg, exerrval);
return (EX_FATAL);
}
/* Update the maximum_name_length attribute on the file. */
ex_update_max_name_length(exoid, max_name_len - 1);
nc_set_fill(exoid, oldfill, &temp); /* default: turn off fill */
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_put_prop_names", errmsg, exerrval);
}
return (EX_FATAL);
}
int ex_put_prop (int exoid,
ex_entity_type obj_type,
ex_entity_id obj_id,
const char *prop_name,
ex_entity_id value)
{
int status;
int oldfill = 0;
int temp;
int found = FALSE;
int num_props, i, dimid, propid, dims[1];
int int_type;
size_t start[1];
size_t prop_name_len, name_length;
char name[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_STR_LENGTH+1];
char dim_name[MAX_VAR_NAME_LENGTH+1];
long long vals[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* check if property has already been created */
num_props = ex_get_num_props(exoid, obj_type);
if (num_props > 1) { /* any properties other than the default 1? */
for (i=1; i<=num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_EDGE_BLOCK:
strcpy (name, VAR_ED_PROP(i));
break;
case EX_FACE_BLOCK:
strcpy (name, VAR_FA_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_EDGE_SET:
strcpy (name, VAR_ES_PROP(i));
break;
case EX_FACE_SET:
strcpy (name, VAR_FS_PROP(i));
break;
case EX_ELEM_SET:
strcpy (name, VAR_ELS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_FACE_MAP:
strcpy (name, VAR_FAM_PROP(i));
break;
case EX_EDGE_MAP:
strcpy (name, VAR_EDM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get property array id in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH+1);
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0) {
found = TRUE;
break;
}
}
}
/* if property array has not been created, create it */
if (!found) {
name_length = ex_inquire_int(exoid, EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH)+1;
/* 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_prop",errmsg,exerrval);
return (EX_FATAL);
}
/* create a variable with a name xx_prop#, where # is the new number */
/* of the property */
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_EL_BLK);
break;
case EX_FACE_BLOCK:
strcpy (name, VAR_FA_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_FA_BLK);
break;
case EX_EDGE_BLOCK:
strcpy (name, VAR_ED_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_ED_BLK);
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_NS);
break;
case EX_EDGE_SET:
strcpy (name, VAR_ES_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_ES);
break;
case EX_FACE_SET:
strcpy (name, VAR_FS_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_FS);
break;
case EX_ELEM_SET:
strcpy (name, VAR_ELS_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_ELS);
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_SS);
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_EM);
break;
case EX_FACE_MAP:
strcpy (name, VAR_FAM_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_FAM);
break;
case EX_EDGE_MAP:
strcpy (name, VAR_EDM_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_EDM);
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(num_props+1));
strcpy (dim_name, DIM_NUM_NM);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* inquire id of previously defined dimension (number of objects) */
if ((status = nc_inq_dimid(exoid, dim_name, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of objects in file id %d",
exoid);
ex_err("ex_put_prop",errmsg, exerrval);
goto error_ret; /* Exit define mode and return */
}
dims[0] = dimid;
nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */
int_type = NC_INT;
if (ex_int64_status(exoid) & EX_IDS_INT64_DB) {
int_type = NC_INT64;
}
if ((status = nc_def_var(exoid, name, int_type, 1, dims, &propid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create property array variable in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
vals[0] = 0; /* fill value */
/* create attribute to cause variable to fill with zeros per routine spec */
if ((status = nc_put_att_longlong(exoid, propid, _FillValue, int_type, 1, vals)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create property name fill attribute in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* Check that the property name length is less than MAX_NAME_LENGTH */
prop_name_len = strlen(prop_name)+1;
if (prop_name_len > name_length) {
fprintf(stderr,
"Warning: The property name '%s' is too long.\n\tIt will be truncated from %d to %d characters\n",
prop_name, (int)prop_name_len-1, (int)name_length-1);
prop_name_len = name_length;
}
/* store property name as attribute of property array variable */
if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME,
prop_name_len, (void*)prop_name)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store property name %s in file id %d",
prop_name,exoid);
ex_err("ex_put_prop",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
ex_update_max_name_length(exoid, prop_name_len-1);
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to leave define mode in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
}
/* find index into property array using obj_id; put value in property */
/* array at proper index; ex_id_lkup returns an index that is 1-based,*/
/* but netcdf expects 0-based arrays so subtract 1 */
/* special case: property name ID - check for duplicate ID assignment */
if (strcmp("ID",prop_name) == 0) {
start[0] = ex_id_lkup (exoid, obj_type, value);
if (exerrval != EX_LOOKUPFAIL) /* found the id */
{
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: attempt to assign duplicate %s ID %"PRId64" in file id %d",
ex_name_of_object(obj_type), value, exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_WARN);
}
}
start[0] = ex_id_lkup (exoid, obj_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no properties allowed for NULL %s id %"PRId64" in file id %d",
ex_name_of_object(obj_type), obj_id,exoid);
ex_err("ex_put_prop",errmsg,EX_MSG);
return (EX_WARN);
} else {
sprintf(errmsg,
"Error: failed to find value %"PRId64" in %s property array in file id %d",
obj_id, ex_name_of_object(obj_type), exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
}
start[0] = start[0] - 1;
/* value is of type 'ex_entity_id' which is a typedef to int64_t or long long */
status = nc_put_var1_longlong(exoid, propid, start, (long long*)&value);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store property value in file id %d",
exoid);
ex_err("ex_put_prop",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
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_prop",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_prop_array(int exoid, ex_entity_type obj_type, const char *prop_name,
const void_int *values)
{
int oldfill = 0;
int temp;
int num_props, i, propid, dimid, dims[1], status;
int found = EX_FALSE;
int int_type;
size_t num_obj;
char * name;
char tmpstr[MAX_STR_LENGTH + 1];
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* check if property has already been created */
num_props = ex_get_num_props(exoid, obj_type);
/* inquire id of previously defined dimension (number of objects) */
status = ex_get_dimension(exoid, ex_dim_num_objects(obj_type), ex_name_of_object(obj_type),
&num_obj, &dimid, __func__);
if (status != NC_NOERR) {
EX_FUNC_LEAVE(status);
}
for (i = 1; i <= num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK: name = VAR_EB_PROP(i); break;
case EX_FACE_BLOCK: name = VAR_FA_PROP(i); break;
case EX_EDGE_BLOCK: name = VAR_ED_PROP(i); break;
case EX_NODE_SET: name = VAR_NS_PROP(i); break;
case EX_EDGE_SET: name = VAR_ES_PROP(i); break;
case EX_FACE_SET: name = VAR_FS_PROP(i); break;
case EX_ELEM_SET: name = VAR_ELS_PROP(i); break;
case EX_SIDE_SET: name = VAR_SS_PROP(i); break;
case EX_ELEM_MAP: name = VAR_EM_PROP(i); break;
case EX_FACE_MAP: name = VAR_FAM_PROP(i); break;
case EX_EDGE_MAP: name = VAR_EDM_PROP(i); break;
case EX_NODE_MAP: name = VAR_NM_PROP(i); break;
default:
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
EX_FUNC_LEAVE(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property array id in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH + 1);
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property name in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0) {
found = EX_TRUE;
break;
}
}
/* if property array has not been created, create it */
if (!found) {
/* put netcdf file into define mode */
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);
}
/* create a variable with a name xx_prop#, where # is the new number */
/* of properties */
switch (obj_type) {
case EX_ELEM_BLOCK: name = VAR_EB_PROP(num_props + 1); break;
case EX_FACE_BLOCK: name = VAR_FA_PROP(num_props + 1); break;
case EX_EDGE_BLOCK: name = VAR_ED_PROP(num_props + 1); break;
case EX_NODE_SET: name = VAR_NS_PROP(num_props + 1); break;
case EX_EDGE_SET: name = VAR_ES_PROP(num_props + 1); break;
case EX_FACE_SET: name = VAR_FS_PROP(num_props + 1); break;
case EX_ELEM_SET: name = VAR_ELS_PROP(num_props + 1); break;
case EX_SIDE_SET: name = VAR_SS_PROP(num_props + 1); break;
case EX_ELEM_MAP: name = VAR_EM_PROP(num_props + 1); break;
case EX_FACE_MAP: name = VAR_FAM_PROP(num_props + 1); break;
case EX_EDGE_MAP: name = VAR_EDM_PROP(num_props + 1); break;
case EX_NODE_MAP: name = VAR_NM_PROP(num_props + 1); break;
default:
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err(__func__, errmsg, EX_BADPARAM);
goto error_ret; /* Exit define mode and return */
}
dims[0] = dimid;
nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */
int_type = NC_INT;
if (ex_int64_status(exoid) & EX_IDS_INT64_DB) {
int_type = NC_INT64;
}
if ((status = nc_def_var(exoid, name, int_type, 1, dims, &propid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to create property array variable in file id %d", exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* Exit define mode and return */
}
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
/* store property name as attribute of property array variable */
if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME, strlen(prop_name) + 1,
prop_name)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property name %s in file id %d",
prop_name, exoid);
ex_err(__func__, errmsg, status);
goto error_ret; /* Exit define mode and return */
}
/* leave define mode */
if ((status = nc_enddef(exoid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to leave define mode in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* put num_obj values in property array */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, propid, values);
}
else {
status = nc_put_var_int(exoid, propid, values);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to store property values in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
nc_set_fill(exoid, oldfill, &temp); /* default: nofill */
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_get_prop (int exoid,
ex_entity_type obj_type,
ex_entity_id obj_id,
const char *prop_name,
void_int *value)
{
int status;
int num_props, i, propid;
int found = EX_FALSE;
size_t start[1];
char name[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_STR_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* open appropriate variable, depending on obj_type and prop_name */
num_props = ex_get_num_props(exoid,obj_type);
for (i=1; i<=num_props; i++) {
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_EDGE_BLOCK:
strcpy (name, VAR_ED_PROP(i));
break;
case EX_FACE_BLOCK:
strcpy (name, VAR_FA_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_EDGE_SET:
strcpy (name, VAR_ES_PROP(i));
break;
case EX_FACE_SET:
strcpy (name, VAR_FS_PROP(i));
break;
case EX_ELEM_SET:
strcpy (name, VAR_ELS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_FACE_MAP:
strcpy (name, VAR_FAM_PROP(i));
break;
case EX_EDGE_MAP:
strcpy (name, VAR_EDM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate property array %s in file id %d",
name, exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH+1);
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0) {
found = EX_TRUE;
break;
}
}
/* if property is not found, return warning */
if (!found) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: %s property %s not defined in file id %d",
ex_name_of_object(obj_type), prop_name, exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_WARN);
}
/* find index into property array using obj_id; read value from property */
/* array at proper index; ex_id_lkup returns an index that is 1-based, */
/* but netcdf expects 0-based arrays so subtract 1 */
start[0] = ex_id_lkup (exoid, obj_type, obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: %s id %"PRId64" is NULL in file id %d",
ex_name_of_object(obj_type), obj_id, exoid);
ex_err("ex_get_prop",errmsg,EX_NULLENTITY);
return (EX_WARN);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate id %"PRId64" in %s property array in file id %d",
obj_id, ex_name_of_object(obj_type), exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_FATAL);
}
}
start[0] = start[0] - 1;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
long long l_val;
status = nc_get_var1_longlong (exoid, propid, start, &l_val);
if (status == NC_NOERR) {
int64_t *val = (int64_t*)value;
*val = l_val;
}
} else {
int i_val;
status = nc_get_var1_int (exoid, propid, start, &i_val);
if (status == NC_NOERR) {
int *val = (int*)value;
*val = i_val;
}
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to read value in %s property array in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_prop",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_put_num_map ( int exoid,
int map_type,
int map_id,
const int *map )
{
int dimid, varid, iresult;
long start[1];
nclong ldum, *lptr;
long num_maps, num_entries, count[1];
int cur_num_maps;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
const char* tname;
const char* dnumentries;
const char* dnummaps;
const char* vmapids;
const char* vmap = 0;
struct list_item** map_ctr_list;
exerrval = 0; /* clear error code */
cdum = 0;
switch ( map_type ) {
case EX_NODE_MAP:
tname = "node";
dnumentries = DIM_NUM_NODES;
dnummaps = DIM_NUM_NM;
vmapids = VAR_NM_PROP(1);
map_ctr_list = &nm_ctr_list;
break;
case EX_EDGE_MAP:
tname = "edge";
dnumentries = DIM_NUM_EDGE;
dnummaps = DIM_NUM_EDM;
vmapids = VAR_EDM_PROP(1);
map_ctr_list = &edm_ctr_list;
break;
case EX_FACE_MAP:
tname = "face";
dnumentries = DIM_NUM_FACE;
dnummaps = DIM_NUM_FAM;
vmapids = VAR_FAM_PROP(1);
map_ctr_list = &fam_ctr_list;
break;
case EX_ELEM_MAP:
tname = "element";
dnumentries = DIM_NUM_ELEM;
dnummaps = DIM_NUM_EM;
vmapids = VAR_EM_PROP(1);
map_ctr_list = &em_ctr_list;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg,
"Error: Bad map type (%d) specified for file id %d",
map_type, exoid );
ex_err( "ex_put_num_map", errmsg, exerrval );
return (EX_FATAL);
}
/* Make sure the file contains entries */
if ((dimid = (ncdimid (exoid, dnumentries))) == -1 )
{
return (EX_NOERR);
}
/* first check if any maps are specified */
if ((dimid = (ncdimid (exoid, dnummaps))) == -1 )
{
exerrval = ncerr;
sprintf(errmsg,
"Error: no %s maps specified in file id %d",
tname,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate map id entry */
ex_id_lkup(exoid,vmapids,map_id);
if (exerrval != EX_LOOKUPFAIL) /* found the map id */
{
exerrval = ncerr;
sprintf(errmsg,
"Error: %s map %d already defined in file id %d",
tname,map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return(EX_FATAL);
}
/* Get number of maps initialized for this file */
if ((ncdiminq (exoid,dimid,cdum,&num_maps)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of %s maps in file id %d",
tname,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of maps defined using a counter stored
in a linked list keyed by exoid.
NOTE: ex_get_file_item is used to find the number of maps
for a specific file and returns that value.
*/
cur_num_maps = ex_get_file_item(exoid, map_ctr_list );
if (cur_num_maps >= num_maps)
{
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %s maps (%ld) specified in file id %d",
tname,num_maps,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is used to find the number of maps
for a specific file and returns that value incremented. */
cur_num_maps = ex_inc_file_item(exoid, map_ctr_list );
/* write out information to previously defined variable */
/* first get id of variable */
if ((varid = ncvarid (exoid, vmapids)) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate %s map ids in file id %d",
tname,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out map id */
start[0] = cur_num_maps;
ldum = (nclong)map_id;
if (ncvarput1 (exoid, varid, start, &ldum) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store %s map id %d in file id %d",
tname,map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* determine number of entries */
if ((dimid = (ncdimid (exoid, dnumentries))) == -1 )
{
exerrval = ncerr;
sprintf(errmsg,
"Error: couldn't determine number of %s entries in file id %d",
tname,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
if (ncdiminq (exoid, dimid, (char *) 0, &num_entries) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to get number of %s entries in file id %d",
tname,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
switch ( map_type ) {
case EX_NODE_MAP:
vmap = VAR_NODE_MAP(cur_num_maps+1);
break;
case EX_EDGE_MAP:
vmap = VAR_EDGE_MAP(cur_num_maps+1);
break;
case EX_FACE_MAP:
vmap = VAR_FACE_MAP(cur_num_maps+1);
break;
case EX_ELEM_MAP:
vmap = VAR_ELEM_MAP(cur_num_maps+1);
break;
}
/* locate variable array in which to store the map */
if ((varid = ncvarid(exoid,vmap)) == -1)
{
#if 0
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to locate %s map %d in file id %d",
vmap,map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
#endif
int dims[2];
ncerr = 0;
if ( ncredef( exoid ) == -1 ) {
exerrval = ncerr;
sprintf(errmsg, "Error: failed to place file id %d into define mode", exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
dims[0] = dimid;
if ( (varid = ncvardef( exoid, vmap, NC_LONG, 1, dims )) == -1 ) {
exerrval = ncerr;
sprintf(errmsg, "Error: failed to define map %s in file id %d", vmap, exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
}
if ( ncendef( exoid ) == -1 ) { /* exit define mode */
sprintf( errmsg, "Error: failed to complete definition for file id %d", exoid );
ex_err( "ex_put_num_map", errmsg, exerrval );
varid = -1; /* force early exit */
}
if ( varid == -1 ) /* we couldn't define variable and have prepared error message. */
return (EX_FATAL);
}
/* write out the map */
/* 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_entries;
if (sizeof(int) == sizeof(nclong)) {
iresult = ncvarput (exoid, varid, start, count, map);
} else {
lptr = itol (map, (int)num_entries);
iresult = ncvarput (exoid, varid, start, count, lptr);
free(lptr);
}
if (iresult == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to store %s map in file id %d",
tname,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
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);
}
/*!
* writes a map; this is a vector of integers of length number of mesh
* objects of that type (element, node, face, edge)
*/
int ex_put_partial_num_map (int exoid,
ex_entity_type map_type,
ex_entity_id map_id,
int64_t ent_start,
int64_t ent_count,
const void_int *map)
{
int status;
int dimid, varid, map_ndx, map_exists;
size_t start[1];
size_t num_maps, num_mobj, count[1];
int cur_num_maps;
char errmsg[MAX_ERR_LENGTH];
const char* dnumentries;
const char* dnummaps;
const char* vmapids;
const char* vmap;
exerrval = 0; /* clear error code */
switch ( map_type ) {
case EX_NODE_MAP:
dnumentries = DIM_NUM_NODES;
dnummaps = DIM_NUM_NM;
vmapids = VAR_NM_PROP(1);
break;
case EX_EDGE_MAP:
dnumentries = DIM_NUM_EDGE;
dnummaps = DIM_NUM_EDM;
vmapids = VAR_EDM_PROP(1);
break;
case EX_FACE_MAP:
dnumentries = DIM_NUM_FACE;
dnummaps = DIM_NUM_FAM;
vmapids = VAR_FAM_PROP(1);
break;
case EX_ELEM_MAP:
dnumentries = DIM_NUM_ELEM;
dnummaps = DIM_NUM_EM;
vmapids = VAR_EM_PROP(1);
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg,
"Error: Bad map type (%d) specified for file id %d",
map_type, exoid );
ex_err( "ex_put_num_map", errmsg, exerrval );
return (EX_FATAL);
}
/* Make sure the file contains entries */
if (nc_inq_dimid (exoid, dnumentries, &dimid) != NC_NOERR ) {
return (EX_NOERR);
}
/* first check if any maps are specified */
if ((status = nc_inq_dimid (exoid, dnummaps, &dimid)) != NC_NOERR )
{
exerrval = status;
sprintf(errmsg,
"Error: no %ss specified in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check for duplicate map id entry */
ex_id_lkup(exoid,map_type,map_id);
if (exerrval == EX_LOOKUPFAIL) { /* did not find the map id */
map_exists = 0; /* Map is being defined */
} else {
map_exists = 1; /* A portion of this map has already been written */
}
/* Check for duplicate map id entry */
if (!map_exists) {
/* Get number of maps initialized for this file */
if ((status = nc_inq_dimlen(exoid,dimid,&num_maps)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Keep track of the total number of maps defined using a
counter stored in a linked list keyed by exoid. NOTE:
ex_get_file_item is used to find the number of element maps for a
specific file and returns that value.
*/
cur_num_maps = ex_get_file_item(exoid, ex_get_counter_list(map_type));
if (cur_num_maps >= (int)num_maps) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%"ST_ZU") specified in file id %d",
ex_name_of_object(map_type),num_maps,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is used to find the number of element maps
for a specific file and returns that value incremented. */
cur_num_maps = ex_inc_file_item(exoid, ex_get_counter_list(map_type));
} else {
map_ndx = ex_id_lkup(exoid,map_type,map_id);
cur_num_maps = map_ndx-1;
}
/* determine number of elements */
if ((status = nc_inq_dimid(exoid, dnumentries, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: couldn't determine number of mesh objects in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_mobj)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of mesh objects in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* Check input parameters for a valid range of numbers */
if (ent_start <= 0 || ent_start > num_mobj) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: start count is invalid in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
if (ent_count < 0) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: Invalid count value in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
if (ent_start+ent_count-1 > num_mobj) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: start+count-1 is larger than mesh object count in file id %d",
exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* write out information to previously defined variable */
/* first get id of variable */
if ((status = nc_inq_varid (exoid, vmapids, &varid)) == -1)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* then, write out map id */
if (!map_exists) {
start[0] = cur_num_maps;
{
if ((status = nc_put_var1_longlong(exoid, varid, start, (long long*)&map_id)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" in file id %d",
ex_name_of_object(map_type),map_id,exoid);
ex_err("ex_put_num_map",errmsg,exerrval);
return (EX_FATAL);
}
}
}
switch ( map_type ) {
case EX_NODE_MAP:
vmap = VAR_NODE_MAP(cur_num_maps+1);
break;
case EX_EDGE_MAP:
vmap = VAR_EDGE_MAP(cur_num_maps+1);
break;
case EX_FACE_MAP:
vmap = VAR_FACE_MAP(cur_num_maps+1);
break;
case EX_ELEM_MAP:
vmap = VAR_ELEM_MAP(cur_num_maps+1);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized map type in switch: %d in file id %d",
map_type,exoid);
ex_err("ex_putt_partial_one_attr",errmsg,EX_MSG);
return (EX_FATAL);
}
/* locate variable array in which to store the map */
if ((status = nc_inq_varid(exoid,vmap, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %"PRId64" in file id %d",
ex_name_of_object(map_type),map_id,exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
/* write out the map */
start[0] = ent_start-1;
count[0] = ent_count;
if (count[0] == 0)
start[0] = 0;
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_put_vara_longlong(exoid, varid, start, count, map);
} else {
status = nc_put_vara_int(exoid, varid, start, count, map);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s in file id %d",
ex_name_of_object(map_type),exoid);
ex_err("ex_put_partial_num_map",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_id_lkup( int exoid,
ex_entity_type id_type,
int num)
{
char id_table[MAX_VAR_NAME_LENGTH+1];
char id_dim[MAX_VAR_NAME_LENGTH+1];
char stat_table[MAX_VAR_NAME_LENGTH+1];
int varid, dimid;
size_t dim_len, i;
int *id_vals=NULL, *stat_vals=NULL;
static int filled=FALSE;
struct obj_stats *tmp_stats;
int status;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
switch(id_type) {
case EX_NODAL:
return 0;
case EX_GLOBAL:
return 0;
case EX_ELEM_BLOCK:
strcpy(id_table, VAR_ID_EL_BLK); /* id array name */
strcpy(id_dim, DIM_NUM_EL_BLK); /* id array dimension name*/
strcpy(stat_table, VAR_STAT_EL_BLK); /* id status array name */
tmp_stats = ex_get_stat_ptr (exoid, &exoII_eb);
break;
case EX_NODE_SET:
strcpy(id_table, VAR_NS_IDS);
strcpy(id_dim, DIM_NUM_NS);
strcpy(stat_table, VAR_NS_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_ns);
break;
case EX_SIDE_SET:
strcpy(id_table, VAR_SS_IDS);
strcpy(id_dim, DIM_NUM_SS);
strcpy(stat_table, VAR_SS_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_ss);
break;
case EX_ELEM_MAP:
strcpy(id_table, VAR_EM_PROP(1));
strcpy(id_dim, DIM_NUM_EM);
strcpy(stat_table, "");
tmp_stats = ex_get_stat_ptr (exoid, &exoII_em);
break;
case EX_NODE_MAP:
strcpy(id_table, VAR_NM_PROP(1));
strcpy(id_dim, DIM_NUM_NM);
strcpy(stat_table, "");
tmp_stats = ex_get_stat_ptr (exoid, &exoII_nm);
break;
case EX_EDGE_BLOCK:
strcpy(id_table, VAR_ID_ED_BLK);
strcpy(id_dim, DIM_NUM_ED_BLK);
strcpy(stat_table, VAR_STAT_ED_BLK);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_ed);
break;
case EX_FACE_BLOCK:
strcpy(id_table, VAR_ID_FA_BLK);
strcpy(id_dim, DIM_NUM_FA_BLK);
strcpy(stat_table, VAR_STAT_FA_BLK);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_fa);
break;
case EX_EDGE_SET:
strcpy(id_table, VAR_ES_IDS);
strcpy(id_dim, DIM_NUM_ES);
strcpy(stat_table, VAR_ES_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_es);
break;
case EX_FACE_SET:
strcpy(id_table, VAR_FS_IDS);
strcpy(id_dim, DIM_NUM_FS);
strcpy(stat_table, VAR_FS_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_fs);
break;
case EX_ELEM_SET:
strcpy(id_table, VAR_ELS_IDS);
strcpy(id_dim, DIM_NUM_ELS);
strcpy(stat_table, VAR_ELS_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_els);
break;
case EX_EDGE_MAP:
strcpy(id_table, VAR_EDM_PROP(1));
strcpy(id_dim, DIM_NUM_EDM);
strcpy(stat_table, "");
tmp_stats = ex_get_stat_ptr (exoid, &exoII_edm);
break;
case EX_FACE_MAP:
strcpy(id_table, VAR_FAM_PROP(1));
strcpy(id_dim, DIM_NUM_FAM);
strcpy(stat_table, "");
tmp_stats = ex_get_stat_ptr (exoid, &exoII_fam);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: unsupported id array type %d for file id %d",
id_type, exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
if ( (tmp_stats->id_vals == NULL) || (!(tmp_stats->valid_ids)) ) {
/* first time thru or id arrays haven't been completely filled yet */
/* get size of id array */
/* First get dimension id of id array */
if ((status = nc_inq_dimid(exoid,id_dim,&dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate id array dimension in file id %d",
exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
/* Next get value of dimension */
if ((status = nc_inq_dimlen(exoid,dimid,&dim_len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s array length in file id %d",
id_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of id array */
if ((status = nc_inq_varid (exoid, id_table, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s array in file id %d",
id_table, exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
/* allocate space for id array */
if (!(id_vals = malloc((int)dim_len*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s array for file id %d",
id_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_get_var_int (exoid, varid, id_vals)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s array from file id %d",
id_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
free(id_vals);
return (EX_FATAL);
}
/* check if values in stored arrays are filled with non-zeroes */
filled = TRUE;
for (i=0;i<dim_len;i++) {
if (id_vals[i] == 0 || id_vals[i] == NC_FILL_INT) {
filled = FALSE;
break; /* id array hasn't been completely filled with valid ids yet */
}
}
if (filled) {
tmp_stats->valid_ids = TRUE;
tmp_stats->num = (long)dim_len;
tmp_stats->id_vals = id_vals;
}
} else {
id_vals = tmp_stats->id_vals;
dim_len = tmp_stats->num;
}
/* Do a linear search through the id array to find the array value
corresponding to the passed index number */
for (i=0;i<dim_len;i++) {
if (id_vals[i] == num)
break; /* found the id requested */
}
if (i >= dim_len) /* failed to find id number */
{
if ( !(tmp_stats->valid_ids) ) {
free (id_vals);
}
exerrval = EX_LOOKUPFAIL;
return(EX_LOOKUPFAIL); /*if we got here, the id array value doesn't exist */
}
/* Now check status array to see if object is null */
/* get variable id of status array */
if (nc_inq_varid (exoid, stat_table, &varid) == NC_NOERR) {
/* if status array exists, use it, otherwise assume object exists
to be backward compatible */
if ( (tmp_stats->stat_vals == NULL) || (!(tmp_stats->valid_stat)) ) {
/* first time thru or status arrays haven't been filled yet */
/* allocate space for new status array */
if (!(stat_vals = malloc((int)dim_len*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s array for file id %d",
id_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_get_var_int (exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to get %s array from file id %d",
stat_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
if (tmp_stats->valid_ids) {
/* status array is valid only if ids are valid */
tmp_stats->valid_stat = TRUE;
tmp_stats->stat_vals = stat_vals;
}
} else {
stat_vals = tmp_stats->stat_vals;
}
if (stat_vals[i] == 0) /* is this object null? */ {
exerrval = EX_NULLENTITY;
if ( !(tmp_stats->valid_stat) ) {
free (stat_vals);
}
if ( !(tmp_stats->valid_ids) ) {
if (id_vals) free (id_vals);
}
return(-(((int)i)+1)); /* return index into id array (1-based) */
}
}
if ( !(tmp_stats->valid_ids) ) {
if (id_vals) free (id_vals);
if (stat_vals) free (stat_vals);
}
return(((int)i)+1); /* return index into id array (1-based) */
}
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_get_prop_names (int exoid,
ex_entity_type obj_type,
char **prop_names)
{
int status;
int i, num_props, propid;
char var_name[12];
size_t att_len;
nc_type att_type;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0;
/* determine which type of object property names are desired for */
num_props = ex_get_num_props (exoid, obj_type);
for (i=0; i<num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK:
strcpy (var_name, VAR_EB_PROP(i+1));
break;
case EX_FACE_BLOCK:
strcpy (var_name, VAR_FA_PROP(i+1));
break;
case EX_EDGE_BLOCK:
strcpy (var_name, VAR_ED_PROP(i+1));
break;
case EX_NODE_SET:
strcpy (var_name, VAR_NS_PROP(i+1));
break;
case EX_SIDE_SET:
strcpy (var_name, VAR_SS_PROP(i+1));
break;
case EX_EDGE_SET:
strcpy (var_name, VAR_ES_PROP(i+1));
break;
case EX_FACE_SET:
strcpy (var_name, VAR_FS_PROP(i+1));
break;
case EX_ELEM_SET:
strcpy (var_name, VAR_ELS_PROP(i+1));
break;
case EX_ELEM_MAP:
strcpy (var_name, VAR_EM_PROP(i+1));
break;
case EX_FACE_MAP:
strcpy (var_name, VAR_FAM_PROP(i+1));
break;
case EX_EDGE_MAP:
strcpy (var_name, VAR_EDM_PROP(i+1));
break;
case EX_NODE_MAP:
strcpy (var_name, VAR_NM_PROP(i+1));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_get_prop_names",errmsg,EX_BADPARAM);
return(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, var_name, &propid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate property array %s in file id %d",
var_name, exoid);
ex_err("ex_get_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
/* for each property, read the "name" attribute of property array variable */
if ((status = nc_inq_att(exoid, propid, ATT_PROP_NAME, &att_type, &att_len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get property attributes (type, len) in file id %d", exoid);
ex_err("ex_get_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
if (att_len-1 <= ex_max_name_length) {
/* Client has large enough char string to hold text... */
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, prop_names[i])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get property name in file id %d", exoid);
ex_err("ex_get_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
}
else {
/* FIXME */
exerrval = NC_ESTS;
sprintf(errmsg,
"Error: property name length exceeds space available to store it in file id %d", exoid);
ex_err("ex_get_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
}
int ex_put_prop_names (int exoid,
ex_entity_type obj_type,
int num_props,
char **prop_names)
{
int status;
int oldfill, temp;
int i, propid, dimid, dims[1];
char name[MAX_VAR_NAME_LENGTH+1];
int vals[1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* inquire id of previously defined dimension (number of objects) */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(obj_type), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of %s in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_put_prop_names",errmsg, exerrval);
return(EX_FATAL);
}
nc_set_fill(exoid, NC_FILL, &oldfill); /* fill with zeros per routine spec */
/* 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_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
/* define num_props variables; we postpend the netcdf variable name with */
/* a counter starting at 2 because "xx_prop1" is reserved for the id array*/
dims[0] = dimid;
for (i=0; i<num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i+2));
break;
case EX_FACE_BLOCK:
strcpy (name, VAR_FA_PROP(i+2));
break;
case EX_EDGE_BLOCK:
strcpy (name, VAR_ED_PROP(i+2));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i+2));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i+2));
break;
case EX_EDGE_SET:
strcpy (name, VAR_ES_PROP(i+2));
break;
case EX_FACE_SET:
strcpy (name, VAR_FS_PROP(i+2));
break;
case EX_ELEM_SET:
strcpy (name, VAR_ELS_PROP(i+2));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i+2));
break;
case EX_FACE_MAP:
strcpy (name, VAR_FAM_PROP(i+2));
break;
case EX_EDGE_MAP:
strcpy (name, VAR_EDM_PROP(i+2));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i+2));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
if ((status = nc_def_var(exoid, name, NC_INT, 1, dims, &propid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create property array variable in file id %d",
exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
vals[0] = 0; /* fill value */
/* create attribute to cause variable to fill with zeros per routine spec */
if ((status = nc_put_att_int(exoid, propid, _FillValue, NC_INT, 1, vals)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create property name fill attribute in file id %d",
exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
goto error_ret; /* Exit define mode and return */
}
/* store property name as attribute of property array variable */
if ((status = nc_put_att_text(exoid, propid, ATT_PROP_NAME,
strlen(prop_names[i])+1, prop_names[i])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store property name %s in file id %d",
prop_names[i],exoid);
ex_err("ex_put_prop_names",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 leave define mode in file id %d",
exoid);
ex_err("ex_put_prop_names",errmsg,exerrval);
return (EX_FATAL);
}
nc_set_fill(exoid, oldfill, &temp); /* default: turn off fill */
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_prop_names",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_ids (int exoid,
ex_entity_type obj_type,
void_int *ids)
{
int varid, status;
char errmsg[MAX_ERR_LENGTH];
const char* varidobj;
exerrval = 0; /* clear error code */
switch (obj_type) {
case EX_EDGE_BLOCK:
varidobj = VAR_ID_ED_BLK;
break;
case EX_FACE_BLOCK:
varidobj = VAR_ID_FA_BLK;
break;
case EX_ELEM_BLOCK:
varidobj = VAR_ID_EL_BLK;
break;
case EX_NODE_SET:
varidobj = VAR_NS_IDS;
break;
case EX_EDGE_SET:
varidobj = VAR_ES_IDS;
break;
case EX_FACE_SET:
varidobj = VAR_FS_IDS;
break;
case EX_SIDE_SET:
varidobj = VAR_SS_IDS;
break;
case EX_ELEM_SET:
varidobj = VAR_ELS_IDS;
break;
case EX_NODE_MAP:
varidobj = VAR_NM_PROP(1);
break;
case EX_EDGE_MAP:
varidobj = VAR_EDM_PROP(1);
break;
case EX_FACE_MAP:
varidobj = VAR_FAM_PROP(1);
break;
case EX_ELEM_MAP:
varidobj = VAR_EM_PROP(1);
break;
default:/* invalid variable type */
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid type specified in file id %d", exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return(EX_FATAL);
}
/* Determine if there are any 'obj-type' objects */
if ((status = nc_inq_dimid (exoid, ex_dim_num_objects(obj_type), &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no %s defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_WARN);
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, varidobj, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids variable in file id %d",
ex_name_of_object(obj_type),exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the element block ids */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varid, ids);
} else {
status = nc_get_var_int(exoid, varid, ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to return %s ids in file id %d",
ex_name_of_object(obj_type),exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
