int ex_get_map(int exoid, void_int *elem_map)
{
int numelemdim, mapid, status;
size_t num_elem, i;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* inquire id's of previously defined dimensions and variables */
/* See if file contains any elements...*/
if ((status = nc_inq_dimid(exoid, DIM_NUM_ELEM, &numelemdim)) != NC_NOERR) {
EX_FUNC_LEAVE(EX_NOERR);
}
if ((status = nc_inq_dimlen(exoid, numelemdim, &num_elem)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of elements in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (nc_inq_varid(exoid, VAR_MAP, &mapid) != NC_NOERR) {
/* generate default map of 1..n, where n is num_elem */
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
int64_t *lmap = (int64_t *)elem_map;
for (i = 0; i < num_elem; i++) {
lmap[i] = i + 1;
}
}
else {
int *lmap = (int *)elem_map;
for (i = 0; i < num_elem; i++) {
lmap[i] = i + 1;
}
}
EX_FUNC_LEAVE(EX_NOERR);
}
/* read in the element order map */
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_get_var_longlong(exoid, mapid, elem_map);
}
else {
status = nc_get_var_int(exoid, mapid, elem_map);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get element order map in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_get_coordinate_frames( int exoid,
int *nframes,
void_int *cf_ids,
void* pt_coordinates,
char* tags)
{
int status;
int dimid; /* ID of the dimension of # frames */
char errmsg[MAX_ERR_LENGTH];
int varids; /* variable id for the frame ids */
size_t start=0; /* start value for varputs */
size_t count=0; /* number vars to put in varput */
/* get the dimensions */
assert( nframes !=NULL );
status = nc_inq_dimid(exoid, DIM_NUM_CFRAMES, &dimid);
if (status != NC_NOERR){
*nframes=0;
return EX_NOERR;
}
(void)nc_inq_dimlen(exoid,dimid,&count);
*nframes=(int)count;
if ( count==0 )
return (EX_NOERR);
if ( cf_ids ) {
if ((status = nc_inq_varid(exoid,VAR_FRAME_IDS, &varids))!= NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to read number coordinate ids from file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid,varids,cf_ids);
} else {
status = nc_get_var_int(exoid,varids,cf_ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to read coordinate frame ids from file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
}
if ( tags )
if ( (status = nc_inq_varid(exoid,VAR_FRAME_TAGS,&varids))!= NC_NOERR ||
(nc_get_vara_text(exoid,varids,&start,&count,tags) != NC_NOERR)) {
exerrval = status;
sprintf(errmsg,
"Error: failed to read number coordinate tags from file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
if (pt_coordinates ){
if ( (status = nc_inq_varid(exoid,VAR_FRAME_COORDS,&varids))!= NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to read number coordinate tags from file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid,varids,pt_coordinates);
} else {
status = nc_get_var_double(exoid,varids,pt_coordinates);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to read number coordinate tags from file id %d",
exoid);
ex_err(PROCNAME,errmsg,exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
}
int ex_get_prop_array(int exoid, ex_entity_type obj_type, const char *prop_name, void_int *values)
{
int num_props, i, propid, status;
int found = EX_FALSE;
char *name;
char tmpstr[MAX_STR_LENGTH + 1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* open appropriate variable, depending on obj_type and prop_name */
num_props = ex_get_num_props(exoid, obj_type);
for (i = 1; i <= num_props; i++) {
switch (obj_type) {
case EX_ELEM_BLOCK: name = VAR_EB_PROP(i); break;
case EX_EDGE_BLOCK: name = VAR_ED_PROP(i); break;
case EX_FACE_BLOCK: name = VAR_FA_PROP(i); break;
case EX_NODE_SET: name = VAR_NS_PROP(i); break;
case EX_EDGE_SET: name = VAR_ES_PROP(i); break;
case EX_FACE_SET: name = VAR_FS_PROP(i); break;
case EX_ELEM_SET: name = VAR_ELS_PROP(i); break;
case EX_SIDE_SET: name = VAR_SS_PROP(i); break;
case EX_ELEM_MAP: name = VAR_EM_PROP(i); break;
case EX_FACE_MAP: name = VAR_FAM_PROP(i); break;
case EX_EDGE_MAP: name = VAR_EDM_PROP(i); break;
case EX_NODE_MAP: name = VAR_NM_PROP(i); break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: object type %d not supported; file id %d", obj_type,
exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate property array %s in file id %d",
name, exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
/* compare stored attribute name with passed property name */
memset(tmpstr, 0, MAX_STR_LENGTH + 1);
if ((status = nc_get_att_text(exoid, propid, ATT_PROP_NAME, tmpstr)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get property name in file id %d", exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
if (strcmp(tmpstr, prop_name) == 0) {
found = EX_TRUE;
break;
}
}
/* if property is not found, return warning */
if (!found) {
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: object type %d, property %s not defined in file id %d", obj_type, prop_name,
exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_WARN);
}
/* read num_obj values from property variable */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, propid, values);
}
else {
status = nc_get_var_int(exoid, propid, values);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to read values in %s property array in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_prop_array", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_id_lkup(int exoid, ex_entity_type id_type, ex_entity_id num)
{
char * id_table;
char * id_dim;
char * stat_table;
int varid, dimid;
size_t dim_len, i;
int64_t *id_vals = NULL;
int * stat_vals = NULL;
static int filled = EX_FALSE;
struct obj_stats *tmp_stats;
int status;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
switch (id_type) {
case EX_NODAL: return 0;
case EX_GLOBAL: return 0;
case EX_ELEM_BLOCK:
id_table = VAR_ID_EL_BLK; /* id array name */
id_dim = DIM_NUM_EL_BLK; /* id array dimension name*/
stat_table = VAR_STAT_EL_BLK; /* id status array name */
tmp_stats = ex_get_stat_ptr(exoid, &exoII_eb);
break;
case EX_NODE_SET:
id_table = VAR_NS_IDS;
id_dim = DIM_NUM_NS;
stat_table = VAR_NS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ns);
break;
case EX_SIDE_SET:
id_table = VAR_SS_IDS;
id_dim = DIM_NUM_SS;
stat_table = VAR_SS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ss);
break;
case EX_EDGE_BLOCK:
id_table = VAR_ID_ED_BLK;
id_dim = DIM_NUM_ED_BLK;
stat_table = VAR_STAT_ED_BLK;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_ed);
break;
case EX_FACE_BLOCK:
id_table = VAR_ID_FA_BLK;
id_dim = DIM_NUM_FA_BLK;
stat_table = VAR_STAT_FA_BLK;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fa);
break;
case EX_EDGE_SET:
id_table = VAR_ES_IDS;
id_dim = DIM_NUM_ES;
stat_table = VAR_ES_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_es);
break;
case EX_FACE_SET:
id_table = VAR_FS_IDS;
id_dim = DIM_NUM_FS;
stat_table = VAR_FS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fs);
break;
case EX_ELEM_SET:
id_table = VAR_ELS_IDS;
id_dim = DIM_NUM_ELS;
stat_table = VAR_ELS_STAT;
tmp_stats = ex_get_stat_ptr(exoid, &exoII_els);
break;
case EX_NODE_MAP:
id_table = VAR_NM_PROP(1);
id_dim = DIM_NUM_NM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_nm);
break;
case EX_EDGE_MAP:
id_table = VAR_EDM_PROP(1);
id_dim = DIM_NUM_EDM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_edm);
break;
case EX_FACE_MAP:
id_table = VAR_FAM_PROP(1);
id_dim = DIM_NUM_FAM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_fam);
break;
case EX_ELEM_MAP:
id_table = VAR_EM_PROP(1);
id_dim = DIM_NUM_EM;
stat_table = "";
tmp_stats = ex_get_stat_ptr(exoid, &exoII_em);
break;
default:
exerrval = EX_BADPARAM;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: unsupported id array type %d for file id %d", id_type,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if ((tmp_stats->id_vals == NULL) || (!(tmp_stats->valid_ids))) {
/* first time thru or id arrays haven't been completely filled yet */
/* get size of id array */
/* First get dimension id of id array */
if ((status = nc_inq_dimid(exoid, id_dim, &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate id array dimension in file id %d",
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* Next get value of dimension */
if ((status = nc_inq_dimlen(exoid, dimid, &dim_len)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s array length in file id %d",
id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* get variable id of id array */
if ((status = nc_inq_varid(exoid, id_table, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate %s array in file id %d", id_table,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
/* allocate space for id array and initialize to zero to ensure
that the higher bits don't contain garbage while copy from ints */
if (!(id_vals = calloc(dim_len, sizeof(int64_t)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate memory for %s array for file id %d", id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varid, (long long *)id_vals);
}
else {
int *id_vals_int;
if (!(id_vals_int = malloc(dim_len * sizeof(int)))) {
exerrval = EX_MEMFAIL;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to allocate memory for temporary array "
"id_vals_int for file id %d",
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
free(id_vals);
return (EX_FATAL);
}
status = nc_get_var_int(exoid, varid, (int *)id_vals_int);
if (status == NC_NOERR) {
for (i = 0; i < dim_len; i++) {
id_vals[i] = (int64_t)id_vals_int[i];
}
}
free(id_vals_int);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s array from file id %d", id_table,
exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
free(id_vals);
return (EX_FATAL);
}
/* check if values in stored arrays are filled with non-zeroes */
filled = EX_TRUE;
for (i = 0; i < dim_len; i++) {
if (id_vals[i] == EX_INVALID_ID || id_vals[i] == NC_FILL_INT) {
filled = EX_FALSE;
break; /* id array hasn't been completely filled with valid ids yet */
}
}
if (filled) {
tmp_stats->valid_ids = EX_TRUE;
tmp_stats->num = dim_len;
tmp_stats->id_vals = id_vals;
}
}
else {
id_vals = tmp_stats->id_vals;
dim_len = tmp_stats->num;
}
/* Do a linear search through the id array to find the array value
corresponding to the passed index number */
for (i = 0; i < dim_len; i++) {
if (id_vals[i] == num) {
break; /* found the id requested */
}
}
if (i >= dim_len) /* failed to find id number */
{
if (!(tmp_stats->valid_ids)) {
free(id_vals);
}
exerrval = EX_LOOKUPFAIL;
return (EX_LOOKUPFAIL); /*if we got here, the id array value doesn't exist */
}
/* Now check status array to see if object is null */
/* get variable id of status array */
if (nc_inq_varid(exoid, stat_table, &varid) == NC_NOERR) {
/* if status array exists, use it, otherwise assume object exists
to be backward compatible */
if ((tmp_stats->stat_vals == NULL) || (!(tmp_stats->valid_stat))) {
/* first time thru or status arrays haven't been filled yet */
/* allocate space for new status array */
if (!(stat_vals = malloc(dim_len * sizeof(int)))) {
exerrval = EX_MEMFAIL;
free(id_vals);
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to allocate memory for %s array for file id %d", id_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free(id_vals);
free(stat_vals);
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s array from file id %d",
stat_table, exoid);
ex_err("ex_id_lkup", errmsg, exerrval);
return (EX_FATAL);
}
if (tmp_stats->valid_ids) {
/* status array is valid only if ids are valid */
tmp_stats->valid_stat = EX_TRUE;
tmp_stats->stat_vals = stat_vals;
}
}
else {
stat_vals = tmp_stats->stat_vals;
}
if (stat_vals[i] == 0) /* is this object null? */ {
exerrval = EX_NULLENTITY;
if (!(tmp_stats->valid_stat)) {
free(stat_vals);
}
if (!(tmp_stats->valid_ids)) {
free(id_vals);
}
return (-((int)i + 1)); /* return index into id array (1-based) */
}
}
if (!(tmp_stats->valid_ids)) {
free(id_vals);
free(stat_vals);
}
return (i + 1); /* return index into id array (1-based) */
}
int ex_get_conn(int exoid, ex_entity_type blk_type, ex_entity_id blk_id, void_int *nodeconn,
void_int *edgeconn, void_int *faceconn)
{
int connid = -1;
int econnid = -1;
int fconnid = -1;
int blk_id_ndx, status;
int numnodperentdim = -1;
int numedgperentdim = -1;
int numfacperentdim = -1;
int iexit = (EX_NOERR); /* exit status */
size_t num_nodes_per_entry = 0;
size_t num_edges_per_entry = 0;
size_t num_faces_per_entry = 0;
char errmsg[MAX_ERR_LENGTH];
const char *dnumnodent = NULL;
const char *dnumedgent = NULL;
const char *dnumfacent = NULL;
const char *vnodeconn = NULL;
const char *vedgeconn = NULL;
const char *vfaceconn = NULL;
/* Should we warn if edgeconn or faceconn are non-NULL?
* No, fail silently so the same code can be used to read any type of block
* info.
* However, we will warn if edgeconn or faceconn are NULL but
* num_edges_per_entry
* or num_faces_per_entry (respectively) are positive.
*/
exerrval = 0; /* clear error code */
/* Locate index of element block id in VAR_ID_EL_BLK array */
blk_id_ndx = ex_id_lkup(exoid, blk_type, blk_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH,
"Warning: no connectivity array for NULL %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, EX_NULLENTITY);
return (EX_WARN); /* no connectivity array for this element block */
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s id %" PRId64 " in id array in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
switch (blk_type) {
case EX_EDGE_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_ED(blk_id_ndx);
dnumedgent = 0;
dnumfacent = 0;
vnodeconn = VAR_EBCONN(blk_id_ndx);
vedgeconn = 0;
vfaceconn = 0;
break;
case EX_FACE_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_FA(blk_id_ndx);
dnumedgent = 0;
dnumfacent = 0;
vnodeconn = VAR_FBCONN(blk_id_ndx);
vedgeconn = 0;
vfaceconn = 0;
break;
case EX_ELEM_BLOCK:
dnumnodent = DIM_NUM_NOD_PER_EL(blk_id_ndx);
dnumedgent = DIM_NUM_EDG_PER_EL(blk_id_ndx);
dnumfacent = DIM_NUM_FAC_PER_EL(blk_id_ndx);
vnodeconn = VAR_CONN(blk_id_ndx);
vedgeconn = VAR_ECONN(blk_id_ndx);
vfaceconn = VAR_FCONN(blk_id_ndx);
break;
default:
exerrval = 1005;
snprintf(errmsg, MAX_ERR_LENGTH,
"Internal ERROR: unrecognized block type in switch: %d in file id %d", blk_type,
exoid);
ex_err("ex_get_conn", errmsg, EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
num_nodes_per_entry = 0;
if (nodeconn && dnumnodent) {
if ((status = nc_inq_dimid(exoid, dnumnodent, &numnodperentdim)) != NC_NOERR) {
numnodperentdim = -1;
}
else {
if ((status = nc_inq_dimlen(exoid, numnodperentdim, &num_nodes_per_entry)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of nodes/entity for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
}
}
if (edgeconn && dnumedgent) {
num_edges_per_entry = 0;
if ((status = nc_inq_dimid(exoid, dnumedgent, &numedgperentdim)) != NC_NOERR) {
numedgperentdim = -1;
}
else {
if ((status = nc_inq_dimlen(exoid, numedgperentdim, &num_edges_per_entry)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of edges/entry for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
}
}
if (faceconn && dnumfacent) {
num_faces_per_entry = 0;
if ((status = nc_inq_dimid(exoid, dnumfacent, &numfacperentdim)) != NC_NOERR) {
numfacperentdim = -1;
}
else {
if ((status = nc_inq_dimlen(exoid, numfacperentdim, &num_faces_per_entry)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get number of faces/entry for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
}
}
status = 0;
if (nodeconn && (numnodperentdim >= 0) &&
((status = nc_inq_varid(exoid, vnodeconn, &connid)) != NC_NOERR)) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate node connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
status = 0;
if (edgeconn && (numedgperentdim >= 0) &&
((status = nc_inq_varid(exoid, vedgeconn, &econnid)) != NC_NOERR)) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate edge connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
if (faceconn && (numfacperentdim >= 0) &&
((status = nc_inq_varid(exoid, vfaceconn, &fconnid)) != NC_NOERR)) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate face connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
/* read in the connectivity array */
if (edgeconn && num_edges_per_entry > 0) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, econnid, edgeconn);
}
else {
status = nc_get_var_int(exoid, econnid, edgeconn);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get edge connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
}
if (faceconn && num_faces_per_entry > 0) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, fconnid, faceconn);
}
else {
status = nc_get_var_int(exoid, fconnid, faceconn);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get face connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
}
if (nodeconn && num_nodes_per_entry > 0) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, connid, nodeconn);
}
else {
status = nc_get_var_int(exoid, connid, nodeconn);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get node connectivity array for %s %" PRId64 " in file id %d",
ex_name_of_object(blk_type), blk_id, exoid);
ex_err("ex_get_conn", errmsg, exerrval);
return (EX_FATAL);
}
}
return iexit;
}
int ex_get_ss_param_global(int exoid, void_int *global_ids, void_int *side_cnts, void_int *df_cnts)
{
const char *func_name = "ex_get_ss_param_global";
int varid, status;
char errmsg[MAX_ERR_LENGTH];
/*-----------------------------Execution begins-----------------------------*/
exerrval = 0; /* clear error code */
/* Get the variable ID for the vector of global side set IDs */
if ((status = nc_inq_varid(exoid, VAR_SS_IDS_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_SS_IDS_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the vector of side set IDs */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varid, global_ids);
}
else {
status = nc_get_var_int(exoid, varid, global_ids);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get variable \"%s\" from file ID %d",
VAR_SS_IDS_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the variable ID for the vector of global side set side count */
if (side_cnts != NULL) {
if ((status = nc_inq_varid(exoid, VAR_SS_SIDE_CNT_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_SS_SIDE_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the vector of side set side counts */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, varid, side_cnts);
}
else {
status = nc_get_var_int(exoid, varid, side_cnts);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get variable \"%s\" from file ID %d",
VAR_SS_SIDE_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (side_cnts != NULL)" */
/* Get the variable ID for the vector of global side set dist. fact count */
if (df_cnts != NULL) {
if ((status = nc_inq_varid(exoid, VAR_SS_DF_CNT_GLOBAL, &varid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to find variable ID for \"%s\" in file ID %d",
VAR_SS_DF_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/* Get the vector of side set dist. fact counts */
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, varid, df_cnts);
}
else {
status = nc_get_var_int(exoid, varid, df_cnts);
}
if (status != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get variable \"%s\" from file ID %d",
VAR_SS_DF_CNT_GLOBAL, exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
} /* End "if (df_cnts != NULL)" */
return (EX_NOERR);
}
/*! \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
main(int argc, char **argv)
{
#ifdef USE_PARALLEL
MPI_Init(&argc, &argv);
#endif
int ncid, dimids[3];
int char_varid, byte_varid, ubyte_varid, short_varid, int_varid, float_varid, double_varid;
int ushort_varid, uint_varid, int64_varid, uint64_varid;
int i, j;
unsigned char ubyte_out[DIM1_LEN][DIM2_LEN] = {{1, 128, 255},{1, 128, 255}};
signed char byte_in[DIM1_LEN][DIM2_LEN], byte_out[DIM1_LEN][DIM2_LEN] = {{-127, 1, 127},{-127, 1, 127}};
unsigned short ushort_out[DIM1_LEN][DIM2_LEN] = {{110, 128, 255},{110, 128, 255}};
short short_in[DIM1_LEN][DIM2_LEN], short_out[DIM1_LEN][DIM2_LEN] = {{-110, -128, 255},{-110, -128, 255}};
int int_in[DIM1_LEN][DIM2_LEN], int_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
float float_in[DIM1_LEN][DIM2_LEN], float_out[DIM1_LEN][DIM2_LEN] = {{-.1, 9999.99, 100.001},{-.1, 9999.99, 100.001}};
double double_in[DIM1_LEN][DIM2_LEN], double_out[DIM1_LEN][DIM2_LEN] = {{0.02, .1128, 1090.1},{0.02, .1128, 1090.1}};
unsigned int uint_in[DIM1_LEN][DIM2_LEN], uint_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
long long int64_in[DIM1_LEN][DIM2_LEN], int64_out[DIM1_LEN][DIM2_LEN] = {{-111, 777, 100},{-111, 777, 100}};
unsigned long long uint64_in[DIM1_LEN][DIM2_LEN];
unsigned long long uint64_out[DIM1_LEN][DIM2_LEN] = {{0, 10101, 9999999},{0, 10101, 9999999}};
char char_out[DIM1_LEN][DIM2_LEN][DIM3_LEN] = {{"lalala", "lololo", "lelele"}, {"lalala", "lololo", "lelele"}};
/*nc_set_log_level(4);*/
printf("\n*** Testing netcdf-4 variable functions.\n");
printf("*** testing netcdf-4 varids inq on netcdf-3 file...");
{
int nvars_in, varids_in[2];
/* Create a netcdf-3 file with one dim and two vars. */
if (nc_create(FILE_NAME, 0, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and make sure nc_inq_varids yeilds correct
* result. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing simple variables...");
{
/* Create a file with a variable of each type. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR;
if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR;
if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR;
if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR;
if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR;
if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR;
if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR;
if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR;
if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR;
if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR;
if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR;
if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR;
if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR;
if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR;
if (nc_put_var_ubyte(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR;
if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR;
if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR;
if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR;
if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check metadata. */
{
nc_type xtype_in;
int ndims_in, dimids_in[10], natts_in, varid_in;
char name_in[NC_MAX_NAME+1];
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE ||
ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
dimids_in[1] != dimids[1]) ERR;
if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR;
if (varid_in != 1) ERR;
if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR;
if (varid_in != 2) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME)) ERR;
if (nc_inq_varname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, VAR_CHAR_NAME)) ERR;
if (nc_inq_varname(ncid, 2, name_in)) ERR;
if (strcmp(name_in, VAR_SHORT_NAME)) ERR;
if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
if (xtype_in != NC_BYTE) ERR;
if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
if (xtype_in != NC_CHAR) ERR;
if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
if (xtype_in != NC_SHORT) ERR;
if (nc_close(ncid)) ERR;
}
/* Open the file and check data. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != byte_out[i][j]) ERR;
if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (short_in[i][j] != short_out[i][j]) ERR;
if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int_in[i][j] != int_out[i][j]) ERR;
if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (float_in[i][j] != float_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint_in[i][j] != uint_out[i][j]) ERR;
if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int64_in[i][j] != int64_out[i][j]) ERR;
if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint64_in[i][j] != uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as double. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)byte_out[i][j]) ERR;
if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)short_out[i][j]) ERR;
if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint_out[i][j]) ERR;
if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)float_out[i][j]) ERR;
if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int64_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as NC_BYTE. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define DEFLATE_LEVEL_4 4
printf("*** testing simple variables with deflation...");
{
/* Create a file with a variable of each type. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var_deflate(ncid, byte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_def_var_deflate(ncid, byte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR;
if (nc_def_var_deflate(ncid, short_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR;
if (nc_def_var_deflate(ncid, int_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR;
if (nc_def_var_deflate(ncid, float_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR;
if (nc_def_var_deflate(ncid, double_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
if (nc_def_var_deflate(ncid, ubyte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR;
if (nc_def_var_deflate(ncid, ushort_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR;
if (nc_def_var_deflate(ncid, uint_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR;
if (nc_def_var_deflate(ncid, int64_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR;
if (nc_def_var_deflate(ncid, uint64_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR;
if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR;
if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR;
if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR;
if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR;
if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR;
if (nc_put_var_ubyte(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR;
if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR;
if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR;
if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR;
if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check metadata. */
{
nc_type xtype_in;
int ndims_in, dimids_in[10], natts_in, varid_in;
char name_in[NC_MAX_NAME+1];
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE ||
ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
dimids_in[1] != dimids[1]) ERR;
if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR;
if (varid_in != 1) ERR;
if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR;
if (varid_in != 2) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME)) ERR;
if (nc_inq_varname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, VAR_CHAR_NAME)) ERR;
if (nc_inq_varname(ncid, 2, name_in)) ERR;
if (strcmp(name_in, VAR_SHORT_NAME)) ERR;
if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
if (xtype_in != NC_BYTE) ERR;
if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
if (xtype_in != NC_CHAR) ERR;
if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
if (xtype_in != NC_SHORT) ERR;
if (nc_close(ncid)) ERR;
}
/* Open the file and check data. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != byte_out[i][j]) ERR;
if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (short_in[i][j] != short_out[i][j]) ERR;
if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int_in[i][j] != int_out[i][j]) ERR;
if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (float_in[i][j] != float_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint_in[i][j] != uint_out[i][j]) ERR;
if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int64_in[i][j] != int64_out[i][j]) ERR;
if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint64_in[i][j] != uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as double. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)byte_out[i][j]) ERR;
if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)short_out[i][j]) ERR;
if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint_out[i][j]) ERR;
if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)float_out[i][j]) ERR;
if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int64_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as NC_BYTE. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NDIMS4 1
#define NVARS4 1
#define DIM4_NAME "treaty_of_paris_1783"
#define DIM4_LEN 5
#define VAR_NAME4 "John_Adams"
#define DEFLATE_LEVEL 6
printf("*** testing netcdf-4 simple variable define...");
{
int dimids[NDIMS4], dimids_in[NDIMS4];
int varid, varids_in[NVARS4];
int ndims, nvars, natts, unlimdimid;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level;
/* Create a netcdf-4 file with one dim and one var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM4_NAME, DIM4_LEN, &dimids[0])) ERR;
if (dimids[0] != 0) ERR;
if (nc_def_var(ncid, VAR_NAME4, NC_INT64, NDIMS4, dimids, &varid)) ERR;
if (nc_def_var_deflate(ncid, varid, 0, 1, DEFLATE_LEVEL)) ERR;
if (varid != 0) ERR;
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS4) ERR;
if (varids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level)) ERR;
if (shuffle_in ||!deflate_in ||
deflate_level != DEFLATE_LEVEL) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS4) ERR;
if (varids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level)) ERR;
if (shuffle_in ||!deflate_in ||
deflate_level != DEFLATE_LEVEL) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NDIMS5 1
#define NVARS5 5
#define DIM5_NAME "treaty_of_paris_1783"
#define DIM5_LEN 5
printf("*** testing netcdf-4 less simple variable define...");
{
int dimids[NDIMS5], dimids_in[NDIMS5];
int varid[NVARS5], varids_in[NVARS5];
int ndims, nvars, natts, unlimdimid;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
char var_name[NVARS5][NC_MAX_NAME + 1] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
"Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
"Charles_F_Ritchel"};
int shuffle_in, deflate_in, deflate_level_in;
int deflate_level[NVARS5];
int i;
/* Set up options for this var. */
for (i = 0; i < NVARS5; i++)
deflate_level[i] = i;
/* Create a netcdf-4 file with one dim and two vars. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM5_NAME, DIM5_LEN, &dimids[0])) ERR;
if (dimids[0] != 0) ERR;
for (i = 0; i < NVARS5; i++)
{
if (nc_def_var(ncid, var_name[i], NC_INT64, NDIMS5, dimids,
&varid[i])) ERR;
if (varid[i] != i) ERR;
if (nc_def_var_deflate(ncid, varid[i], 1, 1, deflate_level[i])) ERR;
}
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS5) ERR;
for (i = 0; i < NVARS5; i++)
{
if (varids_in[i] != i) ERR;
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (!shuffle_in || !deflate_in ||
deflate_level_in != deflate_level[i]) ERR;
}
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS5) ERR;
for (i = 0; i < NVARS5; i++)
{
if (varids_in[i] != i) ERR;
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (!shuffle_in || !deflate_in ||
deflate_level_in != deflate_level[i]) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NVARS 5
#define NDIMS 1
#define DIM6_NAME "airship_cross_sectional_area"
#define DIM6_LEN 100
#define TEN_K_M2 10000.0
#define INCREMENT 1000.0
printf("*** testing more complex netcdf-4 variable defines...");
{
int dimids[NDIMS], dimids_in[NDIMS];
int varid[NVARS], varids_in[NVARS];
int ndims, nvars, natts, unlimdimid;
char var_name[NVARS][50] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
"Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
"Charles_F_Ritchel"};
double data[DIM6_LEN];
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level_in;
int fletcher32_in;
int i;
/* Create some phoney data. */
for (i = 1, data[0] = TEN_K_M2; i < DIM6_LEN; i++)
data[i] = data[i - 1] + INCREMENT;
/* Create a netcdf-4 file with one dim and 5 NC_DOUBLE vars. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM6_NAME, DIM6_LEN, &dimids[0])) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_def_var(ncid, var_name[i], NC_DOUBLE, NDIMS, dimids,
&varid[i])) ERR;
if (nc_def_var_deflate(ncid, varid[i], 0, 1, 0)) ERR;
if (nc_def_var_fletcher32(ncid, varid[i], 1)) ERR;
}
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS) ERR;
for (i = 0; i < NVARS; i++)
if (varids_in[i] != i) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || !deflate_in || deflate_level_in != 0) ERR;
if (nc_inq_var_fletcher32(ncid, varid[i], &fletcher32_in)) ERR;
if (!fletcher32_in) ERR;
}
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS) ERR;
for (i = 0; i < NVARS; i++)
if (varids_in[i] != i) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || !deflate_in ||
deflate_level_in != 0) ERR;
if (nc_inq_var_fletcher32(ncid, varid[i], &fletcher32_in)) ERR;
if (!fletcher32_in) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define DIM7_LEN 2
#define DIM7_NAME "dim_7_from_Indiana"
#define VAR7_NAME "var_7_from_Idaho"
#define NDIMS 1
printf("*** testing fill values...");
{
int dimids[NDIMS], dimids_in[NDIMS];
size_t index[NDIMS];
int varid, ndims, natts;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level_in;
int fletcher32_in, no_fill;
unsigned short ushort_data = 42, ushort_data_in, fill_value_in;
/* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR;
if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids,
&varid)) ERR;
/* Check stuff. */
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || deflate_in) ERR;
if (nc_inq_var_fletcher32(ncid, 0, &fletcher32_in)) ERR;
if (fletcher32_in) ERR;
if (nc_inq_var_fill(ncid, 0, &no_fill, &fill_value_in)) ERR;
if (no_fill || fill_value_in != NC_FILL_USHORT) ERR;
/* Write the second of two values. */
index[0] = 1;
if (nc_put_var1_ushort(ncid, 0, index, &ushort_data)) ERR;
/* Get the first value, and make sure we get the default fill
* value for USHORT. */
index[0] = 0;
if (nc_get_var1_ushort(ncid, 0, index, &ushort_data_in)) ERR;
if (ushort_data_in != NC_FILL_USHORT) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check stuff. */
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || deflate_in) ERR;
if (nc_inq_var_fletcher32(ncid, 0, &fletcher32_in)) ERR;
if (fletcher32_in) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing more fill values...");
{
int dimids[NDIMS];
size_t index[NDIMS];
int varid;
int no_fill;
unsigned short ushort_data = 42, ushort_data_in, fill_value_in;
/* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR;
if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids,
&varid)) ERR;
if (nc_def_var_fill(ncid, varid, 1, NULL)) ERR;
/* Check stuff. */
if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
if (!no_fill) ERR;
/* Write the second of two values. */
index[0] = 1;
if (nc_put_var1_ushort(ncid, varid, index, &ushort_data)) ERR;
/* Get the first value, and make sure we get the default fill
* value for USHORT. */
index[0] = 0;
if (nc_get_var1_ushort(ncid, varid, index, &ushort_data_in)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check stuff. */
if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
if (!no_fill) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing lots of variables...");
#define DIM_A_NAME "x"
#define DIM_A_LEN 10
#define NUM_VARS 2000
#define MAX_VARNAME 10
{
/* This simple test failed on HDF5 1.7.58, but passes just fine
* on 1.8.0 alpha5... */
int ncid, dimids[1], i;
char varname[MAX_VARNAME];
int varids[NUM_VARS];
/* Create a file with three dimensions. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_A_NAME, DIM_A_LEN, &dimids[0])) ERR;
/* Create a large number of variables. */
for (i = 0; i < NUM_VARS; i++)
{
sprintf(varname, "a_%d", i);
if (nc_def_var(ncid, varname, NC_FLOAT, 1, dimids, &varids[i])) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NC3_CLASSIC_FILE "tst_pres_temp_4D_classic.nc"
#define NC3_64BIT_OFFSET_FILE "tst_pres_temp_4D_64bit_offset.nc"
#define NC3_NETCDF4_FILE "tst_pres_temp_4D_netcdf4.nc"
#define NC3_NETCDF4_CLASSIC_FILE "tst_pres_temp_4D_netcdf4_classic.nc"
printf("*** testing 4D example file in classic format...");
if (create_4D_example(NC3_CLASSIC_FILE, NC_CLOBBER)) ERR;
if (check_4D_example(NC3_CLASSIC_FILE, NC_FORMAT_CLASSIC)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in 64-bit offset format...");
if (create_4D_example(NC3_64BIT_OFFSET_FILE, NC_CLOBBER|NC_64BIT_OFFSET)) ERR;
if (check_4D_example(NC3_64BIT_OFFSET_FILE, NC_FORMAT_64BIT)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in netCDF-4/HDF5 format...");
if (create_4D_example(NC3_NETCDF4_FILE, NC_CLOBBER|NC_NETCDF4)) ERR;
if (check_4D_example(NC3_NETCDF4_FILE, NC_FORMAT_NETCDF4)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in netCDF-4/HDF5 format with classic model rules...");
if (create_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL)) ERR;
if (check_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_FORMAT_NETCDF4_CLASSIC)) ERR;
SUMMARIZE_ERR;
FINAL_RESULTS;
#ifdef USE_PARALLEL
MPI_Finalize();
#endif
}
int main(int argc, char **argv) {
if(argc < 4) {
printf("Usage: nc32bin varname nc3file binfile\n");
exit(1);
}
int status, i, ndims;
int ncfile_id, ncvar_id;
int dimids[DIM_LEN];
size_t size, nelmts, buflen;
size_t dimlens[DIM_LEN];
nc_type vartype;
void *buf = NULL;
/*
* read nc file
*/
status = nc_open(argv[2], NC_NOWRITE, &ncfile_id);
NC_ASSERT(status);
status = nc_inq_varid(ncfile_id, argv[1], &ncvar_id);
NC_ASSERT(status);
nc_inq_varndims(ncfile_id, ncvar_id, &ndims);
nc_inq_vartype(ncfile_id, ncvar_id, &vartype);
nc_inq_vardimid(ncfile_id, ncvar_id, dimids);
for(i = 0; i < ndims; i++)
nc_inq_dimlen(ncfile_id, dimids[i], &(dimlens[i]));
size = get_type_size(vartype);
nelmts = 1;
for(i = 0; i < ndims; i++)
nelmts *= dimlens[i];
buflen = size * nelmts;
buf = malloc(buflen);
MEMORY_CHECK(buf);
if(NC_SHORT == vartype)
status = nc_get_var_short(ncfile_id, ncvar_id, (short *)buf);
else if(NC_USHORT == vartype)
status = nc_get_var_ushort(ncfile_id, ncvar_id, (unsigned short *)buf);
else if(NC_INT == vartype)
status = nc_get_var_int(ncfile_id, ncvar_id, (int *)buf);
else if(NC_UINT == vartype)
status = nc_get_var_uint(ncfile_id, ncvar_id, (unsigned int *)buf);
else if(NC_INT64 == vartype)
status = nc_get_var_longlong(ncfile_id, ncvar_id, (long long *)buf);
else if(NC_UINT64 == vartype)
status = nc_get_var_ulonglong(ncfile_id, ncvar_id, (unsigned long long *)buf);
else if(NC_FLOAT == vartype)
status = nc_get_var_float(ncfile_id, ncvar_id, (float *)buf);
else if(NC_DOUBLE == vartype)
status = nc_get_var_double(ncfile_id, ncvar_id, (double *)buf);
NC_ASSERT(status);
nc_close(ncfile_id);
/*
* write binary
*/
FILE *fp = NULL;
fp = fopen(argv[3], "wb");
assert(fp != NULL);
fwrite(buf, size, nelmts, fp);
fclose(fp);
return 0;
}
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
main(int argc, char **argv)
{
printf("\n*** Testing specified endiannesss fill values.\n");
printf("*** testing simple case with int...");
{
int ncid, varid, var2id, var3id;
int data_in;
int fill = NC_FILL_INT;
/* Create file with a scalar int var that's big-endian. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_var(ncid, VAR_NAME, NC_INT, VAR_RANK, 0, &varid)) ERR;
if (nc_def_var_endian(ncid, varid, NC_ENDIAN_BIG)) ERR;
if (nc_def_var(ncid, VAR2_NAME, NC_INT, VAR_RANK, 0, &var2id)) ERR;
if (nc_def_var_endian(ncid, var2id, NC_ENDIAN_LITTLE)) ERR;
/* close without writing data, so vars 1 and 2 should contain
* NC_FILL_INT */
if (nc_def_var(ncid, VAR3_NAME, NC_INT, VAR_RANK, 0, &var3id)) ERR;
if (nc_def_var_endian(ncid, var3id, NC_ENDIAN_BIG)) ERR;
if (nc_put_var(ncid, var3id, &fill)) ERR;
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_varid(ncid, VAR_NAME, &varid)) ERR;
if (nc_inq_varid(ncid, VAR2_NAME, &var2id)) ERR;
if (nc_get_var_int(ncid, varid, &data_in)) ERR;
if (data_in != NC_FILL_INT) ERR;
if (nc_get_var_int(ncid, var2id, &data_in)) ERR;
if (data_in != NC_FILL_INT) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing short, int, int64, and unsigned...");
{
#define NUM_TYPES_TO_CHECK 6
int ncid, varid[NUM_TYPES_TO_CHECK];
int check_type[NUM_TYPES_TO_CHECK] = {NC_SHORT, NC_USHORT, NC_INT,
NC_UINT, NC_INT64, NC_UINT64};
char var_name[NUM_TYPES_TO_CHECK][NC_MAX_NAME + 1] = {"SHORT", "USHORT",
"INT", "UINT", "INT64",
"UINT64"};
long long fill_value[NUM_TYPES_TO_CHECK] = {NC_FILL_SHORT, NC_FILL_USHORT, NC_FILL_INT,
NC_FILL_UINT, NC_FILL_INT64, NC_FILL_UINT64};
long long data_in;
int t;
/* Create file with a scalar vars. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
for (t = 0; t < NUM_TYPES_TO_CHECK; t++)
{
if (nc_def_var(ncid, var_name[t], check_type[t], 0, 0, &varid[t])) ERR;
if (nc_def_var_endian(ncid, varid[t], NC_ENDIAN_BIG)) ERR;
}
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
for (t = 0; t < NUM_TYPES_TO_CHECK; t++)
{
int err = nc_get_var_longlong(ncid, varid[t], &data_in);
if(err && err != NC_ERANGE)
ERR;
if (data_in != fill_value[t])
ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
return 0;
}
int
check_file(int format, unsigned char *uchar_out)
{
int ncid;
int ndims, natts;
int dimids_var[1], var_type;
char var_name[NC_MAX_NAME+1];
unsigned char uchar_in[DIM1_LEN];
signed char char_in[DIM1_LEN];
unsigned short ushort_in[DIM1_LEN];
short short_in[DIM1_LEN];
unsigned int uint_in[DIM1_LEN];
int int_in[DIM1_LEN];
long long int64_in[DIM1_LEN];
unsigned long long uint64_in[DIM1_LEN];
int i, res;
/* Read it back in, and check conversions. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_var(ncid, 0, var_name, &var_type, &ndims, dimids_var, &natts)) ERR;
if (strcmp(var_name, VAR1_NAME) || natts !=0 || ndims != 1 ||
dimids_var[0] != 0 || var_type != NC_BYTE) ERR;
/* This is actually an NC_BYTE, with some negatives, so this should
* generate a range error for netcdf-4, but not for netcdf-3,
* because range errors are not generated for byte type
* conversions. */
res = nc_get_var_uchar(ncid, 0, uchar_in);
if (format == NC_FORMAT_NETCDF4 || format == NC_FORMAT_64BIT_DATA)
{
if (res != NC_ERANGE) ERR;
}
else if (res) ERR;
for (i=0; i<DIM1_LEN; i++)
#ifdef ERANGE_FILL
if (uchar_in[i] != uchar_out[i] && uchar_in[i] != NC_FILL_UBYTE) ERR;
#else
if (uchar_in[i] != uchar_out[i]) ERR;
#endif
if (nc_get_var_schar(ncid, 0, char_in)) ERR;
for (i=0; i<DIM1_LEN; i++)
#ifdef ERANGE_FILL
if (char_in[i] != (signed char)uchar_out[i] && char_in[i] != NC_FILL_BYTE) ERR;
#else
if (char_in[i] != (signed char)uchar_out[i]) ERR;
#endif
if (nc_get_var_short(ncid, 0, short_in)) ERR;
for (i=0; i<DIM1_LEN; i++)
#ifdef ERANGE_FILL
if (short_in[i] != (signed char)uchar_out[i] && short_in[i] != NC_FILL_BYTE) ERR;
#else
if (short_in[i] != (signed char)uchar_out[i]) ERR;
#endif
if (nc_get_var_int(ncid, 0, int_in)) ERR;
for (i=0; i<DIM1_LEN; i++)
#ifdef ERANGE_FILL
if (int_in[i] != (signed char)uchar_out[i] && int_in[i] != NC_FILL_BYTE) ERR;
#else
if (int_in[i] != (signed char)uchar_out[i]) ERR;
#endif
if (format == NC_FORMAT_NETCDF4 || format == NC_FORMAT_NETCDF4_CLASSIC)
{
/* Since we wrote them as NC_BYTE, some of these are negative
* values, and will return a range error when reading into
* unsigned type. To compare values, first cast uchar_out to
* signed int, then cast again to the type we are reading it
* as. */
if (nc_get_var_ushort(ncid, 0, ushort_in) != NC_ERANGE) ERR;
for (i=0; i<DIM1_LEN; i++)
if (ushort_in[i] != (unsigned short)(signed char)uchar_out[i]) ERR;
if (nc_get_var_uint(ncid, 0, uint_in) != NC_ERANGE) ERR;
for (i=0; i<DIM1_LEN; i++)
if (uint_in[i] != (unsigned int)(signed char)uchar_out[i]) ERR;
if (nc_get_var_ulonglong(ncid, 0, uint64_in) != NC_ERANGE) ERR;
for (i=0; i<DIM1_LEN; i++)
if (uint64_in[i] != (unsigned long long)(signed char)uchar_out[i]) ERR;
if (nc_get_var_longlong(ncid, 0, int64_in)) ERR;
for (i=0; i<DIM1_LEN; i++)
if (int64_in[i] != (signed char)uchar_out[i]) ERR;
}
if (nc_close(ncid)) ERR;
return 0;
}
int ex_get_set(int exoid, ex_entity_type set_type, ex_entity_id set_id, void_int *set_entry_list,
void_int *set_extra_list) /* NULL if dont want to retrieve data */
{
int dimid, entry_list_id, extra_list_id, status;
int set_id_ndx;
char errmsg[MAX_ERR_LENGTH];
char *entryptr = NULL;
char *extraptr = NULL;
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no %ss stored in file id %d",
ex_name_of_object(set_type), exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_WARN);
}
/* Lookup index of set id in VAR_*S_IDS array */
set_id_ndx = ex_id_lkup(exoid, set_type, set_id);
if (set_id_ndx <= 0) {
ex_get_err(NULL, NULL, &status);
if (status != 0) {
if (status == EX_NULLENTITY) {
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: %s %" PRId64 " is NULL in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, EX_NULLENTITY);
EX_FUNC_LEAVE(EX_WARN);
}
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate %s id %" PRId64 " in VAR_*S_IDS array in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
entryptr = VAR_NODE_NS(set_id_ndx);
extraptr = NULL;
}
else if (set_type == EX_EDGE_SET) {
entryptr = VAR_EDGE_ES(set_id_ndx);
extraptr = VAR_ORNT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
entryptr = VAR_FACE_FS(set_id_ndx);
extraptr = VAR_ORNT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
entryptr = VAR_ELEM_SS(set_id_ndx);
extraptr = VAR_SIDE_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
entryptr = VAR_ELEM_ELS(set_id_ndx);
extraptr = NULL;
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, entryptr, &entry_list_id)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate entry list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* If client doet not pass in an array to store the
extra list, don't access it at all */
/* only do extra list for edge, face and side sets */
if (set_extra_list) {
if ((status = nc_inq_varid(exoid, extraptr, &extra_list_id)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate extra list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* read in the entry list and extra list arrays unless they are NULL */
if (set_entry_list) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, entry_list_id, set_entry_list);
}
else {
status = nc_get_var_int(exoid, entry_list_id, set_entry_list);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get entry list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
/* only do extra list for edge, face and side sets */
if (set_extra_list) {
if (ex_int64_status(exoid) & EX_BULK_INT64_API) {
status = nc_get_var_longlong(exoid, extra_list_id, set_extra_list);
}
else {
status = nc_get_var_int(exoid, extra_list_id, set_extra_list);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to get extra list for %s %" PRId64 " in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
EX_FUNC_LEAVE(EX_NOERR);
}
int ex_get_id_map ( int exoid,
ex_entity_type map_type,
void_int* map )
{
int dimid, mapid, status;
size_t i;
size_t num_entries;
char errmsg[MAX_ERR_LENGTH];
const char* dnumentries;
const char* vmap;
const char* tname;
switch (map_type) {
case EX_NODE_MAP:
tname = "node";
dnumentries = DIM_NUM_NODES;
vmap = VAR_NODE_NUM_MAP;
break;
case EX_EDGE_MAP:
tname = "edge";
dnumentries = DIM_NUM_EDGE;
vmap = VAR_EDGE_NUM_MAP;
break;
case EX_FACE_MAP:
tname = "face";
dnumentries = DIM_NUM_FACE;
vmap = VAR_FACE_NUM_MAP;
break;
case EX_ELEM_MAP:
tname = "element";
dnumentries = DIM_NUM_ELEM;
vmap = VAR_ELEM_NUM_MAP;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg,
"Error: Bad map type (%d) specified for file id %d",
map_type, exoid );
ex_err( "ex_get_id_map", errmsg, exerrval );
return (EX_FATAL);
}
exerrval = 0; /* clear error code */
/* See if any entries are stored in this file */
if (nc_inq_dimid(exoid, dnumentries,&dimid) != NC_NOERR) {
return (EX_NOERR);
}
if (nc_inq_varid (exoid, vmap, &mapid) != NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_entries)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %ss in file id %d", tname, exoid);
ex_err("ex_get_id_map",errmsg,exerrval);
return (EX_FATAL);
}
/* generate default map of 1..n, where n is num_entries */
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
int64_t *lmap = (int64_t*)map;
for (i=0; i<num_entries; i++) {
lmap[i] = i+1;
}
} else {
int *lmap = (int*)map;
for (i=0; i<num_entries; i++) {
lmap[i] = i+1;
}
}
return (EX_NOERR);
}
/* read in the id map */
if (ex_int64_status(exoid) & EX_MAPS_INT64_API) {
status = nc_get_var_longlong(exoid, mapid, map);
} else {
status = nc_get_var_int(exoid, mapid, map);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s id map in file id %d",
tname, exoid);
ex_err("ex_get_id_map",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
void *mthreadLoadImg(void *arg) {
thread_args *t_args = (thread_args*)arg;
float ****storage = t_args->storage;
float ****count = t_args->count;
int start_i = t_args->start_i;
int stop_i = t_args->stop_i;
int num_rows = t_args->num_rows;
int num_columns = t_args->num_columns;
pthread_mutex_t *fopen_lock = t_args->fopen_lock;
char **warp_list = t_args->warp_list;
int retval;
int ncid;
size_t i,j;
int file_i;
sir_head *head = t_args->head;
// netcdf vars
int lon_varid, lat_varid, time_varid, sm_varid, rsize_varid;
int loc_dimid, obs_dimid;
size_t loc_len,obs_len;
// netcdf storage
double *lon, *lat, *time;
long long *rsize;
int8_t *sm;
// time storage
struct tm *tm;
for (file_i = start_i; file_i <= stop_i; file_i++) {
printf("Processing file %d of %d\n",file_i,935);
pthread_mutex_lock(fopen_lock);
if ((retval = nc_open(warp_list[file_i], NC_NOWRITE, &ncid))) {
ERR(retval);
continue;
}
// get the dimids and the lengths of the dimensions
if ((retval = nc_inq_dimid (ncid, "locations", &loc_dimid))) {
ERR(retval);
continue;
}
if ((retval = nc_inq_dimid (ncid, "obs", &obs_dimid))) {
ERR(retval);
continue;
}
if ((retval = nc_inq_dimlen (ncid, loc_dimid, &loc_len))) {
ERR(retval);
continue;
}
if ((retval = nc_inq_dimlen (ncid, obs_dimid, &obs_len))) {
ERR(retval);
continue;
}
// allocate space for all of the variables based on dim length
lon = malloc(sizeof(double)*loc_len);
lat = malloc(sizeof(double)*loc_len);
time = malloc(sizeof(double)*obs_len);
rsize = malloc(sizeof(int64_t)*loc_len);
sm = malloc(sizeof(int8_t)*obs_len);
// where to store the time conversions
tm = malloc(sizeof(struct tm)*obs_len);
memset(lon,0,sizeof(double)*loc_len);
memset(lat,0,sizeof(double)*loc_len);
memset(time,0,sizeof(double)*obs_len);
memset(rsize,0,sizeof(int64_t)*loc_len);
memset(sm,0,sizeof(int8_t)*obs_len);
memset(tm,0,sizeof(struct tm)*obs_len);
/* Get the varid of the data variable, based on its name. */
if ((retval = nc_inq_varid(ncid, "lon", &lon_varid))) {
ERR(retval);
continue;
}
if ((retval = nc_inq_varid(ncid, "lat", &lat_varid))) {
ERR(retval);
continue;
}
if ((retval = nc_inq_varid(ncid, "time", &time_varid))) {
ERR(retval);
continue;
}
if ((retval = nc_inq_varid(ncid, "row_size", &rsize_varid))) {
ERR(retval);
continue;
}
if ((retval = nc_inq_varid(ncid, "sm", &sm_varid))) {
ERR(retval);
continue;
}
/* read values from netCDF variable */
if ((retval = nc_get_var_double(ncid, lon_varid, lon))) {
ERR(retval);
continue;
}
/* read values from netCDF variable */
if ((retval = nc_get_var_double(ncid, lat_varid, lat))) {
ERR(retval);
continue;
}
/* read values from netCDF variable */
if ((retval = nc_get_var_double(ncid, time_varid, time))) {
ERR(retval);
continue;
}
/* read values from netCDF variable */
if ((retval = nc_get_var_longlong(ncid, rsize_varid, rsize))) {
ERR(retval);
continue;
}
/* read values from netCDF variable */
if ((retval = nc_get_var(ncid, sm_varid, sm))) {
ERR(retval);
continue;
}
if ((retval = nc_close(ncid))) {
ERR(retval);
continue;
}
pthread_mutex_unlock(fopen_lock);
// now load the image into the storage array if necessary
int use_file = 0;
float x,y;
int x_int, y_int;
for (i = 0; i < loc_len; i++) {
sir_latlon2pix(lon[i],lat[i],&x,&y,head);
x_int = (int)x;
y_int = (int)y;
if ( x_int < num_columns && x_int >= 0 && y_int < num_rows && y_int >= 0) {
use_file = 1;
break;
}
}
if (!use_file) {
// free data
free(lon);
free(lat);
free(time);
free(rsize);
free(sm);
free(tm);
continue;
}
// if I'm here, then there are measurements that need to be stored
// first convert the time to doy and year
// time is stored as a double -- number of days since 1900-1-1 00:00:00
double cur_time;
for (i = 0; i < obs_len; i++) {
cur_time = time[i];
// first convert to seconds
// (1 day * 24 hours/day * 60 min/hr * 60 sec/min) = 84600
cur_time = cur_time * 86400;
// convert from seconds since 1900 to unix time
// note that accd to time protocol in RFC 868, this is 2208988800
cur_time = cur_time - 2208988800;
// here, cast from double to time_t and use gmtime_r to convert to year/doy
time_t cur_time_conv = (time_t) cur_time;
gmtime_r(&cur_time_conv, &tm[i]);
// note that tm_year is years since 1900, so adjust to true year
tm[i].tm_year = tm[i].tm_year + 1900;
assert(tm[i].tm_year-(YEAR_START)>=0);
}
// now all the times should be correct in the tm struct
// parse through the measurements
size_t ind = 0;
int affected_days[3] = {-1,-1,-1};
int k;
for (i = 0; i < loc_len; i++) {
sir_latlon2pix(lon[i],lat[i],&x,&y,head);
x_int = (int)x;
y_int = (int)y;
// if lat/lon are in im bounds
if ( x_int < num_columns && x_int >= 0 && y_int < num_rows && y_int >= 0) {
for (j = 0; j < rsize[i]; j++) {
if (tm[ind].tm_yday%2 == 0) {
affected_days[0] = tm[ind].tm_yday-3;
affected_days[1] = tm[ind].tm_yday-1;
affected_days[2] = -1;
}
else {
affected_days[0] = tm[ind].tm_yday-4;
affected_days[1] = tm[ind].tm_yday-2;
affected_days[2] = tm[ind].tm_yday;
}
// convert affected days to a 1:2:365 index
for (k = 0; k < 3; k++) {
if (affected_days[k] < 0)
continue;
affected_days[k] = affected_days[k]/2;
// shorthand
float *st = &storage[y_int][x_int][affected_days[k]][tm[ind].tm_year-YEAR_START];
float *ct = &count[y_int][x_int][affected_days[k]][tm[ind].tm_year-YEAR_START];
// do running average
*st = *st + (((float)sm[ind]) - *st) / *ct;
(*ct)++;
}
ind++;
}
}
else {
ind += rsize[i];
}
}
// free data
free(lon);
free(lat);
free(time);
free(rsize);
free(sm);
free(tm);
}
return NULL;
}
int ex_get_ids (int exoid,
ex_entity_type obj_type,
void_int *ids)
{
int varid, status;
char errmsg[MAX_ERR_LENGTH];
const char* varidobj;
exerrval = 0; /* clear error code */
switch (obj_type) {
case EX_EDGE_BLOCK:
varidobj = VAR_ID_ED_BLK;
break;
case EX_FACE_BLOCK:
varidobj = VAR_ID_FA_BLK;
break;
case EX_ELEM_BLOCK:
varidobj = VAR_ID_EL_BLK;
break;
case EX_NODE_SET:
varidobj = VAR_NS_IDS;
break;
case EX_EDGE_SET:
varidobj = VAR_ES_IDS;
break;
case EX_FACE_SET:
varidobj = VAR_FS_IDS;
break;
case EX_SIDE_SET:
varidobj = VAR_SS_IDS;
break;
case EX_ELEM_SET:
varidobj = VAR_ELS_IDS;
break;
case EX_NODE_MAP:
varidobj = VAR_NM_PROP(1);
break;
case EX_EDGE_MAP:
varidobj = VAR_EDM_PROP(1);
break;
case EX_FACE_MAP:
varidobj = VAR_FAM_PROP(1);
break;
case EX_ELEM_MAP:
varidobj = VAR_EM_PROP(1);
break;
default:/* invalid variable type */
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid type specified in file id %d", exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return(EX_FATAL);
}
/* Determine if there are any 'obj-type' objects */
if ((status = nc_inq_dimid (exoid, ex_dim_num_objects(obj_type), &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no %s defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_WARN);
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, varidobj, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids variable in file id %d",
ex_name_of_object(obj_type),exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the element block ids */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varid, ids);
} else {
status = nc_get_var_int(exoid, varid, ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to return %s ids in file id %d",
ex_name_of_object(obj_type),exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
