int ex_put_sets (int exoid,
size_t set_count,
const struct ex_set *sets)
{
size_t i;
int needs_define = 0;
int set_stat;
int dimid, varid, status, dims[1];
int set_id_ndx;
size_t start[1];
int cur_num_sets;
char errmsg[MAX_ERR_LENGTH];
int* sets_to_define = NULL;
char* numentryptr = NULL;
char* entryptr = NULL;
char* extraptr = NULL;
char* idsptr = NULL;
char* statptr = NULL;
char* numdfptr = NULL;
char* factptr = NULL;
size_t int_size;
exerrval = 0; /* clear error code */
sets_to_define = malloc(set_count*sizeof(int));
/* Note that this routine can be called:
1) just define the sets
2) just output the set data (after a previous call to define)
3) define and output the set data in one call.
*/
for (i=0; i < set_count; i++) {
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(sets[i].type), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: no %ss defined for file id %d", ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %ss defined in file id %d",
ex_name_of_object(sets[i].type), exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
set_id_ndx = ex_id_lkup(exoid, sets[i].type, sets[i].id);
if (exerrval != EX_LOOKUPFAIL) { /* found the side set id, so set is already defined... */
sets_to_define[i] = 0;
continue;
} else {
needs_define++;
sets_to_define[i] = 1;
}
}
if (needs_define > 0) {
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i < set_count; i++) {
if (sets_to_define[i] == 0)
continue;
/* NOTE: ex_inc_file_item finds the current number of sets defined
for a specific file and returns that value incremented. */
cur_num_sets=ex_inc_file_item(exoid, ex_get_counter_list(sets[i].type));
set_id_ndx = cur_num_sets + 1;
sets_to_define[i] = set_id_ndx;
if (sets[i].num_entry == 0)
continue;
/* setup pointers based on set_type */
if (sets[i].type == EX_NODE_SET) {
numentryptr = DIM_NUM_NOD_NS(set_id_ndx);
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
/* note we are using DIM_NUM_NODE_NS instead of DIM_NUM_DF_NS */
numdfptr = DIM_NUM_NOD_NS(set_id_ndx);
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (sets[i].type == EX_EDGE_SET) {
numentryptr = DIM_NUM_EDGE_ES(set_id_ndx);
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
numdfptr = DIM_NUM_DF_ES(set_id_ndx);
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (sets[i].type == EX_FACE_SET) {
numentryptr = DIM_NUM_FACE_FS(set_id_ndx);
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
numdfptr = DIM_NUM_DF_FS(set_id_ndx);
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (sets[i].type == EX_SIDE_SET) {
numentryptr = DIM_NUM_SIDE_SS(set_id_ndx);
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
numdfptr = DIM_NUM_DF_SS(set_id_ndx);
factptr = VAR_FACT_SS(set_id_ndx);
}
else if (sets[i].type == EX_ELEM_SET) {
numentryptr = DIM_NUM_ELE_ELS(set_id_ndx);
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
numdfptr = DIM_NUM_DF_ELS(set_id_ndx);
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* define dimensions and variables */
if ((status = nc_def_dim(exoid, numentryptr,
sets[i].num_entry, &dimid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: %s %"PRId64" -- size already defined in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
else {
sprintf(errmsg,
"Error: failed to define number of entries in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret;
}
int_size = sizeof(int);
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
int_size = sizeof(int64_t);
}
/* create variable array in which to store the entry lists */
dims[0] = dimid;
if ((status = nc_def_var(exoid, entryptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: entry list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create entry list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
if (extraptr) {
if ((status = nc_def_var(exoid, extraptr, int_size, 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: extra list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create extra list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 1);
}
/* Create distribution factors variable if required */
if (sets[i].num_distribution_factor > 0) {
if (sets[i].type != EX_SIDE_SET) {
/* but sets[i].num_distribution_factor must equal number of nodes */
if (sets[i].num_distribution_factor != sets[i].num_entry) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # dist fact (%"PRId64") not equal to # nodes (%"PRId64") in node set %"PRId64" file id %d",
sets[i].num_distribution_factor, sets[i].num_entry, sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* resuse dimid from entry lists */
if ((status = nc_def_dim(exoid, numdfptr,
sets[i].num_distribution_factor, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of dist factors in %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* create variable array in which to store the set distribution factors
*/
dims[0] = dimid;
if ((status = nc_def_var(exoid, factptr, nc_flt_code(exoid), 1, dims, &varid)) != NC_NOERR) {
exerrval = status;
if (status == NC_ENAMEINUSE) {
sprintf(errmsg,
"Error: dist factors list already exists for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
} else {
sprintf(errmsg,
"Error: failed to create dist factors list for %s %"PRId64" in file id %d",
ex_name_of_object(sets[i].type), sets[i].id,exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definition in file id %d", exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* Output the set ids and status... */
for (i=0; i < set_count; i++) {
/* setup pointers based on sets[i].type */
if (sets[i].type == EX_NODE_SET) {
idsptr = VAR_NS_IDS;
statptr = VAR_NS_STAT;
}
else if (sets[i].type == EX_EDGE_SET) {
idsptr = VAR_ES_IDS;
statptr = VAR_ES_STAT;
}
else if (sets[i].type == EX_FACE_SET) {
idsptr = VAR_FS_IDS;
statptr = VAR_FS_STAT;
}
else if (sets[i].type == EX_SIDE_SET) {
idsptr = VAR_SS_IDS;
statptr = VAR_SS_STAT;
}
else if (sets[i].type == EX_ELEM_SET) {
idsptr = VAR_ELS_IDS;
statptr = VAR_ELS_STAT;
}
/* first: get id of set id variable */
if ((status = nc_inq_varid(exoid, idsptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
/* write out set id */
start[0] = sets_to_define[i]-1;
status = nc_put_var1_longlong(exoid, varid, start, (long long*)&sets[i].id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" in file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
set_stat = (sets[i].num_entry == 0) ? 0 : 1;
if ((status = nc_inq_varid(exoid, statptr, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d", ex_name_of_object(sets[i].type),
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &set_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s %"PRId64" status to file id %d", ex_name_of_object(sets[i].type),
sets[i].id, exoid);
ex_err("ex_put_sets",errmsg,exerrval);
return (EX_FATAL);
}
}
free(sets_to_define);
}
/* Sets are now all defined; see if any set data needs to be output... */
status = EX_NOERR;
for (i=0; i < set_count; i++) {
int stat;
if (sets[i].entry_list != NULL || sets[i].extra_list != NULL) {
/* NOTE: ex_put_set will write the warning/error message... */
stat = ex_put_set(exoid, sets[i].type, sets[i].id, sets[i].entry_list, sets[i].extra_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
if (sets[i].distribution_factor_list != NULL) {
/* NOTE: ex_put_set_dist_fact will write the warning/error message... */
stat = ex_put_set_dist_fact(exoid, sets[i].type, sets[i].id, sets[i].distribution_factor_list);
if (stat != EX_NOERR) status = EX_FATAL;
}
}
return (status);
/* Fatal error: exit definition mode and return */
error_ret:
free(sets_to_define);
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_sets",errmsg,exerrval);
}
return (EX_FATAL);
}
int
main(int argc, char **argv)
{
printf("\n*** Testing netcdf-4 group functions.\n");
printf("*** testing use of unlimited dim in parent group...");
{
#define NDIMS_IN_VAR 1
#define NDIMS_IN_FILE 2
#define BABE_LIMIT 3
#define DIM_NAME1 "Influence"
#define DIM_NAME2 "Babe_Factor"
#define VAR_NAME1 "Court_of_Star_Chamber"
#define VAR_NAME2 "Justice_of_the_Peace"
#define VAR_NAME3 "Bosworth_Field"
int ncid, dimid1, dimid2, varid1, varid2, varid3, henry_vii_id;
int grpid_in, varid_in1, varid_in2, varid_in3;
nc_type xtype_in;
int ndims_in, dimids_in[NDIMS_IN_FILE], dimid1_in, natts;
char name_in[NC_MAX_NAME + 1];
size_t len_in, index[NDIMS_IN_VAR] = {0};
long long value = NC_FILL_INT64 + 1, value_in;
/* Create a file with an unlimited dim and a limited, used by
* variables in child groups. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME1, NC_UNLIMITED, &dimid1)) ERR;
if (nc_def_dim(ncid, DIM_NAME2, BABE_LIMIT, &dimid2)) ERR;
if (nc_def_grp(ncid, HENRY_VII, &henry_vii_id)) ERR;
if (nc_def_var(henry_vii_id, VAR_NAME1, NC_INT64, NDIMS_IN_VAR, &dimid1, &varid1)) ERR;
if (nc_def_var(henry_vii_id, VAR_NAME2, NC_INT64, NDIMS_IN_VAR, &dimid1, &varid2)) ERR;
if (nc_def_var(henry_vii_id, VAR_NAME3, NC_INT64, NDIMS_IN_VAR, &dimid2, &varid3)) ERR;
/* Check it out. Find the group by name. */
if (nc_inq_ncid(ncid, HENRY_VII, &grpid_in)) ERR;
/* Ensure that dimensions in parent are visible and correct. */
if (nc_inq_dimids(grpid_in, &ndims_in, dimids_in, 1)) ERR;
if (ndims_in != NDIMS_IN_FILE || dimids_in[0] != dimid1 || dimids_in[1] != dimid2) ERR;
if (nc_inq_dim(grpid_in, dimids_in[0], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM_NAME1) || len_in != 0) ERR;
if (nc_inq_dim(grpid_in, dimids_in[1], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM_NAME2) || len_in != BABE_LIMIT) ERR;
/* Check the vars in the group. */
if (nc_inq_varid(grpid_in, VAR_NAME1, &varid_in1)) ERR;
if (nc_inq_varid(grpid_in, VAR_NAME2, &varid_in2)) ERR;
if (nc_inq_varid(grpid_in, VAR_NAME3, &varid_in3)) ERR;
if (varid_in1 != varid1 || varid_in2 != varid2 || varid_in3 != varid3) ERR;
if (nc_inq_var(grpid_in, varid1, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME1) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid1 || natts != 0) ERR;
if (nc_inq_var(grpid_in, varid2, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME2) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid1 || natts != 0) ERR;
if (nc_inq_var(grpid_in, varid3, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME3) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid2 || natts != 0) ERR;
/* Write one value to one variable. */
if (nc_put_var1_longlong(grpid_in, varid_in1, index, &value)) ERR;
/* Read one value from the second unlim dim variable. It should
* be the fill value. */
if (nc_get_var1_longlong(grpid_in, varid_in2, index, &value_in)) ERR;
if (value_in != NC_FILL_INT64) ERR;
/* Read one value from the variable with limited dim. It should
* be the fill value. */
if (nc_get_var1_longlong(grpid_in, varid_in3, index, &value_in)) ERR;
if (value_in != NC_FILL_INT64) ERR;
/* Attempt to read beyond end of dimensions to generate error. */
index[0] = BABE_LIMIT;
if (nc_get_var1_longlong(grpid_in, varid_in1, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_get_var1_longlong(grpid_in, varid_in2, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_get_var1_longlong(grpid_in, varid_in3, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_close(ncid)) ERR;
/* Check it out again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Find the group by name. */
if (nc_inq_ncid(ncid, HENRY_VII, &grpid_in)) ERR;
/* Ensure that dimensions in parent are visible and correct. */
if (nc_inq_dimids(grpid_in, &ndims_in, dimids_in, 1)) ERR;
if (ndims_in != NDIMS_IN_FILE || dimids_in[0] != dimid1 || dimids_in[1] != dimid2) ERR;
if (nc_inq_dim(grpid_in, dimids_in[0], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM_NAME1) || len_in != 1) ERR;
if (nc_inq_dim(grpid_in, dimids_in[1], name_in, &len_in)) ERR;
if (strcmp(name_in, DIM_NAME2) || len_in != BABE_LIMIT) ERR;
/* Check the vars in the group. */
if (nc_inq_varid(grpid_in, VAR_NAME1, &varid_in1)) ERR;
if (nc_inq_varid(grpid_in, VAR_NAME2, &varid_in2)) ERR;
if (nc_inq_varid(grpid_in, VAR_NAME3, &varid_in3)) ERR;
if (varid_in1 != varid1 || varid_in2 != varid2 || varid_in3 != varid3) ERR;
if (nc_inq_var(grpid_in, varid1, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME1) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid1 || natts != 0) ERR;
if (nc_inq_var(grpid_in, varid2, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME2) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid1 || natts != 0) ERR;
if (nc_inq_var(grpid_in, varid3, name_in, &xtype_in, &ndims_in, &dimid1_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME3) || xtype_in != NC_INT64 || ndims_in != NDIMS_IN_VAR ||
dimid1_in != dimid2 || natts != 0) ERR;
/* Read one value from the second unlim dim variable. It should
* be the fill value. */
index[0] = 0;
if (nc_get_var1_longlong(grpid_in, varid_in2, index, &value_in)) ERR;
if (value_in != NC_FILL_INT64) ERR;
/* Read one value from the variable with limited dim. It should
* be the fill value. */
if (nc_get_var1_longlong(grpid_in, varid_in3, index, &value_in)) ERR;
if (value_in != NC_FILL_INT64) ERR;
/* Attempt to read beyond end of dimensions to generate error. */
index[0] = BABE_LIMIT;
if (nc_get_var1_longlong(grpid_in, varid_in1, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_get_var1_longlong(grpid_in, varid_in2, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_get_var1_longlong(grpid_in, varid_in3, index, &value_in) != NC_EINVALCOORDS) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing groups and unlimited dimensions...");
{
int ncid;
int henry_vii_id;
int tudor_id;
int dimids_in[MAX_SIBLING_GROUPS], ndims_in;
int num_grps;
int dimid, dynasty, varid;
size_t len_in;
int natts_in;
int grpids_in[10];
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int data_out[DIM1_LEN] = {0, 2, 6}, data_in[DIM1_LEN];
size_t start[1] = {0}, count[1] = {3};
int j;
/* Create one group, with one var, which has one dimension, which is unlimited. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_grp(ncid, DYNASTY, &tudor_id)) ERR;
if (nc_def_dim(tudor_id, DIM1_NAME, NC_UNLIMITED, &dimid)) ERR;
if (nc_def_grp(tudor_id, HENRY_VII, &henry_vii_id)) ERR;
if (nc_def_var(henry_vii_id, VAR1_NAME, NC_INT, 1, &dimid, &varid)) ERR;
if (nc_put_vara_int(henry_vii_id, varid, start, count, data_out)) ERR;
if (nc_close(ncid)) ERR;
/* Now check the file to see if the dimension and variable are
* there. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_grps(ncid, &num_grps, &dynasty)) ERR;
if (num_grps != 1) ERR;
if (nc_inq_grps(dynasty, &num_grps, grpids_in)) ERR;
if (num_grps != 1) ERR;
if (nc_inq_dim(grpids_in[0], 0, name_in, &len_in)) ERR;
if (strcmp(name_in, DIM1_NAME) || len_in != DIM1_LEN) ERR;
if (nc_inq_var(grpids_in[0], 0, name_in, &xtype_in, &ndims_in, dimids_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR1_NAME) || xtype_in != NC_INT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_get_vara_int(grpids_in[0], 0, start, count, data_in)) ERR;
for (j=0; j<DIM1_LEN; j++)
if (data_in[j] != data_out[j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
/*! \internal */
int
cpy_var_val(int in_id,int out_id,char *var_nm)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
char *var_nm: input variable name
*/
{
/* Routine to copy the variable data from an input netCDF file
* to an output netCDF file.
*/
int *dim_id;
int idx;
int nbr_dim;
int var_in_id;
int var_out_id;
size_t *dim_cnt;
size_t *dim_sz;
size_t *dim_srt;
size_t var_sz=1L;
nc_type var_type_in, var_type_out;
void *void_ptr = NULL;
/* Get the var_id for the requested variable from both files. */
(void)nc_inq_varid(in_id, var_nm, &var_in_id);
(void)nc_inq_varid(out_id,var_nm, &var_out_id);
/* Get the number of dimensions for the variable. */
(void)nc_inq_vartype( out_id, var_out_id, &var_type_out);
(void)nc_inq_varndims(out_id, var_out_id, &nbr_dim);
(void)nc_inq_vartype( in_id, var_in_id, &var_type_in);
(void)nc_inq_varndims(in_id, var_in_id, &nbr_dim);
/* Allocate space to hold the dimension IDs */
dim_cnt = malloc(nbr_dim*sizeof(size_t));
dim_id=malloc(nbr_dim*sizeof(int));
dim_sz=malloc(nbr_dim*sizeof(size_t));
dim_srt=malloc(nbr_dim*sizeof(size_t));
/* Get the dimension IDs from the input file */
(void)nc_inq_vardimid(in_id, var_in_id, dim_id);
/* Get the dimension sizes and names from the input file */
for(idx=0;idx<nbr_dim;idx++){
/* NB: For the unlimited dimension, ncdiminq() returns the maximum
value used so far in writing data for that dimension.
Thus if you read the dimension sizes from the output file, then
the ncdiminq() returns dim_sz=0 for the unlimited dimension
until a variable has been written with that dimension. This is
the reason for always reading the input file for the dimension
sizes. */
(void)nc_inq_dimlen(in_id,dim_id[idx],dim_cnt+idx);
/* Initialize the indicial offset and stride arrays */
dim_srt[idx]=0L;
var_sz*=dim_cnt[idx];
} /* end loop over dim */
/* Allocate enough space to hold the variable */
if (var_sz > 0)
void_ptr=malloc(var_sz * type_size(var_type_in));
/* Get the variable */
/* if variable is float or double, convert if necessary */
if(nbr_dim==0){ /* variable is a scalar */
if (var_type_in == NC_INT && var_type_out == NC_INT) {
nc_get_var1_int(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_int(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_INT64 && var_type_out == NC_INT64) {
nc_get_var1_longlong(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_longlong(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_FLOAT) {
nc_get_var1_float(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_float(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_DOUBLE) {
nc_get_var1_double(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_double(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_CHAR) {
nc_get_var1_text(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_text(out_id, var_out_id, 0L, void_ptr);
}
else {
assert(1==0);
}
} else { /* variable is a vector */
if (var_type_in == NC_INT && var_type_out == NC_INT) {
(void)nc_get_var_int(in_id, var_in_id, void_ptr);
(void)nc_put_var_int(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_INT64 && var_type_out == NC_INT64) {
(void)nc_get_var_longlong(in_id, var_in_id, void_ptr);
(void)nc_put_var_longlong(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_FLOAT) {
(void)nc_get_var_float(in_id, var_in_id, void_ptr);
(void)nc_put_var_float(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_DOUBLE) {
(void)nc_get_var_double(in_id, var_in_id, void_ptr);
(void)nc_put_var_double(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_CHAR) {
(void)nc_get_var_text(in_id, var_in_id, void_ptr);
(void)nc_put_var_text(out_id, var_out_id, void_ptr);
}
else {
assert(1==0);
}
} /* end if variable is an array */
/* Free the space that held the dimension IDs */
(void)free(dim_cnt);
(void)free(dim_id);
(void)free(dim_sz);
(void)free(dim_srt);
/* Free the space that held the variable */
(void)free(void_ptr);
return(EX_NOERR);
} /* end cpy_var_val() */
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_cmap_params_cc(int exoid,
void_int *node_cmap_ids,
void_int *node_cmap_node_cnts,
void_int *node_proc_ptrs,
void_int *elem_cmap_ids,
void_int *elem_cmap_elem_cnts,
void_int *elem_proc_ptrs
)
{
const char *func_name="ex_put_cmap_params_cc";
size_t num_n_comm_maps, num_e_comm_maps, num_procs_in_file;
int status, icm, n_varid[2], e_varid[2], iproc;
int varid, n_dimid[1], e_dimid[1];
int n_varid_idx, e_varid_idx;
int num_icm;
size_t start[1], count[1];
size_t ecnt_cmap, ncnt_cmap;
long long nl_ecnt_cmap, nl_ncnt_cmap;
void_int *n_var_idx = NULL;
void_int *e_var_idx = NULL;
int nmstat;
char errmsg[MAX_ERR_LENGTH];
int format;
int index_type, bulk_type;
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/* See if using NC_FORMAT_NETCDF4 format... */
nc_inq_format(exoid, &format);
if ((ex_int64_status(exoid) & EX_BULK_INT64_DB) || (format == NC_FORMAT_NETCDF4)) {
index_type = NC_INT64;
} else {
index_type = NC_INT;
}
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
bulk_type = NC_INT64;
} else {
bulk_type = NC_INT;
}
/* Get the number of processors in the file */
if ((status = nc_inq_dimid(exoid, DIM_NUM_PROCS_F, &n_dimid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get dimension ID for \"%s\" in file ID %d",
DIM_NUM_PROCS_F, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, n_dimid[0], &num_procs_in_file)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_PROCS_F, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/*
* since I cannot get variables while in define mode, I need to
* get the cmap information index variables before I go into
* define mode
*/
/* Check to see if there are nodal communications maps in the file */
if (nc_inq_dimid(exoid, DIM_NUM_N_CMAPS, &n_dimid[0]) != NC_NOERR) {
num_n_comm_maps = 0;
}
else {
if ((status = nc_inq_dimlen(exoid, n_dimid[0], &num_n_comm_maps)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in \
file ID %d",
DIM_NUM_N_CMAPS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
if (num_n_comm_maps > 0) {
/* Get the variable ID for the comm map index vector */
if ((status = nc_inq_varid(exoid, VAR_N_COMM_INFO_IDX, &n_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_N_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* allocate space for the index variable */
if (index_type == NC_INT64) {
n_var_idx = malloc((num_procs_in_file + 1) * sizeof(long long));
} else {
n_var_idx = malloc((num_procs_in_file + 1) * sizeof(int));
}
if (!n_var_idx) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: insufficient memory to read index variable from file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* and set the last value of the index */
/* get the communication map info index */
if (index_type == NC_INT64) {
((long long*)n_var_idx)[0] = 0;
status = nc_get_var_longlong(exoid, n_varid_idx, &((long long*)n_var_idx)[1]);
} else {
((int*)n_var_idx)[0] = 0;
status = nc_get_var_int(exoid, n_varid_idx, &((int*)n_var_idx)[1]);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_N_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* "if (num_n_comm_maps > 0)" */
/* Check to see if there are elemental communications maps in the file */
if ((status = nc_inq_dimid(exoid, DIM_NUM_E_CMAPS, &e_dimid[0])) != NC_NOERR) {
num_e_comm_maps = 0;
}
else {
if ((status = nc_inq_dimlen(exoid, e_dimid[0], &num_e_comm_maps)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in \
file ID %d",
DIM_NUM_E_CMAPS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
if (num_e_comm_maps > 0) {
/* Get the variable ID for the comm map index vector */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_INFO_IDX, &e_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* allocate space for the index variable */
if (index_type == NC_INT64) {
e_var_idx = malloc((num_procs_in_file + 1) * sizeof(long long));
} else {
e_var_idx = malloc((num_procs_in_file + 1) * sizeof(int));
}
if (!e_var_idx) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: insufficient memory to read index variable from file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* get the communication map info index */
if (index_type == NC_INT64) {
((long long*)e_var_idx)[0] = 0;
status = nc_get_var_longlong(exoid, e_varid_idx, &((long long*)e_var_idx)[1]);
} else {
((int*)e_var_idx)[0] = 0;
status = nc_get_var_int(exoid, e_varid_idx, &((int*)e_var_idx)[1]);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get variable \"%s\" from file ID %d",
VAR_E_COMM_INFO_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* "if (num_e_comm_maps >0)" */
/* Put NetCDF file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file ID %d into define mode", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/*
* Add dimensions for the size of the number of nodal
* communication maps.
*/
if (num_n_comm_maps > 0) {
/* add the communications data index variable */
if ((status = nc_def_var(exoid, VAR_N_COMM_DATA_IDX, index_type, 1,
n_dimid, &n_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* now add up all of the nodal communications maps */
ncnt_cmap = 0;
for(iproc=0; iproc < num_procs_in_file; iproc++) {
if (index_type == NC_INT64) {
num_icm = ((int64_t*)n_var_idx)[iproc+1] - ((int64_t*)n_var_idx)[iproc];
} else {
num_icm = ((int*)n_var_idx)[iproc+1] - ((int*)n_var_idx)[iproc];
}
for(icm=0; icm < num_icm; icm++) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
ncnt_cmap += ((int64_t*)node_cmap_node_cnts)[((int64_t*)node_proc_ptrs)[iproc]+icm];
} else {
ncnt_cmap += ((int*)node_cmap_node_cnts)[((int*)node_proc_ptrs)[iproc]+icm];
}
}
}
if ((status = nc_def_dim(exoid, DIM_NCNT_CMAP, ncnt_cmap, &n_dimid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add dimension for \"%s\" of size %"ST_ZU" in file ID %d",
DIM_NCNT_CMAP, ncnt_cmap, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* Define variables for the nodal IDS and processor vectors */
if ((status = nc_def_var(exoid, VAR_N_COMM_NIDS, bulk_type, 1, n_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_NIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_N_COMM_PROC, NC_INT, 1, n_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_PROC, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
} /* End "if (num_n_comm_maps > 0)" */
/*
* Add dimensions for the size of the number of elemental
* communication maps.
*/
if (num_e_comm_maps > 0) {
/* add the communications data index variable */
if ((status = nc_def_var(exoid, VAR_E_COMM_DATA_IDX, index_type, 1,
e_dimid, &e_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* now add up all of the nodal communications maps */
ecnt_cmap = 0;
for(iproc=0; iproc < num_procs_in_file; iproc++) {
if (index_type == NC_INT64) {
num_icm = ((int64_t*)e_var_idx)[iproc+1] - ((int64_t*)e_var_idx)[iproc];
} else {
num_icm = ((int*)e_var_idx)[iproc+1] - ((int*)e_var_idx)[iproc];
}
for(icm=0; icm < num_icm; icm++) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
ecnt_cmap += ((int64_t*)elem_cmap_elem_cnts)[((int64_t*)elem_proc_ptrs)[iproc]+icm];
} else {
ecnt_cmap += ((int*)elem_cmap_elem_cnts)[((int*)elem_proc_ptrs)[iproc]+icm];
}
}
}
/* Add dimensions for elemental communications maps */
if ((status = nc_def_dim(exoid, DIM_ECNT_CMAP, ecnt_cmap, &e_dimid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add dimension for \"%s\" in file ID %d",
DIM_ECNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* Define variables for the element IDS and processor vectors */
if ((status = nc_def_var(exoid, VAR_E_COMM_EIDS, bulk_type, 1, e_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_EIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_E_COMM_PROC, NC_INT, 1, e_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_PROC, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_E_COMM_SIDS, bulk_type, 1, e_dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_SIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
} /* End "if (num_e_comm_maps > 0)" */
/* Exit define mode */
ex_leavedef(exoid, func_name);
/* Set the status of the nodal communication maps */
if (num_n_comm_maps > 0) {
/* need to get the two "n_comm_*" variable ids */
if ((status = nc_inq_varid(exoid, VAR_N_COMM_STAT, &n_varid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_N_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the variable ID for the comm map IDs vector */
if ((status = nc_inq_varid(exoid, VAR_N_COMM_IDS, &n_varid[1])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_N_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* reset the index variable */
nl_ncnt_cmap = 0;
for(iproc=0; iproc < num_procs_in_file; iproc++) {
size_t proc_ptr;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
proc_ptr = ((int64_t*)node_proc_ptrs)[iproc];
} else {
proc_ptr = ((int*)node_proc_ptrs)[iproc];
}
if (index_type == NC_INT64) {
num_icm = ((int64_t*)n_var_idx)[iproc+1] - ((int64_t*)n_var_idx)[iproc];
} else {
num_icm = ((int*)n_var_idx)[iproc+1] - ((int*)n_var_idx)[iproc];
}
for(icm=0; icm < num_icm; icm++) {
size_t cnt;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
cnt = ((int64_t*)node_cmap_node_cnts)[proc_ptr+icm];
} else {
cnt = ((int*)node_cmap_node_cnts)[proc_ptr+icm];
}
if (index_type == NC_INT64) {
start[0] = ((int64_t*)n_var_idx)[iproc] + icm;
} else {
start[0] = ((int*)n_var_idx)[iproc] + icm;
}
if (cnt > 0) {
nmstat = 1;
} else {
nmstat = 0;
}
if ((status = nc_put_var1_int(exoid, n_varid[0], start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: unable to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* increment to the next starting position */
nl_ncnt_cmap += cnt;
/* fill the data index variable */
status = nc_put_var1_longlong(exoid, n_varid_idx, start, &nl_ncnt_cmap);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output int elem map index in file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "for(icm=0; icm < num_icm; icm++)" */
if (num_icm > 0) {
/* Output the nodal comm map IDs */
if (index_type == NC_INT64) {
start[0] = ((int64_t*)n_var_idx)[iproc];
} else {
start[0] = ((int*)n_var_idx)[iproc];
}
count[0] = num_icm;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_vara_longlong(exoid, n_varid[1], start, count,
&((long long*)node_cmap_ids)[proc_ptr]);
} else {
status = nc_put_vara_int(exoid, n_varid[1], start, count,
&((int*)node_cmap_ids)[proc_ptr]);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
} /* End "for(iproc=0; iproc < num_procs_in_file; iproc++)" */
/* free up memory for index */
free(n_var_idx);
} /* End "if (num_n_comm_maps > 0)" */
/* Set the status of the elemental communication maps */
if (num_e_comm_maps > 0) {
/* need to get the two "e_comm_*" variables" */
/* Get variable ID for elemental status vector */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_STAT, &e_varid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the variable ID for the elemental comm map IDs vector */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_IDS, &e_varid[1])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* reset the index variable */
nl_ecnt_cmap = 0;
for(iproc=0; iproc < num_procs_in_file; iproc++) {
size_t proc_ptr;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
proc_ptr = ((int64_t*)elem_proc_ptrs)[iproc];
} else {
proc_ptr = ((int*)elem_proc_ptrs)[iproc];
}
if (index_type == NC_INT64) {
num_icm = ((int64_t*)e_var_idx)[iproc+1] - ((int64_t*)e_var_idx)[iproc];
} else {
num_icm = ((int*)e_var_idx)[iproc+1] - ((int*)e_var_idx)[iproc];
}
for(icm=0; icm < num_icm; icm++) {
size_t cnt;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
cnt = ((int64_t*)elem_cmap_elem_cnts)[proc_ptr+icm];
} else {
cnt = ((int*)elem_cmap_elem_cnts)[proc_ptr+icm];
}
if (index_type == NC_INT64) {
start[0] = ((int64_t*)e_var_idx)[iproc] + icm;
} else {
start[0] = ((int*)e_var_idx)[iproc] + icm;
}
if (cnt > 0) {
nmstat = 1;
} else {
nmstat = 0;
}
if ((status = nc_put_var1_int(exoid, e_varid[0], start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: unable to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* increment to the next starting position */
nl_ecnt_cmap += cnt;
/* fill the data index variable */
status = nc_put_var1_longlong(exoid, e_varid_idx, start, &nl_ecnt_cmap);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output int elem map index in file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "for(icm=0; icm < num_icm; icm++)" */
if (num_icm > 0) {
/* Output the elemental comm map IDs */
if (index_type == NC_INT64) {
start[0] = ((int64_t*)e_var_idx)[iproc];
} else {
start[0] = ((int*)e_var_idx)[iproc];
}
count[0] = num_icm;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_vara_longlong(exoid, e_varid[1], start, count,
&((long long*)elem_cmap_ids)[proc_ptr]);
} else {
status = nc_put_vara_int(exoid, e_varid[1], start, count,
&((int*)elem_cmap_ids)[proc_ptr]);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
} /* End "for(iproc=0; iproc < num_procs_in_file; iproc++)" */
free(e_var_idx);
} /* End "if (num_e_comm_maps > 0)" */
return (EX_NOERR);
}
/*!
* 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_put_block_params( int exoid,
size_t block_count,
const struct ex_block *blocks)
{
size_t i;
int conn_int_type;
int status;
int arbitrary_polyhedra = 0; /* 1 if block is arbitrary 2d polyhedra type; 2 if 3d polyhedra */
int att_name_varid = -1;
int varid, dimid, dims[2], blk_id_ndx, blk_stat, strdim;
size_t start[2];
size_t num_blk;
int cur_num_blk, numblkdim, numattrdim;
int nnodperentdim = -1;
int nedgperentdim = -1;
int nfacperentdim = -1;
int connid;
int npeid;
char errmsg[MAX_ERR_LENGTH];
char entity_type1[5];
char entity_type2[5];
int* blocks_to_define = NULL;
const char* dnumblk = NULL;
const char* vblkids = NULL;
const char* vblksta = NULL;
const char* vnodcon = NULL;
const char* vnpecnt = NULL;
const char* vedgcon = NULL;
const char* vfaccon = NULL;
const char* vconn = NULL;
const char* vattnam = NULL;
const char* vblkatt = NULL;
const char* dneblk = NULL;
const char* dnape = NULL;
const char* dnnpe = NULL;
const char* dnepe = NULL;
const char* dnfpe = NULL;
exerrval = 0; /* clear error code */
blocks_to_define = malloc(block_count*sizeof(int));
for (i=0; i < block_count; i++) {
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
dnumblk = DIM_NUM_ED_BLK;
vblkids = VAR_ID_ED_BLK;
vblksta = VAR_STAT_ED_BLK;
break;
case EX_FACE_BLOCK:
dnumblk = DIM_NUM_FA_BLK;
vblkids = VAR_ID_FA_BLK;
vblksta = VAR_STAT_FA_BLK;
break;
case EX_ELEM_BLOCK:
dnumblk = DIM_NUM_EL_BLK;
vblkids = VAR_ID_EL_BLK;
vblksta = VAR_STAT_EL_BLK;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) specified for entry %d file id %d",
blocks[i].type, (int)i, exoid );
ex_err( "ex_put_block_params", errmsg, exerrval );
free(blocks_to_define);
return (EX_FATAL);
}
/* first check if any blocks of that type are specified */
if ((status = ex_get_dimension(exoid, dnumblk, ex_name_of_object(blocks[i].type),
&num_blk, &dimid, "ex_put_block_params")) != NC_NOERR) {
sprintf(errmsg,
"Error: No %ss defined in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return EX_FATAL;
}
/* Next: Make sure that there are not any duplicate block ids by
searching the vblkids array.
WARNING: This must be done outside of define mode because id_lkup accesses
the database to determine the position
*/
if ((status = nc_inq_varid(exoid, vblkids, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return EX_FATAL;
}
ex_id_lkup(exoid,blocks[i].type,blocks[i].id); /* Error value used, but don't need return value */
if (exerrval != EX_LOOKUPFAIL) { /* found the element block id */
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: %s id %"PRId64" already exists in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
/* Keep track of the total number of element blocks defined using a counter
stored in a linked list keyed by exoid.
NOTE: ex_get_file_item is a function that finds the number of element
blocks for a specific file and returns that value.
*/
cur_num_blk=ex_get_file_item(exoid, ex_get_counter_list(blocks[i].type));
if (cur_num_blk >= (int)num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: exceeded number of %ss (%d) defined in file id %d",
ex_name_of_object(blocks[i].type), (int)num_blk,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
/* NOTE: ex_inc_file_item is a function that finds the number of element
blocks for a specific file and returns that value incremented. */
cur_num_blk=ex_inc_file_item(exoid, ex_get_counter_list(blocks[i].type));
start[0] = cur_num_blk;
/* write out block id to previously defined id array variable*/
status = nc_put_var1_longlong(exoid, varid, start, (long long*)&blocks[i].id);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id to file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
blocks_to_define[i] = start[0]+1; /* element id index into vblkids array*/
if (blocks[i].num_entry == 0) /* Is this a NULL element block? */
blk_stat = 0; /* change element block status to NULL */
else
blk_stat = 1; /* change element block status to EX_EX_TRUE */
if ((status = nc_inq_varid (exoid, vblksta, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s status in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, start, &blk_stat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s id %"PRId64" status to file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
}
/* put netcdf file into define mode */
if ((status=nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to place file id %d into define mode",exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
free(blocks_to_define);
return (EX_FATAL);
}
for (i=0; i < block_count; i++) {
if (blocks[i].num_entry == 0) {/* Is this a NULL element block? */
continue;
}
blk_id_ndx = blocks_to_define[i];
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
dneblk = DIM_NUM_ED_IN_EBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_EBLK(blk_id_ndx);
vblkatt = VAR_EATTRIB(blk_id_ndx);
vattnam = VAR_NAME_EATTRIB(blk_id_ndx);
vnodcon = VAR_EBCONN(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_FACE_BLOCK:
dneblk = DIM_NUM_FA_IN_FBLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnepe = 0;
dnfpe = 0;
dnape = DIM_NUM_ATT_IN_FBLK(blk_id_ndx);
vblkatt = VAR_FATTRIB(blk_id_ndx);
vattnam = VAR_NAME_FATTRIB(blk_id_ndx);
vnodcon = VAR_FBCONN(blk_id_ndx);
vnpecnt = VAR_FBEPEC(blk_id_ndx);
vedgcon = 0;
vfaccon = 0;
break;
case EX_ELEM_BLOCK:
dneblk = DIM_NUM_EL_IN_BLK(blk_id_ndx);
dnnpe = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnepe = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnfpe = DIM_NUM_FAC_PER_EL(blk_id_ndx);
dnape = DIM_NUM_ATT_IN_BLK(blk_id_ndx);
vblkatt = VAR_ATTRIB(blk_id_ndx);
vattnam = VAR_NAME_ATTRIB(blk_id_ndx);
vnodcon = VAR_CONN(blk_id_ndx);
vnpecnt = VAR_EBEPEC(blk_id_ndx);
vedgcon = VAR_ECONN(blk_id_ndx);
vfaccon = VAR_FCONN(blk_id_ndx);
break;
default:
goto error_ret;
}
/* define some dimensions and variables*/
if ((status = nc_def_dim(exoid,dneblk,blocks[i].num_entry, &numblkdim )) != NC_NOERR) {
if (status == NC_ENAMEINUSE) { /* duplicate entry */
exerrval = status;
sprintf(errmsg,
"Error: %s %"PRId64" already defined in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of entities/block for %s %"PRId64" file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
}
goto error_ret; /* exit define mode and return */
}
if ( dnnpe && blocks[i].num_nodes_per_entry > 0) {
/* A nfaced block would not have any nodes defined... */
if ((status = nc_def_dim(exoid,dnnpe,blocks[i].num_nodes_per_entry, &nnodperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of nodes/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if (dnepe && blocks[i].num_edges_per_entry > 0 ) {
if ((status = nc_def_dim (exoid,dnepe,blocks[i].num_edges_per_entry, &nedgperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of edges/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( dnfpe && blocks[i].num_faces_per_entry > 0 ) {
if ((status = nc_def_dim(exoid,dnfpe,blocks[i].num_faces_per_entry, &nfacperentdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of faces/entity for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
/* element attribute array */
if (blocks[i].num_attribute > 0) {
if ((status = nc_def_dim(exoid, dnape, blocks[i].num_attribute, &numattrdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define number of attributes in %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
dims[0] = numblkdim;
dims[1] = numattrdim;
if ((status = nc_def_var(exoid, vblkatt, nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define attributes for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &strdim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get string length in file id %d",exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret;
}
/* Attribute names... */
dims[0] = numattrdim;
dims[1] = strdim;
if ((status = nc_def_var(exoid, vattnam, NC_CHAR, 2, dims, &att_name_varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s attribute name array in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
conn_int_type = NC_INT;
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
conn_int_type = NC_INT64;
}
/* See if storing an 'nsided' element block (arbitrary 2d polyhedra or super element) */
if (strlen(blocks[i].topology) >= 3) {
if ((blocks[i].topology[0] == 'n' || blocks[i].topology[0] == 'N') &&
(blocks[i].topology[1] == 's' || blocks[i].topology[1] == 'S') &&
(blocks[i].topology[2] == 'i' || blocks[i].topology[2] == 'I'))
arbitrary_polyhedra = 1;
else if ((blocks[i].topology[0] == 'n' || blocks[i].topology[0] == 'N') &&
(blocks[i].topology[1] == 'f' || blocks[i].topology[1] == 'F') &&
(blocks[i].topology[2] == 'a' || blocks[i].topology[2] == 'A'))
/* If a FACE_BLOCK, then we are dealing with the faces of the nfaced blocks[i]. */
arbitrary_polyhedra = blocks[i].type == EX_FACE_BLOCK ? 1 : 2;
}
/* element connectivity array */
if (arbitrary_polyhedra > 0) {
if (blocks[i].type != EX_FACE_BLOCK && blocks[i].type != EX_ELEM_BLOCK) {
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Bad block type (%d) for nsided/nfaced block in file id %d",
blocks[i].type, exoid );
ex_err( "ex_put_block_params", errmsg, exerrval );
goto error_ret;
}
if (arbitrary_polyhedra == 1) {
dims[0] = nnodperentdim;
vconn = vnodcon;
/* store entity types as attribute of npeid variable -- node/elem, node/face, face/elem*/
strcpy(entity_type1, "NODE");
if (blocks[i].type == EX_ELEM_BLOCK)
strcpy(entity_type2, "ELEM");
else
strcpy(entity_type2, "FACE");
} else if (arbitrary_polyhedra == 2) {
dims[0] = nfacperentdim;
vconn = vfaccon;
/* store entity types as attribute of npeid variable -- node/elem, node/face, face/elem*/
strcpy(entity_type1, "FACE");
strcpy(entity_type2, "ELEM");
}
if ((status = nc_def_var(exoid, vconn, conn_int_type, 1, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* element face-per-element or node-per-element count array */
dims[0] = numblkdim;
if ((status = nc_def_var(exoid, vnpecnt, conn_int_type, 1, dims, &npeid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create face- or node- per-entity count array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_put_att_text(exoid, npeid, "entity_type1", strlen(entity_type1)+1,
entity_type1)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store entity type attribute text for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_put_att_text(exoid, npeid, "entity_type2", strlen(entity_type2)+1,
entity_type2)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store entity type attribute text for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id, exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
} else {
/* "Normal" (non-polyhedra) element block type */
dims[0] = numblkdim;
dims[1] = nnodperentdim;
if ((status = nc_def_var(exoid, vnodcon, conn_int_type, 2, dims, &connid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, connid, 1);
}
/* store element type as attribute of connectivity variable */
if ((status = nc_put_att_text(exoid, connid, ATT_NAME_ELB, strlen(blocks[i].topology)+1,
blocks[i].topology)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store %s type name %s in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].topology,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
if (arbitrary_polyhedra == 0) {
if (vedgcon && blocks[i].num_edges_per_entry ) {
dims[0] = numblkdim;
dims[1] = nedgperentdim;
if ((status = nc_def_var(exoid, vedgcon, conn_int_type, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create edge connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
if ( vfaccon && blocks[i].num_faces_per_entry ) {
dims[0] = numblkdim;
dims[1] = nfacperentdim;
if ((status = nc_def_var(exoid, vfaccon, conn_int_type, 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to create face connectivity array for %s %"PRId64" in file id %d",
ex_name_of_object(blocks[i].type), blocks[i].id,exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
}
}
}
free(blocks_to_define);
/* leave define mode */
if ((exerrval=nc_enddef (exoid)) != NC_NOERR) {
sprintf(errmsg,
"Error: failed to complete %s definition in file id %d",
ex_name_of_object(blocks[i].type), exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i < block_count; i++) {
switch (blocks[i].type) {
case EX_EDGE_BLOCK:
vblkids = VAR_ID_ED_BLK;
break;
case EX_FACE_BLOCK:
vblkids = VAR_ID_FA_BLK;
break;
case EX_ELEM_BLOCK:
vblkids = VAR_ID_EL_BLK;
break;
default:
return (EX_FATAL); /* should have been handled earlier; quiet compiler here */
}
nc_inq_varid(exoid, vblkids, &att_name_varid);
if (blocks[i].num_attribute > 0 && att_name_varid >= 0) {
/* Output a dummy empty attribute name in case client code doesn't
write anything; avoids corruption in some cases.
*/
size_t count[2];
char *text = "";
size_t j;
count[0] = 1;
start[1] = 0;
count[1] = strlen(text)+1;
for (j = 0; j < blocks[i].num_attribute; j++) {
start[0] = j;
nc_put_vara_text(exoid, att_name_varid, start, count, text);
}
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
free(blocks_to_define);
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_block_params",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_put_cmap_params(int exoid,
void_int *node_cmap_ids,
void_int *node_cmap_node_cnts,
void_int *elem_cmap_ids,
void_int *elem_cmap_elem_cnts,
int64_t processor
)
{
const char *func_name="ex_put_cmap_params";
size_t num_n_comm_maps, num_e_comm_maps;
size_t ncnt_cmap, ecnt_cmap;
size_t icm;
int varid, dimid[1], n_varid, e_varid, status;
int n_varid_idx, e_varid_idx;
size_t start[1];
char ftype[2];
int64_t nl_ncnt_cmap, nl_ecnt_cmap;
int nmstat;
char errmsg[MAX_ERR_LENGTH];
int index_type = NC_INT;
int id_type = NC_INT;
int format;
nc_inq_format(exoid, &format);
if ((ex_int64_status(exoid) & EX_BULK_INT64_DB) || (format == NC_FORMAT_NETCDF4)) {
index_type = NC_INT64;
}
if (ex_int64_status(exoid) & EX_IDS_INT64_DB) {
id_type = NC_INT64;
}
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/*
** with the new database format, this function sould only
** be used for writing a parallel file
*/
/* Get the file type */
if (ex_get_file_type(exoid, ftype) != EX_NOERR) {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: failed to get file type from file ID %d\n",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* make sure that this is a parallel file */
if (ftype[0] != 'p') {
exerrval = EX_MSG;
sprintf(errmsg,
"Error: function for use with parallel files only, file ID %d\n",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Put NetCDF file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to file ID %d into define mode", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Check to see if there are nodal communications maps in the file */
if ((status = nc_inq_dimid(exoid, DIM_NUM_N_CMAPS, &dimid[0])) != NC_NOERR) {
num_n_comm_maps = 0;
}
else {
if ((status = nc_inq_dimlen(exoid, dimid[0], &num_n_comm_maps)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_N_CMAPS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
/*
* Add dimensions for the size of the number of nodal
* communication maps.
*/
if (num_n_comm_maps > 0) {
/* add the communications data index variable */
if ((status = nc_def_var(exoid, VAR_N_COMM_DATA_IDX, index_type, 1,
dimid, &n_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* Add dimensions for all of the nodal communication maps */
ncnt_cmap = 0;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
for(icm=0; icm < num_n_comm_maps; icm++) {
ncnt_cmap += ((int64_t*)node_cmap_node_cnts)[icm];
}
} else {
for(icm=0; icm < num_n_comm_maps; icm++) {
ncnt_cmap += ((int*)node_cmap_node_cnts)[icm];
}
}
if ((status = nc_def_dim(exoid, DIM_NCNT_CMAP, ncnt_cmap, &dimid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add dimension for \"%s\" in file ID %d",
DIM_NCNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* Define variables for the nodal IDS and processor vectors */
if ((status = nc_def_var(exoid, VAR_N_COMM_NIDS, id_type, 1, dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_NIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_N_COMM_PROC, NC_INT, 1, dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_N_COMM_PROC, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
} /* End "if (num_n_comm_maps > 0)" */
/* Check to see if there are elemental communications maps in the file */
if ((status = nc_inq_dimid(exoid, DIM_NUM_E_CMAPS, &dimid[0])) != NC_NOERR) {
num_e_comm_maps = 0;
}
else{
if ((status = nc_inq_dimlen(exoid, dimid[0], &num_e_comm_maps)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find length of dimension \"%s\" in file ID %d",
DIM_NUM_E_CMAPS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
/*
* Add dimensions for the size of the number of elemental
* communication maps.
*/
if (num_e_comm_maps > 0) {
/* add the communications data index variable */
if ((status = nc_def_var(exoid, VAR_E_COMM_DATA_IDX, index_type, 1,
dimid, &e_varid_idx)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_DATA_IDX, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* Add dimensions for each of the nodal communication maps */
ecnt_cmap = 0;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
for(icm=0; icm < num_e_comm_maps; icm++)
ecnt_cmap += ((int64_t*)elem_cmap_elem_cnts)[icm];
} else {
for(icm=0; icm < num_e_comm_maps; icm++)
ecnt_cmap += ((int*)elem_cmap_elem_cnts)[icm];
}
if ((status = nc_def_dim(exoid, DIM_ECNT_CMAP, ecnt_cmap, &dimid[0])) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add dimension for \"%s\" in file ID %d",
DIM_ECNT_CMAP, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
/* Define variables for the element IDS and processor vectors */
if ((status = nc_def_var(exoid, VAR_E_COMM_EIDS, id_type, 1, dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_EIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_E_COMM_PROC, NC_INT, 1, dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_PROC, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
if ((status = nc_def_var(exoid, VAR_E_COMM_SIDS, NC_INT, 1, dimid, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to add variable \"%s\" in file ID %d",
VAR_E_COMM_SIDS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
ex_compress_variable(exoid, varid, 1);
} /* End "if (num_e_comm_maps > 0)" */
/* Exit define mode */
ex_leavedef(exoid, func_name);
/* Set the status of the nodal communication maps */
if (num_n_comm_maps > 0) {
if ((status = nc_inq_varid(exoid, VAR_N_COMM_STAT, &n_varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_N_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
nl_ncnt_cmap = 0; /* reset this for index */
for(icm=0; icm < num_n_comm_maps; icm++) {
size_t ncnc;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
ncnc = ((int64_t*)node_cmap_node_cnts)[icm];
} else {
ncnc = ((int*)node_cmap_node_cnts)[icm];
}
start[0] = icm;
if (ncnc > 0)
nmstat = 1;
else
nmstat = 0;
if ((status = nc_put_var1_int(exoid, n_varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: unable to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* increment to the next starting position */
nl_ncnt_cmap += ncnc;
/* fill the cmap data index */
if ((status = nc_put_var1_longlong(exoid, n_varid_idx, start, (long long*)&nl_ncnt_cmap)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output int elem map index in file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "for(icm=0; icm < num_n_comm_maps; icm++)" */
/* Get the variable ID for the comm map IDs vector */
if ((status = nc_inq_varid(exoid, VAR_N_COMM_IDS, &n_varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_N_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the nodal comm map IDs */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, n_varid, node_cmap_ids);
} else {
status = nc_put_var_int(exoid, n_varid, node_cmap_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (num_n_comm_maps > 0)" */
/* Set the status of the elemental communication maps */
if (num_e_comm_maps > 0) {
/* Get variable ID for elemental status vector */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_STAT, &e_varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_STAT, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
nl_ecnt_cmap = 0; /* reset this for index */
for(icm=0; icm < num_e_comm_maps; icm++) {
size_t ecec;
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
ecec = ((int64_t*)elem_cmap_elem_cnts)[icm];
} else {
ecec = ((int*)elem_cmap_elem_cnts)[icm];
}
start[0] = icm;
if (ecec > 0)
nmstat = 1;
else
nmstat = 0;
if ((status = nc_put_var1_int(exoid, e_varid, start, &nmstat)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: unable to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* increment to the next starting position */
nl_ecnt_cmap += ecec;
/* fill the cmap data index */
if ((status = nc_put_var1_longlong(exoid, e_varid_idx, start, (long long*)&nl_ecnt_cmap)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output int elem map index in file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "for(icm=0; icm < num_e_comm_maps; icm++)" */
/* Get the variable ID for the elemental comm map IDs vector */
if ((status = nc_inq_varid(exoid, VAR_E_COMM_IDS, &e_varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to find variable ID for \"%s\" in file ID %d",
VAR_E_COMM_IDS, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Output the elemental comm map IDs */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_put_var_longlong(exoid, e_varid, elem_cmap_ids);
} else {
status = nc_put_var_int(exoid, e_varid, elem_cmap_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to output variable in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (num_e_comm_maps > 0)" */
return (EX_NOERR);
}