void WrfNcSquareProjectionData::LoadData(const char* file_name){
int ncid, dim_id, var_id;
int status;
nc_open(file_name, NC_NOWRITE, &ncid);
nc_inq_dimid(ncid, "time", &dim_id);
nc_inq_dimlen(ncid, dim_id, &time_len_);
nc_inq_dimid(ncid, "lat", &dim_id);
nc_inq_dimlen(ncid, dim_id, &lat_len_);
nc_inq_dimid(ncid, "lon", &dim_id);
nc_inq_dimlen(ncid, dim_id, &lon_len_);
status = nc_inq_dimid(ncid, "ens", &dim_id);
if ( status == NC_NOERR ){
nc_inq_dimlen(ncid, dim_id, &ens_len_);
} else {
ens_len_ = 1;
}
nc_inq_dimid(ncid, "fhour", &dim_id);
nc_inq_dimlen(ncid, dim_id, &fhour_len_);
// load analysis time
nc_inq_varid(ncid, "time", &var_id);
std::vector< double > temp_time;
temp_time.resize(time_len_ * fhour_len_);
nc_get_var_double(ncid, var_id, temp_time.data());
for ( int i = 0; i < temp_time.size(); ++i ) {
time_map_.insert(std::map< int, int >::value_type((int)temp_time[i], i));
}
nc_inq_varid(ncid, "intValidTime", &var_id);
std::vector< int > intvalidtime;
intvalidtime.resize(time_len_ * fhour_len_);
nc_get_var_int(ncid, var_id, intvalidtime.data());
nc_inq_varid(ncid, "intTime", &var_id);
std::vector< int > inttime;
inttime.resize(time_len_ * fhour_len_);
nc_get_var_int(ncid, var_id, inttime.data());
nc_inq_varid(ncid, "lat", &var_id);
lat_.resize(lat_len_);
nc_get_var_float(ncid, var_id, lat_.data());
nc_inq_varid(ncid, "lon", &var_id);
lon_.resize(lon_len_);
nc_get_var_float(ncid, var_id, lon_.data());
nc_inq_varid(ncid, "fhour", &var_id);
std::vector< int > temp_fhour;
temp_fhour.resize(fhour_len_);
nc_get_var_int(ncid, var_id, temp_fhour.data());
for ( int i = 0; i < temp_fhour.size(); ++i )
fhour_map_.insert(std::map< int, int >::value_type(temp_fhour[i], i));
switch ( element_ ){
case WRF_ACCUMULATED_PRECIPITATION:
nc_inq_varid(ncid, "Total_precipitation", &var_id);
break;
case WRF_PRECIPITABLE_WATER:
nc_inq_varid(ncid, "Precipitable_water", &var_id);
break;
case WRF_T2M:
nc_inq_varid(ncid, "Temperature_height_above_ground", &var_id);
break;
case WRF_PRESSURE_SURFACE:
nc_inq_varid(ncid, "Pressure_surface", &var_id);
break;
case WRF_MSLP:
nc_inq_varid(ncid, "Pressure", &var_id);
break;
default:
return;
}
data_values_ = new float[time_len_ * ens_len_ * fhour_len_ * lat_len_ * lon_len_];
if ( data_values_ == NULL ){
std::cout << "Out of memory" << std::endl;
return;
}
nc_get_var_float(ncid, var_id, data_values_);
nc_close(ncid);
map_range_.start_x = lon_[0];
map_range_.end_x = lon_[lon_.size() - 1];
map_range_.start_y = lat_[0];
map_range_.end_y = lat_[lat_.size() - 1];
map_range_.x_grid_space = lon_[1] - lon_[0];
map_range_.y_grid_space = lat_[1] - lat_[0];
map_range_.x_grid_number = lon_len_;
map_range_.y_grid_number = lat_len_;
}
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)
{
if (res != NC_ERANGE) ERR;
}
else if (res) ERR;
for (i=0; i<DIM1_LEN; i++)
if (uchar_in[i] != uchar_out[i]) ERR;
if (nc_get_var_schar(ncid, 0, char_in)) ERR;
for (i=0; i<DIM1_LEN; i++)
if (char_in[i] != (signed char)uchar_out[i]) ERR;
if (nc_get_var_short(ncid, 0, short_in)) ERR;
for (i=0; i<DIM1_LEN; i++)
if (short_in[i] != (signed char)uchar_out[i]) ERR;
if (nc_get_var_int(ncid, 0, int_in)) ERR;
for (i=0; i<DIM1_LEN; i++)
if (int_in[i] != (signed char)uchar_out[i]) ERR;
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
main(int argc, char **argv)
{ /* create tst_classic_fills.nc */
printf("\n*** Testing fill values.\n");
printf("*** testing empty fill values of a string var...");
{
#define STRING_VAR_NAME "The_String"
#define NDIMS_STRING 1
#define FILLVALUE_LEN 1 /* There is 1 string, the empty one. */
#define DATA_START 2 /* Real data here. */
int ncid, varid, dimid, varid_in;
const char *missing_val[FILLVALUE_LEN] = {""};
const char *missing_val_in[FILLVALUE_LEN];
const char *data_out[1] = {"The evil that men do lives after them; "
"the good is oft interred with their bones."};
char **data_in;
size_t index = DATA_START;
int i;
/* Create file with a 1D string var. Set its fill value to the
* empty string. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, "rec", NC_UNLIMITED, &dimid)) ERR;
if (nc_def_var(ncid, STRING_VAR_NAME, NC_STRING, NDIMS_STRING, &dimid, &varid)) ERR;
if (nc_put_att_string(ncid, varid, "_FillValue", FILLVALUE_LEN, missing_val)) ERR;
/* Check it out. */
if (nc_inq_varid(ncid, STRING_VAR_NAME, &varid_in)) ERR;
if (nc_get_att_string(ncid, varid_in, "_FillValue", (char **)missing_val_in)) ERR;
if (strcmp(missing_val[0], missing_val_in[0])) ERR;
if (nc_free_string(FILLVALUE_LEN, (char **)missing_val_in)) ERR;
/* Write one string, leaving some blank records which will then
* get the fill value. */
if (nc_put_var1_string(ncid, varid_in, &index, data_out)) ERR;
/* Get all the data from the variable. */
if (!(data_in = malloc((DATA_START + 1) * sizeof(char *)))) ERR;
if (nc_get_var_string(ncid, varid_in, data_in)) ERR;
/* First there should be fill values, then the data value we
* wrote. */
for (i = 0; i < DATA_START; i++)
if (strcmp(data_in[i], "")) ERR;
if (strcmp(data_in[DATA_START], data_out[0])) ERR;
/* Close everything up. */
if (nc_close(ncid)) ERR;
/* Now re-open file, read data, and check values again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_varid(ncid, STRING_VAR_NAME, &varid_in)) ERR;
if (nc_get_att_string(ncid, varid_in, "_FillValue", (char **)missing_val_in)) ERR;
if (strcmp(missing_val[0], missing_val_in[0])) ERR;
if (nc_free_string(FILLVALUE_LEN, (char **)missing_val_in)) ERR;
if (nc_close(ncid)) ERR;
free(data_in);
}
SUMMARIZE_ERR;
printf("*** testing non-empty fill values of a string var...");
{
#define STRING_VAR_NAME2 "CASSIUS"
#define FILLVALUE_LEN2 1 /* There is 1 string in the fillvalue array. */
#define DATA_START2 9 /* Real data starts here. */
int ncid, varid, dimid, varid_in;
const char *missing_val[FILLVALUE_LEN2] = {"I know that virtue to be in you, Brutus"};
const char *missing_val_in[FILLVALUE_LEN2];
const char *data_out[1] = {"The evil that men do lives after them; "
"the good is oft interred with their bones."};
char **data_in;
size_t index = DATA_START2;
int i;
/* Create file with a 1D string var. Set its fill value to the
* a non-empty string. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, "rec", NC_UNLIMITED, &dimid)) ERR;
if (nc_def_var(ncid, STRING_VAR_NAME2, NC_STRING, NDIMS_STRING, &dimid, &varid)) ERR;
if (nc_put_att_string(ncid, varid, "_FillValue", FILLVALUE_LEN2, missing_val)) ERR;
/* Check it out. */
if (nc_inq_varid(ncid, STRING_VAR_NAME2, &varid_in)) ERR;
if (nc_get_att_string(ncid, varid_in, "_FillValue", (char **)missing_val_in)) ERR;
if (strcmp(missing_val[0], missing_val_in[0])) ERR;
if (nc_free_string(FILLVALUE_LEN2, (char **)missing_val_in)) ERR;
/* Write one string, leaving some blank records which will then
* get the fill value. */
if (nc_put_var1_string(ncid, varid_in, &index, data_out)) ERR;
/* Get all the data from the variable. */
if (!(data_in = malloc((DATA_START2 + 1) * sizeof(char *)))) ERR;
if (nc_get_var_string(ncid, varid_in, data_in)) ERR;
/* First there should be fill values, then the data value we
* wrote. */
for (i = 0; i < DATA_START2; i++)
if (strcmp(data_in[i], missing_val[0])) ERR;
if (strcmp(data_in[DATA_START2], data_out[0])) ERR;
/* Close everything up. */
if (nc_close(ncid)) ERR;
/* Now re-open file, read data, and check values again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_varid(ncid, STRING_VAR_NAME2, &varid_in)) ERR;
if (nc_get_att_string(ncid, varid_in, "_FillValue", (char **)missing_val_in)) ERR;
if (strcmp(missing_val[0], missing_val_in[0])) ERR;
if (nc_free_string(FILLVALUE_LEN2, (char **)missing_val_in)) ERR;
if (nc_close(ncid)) ERR;
free(data_in);
}
SUMMARIZE_ERR;
printf("*** testing fill values of one var...");
{
#define V1_NAME "v1"
#define MAX_VALS 10
int ncid, varid, rec_id, dims[2];
static int rec[1] = {1};
size_t start[2] = {0, 0};
size_t count[2] = {1, MAX_VALS};
char vals[MAX_VALS];
int i;
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
/* Define dimensions and two vars, a 1D coordinate var for
* unlimited dimension, and a 2D var which uses the unlimited
* dimension. */
if (nc_def_dim(ncid, "rec", NC_UNLIMITED, &dims[0])) ERR;
if (nc_def_dim(ncid, "len", MAX_VALS, &dims[1])) ERR;
if (nc_def_var(ncid, "rec", NC_INT, 1, dims, &rec_id)) ERR;
if (nc_def_var(ncid, V1_NAME, NC_CHAR, 2, dims, &varid)) ERR;
/* Extend record dimension by 1. */
if (nc_put_vara_int(ncid, rec_id, start, count, rec)) ERR;
/* Read the other variable; it must have only fill values. */
if (nc_get_vara_text(ncid, 1, start, count, vals)) ERR;
for (i = 0; i < MAX_VALS; i++)
if(vals[i] != NC_FILL_CHAR) ERR;
if (nc_close(ncid)) ERR;
/* Now re-open file, read data, and check values again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Read the other variable; it must have only fill values. */
if (nc_get_vara_text(ncid, 1, start, count, vals)) ERR;
for (i = 0; i < MAX_VALS; i++)
if(vals[i] != NC_FILL_CHAR) ERR;
if(nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing fill values of lots of vars...");
{
int ncid; /* netCDF id */
#define NVALS 10 /* values per fixed-size variable or record */
#define NFIXVARS 6 /* number of fixed-size vars, one of each type */
#define NRECVARS 6 /* number of record vars, one of each type */
#define RANK_REC 1
#define RANK_FIXVARS 1
#define RANK_RECVARS 2
/* dimension ids */
int rec_dim;
int len_dim;
/* dimension lengths */
size_t rec_len = NC_UNLIMITED;
size_t len_len = NVALS;
/* variable ids */
int rec_id;
int fixvar_ids[NFIXVARS];
int recvar_ids[NRECVARS];
int rec_dims[RANK_REC];
int fixvar_dims[RANK_FIXVARS];
int recvar_dims[RANK_RECVARS];
int fixvar, recvar, i;
char *fnames[] = {"c", "b", "s", "i", "f", "d"};
char *rnames[] = {"cr", "br", "sr", "ir", "fr", "dr"};
nc_type types[] = {NC_CHAR, NC_BYTE, NC_SHORT, NC_INT, NC_FLOAT, NC_DOUBLE};
/*if (nc_set_default_format(format + 1, NULL)) ERR;*/
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
/* define dimensions */
if (nc_def_dim(ncid, "rec", rec_len, &rec_dim)) ERR;
if (nc_def_dim(ncid, "len", len_len, &len_dim)) ERR;
rec_dims[0] = rec_dim;
if (nc_def_var(ncid, "rec", NC_INT, RANK_REC, rec_dims, &rec_id)) ERR;
/* define fixed and record variables of all 6 primitive types */
fixvar_dims[0] = len_dim;
for (fixvar = 0; fixvar < NFIXVARS; fixvar++)
if (nc_def_var(ncid, fnames[fixvar], types[fixvar], RANK_FIXVARS,
fixvar_dims, &fixvar_ids[fixvar])) ERR;
recvar_dims[0] = rec_dim;
recvar_dims[1] = len_dim;
for (recvar = 0; recvar < NRECVARS; recvar++)
if (nc_def_var(ncid, rnames[recvar], types[recvar], RANK_RECVARS,
recvar_dims, &recvar_ids[recvar])) ERR;
/* leave define mode */
if (nc_enddef(ncid)) ERR;
{ /* store rec */
static size_t rec_start[RANK_REC];
static size_t rec_count[RANK_REC];
static int rec[] = {1};
rec_len = 1; /* number of records of rec data */
rec_start[0] = 0;
rec_count[0] = rec_len;
if (nc_put_vara_int(ncid, rec_id, rec_start, rec_count, rec)) ERR;
}
if (nc_close(ncid)) ERR;
/* Now re-open file, read data, and check values */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check that fixed-size variables are full of fill values */
for (fixvar = 0; fixvar < NFIXVARS; fixvar++) {
int varid;
nc_type type;
if (nc_inq_varid(ncid, fnames[fixvar], &varid)) ERR;
if (nc_inq_vartype(ncid, varid, &type)) ERR;
switch(type) {
case NC_CHAR:
{
char vals[NVALS];
if (nc_get_var_text(ncid, varid, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_CHAR) ERR;
}
break;
case NC_BYTE:
{
signed char vals[NVALS];
if (nc_get_var_schar(ncid, varid, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_BYTE) ERR;
}
break;
case NC_SHORT:
{
short vals[NVALS];
if (nc_get_var_short(ncid, varid, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_SHORT) ERR;
}
break;
case NC_INT:
{
int vals[NVALS];
if (nc_get_var_int(ncid, varid, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_INT) ERR;
}
break;
case NC_FLOAT:
{
float vals[NVALS];
if (nc_get_var_float(ncid, varid, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_FLOAT) ERR;
}
break;
case NC_DOUBLE:
{
double vals[NVALS];
if (nc_get_var_double(ncid, varid, vals)) ERR;
for (i = 0; i < NVALS; i++)
if (vals[i] != NC_FILL_DOUBLE) ERR;
}
break;
default:
ERR;
}
}
/* Read record, check record variables have only fill values */
for (recvar = 0; recvar < NRECVARS; recvar++) {
int varid;
nc_type type;
size_t start[] = {0, 0};
size_t count[] = {1, NVALS};
if (nc_inq_varid(ncid, rnames[recvar], &varid)) ERR;
if (nc_inq_vartype(ncid, varid, &type)) ERR;
switch(type) {
case NC_CHAR:
{
char vals[NVALS];
if (nc_get_vara_text(ncid, varid, start, count, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_CHAR) ERR;
}
break;
case NC_BYTE:
{
signed char vals[NVALS];
if (nc_get_vara_schar(ncid, varid, start, count, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_BYTE) ERR;
}
break;
case NC_SHORT:
{
short vals[NVALS];
if (nc_get_vara_short(ncid, varid, start, count, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_SHORT) ERR;
}
break;
case NC_INT:
{
int vals[NVALS];
if (nc_get_vara_int(ncid, varid, start, count, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_INT) ERR;
}
break;
case NC_FLOAT:
{
float vals[NVALS];
if (nc_get_vara_float(ncid, varid, start, count, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_FLOAT) ERR;
}
break;
case NC_DOUBLE:
{
double vals[NVALS];
if (nc_get_vara_double(ncid, varid, start, count, vals)) ERR;
for (i = 0; i < NVALS; i++)
if(vals[i] != NC_FILL_DOUBLE) ERR;
}
break;
default:
ERR;
}
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
return 0;
}
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[MAX_VAR_NAME_LENGTH+1];
char tmpstr[MAX_STR_LENGTH+1];
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* open appropriate variable, depending on obj_type and prop_name */
num_props = ex_get_num_props(exoid, obj_type);
for (i=1; i<=num_props; i++)
{
switch (obj_type){
case EX_ELEM_BLOCK:
strcpy (name, VAR_EB_PROP(i));
break;
case EX_EDGE_BLOCK:
strcpy (name, VAR_ED_PROP(i));
break;
case EX_FACE_BLOCK:
strcpy (name, VAR_FA_PROP(i));
break;
case EX_NODE_SET:
strcpy (name, VAR_NS_PROP(i));
break;
case EX_EDGE_SET:
strcpy (name, VAR_ES_PROP(i));
break;
case EX_FACE_SET:
strcpy (name, VAR_FS_PROP(i));
break;
case EX_ELEM_SET:
strcpy (name, VAR_ELS_PROP(i));
break;
case EX_SIDE_SET:
strcpy (name, VAR_SS_PROP(i));
break;
case EX_ELEM_MAP:
strcpy (name, VAR_EM_PROP(i));
break;
case EX_FACE_MAP:
strcpy (name, VAR_FAM_PROP(i));
break;
case EX_EDGE_MAP:
strcpy (name, VAR_EDM_PROP(i));
break;
case EX_NODE_MAP:
strcpy (name, VAR_NM_PROP(i));
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: object type %d not supported; file id %d",
obj_type, exoid);
ex_err("ex_get_prop_array",errmsg,exerrval);
return(EX_FATAL);
}
if ((status = nc_inq_varid(exoid, name, &propid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate property array %s in file id %d",
name, exoid);
ex_err("ex_get_prop_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;
sprintf(errmsg,
"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;
sprintf(errmsg,
"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;
sprintf(errmsg,
"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 NC::Init(const char *fname) {
FILE *F;
int jj,rc;
int ncid, ndims, dimids[128];
int nvars, varids[128], vardim;
size_t alen, len[128];
F=fopen(fname,"r");
if ( !F ) {
fprintf(stderr, "Bummer: unable to open %s to read. \n", fname);
return (-1);
}
fclose(F);
/* read the netCDF file */
if ( (rc = nc_open(fname, NC_NOWRITE, &ncid)) != NC_NOERR) NETCDF_ERR(rc);
if ( (rc = nc_inq_dimids(ncid, &ndims, dimids,0)) != NC_NOERR) NETCDF_ERR(rc);
#if PRT
int kk,where;
printf("dim = %d\n", ndims);
#endif
for (jj=0; jj<ndims;jj++) {
if ( (rc = nc_inq_dimlen(ncid, dimids[jj],&alen)) != NC_NOERR) NETCDF_ERR(rc);
len[jj] = alen;
#if PRT
printf("The %d th dimension's length is: %d \n", dimids[jj], (unsigned int)alen);
#endif
}
_num_comid = (int)len[0];
_num_time = (int)len[1];
if ( (rc = nc_inq_varids(ncid, &nvars, varids)) != NC_NOERR) NETCDF_ERR(rc);
#if PRT
printf("var = %d\n", nvars);
#endif
_num_vars = nvars;
for (jj=0; jj<nvars;jj++) {
if ( (rc = nc_inq_varndims(ncid, varids[jj],&vardim)) != NC_NOERR) NETCDF_ERR(rc);
#if PRT
printf("%d %d\n", varids[jj], vardim);
#endif
}
#if PRT
printf("%d\n", (unsigned int)len[0]);
#endif
_comids = (int*)malloc( len[0] *sizeof(int) ); //allocate memory for comids
_runoff = (float*)malloc( len[0]*len[1] * sizeof(float)); //assign memory for runoff
if (!_comids) return (-1);
//assign comid to memory
if ( ( rc = nc_get_var_int(ncid, varids[0], _comids)) != NC_NOERR) NETCDF_ERR(rc);
if ( !_runoff ) return (-1);
if ( (rc=nc_get_var_float(ncid, varids[1], _runoff)) != NC_NOERR) NETCDF_ERR(rc);
if (nvars == 3)
{
_upstream_hg = (float*)malloc( len[0]*len[1] * sizeof(float));
if ( (rc=nc_get_var_float(ncid, varids[2], _upstream_hg)) != NC_NOERR) NETCDF_ERR(rc);
}
if ( (rc=nc_close(ncid)) != NC_NOERR ) NETCDF_ERR(rc);
//printf("dimensions : %d , %d \n", len[0],len[1]);
//for (int kk = 0; kk<_num_comid; kk++){printf("%i \n", _comids[kk]);}
#if PRT
for (kk=0; kk< len[0]; kk++) {
where = _search_index(_comids[kk]);
if ( where >= 0 ) {
printf("%d: ", _comids[kk]);
for ( jj=0; jj<len[1]; jj++) {
printf("%g ", _runoff[jj*len[0]+where]);
}
printf("\n");
} else {
printf("%d not found\n", _comids[kk]);
}
}
#endif
#if 0
*e_comids = comids;
*e_sgs = bgs;
*e_ss = ss;
#endif
return rc;
}
int
main(int argc, char **argv)
{
printf("\n*** Testing HDF4/NetCDF-4 interoperability...\n");
printf("*** testing that netCDF can read a HDF4 file with some ints...");
{
#define PRES_NAME "pres"
#define LAT_LEN 3
#define LON_LEN 2
#define DIMS_2 2
int32 sd_id, sds_id;
int32 dim_size[DIMS_2] = {LAT_LEN, LON_LEN};
int32 start[DIMS_2] = {0, 0}, edge[DIMS_2] = {LAT_LEN, LON_LEN};
int ncid, nvars_in, ndims_in, natts_in, unlimdim_in;
size_t len_in;
int data_out[LAT_LEN][LON_LEN], data_in[LAT_LEN][LON_LEN];
size_t nstart[DIMS_2] = {0, 0}, ncount[DIMS_2] = {LAT_LEN, LON_LEN};
size_t nindex[DIMS_2] = {0, 0};
int scalar_data_in = 0;
int i, j;
/* Create some data. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
data_out[i][j] = j;
/* Create a file with one SDS, containing our phony data. */
sd_id = SDstart(FILE_NAME, DFACC_CREATE);
sds_id = SDcreate(sd_id, PRES_NAME, DFNT_INT32, DIMS_2, dim_size);
if (SDwritedata(sds_id, start, NULL, edge, (void *)data_out)) ERR;
if (SDendaccess(sds_id)) ERR;
if (SDend(sd_id)) ERR;
/* Now open with netCDF and check the contents. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdim_in)) ERR;
if (ndims_in != 2 || nvars_in != 1 || natts_in != 0 || unlimdim_in != -1) ERR;
if (nc_inq_dim(ncid, 0, NULL, &len_in)) ERR;
if (len_in != LAT_LEN) ERR;
if (nc_inq_dim(ncid, 1, NULL, &len_in)) ERR;
if (len_in != LON_LEN) ERR;
/* Read the data through a vara function from the netCDF API. */
if (nc_get_vara(ncid, 0, nstart, ncount, data_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
if (data_in[i][j] != data_out[i][j]) ERR;
/* Reset for next test. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
data_in[i][j] = -88;
/* Read the data through a vara_int function from the netCDF API. */
if (nc_get_vara_int(ncid, 0, nstart, ncount, data_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
if (data_in[i][j] != data_out[i][j]) ERR;
/* Reset for next test. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
data_in[i][j] = -88;
/* Read the data through a var_int function from the netCDF API. */
if (nc_get_var_int(ncid, 0, data_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
if (data_in[i][j] != data_out[i][j]) ERR;
/* Read the data through a var1 function from the netCDF API. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
{
nindex[0] = i;
nindex[1] = j;
if (nc_get_var1(ncid, 0, nindex, &scalar_data_in)) ERR;
if (scalar_data_in != data_out[i][j]) ERR;
scalar_data_in = -88; /* reset */
if (nc_get_var1_int(ncid, 0, nindex, &scalar_data_in)) ERR;
if (scalar_data_in != data_out[i][j]) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing with a more complex HDF4 file...");
{
#define Z_LEN 3
#define Y_LEN 2
#define X_LEN 5
#define DIMS_3 3
#define NUM_TYPES 8
int32 sd_id, sds_id;
int32 dim_size[DIMS_3] = {Z_LEN, Y_LEN, X_LEN};
int dimids_in[DIMS_3];
int ncid, nvars_in, ndims_in, natts_in, unlimdim_in;
size_t len_in;
nc_type type_in;
int hdf4_type[NUM_TYPES] = {DFNT_FLOAT32, DFNT_FLOAT64,
DFNT_INT8, DFNT_UINT8, DFNT_INT16,
DFNT_UINT16, DFNT_INT32, DFNT_UINT32};
int netcdf_type[NUM_TYPES] = {NC_FLOAT, NC_DOUBLE,
NC_BYTE, NC_UBYTE, NC_SHORT,
NC_USHORT, NC_INT, NC_UINT};
char tmp_name[NC_MAX_NAME + 1], name_in[NC_MAX_NAME + 1];
char dim_name[NC_MAX_NAME + 1][DIMS_3] = {"z", "y", "x"};
int d, t;
/* Create a HDF4 SD file. */
sd_id = SDstart (FILE_NAME, DFACC_CREATE);
/* Create some HDF4 datasets. */
for (t = 0; t < NUM_TYPES; t++)
{
sprintf(tmp_name, "hdf4_dataset_type_%d", t);
if ((sds_id = SDcreate(sd_id, tmp_name, hdf4_type[t],
DIMS_3, dim_size)) == FAIL) ERR;
/* Set up dimensions. By giving them the same names for each
* dataset, I am specifying that they are shared
* dimensions. */
for (d = 0; d < DIMS_3; d++)
{
int32 dimid;
if ((dimid = SDgetdimid(sds_id, d)) == FAIL) ERR;
if (SDsetdimname(dimid, dim_name[d])) ERR;
}
if (SDendaccess(sds_id)) ERR;
}
if (SDend(sd_id)) ERR;
/* Open the file with netCDF and check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdim_in)) ERR;
if (ndims_in != DIMS_3 || nvars_in != NUM_TYPES || natts_in != 0 || unlimdim_in != -1) ERR;
if (nc_inq_dim(ncid, 0, NULL, &len_in)) ERR;
if (len_in != Z_LEN) ERR;
if (nc_inq_dim(ncid, 1, NULL, &len_in)) ERR;
if (len_in != Y_LEN) ERR;
if (nc_inq_dim(ncid, 2, NULL, &len_in)) ERR;
if (len_in != X_LEN) ERR;
for (t = 0; t < NUM_TYPES; t++)
{
if (nc_inq_var(ncid, t, name_in, &type_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (type_in != netcdf_type[t] || ndims_in != DIMS_3 ||
dimids_in[0] != 0 || dimids_in[2] != 2 || dimids_in[2] != 2 ||
natts_in != 0) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
int get_netcdf_var_timeserias(char *netcdf_filename, char *varname,
char *nlat_name, char *nlon_name,
float rlat, float rlon, float sd,
int startday, int day_offset, int duration, float *data){
/***Read netcdf format metdata by using lat,lon as index
varname: variable name
rlat,rlon: latitue and longitude of site location
sd: the minimum distance for searching nearby grid in netcdf
startday: startday of metdata (since STARTYEAR-01-01)
duration: days of required metdata
Mingliang Liu
Nov. 17, 2011
************************************************************/
int ncid, temp_varid,ndaysid,nlatid,nlontid;
int dayid,latid,lontid;
size_t nday,nlat,nlont;
int ndims_in, nvars_in, ngatts_in, unlimdimid_in;
int *days;
float *lat,*lont;
size_t start[3],count[3];
int i,j,k,l;
int retval;
int idlat,idlont,idday; //offset
/*printf("\n Opening netcdf file...\n");*/
/***open netcdf***/
if((retval = nc_open(netcdf_filename, NC_NOWRITE, &ncid)))
ERR(retval);
if((retval = nc_inq(ncid, &ndims_in, &nvars_in, &ngatts_in,
&unlimdimid_in)))
ERR(retval);
/*printf("\n ncid=%d ndims_in=%d nvars_in=%d ngatts_in=%d unlimdimid_in=%d\n",ncid, ndims_in, nvars_in, ngatts_in, unlimdimid_in);*/
/*printf("\n Getting dimensions and var id... %d %s %d\n",ncid,NDAYS_NAME,ndaysid);*/
/***Get the dimension and var id***/
if((retval = nc_inq_dimid(ncid,NDAYS_NAME, &ndaysid)))
ERR(retval);
if((retval = nc_inq_dimid(ncid, nlat_name, &nlatid)))
ERR(retval);
if((retval = nc_inq_dimid(ncid, nlon_name, &nlontid)))
ERR(retval);
if((retval = nc_inq_dimlen(ncid, ndaysid, &nday)))
ERR(retval);
if((retval = nc_inq_dimlen(ncid, nlatid, &nlat)))
ERR(retval);
if((retval = nc_inq_dimlen(ncid, nlontid, &nlont)))
ERR(retval);
/* Get the varids of variables. */
if ((retval = nc_inq_varid(ncid, NDAYS_NAME, &dayid)))
ERR(retval);
if ((retval = nc_inq_varid(ncid, nlat_name, &latid)))
ERR(retval);
if ((retval = nc_inq_varid(ncid, nlon_name, &lontid)))
ERR(retval);
if ((retval = nc_inq_varid(ncid, varname, &temp_varid)))
ERR(retval);
days = (int *) alloc(nday * sizeof(int),"days","get_netcdf_var_timeserias");
lat = (float *) alloc(nlat * sizeof(float),"lat","get_netcdf_var_timeserias");
lont = (float *) alloc(nlont * sizeof(float),"lont","get_netcdf_var_timeserias");
/* get dimention var */
if ((retval = nc_get_var_int(ncid, dayid, &days[0]))){
free(days);
free(lat);
free(lont);
ERR(retval);
}
if ((retval = nc_get_var_float(ncid, latid, &lat[0]))){
free(days);
free(lat);
free(lont);
ERR(retval);
}
if ((retval = nc_get_var_float(ncid, lontid, &lont[0]))){
free(days);
free(lat);
free(lont);
ERR(retval);
}
/*locate the record */
idlat = locate(lat,nlat,rlat,sd);
idlont = locate(lont,nlont,rlon,sd);
if(idlat == -1 || idlont == -1){
fprintf(stderr,"can't locate the station\n");
free(days);
free(lat);
free(lont);
return -1;
}
/*printf("\nstartday=%d duration=%d nday=%d day1=%d dayfin=%d\n",startday,duration,nday,days[0],days[nday-1]);*/
if((startday<days[0] || (duration+startday) > days[nday-1])){
fprintf(stderr,"time period is out of the range of metdata\n");
free(days);
free(lat);
free(lont);
return -1;
}
start[0] = startday-days[0]+day_offset; //netcdf 4.1.3 problem: there is 1 day offset
start[1] = idlat; //lat
start[2] = idlont;
count[0] = duration;
count[1] = 1;
count[2] = 1;
/***Read netcdf data***/
if ((retval = nc_get_vara_float(ncid,temp_varid,start,count,&data[0]))){
free(days);
free(lat);
free(lont);
ERR(retval);
}
if ((retval = nc_close(ncid))){
free(days);
free(lat);
free(lont);
ERR(retval);
}
free(days);
free(lat);
free(lont);
return 0;
}
static int
ex_look_up_var(int exoid, ex_entity_type var_type, int var_index, ex_entity_id obj_id,
const char *VOBJID, const char *VOBJTAB, const char *DNUMOBJ,
const char *DNUMOBJVAR, int *varid)
{
int status;
int obj_id_ndx;
int dimid,time_dim, numobjdim, dims[2];
size_t num_obj;
size_t num_obj_var;
size_t num_entity;
int *obj_var_truth_tab;
char errmsg[MAX_ERR_LENGTH];
/* Determine index of obj_id in VOBJID array */
obj_id_ndx = ex_id_lkup(exoid,var_type,obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no variables allowed for NULL block %"PRId64" in file id %d",
obj_id,exoid);
ex_err("ex_put_var",errmsg,EX_NULLENTITY);
return (EX_WARN);
}
else {
sprintf(errmsg,
"Error: failed to locate %s id %"PRId64" in %s array in file id %d",
ex_name_of_object(var_type), obj_id, VOBJID, exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
}
if ((status = nc_inq_varid (exoid, ex_name_var_of_object(var_type, var_index, obj_id_ndx), varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) {/* variable doesn't exist, create it! */
/* check for the existance of an TNAME variable truth table */
if (nc_inq_varid(exoid, VOBJTAB, varid) == NC_NOERR) {
/* find out number of TNAMEs and TNAME variables */
status = ex_get_dimension(exoid, DNUMOBJ, ex_name_of_object(var_type), &num_obj, &dimid, "ex_put_var");
if (status != NC_NOERR) return status;
status = ex_get_dimension(exoid, DNUMOBJVAR, ex_name_of_object(var_type), &num_obj_var, &dimid, "ex_put_var");
if (status != NC_NOERR) return status;
if (!(obj_var_truth_tab = malloc(num_obj*num_obj_var*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s variable truth table in file id %d",
ex_name_of_object(var_type), exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the TNAME variable truth table */
if ((status = nc_get_var_int (exoid, *varid, obj_var_truth_tab)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get truth table from file id %d", exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
if(obj_var_truth_tab[num_obj_var*(obj_id_ndx-1)+var_index-1] == 0L) {
free(obj_var_truth_tab);
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid %s variable %d, %s %"PRId64" in file id %d",
ex_name_of_object(var_type), var_index, ex_name_of_object(var_type), obj_id, exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
free(obj_var_truth_tab);
}
if ((status = nc_inq_dimid(exoid, DIM_TIME, &time_dim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate time dimension in file id %d", exoid);
ex_err("ex_put_var",errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_get_dimension(exoid, ex_dim_num_entries_in_object(var_type, obj_id_ndx),
ex_name_of_object(var_type), &num_entity, &numobjdim, "ex_put_var");
/* variable doesn't exist so put file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode", exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
/* define netCDF variable to store TNAME variable values */
dims[0] = time_dim;
dims[1] = numobjdim;
if ((status = nc_def_var(exoid, ex_name_var_of_object(var_type, var_index, obj_id_ndx),
nc_flt_code(exoid), 2, dims, varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s variable %d in file id %d",
ex_name_of_object(var_type), var_index,exoid);
ex_err("ex_put_var",errmsg,exerrval);
goto error_ret;
}
ex_compress_variable(exoid, *varid, 2);
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete %s variable %s definition to file id %d",
ex_name_of_object(var_type), ex_name_var_of_object(var_type, var_index, obj_id_ndx), exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
}
else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s variable %s in file id %d",
ex_name_of_object(var_type), ex_name_var_of_object(var_type, var_index, obj_id_ndx), exoid);
ex_err("ex_put_var",errmsg,exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef (exoid) != NC_NOERR) { /* exit define mode */
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err("ex_put_var",errmsg,exerrval);
}
return (EX_FATAL);
}
int ex_get_ids (int exoid,
ex_entity_type obj_type,
void_int *ids)
{
int varid, status;
char errmsg[MAX_ERR_LENGTH];
const char* varidobj;
exerrval = 0; /* clear error code */
switch (obj_type) {
case EX_EDGE_BLOCK:
varidobj = VAR_ID_ED_BLK;
break;
case EX_FACE_BLOCK:
varidobj = VAR_ID_FA_BLK;
break;
case EX_ELEM_BLOCK:
varidobj = VAR_ID_EL_BLK;
break;
case EX_NODE_SET:
varidobj = VAR_NS_IDS;
break;
case EX_EDGE_SET:
varidobj = VAR_ES_IDS;
break;
case EX_FACE_SET:
varidobj = VAR_FS_IDS;
break;
case EX_SIDE_SET:
varidobj = VAR_SS_IDS;
break;
case EX_ELEM_SET:
varidobj = VAR_ELS_IDS;
break;
case EX_NODE_MAP:
varidobj = VAR_NM_PROP(1);
break;
case EX_EDGE_MAP:
varidobj = VAR_EDM_PROP(1);
break;
case EX_FACE_MAP:
varidobj = VAR_FAM_PROP(1);
break;
case EX_ELEM_MAP:
varidobj = VAR_EM_PROP(1);
break;
default:/* invalid variable type */
exerrval = EX_BADPARAM;
sprintf(errmsg, "Error: Invalid type specified in file id %d", exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return(EX_FATAL);
}
/* Determine if there are any 'obj-type' objects */
if ((status = nc_inq_dimid (exoid, ex_dim_num_objects(obj_type), &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no %s defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_WARN);
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, varidobj, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s ids variable in file id %d",
ex_name_of_object(obj_type),exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the element block ids */
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
status = nc_get_var_longlong(exoid, varid, ids);
} else {
status = nc_get_var_int(exoid, varid, ids);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to return %s ids in file id %d",
ex_name_of_object(obj_type),exoid);
ex_err("ex_get_ids",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
int ex_inquire (int exoid,
int req_info,
int *ret_int,
void *ret_float,
char *ret_char)
{
int dimid, varid, tmp_num, *ids;
size_t ldum = 0;
size_t num_sets, idum, i;
int *stat_vals;
char errmsg[MAX_ERR_LENGTH];
int status;
exerrval = 0; /* clear error code */
switch (req_info)
{
case EX_INQ_FILE_TYPE:
/* obsolete call */
/*returns "r" for regular EXODUS II file or "h" for history EXODUS file*/
*ret_char = '\0';
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: file type inquire is obsolete");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_WARN);
case EX_INQ_API_VERS:
/* returns the EXODUS II API version number */
if (nc_get_att_float(exoid, NC_GLOBAL, ATT_API_VERSION, ret_float) != NC_NOERR)
{ /* try old (prior to db version 2.02) attribute name */
if ((status = nc_get_att_float (exoid, NC_GLOBAL, ATT_API_VERSION_BLANK,ret_float)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get EXODUS API version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
break;
case EX_INQ_DB_VERS:
/* returns the EXODUS II database version number */
if ((status = nc_get_att_float (exoid, NC_GLOBAL, ATT_VERSION, ret_float)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get EXODUS database version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_LIB_VERS:
/* returns the EXODUS II Library version number */
if (ret_float)
flt_cvt((float *)ret_float, EX_API_VERS);
if (ret_int)
*ret_int = EX_API_VERS_NODOT;
break;
case EX_INQ_TITLE:
/* returns the title of the database */
if ((status = nc_get_att_text (exoid, NC_GLOBAL, ATT_TITLE, ret_char)) != NC_NOERR) {
*ret_char = '\0';
exerrval = status;
sprintf(errmsg,
"Error: failed to get database title for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_DIM:
/* returns the dimensionality (2 or 3, for 2-d or 3-d) of the database */
if (ex_get_dimension(exoid, DIM_NUM_DIM, "database dimensionality", &ldum, &dimid, "ex_inquire") != NC_NOERR)
return EX_FATAL;
*ret_int = ldum;
break;
case EX_INQ_NODES:
/* returns the number of nodes */
if (ex_get_dimension(exoid, DIM_NUM_NODES, "nodes", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_ELEM:
/* returns the number of elements */
if (ex_get_dimension(exoid, DIM_NUM_ELEM, "elements", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_ELEM_BLK:
/* returns the number of element blocks */
if (ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element blocks", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NODE_SETS:
/* returns the number of node sets */
if (ex_get_dimension(exoid, DIM_NUM_NS, "node sets", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NS_NODE_LEN:
/* returns the length of the concatenated node sets node list */
EX_GET_CONCAT_SET_LEN(ret_int,"node",EX_NODE_SET,DIM_NUM_NS,VAR_NS_STAT,DIM_NUM_NOD_NS,0);
break;
case EX_INQ_NS_DF_LEN:
/* returns the length of the concatenated node sets dist factor list */
/*
Determine the concatenated node sets distribution factor length:
1. Get the node set ids list.
2. Check see if the dist factor variable for a node set id exists.
3. If it exists, goto step 4, else the length is zero.
4. Get the dimension of the number of nodes in the node set -0
use this value as the length as by definition they are the same.
5. Sum the individual lengths for the total list length.
*/
*ret_int = 0; /* default value if no node sets defined */
if (nc_inq_dimid (exoid, DIM_NUM_NS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int))))
{
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for node set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_node_set_ids (exoid, ids) == EX_FATAL)
{
sprintf(errmsg,
"Error: failed to get node sets in file id %d",
exoid);
/* pass back error code from ex_get_node_set_ids (in exerrval) */
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++) {
if ((status = nc_inq_varid (exoid, VAR_FACT_NS(i+1), &varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) {
idum = 0; /* this dist factor doesn't exist */
} else {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist fact for node set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimid (exoid, DIM_NUM_NOD_NS(i+1), &dimid)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in node set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen (exoid, dimid, &idum)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in node set %d in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
}
*ret_int += idum;
}
free(ids);
}
break;
case EX_INQ_SIDE_SETS:
/* returns the number of side sets */
if (ex_get_dimension(exoid, DIM_NUM_SS, "side sets", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_SS_NODE_LEN:
/* returns the length of the concatenated side sets node list */
*ret_int = 0; /* default return value */
if (nc_inq_dimid (exoid, DIM_NUM_SS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL) {
sprintf(errmsg,
"Error: failed to get side set ids in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
free (ids);
sprintf(errmsg,
"Error: failed to allocate memory for side set status array for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((status = nc_inq_varid (exoid, VAR_SS_STAT, &varid)) == NC_NOERR) {
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free (ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get element block status array from file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
/* walk id list, get each side set node length and sum for total */
for (i=0; i<num_sets; i++) {
if (stat_vals[i] == 0) /* is this object null? */
continue;
if ((status = ex_get_side_set_node_list_len(exoid, ids[i], &tmp_num)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to side set %d node length in file id %d",
ids[i],exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(stat_vals);
free(ids);
return (EX_FATAL);
}
*ret_int += tmp_num;
}
free(stat_vals);
free (ids);
}
break;
case EX_INQ_SS_ELEM_LEN:
/* returns the length of the concatenated side sets element list */
EX_GET_CONCAT_SET_LEN(ret_int,"side",EX_SIDE_SET,DIM_NUM_SS,VAR_SS_STAT,DIM_NUM_SIDE_SS,0);
break;
case EX_INQ_SS_DF_LEN:
/* returns the length of the concatenated side sets dist factor list */
/*
Determine the concatenated side sets distribution factor length:
1. Get the side set ids list.
2. Check see if the dist factor dimension for a side set id exists.
3. If it exists, goto step 4, else set the individual length to zero.
4. Sum the dimension value into the running total length.
*/
*ret_int = 0;
/* first check see if any side sets exist */
if (nc_inq_dimid (exoid, DIM_NUM_SS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen (exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL) {
sprintf(errmsg,
"Error: failed to get side sets in file id %d",
exoid);
/* pass back error code from ex_get_side_set_ids (in exerrval) */
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++) {
if ((status = nc_inq_dimid (exoid, DIM_NUM_DF_SS(i+1), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
ldum = 0; /* this dist factor doesn't exist */
} else {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist fact for side set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &ldum)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of dist factors in side set %d in file id %d",
ids[i], exoid);
ex_err("ex_inquire",errmsg,exerrval);
free (ids);
return (EX_FATAL);
}
}
*ret_int += ldum;
}
free (ids);
}
break;
case EX_INQ_QA:
/* returns the number of QA records */
if (ex_get_dimension(exoid, DIM_NUM_QA, "QA records", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_INFO:
/* returns the number of information records */
if (ex_get_dimension(exoid, DIM_NUM_INFO, "info records", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_TIME:
/* returns the number of time steps stored in the database */
if (ex_get_dimension(exoid, DIM_TIME, "time dimension", &ldum, &dimid, "ex_inquire") != NC_NOERR)
return EX_FATAL;
*ret_int = ldum;
break;
case EX_INQ_EB_PROP:
/* returns the number of element block properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_BLOCK);
break;
case EX_INQ_NS_PROP:
/* returns the number of node set properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_SET);
break;
case EX_INQ_SS_PROP:
/* returns the number of side set properties */
*ret_int = ex_get_num_props (exoid, EX_SIDE_SET);
break;
case EX_INQ_ELEM_MAP:
/* returns the number of element maps */
if (ex_get_dimension(exoid, DIM_NUM_EM, "element maps", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_EM_PROP:
/* returns the number of element map properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_MAP);
break;
case EX_INQ_NODE_MAP:
/* returns the number of node maps */
if (ex_get_dimension(exoid, DIM_NUM_NM, "node maps", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NM_PROP:
/* returns the number of node map properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_MAP);
break;
case EX_INQ_EDGE:
/* returns the number of edges (defined across all edge blocks). */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_EDGE, 1);
break;
case EX_INQ_EDGE_BLK:
/* returns the number of edge blocks. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ED_BLK, 1);
break;
case EX_INQ_EDGE_SETS:
/* returns the number of edge sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ES, 1);
break;
case EX_INQ_ES_LEN:
/* returns the length of the concatenated edge set edge list. */
EX_GET_CONCAT_SET_LEN(ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,DIM_NUM_EDGE_ES,0);
break;
case EX_INQ_ES_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,DIM_NUM_DF_ES,1);
break;
case EX_INQ_EDGE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_EDGE_BLOCK );
break;
case EX_INQ_ES_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_EDGE_SET );
break;
case EX_INQ_FACE:
/* returns the number of faces (defined across all face blocks). */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FACE, 1);
break;
case EX_INQ_FACE_BLK:
/* returns the number of face blocks. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FA_BLK, 1);
break;
case EX_INQ_FACE_SETS:
/* returns the number of face sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FS, 1);
break;
case EX_INQ_FS_LEN:
/* returns the length of the concatenated edge set edge list. */
EX_GET_CONCAT_SET_LEN(ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,DIM_NUM_FACE_FS,0);
break;
case EX_INQ_FS_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,DIM_NUM_DF_FS,1);
break;
case EX_INQ_FACE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_FACE_BLOCK );
break;
case EX_INQ_FS_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_FACE_SET );
break;
case EX_INQ_ELEM_SETS:
/* returns the number of element sets. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_ELS, 1);
break;
case EX_INQ_ELS_LEN:
/* returns the length of the concatenated element set element list. */
EX_GET_CONCAT_SET_LEN(ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,DIM_NUM_ELE_ELS,0);
break;
case EX_INQ_ELS_DF_LEN:
/* returns the length of the concatenated element set distribution factor list. */
EX_GET_CONCAT_SET_LEN(ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,DIM_NUM_DF_ELS,1);
break;
case EX_INQ_ELS_PROP:
/* returns the number of integer properties stored for each element set. */
*ret_int = ex_get_num_props( exoid, EX_ELEM_SET );
break;
case EX_INQ_EDGE_MAP:
/* returns the number of edge maps. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_EDM, 1);
break;
case EX_INQ_FACE_MAP:
/* returns the number of face maps. */
EX_GET_DIMENSION_VALUE(ret_int, 0, DIM_NUM_FAM, 1);
break;
default:
*ret_int = 0;
exerrval = EX_FATAL;
sprintf(errmsg, "Error: invalid inquiry %d", req_info);
ex_err("ex_inquire",errmsg,exerrval);
return(EX_FATAL);
}
return (EX_NOERR);
}
int ex_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;
exerrval = 0; /* clear error code */
/* first check if any sets are specified */
if ((status = nc_inq_dimid(exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
exerrval = status;
snprintf(errmsg, MAX_ERR_LENGTH, "Warning: no %ss stored in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_get_set", errmsg, exerrval);
return (EX_WARN);
}
/* Lookup index of set id in VAR_*S_IDS array */
set_id_ndx = ex_id_lkup(exoid, set_type, set_id);
if (exerrval != 0) {
if (exerrval == 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("ex_get_set", errmsg, EX_NULLENTITY);
return (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("ex_get_set", errmsg, exerrval);
return (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) {
exerrval = status;
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("ex_get_set", errmsg, exerrval);
return (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) {
exerrval = status;
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("ex_get_set", errmsg, exerrval);
return (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) {
exerrval = status;
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("ex_get_set", errmsg, exerrval);
return (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) {
exerrval = status;
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("ex_get_set", errmsg, exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
}
int ne_put_elem_var_slab (int neid,
int time_step,
int elem_var_index,
int elem_blk_id,
int start_pos,
int num_vals,
void *elem_var_vals)
{
int status;
int varid, dimid,time_dim, numelbdim, dims[2], elem_blk_id_ndx;
size_t num_elem_blk, num_elem_var, start[2], count[2];
int *elem_var_tab;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* Determine index of elem_blk_id in VAR_ID_EL_BLK array */
if ((elem_blk_id_ndx = ex_id_lkup(neid, EX_ELEM_BLOCK, elem_blk_id)) < 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no variables allowed for NULL block %d in file id %d",
elem_blk_id, neid);
ex_err("ne_put_elem_var_slab", errmsg, EX_MSG);
return (EX_WARN);
} else {
sprintf(errmsg,
"Error: failed to locate element block id %d in %s array in file id %d",
elem_blk_id, VAR_ID_EL_BLK, neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
}
if ((status = nc_inq_varid (neid,
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx), &varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) { /* variable doesn't exist, create it! */
/* inquire previously defined dimensions */
/* check for the existance of an element variable truth table */
if ((status = nc_inq_varid (neid, VAR_ELEM_TAB, &varid)) == NC_NOERR) {
/* find out number of element blocks and element variables */
if ((status = nc_inq_dimid (neid, DIM_NUM_EL_BLK, &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of element blocks in file id %d",
neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(neid, dimid, &num_elem_blk)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of element blocks in file id %d",
neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimid (neid, DIM_NUM_ELE_VAR, &dimid)) != NC_NOERR) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: no element variables stored in file id %d",
neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(neid, dimid, &num_elem_var)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of element variables in file id %d",
neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if (!(elem_var_tab =
(int *)malloc(num_elem_blk*num_elem_var*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for element variable truth table in file id %d",
neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
/* read in the element variable truth table */
if ((status = nc_get_var_int(neid, varid, elem_var_tab)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get truth table from file id %d", neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
if (elem_var_tab[num_elem_var*(elem_blk_id_ndx-1)+elem_var_index-1] == 0L) {
free(elem_var_tab);
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid element variable %d, block %d in file id %d",
elem_var_index, elem_blk_id, neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
free(elem_var_tab);
}
if ((status = nc_inq_dimid (neid, DIM_TIME, &time_dim)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate time dimension in file id %d", neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
goto error_ret; /* exit define mode and return */
}
if ((status = nc_inq_dimid(neid, DIM_NUM_EL_IN_BLK(elem_blk_id_ndx), &numelbdim)) != NC_NOERR) {
if (status == NC_EBADDIM) {
exerrval = status;
sprintf(errmsg,
"Error: number of elements in element block %d not defined in file id %d",
elem_blk_id, neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of elements in element block %d in file id %d",
elem_blk_id, neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
}
goto error_ret;
}
/* variable doesn't exist so put file into define mode */
if ((status = nc_redef (neid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode", neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
/* define netCDF variable to store element variable values */
dims[0] = time_dim;
dims[1] = numelbdim;
if ((status = nc_def_var(neid, VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx),
nc_flt_code(neid), 2, dims, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define element variable %d in file id %d",
elem_var_index, neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
goto error_ret;
}
/* leave define mode */
if ((status = nc_enddef(neid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete element variable %s definition to file id %d",
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx), neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
} else {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate element variable %s in file id %d",
VAR_ELEM_VAR(elem_var_index, elem_blk_id_ndx),neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
}
/* store element variable values */
start[0] = --time_step;
start[1] = --start_pos;
count[0] = 1;
count[1] = num_vals;
if (ex_comp_ws(neid) == 4) {
status = nc_put_vara_float(neid, varid, start, count, elem_var_vals);
} else {
status = nc_put_vara_double(neid, varid, start, count, elem_var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store element variable %d in file id %d",
elem_var_index, neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef (neid) != NC_NOERR) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d", neid);
ex_err("ne_put_elem_var_slab", errmsg, exerrval);
}
return (EX_FATAL);
}
int ex_id_lkup( int exoid,
ex_entity_type id_type,
ex_entity_id num)
{
char id_table[MAX_VAR_NAME_LENGTH+1];
char id_dim[MAX_VAR_NAME_LENGTH+1];
char stat_table[MAX_VAR_NAME_LENGTH+1];
int varid, dimid;
size_t dim_len, i;
int64_t *id_vals=NULL;
int *stat_vals=NULL;
static int filled=FALSE;
struct obj_stats *tmp_stats;
int status;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
switch(id_type) {
case EX_NODAL:
return 0;
case EX_GLOBAL:
return 0;
case EX_ELEM_BLOCK:
strcpy(id_table, VAR_ID_EL_BLK); /* id array name */
strcpy(id_dim, DIM_NUM_EL_BLK); /* id array dimension name*/
strcpy(stat_table, VAR_STAT_EL_BLK); /* id status array name */
tmp_stats = ex_get_stat_ptr (exoid, &exoII_eb);
break;
case EX_NODE_SET:
strcpy(id_table, VAR_NS_IDS);
strcpy(id_dim, DIM_NUM_NS);
strcpy(stat_table, VAR_NS_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_ns);
break;
case EX_SIDE_SET:
strcpy(id_table, VAR_SS_IDS);
strcpy(id_dim, DIM_NUM_SS);
strcpy(stat_table, VAR_SS_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_ss);
break;
case EX_ELEM_MAP:
strcpy(id_table, VAR_EM_PROP(1));
strcpy(id_dim, DIM_NUM_EM);
strcpy(stat_table, "");
tmp_stats = ex_get_stat_ptr (exoid, &exoII_em);
break;
case EX_NODE_MAP:
strcpy(id_table, VAR_NM_PROP(1));
strcpy(id_dim, DIM_NUM_NM);
strcpy(stat_table, "");
tmp_stats = ex_get_stat_ptr (exoid, &exoII_nm);
break;
case EX_EDGE_BLOCK:
strcpy(id_table, VAR_ID_ED_BLK);
strcpy(id_dim, DIM_NUM_ED_BLK);
strcpy(stat_table, VAR_STAT_ED_BLK);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_ed);
break;
case EX_FACE_BLOCK:
strcpy(id_table, VAR_ID_FA_BLK);
strcpy(id_dim, DIM_NUM_FA_BLK);
strcpy(stat_table, VAR_STAT_FA_BLK);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_fa);
break;
case EX_EDGE_SET:
strcpy(id_table, VAR_ES_IDS);
strcpy(id_dim, DIM_NUM_ES);
strcpy(stat_table, VAR_ES_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_es);
break;
case EX_FACE_SET:
strcpy(id_table, VAR_FS_IDS);
strcpy(id_dim, DIM_NUM_FS);
strcpy(stat_table, VAR_FS_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_fs);
break;
case EX_ELEM_SET:
strcpy(id_table, VAR_ELS_IDS);
strcpy(id_dim, DIM_NUM_ELS);
strcpy(stat_table, VAR_ELS_STAT);
tmp_stats = ex_get_stat_ptr (exoid, &exoII_els);
break;
case EX_EDGE_MAP:
strcpy(id_table, VAR_EDM_PROP(1));
strcpy(id_dim, DIM_NUM_EDM);
strcpy(stat_table, "");
tmp_stats = ex_get_stat_ptr (exoid, &exoII_edm);
break;
case EX_FACE_MAP:
strcpy(id_table, VAR_FAM_PROP(1));
strcpy(id_dim, DIM_NUM_FAM);
strcpy(stat_table, "");
tmp_stats = ex_get_stat_ptr (exoid, &exoII_fam);
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: unsupported id array type %d for file id %d",
id_type, exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
if ( (tmp_stats->id_vals == NULL) || (!(tmp_stats->valid_ids)) ) {
/* first time thru or id arrays haven't been completely filled yet */
/* get size of id array */
/* First get dimension id of id array */
if ((status = nc_inq_dimid(exoid,id_dim,&dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate id array dimension in file id %d",
exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
/* Next get value of dimension */
if ((status = nc_inq_dimlen(exoid,dimid,&dim_len)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s array length in file id %d",
id_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of id array */
if ((status = nc_inq_varid (exoid, id_table, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate %s array in file id %d",
id_table, exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
/* allocate space for id array 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;
sprintf(errmsg,
"Error: failed to allocate memory for %s array for file id %d",
id_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
if (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;
sprintf(errmsg,
"Error: failed to allocate memory for temporary array id_vals_int for file id %d",
exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
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;
sprintf(errmsg,
"Error: failed to get %s array from file id %d",
id_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
free(id_vals);
return (EX_FATAL);
}
/* check if values in stored arrays are filled with non-zeroes */
filled = TRUE;
for (i=0;i<dim_len;i++) {
if (id_vals[i] == EX_INVALID_ID || id_vals[i] == NC_FILL_INT) {
filled = FALSE;
break; /* id array hasn't been completely filled with valid ids yet */
}
}
if (filled) {
tmp_stats->valid_ids = TRUE;
tmp_stats->num = 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;
sprintf(errmsg,
"Error: failed to allocate memory for %s array for file id %d",
id_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_get_var_int (exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to get %s array from file id %d",
stat_table,exoid);
ex_err("ex_id_lkup",errmsg,exerrval);
return (EX_FATAL);
}
if (tmp_stats->valid_ids) {
/* status array is valid only if ids are valid */
tmp_stats->valid_stat = TRUE;
tmp_stats->stat_vals = stat_vals;
}
} else {
stat_vals = tmp_stats->stat_vals;
}
if (stat_vals[i] == 0) /* is this object null? */ {
exerrval = EX_NULLENTITY;
if ( !(tmp_stats->valid_stat) ) {
free (stat_vals);
}
if ( !(tmp_stats->valid_ids) ) {
if (id_vals) free (id_vals);
}
return(-((int)i+1)); /* return index into id array (1-based) */
}
}
if ( !(tmp_stats->valid_ids) ) {
if (id_vals) free (id_vals);
if (stat_vals) free (stat_vals);
}
return(i+1); /* return index into id array (1-based) */
}
int ex_get_conn( int exoid,
ex_entity_type blk_type,
int blk_id,
int* nodeconn,
int* edgeconn,
int* faceconn )
{
int connid, econnid, fconnid, blk_id_ndx, status;
int numnodperentdim, numedgperentdim, numfacperentdim;
int iexit = (EX_NOERR); /* exit status */
size_t num_nodes_per_entry, num_edges_per_entry, num_faces_per_entry;
char errmsg[MAX_ERR_LENGTH];
const char* dnumnodent;
const char* dnumedgent;
const char* dnumfacent;
const char* vnodeconn;
const char* vedgeconn;
const char* vfaceconn;
/* 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)
{
sprintf(errmsg,
"Warning: no connectivity array for NULL %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg,EX_MSG);
return (EX_WARN); /* no connectivity array for this element block */
}
else
{
sprintf(errmsg,
"Error: failed to locate %s id %d 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;
sprintf(errmsg,
"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 ((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;
sprintf(errmsg,
"Error: failed to get number of nodes/entity for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
if ( 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;
sprintf(errmsg,
"Error: failed to get number of edges/entry for %s %d in file id %d",
ex_name_of_object(blk_type),blk_id,exoid);
ex_err("ex_get_conn",errmsg, exerrval);
return(EX_FATAL);
}
}
}
if ( 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;
sprintf(errmsg,
"Error: failed to get number of faces/entry for %s %d 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;
sprintf(errmsg,
"Error: failed to locate node connectivity array for %s %d 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;
sprintf(errmsg,
"Error: failed to locate edge connectivity array for %s %d 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;
sprintf(errmsg,
"Error: failed to locate face connectivity array for %s %d 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) {
status = nc_get_var_int(exoid, econnid, edgeconn);
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get edge connectivity array for %s %d 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) {
status = nc_get_var_int(exoid, fconnid, faceconn);
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get face connectivity array for %s %d 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) {
status = nc_get_var_int(exoid, connid, nodeconn);
if (status != NC_NOERR)
{
exerrval = status;
sprintf(errmsg,
"Error: failed to get node connectivity array for %s %d 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 main(int argc, char* argv[])
{
int i, j, rank, nprocs, ncid, cmode, varid[NVARS], dimid[2], *buf;
int err = 0;
char str[32];
size_t start[2], count[2];
MPI_Comm comm=MPI_COMM_SELF;
MPI_Info info=MPI_INFO_NULL;
printf("\n*** Testing bug fix with changing pnetcdf variable offsets...");
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if (nprocs > 1 && rank == 0)
printf("This test program is intended to run on ONE process\n");
if (rank > 0) goto fn_exit;
/* first, use PnetCDF to create a file with default header/variable alignment */
#ifdef DISABLE_PNETCDF_ALIGNMENT
MPI_Info_create(&info);
MPI_Info_set(info, "nc_header_align_size", "1");
MPI_Info_set(info, "nc_var_align_size", "1");
#endif
cmode = NC_PNETCDF | NC_CLOBBER;
if (nc_create_par(FILENAME, cmode, comm, info, &ncid)) ERR_RET;
/* define dimension */
if (nc_def_dim(ncid, "Y", NC_UNLIMITED, &dimid[0])) ERR;
if (nc_def_dim(ncid, "X", NX, &dimid[1])) ERR;
/* Odd numbers are fixed variables, even numbers are record variables */
for (i=0; i<NVARS; i++) {
if (i%2) {
sprintf(str,"fixed_var_%d",i);
if (nc_def_var(ncid, str, NC_INT, 1, dimid+1, &varid[i])) ERR;
}
else {
sprintf(str,"record_var_%d",i);
if (nc_def_var(ncid, str, NC_INT, 2, dimid, &varid[i])) ERR;
}
}
if (nc_enddef(ncid)) ERR;
for (i=0; i<NVARS; i++) {
/* Note NC_INDEPENDENT is the default */
if (nc_var_par_access(ncid, varid[i], NC_INDEPENDENT)) ERR;
}
/* write all variables */
buf = (int*) malloc(NX * sizeof(int));
for (i=0; i<NVARS; i++) {
for (j=0; j<NX; j++) buf[j] = i*10 + j;
if (i%2) {
start[0] = 0; count[0] = NX;
if (nc_put_vara_int(ncid, varid[i], start, count, buf)) ERR;
}
else {
start[0] = 0; start[1] = 0;
count[0] = 1; count[1] = NX;
if (nc_put_vara_int(ncid, varid[i], start, count, buf)) ERR;
}
}
if (nc_close(ncid)) ERR;
if (info != MPI_INFO_NULL) MPI_Info_free(&info);
/* re-open the file with netCDF (parallel) and enter define mode */
if (nc_open_par(FILENAME, NC_WRITE|NC_PNETCDF, comm, info, &ncid)) ERR_RET;
if (nc_redef(ncid)) ERR;
/* add attributes to make header grow */
for (i=0; i<NVARS; i++) {
sprintf(str, "annotation_for_var_%d",i);
if (nc_put_att_text(ncid, varid[i], "text_attr", strlen(str), str)) ERR;
}
if (nc_enddef(ncid)) ERR;
/* read variables and check their contents */
for (i=0; i<NVARS; i++) {
for (j=0; j<NX; j++) buf[j] = -1;
if (i%2) {
start[0] = 0; count[0] = NX;
if (nc_get_var_int(ncid, varid[i], buf)) ERR;
for (j=0; j<NX; j++)
if (buf[j] != i*10 + j)
printf("unexpected read value var i=%d buf[j=%d]=%d should be %d\n",i,j,buf[j],i*10+j);
}
else {
start[0] = 0; start[1] = 0;
count[0] = 1; count[1] = NX;
if (nc_get_vara_int(ncid, varid[i], start, count, buf)) ERR;
for (j=0; j<NX; j++)
if (buf[j] != i*10+j)
printf("unexpected read value var i=%d buf[j=%d]=%d should be %d\n",i,j,buf[j],i*10+j);
}
}
if (nc_close(ncid)) ERR;
fn_exit:
MPI_Finalize();
SUMMARIZE_ERR;
FINAL_RESULTS;
return 0;
}
static int ex_get_concat_set_len(int exoid, int64_t *set_length, const char *set_name,
ex_entity_type set_type, const char *set_num_dim,
const char *set_stat_var, const char *set_size_root,
int missing_ok)
{
int i;
int status;
char errmsg[MAX_ERR_LENGTH];
size_t idum;
int dimid, varid;
size_t num_sets;
int *stat_vals = NULL;
*set_length = 0; /* default return value */
if ((status = nc_inq_dimid (exoid, set_num_dim, &dimid)) == NC_NOERR)
{
if ((status = nc_inq_dimlen (exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of %s sets in file id %d",
set_name, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* Allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s set status array for file id %d",
set_name, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((status = nc_inq_varid (exoid, set_stat_var, &varid)) == NC_NOERR) {
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to get %s set status array from file id %d",
set_name, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
} else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
for (i=0; i<num_sets; i++) {
if (stat_vals[i] == 0) /* is this object null? */
continue;
if ((status = nc_inq_dimid (exoid, ex_catstr(set_size_root,i+1), &dimid)) != NC_NOERR) {
if ( missing_ok ) {
idum = 0;
} else {
*set_length = 0;
free(stat_vals);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &idum)) != NC_NOERR) {
*set_length = 0;
free(stat_vals);
return (EX_FATAL);
}
}
*set_length += idum;
}
free(stat_vals);
}
return (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);
}
static int ex_inquire_internal (int exoid,
int req_info,
int64_t *ret_int,
float *ret_float,
char *ret_char)
{
int dimid, varid, tmp_num;
void_int *ids = NULL;
size_t i;
size_t ldum = 0;
size_t num_sets, idum;
int *stat_vals;
char errmsg[MAX_ERR_LENGTH];
int status;
char tmp_title[2048];
exerrval = 0; /* clear error code */
if (ret_char) *ret_char = '\0'; /* Only needs to be non-null for TITLE */
if (!ret_int) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: integer argument is NULL which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
switch (req_info) {
case EX_INQ_FILE_TYPE:
/* obsolete call */
/*returns "r" for regular EXODUS II file or "h" for history EXODUS file*/
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: file type inquire is obsolete");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_WARN);
case EX_INQ_API_VERS:
/* returns the EXODUS II API version number */
if (!ret_float) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: float argument is NULL for EX_INQ_API_VERS which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (nc_get_att_float(exoid, NC_GLOBAL, ATT_API_VERSION, ret_float) != NC_NOERR)
{ /* try old (prior to db version 2.02) attribute name */
if ((status = nc_get_att_float (exoid, NC_GLOBAL, ATT_API_VERSION_BLANK,ret_float)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get EXODUS API version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
break;
case EX_INQ_DB_VERS:
/* returns the EXODUS II database version number */
if (!ret_float) {
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Warning: float argument is NULL for EX_INQ_DB_VERS which is not allowed.");
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_get_att_float (exoid, NC_GLOBAL, ATT_VERSION, ret_float)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get EXODUS database version for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
break;
case EX_INQ_LIB_VERS:
/* returns the EXODUS II Library version number */
if (ret_float)
flt_cvt(ret_float, EX_API_VERS);
*ret_int = EX_API_VERS_NODOT;
break;
case EX_INQ_DB_MAX_ALLOWED_NAME_LENGTH:
/* Return the MAX_NAME_LENGTH size for this database
It will not include the space for the trailing null, so if it
is defined as 33 on the database, 32 will be returned.
*/
if ((status = nc_inq_dimid(exoid, DIM_STR_NAME, &dimid)) != NC_NOERR) {
/* If not found, then an older database */
*ret_int = 32;
}
else {
/* Get the name string length */
size_t name_length = 0;
if ((status = nc_inq_dimlen(exoid,dimid,&name_length)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get name string length in file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
else {
*ret_int = name_length-1;
}
}
break;
case EX_INQ_DB_FLOAT_SIZE:
{
nc_get_att_longlong(exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, (long long*)ret_int);
}
break;
case EX_INQ_DB_MAX_USED_NAME_LENGTH:
/* Return the value of the ATT_MAX_NAME_LENGTH attribute (if it
exists) which is the maximum length of any entity, variable,
attribute, property name written to this database. If the
attribute does not exist, then '32' is returned. The length
does not include the trailing null.
*/
{
nc_type att_type = NC_NAT;
size_t att_len = 0;
*ret_int = 32; /* Default size consistent with older databases */
status = nc_inq_att(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, &att_type, &att_len);
if (status == NC_NOERR && att_type == NC_INT) {
/* The attribute exists, return it... */
nc_get_att_longlong(exoid, NC_GLOBAL, ATT_MAX_NAME_LENGTH, (long long*)ret_int);
}
}
break;
case EX_INQ_MAX_READ_NAME_LENGTH:
{
/* Returns the user-specified maximum size of names that will be
* returned to the user by any of the ex_get_ routines. If the
* name is longer than this value, it will be truncated. The
* default if not set by the client is 32 characters. The value
* does not include the trailing null.
*/
struct ex_file_item* file = ex_find_file_item(exoid);
if (!file ) {
exerrval = EX_BADFILEID;
sprintf(errmsg,"Error: unknown file id %d for ex_inquire_int().",exoid);
ex_err("ex_intquire",errmsg,exerrval);
*ret_int = 0;
}
else {
*ret_int = file->maximum_name_length;
}
}
break;
case EX_INQ_TITLE:
if (!ret_char) {
sprintf(errmsg,
"Error: Requested title, but character pointer was null for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
} else {
/* returns the title of the database */
if ((status = nc_get_att_text (exoid, NC_GLOBAL, ATT_TITLE, tmp_title)) != NC_NOERR) {
*ret_char = '\0';
exerrval = status;
sprintf(errmsg,
"Error: failed to get database title for file id %d", exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
} else {
strncpy(ret_char, tmp_title, MAX_LINE_LENGTH+1);
ret_char[MAX_LINE_LENGTH] = '\0';
}
}
break;
case EX_INQ_DIM:
/* returns the dimensionality (2 or 3, for 2-d or 3-d) of the database */
if (ex_get_dimension(exoid, DIM_NUM_DIM, "database dimensionality", &ldum, &dimid, "ex_inquire") != NC_NOERR)
return EX_FATAL;
*ret_int = ldum;
break;
case EX_INQ_NODES:
/* returns the number of nodes */
if (ex_get_dimension(exoid, DIM_NUM_NODES, "nodes", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_ELEM:
/* returns the number of elements */
if (ex_get_dimension(exoid, DIM_NUM_ELEM, "elements", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_ELEM_BLK:
/* returns the number of element blocks */
if (ex_get_dimension(exoid, DIM_NUM_EL_BLK, "element blocks", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NODE_SETS:
/* returns the number of node sets */
if (ex_get_dimension(exoid, DIM_NUM_NS, "node sets", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NS_NODE_LEN:
/* returns the length of the concatenated node sets node list */
ex_get_concat_set_len(exoid, ret_int,"node",EX_NODE_SET,DIM_NUM_NS,VAR_NS_STAT,"num_nod_ns",0);
break;
case EX_INQ_NS_DF_LEN:
/* returns the length of the concatenated node sets dist factor list */
/*
Determine the concatenated node sets distribution factor length:
2. Check see if the dist factor variable for a node set id exists.
3. If it exists, goto step 4, else the length is zero.
4. Get the dimension of the number of nodes in the node set -0
use this value as the length as by definition they are the same.
5. Sum the individual lengths for the total list length.
*/
*ret_int = 0; /* default value if no node sets defined */
if (nc_inq_dimid (exoid, DIM_NUM_NS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of node sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++) {
if ((status = nc_inq_varid (exoid, VAR_FACT_NS(i+1), &varid)) != NC_NOERR) {
if (status == NC_ENOTVAR) {
idum = 0; /* this dist factor doesn't exist */
} else {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist fact for %"ST_ZU"'th node set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimid (exoid, DIM_NUM_NOD_NS(i+1), &dimid)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of nodes in %"ST_ZU"'th node set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen (exoid, dimid, &idum)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of nodes in %"ST_ZU"'th node set in file id %d",
i,exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
*ret_int += idum;
}
}
break;
case EX_INQ_SIDE_SETS:
/* returns the number of side sets */
if (ex_get_dimension(exoid, DIM_NUM_SS, "side sets", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_SS_NODE_LEN:
/* returns the length of the concatenated side sets node list */
*ret_int = 0; /* default return value */
if (nc_inq_dimid (exoid, DIM_NUM_SS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen(exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (!(ids = malloc(num_sets*sizeof(int64_t)))) { /* May be getting 2x what is needed, but should be OK */
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for side set ids for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
if (ex_get_side_set_ids (exoid, ids) == EX_FATAL) {
sprintf(errmsg,
"Error: failed to get side set ids in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(ids);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_sets*sizeof(int)))) {
exerrval = EX_MEMFAIL;
free (ids);
sprintf(errmsg,
"Error: failed to allocate memory for side set status array for file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if ((status = nc_inq_varid (exoid, VAR_SS_STAT, &varid)) == NC_NOERR) {
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free (ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get element block status array from file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
else /* default: status is true */
for(i=0;i<num_sets;i++)
stat_vals[i]=1;
/* walk id list, get each side set node length and sum for total */
for (i=0; i<num_sets; i++) {
ex_entity_id id;
if (stat_vals[i] == 0) /* is this object null? */
continue;
if (ex_int64_status(exoid) & EX_IDS_INT64_API) {
int64_t tmp_len = 0;
id = ((int64_t*)ids)[i];
status = ex_get_side_set_node_list_len(exoid, id, &tmp_len);
if (status == NC_NOERR) *ret_int += tmp_len;
}
else {
int tmp_len = 0;
id = ((int*)ids)[i];
status = ex_get_side_set_node_list_len(exoid, id, &tmp_len);
if (status == NC_NOERR) *ret_int += tmp_len;
}
if (status != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to side set %"PRId64" node length in file id %d",
id,exoid);
ex_err("ex_inquire",errmsg,exerrval);
free(stat_vals);
free(ids);
return (EX_FATAL);
}
}
free(stat_vals);
free (ids);
}
break;
case EX_INQ_SS_ELEM_LEN:
/* returns the length of the concatenated side sets element list */
ex_get_concat_set_len(exoid, ret_int,"side",EX_SIDE_SET,DIM_NUM_SS,VAR_SS_STAT,"num_side_ss",0);
break;
case EX_INQ_SS_DF_LEN:
/* returns the length of the concatenated side sets dist factor list */
/*
Determine the concatenated side sets distribution factor length:
1. Get the side set ids list.
2. Check see if the dist factor dimension for a side set id exists.
3. If it exists, goto step 4, else set the individual length to zero.
4. Sum the dimension value into the running total length.
*/
*ret_int = 0;
/* first check see if any side sets exist */
if (nc_inq_dimid (exoid, DIM_NUM_SS, &dimid) == NC_NOERR) {
if ((status = nc_inq_dimlen (exoid, dimid, &num_sets)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of side sets in file id %d",
exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
for (i=0; i<num_sets; i++) {
if ((status = nc_inq_dimid (exoid, DIM_NUM_DF_SS(i+1), &dimid)) != NC_NOERR) {
if (status == NC_EBADDIM) {
ldum = 0; /* this dist factor doesn't exist */
} else {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of dist fact for %"ST_ZU"'th side set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
} else {
if ((status = nc_inq_dimlen (exoid, dimid, &ldum)) != NC_NOERR) {
*ret_int = 0;
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of dist factors in %"ST_ZU"'th side set in file id %d",
i, exoid);
ex_err("ex_inquire",errmsg,exerrval);
return (EX_FATAL);
}
}
*ret_int += ldum;
}
}
break;
case EX_INQ_QA:
/* returns the number of QA records */
if (ex_get_dimension(exoid, DIM_NUM_QA, "QA records", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_INFO:
/* returns the number of information records */
if (ex_get_dimension(exoid, DIM_NUM_INFO, "info records", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_TIME:
/* returns the number of time steps stored in the database */
if (ex_get_dimension(exoid, DIM_TIME, "time dimension", &ldum, &dimid, "ex_inquire") != NC_NOERR)
return EX_FATAL;
*ret_int = ldum;
break;
case EX_INQ_EB_PROP:
/* returns the number of element block properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_BLOCK);
break;
case EX_INQ_NS_PROP:
/* returns the number of node set properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_SET);
break;
case EX_INQ_SS_PROP:
/* returns the number of side set properties */
*ret_int = ex_get_num_props (exoid, EX_SIDE_SET);
break;
case EX_INQ_ELEM_MAP:
/* returns the number of element maps */
if (ex_get_dimension(exoid, DIM_NUM_EM, "element maps", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_EM_PROP:
/* returns the number of element map properties */
*ret_int = ex_get_num_props (exoid, EX_ELEM_MAP);
break;
case EX_INQ_NODE_MAP:
/* returns the number of node maps */
if (ex_get_dimension(exoid, DIM_NUM_NM, "node maps", &ldum, &dimid, NULL) != NC_NOERR)
*ret_int = 0;
else
*ret_int = ldum;
break;
case EX_INQ_NM_PROP:
/* returns the number of node map properties */
*ret_int = ex_get_num_props (exoid, EX_NODE_MAP);
break;
case EX_INQ_EDGE:
/* returns the number of edges (defined across all edge blocks). */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_EDGE, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_EDGE_BLK:
/* returns the number of edge blocks. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ED_BLK, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_EDGE_SETS:
/* returns the number of edge sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ES, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_ES_LEN:
/* returns the length of the concatenated edge set edge list. */
ex_get_concat_set_len(exoid, ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,"num_edge_es",0);
break;
case EX_INQ_ES_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"edge",EX_EDGE_SET,DIM_NUM_ES,VAR_ES_STAT,"num_df_es",1);
break;
case EX_INQ_EDGE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_EDGE_BLOCK );
break;
case EX_INQ_ES_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_EDGE_SET );
break;
case EX_INQ_FACE:
/* returns the number of faces (defined across all face blocks). */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FACE, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_BLK:
/* returns the number of face blocks. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FA_BLK, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_SETS:
/* returns the number of face sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FS, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FS_LEN:
/* returns the length of the concatenated edge set edge list. */
ex_get_concat_set_len(exoid, ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,"num_face_fs",0);
break;
case EX_INQ_FS_DF_LEN:
/* returns the length of the concatenated edge set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"face",EX_FACE_SET,DIM_NUM_FS,VAR_FS_STAT,"num_df_fs",1);
break;
case EX_INQ_FACE_PROP:
/* returns the number of integer properties stored for each edge block. This includes the "ID" property. */
*ret_int = ex_get_num_props( exoid, EX_FACE_BLOCK );
break;
case EX_INQ_FS_PROP:
/* returns the number of integer properties stored for each edge set.. This includes the "ID" property */
*ret_int = ex_get_num_props( exoid, EX_FACE_SET );
break;
case EX_INQ_ELEM_SETS:
/* returns the number of element sets. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_ELS, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_ELS_LEN:
/* returns the length of the concatenated element set element list. */
ex_get_concat_set_len(exoid, ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,"num_ele_els",0);
break;
case EX_INQ_ELS_DF_LEN:
/* returns the length of the concatenated element set distribution factor list. */
ex_get_concat_set_len(exoid, ret_int,"element",EX_ELEM_SET,DIM_NUM_ELS,VAR_ELS_STAT,"num_df_els",1);
break;
case EX_INQ_ELS_PROP:
/* returns the number of integer properties stored for each element set. */
*ret_int = ex_get_num_props( exoid, EX_ELEM_SET );
break;
case EX_INQ_EDGE_MAP:
/* returns the number of edge maps. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_EDM, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_FACE_MAP:
/* returns the number of face maps. */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_FAM, 1) != EX_NOERR) return EX_FATAL;
break;
case EX_INQ_COORD_FRAMES:
/* return the number of coordinate frames */
if (ex_get_dimension_value(exoid, ret_int, 0, DIM_NUM_CFRAMES, 1) != EX_NOERR) return EX_FATAL;
break;
default:
*ret_int = 0;
exerrval = EX_FATAL;
sprintf(errmsg, "Error: invalid inquiry %d", req_info);
ex_err("ex_inquire",errmsg,exerrval);
return(EX_FATAL);
}
return (EX_NOERR);
}
int ex_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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to put file ID %d into define mode", exoid);
ex_err(func_name, errmsg, exerrval);
return (EX_FATAL);
}
/*
* 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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH, "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;
snprintf(errmsg, MAX_ERR_LENGTH,
"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;
snprintf(errmsg, MAX_ERR_LENGTH, "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 ncid, varid;
int ncstat = NC_NOERR;
char url[8102];
const char* topsrcdir;
#ifndef USE_NETCDF4
int i,j;
#endif
/* location of our target url: use file:// to avoid remote
server downtime issues
*/
topsrcdir = gettopsrcdir();
url[0] = '\0';
#ifdef DEBUG
strlcat(url,"[log][show=fetch]",sizeof(url));
#endif
strlcat(url,"file://",sizeof(url));
strlcat(url,topsrcdir,sizeof(url));
strlcat(url,"/ncdap_test/testdata3/test.02",sizeof(url));
printf("*** Test: var conversions on URL: %s\n",url);
/* open file, get varid */
CHECK(nc_open(url, NC_NOWRITE, &ncid));
/* extract the string case for netcdf-3*/
#ifndef USE_NETCDF4
CHECK(nc_inq_varid(ncid, "s", &varid));
CHECK(nc_get_var_text(ncid,varid,(char*)string3));
#ifdef GENERATE
printf("static %s string3_data[DIMSIZE][STRLEN]={","char");
for(i=0;i<DIMSIZE;i++) {
int j;
/* Do simple escape */
for(j=0;j<STRLEN;j++) {
if(string3[i][j] > 0
&& string3[i][j] != '\n'
&& string3[i][j] != '\r'
&& string3[i][j] != '\t'
&&(string3[i][j] < ' ' || string3[i][j] >= '\177'))
string3[i][j] = '?';
}
printf("%s\"%s\"",COMMA,string3[i]);
}
printf("};\n");
#else
fprintf(stdout,"*** testing: %s\n","string3");
for(i=0;i<DIMSIZE;i++) {
for(j=0;j<STRLEN;j++) {
if(string3[i][j] != string3_data[i][j]) {report(i,"string3",__LINE__); break;}
}
}
#endif
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_text(ncid,varid,ch));
#ifdef GENERATE
printf("static %s ch_data[DIMSIZE]={","char");
for(i=0;i<DIMSIZE;i++) printf("%s'\\%03hho'",COMMA,ch[i]);
printf("};\n");
#else
COMPARE(NC_CHAR,NC_CHAR,ch,ch_data);
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_schar(ncid,varid,int8v));
#ifdef GENERATE
printf("static %s int8_data[DIMSIZE]={","signed char");
for(i=0;i<DIMSIZE;i++) printf("%s%hhd",COMMA,int8v[i]);
printf("};\n");
#else
COMPARE(NC_BYTE,NC_BYTE,int8v,int8_data);
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_uchar(ncid,varid,uint8v));
#ifdef GENERATE
printf("static %s uint8_data[DIMSIZE]={","unsigned char");
for(i=0;i<DIMSIZE;i++) printf("%s%hhu",COMMA,uint8v[i]);
printf("};\n");
#else
COMPARE(NC_UBYTE,NC_UBYTE,uint8v,uint8_data);
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_int(ncid,varid,int32v));
#ifdef GENERATE
printf("static %s int8toint32_data[DIMSIZE]={","int");
for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
printf("};\n");
#else
COMPARE(NC_BYTE,NC_INT,int32v,int8toint32_data);
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_float(ncid,varid,float32v));
#ifdef GENERATE
printf("static %s int82float32_data[DIMSIZE]={","float");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
printf("};\n");
#else
COMPARE(NC_FLOAT,NC_FLOAT,float32v,int82float32_data);
#endif
CHECK(nc_inq_varid(ncid, "i16", &varid));
CHECK(nc_get_var_short(ncid,varid,int16v));
#ifdef GENERATE
printf("static %s int16_data[DIMSIZE]={","short");
for(i=0;i<DIMSIZE;i++) printf("%s%hd",COMMA,int16v[i]);
printf("};\n");
#else
COMPARE(NC_SHORT,NC_SHORT,int16v,int16_data);
#endif
CHECK(nc_inq_varid(ncid, "i16", &varid));
CHECK(nc_get_var_int(ncid,varid,int32v));
#ifdef GENERATE
printf("static %s int16toint32_data[DIMSIZE]={","int");
for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
printf("};\n");
#else
COMPARE(NC_SHORT,NC_INT,int32v,int16toint32_data);
#endif
CHECK(nc_inq_varid(ncid, "i16", &varid));
CHECK(nc_get_var_float(ncid,varid,float32v));
#ifdef GENERATE
printf("static %s int162float32_data[DIMSIZE]={","float");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
printf("};\n");
#else
COMPARE(NC_SHORT,NC_FLOAT,float32v,int162float32_data);
#endif
CHECK(nc_inq_varid(ncid, "i32", &varid));
CHECK(nc_get_var_int(ncid,varid,int32v));
#ifdef GENERATE
printf("static %s int32_data[DIMSIZE]={","int");
for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32v[i]);
printf("};\n");
#else
COMPARE(NC_INT,NC_INT,int32v,int32_data);
#endif
CHECK(nc_inq_varid(ncid, "i32", &varid));
CHECK(nc_get_var_float(ncid,varid,float32v));
#ifdef GENERATE
printf("static %s int32tofloat32_data[DIMSIZE]={","float");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
printf("};\n");
#else
COMPARE(NC_INT,NC_FLOAT,float32v,int32tofloat32_data);
#endif
CHECK(nc_inq_varid(ncid, "i32", &varid));
CHECK(nc_get_var_long(ncid,varid,ilong));
#ifdef GENERATE
printf("static %s int32toilong_data[DIMSIZE]={","long");
for(i=0;i<DIMSIZE;i++) printf("%s%ld",COMMA,ilong[i]);
printf("};\n");
#else
COMPARE(NC_INT,NC_NAT,ilong,int32toilong_data);
#endif
CHECK(nc_inq_varid(ncid, "f32", &varid));
CHECK(nc_get_var_float(ncid,varid,float32v));
#ifdef GENERATE
printf("static %s float32_data[DIMSIZE]={","float");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32v[i]);
printf("};\n");
#else
COMPARE(NC_FLOAT,NC_FLOAT,float32v,float32_data);
#endif
CHECK(nc_inq_varid(ncid, "f64", &varid));
CHECK(nc_get_var_double(ncid,varid,float64v));
#ifdef GENERATE
printf("static %s float64_data[DIMSIZE]={","double");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float64v[i]);
printf("};\n");
#else
COMPARE(NC_DOUBLE,NC_DOUBLE,float64v,float64_data);
#endif
if(failure) {
printf("ncstat=%d %s",ncstat,nc_strerror(ncstat));
exit(1);
}
nc_close(ncid);
return 0;
}
int main()
{
int ncid, varid;
int ncstat = NC_NOERR;
char* url;
char* topsrcdir;
size_t len;
#ifndef USE_NETCDF4
int i,j;
#endif
/* location of our target url: use file// to avoid remote
server downtime issues
*/
/* Assume that TESTS_ENVIRONMENT was set */
topsrcdir = getenv("TOPSRCDIR");
if(topsrcdir == NULL) {
fprintf(stderr,"*** FAIL: $abs_top_srcdir not defined: location= %s:%d\n",__FILE__,__LINE__);
exit(1);
}
len = strlen("file://") + strlen(topsrcdir) + strlen("/ncdap_test/testdata3/test.02") + 1;
#ifdef DEBUG
len += strlen("[log][show=fetch]");
#endif
url = (char*)malloc(len);
url[0] = '\0';
#ifdef DEBUG
strcat(url,"[log][show=fetch]");
#endif
strcat(url,"file://");
strcat(url,topsrcdir);
strcat(url,"/ncdap_test/testdata3/test.02");
printf("*** Test: var conversions on URL: %s\n",url);
/* open file, get varid */
CHECK(nc_open(url, NC_NOWRITE, &ncid));
/* extract the string case for netcdf-3*/
#ifndef USE_NETCDF4
CHECK(nc_inq_varid(ncid, "s", &varid));
CHECK(nc_get_var_text(ncid,varid,(char*)string3_tst));
#ifdef GENERATE
printf("static %s string3_data[DIMSIZE][STRLEN]={","char");
for(i=0;i<DIMSIZE;i++) {
int j;
/* Do simple escape */
for(j=0;j<STRLEN;j++) {
if(string3_tst[i][j] > 0
&& string3_tst[i][j] != '\n'
&& string3_tst[i][j] != '\r'
&& string3_tst[i][j] != '\t'
&&(string3_tst[i][j] < ' ' || string3_tst[i][j] >= '\177'))
string3_tst[i][j] = '?';
}
printf("%s\"%s\"",COMMA,string3_tst[i]);
}
printf("};\n");
#else
fprintf(stdout,"*** testing: %s\n","string3");
for(i=0;i<DIMSIZE;i++) {
for(j=0;j<STRLEN;j++) {
if(string3_tst[i][j] != string3_data[i][j]) {report(i,"string3",__LINE__); break;}
}
}
#endif
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_text(ncid,varid,ch_tst));
#ifdef GENERATE
printf("static %s ch_data[DIMSIZE]={","char");
for(i=0;i<DIMSIZE;i++) printf("%s'\\%03hho'",COMMA,ch_tst[i]);
printf("};\n");
#else
COMPARE(NC_CHAR,NC_CHAR,ch_tst,ch_data);
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_schar(ncid,varid,int8_tst));
#ifdef GENERATE
printf("static %s int8_data[DIMSIZE]={","signed char");
for(i=0;i<DIMSIZE;i++) printf("%s%hhd",COMMA,int8_tst[i]);
printf("};\n");
#else
COMPARE(NC_BYTE,NC_BYTE,int8_tst,int8_data);
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_uchar(ncid,varid,uint8_tst));
#ifdef GENERATE
printf("static %s uint8_data[DIMSIZE]={","unsigned char");
for(i=0;i<DIMSIZE;i++) printf("%s%hhu",COMMA,uint8_tst[i]);
printf("};\n");
#else
COMPARE(NC_UBYTE,NC_UBYTE,uint8_tst,uint8_data);
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_int(ncid,varid,int32_tst));
#ifdef GENERATE
printf("static %s int8toint32_data[DIMSIZE]={","int");
for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32_tst[i]);
printf("};\n");
#else
COMPARE(NC_BYTE,NC_INT,int32_tst,int8toint32_data);
#endif
CHECK(nc_inq_varid(ncid, "b", &varid));
CHECK(nc_get_var_float(ncid,varid,float32_tst));
#ifdef GENERATE
printf("static %s int82float32_data[DIMSIZE]={","float");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32_tst[i]);
printf("};\n");
#else
COMPARE(NC_FLOAT,NC_FLOAT,float32_tst,int82float32_data);
#endif
CHECK(nc_inq_varid(ncid, "i16", &varid));
CHECK(nc_get_var_short(ncid,varid,int16_tst));
#ifdef GENERATE
printf("static %s int16_data[DIMSIZE]={","short");
for(i=0;i<DIMSIZE;i++) printf("%s%hd",COMMA,int16_tst[i]);
printf("};\n");
#else
COMPARE(NC_SHORT,NC_SHORT,int16_tst,int16_data);
#endif
CHECK(nc_inq_varid(ncid, "i16", &varid));
CHECK(nc_get_var_int(ncid,varid,int32_tst));
#ifdef GENERATE
printf("static %s int16toint32_data[DIMSIZE]={","int");
for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32_tst[i]);
printf("};\n");
#else
COMPARE(NC_SHORT,NC_INT,int32_tst,int16toint32_data);
#endif
CHECK(nc_inq_varid(ncid, "i16", &varid));
CHECK(nc_get_var_float(ncid,varid,float32_tst));
#ifdef GENERATE
printf("static %s int162float32_data[DIMSIZE]={","float");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32_tst[i]);
printf("};\n");
#else
COMPARE(NC_SHORT,NC_FLOAT,float32_tst,int162float32_data);
#endif
CHECK(nc_inq_varid(ncid, "i32", &varid));
CHECK(nc_get_var_int(ncid,varid,int32_tst));
#ifdef GENERATE
printf("static %s int32_data[DIMSIZE]={","int");
for(i=0;i<DIMSIZE;i++) printf("%s%d",COMMA,int32_tst[i]);
printf("};\n");
#else
COMPARE(NC_INT,NC_INT,int32_tst,int32_data);
#endif
CHECK(nc_inq_varid(ncid, "i32", &varid));
CHECK(nc_get_var_float(ncid,varid,float32_tst));
#ifdef GENERATE
printf("static %s int32tofloat32_data[DIMSIZE]={","float");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32_tst[i]);
printf("};\n");
#else
COMPARE(NC_INT,NC_FLOAT,float32_tst,int32tofloat32_data);
#endif
CHECK(nc_inq_varid(ncid, "i32", &varid));
CHECK(nc_get_var_long(ncid,varid,ilong_tst));
#ifdef GENERATE
printf("static %s int32toilong_data[DIMSIZE]={","long");
for(i=0;i<DIMSIZE;i++) printf("%s%ld",COMMA,ilong_tst[i]);
printf("};\n");
#else
COMPARE(NC_INT,NC_NAT,ilong_tst,int32toilong_data);
#endif
CHECK(nc_inq_varid(ncid, "f32", &varid));
CHECK(nc_get_var_float(ncid,varid,float32_tst));
#ifdef GENERATE
printf("static %s float32_data[DIMSIZE]={","float");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float32_tst[i]);
printf("};\n");
#else
COMPARE(NC_FLOAT,NC_FLOAT,float32_tst,float32_data);
#endif
CHECK(nc_inq_varid(ncid, "f64", &varid));
CHECK(nc_get_var_double(ncid,varid,float64_tst));
#ifdef GENERATE
printf("static %s float64_data[DIMSIZE]={","double");
for(i=0;i<DIMSIZE;i++) printf("%s%1.3f",COMMA,float64_tst[i]);
printf("};\n");
#else
COMPARE(NC_DOUBLE,NC_DOUBLE,float64_tst,float64_data);
#endif
if(fail) {
printf("ncstat=%d %s",ncstat,nc_strerror(ncstat));
exit(1);
}
return 0;
}
int ex_get_truth_table (int exoid,
ex_entity_type obj_type,
int num_blk,
int num_var,
int *var_tab)
{
int dimid, varid, tabid, i, j, status, status1;
size_t num_entity = 0;
size_t num_var_db = 0;
char errmsg[MAX_ERR_LENGTH];
const char* routine = "ex_get_truth_table";
/*
* The ent_type and the var_name are used to build the netcdf
* variables name. Normally this is done via a macro defined in
* exodusII_int.h
*/
const char* ent_type = NULL;
const char* var_name = NULL;
exerrval = 0; /* clear error code */
switch (obj_type) {
case EX_EDGE_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_EDG_VAR, "edge variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_EBLK_TAB, &tabid);
var_name = "vals_edge_var";
ent_type = "eb";
break;
case EX_FACE_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_FAC_VAR, "face variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_FBLK_TAB, &tabid);
var_name = "vals_face_var";
ent_type = "fb";
break;
case EX_ELEM_BLOCK:
status = ex_get_dimension(exoid, DIM_NUM_ELE_VAR, "element variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_ELEM_TAB, &tabid);
var_name = "vals_elem_var";
ent_type = "eb";
break;
case EX_NODE_SET:
status = ex_get_dimension(exoid, DIM_NUM_NSET_VAR, "nodeset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_NSET_TAB, &tabid);
var_name = "vals_nset_var";
ent_type = "ns";
break;
case EX_EDGE_SET:
status = ex_get_dimension(exoid, DIM_NUM_ESET_VAR, "edgeset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_ESET_TAB, &tabid);
var_name = "vals_eset_var";
ent_type = "es";
break;
case EX_FACE_SET:
status = ex_get_dimension(exoid, DIM_NUM_FSET_VAR, "faceset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_FSET_TAB, &tabid);
var_name = "vals_fset_var";
ent_type = "fs";
break;
case EX_SIDE_SET:
status = ex_get_dimension(exoid, DIM_NUM_SSET_VAR, "sideset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_SSET_TAB, &tabid);
var_name = "vals_sset_var";
ent_type = "ss";
break;
case EX_ELEM_SET:
status = ex_get_dimension(exoid, DIM_NUM_ELSET_VAR, "elemset variables", &num_var_db, &varid, routine);
status1 = nc_inq_varid (exoid, VAR_ELSET_TAB, &tabid);
var_name = "vals_elset_var";
ent_type = "es";
break;
default:
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %d specified in file id %d",
obj_type, exoid);
ex_err(routine,errmsg,exerrval);
return (EX_WARN);
}
if (status != NC_NOERR) {
exerrval = status;
return (EX_WARN);
}
status = ex_get_dimension(exoid, ex_dim_num_objects(obj_type),
ex_name_of_object(obj_type), &num_entity, &dimid, routine);
if (status != NC_NOERR) {
exerrval = status;
return (EX_FATAL);
}
if (num_entity != (size_t)num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of %s doesn't match those defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
if (num_var_db != (size_t)num_var) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of %s variables doesn't match those defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
if (status1 != NC_NOERR) {
/* since truth table isn't stored in the data file, derive it dynamically */
for (j=0; j<num_blk; j++) {
for (i=0; i<num_var; i++) {
/* NOTE: names are 1-based */
if (nc_inq_varid (exoid, ex_catstr2(var_name, i+1, ent_type, j+1), &tabid) == NC_NOERR) {
/* variable exists; put a 1 in the truth table */
var_tab[j*num_var+i] = 1;
} else {
/* variable doesn't exist; put a 0 in the truth table */
var_tab[j*num_var+i] = 0;
}
}
}
} else {
/* read in the truth table */
status = nc_get_var_int(exoid, tabid, var_tab);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s truth table from file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
}
return (EX_NOERR);
}
int ex_get_var_time( int exoid,
ex_entity_type var_type,
int var_index,
int id,
int beg_time_step,
int end_time_step,
void* var_vals )
{
int i, dimid, varid, numel = 0, offset;
int status;
int *obj_ids, *stat_vals;
size_t num_obj;
size_t num_entries_this_obj = 0;
size_t start[2], count[2];
float fdum;
char *cdum;
char errmsg[MAX_ERR_LENGTH];
const char* varobjids;
const char* varobstat;
switch (var_type) {
case EX_GLOBAL:
return ex_get_glob_var_time( exoid, var_index, beg_time_step, end_time_step, var_vals );
case EX_NODAL:
return ex_get_nodal_var_time( exoid, var_index, id, beg_time_step, end_time_step, var_vals );
case EX_EDGE_BLOCK:
varobjids = VAR_ID_ED_BLK;
varobstat = VAR_STAT_ED_BLK;
break;
case EX_FACE_BLOCK:
varobjids = VAR_ID_FA_BLK;
varobstat = VAR_STAT_FA_BLK;
break;
case EX_ELEM_BLOCK:
varobjids = VAR_ID_EL_BLK;
varobstat = VAR_STAT_EL_BLK;
break;
case EX_NODE_SET:
varobjids = VAR_NS_IDS;
varobstat = VAR_NS_STAT;
break;
case EX_EDGE_SET:
varobjids = VAR_ES_IDS;
varobstat = VAR_ES_STAT;
break;
case EX_FACE_SET:
varobjids = VAR_FS_IDS;
varobstat = VAR_FS_STAT;
break;
case EX_SIDE_SET:
varobjids = VAR_SS_IDS;
varobstat = VAR_SS_STAT;
break;
case EX_ELEM_SET:
varobjids = VAR_ELS_IDS;
varobstat = VAR_ELS_STAT;
break;
default:
exerrval = EX_BADPARAM;
sprintf( errmsg, "Error: Invalid variable type (%d) specified for file id %d", var_type, exoid );
ex_err( "ex_get_var_time", errmsg, exerrval );
return (EX_FATAL);
}
exerrval = 0; /* clear error code */
cdum = 0; /* initialize even though it is not used */
/* assume entry number is 1-based (the first entry of an object is 1, not 0);
* adjust so it is 0-based
*/
id--;
/* find what object the entry is in */
/* first, find out how many objects there are */
status = ex_get_dimension(exoid, ex_dim_num_objects(var_type), ex_name_of_object(var_type),
&num_obj, &dimid, "ex_get_var_time");
if (status != NC_NOERR) return status;
/* get the array of object ids */
/* don't think we need this anymore since the netcdf variable names
associated with objects don't contain the object ids */
if (!(obj_ids = malloc(num_obj*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s ids for file id %d",
ex_name_of_object(var_type),exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_inq_varid (exoid, varobjids, &varid )) != NC_NOERR) {
exerrval = status;
free(obj_ids);
sprintf(errmsg,
"Error: failed to locate %s ids in file id %d",
ex_name_of_object(var_type),exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
return (EX_FATAL);
}
if ((status = nc_get_var_int(exoid, varid, obj_ids)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s ids from file id %d",
ex_name_of_object(var_type),exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
return (EX_FATAL);
}
/* allocate space for stat array */
if (!(stat_vals = malloc((int)num_obj*sizeof(int)))) {
exerrval = EX_MEMFAIL;
free (obj_ids);
sprintf(errmsg,
"Error: failed to allocate memory for %s status array for file id %d",
ex_name_of_object(var_type),exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
return (EX_FATAL);
}
/* get variable id of status array */
if (nc_inq_varid (exoid, varobstat, &varid) == NC_NOERR) {
/* if status array exists, use it, otherwise assume, object exists
to be backward compatible */
if ((status = nc_get_var_int(exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free (obj_ids);
free(stat_vals);
sprintf(errmsg,
"Error: failed to get %s status array from file id %d",
ex_name_of_object(var_type),exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
return (EX_FATAL);
}
}
else { /* default: status is true */
for(i=0;i<(int)num_obj;i++)
stat_vals[i]=1;
}
/* loop through each object until id is found; since entry
* numbers are sequential (beginning with 1) id is in obj_i
* when id_first_i <= id <= id_last_i, where
* id_first_i is the entry number of the first entry in
* obj_i and id_last_i is the entry number of the last
* entry in obj_i
*/
i = 0;
if (stat_vals[i] != 0) {
if ((status = nc_inq_dimid(exoid, ex_dim_num_entries_in_object(var_type,i+1), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of entries in %s %d in file id %d",
ex_name_of_object(var_type), obj_ids[i], exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
free(stat_vals);
free(obj_ids);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_entries_this_obj)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of entries in %s %d in file id %d",
ex_name_of_object(var_type), obj_ids[i], exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
free(stat_vals);
free(obj_ids);
return (EX_FATAL);
}
} /* End NULL object check */
numel = num_entries_this_obj;
while (numel <= id) {
if (stat_vals[++i] != 0) {
if ((status = nc_inq_dimid(exoid,ex_dim_num_entries_in_object(var_type,i+1), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate number of entries in %s %d in file id %d",
ex_name_of_object(var_type), obj_ids[i], exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
free(stat_vals);
free(obj_ids);
return (EX_FATAL);
}
if ((status = nc_inq_dimlen(exoid, dimid, &num_entries_this_obj)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get number of entries in %s %d in file id %d",
ex_name_of_object(var_type), obj_ids[i], exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
free(stat_vals);
free(obj_ids);
return (EX_FATAL);
}
numel += num_entries_this_obj;
}
}
offset = id - (numel - num_entries_this_obj);
/* inquire previously defined variable */
if ((status = nc_inq_varid(exoid,ex_name_var_of_object(var_type,var_index,i+1), &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate variable %d for %s %d in file id %d",
var_index,ex_name_of_object(var_type),obj_ids[i],exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
free(stat_vals);
free(obj_ids);
return (EX_FATAL);
}
free(stat_vals);
free(obj_ids);
/* read values of object variable */
start[0] = --beg_time_step;
start[1] = offset;
if (end_time_step < 0) {
/* user is requesting the maximum time step; we find this out using the
* database inquire function to get the number of time steps; the ending
* time step number is 1 less due to 0 based array indexing in C
*/
if ((status = ex_inquire (exoid, EX_INQ_TIME, &end_time_step, &fdum, cdum)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get maximum time step in file id %d",
exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
return (EX_FATAL);
}
}
end_time_step--;
count[0] = end_time_step - beg_time_step + 1;
count[1] = 1;
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, varid, start, count, var_vals);
} else {
status = nc_get_vara_double(exoid, varid, start, count, var_vals);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get %s variable values in file id %d",
ex_name_of_object(var_type),exoid);
ex_err("ex_get_var_time",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
int ex_put_truth_table (int exoid,
ex_entity_type obj_type,
int num_blk,
int num_var,
int *var_tab)
{
int numelblkdim, numelvardim, timedim, dims[2], varid;
char *sta_type, *tab_type;
size_t num_entity = 0;
size_t num_var_db = 0;
int *stat_vals;
int i, j, k;
int status;
char errmsg[MAX_ERR_LENGTH];
const char* routine = "ex_put_truth_table";
/*
* The ent_type and the var_name are used to build the netcdf
* variables name. Normally this is done via a macro defined in
* exodusII_int.h
*/
const char* ent_type = NULL;
const char* var_name = NULL;
const char* ent_size = NULL;
exerrval = 0; /* clear error code */
ex_get_dimension(exoid, ex_dim_num_objects(obj_type),
ex_name_of_object(obj_type), &num_entity, &numelblkdim, routine);
if (obj_type == EX_ELEM_BLOCK) {
ex_get_dimension(exoid, DIM_NUM_ELE_VAR, "element variables",
&num_var_db, &numelvardim, routine);
nc_inq_varid (exoid, VAR_ELEM_TAB, &varid);
var_name = "vals_elem_var";
ent_type = "eb";
ent_size = "num_el_in_blk";
sta_type = VAR_STAT_EL_BLK;
tab_type = VAR_ELEM_TAB;
}
else if (obj_type == EX_EDGE_BLOCK) {
ex_get_dimension(exoid, DIM_NUM_EDG_VAR, "edge block variables",
&num_var_db, &numelvardim, routine);
nc_inq_varid (exoid, VAR_EBLK_TAB, &varid);
var_name = "vals_edge_var";
ent_type = "eb";
ent_size = "num_ed_in_blk";
sta_type = VAR_STAT_ED_BLK;
tab_type = VAR_EBLK_TAB;
}
else if (obj_type == EX_FACE_BLOCK) {
ex_get_dimension(exoid, DIM_NUM_FAC_VAR, "face block variables",
&num_var_db, &numelvardim, routine);
nc_inq_varid (exoid, VAR_FBLK_TAB, &varid);
var_name = "vals_face_var";
ent_type = "fb";
ent_size = "num_fa_in_blk";
sta_type = VAR_STAT_FA_BLK;
tab_type = VAR_FBLK_TAB;
}
else if (obj_type == EX_SIDE_SET) {
ex_get_dimension(exoid, DIM_NUM_SSET_VAR, "sideset variables",
&num_var_db, &numelvardim, routine);
nc_inq_varid (exoid, VAR_SSET_TAB, &varid);
var_name = "vals_sset_var";
ent_type = "ss";
ent_size = "num_side_ss";
sta_type = VAR_SS_STAT;
tab_type = VAR_SSET_TAB;
}
else if (obj_type == EX_NODE_SET) {
ex_get_dimension(exoid, DIM_NUM_NSET_VAR, "nodeset variables",
&num_var_db, &numelvardim, routine);
nc_inq_varid (exoid, VAR_NSET_TAB, &varid);
var_name = "vals_nset_var";
ent_type = "ns";
ent_size = "num_nod_ns";
sta_type = VAR_NS_STAT;
tab_type = VAR_NSET_TAB;
}
else if (obj_type == EX_EDGE_SET) {
ex_get_dimension(exoid, DIM_NUM_ESET_VAR, "edge set variables",
&num_var_db, &numelvardim, routine);
nc_inq_varid (exoid, VAR_ESET_TAB, &varid);
var_name = "vals_eset_var";
ent_type = "es";
ent_size = "num_edge_es";
sta_type = VAR_ES_STAT;
tab_type = VAR_ESET_TAB;
}
else if (obj_type == EX_FACE_SET) {
ex_get_dimension(exoid, DIM_NUM_FSET_VAR, "face set variables",
&num_var_db, &numelvardim, routine);
nc_inq_varid (exoid, VAR_FSET_TAB, &varid);
var_name = "vals_fset_var";
ent_type = "fs";
ent_size = "num_face_fs";
sta_type = VAR_FS_STAT;
tab_type = VAR_FSET_TAB;
}
else if (obj_type == EX_ELEM_SET) {
ex_get_dimension(exoid, DIM_NUM_ELSET_VAR, "element set variables",
&num_var_db, &numelvardim, routine);
nc_inq_varid (exoid, VAR_ELSET_TAB, &varid);
var_name = "vals_elset_var";
ent_type = "es";
ent_size = "num_ele_els";
sta_type = VAR_ELS_STAT;
tab_type = VAR_ELSET_TAB;
}
else { /* invalid variable type */
exerrval = EX_BADPARAM;
sprintf(errmsg,
"Error: Invalid variable type %d specified in file id %d",
obj_type, exoid);
ex_err("ex_get_varid",errmsg,exerrval);
return (EX_WARN);
}
if ((int)num_entity != num_blk) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of %s doesn't match those defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
if ((int)num_var_db != num_var) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: # of %s variables doesn't match those defined in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("ex_get_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
/* Get status array for later use */
if (!(stat_vals = malloc(num_blk*sizeof(int)))) {
exerrval = EX_MEMFAIL;
sprintf(errmsg,
"Error: failed to allocate memory for %s status array for file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
status = nc_inq_varid (exoid, sta_type, &varid);
/* get variable id of status array */
if (status == NC_NOERR) {
/* if status array exists (V 2.01+), use it, otherwise assume
object exists to be backward compatible */
if ((status = nc_get_var_int (exoid, varid, stat_vals)) != NC_NOERR) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to get %s status array from file id %d",
ex_name_of_object(obj_type), exoid);
ex_err("put_var_tab",errmsg,exerrval);
return (EX_FATAL);
}
} else {
/* status array doesn't exist (V2.00), dummy one up for later checking */
for(i=0; i<num_blk; i++)
stat_vals[i] = 1;
}
/* put netcdf file into define mode */
if ((status = nc_redef (exoid)) != NC_NOERR) {
free(stat_vals);
exerrval = status;
sprintf(errmsg,
"Error: failed to put file id %d into define mode",
exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
/* inquire previously defined dimensions */
if ((status = nc_inq_dimid (exoid, DIM_TIME, &timedim)) != NC_NOERR) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to locate time variable in file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* define netCDF variables in which to store EXODUS II element
* variable values
*/
k = 0;
for (i=0; i<num_blk; i++) {
for (j=1; j<=num_var; j++) {
/* check if variables are to be put out for this entity */
if (var_tab[k] != 0) {
if (stat_vals[i] != 0) {/* check for NULL entity */
/* NOTE: This code used to zero out the var_tab entry
if the stat_vals[i] value was zero. However, in some
cases it is good to know that a variable was assigned to
an entity even if that entity is empty. The code was
changed to not modify the truth table.
*/
dims[0] = timedim;
/* Determine number of entities in block */
if ((status = nc_inq_dimid(exoid, ex_catstr(ent_size, (i+1)), &dims[1])) != NC_NOERR) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to locate number of entities in %d'th %s in file id %d",
i+1, ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* define netCDF variable to store variable values; the j
* index cycles from 1 through the number of variables so
* that the index of the EXODUS II variable (which is part
* of the name of the netCDF variable) will begin at 1
* instead of 0
*/
if ((status = nc_def_var(exoid, ex_catstr2(var_name, j, ent_type, i+1),
nc_flt_code(exoid), 2, dims, &varid)) != NC_NOERR) {
if (status != NC_ENAMEINUSE) {
exerrval = status;
free(stat_vals);
sprintf(errmsg,
"Error: failed to define variable for %d'th %s in file id %d",
i+1, ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
ex_compress_variable(exoid, varid, 2);
}
}
} /* if */
k++; /* increment element truth table pointer */
} /* for j */
} /* for i */
free (stat_vals);
/* create a variable array in which to store the truth table
*/
dims[0] = numelblkdim;
dims[1] = numelvardim;
status = nc_def_var (exoid, tab_type, NC_INT, 2, dims, &varid);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to define %s variable truth table in file id %d",
ex_name_of_object(obj_type), exoid);
ex_err(routine,errmsg,exerrval);
goto error_ret; /* exit define mode and return */
}
/* leave define mode */
if ((status = nc_enddef (exoid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to complete definitions in file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
/* write out the element variable truth table */
status = nc_put_var_int(exoid, varid, var_tab);
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to store variable truth table in file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
/* Fatal error: exit definition mode and return */
error_ret:
if (nc_enddef (exoid) != NC_NOERR) /* exit define mode */
{
sprintf(errmsg,
"Error: failed to complete definition for file id %d",
exoid);
ex_err(routine,errmsg,exerrval);
}
return (EX_FATAL);
}
