int
nc_inq_varnatts(int ncid, int varid, int *nattsp)
{
int status;
NC *ncp;
NC_var *varp;
if(varid == NC_GLOBAL)
return nc_inq_natts(ncid, nattsp);
status = NC_check_id(ncid, &ncp);
if(status != NC_NOERR)
return status;
varp = elem_NC_vararray(&ncp->vars, (size_t)varid);
if(varp == NULL)
return NC_ENOTVAR; /* TODO: is this the right error code? */
if(nattsp != 0)
{
*nattsp = (int) varp->attrs.nelems;
}
return NC_NOERR;
}
/*! \cond INTERNAL */
int cpy_att(int in_id,int out_id,int var_in_id,int var_out_id)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
int var_in_id: input netCDF input-variable ID
int var_out_id: input netCDF output-variable ID
*/
{
/* Routine to copy all the attributes from the input netCDF
file to the output netCDF file. If var_in_id == NC_GLOBAL,
then the global attributes are copied. Otherwise the variable's
attributes are copied. */
int idx;
int nbr_att;
if(var_in_id == NC_GLOBAL) {
(void)nc_inq_natts(in_id,&nbr_att);
} else {
(void)nc_inq_varnatts(in_id, var_in_id, &nbr_att);
}
/* Get the attributes names, types, lengths, and values */
for (idx=0; idx<nbr_att; idx++) {
char att_nm[MAX_VAR_NAME_LENGTH];
(void)nc_inq_attname(in_id, var_in_id, idx, att_nm);
(void)nc_copy_att(in_id, var_in_id, att_nm, out_id, var_out_id);
}
return(EX_NOERR);
}
/* Open/close the file with netCDF. */
int
readfile(char *file_name, long long *delta, int do_inq, int num_vars)
{
int ncid;
struct timeval starttime, endtime;
long long startt, endt;
int natts;
int v;
/* Start the clock. */
gettimeofday(&starttime, NULL);
/* Open the file. */
if (nc_open(file_name, NC_NETCDF4, &ncid)) ERR;
/* Do an inq if desired, triggering read of atts. */
for (v = 0; v < num_vars; v++)
if (nc_inq_varnatts(ncid, v, &natts)) ERR;
if (nc_inq_natts(ncid, &natts)) ERR;
/* Close the file. */
if (nc_close(ncid)) ERR;
gettimeofday(&endtime, NULL);
/* Compute the time delta */
startt = (1000000 * starttime.tv_sec) + starttime.tv_usec;
endt = (1000000 * endtime.tv_sec) + endtime.tv_usec;
*delta = endt - startt;
return 0;
}
int NcFile::num_atts( void ) const
{
int num = 0;
if (is_valid())
NcError::set_err(
nc_inq_natts(the_id, &num)
);
return num;
}
/** Learn how many attributes are associated with a variable.
\ingroup variables
\param ncid NetCDF or group ID, from a previous call to nc_open(),
nc_create(), nc_def_grp(), or associated inquiry functions such as
nc_inq_ncid().
\param varid Variable ID
\param nattsp Pointer where number of attributes will be
stored. \ref ignored_if_null.
\returns ::NC_NOERR No error.
\returns ::NC_EBADID Bad ncid.
\returns ::NC_ENOTVAR Invalid variable ID.
*/
int
nc_inq_varnatts(int ncid, int varid, int *nattsp)
{
if (varid == NC_GLOBAL)
return nc_inq_natts(ncid,nattsp);
/*else*/
return nc_inq_var(ncid, varid, NULL, NULL, NULL, NULL,
nattsp);
}
/*!
This function queries the number of global attributes given a location id.
\param [in] ncid Groupd id (or File Id)
\param [out] ngatts the number of global attributes
\return Status code
*/
int CNetCdfInterface::inqNAtts(int ncid, int& ngatts)
{
int status = nc_inq_natts(ncid, &ngatts);
if (NC_NOERR != status)
{
StdString errormsg(nc_strerror(status));
StdStringStream sstr;
sstr << "Error when calling function nc_inq_natts(ncid, &ngatts)" << std::endl;
sstr << errormsg << std::endl;
sstr << "Unable to query the number of global attributes given the location id:" << ncid << std::endl;
StdString e = sstr.str();
throw CNetCdfException(e);
}
return status;
}
int
check_4D_example(char *file_name, int expected_format)
{
int ncid;
int format, ndims_in, nvars_in, natts_in;
int dimid[NDIMS_EX];
int varid[NVARS_EX];
char dim_name_in[NDIMS_EX][NC_MAX_NAME];
char var_name_in[NVARS_EX][NC_MAX_NAME];
char name_in[NC_MAX_NAME + 1];
char units_in[NC_MAX_NAME + 1];
nc_type xtype_in;
size_t len_in;
int i;
if (nc_open(file_name, 0, &ncid)) ERR;
/* Count stuff. */
if (nc_inq_format(ncid, &format)) ERR;
if (nc_inq_ndims(ncid, &ndims_in)) ERR;
if (ndims_in != NDIMS_EX) ERR;
if (nc_inq_nvars(ncid, &nvars_in)) ERR;
if (nvars_in != NVARS_EX) ERR;
if (nc_inq_natts(ncid, &natts_in)) ERR;
if (natts_in != 0) ERR;
if (format != expected_format) ERR;
/* Check dimensions. */
ndims_in = 0;
if (nc_inq_dimids(ncid, &ndims_in, dimid, 0)) ERR;
if (ndims_in != NDIMS_EX) ERR;
for (i = 0; i < NDIMS_EX; i++)
{
if (dimid[i] != i) ERR;
if (nc_inq_dimname(ncid, i, dim_name_in[i])) ERR;
}
if (strcmp(dim_name_in[0], LVL_NAME) || strcmp(dim_name_in[1], LAT_NAME) ||
strcmp(dim_name_in[2], LON_NAME) || strcmp(dim_name_in[3], REC_NAME)) ERR;
/* Check variables. */
nvars_in = 0;
if (nc_inq_varids(ncid, &nvars_in, varid)) ERR;
if (nvars_in != NVARS_EX) ERR;
for (i = 0; i < NVARS_EX; i++)
{
if (varid[i] != i) ERR;
if (nc_inq_varname(ncid, i, var_name_in[i])) ERR;
}
if (strcmp(var_name_in[0], LAT_NAME) || strcmp(var_name_in[1], LON_NAME) ||
strcmp(var_name_in[2], PRES_NAME) || strcmp(var_name_in[3], TEMP_NAME)) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR;
if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimid[0] != 1 || natts_in != 1) ERR;
if (nc_inq_var(ncid, 1, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR;
if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimid[0] != 2 || natts_in != 1) ERR;
if (nc_inq_var(ncid, 2, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR;
if (strcmp(name_in, PRES_NAME) || xtype_in != NC_FLOAT || ndims_in != 4 ||
dimid[0] != 3 || dimid[1] != 0 || dimid[2] != 1 || dimid[3] != 2 ||
natts_in != 1) ERR;
if (nc_inq_var(ncid, 3, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR;
if (strcmp(name_in, TEMP_NAME) || xtype_in != NC_FLOAT || ndims_in != 4 ||
dimid[0] != 3 || dimid[1] != 0 || dimid[2] != 1 || dimid[3] != 2 ||
natts_in != 1) ERR;
/* Check variable atts. */
if (nc_inq_att(ncid, 0, UNITS, &xtype_in, &len_in)) ERR;
if (xtype_in != NC_CHAR || len_in != strlen(DEGREES_NORTH)) ERR;
if (nc_get_att_text(ncid, 0, UNITS, units_in)) ERR;
if (strncmp(units_in, DEGREES_NORTH, strlen(DEGREES_NORTH))) ERR;
if (nc_inq_att(ncid, 1, UNITS, &xtype_in, &len_in)) ERR;
if (xtype_in != NC_CHAR || len_in != strlen(DEGREES_EAST)) ERR;
if (nc_get_att_text(ncid, 1, UNITS, units_in)) ERR;
if (strncmp(units_in, DEGREES_EAST, strlen(DEGREES_EAST))) ERR;
if (nc_inq_att(ncid, 2, UNITS, &xtype_in, &len_in)) ERR;
if (xtype_in != NC_CHAR || len_in != strlen(PRES_UNITS)) ERR;
if (nc_get_att_text(ncid, 2, UNITS, units_in)) ERR;
if (strncmp(units_in, PRES_UNITS, strlen(PRES_UNITS))) ERR;
if (nc_inq_att(ncid, 3, UNITS, &xtype_in, &len_in)) ERR;
if (xtype_in != NC_CHAR || len_in != strlen(TEMP_UNITS)) ERR;
if (nc_get_att_text(ncid, 3, UNITS, units_in)) ERR;
if (strncmp(units_in, TEMP_UNITS, strlen(TEMP_UNITS))) ERR;
if (nc_close(ncid)) ERR;
return err;
}
bool
NETCDFFileObject::ReadAttribute(const char *varname, const char *attname,
TypeEnum *type, int *ndims, int **dims, void **value)
{
const char *mName = "NETCDFFileObject::ReadAttribute: ";
int varid, status;
int natts = 0;
bool varvalid = false;
if(varname == 0)
{
varid = NC_GLOBAL;
if((status = nc_inq_natts(GetFileHandle(), &natts)) == NC_NOERR)
varvalid = natts > 0;
else
{
debug4 << mName << "0: ";
HandleError(status);
}
}
else
{
// Look up the variable name and gets its variable id.
varvalid = GetVarId(varname, &varid);
}
if(varvalid)
{
nc_type atttype;
size_t attsize;
if((status = nc_inq_att(GetFileHandle(), varid, attname, &atttype,
&attsize)) == NC_NOERR)
{
void *val = 0;
TypeEnum t = NO_TYPE;
// Try and read the attribute.
if(atttype == NC_CHAR)
{
char *arr = new char[attsize+1];
status = nc_get_att_text(GetFileHandle(), varid, attname, arr);
if(status != NC_NOERR)
delete [] arr;
else
{
// Trim trailing spaces.
arr[attsize] = '\0';
char *c2 = arr + attsize - 1;
while(c2 >= arr && *c2 == ' ')
*c2-- = '\0';
val = (void*)arr;
}
t = CHARARRAY_TYPE;
}
else if(atttype == NC_BYTE)
{
unsigned char *arr = new unsigned char[attsize+1];
status = nc_get_att_uchar(GetFileHandle(), varid, attname, arr);
if(status != NC_NOERR)
delete [] arr;
else
val = (void*)arr;
t = UCHARARRAY_TYPE;
}
else if(atttype == NC_SHORT)
{
short *arr = new short[attsize];
status = nc_get_att_short(GetFileHandle(), varid, attname, arr);
if(status != NC_NOERR)
delete [] arr;
else
val = (void*)arr;
t = SHORTARRAY_TYPE;
}
else if(atttype == NC_INT)
{
int *arr = new int[attsize];
status = nc_get_att_int(GetFileHandle(), varid, attname, arr);
if(status != NC_NOERR)
delete [] arr;
else
val = (void*)arr;
t = INTEGERARRAY_TYPE;
}
else if(atttype == NC_LONG)
{
long *arr = new long[attsize];
status = nc_get_att_long(GetFileHandle(), varid, attname, arr);
if(status != NC_NOERR)
delete [] arr;
else
val = (void*)arr;
t = LONGARRAY_TYPE;
}
else if(atttype == NC_FLOAT)
{
float *arr = new float[attsize];
status = nc_get_att_float(GetFileHandle(), varid, attname, arr);
if(status != NC_NOERR)
delete [] arr;
else
val = (void*)arr;
t = FLOATARRAY_TYPE;
}
else if(atttype == NC_DOUBLE)
{
double *arr = new double[attsize];
status = nc_get_att_double(GetFileHandle(), varid, attname, arr);
if(status != NC_NOERR)
delete [] arr;
else
val = (void*)arr;
t = DOUBLEARRAY_TYPE;
}
if(status == NC_NOERR)
{
*type = t;
*ndims = 1;
int *d = new int[1];
d[0] = (int)attsize;
*dims = d;
*value = val;
}
else
{
*type = NO_TYPE;
*ndims = 0;
*dims = 0;
*value = 0;
debug4 << mName << "3: ";
HandleError(status);
varvalid = false;
}
}
else
{
varvalid = false;
debug4 << mName << "4: ";
HandleError(status);
}
}
return varvalid;
}
