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);
}
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);
}
int ex_put_init_info(int exoid, int num_proc, int num_proc_in_f, char *ftype)
{
const char *func_name = "ex_put_init_info";
int dimid, varid;
int ltempsv;
int lftype;
int status;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/* Check the file type */
if (!ftype) {
exerrval = EX_MSG;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: NULL file type input for file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Set the file type */
if (ftype[0] == 'p' || ftype[0] == 'P') {
lftype = 0;
}
else if (ftype[0] == 's' || ftype[0] == 'S') {
lftype = 1;
}
else {
exerrval = EX_MSG;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unknown file type requested for file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Put file into define mode */
if ((status = nc_redef(exoid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file ID %d into define mode", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Define dimension for the number of processors */
if ((status = nc_inq_dimid(exoid, DIM_NUM_PROCS, &dimid)) != NC_NOERR) {
ltempsv = num_proc;
if ((status = nc_def_dim(exoid, DIM_NUM_PROCS, ltempsv, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to dimension \"%s\" in file ID %d",
DIM_NUM_PROCS, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
}
/* If this is a parallel file then the status vectors are size 1 */
if (nc_inq_dimid(exoid, DIM_NUM_PROCS_F, &dimid) != NC_NOERR) {
ltempsv = num_proc_in_f;
if ((status = nc_def_dim(exoid, DIM_NUM_PROCS_F, ltempsv, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to dimension \"%s\" in file ID %d",
DIM_NUM_PROCS_F, exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
}
/* Output the file type */
if (nc_inq_varid(exoid, VAR_FILE_TYPE, &varid) != NC_NOERR) {
if ((status = nc_def_var(exoid, VAR_FILE_TYPE, NC_INT, 0, NULL, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to define file type in file ID %d", exoid);
ex_err(func_name, errmsg, exerrval);
/* Leave define mode before returning */
ex_leavedef(exoid, func_name);
return (EX_FATAL);
}
if (ex_leavedef(exoid, func_name) != EX_NOERR) {
return (EX_FATAL);
}
if ((status = nc_put_var1_int(exoid, varid, NULL, &lftype)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unable to output file type variable in file ID %d",
exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
}
else {
if (ex_leavedef(exoid, func_name) != EX_NOERR) {
return (EX_FATAL);
}
}
return (EX_NOERR);
}
int ex_put_init_global(int exoid, int64_t num_nodes_g, int64_t num_elems_g, int64_t num_elem_blks_g,
int64_t num_node_sets_g, int64_t num_side_sets_g)
{
int varid, dimid, status;
char errmsg[MAX_ERR_LENGTH];
int int_type = NC_INT;
int id_type = NC_INT;
/*-----------------------------Execution begins-----------------------------*/
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
if (ex_int64_status(exoid) & EX_BULK_INT64_DB) {
int_type = NC_INT64;
}
if (ex_int64_status(exoid) & EX_IDS_INT64_DB) {
id_type = NC_INT64;
}
/* Put NetCDF 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);
}
/* Output the file version */
if ((status = ex_put_nemesis_version(exoid)) < 0) {
EX_FUNC_LEAVE(status);
}
/* Define dimension for number of global nodes */
if ((status = nc_def_dim(exoid, DIM_NUM_NODES_GLOBAL, num_nodes_g, &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to dimension \"%s\" in file ID %d",
DIM_NUM_NODES_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Define dimension for number of global elements */
if ((status = nc_def_dim(exoid, DIM_NUM_ELEMS_GLOBAL, num_elems_g, &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to dimension \"%s\" in file ID %d",
DIM_NUM_ELEMS_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/*
* Output the number of global element blocks. This is output as a
* dimension since the vector of global element block IDs is sized
* by this quantity.
*/
if ((status = nc_def_dim(exoid, DIM_NUM_ELBLK_GLOBAL, num_elem_blks_g, &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to dimension \"%s\" in file ID %d",
DIM_NUM_ELBLK_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Define the element block IDs variable. */
if ((status = nc_def_var(exoid, VAR_ELBLK_IDS_GLOBAL, id_type, 1, &dimid, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put variable definition for \"%s\" into file ID %d",
VAR_ELBLK_IDS_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Define the element block counts variable. */
if ((status = nc_def_var(exoid, VAR_ELBLK_CNT_GLOBAL, int_type, 1, &dimid, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put variable definition for \"%s\" into file ID %d",
VAR_ELBLK_CNT_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/*
* Output the number of global node sets. This is output as a
* dimension since the vector of global element block IDs is sized
* by this quantity.
*/
if (num_node_sets_g > 0) {
if ((status = nc_def_dim(exoid, DIM_NUM_NS_GLOBAL, num_node_sets_g, &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to dimension \"%s\" in file ID %d",
DIM_NUM_NS_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Define the variable for output of global node set IDs */
if ((status = nc_def_var(exoid, VAR_NS_IDS_GLOBAL, id_type, 1, &dimid, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put variable definition for \"%s\" into file ID %d",
VAR_NS_IDS_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Define variable for global node counts in each global node set */
if ((status = nc_def_var(exoid, VAR_NS_NODE_CNT_GLOBAL, int_type, 1, &dimid, &varid)) !=
NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put variable definition for \"%s\" into file ID %d",
VAR_NS_NODE_CNT_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/*
* Define variable for global dist. factor count in each global
* node set
*/
if ((status = nc_def_var(exoid, VAR_NS_DF_CNT_GLOBAL, int_type, 1, &dimid, &varid)) !=
NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put variable definition for \"%s\" into file ID %d",
VAR_NS_DF_CNT_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
} /* End "if (num_node_sets_g > 0)" */
/*
* Output the number of global side sets. This is output as a
* dimension since the vector of global element block IDs is sized
* by this quantity.
*/
if (num_side_sets_g > 0) {
if ((status = nc_def_dim(exoid, DIM_NUM_SS_GLOBAL, num_side_sets_g, &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to dimension \"%s\" in file id %d",
DIM_NUM_SS_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/* Define the variable for output of global side set IDs */
if ((status = nc_def_var(exoid, VAR_SS_IDS_GLOBAL, id_type, 1, &dimid, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put variable definition for \"%s\" into file id %d",
VAR_SS_IDS_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/*
* Define the variable for count of global number of sides in the
* global side sets.
*/
if ((status = nc_def_var(exoid, VAR_SS_SIDE_CNT_GLOBAL, int_type, 1, &dimid, &varid)) !=
NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put variable definition for \"%s\" into file id %d",
VAR_SS_SIDE_CNT_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
/*
* Define the variable for count of global dist. factors in the
* global side sets.
*/
if ((status = nc_def_var(exoid, VAR_SS_DF_CNT_GLOBAL, int_type, 1, &dimid, &varid)) !=
NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to put variable definition for \"%s\" into file id %d",
VAR_SS_DF_CNT_GLOBAL, exoid);
ex_err(__func__, errmsg, status);
/* Leave define mode before returning */
ex_leavedef(exoid, __func__);
EX_FUNC_LEAVE(EX_FATAL);
}
} /* End "if (num_side_sets_g > 0)" */
/* End define mode */
if (ex_leavedef(exoid, __func__) != EX_NOERR) {
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}