void load_RAIN () {
fprintf(stdout, "Loading RAIN\n");
int rain_id;
int rainc_id;
nc_error(nc_inq_varid (wrfout_id, "RAINNC", &rain_id));
nc_error(nc_inq_varid (wrfout_id, "RAINC", &rainc_id));
wRAIN = malloc (wN2D * sizeof(float));
if (wRAIN==NULL) {fprintf(stderr, "rain.c : Cannot allocate wRAIN\n"); exit(-1);}
wRAINC = malloc (wN2D * sizeof(float));
if (wRAINC==NULL) {fprintf(stderr, "rain.c : Cannot allocate wRAINC\n"); exit(-1);}
nc_error(nc_get_var_float(wrfout_id, rain_id, wRAIN));
nc_error(nc_get_var_float(wrfout_id, rainc_id, wRAINC));
int i;
if (wFRAME_N_LAST >= 0) {
fprintf(stdout, "Getting accumulated rain values from previous file\n");
int rain_last_id;
int rainc_last_id;
nc_error(nc_inq_varid (wrfout_last_id, "RAINNC", &rain_last_id));
nc_error(nc_inq_varid (wrfout_last_id, "RAINC", &rainc_last_id));
wRAIN_LAST = malloc (wN2D * sizeof(float));
if (wRAIN_LAST==NULL) {fprintf(stderr, "rain.c : Cannot allocate wRAIN_LAST\n"); exit(-1);}
wRAINC_LAST = malloc (wN2D * sizeof(float));
if (wRAINC_LAST==NULL) {fprintf(stderr, "rain.c : Cannot allocate wRAINC_LAST\n"); exit(-1);}
nc_error(nc_get_var_float(wrfout_last_id, rain_last_id, wRAIN_LAST));
nc_error(nc_get_var_float(wrfout_last_id, rainc_last_id, wRAINC_LAST));
#pragma omp parallel for private(i)
for (i=0; i<wN2D; i++) {
wRAIN[i] -= wRAIN_LAST[i];
wRAINC[i] -= wRAINC_LAST[i];
}
free(wRAIN_LAST);
free(wRAINC_LAST);
} else {
fprintf(stderr, "rain.c : WARNING : no previous rain. Using raw values.\n");
}
for (i=0; i<wN2D; i++) {
wRAIN[i] += wRAINC[i];
}
}
void load_UV10 () {
int u10_id;
int v10_id;
nc_error(nc_inq_varid (wrfout_id, "U10", &u10_id));
nc_error(nc_inq_varid (wrfout_id, "V10", &v10_id));
U10 = malloc (nWE * nSN * sizeof(float));
if (U10==NULL) {fprintf(stderr, "uv10.c : Cannot allocate U10\n"); exit(-1);}
V10 = malloc (nWE * nSN * sizeof(float));
if (V10==NULL) {fprintf(stderr, "uv10.c : Cannot allocate V10\n"); exit(-1);}
nc_error(nc_get_var_float(wrfout_id, u10_id, U10));
nc_error(nc_get_var_float(wrfout_id, v10_id, V10));
double deg2rad = M_PI/180;
if (MAP_PROJ == 1 || MAP_PROJ == 2) {
double cone;
if (MAP_PROJ == 1) { // lambert conformal
if ( (fabs(TRUELAT1 - TRUELAT2) > 0.1) && (fabs(TRUELAT2 - 90.) > 0.1)) {
cone = ( pow(10, cos(TRUELAT1*deg2rad)) - pow(10, cos(TRUELAT2*deg2rad)) )
/ ( pow(10, tan(45. -fabs(TRUELAT1/2.)*deg2rad))
- pow(10, tan(45. -fabs(TRUELAT2/2.)*deg2rad)) );
} else {
cone = sin(fabs(TRUELAT1)*deg2rad);
}
} else if (MAP_PROJ == 2) { // polar stereographic
cone = 1.;
}
float * umet10 = malloc (nWE * nSN * sizeof(float));
if (umet10==NULL) {fprintf(stderr, "uv10.c : Cannot allocate UMET10\n"); exit(-1);}
float * vmet10 = malloc (nWE * nSN * sizeof(float));
if (vmet10==NULL) {fprintf(stderr, "uv10.c : Cannot allocate VMET10\n"); exit(-1);}
int is_stag = 1;
int is_missing_val = 0;
calc_uvmet (U10, V10, umet10, vmet10, cone, is_stag, is_missing_val);
U10 = umet10;
V10 = vmet10;
free (umet10);
free (vmet10);
}
}
int ex_get_all_times (int exoid,
void *time_values)
{
int varid;
int status;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0;
if ((status = nc_inq_varid(exoid, VAR_WHOLE_TIME, &varid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,"Error: failed to locate time variable %s in file id %d",
VAR_WHOLE_TIME, exoid);
ex_err("ex_get_all_times",errmsg,exerrval);
return(EX_FATAL);
}
/*read time values */
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, varid, time_values);
} else {
status = nc_get_var_double(exoid, varid, time_values);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get time values from file id %d",
exoid);
ex_err("ex_get_all_times",errmsg,exerrval);
return(EX_FATAL);
}
return (EX_NOERR);
}
int ex_get_all_times(int exoid, void *time_values)
{
int varid;
int status;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
if ((status = nc_inq_varid(exoid, VAR_WHOLE_TIME, &varid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate time variable %s in file id %d",
VAR_WHOLE_TIME, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/*read time values */
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, varid, time_values);
}
else {
status = nc_get_var_double(exoid, varid, time_values);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get time values from file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
EX_FUNC_LEAVE(EX_NOERR);
}
int
main()
{
int ncid;
int ncstatus;
int lat_id;
nc_type lat_type;
int lat_ndims;
int lat_dimids[NC_MAX_VAR_DIMS];
int lat_natts;
int format_p;
float lat_data[4320];
#ifdef _MSC_VER
/* See https://msdn.microsoft.com/en-us/library/5at7yxcs(v=vs.120).aspx
for more information re: these. */
//int tmpFlag = _CrtSetDbgFlag(_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
printf(" \n");
printf("********************\n");
printf("open URL %s\n",URL);
printf(" \n");
ncstatus = nc_open(URL, NC_NOWRITE, &ncid);
if(ncstatus != NC_NOERR) {
printf("Could not open: %s; server may be down; test ignored\n",URL);
exit(0);
}
printf("status after open = %d\n", ncstatus);
// get the format
ncstatus = nc_inq_format(ncid, &format_p);
printf("lat id = %d\n", format_p);
// get varid for latitude
ncstatus = nc_inq_varid(ncid,"lat",&lat_id);
printf("status after inq lat id = %d\n", ncstatus);
printf("lat id = %d\n", lat_id);
ncstatus = nc_inq_var(ncid, lat_id, 0, &lat_type, &lat_ndims, lat_dimids, &lat_natts);
printf("status after inq lat var = %d\n", ncstatus);
printf("lat type = %d\n", lat_type);
// extract the first latitude value
ncstatus = nc_get_var_float(ncid, lat_id, &lat_data[0]);
printf("status after get = %d\n", ncstatus);
printf("my datum = %f\n", lat_data[0]);
// This code works okay in Linux and Mac
// Everything works okay up until here in Windows then an exception occurs
ncstatus = nc_close(ncid);
printf("status after close = %d\n", ncstatus);
printf("End of test.\n\n");
return 0;
}
void CTAI_SObs_netcdf_GetVariances(
// Get all the variances of the measurements in a netcdf-StochObserver
// INPUTS
CTAI_SObs_netcdf *x, // StochObserver from which the measurements are
// returned
int *returnvar, //return variance (CTA_TRUE) or std (CTA_FALSE)
// OUTPUTS
CTA_Vector *hvec, // COSTA-vector containing the values
int *retval
)
{
#if HAVE_LIBNETCDF
int ierr, ncid, varid;
float *stdv;
float *nc_values;
// first allocate space for temporary arrays
nc_values = CTA_Malloc(x->nmeasr_orig * sizeof(float));
stdv=CTA_Malloc(x->nmeasr*sizeof(float));
// Look up all the standard deviations of the measurements in the observer:
/* read values from database. First read entire vcd-array. Note: netcdf file should first be opened */
// Get the netcdf-id of the database
ncid = x->database->ncid;
// read the vcd vector. We know the size: nmeasr_orig. OMI-vcd vector contains one float per entry.
ierr = nc_inq_varid(ncid, "sigma_vcd_trop", &varid);
if (ierr != 0) ierr = nc_get_var_float(ncid, varid, &nc_values[0]);
if (ierr != 0)
{printf("Error: could not read sigma_vcd_trop \n");
*retval = -1; return;}
// now fill the stdv array. The relation table is used to get only the selection.
ierr = CTA_RelTable_ApplyVal(x->selectionReltab, nc_values, x->nmeasr_orig,
stdv, x->nmeasr, CTA_REAL);
if (ierr != CTA_OK)
{printf("Error: reltable_applyval in netcdf_getvariances \n");
*retval = -1; return;}
// Fill in the variances in the variable *hvec
*retval = CTA_Vector_SetVals( *hvec, stdv, x->nmeasr, CTA_REAL);
if (*retval!=CTA_OK) return;
*returnvar = CTA_FALSE; //it is the std, not the var !
*retval = CTA_OK;
#else
printf("Error: CTAI_SObs_netcdf_GetVariances: COSTA is compiled without NETCDFsupport\n");
*retval=CTA_NOT_IMPLEMENTED;
#endif
};
void load_MODEL_LEVEL () {
fprintf(stdout, "Loading MODEL_LEVEL\n");
int model_level_id;
nc_error(nc_inq_varid (wrfout_id, "ZNU", &model_level_id));
wMODEL_LEVEL = malloc (wNZ * sizeof(float));
if (wMODEL_LEVEL==NULL) {fprintf(stderr, "model_level.c : Cannot allocate wMODEL_LEVEL\n"); exit(-1);}
nc_error(nc_get_var_float(wrfout_id, model_level_id, wMODEL_LEVEL));
}
void load_TOPO () {
fprintf(stdout, "Loading TOPO\n");
int topo_id;
nc_error(nc_inq_varid (wrfout_id, "HGT", &topo_id));
wTOPO = malloc (wN2D * sizeof(float));
if (wTOPO==NULL) {fprintf(stderr, "topo.c : Cannot allocate wTOPO\n"); exit(-1);}
nc_error(nc_get_var_float(wrfout_id, topo_id, wTOPO));
}
void load_TEMP2M () {
fprintf(stdout, "Loading TEMP2M\n");
int temp2m_id;
nc_error(nc_inq_varid (wrfout_id, "T2", &temp2m_id));
wTEMP2M = malloc (wN2D * sizeof(float));
if (wTEMP2M==NULL) {fprintf(stderr, "temp2m.c : Cannot allocate wTEMP2M\n"); exit(-1);}
nc_error(nc_get_var_float(wrfout_id, temp2m_id, wTEMP2M));
int i;
for (i=0; i<wN2D; i++) {
wTEMP2M[i] -= 273.16;
}
}
void load_RH () {
fprintf(stdout, "Loading RH\n");
int qvapor_id;
nc_error(nc_inq_varid (wrfout_id, "QVAPOR", &qvapor_id));
wRH = malloc (wN3D * sizeof(float));
if (wRH==NULL) {fprintf(stderr, "rh.c : Cannot allocate wRH\n"); exit(-1);}
wQVAPOR = malloc (wN3D * sizeof(float));
if (wQVAPOR==NULL) {fprintf(stderr, "rh.c : Cannot allocate wQVAPOR\n"); exit(-1);}
nc_error(nc_get_var_float(wrfout_id, qvapor_id, wQVAPOR));
double svp1=0.6112;
double svp2=17.67;
double svp3=29.65;
double ep_3=0.622;
double es;
double qvs;
int i;
#pragma omp parallel for private(i)
for (i=0; i<wN3D; i++) {
es = 10.*svp1*exp(svp2*(wTEMP[i])/(wTK[i]-svp3));
qvs = ep_3*es/ (wPRESS[i] - (1.-ep_3)*es);
wRH[i] = 100.*MAX(MIN(wQVAPOR[i]/qvs,1.0),0.0);
}
wRH_A = malloc (wN2D * ip_nALEVELS * sizeof(float));
if (wRH_A==NULL) {fprintf(stderr, "rh.c : Cannot allocate wRH_A\n"); exit(-1);}
wRH_P = malloc (wN2D * ip_nPLEVELS * sizeof(float));
if (wRH_P==NULL) {fprintf(stderr, "rh.c : Cannot allocate wRH_P\n"); exit(-1);}
#pragma omp parallel for private(i)
for (i=0; i<ip_nALEVELS; i++) {
interpolate_3d_z (wRH, ip_ALEVELS[i], wHEIGHT, &wRH_A[wN2D*i]);
}
#pragma omp parallel for private(i)
for (i=0; i<ip_nPLEVELS; i++) {
interpolate_3d_z (wRH, ip_PLEVELS[i], wPRESS, &wRH_P[wN2D*i]);
}
}
int main(int argc, char *argv[]) {
fprintf(stdout, "start\n");
int varid;
int ndims;
int dimids[NC_MAX_VAR_DIMS];
size_t nx, ny, size, var_size, var_offset, i;
int shm_id, shm_key;
int nhours, nvars, var_i, frame;
float* shm_p;
float* data_p;
if (argc != 9) {
fprintf(stdout, "usage: ./load-dap {SHM_KEY} {NHOURS} {NVARS} {VAR_ID} {FRAME} {URL} {VAR_NAME} {Z_LEVEL}\n");
exit(EXIT_FAILURE);
}
fprintf(stdout, "nc_open %s\n", argv[URL]);
ne(nc_open(argv[URL], 0, &ncid));
fprintf(stdout, "nc_inq\n");
ne(nc_inq_varid (ncid, argv[VAR_NAME], &varid));
ne(nc_inq_varndims(ncid, varid, &ndims));
ne(nc_inq_vardimid(ncid, varid, dimids));
fprintf(stdout, "ndims\n");
if (ndims==2) {
ne(nc_inq_dimlen(ncid, dimids[0], &ny));
ne(nc_inq_dimlen(ncid, dimids[1], &nx));
} else if (ndims==3) {
ne(nc_inq_dimlen(ncid, dimids[1], &ny));
ne(nc_inq_dimlen(ncid, dimids[2], &nx));
}
shm_key=atoi(argv[SHM_KEY]);
shm_id=shmget(shm_key, 0, 0644);
if (shm_id == -1) {
fprintf(stderr, "Shared memory shmget() failed\n");
exit(EXIT_FAILURE);
}
shm_p = shmat(shm_id, NULL, 0);
if (shm_p == (void *)-1) {
fprintf(stderr, "Shared memory shmat() failed\n");
exit(EXIT_FAILURE);
}
size=nx*ny;
data_p=malloc(size*sizeof(float));
if (data_p == NULL) {
fprintf(stderr, "malloc() failed\n");
exit(EXIT_FAILURE);
}
if (ndims==2) {
ne(nc_get_var_float(ncid, varid, data_p));
} else {
size_t start[3]={0,0,0};
size_t count[3]={1,ny,nx};
start[0]=atoi(argv[Z_LEVEL]);
ne(nc_get_vara_float(ncid, varid, start, count, data_p));
}
// run[point[var[frames[]]]]
nhours=atoi(argv[NHOURS]);
nvars=atoi(argv[NVARS]);
frame=atoi(argv[FRAME]);
var_i=atoi(argv[VAR_ID]);
size_t index;
var_size=nhours*nvars;
var_offset=var_i*nhours+frame;
for (i=0; i<size; i++) {
index=i*var_size+var_offset;
shm_p[index]=data_p[i];
}
free(data_p);
if(shmdt(shm_p)==-1){
fprintf(stderr, "Shared memory shmdt() failed\n");
exit(EXIT_FAILURE);
}
nc_close(ncid);
return 0;
}
void CTAI_SObs_netcdf_GetCovMat(
// Get all the variances of the measurements in a netcdf-StochObserver
// INPUTS
CTAI_SObs_netcdf *x, // StochObserver from which the measurements are
// returned
// OUTPUTS
CTA_Matrix *hmat, /* Covariance matrix */
int *retval
)
{
#if HAVE_LIBNETCDF
double *matval;
int i, ierr, ncid, varid;
float *stdv;
float *nc_values;
// first allocate space for temporary arrays
nc_values = CTA_Malloc(x->nmeasr_orig * sizeof(float));
stdv=CTA_Malloc(x->nmeasr*sizeof(float));
// Look up all the standard deviations of the measurements in the observer:
/* read values from database. First read entire vcd-array. Note: netcdf file should first be opened */
// Get the netcdf-id of the database
ncid = x->database->ncid;
// read the vcd vector. We know the size: nmeasr_orig. OMI-vcd vector contains one float per entry.
ierr = nc_inq_varid(ncid, "sigma_vcd_trop", &varid);
ierr = nc_get_var_float(ncid, varid, &nc_values[0]);
if (IDEBUG>0) {printf("variance has been read %f \n",nc_values[0]);}
if (ierr != CTA_OK)
{printf("Error: could not read sigma_vcd_trop \n");
*retval = -1; return;}
// now fill the stdv array. The relation table is used to get only the selection.
ierr = CTA_RelTable_ApplyVal(x->selectionReltab, nc_values, x->nmeasr_orig,
stdv, x->nmeasr, CTA_REAL);
if (ierr != CTA_OK)
{printf("Error: reltable_applyval in netcdf_getcovmat; nobs:%d of %d \n",x->nmeasr,x->nmeasr_orig);
*retval = -1; return;}
// Fill in the variances in the variable matval (matrix values)
if (IDEBUG>0) {printf("filling matrix of size %d...%f %f \n",x->nmeasr,stdv[0],stdv[1]);}
matval=CTA_Malloc(x->nmeasr * x->nmeasr * sizeof(double));
for (i=0;i < x->nmeasr * x->nmeasr ; i++){matval[i]=0.0;}
for (i=0;i < x->nmeasr ; i++){
matval[i * x->nmeasr + i] = stdv[i]*stdv[i];
}
free(stdv);
free(nc_values);
*retval = CTA_Matrix_SetVals( *hmat, matval, x->nmeasr, x->nmeasr,
CTA_DOUBLE);
free(matval);
if (IDEBUG>0) {printf("getcovmat completed! \n");}
if (*retval!=CTA_OK) return;
*retval=CTA_OK;
*retval = CTA_OK;
return ;
#else
printf("Error: CTAI_SObs_netcdf_GetCovMat: COSTA is compiled without NETCDFsupport\n");
*retval=CTA_NOT_IMPLEMENTED;
#endif
};
/*+++++++++++++++++++++++++
.IDENTifer SCIA_RD_NC_HDO_REC
.PURPOSE read records from IMAP-HDO product in netCDF-4 (ADAGUC standard)
.INPUT/OUTPUT
call as numRec = SCIA_RD_NC_HDO_REC( ncid, &rec );
input:
int ncid : netCDF file ID
output:
struct imap_rec **rec : IMAP records
.RETURNS number of IMAP records (unsigned int)
.COMMENTS static function
-------------------------*/
unsigned int SCIA_RD_NC_HDO_REC( int ncid, struct imap_rec **rec_out )
{
register unsigned int ni, nr;
unsigned int numRec = 0;
int retval;
int time_id;
int var_id;
size_t indx, length;
float *rbuff = NULL;
double *dbuff = NULL;
struct imap_rec *rec = NULL;
const size_t nr_byte = NUM_CORNERS * sizeof(float);
rec_out[0] = NULL;
/*
* get size of dimension scale "time"
*/
if ( (retval = nc_inq_dimid( ncid, "time", &time_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
if ( (retval = nc_inq_dimlen( ncid, time_id, &length )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
numRec = (unsigned int) length;
rec = (struct imap_rec *) malloc( numRec * sizeof(struct imap_rec) );
if ( rec == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "rec" );
/*
* read Julian date of measurements
*/
dbuff = (double *) malloc( numRec * sizeof(double) );
if ( dbuff == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "dbuff" );
if ( (retval = nc_inq_varid( ncid, "time", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_double( ncid, var_id, dbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].jday = dbuff[nr];
free( dbuff );
/*
* read longitude and latitude of measurements
*/
rbuff = (float *) malloc( numRec * sizeof(float) );
if ( rbuff == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "rbuff" );
if ( (retval = nc_inq_varid( ncid, "lon", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].lon_center = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "lat", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].lat_center = rbuff[nr];
/*
* read datasets (HDO, HDO_error, H2O, H2O_error, H2O_model, delta_d)
*/
/*+++++++++++++++++++++++++*/
if ( (retval = nc_inq_varid( ncid, "H2O", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].h2o_vcd = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "H2O_error", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].h2o_error = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "H2O_model", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].h2o_model = rbuff[nr];
/*+++++++++++++++++++++++++*/
if ( (retval = nc_inq_varid( ncid, "HDO", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].hdo_vcd = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "HDO_error", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].hdo_error = rbuff[nr];
/*+++++++++++++++++++++++++*/
if ( (retval = nc_inq_varid( ncid, "delta_d", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].delta_d = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "delta_d_error", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].delta_d_error = rbuff[nr];
/*
* read longitude and latitude bounding boxes
*/
rbuff = (float *) realloc( rbuff, NUM_CORNERS * numRec * sizeof(float) );
if ( rbuff == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "rbuff" );
if ( (retval = nc_inq_varid( ncid, "lon_bnds", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( ni = nr = 0; nr < numRec; nr++, ni += NUM_CORNERS )
(void) memcpy( rec[nr].lon_corner, rbuff+ni, nr_byte );
if ( (retval = nc_inq_varid( ncid, "lat_bnds", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( ni = nr = 0; nr < numRec; nr++, ni += NUM_CORNERS )
(void) memcpy( rec[nr].lat_corner, rbuff+ni, nr_byte );
/*
* read pixel meta-data as compound dataset
*/
if ( (retval = nc_inq_varid( ncid, "tile_properties", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
for ( indx = 0; indx < (size_t) numRec; indx++ ) {
retval = nc_get_var1( ncid, var_id, &indx, &rec[indx].meta );
}
rec_out[0] = rec;
return numRec;
done:
if ( rec != NULL ) free( rec );
if ( rbuff != NULL ) free( rbuff );
if ( dbuff != NULL ) free( dbuff );
return 0;
}
void CTAI_SObs_netcdf_GetVals(
// Get all the values from a netcdf-StochObserver
// INPUTS
CTAI_SObs_netcdf *x, // StochObserver from which the measurements are
// returned
// OUTPUTS
CTA_Vector *hvec, // COSTA-vector containing the values
int *retval
)
{
#if HAVE_LIBNETCDF
int ierr, ncid, varid;
CTA_Datatype datatype;
float *nc_vcd_values;
CTA_Vector hvcd;
/* Get datatype of vector */
*retval=CTA_Vector_GetDatatype(*hvec,&datatype);
if (*retval!=CTA_OK) return;
/* read values from database. First read entire vcd-array. Note: netcdf file should first be opened */
// Get the netcdf-id of the database
ncid = x->database->ncid;
// read the vcd vector. We know the size: nmeasr_orig. OMI-vcd vector contains one float per entry.
// first allocate space for temporary arrays
nc_vcd_values = CTA_Malloc(x->nmeasr_orig * sizeof(float));
ierr = nc_inq_varid(ncid, "vcd_trop", &varid);
ierr = nc_get_var_float(ncid, varid, &nc_vcd_values[0]);
if (ierr != CTA_OK)
{printf("Error: could not read vcd_trop \n");
*retval = -1;
return;}
// now fill the values array with the vcd_trop. The
// relation table is used to get only the selection.
ierr = CTA_Vector_Create(CTA_DEFAULT_VECTOR, x->nmeasr_orig, CTA_REAL, CTA_NULL,&hvcd);
ierr = CTA_Vector_SetVals(hvcd, nc_vcd_values, x->nmeasr_orig, CTA_REAL);
ierr = CTA_RelTable_Apply(x->selectionReltab, hvcd, *hvec);
// TODO: use the kernel and lon/lat info to couple the no2-conc to specific imerid,izonal and iverti
// This is done in the model_obs!
CTA_Vector_Free(&hvcd);
free(nc_vcd_values);
if (*retval!=CTA_OK) return;
*retval = CTA_OK;
#else
printf("Error: CTAI_SObs_netcdf_GetVals: COSTA is compiled without NETCDFsupport\n");
*retval=CTA_NOT_IMPLEMENTED;
#endif
};
void CTAI_SObs_netcdf_CreateSelString(
/*
Allocate the memory which is necessary to store the data necessary for a
netcdf-observer
*/
// INPUTS
CTAI_SObs_netcdf *obsin,// The netcdf-observer of which a selection
// is to be made
CTA_Handle userdata, // User data: condition
// OUTPUTS
CTAI_SObs_netcdf *obsout, // The netcdf-observer which is a selection
// of observer obsin
int *retval) // Error code
{
#if HAVE_LIBNETCDF
int len, ierr,i ;
char *condition;
double t1_in,t2_in, t1,t2, t1_out, t2_out;
float t1_f, t2_f;
int nstations, count_out, varid;
CTA_Vector hvec_time;
double *vec_time;
int *selvec, *flag;
CTA_RelTable reltab1;
float bbx_1, bbx_2, bby_1, bby_2;
float *nc_values1, *nc_values2, *nc_sel_values1, *nc_sel_values2;
if (IDEBUG>0) {printf("DEBUG: CTAI_SObs_netcdf_CreateSelString START\n");}
if (IDEBUG>0) {printf("DEBUG: *obsin: %p \n", obsin);}
if (IDEBUG>0) {printf("DEBUG: *obsout: %p \n", obsout);}
// Allocate a name-string
*retval = CTA_String_GetLength(userdata, &len);
if (*retval!=CTA_OK) return;
// Get the condition
condition = CTA_Malloc((len+1)*sizeof(char));
ierr = CTA_String_Get(userdata, condition);
if (ierr!=CTA_OK) return;
// Link the database also to this observer and keep track of the number of
// observers using this database
obsout->database = obsin->database;
obsout->database->nusers++;
// IF the callling sequence has been : cta_sobs_createtimsel -> cta_sobs_createsel ->
// ctai_sobs_netcdf_createsel, THEN
// The condition is the string starting with 'time BETWEEN'
if (strstr(condition,"time BETWEEN") != NULL) {
//printf("condition string is: |%s| \n",condition);
ierr = sscanf(condition,"%*s %*s %f %*s %f",&t1_f,&t2_f); t1 = t1_f; t2=t2_f;
} else {
t1 = 0.0; t2 = 24.0;
}
if (IDEBUG>0){
printf("ctai_sobs_createselstring: time selection: %s %f %f %d \n",obsout->database->dbname,t1,t2,ierr);
}
// It may be possible that a spatial restriction is given.
for (i=0; i < 2; i++) {
obsout->bb_lon[i] = obsin->bb_lon[i];
obsout->bb_lat[i] = obsin->bb_lat[i];
}
/* spatial selection: */
if (strstr(condition,"bounding box") !=NULL) {
ierr = sscanf(condition,"%*s %*s %f %f %f %f ",&bbx_1,&bbx_2, &bby_1,&bby_2);
obsout->bb_lon[0] = bbx_1; obsout->bb_lon[1] = bbx_2;
obsout->bb_lat[0] = bby_1; obsout->bb_lat[1] = bby_2;
// printf("SOBS_NETCDF_CREATESEL: condition |%s| \n",condition);
//printf("SOBS_NETCDF_CREATESEL: condition window is: %f %f %f %f \n",bbx_1,bbx_2,bby_1,bby_2);
}
// Combine the input-condition and the condition of the input observer.
// In our netcdf-case, the condition is a combination of spatial window and timespan.
ierr = CTA_Time_GetSpan(obsin->tspan, &t1_in, &t2_in);
t1_out = MAX(t1_in,t1);
t2_out = MIN(t2_in,t2);
ierr = CTA_Time_Create(&(obsout->tspan));
ierr = CTA_Time_SetSpan(obsout->tspan, t1_out, t2_out);
if (ierr != CTA_OK) {printf("time_create in ctai_sobs_netcdf_createsel FAILED!\n");}
// We must recompute the number of stations after selection. Also, the relation table should be adjusted.
// first get the time vector.
ierr = CTA_Vector_Create(CTA_DEFAULT_VECTOR, obsin->nmeasr, CTA_DOUBLE, CTA_NULL, &hvec_time);
CTAI_SObs_netcdf_GetTimes(obsin, &hvec_time, &ierr);
vec_time = CTA_Malloc(obsin->nmeasr * sizeof(double));
ierr=CTA_Vector_GetVals(hvec_time,vec_time, obsin->nmeasr, CTA_DOUBLE);
if (IDEBUG>5){
printf("createsel: ierr time vector %d ; timespan: %f %f \n",ierr, t1_out, t2_out);
printf("vectime, %f %f \n",vec_time[0],vec_time[1]);
}
// We use the relation table to investigate if the current selection should be restricted more.
nc_values1 = CTA_Malloc(obsin->nmeasr_orig * sizeof(float));
nc_values2 = CTA_Malloc(obsin->nmeasr_orig * sizeof(float));
nc_sel_values1 = CTA_Malloc(obsin->nmeasr * sizeof(float));
nc_sel_values2 = CTA_Malloc(obsin->nmeasr * sizeof(float));
nc_inq_varid(obsin->database->ncid, "longitude", &varid);
nc_get_var_float(obsin->database->ncid, varid, &nc_values1[0]);
nc_inq_varid(obsin->database->ncid, "latitude", &varid);
nc_get_var_float(obsin->database->ncid, varid, &nc_values2[0]);
CTA_RelTable_ApplyVal(obsin->selectionReltab, nc_values1, obsin->nmeasr_orig,
nc_sel_values1,obsin->nmeasr, CTA_REAL);
CTA_RelTable_ApplyVal(obsin->selectionReltab, nc_values2, obsin->nmeasr_orig,
nc_sel_values2,obsin->nmeasr, CTA_REAL);
if (IDEBUG>10){
printf("latitudes of obsin: \n");
for (i=0; i < MIN(15,obsin->nmeasr); i++) {
printf(" %d %f\n ",i, nc_values2[i]);
}
printf("------------%f %f ------\n",obsout->bb_lat[0],obsout->bb_lat[1]);
}
count_out = 0;
flag=CTA_Malloc((obsin->nmeasr)*sizeof(int));
for (i=0; i < obsin->nmeasr; i++) {
flag[i]= 0;
if ((vec_time[i] >= t1_out) && (vec_time[i] <=t2_out) &&
(nc_sel_values1[i] > obsout->bb_lon[0]) && (nc_sel_values1[i] < obsout->bb_lon[1])
&& (nc_sel_values2[i] > obsout->bb_lat[0]) && (nc_sel_values2[i] < obsout->bb_lat[1])
) {
flag[i] = 1;
//printf("selected: %d = %f ; lat %f \n",i,vec_time[i], nc_sel_values2[i]);
count_out = count_out + 1;
}
}
free(nc_values1); free(nc_values2);free(nc_sel_values1);free(nc_sel_values2);
nstations = count_out;
obsout->nstations = nstations;
obsout->nmeasr = nstations;
if (IDEBUG>0) {printf("selection made: now %d stations \n",nstations);}
// make the relation table for this restriction
ierr = CTA_RelTable_Create(&reltab1);
selvec = CTA_Malloc(obsout->nmeasr * sizeof(int));
count_out = 0;
for (i=0; i < obsin->nmeasr; i++) {
if (flag[i] > 0 && count_out < obsout->nmeasr) {
selvec[count_out] = i+1;
count_out = count_out + 1;
}
}
ierr = CTA_RelTable_SetSelectVal(reltab1, selvec, obsout->nmeasr, CTA_INTEGER);
if (IDEBUG>5){printf("createselstring: setselect ierr %d \n",ierr);}
// now combine the two relation tables to get the whole selection
ierr = CTA_RelTable_Create(&(obsout->selectionReltab)); //moet dit?????
ierr=CTA_RelTable_SetTableCombine(obsout->selectionReltab, obsin->selectionReltab, CTA_FALSE,
reltab1, CTA_FALSE);
obsout->nmeasr_orig = obsin->nmeasr_orig;
obsout->timeoffset = obsin->timeoffset;
//printf("createsel: ierr reltable_combine: end %d \n",ierr);
free(vec_time);free(selvec);
free(flag);
ierr = CTA_RelTable_Free(&reltab1);
*retval = CTA_OK;
if (IDEBUG>0){printf("createselstring %s : END: from %d to %d \n",obsin->database->dbname,obsin->nmeasr, obsout->nmeasr);}
if (IDEBUG>10){printf("createsel: END: lat.window %f to %f \n",obsout->bb_lat[0], obsout->bb_lat[1]);}
#else
printf("Error: CTAI_SObs_netcdf_CreateSelString: COSTA is compiled without NETCDF support\n");
*retval=CTA_NOT_IMPLEMENTED;
#endif
};
int
main(int argc, char **argv)
{
#ifdef USE_PARALLEL
MPI_Init(&argc, &argv);
#endif
int ncid, dimids[3];
int char_varid, byte_varid, ubyte_varid, short_varid, int_varid, float_varid, double_varid;
int ushort_varid, uint_varid, int64_varid, uint64_varid;
int i, j;
unsigned char ubyte_out[DIM1_LEN][DIM2_LEN] = {{1, 128, 255},{1, 128, 255}};
signed char byte_in[DIM1_LEN][DIM2_LEN], byte_out[DIM1_LEN][DIM2_LEN] = {{-127, 1, 127},{-127, 1, 127}};
unsigned short ushort_out[DIM1_LEN][DIM2_LEN] = {{110, 128, 255},{110, 128, 255}};
short short_in[DIM1_LEN][DIM2_LEN], short_out[DIM1_LEN][DIM2_LEN] = {{-110, -128, 255},{-110, -128, 255}};
int int_in[DIM1_LEN][DIM2_LEN], int_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
float float_in[DIM1_LEN][DIM2_LEN], float_out[DIM1_LEN][DIM2_LEN] = {{-.1, 9999.99, 100.001},{-.1, 9999.99, 100.001}};
double double_in[DIM1_LEN][DIM2_LEN], double_out[DIM1_LEN][DIM2_LEN] = {{0.02, .1128, 1090.1},{0.02, .1128, 1090.1}};
unsigned int uint_in[DIM1_LEN][DIM2_LEN], uint_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}};
long long int64_in[DIM1_LEN][DIM2_LEN], int64_out[DIM1_LEN][DIM2_LEN] = {{-111, 777, 100},{-111, 777, 100}};
unsigned long long uint64_in[DIM1_LEN][DIM2_LEN];
unsigned long long uint64_out[DIM1_LEN][DIM2_LEN] = {{0, 10101, 9999999},{0, 10101, 9999999}};
char char_out[DIM1_LEN][DIM2_LEN][DIM3_LEN] = {{"lalala", "lololo", "lelele"}, {"lalala", "lololo", "lelele"}};
/*nc_set_log_level(4);*/
printf("\n*** Testing netcdf-4 variable functions.\n");
printf("*** testing netcdf-4 varids inq on netcdf-3 file...");
{
int nvars_in, varids_in[2];
/* Create a netcdf-3 file with one dim and two vars. */
if (nc_create(FILE_NAME, 0, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and make sure nc_inq_varids yeilds correct
* result. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR;
if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing simple variables...");
{
/* Create a file with a variable of each type. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR;
if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR;
if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR;
if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR;
if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR;
if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR;
if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR;
if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR;
if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR;
if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR;
if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR;
if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR;
if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR;
if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR;
if (nc_put_var_ubyte(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR;
if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR;
if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR;
if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR;
if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check metadata. */
{
nc_type xtype_in;
int ndims_in, dimids_in[10], natts_in, varid_in;
char name_in[NC_MAX_NAME+1];
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE ||
ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
dimids_in[1] != dimids[1]) ERR;
if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR;
if (varid_in != 1) ERR;
if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR;
if (varid_in != 2) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME)) ERR;
if (nc_inq_varname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, VAR_CHAR_NAME)) ERR;
if (nc_inq_varname(ncid, 2, name_in)) ERR;
if (strcmp(name_in, VAR_SHORT_NAME)) ERR;
if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
if (xtype_in != NC_BYTE) ERR;
if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
if (xtype_in != NC_CHAR) ERR;
if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
if (xtype_in != NC_SHORT) ERR;
if (nc_close(ncid)) ERR;
}
/* Open the file and check data. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != byte_out[i][j]) ERR;
if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (short_in[i][j] != short_out[i][j]) ERR;
if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int_in[i][j] != int_out[i][j]) ERR;
if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (float_in[i][j] != float_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint_in[i][j] != uint_out[i][j]) ERR;
if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int64_in[i][j] != int64_out[i][j]) ERR;
if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint64_in[i][j] != uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as double. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)byte_out[i][j]) ERR;
if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)short_out[i][j]) ERR;
if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint_out[i][j]) ERR;
if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)float_out[i][j]) ERR;
if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int64_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as NC_BYTE. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define DEFLATE_LEVEL_4 4
printf("*** testing simple variables with deflation...");
{
/* Create a file with a variable of each type. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR;
if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR;
if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR;
if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR;
if (nc_def_var_deflate(ncid, byte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR;
if (nc_def_var_deflate(ncid, byte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR;
if (nc_def_var_deflate(ncid, short_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR;
if (nc_def_var_deflate(ncid, int_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR;
if (nc_def_var_deflate(ncid, float_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR;
if (nc_def_var_deflate(ncid, double_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR;
if (nc_def_var_deflate(ncid, ubyte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR;
if (nc_def_var_deflate(ncid, ushort_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR;
if (nc_def_var_deflate(ncid, uint_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR;
if (nc_def_var_deflate(ncid, int64_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR;
if (nc_def_var_deflate(ncid, uint64_varid, 0, 1, DEFLATE_LEVEL_4)) ERR;
if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR;
if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR;
if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR;
if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR;
if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR;
if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR;
if (nc_put_var_ubyte(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR;
if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR;
if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR;
if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR;
if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check metadata. */
{
nc_type xtype_in;
int ndims_in, dimids_in[10], natts_in, varid_in;
char name_in[NC_MAX_NAME+1];
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in,
&natts_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE ||
ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] ||
dimids_in[1] != dimids[1]) ERR;
if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR;
if (varid_in != 1) ERR;
if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR;
if (varid_in != 2) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, VAR_BYTE_NAME)) ERR;
if (nc_inq_varname(ncid, 1, name_in)) ERR;
if (strcmp(name_in, VAR_CHAR_NAME)) ERR;
if (nc_inq_varname(ncid, 2, name_in)) ERR;
if (strcmp(name_in, VAR_SHORT_NAME)) ERR;
if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR;
if (xtype_in != NC_BYTE) ERR;
if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR;
if (xtype_in != NC_CHAR) ERR;
if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR;
if (xtype_in != NC_SHORT) ERR;
if (nc_close(ncid)) ERR;
}
/* Open the file and check data. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != byte_out[i][j]) ERR;
if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (short_in[i][j] != short_out[i][j]) ERR;
if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int_in[i][j] != int_out[i][j]) ERR;
if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (float_in[i][j] != float_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != double_out[i][j]) ERR;
if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint_in[i][j] != uint_out[i][j]) ERR;
if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (int64_in[i][j] != int64_out[i][j]) ERR;
if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (uint64_in[i][j] != uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as double. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)byte_out[i][j]) ERR;
if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ubyte_out[i][j]) ERR;
if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)short_out[i][j]) ERR;
if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)ushort_out[i][j]) ERR;
if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint_out[i][j]) ERR;
if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)float_out[i][j]) ERR;
if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)int64_out[i][j]) ERR;
if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (double_in[i][j] != (double)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and read everything as NC_BYTE. */
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR;
if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)short_out[i][j]) ERR;
if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR;
if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)float_out[i][j]) ERR;
if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR;
if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR;
for (i = 0; i < DIM1_LEN; i++)
for (j = 0; j < DIM2_LEN; j++)
if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NDIMS4 1
#define NVARS4 1
#define DIM4_NAME "treaty_of_paris_1783"
#define DIM4_LEN 5
#define VAR_NAME4 "John_Adams"
#define DEFLATE_LEVEL 6
printf("*** testing netcdf-4 simple variable define...");
{
int dimids[NDIMS4], dimids_in[NDIMS4];
int varid, varids_in[NVARS4];
int ndims, nvars, natts, unlimdimid;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level;
/* Create a netcdf-4 file with one dim and one var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM4_NAME, DIM4_LEN, &dimids[0])) ERR;
if (dimids[0] != 0) ERR;
if (nc_def_var(ncid, VAR_NAME4, NC_INT64, NDIMS4, dimids, &varid)) ERR;
if (nc_def_var_deflate(ncid, varid, 0, 1, DEFLATE_LEVEL)) ERR;
if (varid != 0) ERR;
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS4) ERR;
if (varids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level)) ERR;
if (shuffle_in ||!deflate_in ||
deflate_level != DEFLATE_LEVEL) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS4) ERR;
if (varids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level)) ERR;
if (shuffle_in ||!deflate_in ||
deflate_level != DEFLATE_LEVEL) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NDIMS5 1
#define NVARS5 5
#define DIM5_NAME "treaty_of_paris_1783"
#define DIM5_LEN 5
printf("*** testing netcdf-4 less simple variable define...");
{
int dimids[NDIMS5], dimids_in[NDIMS5];
int varid[NVARS5], varids_in[NVARS5];
int ndims, nvars, natts, unlimdimid;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
char var_name[NVARS5][NC_MAX_NAME + 1] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
"Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
"Charles_F_Ritchel"};
int shuffle_in, deflate_in, deflate_level_in;
int deflate_level[NVARS5];
int i;
/* Set up options for this var. */
for (i = 0; i < NVARS5; i++)
deflate_level[i] = i;
/* Create a netcdf-4 file with one dim and two vars. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM5_NAME, DIM5_LEN, &dimids[0])) ERR;
if (dimids[0] != 0) ERR;
for (i = 0; i < NVARS5; i++)
{
if (nc_def_var(ncid, var_name[i], NC_INT64, NDIMS5, dimids,
&varid[i])) ERR;
if (varid[i] != i) ERR;
if (nc_def_var_deflate(ncid, varid[i], 1, 1, deflate_level[i])) ERR;
}
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS5) ERR;
for (i = 0; i < NVARS5; i++)
{
if (varids_in[i] != i) ERR;
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (!shuffle_in || !deflate_in ||
deflate_level_in != deflate_level[i]) ERR;
}
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS5) ERR;
for (i = 0; i < NVARS5; i++)
{
if (varids_in[i] != i) ERR;
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (!shuffle_in || !deflate_in ||
deflate_level_in != deflate_level[i]) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NVARS 5
#define NDIMS 1
#define DIM6_NAME "airship_cross_sectional_area"
#define DIM6_LEN 100
#define TEN_K_M2 10000.0
#define INCREMENT 1000.0
printf("*** testing more complex netcdf-4 variable defines...");
{
int dimids[NDIMS], dimids_in[NDIMS];
int varid[NVARS], varids_in[NVARS];
int ndims, nvars, natts, unlimdimid;
char var_name[NVARS][50] = {"Jean-Pierre_Blanchard", "Madame_Blanchard",
"Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome",
"Charles_F_Ritchel"};
double data[DIM6_LEN];
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level_in;
int fletcher32_in;
int i;
/* Create some phoney data. */
for (i = 1, data[0] = TEN_K_M2; i < DIM6_LEN; i++)
data[i] = data[i - 1] + INCREMENT;
/* Create a netcdf-4 file with one dim and 5 NC_DOUBLE vars. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM6_NAME, DIM6_LEN, &dimids[0])) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_def_var(ncid, var_name[i], NC_DOUBLE, NDIMS, dimids,
&varid[i])) ERR;
if (nc_def_var_deflate(ncid, varid[i], 0, 1, 0)) ERR;
if (nc_def_var_fletcher32(ncid, varid[i], 1)) ERR;
}
/* Check stuff. */
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS) ERR;
for (i = 0; i < NVARS; i++)
if (varids_in[i] != i) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || !deflate_in || deflate_level_in != 0) ERR;
if (nc_inq_var_fletcher32(ncid, varid[i], &fletcher32_in)) ERR;
if (!fletcher32_in) ERR;
}
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != NDIMS || nvars != NVARS || natts != 0 ||
unlimdimid != -1) ERR;
if (nc_inq_varids(ncid, &nvars, varids_in)) ERR;
if (nvars != NVARS) ERR;
for (i = 0; i < NVARS; i++)
if (varids_in[i] != i) ERR;
for (i = 0; i < NVARS; i++)
{
if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || !deflate_in ||
deflate_level_in != 0) ERR;
if (nc_inq_var_fletcher32(ncid, varid[i], &fletcher32_in)) ERR;
if (!fletcher32_in) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define DIM7_LEN 2
#define DIM7_NAME "dim_7_from_Indiana"
#define VAR7_NAME "var_7_from_Idaho"
#define NDIMS 1
printf("*** testing fill values...");
{
int dimids[NDIMS], dimids_in[NDIMS];
size_t index[NDIMS];
int varid, ndims, natts;
nc_type xtype_in;
char name_in[NC_MAX_NAME + 1];
int shuffle_in, deflate_in, deflate_level_in;
int fletcher32_in, no_fill;
unsigned short ushort_data = 42, ushort_data_in, fill_value_in;
/* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR;
if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids,
&varid)) ERR;
/* Check stuff. */
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || deflate_in) ERR;
if (nc_inq_var_fletcher32(ncid, 0, &fletcher32_in)) ERR;
if (fletcher32_in) ERR;
if (nc_inq_var_fill(ncid, 0, &no_fill, &fill_value_in)) ERR;
if (no_fill || fill_value_in != NC_FILL_USHORT) ERR;
/* Write the second of two values. */
index[0] = 1;
if (nc_put_var1_ushort(ncid, 0, index, &ushort_data)) ERR;
/* Get the first value, and make sure we get the default fill
* value for USHORT. */
index[0] = 0;
if (nc_get_var1_ushort(ncid, 0, index, &ushort_data_in)) ERR;
if (ushort_data_in != NC_FILL_USHORT) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check stuff. */
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims,
dimids_in, &natts)) ERR;
if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT ||
ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR;
if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in,
&deflate_level_in)) ERR;
if (shuffle_in || deflate_in) ERR;
if (nc_inq_var_fletcher32(ncid, 0, &fletcher32_in)) ERR;
if (fletcher32_in) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing more fill values...");
{
int dimids[NDIMS];
size_t index[NDIMS];
int varid;
int no_fill;
unsigned short ushort_data = 42, ushort_data_in, fill_value_in;
/* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR;
if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids,
&varid)) ERR;
if (nc_def_var_fill(ncid, varid, 1, NULL)) ERR;
/* Check stuff. */
if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
if (!no_fill) ERR;
/* Write the second of two values. */
index[0] = 1;
if (nc_put_var1_ushort(ncid, varid, index, &ushort_data)) ERR;
/* Get the first value, and make sure we get the default fill
* value for USHORT. */
index[0] = 0;
if (nc_get_var1_ushort(ncid, varid, index, &ushort_data_in)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and check the same stuff. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check stuff. */
if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR;
if (!no_fill) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** testing lots of variables...");
#define DIM_A_NAME "x"
#define DIM_A_LEN 10
#define NUM_VARS 2000
#define MAX_VARNAME 10
{
/* This simple test failed on HDF5 1.7.58, but passes just fine
* on 1.8.0 alpha5... */
int ncid, dimids[1], i;
char varname[MAX_VARNAME];
int varids[NUM_VARS];
/* Create a file with three dimensions. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_A_NAME, DIM_A_LEN, &dimids[0])) ERR;
/* Create a large number of variables. */
for (i = 0; i < NUM_VARS; i++)
{
sprintf(varname, "a_%d", i);
if (nc_def_var(ncid, varname, NC_FLOAT, 1, dimids, &varids[i])) ERR;
}
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define NC3_CLASSIC_FILE "tst_pres_temp_4D_classic.nc"
#define NC3_64BIT_OFFSET_FILE "tst_pres_temp_4D_64bit_offset.nc"
#define NC3_NETCDF4_FILE "tst_pres_temp_4D_netcdf4.nc"
#define NC3_NETCDF4_CLASSIC_FILE "tst_pres_temp_4D_netcdf4_classic.nc"
printf("*** testing 4D example file in classic format...");
if (create_4D_example(NC3_CLASSIC_FILE, NC_CLOBBER)) ERR;
if (check_4D_example(NC3_CLASSIC_FILE, NC_FORMAT_CLASSIC)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in 64-bit offset format...");
if (create_4D_example(NC3_64BIT_OFFSET_FILE, NC_CLOBBER|NC_64BIT_OFFSET)) ERR;
if (check_4D_example(NC3_64BIT_OFFSET_FILE, NC_FORMAT_64BIT)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in netCDF-4/HDF5 format...");
if (create_4D_example(NC3_NETCDF4_FILE, NC_CLOBBER|NC_NETCDF4)) ERR;
if (check_4D_example(NC3_NETCDF4_FILE, NC_FORMAT_NETCDF4)) ERR;
SUMMARIZE_ERR;
printf("*** testing 4D example file in netCDF-4/HDF5 format with classic model rules...");
if (create_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL)) ERR;
if (check_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_FORMAT_NETCDF4_CLASSIC)) ERR;
SUMMARIZE_ERR;
FINAL_RESULTS;
#ifdef USE_PARALLEL
MPI_Finalize();
#endif
}
int main (int argc, char **argv)
{
struct arguments arguments;
/* Default values. */
arguments.verbose = 0;
arguments.grd = 0;
arguments.region = NULL;
arguments.type = NULL;
static const int NUM_DAYS = 365;
/* Parse our arguments; every option seen by parse_opt will
be reflected in arguments. */
argp_parse (&argp, argc, argv, 0, 0, &arguments);
/* Set up variables */
int num_columns;
int num_rows;
char* region = arguments.region;
char* type = arguments.type;
int grd = arguments.grd;
int i,j,k;
/* Initialize NETCDF Variables */
int ncid, row_dimid, col_dimid;
int varid, wet_varid, dry_varid, slope_varid;
int retval;
char FILE_NAME[100];
int dimids[NDIMS];
/* multithread args */
thread_args t_args[NUM_THREADS];
pthread_t thread_id[NUM_THREADS];
int ind_per_thread;
int start_index;
int stop_index;
printf ("GEN_C0\n---------------\nBeginning processing with options:\n");
printf ("Region = %s\nVERBOSE = %s\nTYPE = %s\n---------------\n",
arguments.region,
arguments.verbose ? "yes" : "no",
arguments.type);
/* define image areas based on region */
if (!grd) {
if (strcmp(region,"Ama") == 0) {
num_columns = 1128;
num_rows = 744;
} else if (strcmp(region,"Ber") == 0) {
num_columns = 1350;
num_rows = 750;
} else if (strcmp(region,"CAm") == 0) {
num_columns = 1440;
num_rows = 700;
} else if (strcmp(region,"ChJ") == 0) {
num_columns = 1980;
num_rows = 950;
} else if (strcmp(region,"Eur") == 0) {
num_columns = 1530;
num_rows = 1040;
} else if (strcmp(region,"Ind") == 0) {
num_columns = 1800;
num_rows = 680;
} else if (strcmp(region,"NAf") == 0) {
num_columns = 2120;
num_rows = 1130;
} else if (strcmp(region,"NAm") == 0) {
num_columns = 1890;
num_rows = 1150;
} else if (strcmp(region,"SAf") == 0) {
num_columns = 1220;
num_rows = 1260;
} else if (strcmp(region,"SAm") == 0) {
num_columns = 1310;
num_rows = 1850;
} else if (strcmp(region,"SAs") == 0) {
num_columns = 1760;
num_rows = 720;
} else {
printf("ERROR SETTING REGION SIZES!");
exit(-1);
}
} else {
if (strcmp(region,"NAm") == 0) {
num_columns = 672;
num_rows = 410;
} else {
printf("ERROR SETTING REGION SIZES!");
exit(-1);
}
}
/* allocate memory for 2d arrays */
printf("Allocating Memory...");
float **c0_dry = (float**)malloc(sizeof(float *)*num_rows);
float **c0_wet = (float**)malloc(sizeof(float *)*num_rows);
float **dry_slope = (float**)malloc(sizeof(float *)*num_rows);
c0_dry[0] = (float*)malloc(sizeof(float)*num_rows*num_columns);
c0_wet[0] = (float*)malloc(sizeof(float)*num_rows*num_columns);
dry_slope[0] = (float*)malloc(sizeof(float)*num_rows*num_columns);
for (i = 1; i < num_rows; i++) {
c0_dry[i] = c0_dry[0] + i * num_columns;
c0_wet[i] = c0_wet[0] + i * num_columns;
dry_slope[i] = dry_slope[0] + i * num_columns;
}
memset(c0_dry[0],0,num_rows*num_columns*sizeof(float));
memset(c0_wet[0],0,num_rows*num_columns*sizeof(float));
memset(dry_slope[0],0,num_rows*num_columns*sizeof(float));
/* allocate memory for NetCDF File */
float ****row_ptr = (float****)malloc(sizeof(float ***)*num_rows);
float ***column_ptr = (float***)malloc(sizeof(float **)*num_rows * num_columns);
float **year_ptr = (float**)malloc(sizeof(float *)*num_rows * num_columns*NUM_YEARS);
float *day_ptr = (float*)malloc(sizeof(float)*num_rows*num_columns*NUM_YEARS*NUM_DAYS);
float ****tseries = row_ptr;
for (i = 0; i < num_rows; i++, column_ptr += num_columns) {
tseries[i] = column_ptr;
for (j = 0; j < num_columns; j++, year_ptr += NUM_YEARS) {
tseries[i][j] = year_ptr;
for (k = 0; k < NUM_YEARS; k++, day_ptr += NUM_DAYS) {
tseries[i][j][k] = day_ptr;
}
}
}
row_ptr = (float****)malloc(sizeof(float ***)*num_rows);
column_ptr = (float***)malloc(sizeof(float **)*num_rows * num_columns);
year_ptr = (float**)malloc(sizeof(float *)*num_rows * num_columns*NUM_YEARS);
day_ptr = (float*)malloc(sizeof(float)*num_rows*num_columns*NUM_YEARS*NUM_DAYS);
float ****tseriesb = row_ptr;
for (i = 0; i < num_rows; i++, column_ptr += num_columns) {
tseriesb[i] = column_ptr;
for (j = 0; j < num_columns; j++, year_ptr += NUM_YEARS) {
tseriesb[i][j] = year_ptr;
for (k = 0; k < NUM_YEARS; k++, day_ptr += NUM_DAYS) {
tseriesb[i][j][k] = day_ptr;
}
}
}
printf("done\n");
setvbuf (stdout, NULL, _IONBF, 0);
printf("Reading NetCDF Files...");
/* Open the netCDF time series a file*/
sprintf(FILE_NAME,"/auto/temp/lindell/soilmoisture/ts/ts_%s_%s.nc",region,"a");
if ((retval = nc_open(FILE_NAME, NC_NOWRITE, &ncid)))
ERR(retval);
/* Get the varid of the data variable, based on its name. */
if ((retval = nc_inq_varid(ncid, "data", &varid)))
ERR(retval);
/* read values from netCDF variable */
if ((retval = nc_get_var_float(ncid, varid, &tseries[0][0][0][0])))
ERR(retval);
/* Open the netCDF time series b file*/
sprintf(FILE_NAME,"/auto/temp/lindell/soilmoisture/ts/ts_%s_%s.nc",region,"b");
if ((retval = nc_open(FILE_NAME, NC_NOWRITE, &ncid)))
ERR(retval);
/* Get the varid of the data variable, based on its name. */
if ((retval = nc_inq_varid(ncid, "data", &varid)))
ERR(retval);
/* read values from netCDF variable */
if ((retval = nc_get_var_float(ncid, varid, &tseriesb[0][0][0][0])))
ERR(retval);
printf("done\n");
/* get threads ready */
/* split up column processing based on number of threads/rows */
ind_per_thread = num_rows / NUM_THREADS - 1;
start_index = 0;
stop_index = 0;
for (i = 0; i < NUM_THREADS; i++) {
if (i == NUM_THREADS - 1) {
stop_index = num_rows-1;
} else {
stop_index = start_index + ind_per_thread;
}
t_args[i].tseries = tseries;
t_args[i].tseriesb = tseriesb;
t_args[i].c0_wet = c0_wet;
t_args[i].c0_dry = c0_dry;
t_args[i].dry_slope = dry_slope;
t_args[i].start_i = start_index;
t_args[i].stop_i = stop_index;
t_args[i].num_columns = num_columns;
t_args[i].region = region;
t_args[i].type = type;
start_index = stop_index + 1;
}
/* call multithreaded function */
/* submit threads */
printf("Starting Processing\n");
for (i = 0; i < NUM_THREADS; i++) {
pthread_create(&thread_id[i], NULL, mthreadGenC0, &t_args[i]);
}
/* join threads */
for (i = 0; i < NUM_THREADS; i++) {
pthread_join(thread_id[i], NULL);
}
/* save min/max 2d arrays to netcdf file */
/* Create the file. */
sprintf(FILE_NAME,"/auto/temp/lindell/soilmoisture/c0/c0_%s.nc",region);
if ((retval = nc_create(FILE_NAME, NC_NETCDF4, &ncid)))
ERR(retval);
/* Define the dimensions. */
if ((retval = nc_def_dim(ncid, "row", num_rows, &row_dimid)))
ERR(retval);
if ((retval = nc_def_dim(ncid, "column", num_columns, &col_dimid)))
ERR(retval);
/* Define the netCDF variables. The dimids array is used to pass
the dimids of the dimensions of the variables.*/
dimids[0] = row_dimid;
dimids[1] = col_dimid;
/* define the variable */
if ((retval = nc_def_var(ncid, "dry", NC_FLOAT, NDIMS, dimids, &dry_varid)))
ERR(retval);
if ((retval = nc_def_var(ncid, "wet", NC_FLOAT, NDIMS, dimids, &wet_varid)))
ERR(retval);
if ((retval = nc_def_var(ncid, "dry_slope", NC_FLOAT, NDIMS, dimids, &slope_varid)))
ERR(retval);
/* End define mode. */
if ((retval = nc_enddef(ncid)))
ERR(retval);
/* Write the data. */
if ((retval = nc_put_var_float(ncid, dry_varid, &c0_dry[0][0])))
ERR(retval);
if ((retval = nc_put_var_float(ncid, wet_varid, &c0_wet[0][0])))
ERR(retval);
if ((retval = nc_put_var_float(ncid, slope_varid, &dry_slope[0][0])))
ERR(retval);
/* Close the file. */
if ((retval = nc_close(ncid)))
ERR(retval);
/* Free memory for 3D image timeseries array */
printf("Finishing up...");
free(tseries[0][0][0]);
free(tseries[0][0]);
free(tseries[0]);
free(tseries);
free(c0_wet[0]);
free(c0_dry[0]);
free(dry_slope[0]);
free(c0_wet);
free(c0_dry);
free(dry_slope);
printf("done\n");
exit (0);
}
int
main()
{
int ncid, pres_varid, temp_varid;
int lat_varid, lon_varid;
/* The start and count arrays will tell the netCDF library where to
read our data. */
size_t start[NDIMS], count[NDIMS];
/* Program variables to hold the data we will read. We will only
need enough space to hold one timestep of data; one record. */
float pres_in[NLVL][NLAT][NLON];
float temp_in[NLVL][NLAT][NLON];
/* These program variables hold the latitudes and longitudes. */
float lats[NLAT], lons[NLON];
/* Loop indexes. */
int lvl, lat, lon, rec, i = 0;
/* Error handling. */
int retval;
/* Open the file. */
if ((retval = nc_open(FILE_NAME, NC_NOWRITE, &ncid)))
ERR(retval);
/* Get the varids of the latitude and longitude coordinate
* variables. */
if ((retval = nc_inq_varid(ncid, LAT_NAME, &lat_varid)))
ERR(retval);
if ((retval = nc_inq_varid(ncid, LON_NAME, &lon_varid)))
ERR(retval);
/* Read the coordinate variable data. */
if ((retval = nc_get_var_float(ncid, lat_varid, &lats[0])))
ERR(retval);
if ((retval = nc_get_var_float(ncid, lon_varid, &lons[0])))
ERR(retval);
/* Check the coordinate variable data. */
for (lat = 0; lat < NLAT; lat++)
if (lats[lat] != START_LAT + 5.*lat)
return 2;
for (lon = 0; lon < NLON; lon++)
if (lons[lon] != START_LON + 5.*lon)
return 2;
/* Get the varids of the pressure and temperature netCDF
* variables. */
if ((retval = nc_inq_varid(ncid, PRES_NAME, &pres_varid)))
ERR(retval);
if ((retval = nc_inq_varid(ncid, TEMP_NAME, &temp_varid)))
ERR(retval);
/* Read the data. Since we know the contents of the file we know
* that the data arrays in this program are the correct size to
* hold one timestep. */
count[0] = 1;
count[1] = NLVL;
count[2] = NLAT;
count[3] = NLON;
start[1] = 0;
start[2] = 0;
start[3] = 0;
/* Read and check one record at a time. */
for (rec = 0; rec < NREC; rec++)
{
start[0] = rec;
if ((retval = nc_get_vara_float(ncid, pres_varid, start,
count, &pres_in[0][0][0])))
ERR(retval);
if ((retval = nc_get_vara_float(ncid, temp_varid, start,
count, &temp_in[0][0][0])))
ERR(retval);
/* Check the data. */
i = 0;
for (lvl = 0; lvl < NLVL; lvl++)
for (lat = 0; lat < NLAT; lat++)
for (lon = 0; lon < NLON; lon++)
{
if (pres_in[lvl][lat][lon] != SAMPLE_PRESSURE + i)
return 2;
if (temp_in[lvl][lat][lon] != SAMPLE_TEMP + i)
return 2;
i++;
}
} /* next record */
/* Close the file. */
if ((retval = nc_close(ncid)))
ERR(retval);
printf("*** SUCCESS reading example file pres_temp_4D.nc!\n");
return 0;
}
int
cpy_coord_val(int in_id,int out_id,char *var_nm,
int in_large, int out_large)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
char *var_nm: input variable name
*/
{
/* Routine to copy the coordinate data from an input netCDF file
* to an output netCDF file.
*/
const char *routine = NULL;
int i;
long spatial_dim, num_nodes;
long start[2], count[2];
nc_type var_type_in, var_type_out;
void *void_ptr;
/* Handle easiest situation first: in_large matches out_large */
if (in_large == out_large)
return cpy_var_val(in_id, out_id, var_nm);
/* At this point, know that in_large != out_large, so will need to
either copy a vector to multiple scalars or vice-versa. Also
will a couple dimensions, so get them now.*/
ex_get_dimension(in_id, DIM_NUM_DIM, "dimension", &spatial_dim, routine);
ex_get_dimension(in_id, DIM_NUM_NODES, "nodes", &num_nodes, routine);
if (in_large == 0 && out_large == 1) {
/* output file will have coordx, coordy, coordz (if 3d). */
/* Get the var_id for the requested variable from both files. */
int var_in_id, var_out_id[3];
var_in_id = ncvarid(in_id, VAR_COORD);
var_out_id[0] = ncvarid(out_id,VAR_COORD_X);
var_out_id[1] = ncvarid(out_id,VAR_COORD_Y);
var_out_id[2] = ncvarid(out_id,VAR_COORD_Z);
ncvarinq(in_id,var_in_id,(char *)NULL,&var_type_in,(int*)NULL,
(int *)NULL,(int *)NULL);
ncvarinq(out_id,var_out_id[0],(char *)NULL,&var_type_out,(int *)NULL,
(int *)NULL,(int *)NULL);
void_ptr=malloc(num_nodes * nctypelen(var_type_in));
/* Copy each component of the variable... */
for (i=0; i < spatial_dim; i++) {
start[0] = i; start[1] = 0;
count[0] = 1; count[1] = num_nodes;
ncvarget(in_id, var_in_id, start, count, void_ptr);
if (var_type_in == var_type_out) {
if (var_type_out == NC_FLOAT) {
nc_put_var_float(out_id, var_out_id[i], void_ptr);
} else {
nc_put_var_double(out_id, var_out_id[i], void_ptr);
}
} else if (var_type_in == NC_FLOAT && var_type_out == NC_DOUBLE) {
nc_put_var_double(out_id, var_out_id[i],
ex_conv_array(out_id, WRITE_CONVERT_UP, void_ptr, num_nodes));
} else if (var_type_in == NC_DOUBLE && var_type_out == NC_FLOAT) {
nc_put_var_float(out_id, var_out_id[i],
ex_conv_array(out_id, WRITE_CONVERT_DOWN, void_ptr, num_nodes));
}
}
}
if (in_large == 1 && out_large == 0) {
/* input file will have coordx, coordy, coordz (if 3d); output has
only "coord" */
int var_in_id[3], var_out_id;
var_in_id[0] = ncvarid(in_id, VAR_COORD_X);
var_in_id[1] = ncvarid(in_id, VAR_COORD_Y);
var_in_id[2] = ncvarid(in_id, VAR_COORD_Z);
var_out_id = ncvarid(out_id, VAR_COORD);
ncvarinq(in_id,var_in_id[0],(char *)NULL,&var_type_in,(int *)NULL,
(int *)NULL,(int *)NULL);
ncvarinq(out_id,var_out_id,(char *)NULL,&var_type_out,(int*)NULL,
(int *)NULL,(int *)NULL);
void_ptr=malloc(num_nodes * nctypelen(var_type_in));
/* Copy each component of the variable... */
for (i=0; i < spatial_dim; i++) {
if (var_type_in == NC_FLOAT) {
nc_get_var_float(in_id, var_in_id[i], void_ptr);
} else {
nc_get_var_double(in_id, var_in_id[i], void_ptr);
}
start[0] = i; start[1] = 0;
count[0] = 1; count[1] = num_nodes;
if (var_type_in == var_type_out) {
ncvarput(out_id, var_out_id, start, count, void_ptr);
} else if (var_type_in == NC_FLOAT && var_type_out == NC_DOUBLE) {
ncvarput(out_id, var_out_id, start, count,
ex_conv_array(out_id, WRITE_CONVERT_UP, void_ptr, num_nodes));
} else if (var_type_in == NC_DOUBLE && var_type_out == NC_FLOAT) {
ncvarput(out_id, var_out_id, start, count,
ex_conv_array(out_id, WRITE_CONVERT_DOWN, void_ptr, num_nodes));
}
}
}
/* Free the space that held the variable */
(void)free(void_ptr);
return(EX_NOERR);
} /* end cpy_coord_val() */
int
main(int argc, char **argv)
{
int ncid, dimid, fvarid, dvarid;
float fvals[NVALS], fvals_in[NVALS];
double dvals[NVALS], dvals_in[NVALS];
float fnan = NC_FNAN;//(NC_INFINITE-NC_INFINITE);//0.f/0.f;
double dnan = NC_DNAN;//(NC_INFINITE-NC_INFINITE);//0.0/0.0;
float fpinf = NC_FPINF;//NC_INFINITE;//1.0f/0.0f;
float fninf = -fpinf;
double dpinf = NC_DPINF;//NC_INFINITE;//1.0/0.0;
double dninf = -dpinf;
nc_type att_type;
size_t att_len;
float att_fvals[NVALS];
double att_dvals[NVALS];
printf("\n*** Testing NaN\n");
printf("*** creating NaN test file %s...", FILE8_NAME);
if (nc_create(FILE8_NAME, NC_CLOBBER, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME, NVALS, &dimid)) ERR;
if (nc_def_var(ncid, F_NAME, NC_FLOAT, NDIMS, &dimid, &fvarid)) ERR;
if (nc_def_var(ncid, D_NAME, NC_DOUBLE, NDIMS, &dimid, &dvarid)) ERR;
fvals[0] = fninf;
fvals[1] = fnan;
fvals[2] = fpinf;
dvals[0] = dninf;
dvals[1] = dnan;
dvals[2] = dpinf;
/* Create float and double attributes */
if (nc_put_att_float(ncid, fvarid, FV_NAME, NC_FLOAT, FV_NVALS, &fnan)) ERR;
if (nc_put_att_float(ncid, fvarid, ATT_NAME, NC_FLOAT, NVALS, fvals)) ERR;
if (nc_put_att_double(ncid, dvarid, FV_NAME, NC_DOUBLE, FV_NVALS, &dnan)) ERR;
if (nc_put_att_double(ncid, dvarid, ATT_NAME, NC_DOUBLE, NVALS, dvals)) ERR;
if (nc_enddef(ncid)) ERR;
/* Write float and double data */
if (nc_put_var_float(ncid, fvarid, fvals)) ERR;
if (nc_put_var_double(ncid, dvarid, dvals)) ERR;
if (nc_close(ncid)) ERR;
/* Check it out. */
/* Reopen the file. */
if (nc_open(FILE8_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_varid(ncid, F_NAME, &fvarid)) ERR;
if (nc_inq_varid(ncid, D_NAME, &dvarid)) ERR;
/* Check the values of the float attributes */
if (nc_inq_att(ncid, fvarid, FV_NAME, &att_type, &att_len)) ERR;
if (att_type != NC_FLOAT || att_len != FV_NVALS) ERR;
if (nc_get_att_float(ncid, fvarid, FV_NAME, att_fvals)) ERR;
if (!isnan(att_fvals[0])) ERR;
if (nc_get_att_float(ncid, fvarid, ATT_NAME, att_fvals)) ERR;
if (!(isinf(att_fvals[0]) && att_fvals[0] < 0)) ERR;
if (!isnan(att_fvals[1])) ERR;
if (!(isinf(att_fvals[2]) && att_fvals[2] > 0)) ERR;
/* Check the values of double attributes */
if (nc_inq_att(ncid, dvarid, FV_NAME, &att_type, &att_len)) ERR;
if (att_type != NC_DOUBLE || att_len != FV_NVALS) ERR;
if (nc_get_att_double(ncid, dvarid, FV_NAME, att_dvals)) ERR;
if (!isnan(att_dvals[0])) ERR;
if (nc_get_att_double(ncid, dvarid, ATT_NAME, att_dvals)) ERR;
if (!(isinf(att_dvals[0]) && att_dvals[0] < 0)) ERR;
if (!isnan(att_dvals[1])) ERR;
if (!(isinf(att_dvals[2]) && att_dvals[2] > 0)) ERR;
/* Check values of float data */
if (nc_get_var_float(ncid, fvarid, fvals_in)) ERR;
if (!(isinf(fvals_in[0]) && fvals_in[0] < 0)) ERR;
if (!isnan(fvals_in[1])) ERR;
if (!(isinf(fvals_in[2]) && fvals_in[2] > 0)) ERR;
/* Check values of double data */
if (nc_get_var_double(ncid, dvarid, dvals_in)) ERR;
if (!(isinf(dvals_in[0]) && dvals_in[0] < 0)) ERR;
if (!isnan(dvals_in[1])) ERR;
if (!(isinf(dvals_in[2]) && dvals_in[2] > 0)) ERR;
if (nc_close(ncid)) ERR;
SUMMARIZE_ERR;
FINAL_RESULTS;
}
/*! \internal */
int
cpy_coord_val(int in_id,int out_id,char *var_nm,
int in_large, int out_large)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
char *var_nm: input variable name
*/
{
/* Routine to copy the coordinate data from an input netCDF file
* to an output netCDF file.
*/
const char *routine = NULL;
int temp;
size_t i;
size_t spatial_dim, num_nodes;
size_t start[2], count[2];
nc_type var_type_in, var_type_out;
void *void_ptr = NULL;
/* Handle easiest situation first: in_large matches out_large */
if (in_large == out_large)
return cpy_var_val(in_id, out_id, var_nm);
/* At this point, know that in_large != out_large, so will need to
either copy a vector to multiple scalars or vice-versa. Also
will need a couple dimensions, so get them now.*/
ex_get_dimension(in_id, DIM_NUM_DIM, "dimension", &spatial_dim, &temp, routine);
ex_get_dimension(in_id, DIM_NUM_NODES, "nodes", &num_nodes, &temp, routine);
if (in_large == 0 && out_large == 1) {
/* output file will have coordx, coordy, coordz (if 3d). */
/* Get the var_id for the requested variable from both files. */
int var_in_id, var_out_id[3];
(void)nc_inq_varid(in_id, VAR_COORD, &var_in_id);
(void)nc_inq_varid(out_id, VAR_COORD_X, &var_out_id[0]);
(void)nc_inq_varid(out_id, VAR_COORD_Y, &var_out_id[1]);
(void)nc_inq_varid(out_id, VAR_COORD_Z, &var_out_id[2]);
(void)nc_inq_vartype( in_id, var_in_id, &var_type_in);
(void)nc_inq_vartype(out_id, var_out_id[0], &var_type_out);
if (num_nodes > 0)
void_ptr=malloc(num_nodes * type_size(var_type_in));
/* Copy each component of the variable... */
for (i=0; i < spatial_dim; i++) {
start[0] = i; start[1] = 0;
count[0] = 1; count[1] = num_nodes;
if (var_type_in == NC_FLOAT) {
nc_get_vara_float(in_id, var_in_id, start, count, void_ptr);
nc_put_var_float(out_id, var_out_id[i], void_ptr);
} else {
assert(var_type_in == NC_DOUBLE);
nc_get_vara_double(in_id, var_in_id, start, count, void_ptr);
nc_put_var_double(out_id, var_out_id[i], void_ptr);
}
}
}
if (in_large == 1 && out_large == 0) {
/* input file will have coordx, coordy, coordz (if 3d); output has only "coord" */
int var_in_id[3], var_out_id;
(void)nc_inq_varid(in_id, VAR_COORD_X, &var_in_id[0]);
(void)nc_inq_varid(in_id, VAR_COORD_Y, &var_in_id[1]);
(void)nc_inq_varid(in_id, VAR_COORD_Z, &var_in_id[2]);
(void)nc_inq_varid(out_id, VAR_COORD, &var_out_id);
(void)nc_inq_vartype(in_id, var_in_id[0], &var_type_in);
(void)nc_inq_vartype(out_id, var_out_id, &var_type_out);
if (num_nodes > 0)
void_ptr=malloc(num_nodes * type_size(var_type_in));
/* Copy each component of the variable... */
for (i=0; i < spatial_dim; i++) {
start[0] = i; start[1] = 0;
count[0] = 1; count[1] = num_nodes;
if (var_type_in == NC_FLOAT) {
nc_get_var_float( in_id, var_in_id[i], void_ptr);
nc_put_vara_float(out_id, var_out_id, start, count, void_ptr);
} else {
nc_get_var_double( in_id, var_in_id[i], void_ptr);
nc_put_vara_double(out_id, var_out_id, start, count, void_ptr);
}
}
}
/* Free the space that held the variable */
(void)free(void_ptr);
return(EX_NOERR);
} /* end cpy_coord_val() */
/*! \internal */
int
cpy_var_val(int in_id,int out_id,char *var_nm)
/*
int in_id: input netCDF input-file ID
int out_id: input netCDF output-file ID
char *var_nm: input variable name
*/
{
/* Routine to copy the variable data from an input netCDF file
* to an output netCDF file.
*/
int *dim_id;
int idx;
int nbr_dim;
int var_in_id;
int var_out_id;
size_t *dim_cnt;
size_t *dim_sz;
size_t *dim_srt;
size_t var_sz=1L;
nc_type var_type_in, var_type_out;
void *void_ptr = NULL;
/* Get the var_id for the requested variable from both files. */
(void)nc_inq_varid(in_id, var_nm, &var_in_id);
(void)nc_inq_varid(out_id,var_nm, &var_out_id);
/* Get the number of dimensions for the variable. */
(void)nc_inq_vartype( out_id, var_out_id, &var_type_out);
(void)nc_inq_varndims(out_id, var_out_id, &nbr_dim);
(void)nc_inq_vartype( in_id, var_in_id, &var_type_in);
(void)nc_inq_varndims(in_id, var_in_id, &nbr_dim);
/* Allocate space to hold the dimension IDs */
dim_cnt = malloc(nbr_dim*sizeof(size_t));
dim_id=malloc(nbr_dim*sizeof(int));
dim_sz=malloc(nbr_dim*sizeof(size_t));
dim_srt=malloc(nbr_dim*sizeof(size_t));
/* Get the dimension IDs from the input file */
(void)nc_inq_vardimid(in_id, var_in_id, dim_id);
/* Get the dimension sizes and names from the input file */
for(idx=0;idx<nbr_dim;idx++){
/* NB: For the unlimited dimension, ncdiminq() returns the maximum
value used so far in writing data for that dimension.
Thus if you read the dimension sizes from the output file, then
the ncdiminq() returns dim_sz=0 for the unlimited dimension
until a variable has been written with that dimension. This is
the reason for always reading the input file for the dimension
sizes. */
(void)nc_inq_dimlen(in_id,dim_id[idx],dim_cnt+idx);
/* Initialize the indicial offset and stride arrays */
dim_srt[idx]=0L;
var_sz*=dim_cnt[idx];
} /* end loop over dim */
/* Allocate enough space to hold the variable */
if (var_sz > 0)
void_ptr=malloc(var_sz * type_size(var_type_in));
/* Get the variable */
/* if variable is float or double, convert if necessary */
if(nbr_dim==0){ /* variable is a scalar */
if (var_type_in == NC_INT && var_type_out == NC_INT) {
nc_get_var1_int(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_int(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_INT64 && var_type_out == NC_INT64) {
nc_get_var1_longlong(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_longlong(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_FLOAT) {
nc_get_var1_float(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_float(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_DOUBLE) {
nc_get_var1_double(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_double(out_id, var_out_id, 0L, void_ptr);
}
else if (var_type_in == NC_CHAR) {
nc_get_var1_text(in_id, var_in_id, 0L, void_ptr);
nc_put_var1_text(out_id, var_out_id, 0L, void_ptr);
}
else {
assert(1==0);
}
} else { /* variable is a vector */
if (var_type_in == NC_INT && var_type_out == NC_INT) {
(void)nc_get_var_int(in_id, var_in_id, void_ptr);
(void)nc_put_var_int(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_INT64 && var_type_out == NC_INT64) {
(void)nc_get_var_longlong(in_id, var_in_id, void_ptr);
(void)nc_put_var_longlong(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_FLOAT) {
(void)nc_get_var_float(in_id, var_in_id, void_ptr);
(void)nc_put_var_float(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_DOUBLE) {
(void)nc_get_var_double(in_id, var_in_id, void_ptr);
(void)nc_put_var_double(out_id, var_out_id, void_ptr);
}
else if (var_type_in == NC_CHAR) {
(void)nc_get_var_text(in_id, var_in_id, void_ptr);
(void)nc_put_var_text(out_id, var_out_id, void_ptr);
}
else {
assert(1==0);
}
} /* end if variable is an array */
/* Free the space that held the dimension IDs */
(void)free(dim_cnt);
(void)free(dim_id);
(void)free(dim_sz);
(void)free(dim_srt);
/* Free the space that held the variable */
(void)free(void_ptr);
return(EX_NOERR);
} /* end cpy_var_val() */
static int read_variable(harp_product *product, int ncid, int varid, netcdf_dimensions *dimensions)
{
harp_variable *variable;
harp_data_type data_type;
int num_dimensions;
harp_dimension_type dimension_type[HARP_MAX_NUM_DIMS];
long dimension[HARP_MAX_NUM_DIMS];
char netcdf_name[NC_MAX_NAME + 1];
nc_type netcdf_data_type;
int netcdf_num_dimensions;
int netcdf_dim_id[NC_MAX_VAR_DIMS];
int result;
long i;
result = nc_inq_var(ncid, varid, netcdf_name, &netcdf_data_type, &netcdf_num_dimensions, netcdf_dim_id, NULL);
if (result != NC_NOERR)
{
harp_set_error(HARP_ERROR_NETCDF, "%s", nc_strerror(result));
return -1;
}
if (get_harp_type(netcdf_data_type, &data_type) != 0)
{
harp_add_error_message(" (variable '%s')", netcdf_name);
return -1;
}
num_dimensions = netcdf_num_dimensions;
if (data_type == harp_type_string)
{
if (num_dimensions == 0)
{
harp_set_error(HARP_ERROR_IMPORT, "variable '%s' of type '%s' has 0 dimensions; expected >= 1",
netcdf_name, harp_get_data_type_name(harp_type_string));
}
if (dimensions->type[netcdf_dim_id[num_dimensions - 1]] != netcdf_dimension_string)
{
harp_set_error(HARP_ERROR_IMPORT, "inner-most dimension of variable '%s' is of type '%s'; expected '%s'",
netcdf_name, get_dimension_type_name(dimensions->type[netcdf_dim_id[num_dimensions - 1]]),
get_dimension_type_name(netcdf_dimension_string));
return -1;
}
num_dimensions--;
}
if (num_dimensions > HARP_MAX_NUM_DIMS)
{
harp_set_error(HARP_ERROR_IMPORT, "variable '%s' has too many dimensions", netcdf_name);
return -1;
}
for (i = 0; i < num_dimensions; i++)
{
if (get_harp_dimension_type(dimensions->type[netcdf_dim_id[i]], &dimension_type[i]) != 0)
{
harp_add_error_message(" (variable '%s')", netcdf_name);
return -1;
}
}
for (i = 0; i < num_dimensions; i++)
{
dimension[i] = dimensions->length[netcdf_dim_id[i]];
}
if (harp_variable_new(netcdf_name, data_type, num_dimensions, dimension_type, dimension, &variable) != 0)
{
return -1;
}
if (harp_product_add_variable(product, variable) != 0)
{
harp_variable_delete(variable);
return -1;
}
/* Read data. */
if (data_type == harp_type_string)
{
char *buffer;
long length;
assert(netcdf_num_dimensions > 0);
length = dimensions->length[netcdf_dim_id[netcdf_num_dimensions - 1]];
buffer = malloc(variable->num_elements * length * sizeof(char));
if (buffer == NULL)
{
harp_set_error(HARP_ERROR_OUT_OF_MEMORY, "out of memory (could not allocate %lu bytes) (%s:%u)",
variable->num_elements * length * sizeof(char), __FILE__, __LINE__);
return -1;
}
result = nc_get_var_text(ncid, varid, buffer);
if (result != NC_NOERR)
{
harp_set_error(HARP_ERROR_NETCDF, "%s", nc_strerror(result));
free(buffer);
return -1;
}
for (i = 0; i < variable->num_elements; i++)
{
char *str;
str = malloc((length + 1) * sizeof(char));
if (str == NULL)
{
harp_set_error(HARP_ERROR_OUT_OF_MEMORY, "out of memory (could not allocate %lu bytes) (%s:%u)",
(length + 1) * sizeof(char), __FILE__, __LINE__);
free(buffer);
return -1;
}
memcpy(str, &buffer[i * length], length);
str[length] = '\0';
variable->data.string_data[i] = str;
}
free(buffer);
}
else
{
switch (data_type)
{
case harp_type_int8:
result = nc_get_var_schar(ncid, varid, variable->data.int8_data);
break;
case harp_type_int16:
result = nc_get_var_short(ncid, varid, variable->data.int16_data);
break;
case harp_type_int32:
result = nc_get_var_int(ncid, varid, variable->data.int32_data);
break;
case harp_type_float:
result = nc_get_var_float(ncid, varid, variable->data.float_data);
break;
case harp_type_double:
result = nc_get_var_double(ncid, varid, variable->data.double_data);
break;
default:
assert(0);
exit(1);
}
if (result != NC_NOERR)
{
harp_set_error(HARP_ERROR_NETCDF, "%s", nc_strerror(result));
return -1;
}
}
/* Read attributes. */
result = nc_inq_att(ncid, varid, "description", NULL, NULL);
if (result == NC_NOERR)
{
if (read_string_attribute(ncid, varid, "description", &variable->description) != 0)
{
harp_add_error_message(" (variable '%s')", netcdf_name);
return -1;
}
}
else if (result != NC_ENOTATT)
{
harp_set_error(HARP_ERROR_NETCDF, "%s", nc_strerror(result));
return -1;
}
result = nc_inq_att(ncid, varid, "units", NULL, NULL);
if (result == NC_NOERR)
{
if (read_string_attribute(ncid, varid, "units", &variable->unit) != 0)
{
harp_add_error_message(" (variable '%s')", netcdf_name);
return -1;
}
}
else if (result != NC_ENOTATT)
{
harp_set_error(HARP_ERROR_NETCDF, "%s", nc_strerror(result));
return -1;
}
result = nc_inq_att(ncid, varid, "valid_min", NULL, NULL);
if (result == NC_NOERR)
{
harp_data_type attr_data_type;
if (read_numeric_attribute(ncid, varid, "valid_min", &attr_data_type, &variable->valid_min) != 0)
{
harp_add_error_message(" (variable '%s')", netcdf_name);
return -1;
}
if (attr_data_type != data_type)
{
harp_set_error(HARP_ERROR_IMPORT, "attribute 'valid_min' of variable '%s' has invalid type", netcdf_name);
return -1;
}
}
else if (result != NC_ENOTATT)
{
harp_set_error(HARP_ERROR_NETCDF, "%s", nc_strerror(result));
return -1;
}
result = nc_inq_att(ncid, varid, "valid_max", NULL, NULL);
if (result == NC_NOERR)
{
harp_data_type attr_data_type;
if (read_numeric_attribute(ncid, varid, "valid_max", &attr_data_type, &variable->valid_max) != 0)
{
harp_add_error_message(" (variable '%s')", netcdf_name);
return -1;
}
if (attr_data_type != data_type)
{
harp_set_error(HARP_ERROR_IMPORT, "attribute 'valid_max' of variable '%s' has invalid type", netcdf_name);
return -1;
}
}
else if (result != NC_ENOTATT)
{
harp_set_error(HARP_ERROR_NETCDF, "%s", nc_strerror(result));
return -1;
}
return 0;
}
void CTAI_ObsDescr_netcdf_Get_Properties(
CTAI_ObsDescr_netcdf *descr,
const char *Key,
CTA_Vector *Properties,
CTA_Datatype *datatype,
int *retval)
{
#if HAVE_LIBNETCDF
int ierr,ncid,varid;
int i, ival, dim2;
float *nc_values, *selected_nc_values, *nc_tot_values, *nc_values_lon,*nc_values_lat;
char tmpchar[20];
CTA_String hstr;
if (IDEBUG>0) {printf("ctai_obsdescr_netcdf_get_properties; START\n");}
if (IDEBUG>0) {printf("ctai_obsdescr_netcdf_get_properties: key: %s of: |%s| \n",Key,descr->database->dbname);}
// first allocate space for temporary arrays
dim2 = 1;
if (strstr(Key,"kernel")!=NULL){dim2 = descr->size_1Dproperties;}
if (strstr(Key,"pressure_levels")!=NULL){dim2 = descr->size_1Dproperties+1 ;}
nc_tot_values = CTA_Malloc(descr->nmeasr_orig * dim2 * sizeof(float));
nc_values = CTA_Malloc(descr->nmeasr_orig * sizeof(float));
nc_values_lon = CTA_Malloc(descr->nmeasr_orig * sizeof(float));
nc_values_lat = CTA_Malloc(descr->nmeasr_orig * sizeof(float));
selected_nc_values = CTA_Malloc(descr->nmeasr * sizeof(float));
// Get the netcdf-id of the database
ncid = descr->database->ncid;
/* now obtain the desired secondary variable, given by the keyname */
/* For our specific OMI-netcdf-file, we need: */
/* always: get the lon and lat */
ierr = nc_inq_varid(ncid, "longitude", &varid);
ierr = nc_get_var_float(ncid, varid, &nc_values_lon[0]);
ierr = nc_inq_varid(ncid, "latitude", &varid);
ierr = nc_get_var_float(ncid, varid, &nc_values_lat[0]);
if (ierr != CTA_OK)
{printf("Error: could not read the property lat/lon \n");
*retval = -1; return;
}
if (strcmp(Key,"NAME")==0){
/* this key should not be necessary, but it is naively asked by certain COSTA-routines
like CTA_Util_MethodsPrintObservations */
for (i=0; i < descr->nmeasr_orig; i++){
nc_values[i] = i*1.0;
}
} else if (strcmp(Key,"longitude")==0){
if (IDEBUG>0) {printf("ctai_obsdescr_netcdf_get_properties: LONGITUDE \n");}
// read the lon vector. We know the size: nmeasr_orig.
// ierr = nc_inq_varid(ncid, "longitude", &varid);
//ierr = nc_get_var_float(ncid, varid, &nc_values[0]);
for (i=0; i < descr->nmeasr_orig; i++){
nc_values[i] = nc_values_lon[i]; }
} else if (strcmp(Key,"latitude")==0) {
// ierr = nc_inq_varid(ncid, "latitude", &varid);
//ierr = nc_get_var_float(ncid, varid, &nc_values[0]);
for (i=0; i < descr->nmeasr_orig; i++){
nc_values[i] = nc_values_lat[i]; }
} else if (strstr(Key,"pressure_levels")!=NULL) {
ierr = nc_inq_varid(ncid, "pressure_levels", &varid);
sscanf(&Key[16] ,"%d",&ival);
if (IDEBUG>0) {printf("Getting key %s, number: %d \n",Key,ival);}
ierr = nc_get_var_float(ncid, varid, &nc_tot_values[0]);
if (ierr != CTA_OK)
{printf("Error: could not read the property %s %d \n",Key,ierr);
*retval = -1; return;
}
for (i=0; i < descr->nmeasr_orig; i++){
nc_values[i] = nc_tot_values[ival-1 + (i* (descr->size_1Dproperties+1))];
}
} else if (strstr(Key,"kernel")!=NULL) {
ierr = nc_inq_varid(ncid, "kernel", &varid);
sscanf(&Key[7] ,"%d",&ival);
if (IDEBUG>0) {printf("Getting key %s, number: %d \n",Key,ival);}
ierr = nc_get_var_float(ncid, varid, &nc_tot_values[0]);
if (ierr != CTA_OK)
{printf("Error: could not read the property %s %d \n",Key,ierr);
*retval = -1; return;
}
for (i=0; i < descr->nmeasr_orig; i++){
nc_values[i] = nc_tot_values[ival-1 + (i* descr->size_1Dproperties)];
}
}else {
printf("Key %s is NOT YET IMPLEMENTED!!! \n",Key);
*retval = CTA_NOT_IMPLEMENTED;
return;
}
// now fill the properties vector with the obtained values. The relation table is used to get only the selection.
ierr = CTA_RelTable_ApplyVal(descr->selectionReltab, nc_values,descr->nmeasr_orig,
selected_nc_values,descr->nmeasr,CTA_REAL );
if (IDEBUG>0) {printf("ctai_obsdescr_netcdf_get_properties:ierr %d \n",ierr);}
if (IDEBUG>0) {printf("selected values %f %f %d %d \n",selected_nc_values[0], selected_nc_values[1],descr->nmeasr, *datatype);}
if (*datatype == CTA_STRING){
if (IDEBUG>0) {printf("cta-string-expected;workaround \n");}
ierr = CTA_String_Create(&hstr);
for (i=0; i<descr->nmeasr; i++){
sprintf(tmpchar,"%f",selected_nc_values[i]);
ierr = CTA_String_Set(hstr,tmpchar);
ierr=CTA_Vector_SetVal(*Properties,i+1,&hstr, CTA_STRING);
}
ierr = CTA_String_Free(&hstr);
} else {
ierr=CTA_Vector_SetVals(*Properties,selected_nc_values, descr->nmeasr, CTA_REAL);
}
if (IDEBUG>0) {printf("ctai_obsdescr_netcdf_get_properties:setvals %d \n",ierr);}
if (ierr != CTA_OK)
{printf("Error: could not fill the property vector %s \n",Key);
*retval = -1; return;
}
free(nc_values);
free(nc_values_lon);
free(nc_values_lat);
free(selected_nc_values);
free(nc_tot_values);
if (*retval!=CTA_OK) return;
*retval = CTA_OK;
#else
printf("CTAI_ObsDescr_netcdf_Get_Properties :Version is compiled without NETCDF support.\n");
*retval=CTA_NOT_IMPLEMENTED;
#endif
};
int ex_get_coord(int exoid, void *x_coor, void *y_coor, void *z_coor)
{
int status;
int coordid;
int coordidx, coordidy, coordidz;
int numnoddim, ndimdim;
size_t num_nod, num_dim, start[2], count[2], i;
char errmsg[MAX_ERR_LENGTH];
EX_FUNC_ENTER();
ex_check_valid_file_id(exoid, __func__);
/* inquire id's of previously defined dimensions */
if (ex_get_dimension(exoid, DIM_NUM_DIM, "dimension count", &num_dim, &ndimdim, __func__) !=
NC_NOERR) {
EX_FUNC_LEAVE(EX_FATAL);
}
if (nc_inq_dimid(exoid, DIM_NUM_NODES, &numnoddim) != NC_NOERR) {
/* If not found, then this file is storing 0 nodes.
Return immediately */
EX_FUNC_LEAVE(EX_NOERR);
}
if ((status = nc_inq_dimlen(exoid, numnoddim, &num_nod)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get number of nodes in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
/* read in the coordinates */
if (ex_large_model(exoid) == 0) {
if ((status = nc_inq_varid(exoid, VAR_COORD, &coordid)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate nodal coordinates in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
for (i = 0; i < num_dim; i++) {
char *which = NULL;
start[0] = i;
start[1] = 0;
count[0] = 1;
count[1] = num_nod;
if (i == 0 && x_coor != NULL) {
which = "X";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, x_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, x_coor);
}
}
else if (i == 1 && y_coor != NULL) {
which = "Y";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, y_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, y_coor);
}
}
else if (i == 2 && z_coor != NULL) {
which = "Z";
if (ex_comp_ws(exoid) == 4) {
status = nc_get_vara_float(exoid, coordid, start, count, z_coor);
}
else {
status = nc_get_vara_double(exoid, coordid, start, count, z_coor);
}
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s coord array in file id %d", which,
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
else {
if ((status = nc_inq_varid(exoid, VAR_COORD_X, &coordidx)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to locate x nodal coordinates in file id %d",
exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
if (num_dim > 1) {
if ((status = nc_inq_varid(exoid, VAR_COORD_Y, &coordidy)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate y nodal coordinates in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
else {
coordidy = 0;
}
if (num_dim > 2) {
if ((status = nc_inq_varid(exoid, VAR_COORD_Z, &coordidz)) != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH,
"ERROR: failed to locate z nodal coordinates in file id %d", exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
else {
coordidz = 0;
}
/* write out the coordinates */
for (i = 0; i < num_dim; i++) {
void *coor = NULL;
char *which = NULL;
if (i == 0) {
coor = x_coor;
which = "X";
coordid = coordidx;
}
else if (i == 1) {
coor = y_coor;
which = "Y";
coordid = coordidy;
}
else if (i == 2) {
coor = z_coor;
which = "Z";
coordid = coordidz;
}
if (coor != NULL && coordid != 0) {
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, coordid, coor);
}
else {
status = nc_get_var_double(exoid, coordid, coor);
}
if (status != NC_NOERR) {
snprintf(errmsg, MAX_ERR_LENGTH, "ERROR: failed to get %s coord array in file id %d",
which, exoid);
ex_err(__func__, errmsg, status);
EX_FUNC_LEAVE(EX_FATAL);
}
}
}
}
EX_FUNC_LEAVE(EX_NOERR);
}
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));
#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);
}
return 0;
}
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);
}
/*+++++++++++++++++++++++++
.IDENTifer SCIA_RD_NC_H2O_REC
.PURPOSE read records from IMLM-H2O product in netCDF-4 (ADAGUC standard)
.INPUT/OUTPUT
call as numRec = SCIA_RD_NC_H2O_REC( ncid, &rec );
input:
int ncid : netCDF file ID
output:
struct imlm_rec **rec : IMLM-H2O records
.RETURNS number of IMLM-H2O records (unsigned int)
.COMMENTS static function
-------------------------*/
unsigned int SCIA_RD_NC_H2O_REC( int ncid, struct imlm_rec **rec_out )
{
register unsigned int ni, nr;
unsigned int numRec = 0;
int retval;
int time_id;
int var_id;
size_t indx, length;
float *rbuff = NULL;
double *dbuff = NULL;
struct imlm_rec *rec = NULL;
const size_t nr_byte = NUM_CORNERS * sizeof(float);
rec_out[0] = NULL;
/*
* get size of dimension scale "time"
*/
if ( (retval = nc_inq_dimid( ncid, "time", &time_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
if ( (retval = nc_inq_dimlen( ncid, time_id, &length )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
numRec = (unsigned int) length;
rec = (struct imlm_rec *) malloc( numRec * sizeof(struct imlm_rec) );
if ( rec == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "rec" );
/*
* read Julian date of measurements
*/
dbuff = (double *) malloc( numRec * sizeof(double) );
if ( dbuff == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "dbuff" );
if ( (retval = nc_inq_varid( ncid, "time", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_double( ncid, var_id, dbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].dsr_time = dbuff[nr];
/*
* read longitude and latitude of measurements
*/
rbuff = (float *) malloc( numRec * sizeof(float) );
if ( rbuff == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "rbuff" );
if ( (retval = nc_inq_varid( ncid, "lon", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].lon_center = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "lat", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].lat_center = rbuff[nr];
/*
* read datasets (H2O, CH4)
*/
if ( (retval = nc_inq_varid( ncid, "H2O", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].H2O = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "H2O_error", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].H2O_err = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "CH4", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].CH4 = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "CH4_error", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].CH4_err = rbuff[nr];
#ifdef _IMLM_WHOLE_PRODUCT /* additional species H2O, N2O */
if ( (retval = nc_inq_varid( ncid, "H2O", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].H2O = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "H2O_error", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].H2O_err = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "N2O", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].N2O = rbuff[nr];
if ( (retval = nc_inq_varid( ncid, "N2O_error", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].N2O_err = rbuff[nr];
#endif
if ( (retval = nc_inq_varid( ncid, "albedo", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].albedo = rbuff[nr];
retval = nc_inq_varid( ncid, "cloudFraction", &var_id );
if ( retval != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].cl_fr = rbuff[nr];
retval = nc_inq_varid( ncid, "meanElevation", &var_id );
if ( retval != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( nr = 0; nr < numRec; nr++ ) rec[nr].mean_elev = rbuff[nr];
/*
* read longitude and latitude bounding boxes
*/
rbuff = (float *) realloc( rbuff, NUM_CORNERS * numRec * sizeof(float) );
if ( rbuff == NULL ) NADC_GOTO_ERROR( NADC_ERR_ALLOC, "rbuff" );
if ( (retval = nc_inq_varid( ncid, "lon_bnds", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( ni = nr = 0; nr < numRec; nr++, ni += NUM_CORNERS )
(void) memcpy( rec[nr].lon_corner, rbuff+ni, nr_byte );
if ( (retval = nc_inq_varid( ncid, "lat_bnds", &var_id )) != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
retval = nc_get_var_float( ncid, var_id, rbuff );
for ( ni = nr = 0; nr < numRec; nr++, ni += NUM_CORNERS )
(void) memcpy( rec[nr].lat_corner, rbuff+ni, nr_byte );
/*
* read pixel meta-data as compound dataset
*/
retval = nc_inq_varid( ncid, "tile_properties", &var_id );
if ( retval != NC_NOERR )
NADC_GOTO_ERROR( NADC_ERR_FATAL, nc_strerror(retval) );
for ( indx = 0; indx < (size_t) numRec; indx++ ) {
retval = nc_get_var1( ncid, var_id, &indx, &rec[indx].meta );
}
free( rbuff );
free( dbuff );
rec_out[0] = rec;
return numRec;
done:
if ( rec != NULL ) free( rec );
if ( rbuff != NULL ) free( rbuff );
if ( dbuff != NULL ) free( dbuff );
return 0;
}
int ex_get_attr( int exoid,
ex_entity_type obj_type,
ex_entity_id obj_id,
void* attrib )
{
int status;
int attrid, obj_id_ndx;
char errmsg[MAX_ERR_LENGTH];
const char* vattrbname;
exerrval = 0; /* clear error code */
/* Determine index of obj_id in vobjids array */
if (obj_type == EX_NODAL) {
obj_id_ndx = 0;
} else {
obj_id_ndx = ex_id_lkup(exoid,obj_type,obj_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: no attributes found for NULL %s %"PRId64" in file id %d",
ex_name_of_object(obj_type),obj_id,exoid);
ex_err("ex_get_attr",errmsg,EX_NULLENTITY);
return (EX_WARN); /* no attributes for this object */
}
sprintf(errmsg,
"Warning: failed to locate %s id %"PRId64" in id array in file id %d",
ex_name_of_object(obj_type),obj_id, exoid);
ex_err("ex_get_attr",errmsg,exerrval);
return (EX_WARN);
}
}
switch (obj_type) {
case EX_SIDE_SET:
vattrbname = VAR_SSATTRIB(obj_id_ndx);
break;
case EX_NODE_SET:
vattrbname = VAR_NSATTRIB(obj_id_ndx);
break;
case EX_EDGE_SET:
vattrbname = VAR_ESATTRIB(obj_id_ndx);
break;
case EX_FACE_SET:
vattrbname = VAR_FSATTRIB(obj_id_ndx);
break;
case EX_ELEM_SET:
vattrbname = VAR_ELSATTRIB(obj_id_ndx);
break;
case EX_NODAL:
vattrbname = VAR_NATTRIB;
break;
case EX_EDGE_BLOCK:
vattrbname = VAR_EATTRIB(obj_id_ndx);
break;
case EX_FACE_BLOCK:
vattrbname = VAR_FATTRIB(obj_id_ndx);
break;
case EX_ELEM_BLOCK:
vattrbname = VAR_ATTRIB(obj_id_ndx);
break;
default:
exerrval = 1005;
sprintf(errmsg,
"Internal Error: unrecognized object type in switch: %d in file id %d",
obj_type,exoid);
ex_err("ex_get_attr",errmsg,EX_MSG);
return (EX_FATAL); /* number of attributes not defined */
}
/* inquire id's of previously defined dimensions */
if ((status = nc_inq_varid(exoid, vattrbname, &attrid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to locate attributes for %s %"PRId64" in file id %d",
ex_name_of_object(obj_type), obj_id,exoid);
ex_err("ex_get_attr",errmsg,exerrval);
return (EX_FATAL);
}
/* read in the attributes */
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, attrid, attrib);
} else {
status = nc_get_var_double(exoid, attrid, attrib);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get attributes for %s %"PRId64" in file id %d",
ex_name_of_object(obj_type),obj_id,exoid);
ex_err("ex_get_attr",errmsg,exerrval);
return (EX_FATAL);
}
return(EX_NOERR);
}
int
main(int argc, char **argv)
{
printf("\n*** Testing netcdf-4 dimensions.\n");
printf("*** Testing that netcdf-4 dimids inq works on netcdf-3 file...");
{
int ncid, dimid;
int ndims_in, dimids_in[MAX_DIMS];
/* Create a netcdf-3 file with one dim. */
if (nc_create(FILE_NAME, 0, &ncid)) ERR;
if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &dimid)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and make sure nc_inq_dimids yeilds correct
* result. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR;
if (ndims_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing that netcdf-4 dimids inq works on more complex netcdf-3 file...");
{
int ncid, dimid;
int lon_dimid;
int ndims_in, dimids_in[MAX_DIMS];
/* Create a netcdf-3 file with three dim. */
if (nc_create(FILE_NAME, 0, &ncid)) ERR;
if (nc_def_dim(ncid, LEVEL_NAME, NC_UNLIMITED, &dimid)) ERR;
if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &dimid)) ERR;
if (nc_def_dim(ncid, LON_NAME, LON_LEN, &lon_dimid)) ERR;
if (nc_close(ncid)) ERR;
/* Open the file and make sure nc_inq_dimids yeilds correct
* result. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 3 || dimids_in[0] != 0 || dimids_in[1] != 1 ||
dimids_in[2] != 2) ERR;
if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing file with just one dimension...");
{
int ncid, dimid;
int ndims_in, dimids_in[MAX_DIMS];
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int dimid_in;
/* Create a file with one dim and nothing else. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &dimid)) ERR;
/* Check out what we've got. */
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1) ERR;
if (nc_inq_dimid(ncid, LAT_NAME, &dimid_in)) ERR;
if (dimid_in != 0) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimlen(ncid, 0, &len_in)) ERR;
if (len_in != LAT_LEN) ERR;
if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR;
if (ndims_in != 0) ERR;
if (nc_close(ncid)) ERR;
/* Reopen and check it out again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1) ERR;
if (nc_inq_dimid(ncid, LAT_NAME, &dimid_in)) ERR;
if (dimid_in != 0) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimlen(ncid, 0, &len_in)) ERR;
if (len_in != LAT_LEN) ERR;
if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR;
if (ndims_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing renaming of one dimension...");
{
int ncid, dimid, dimid_in;
char name_in[NC_MAX_NAME + 1];
size_t len_in;
int ndims_in, dimids_in[MAX_DIMS];
/* Reopen the file with one dim, and change the name of the dim. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_rename_dim(ncid, 0, BUBBA)) ERR;
/* Check out what we've got. */
dimid = 0;
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != LAT_LEN || strcmp(name_in, BUBBA)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1) ERR;
if (dimids_in[0] != 0) ERR;
if (nc_inq_dimid(ncid, BUBBA, &dimid_in)) ERR;
if (dimid_in != 0) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, BUBBA)) ERR;
if (nc_inq_dimlen(ncid, 0, &len_in)) ERR;
if (len_in != LAT_LEN) ERR;
if (nc_close(ncid)) ERR;
/* Reopen and check out what we've got again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != LAT_LEN || strcmp(name_in, BUBBA)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_dimid(ncid, BUBBA, &dimid_in)) ERR;
if (dimid_in != 0) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, BUBBA)) ERR;
if (nc_inq_dimlen(ncid, 0, &len_in)) ERR;
if (len_in != LAT_LEN) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing renaming dimensions and vars...");
{
#define FILE_NAME1 "foo1.nc"
#define FILE_NAME2 "foo2.nc"
#define FILE_NAME3 "foo3.nc"
#define FILE_NAME4 "foo4.nc"
#define DIM_NAME "lat_T42"
#define VAR_NAME DIM_NAME
#define DIM_NAME2 "lat"
#define VAR_NAME2 DIM_NAME2
#define RANK_lat_T42 1
int ncid, varid, dimid;
int lat_T42_dim;
size_t lat_T42_len = 3;
int lat_T42_id;
int lat_T42_dims[RANK_lat_T42];
char name[NC_MAX_NAME + 1];
/* =========== */
/* Sub-test #1 */
/* =========== */
/* create file with dimension and associated coordinate variable */
if (nc_create(FILE_NAME1, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME, lat_T42_len, &lat_T42_dim)) ERR;
lat_T42_dims[0] = lat_T42_dim;
if (nc_def_var(ncid, VAR_NAME, NC_INT, RANK_lat_T42, lat_T42_dims, &lat_T42_id)) ERR;
if (nc_close(ncid)) ERR;
/* reopen file, rename coordinate dimension and then associated variable */
if (nc_open(FILE_NAME1, NC_WRITE, &ncid)) ERR;
if (nc_inq_dimid(ncid, DIM_NAME, &dimid)) ERR;
if (nc_inq_varid(ncid, VAR_NAME, &varid)) ERR;
if (nc_rename_dim(ncid, dimid, DIM_NAME2)) ERR;
if (nc_rename_var(ncid, varid, VAR_NAME2)) ERR;
if (nc_close(ncid)) ERR;
/* reopen file, check coordinate dimension and associated variable names */
/* Should be just like they created the file with DIM_NAME2 & VAR_NAME2 to
* begin with.
*/
if (nc_open(FILE_NAME1, NC_WRITE, &ncid)) ERR;
if (nc_inq_dimid(ncid, DIM_NAME2, &dimid)) ERR;
if (nc_inq_varid(ncid, VAR_NAME2, &varid)) ERR;
if (nc_inq_dimname(ncid, dimid, name)) ERR;
if (strcmp(name, DIM_NAME2)) ERR;
if (nc_inq_varname(ncid, varid, name)) ERR;
if (strcmp(name, VAR_NAME2)) ERR;
if (nc_close(ncid)) ERR;
/* =========== */
/* Sub-test #2 */
/* =========== */
/* create file with dimension and associated coordinate variable */
if (nc_create(FILE_NAME1, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME, lat_T42_len, &lat_T42_dim)) ERR;
lat_T42_dims[0] = lat_T42_dim;
if (nc_def_var(ncid, VAR_NAME, NC_INT, RANK_lat_T42, lat_T42_dims, &lat_T42_id)) ERR;
if (nc_close(ncid)) ERR;
/* reopen file, just rename coordinate dimension */
if (nc_open(FILE_NAME1, NC_WRITE, &ncid)) ERR;
if (nc_inq_dimid(ncid, DIM_NAME, &dimid)) ERR;
if (nc_rename_dim(ncid, dimid, DIM_NAME2)) ERR;
if (nc_close(ncid)) ERR;
/* reopen file, check coordinate dimension and associated variable names */
/* Should be just like the file was created with DIM_NAME2 to begin with */
if (nc_open(FILE_NAME1, NC_WRITE, &ncid)) ERR;
if (nc_inq_dimid(ncid, DIM_NAME2, &dimid)) ERR;
if (nc_inq_varid(ncid, VAR_NAME, &varid)) ERR;
if (nc_inq_dimname(ncid, dimid, name)) ERR;
if (strcmp(name, DIM_NAME2)) ERR;
if (nc_inq_varname(ncid, varid, name)) ERR;
if (strcmp(name, VAR_NAME)) ERR;
if (nc_close(ncid)) ERR;
/* =========== */
/* Sub-test #3 */
/* =========== */
/* create file with dimension and associated coordinate variable */
if (nc_create(FILE_NAME1, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME, lat_T42_len, &lat_T42_dim)) ERR;
lat_T42_dims[0] = lat_T42_dim;
if (nc_def_var(ncid, VAR_NAME, NC_INT, RANK_lat_T42, lat_T42_dims, &lat_T42_id)) ERR;
if (nc_close(ncid)) ERR;
/* reopen file, just rename variable */
if (nc_open(FILE_NAME1, NC_WRITE, &ncid)) ERR;
if (nc_inq_varid(ncid, VAR_NAME, &varid)) ERR;
if (nc_rename_var(ncid, varid, VAR_NAME2)) ERR;
if (nc_close(ncid)) ERR;
/* reopen file, check coordinate dimension and associated variable names */
/* Should be just like the file was created with VAR_NAME2 to begin with */
if (nc_open(FILE_NAME1, NC_WRITE, &ncid)) ERR;
if (nc_inq_dimid(ncid, DIM_NAME, &dimid)) ERR;
if (nc_inq_varid(ncid, VAR_NAME2, &varid)) ERR;
if (nc_inq_dimname(ncid, dimid, name)) ERR;
if (strcmp(name, DIM_NAME)) ERR;
if (nc_inq_varname(ncid, varid, name)) ERR;
if (strcmp(name, VAR_NAME2)) ERR;
if (nc_close(ncid)) ERR;
/* =========== */
/* Sub-test #4 */
/* =========== */
/* create file with dimension and associated coordinate variable */
if (nc_create(FILE_NAME1, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR;
if (nc_def_dim(ncid, DIM_NAME, lat_T42_len, &lat_T42_dim)) ERR;
lat_T42_dims[0] = lat_T42_dim;
if (nc_def_var(ncid, VAR_NAME, NC_INT, RANK_lat_T42, lat_T42_dims, &lat_T42_id)) ERR;
if (nc_close(ncid)) ERR;
/* reopen file, rename associated variable and then coordinate dimension */
if (nc_open(FILE_NAME1, NC_WRITE, &ncid)) ERR;
if (nc_inq_dimid(ncid, DIM_NAME, &dimid)) ERR;
if (nc_inq_varid(ncid, VAR_NAME, &varid)) ERR;
if (nc_rename_var(ncid, varid, VAR_NAME2)) ERR;
if (nc_rename_dim(ncid, dimid, DIM_NAME2)) ERR;
if (nc_close(ncid)) ERR;
/* reopen file, check coordinate dimension and associated variable names */
/* Should be just like they created the file with DIM_NAME2 & VAR_NAME2 to
* begin with.
*/
if (nc_open(FILE_NAME1, NC_WRITE, &ncid)) ERR;
if (nc_inq_dimid(ncid, DIM_NAME2, &dimid)) ERR;
if (nc_inq_varid(ncid, VAR_NAME2, &varid)) ERR;
if (nc_inq_dimname(ncid, dimid, name)) ERR;
if (strcmp(name, DIM_NAME2)) ERR;
if (nc_inq_varname(ncid, varid, name)) ERR;
if (strcmp(name, VAR_NAME2)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing file with just one unlimited dimension...");
{
int ncid, dimid;
int ndims_in, dimids_in[MAX_DIMS];
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int unlimdimid_in;
int nunlimdims_in;
/* Create a file with one unlimied dim and nothing else. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, LEVEL_NAME, NC_UNLIMITED, &dimid)) ERR;
/* Check it out before the enddef. */
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != NC_UNLIMITED || strcmp(name_in, LEVEL_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR;
if (unlimdimid_in != 0) ERR;
if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR;
if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR;
/* Automatically enddef and close. */
if (nc_close(ncid)) ERR;
/* Reopen and check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != NC_UNLIMITED || strcmp(name_in, LEVEL_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR;
if (unlimdimid_in != 0) ERR;
if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR;
if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR;
if (unlimdimid_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
#define ROMULUS "Romulus"
#define REMUS "Remus"
#define DIMS2 2
printf("*** Testing file with two unlimited dimensions...");
{
int ncid, dimid[DIMS2];
int ndims_in, dimids_in[DIMS2];
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int unlimdimid_in[DIMS2];
int nunlimdims_in;
/* Create a file with two unlimited dims and nothing else. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, REMUS, NC_UNLIMITED, &dimid[0])) ERR;
if (nc_def_dim(ncid, ROMULUS, NC_UNLIMITED, &dimid[1])) ERR;
/* Check it out before the enddef. */
if (nc_inq_dim(ncid, dimid[0], name_in, &len_in)) ERR;
if (len_in != NC_UNLIMITED || strcmp(name_in, REMUS)) ERR;
if (nc_inq_dim(ncid, dimid[1], name_in, &len_in)) ERR;
if (len_in != NC_UNLIMITED || strcmp(name_in, ROMULUS)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 2 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR;
if (nc_inq_unlimdim(ncid, &unlimdimid_in[0])) ERR;
if (unlimdimid_in[0] != 0) ERR;
if (nc_inq_unlimdims(ncid, &nunlimdims_in, unlimdimid_in)) ERR;
if (nunlimdims_in != 2 || unlimdimid_in[0] != 0 || unlimdimid_in[1] != 1) ERR;
/* Automatically enddef and close. */
if (nc_close(ncid)) ERR;
/* Reopen and check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing ordering of dimensions...");
{
#define A_NAME "a"
#define B_NAME "b"
#define A_LEN 50
#define B_LEN 92
#define A_DIMID 1
#define B_DIMID 0
int ncid;
int ndims_in, dimids_in[MAX_DIMS];
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int dimid_a, dimid_b;
/* Create a file with two dims and nothing else. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, B_NAME, B_LEN, &dimid_b)) ERR;
if (nc_def_dim(ncid, A_NAME, A_LEN, &dimid_a)) ERR;
if (dimid_b != B_DIMID || dimid_a != A_DIMID) ERR;
/* Check out what we've got. */
if (nc_inq_dim(ncid, dimid_a, name_in, &len_in)) ERR;
if (len_in != A_LEN || strcmp(name_in, A_NAME)) ERR;
if (nc_inq_dim(ncid, dimid_b, name_in, &len_in)) ERR;
if (len_in != B_LEN || strcmp(name_in, B_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 2 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR;
if (nc_close(ncid)) ERR;
/* Reopen and check it out again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dim(ncid, B_DIMID, name_in, &len_in)) ERR;
if (len_in != B_LEN || strcmp(name_in, B_NAME)) ERR;
if (nc_inq_dim(ncid, A_DIMID, name_in, &len_in)) ERR;
if (len_in != A_LEN || strcmp(name_in, A_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 2 || dimids_in[0] != 0 ||
dimids_in[1] != 1) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing file with just one unlimited dimension and one var...");
{
int ncid, dimid, dimids[MAX_DIMS];
int level_varid;
int natts_in, ndims_in, dimids_in[MAX_DIMS];
nc_type xtype_in;
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int unlimdimid_in;
size_t start[MAX_DIMS], count[MAX_DIMS];
int varid_in, nvars_in, nunlimdims_in;
unsigned long long uint64_data[1] = {42};
/* Create a file with one unlimied dim and nothing else. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, LEVEL_NAME, NC_UNLIMITED, &dimid)) ERR;
if (dimid != 0) ERR;
dimids[0] = dimid;
if (nc_def_var(ncid, LEVEL_NAME, NC_UINT64, 1, dimids, &level_varid)) ERR;
if (level_varid != 0) ERR;
/* Check it out before enddef. */
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != 0 || strcmp(name_in, LEVEL_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR;
if (unlimdimid_in != 0) ERR;
if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR;
if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != 0) ERR;
if (nc_inq_varid(ncid, LEVEL_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LEVEL_NAME) || xtype_in != NC_UINT64 || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, LEVEL_NAME)) ERR;
/* Now write one record of data to the var. */
start[0] = 0;
count[0] = 1;
if (nc_put_vara_ulonglong(ncid, 0, start, count, uint64_data)) ERR;
/* Check dimension informaiton again. Now the length of this
* dimension should be one. */
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != 1 || strcmp(name_in, LEVEL_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_dimlen(ncid, 0, &len_in)) ERR;
if (len_in != 1) ERR;
if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR;
if (unlimdimid_in != 0) ERR;
if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR;
if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR;
if (unlimdimid_in != 0) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != 0) ERR;
if (nc_inq_varid(ncid, LEVEL_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LEVEL_NAME) || xtype_in != NC_UINT64 || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, LEVEL_NAME)) ERR;
/* Close the file. */
if (nc_close(ncid)) ERR;
/* Check it out. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != 1 || strcmp(name_in, LEVEL_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_unlimdim(ncid, &unlimdimid_in)) ERR;
if (unlimdimid_in != 0) ERR;
if (nc_inq_unlimdims(ncid, &nunlimdims_in, &unlimdimid_in)) ERR;
if (nunlimdims_in != 1 || unlimdimid_in != 0) ERR;
if (unlimdimid_in != 0) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 || unlimdimid_in != 0) ERR;
if (nc_inq_varid(ncid, LEVEL_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LEVEL_NAME) || xtype_in != NC_UINT64 || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_inq_varname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, LEVEL_NAME)) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing adding a coordinate var to file with dimension...");
{
int ncid, dimid, dimids[MAX_DIMS];
int natts_in, ndims_in, dimids_in[MAX_DIMS];
nc_type xtype_in;
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int unlimdimid_in;
int nvars_in, dim5_varid;
/* Create a file with one dim and nothing else. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM5_NAME, DIM5_LEN, &dimid)) ERR;
/* Check out what we've got. */
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 0 || natts_in != 0 ||
unlimdimid_in != -1) ERR;
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != DIM5_LEN || strcmp(name_in, DIM5_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_close(ncid)) ERR;
/* Reopen and check it out again. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 0 || natts_in != 0 ||
unlimdimid_in != -1) ERR;
if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR;
if (len_in != DIM5_LEN || strcmp(name_in, DIM5_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
/* Add a coordinate var for this dimension. */
dimids[0] = 0;
if (nc_def_var(ncid, DIM5_NAME, NC_FLOAT, 1, dimids, &dim5_varid)) ERR;
/* Check it out. */
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 ||
unlimdimid_in != -1) ERR;
if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR;
if (len_in != DIM5_LEN || strcmp(name_in, DIM5_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(name_in, DIM5_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
/* Reopen and check it out again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 ||
unlimdimid_in != -1) ERR;
if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR;
if (len_in != DIM5_LEN || strcmp(name_in, DIM5_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(name_in, DIM5_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing adding a coordinate var to file with unlimited dimension...");
{
int ncid, dimid, dimids[MAX_DIMS];
int natts_in, ndims_in, dimids_in[MAX_DIMS];
nc_type xtype_in;
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int unlimdimid_in;
size_t start[MAX_DIMS], count[MAX_DIMS], index[MAX_DIMS];
unsigned short data[2] = {42, 24}, data_in[2];
int nvars_in, hp_varid, dim5_varid;
/* Create a file with one dim and one var. This time make
* it an unlimited dim. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, DIM5_NAME, NC_UNLIMITED, &dimid)) ERR;
if (dimid != 0) ERR;
dimids[0] = dimid;
if (nc_def_var(ncid, HP_NAME, NC_USHORT, 1, dimids, &hp_varid)) ERR;
if (hp_varid != 0) ERR;
/* Check out what we've got. */
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 ||
unlimdimid_in != 0) ERR;
if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR;
if (len_in != 0 || strcmp(name_in, DIM5_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(name_in, HP_NAME) || xtype_in != NC_USHORT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
/* Add a record to the HP variable. */
start[0] = 0;
count[0] = 1;
if (nc_put_vara(ncid, hp_varid, start, count, data)) ERR;
/* Check to ensure dimension grew. */
if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR;
if (len_in != 1 || strcmp(name_in, DIM5_NAME)) ERR;
/* Reread the value just written. */
index[0] = 0;
if (nc_get_var1_ushort(ncid, hp_varid, index, data_in)) ERR;
if (data_in[0] != data[0]) ERR;
if (nc_close(ncid)) ERR;
/* Reopen and check it out again. */
if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 1 || natts_in != 0 ||
unlimdimid_in != 0) ERR;
if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR;
if (len_in != 1 || strcmp(name_in, DIM5_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
/* Add a coordinate var for this dimension. */
dimids[0] = 0;
if (nc_def_var(ncid, DIM5_NAME, NC_FLOAT, 1, dimids, &dim5_varid)) ERR;
/* Check it out. */
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 2 || natts_in != 0 ||
unlimdimid_in != 0) ERR;
if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR;
if (len_in != 1 || strcmp(name_in, DIM5_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_var(ncid, dim5_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(name_in, DIM5_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
/* Reopen and check it out again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims_in, &nvars_in, &natts_in, &unlimdimid_in)) ERR;
if (ndims_in != 1 || nvars_in != 2 || natts_in != 0 ||
unlimdimid_in != 0) ERR;
if (nc_inq_dim(ncid, 0, name_in, &len_in)) ERR;
if (len_in != 1 || strcmp(name_in, DIM5_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1 || dimids_in[0] != 0) ERR;
if (nc_inq_var(ncid, dim5_varid, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR;
if (strcmp(name_in, DIM5_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != 0 || natts_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Creating file with 1 data var, 2 dims, and 2 coord. vars...");
{
int ncid, dimids[MAX_DIMS];
int lat_dimid, lon_dimid, lat_varid, lon_varid;
int pres_varid;
char name_in[NC_MAX_NAME + 1];
int natts_in, ndims_in, dimids_in[MAX_DIMS];
nc_type xtype_in;
size_t len_in;
float lat[LAT_LEN], lon[LON_LEN];
float lat_in[LAT_LEN], lon_in[LON_LEN];
double pres[LAT_LEN][LON_LEN], pres_in[LAT_LEN][LON_LEN];
int i, j;
/* Lats and lons suitable for some South American data. */
for (lat[0] = 40.0, i = 1; i < LAT_LEN; i++)
lat[i] = lat[i - 1] + .5;
for (lon[0] = 20.0, i = 1; i < LON_LEN; i++)
lon[i] = lon[i - 1] + 1.5;
/* Some phoney 2D pressure data. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
pres[i][j] = 1013.1 + j;
/* Create a file. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
/* Define lat and lon dimensions, with associated variables. */
if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &lat_dimid)) ERR;
dimids[0] = lat_dimid;
if (nc_def_var(ncid, LAT_NAME, NC_FLOAT, 1, dimids, &lat_varid)) ERR;
if (nc_def_dim(ncid, LON_NAME, LON_LEN, &lon_dimid)) ERR;
dimids[0] = lon_dimid;
if (nc_def_var(ncid, LON_NAME, NC_FLOAT, 1, dimids, &lon_varid)) ERR;
/* Define a 2D variable called pressure, with NC_DOUBLE on a lat
* lon grid. */
dimids[0] = lat_dimid;
dimids[1] = lon_dimid;
if (nc_def_var(ncid, PRES_NAME, NC_DOUBLE, 2, dimids, &pres_varid)) ERR;
/* Check our dimensions. */
if (nc_inq_dim(ncid, lat_dimid, name_in, &len_in)) ERR;
if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dim(ncid, lon_dimid, name_in, &len_in)) ERR;
if (len_in != LON_LEN || strcmp(name_in, LON_NAME)) ERR;
if (nc_inq_var(ncid, lat_varid, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != lat_dimid || natts_in != 0) ERR;
if (nc_inq_var(ncid, lon_varid, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != lon_dimid || natts_in != 0) ERR;
/* Check our data variable. */
if (nc_inq_var(ncid, pres_varid, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, PRES_NAME) || xtype_in != NC_DOUBLE || ndims_in != 2 ||
dimids_in[0] != lat_dimid || dimids_in[1] != lon_dimid || natts_in != 0) ERR;
/* Write our latitude and longitude values. This writes all
* metadata to disk too. */
if (nc_put_var_float(ncid, lat_varid, lat)) ERR;
if (nc_put_var_float(ncid, lon_varid, lon)) ERR;
/* Write our 2D pressure values. */
if (nc_put_var_double(ncid, pres_varid, (double *)pres)) ERR;
/* Check our latitude and longitude values. */
if (nc_get_var(ncid, lat_varid, lat_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
if (lat[i] != lat_in[i]) ERR;
if (nc_get_var_float(ncid, lon_varid, lon_in)) ERR;
for (i = 0; i < LON_LEN; i++)
if (lon[i] != lon_in[i]) ERR;
/* Check our pressure values. */
if (nc_get_var_double(ncid, pres_varid, (double *)pres_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
if (pres[i][j] != pres_in[i][j]) ERR;
/* Close the file. */
if (nc_close(ncid)) ERR;
/* Reopen the file and check it out again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check our dimensions. */
if (nc_inq_dim(ncid, lat_dimid, name_in, &len_in)) ERR;
if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dim(ncid, lon_dimid, name_in, &len_in)) ERR;
if (len_in != LON_LEN || strcmp(name_in, LON_NAME)) ERR;
if (nc_inq_var(ncid, lat_varid, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != lat_dimid || natts_in != 0) ERR;
if (nc_inq_var(ncid, lon_varid, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != lon_dimid || natts_in != 0) ERR;
/* Check our data variable. */
if (nc_inq_var(ncid, pres_varid, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, PRES_NAME) || xtype_in != NC_DOUBLE || ndims_in != 2 ||
dimids_in[0] != lat_dimid || dimids_in[1] != lon_dimid || natts_in != 0) ERR;
/* Check our latitude and longitude values. */
if (nc_get_var(ncid, lat_varid, lat_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
if (lat[i] != lat_in[i]) ERR;
if (nc_get_var_float(ncid, lon_varid, lon_in)) ERR;
for (i = 0; i < LON_LEN; i++)
if (lon[i] != lon_in[i]) ERR;
/* Check our pressure values. */
if (nc_get_var_double(ncid, pres_varid, (double *)pres_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
if (pres[i][j] != pres_in[i][j]) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Creating file with 3 data vars, 4 dims, and 2 coord. vars...");
{
int ncid, lat_dimid, dimids[MAX_DIMS];
int level_dimid, time_dimid, elev_varid;
int lat_varid, lon_dimid, lon_varid, pres_varid, hp_varid;
double pres[LAT_LEN][LON_LEN][LEVEL_LEN][TIME_LEN];
double pres_in[LAT_LEN][LON_LEN][LEVEL_LEN][TIME_LEN];
unsigned short hp[LAT_LEN][LON_LEN][TIME_LEN];
unsigned short hp_in[LAT_LEN][LON_LEN][TIME_LEN];
unsigned long long elev[LAT_LEN][LON_LEN], elev_in[LAT_LEN][LON_LEN];
size_t start[4], count[4];
int nvars, ndims, natts, unlimdimid;
int natts_in, ndims_in, dimids_in[MAX_DIMS];
nc_type xtype_in;
size_t len_in;
char name_in[NC_MAX_NAME + 1];
float lat[LAT_LEN], lon[LON_LEN];
float lat_in[LAT_LEN], lon_in[LON_LEN];
int i, j, k, l;
/* Some phony 4D pressure data. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
for (k = 0; k < LEVEL_LEN; k++)
for (l = 0; l <TIME_LEN; l++)
pres[i][j][k][l] = 1013.1 + j;
/* Some phony 3D hp data. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
for (l = 0; l <TIME_LEN; l++)
hp[i][j][l] = 100 + l;
/* Some phony 2D elevaton data. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
elev[i][j] = 1010101022223333ULL + i + j;
/* Some phony 1D lats and lons. */
for (i = 0; i < LAT_LEN; i++)
lat[i] = i * 5.;
for (i = 0; i < LON_LEN; i++)
lon[i] = i * 5.;
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
/* Define lat, lon, level, and timestep dimensions, with
* associated coordinate variables for lat and lon only. Time is
* an unlimited dimension. */
if (nc_def_dim(ncid, LAT_NAME, LAT_LEN, &lat_dimid)) ERR;
if (lat_dimid != LAT_DIMID) ERR;
dimids[0] = lat_dimid;
if (nc_def_var(ncid, LAT_NAME, NC_FLOAT, 1, dimids, &lat_varid)) ERR;
if (lat_varid != LAT_VARID) ERR;
if (nc_def_dim(ncid, LON_NAME, LON_LEN, &lon_dimid)) ERR;
if (lon_dimid != LON_DIMID) ERR;
dimids[0] = lon_dimid;
if (nc_def_var(ncid, LON_NAME, NC_FLOAT, 1, dimids, &lon_varid)) ERR;
if (lon_varid != LON_VARID) ERR;
if (nc_def_dim(ncid, LEVEL_NAME, LEVEL_LEN, &level_dimid)) ERR;
if (level_dimid != LEVEL_DIMID) ERR;
if (nc_def_dim(ncid, TIME_NAME, NC_UNLIMITED, &time_dimid)) ERR;
if (time_dimid != TIME_DIMID) ERR;
/* Define a 4D NC_DOUBLE variable called pressure. */
dimids[0] = lat_dimid;
dimids[1] = lon_dimid;
dimids[2] = level_dimid;
dimids[3] = time_dimid;
if (nc_def_var(ncid, PRES_NAME, NC_DOUBLE, 4, dimids, &pres_varid)) ERR;
if (pres_varid != PRES_VARID) ERR;
/* Define a 2D variable for surface elevation. Use NC_INT64
* because our units for this is Angstroms from Earth's
* Center. */
if (nc_def_var(ncid, ELEV_NAME, NC_INT64, 2, dimids, &elev_varid)) ERR;
if (elev_varid != ELEV_VARID) ERR;
/* Define a 3D NC_USHORT variable to store the number of Harry
* Potter books in this grid square at this time (ignore HP
* books in airplanes, dirigibles, hot air balloons, space
* capsules, hang-gliders, parachutes, and flying on brooms). */
dimids[2] = time_dimid;
if (nc_def_var(ncid, HP_NAME, NC_USHORT, 3, dimids, &hp_varid)) ERR;
if (hp_varid != HP_VARID) ERR;
/* Did all our stuff make it into the internal metadata model
* intact? */
/* Check our dimensions. */
if (nc_inq_dim(ncid, LAT_DIMID, name_in, &len_in)) ERR;
if (len_in != LAT_LEN || strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dim(ncid, LON_DIMID, name_in, &len_in)) ERR;
if (len_in != LON_LEN || strcmp(name_in, LON_NAME)) ERR;
if (nc_inq_dim(ncid, LEVEL_DIMID, name_in, &len_in)) ERR;
if (len_in != LEVEL_LEN || strcmp(name_in, LEVEL_NAME)) ERR;
if (nc_inq_dim(ncid, TIME_DIMID, name_in, &len_in)) ERR;
if (len_in != 0 || strcmp(name_in, TIME_NAME)) ERR;
/* Check our coordinate variables. */
if (nc_inq_var(ncid, LAT_VARID, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != LAT_DIMID || natts_in != 0) ERR;
if (nc_inq_var(ncid, LON_VARID, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 ||
dimids_in[0] != LON_DIMID || natts_in != 0) ERR;
/* Check our data variables. */
if (nc_inq_var(ncid, PRES_VARID, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, PRES_NAME) || xtype_in != NC_DOUBLE || ndims_in != 4 ||
dimids_in[0] != LAT_DIMID || dimids_in[1] != LON_DIMID ||
dimids_in[2] != LEVEL_DIMID || dimids_in[3] != TIME_DIMID ||
natts_in != 0) ERR;
if (nc_inq_var(ncid, ELEV_VARID, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, ELEV_NAME) || xtype_in != NC_INT64 || ndims_in != 2 ||
dimids_in[0] != LAT_DIMID || dimids_in[1] != LON_DIMID ||
natts_in != 0) ERR;
if (nc_inq_var(ncid, HP_VARID, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (strcmp(name_in, HP_NAME) || xtype_in != NC_USHORT || ndims_in != 3 ||
dimids_in[0] != LAT_DIMID || dimids_in[1] != LON_DIMID ||
dimids_in[2] != TIME_DIMID || natts_in != 0) ERR;
/* Write our latitude and longitude values. This writes all
* metadata to disk too. */
if (nc_put_var_float(ncid, lat_varid, lat)) ERR;
if (nc_put_var_float(ncid, lon_varid, lon)) ERR;
/* Write our 4D pressure, elevation, and hp data. But this
* should do nothing for pressure and hp, because these are
* record vars, and nc_put_var_* doesn't do anything to record
* vars, because it doesn't know how big the var is supposed to
* be. */
if (nc_put_var_double(ncid, pres_varid, (double *)pres)) ERR;
if (nc_put_var_ulonglong(ncid, elev_varid, (unsigned long long *)elev)) ERR;
if (nc_put_var_ushort(ncid, hp_varid, (unsigned short *)hp)) ERR;
/* Check our latitude and longitude values. */
if (nc_get_var(ncid, lat_varid, lat_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
if (lat[i] != lat_in[i]) ERR;
if (nc_get_var_float(ncid, lon_varid, lon_in)) ERR;
for (i = 0; i < LON_LEN; i++)
if (lon[i] != lon_in[i]) ERR;
/* Make sure our pressure and hp variables are still
* empty. get_var calls will return no error, but fetch no
* data. */
if (nc_inq_var(ncid, pres_varid, name_in, &xtype_in, &ndims_in,
dimids_in, &natts_in)) ERR;
if (nc_inq_dim(ncid, dimids_in[3], NULL, &len_in)) ERR;
if (len_in != 0) ERR;
memset(pres_in, 0, sizeof(pres_in));
if (nc_get_var_double(ncid, pres_varid, (double *)pres_in)) ERR;
/* Check our pressure values. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
for (k = 0; k < LEVEL_LEN; k++)
for (l = 0; l <TIME_LEN; l++)
if (0 != pres_in[i][j][k][l]) ERR;
if (nc_inq_var(ncid, hp_varid, NULL, NULL, &ndims_in,
dimids_in, NULL)) ERR;
if (nc_inq_dim(ncid, dimids_in[2], NULL, &len_in)) ERR;
if (len_in != 0) ERR;
memset(hp_in, 0, sizeof(hp_in));
if (nc_get_var_ushort(ncid, hp_varid, (unsigned short *)hp_in)) ERR;
/* Check our hp values. */
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
for (l = 0; l <TIME_LEN; l++)
if (0 != hp_in[i][j][l]) ERR;
/* Now use nc_put_vara to really write pressure and hp
* data. Write TIME_LEN (4) records of each. */
start[0] = start[1] = start[2] = start[3] = 0;
count[0] = LAT_LEN;
count[1] = LON_LEN;
count[2] = LEVEL_LEN;
count[3] = TIME_LEN;
if (nc_put_vara(ncid, pres_varid, start, count,
(double *)pres)) ERR;
count[2] = TIME_LEN;
if (nc_put_vara(ncid, hp_varid, start, count,
(double *)hp)) ERR;
/* Check our pressure values. */
if (nc_get_var_double(ncid, pres_varid, (double *)pres_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
for (k = 0; k < LEVEL_LEN; k++)
for (l = 0; l <TIME_LEN; l++)
if (pres[i][j][k][l] != pres_in[i][j][k][l]) ERR;
/* Check our elevation values. */
if (nc_get_var_ulonglong(ncid, elev_varid, (unsigned long long *)elev_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
if (elev[i][j] != elev_in[i][j]) ERR;
/* Check our hp values. */
if (nc_get_var_ushort(ncid, hp_varid, (unsigned short *)hp_in)) ERR;
for (i = 0; i < LAT_LEN; i++)
for (j = 0; j < LON_LEN; j++)
for (l = 0; l <TIME_LEN; l++)
if (hp[i][j][l] != hp_in[i][j][l]) ERR;
/* Close the file. */
if (nc_close(ncid)) ERR;
/* Reopen the file and check it out again. At the moment, we
* can't count on the varids and dimids being the same. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR;
if (ndims != 4 || nvars != 5 || natts != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing file with dims and only some coordinate vars...");
#define NDIMS_EX 4
#define NLAT 6
#define NLON 12
#define LAT_NAME_EX "latitude"
#define LON_NAME_EX "longitude"
#define NREC 2
#define REC_NAME "time"
#define LVL_NAME "level"
#define NLVL 2
/* Names of things. */
#define PRES_NAME "pressure"
#define TEMP_NAME "temperature"
#define UNITS "units"
#define DEGREES_EAST "degrees_east"
#define DEGREES_NORTH "degrees_north"
/* There are 4 vars, two for data, two for coordinate data. */
#define NVARS_EX 4
/* These are used to construct some example data. */
#define SAMPLE_PRESSURE 900
#define SAMPLE_TEMP 9.0
#define START_LAT 25.0
#define START_LON -125.0
/* For the units attributes. */
#define UNITS "units"
#define PRES_UNITS "hPa"
#define TEMP_UNITS "celsius"
#define LAT_UNITS "degrees_north"
#define LON_UNITS "degrees_east"
#define MAX_ATT_LEN 80
{
/* IDs for the netCDF file, dimensions, and variables. */
int ncid, lon_dimid, lat_dimid;
int lon_varid;
int ndims_in;
int dimid[NDIMS_EX];
char dim_name_in[NDIMS_EX][NC_MAX_NAME];
int i;
/* Create the file. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
/* Define the dimensions. */
if (nc_def_dim(ncid, LAT_NAME_EX, NLAT, &lat_dimid)) ERR;
if (nc_def_dim(ncid, LON_NAME_EX, NLON, &lon_dimid)) ERR;
/* Define a coordinate var. */
if (nc_def_var(ncid, LON_NAME_EX, NC_FLOAT, 1, &lon_dimid,
&lon_varid)) ERR;
/* Close the file. */
if (nc_close(ncid)) ERR;
if (nc_open(FILE_NAME, 0, &ncid)) ERR;
/* Check dimensions. */
ndims_in = 0;
if (nc_inq_dimids(ncid, &ndims_in, dimid, 0)) ERR;
if (ndims_in != 2) ERR;
for (i = 0; i < 2; i++)
{
if (dimid[i] != i) ERR;
if (nc_inq_dimname(ncid, i, dim_name_in[i])) ERR;
}
if (strcmp(dim_name_in[0], LAT_NAME_EX) ||
strcmp(dim_name_in[1], LON_NAME_EX)) ERR;
/* Close the file. */
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
printf("*** Testing file with just one very long dimension...");
{
#define VERY_LONG_LEN (size_t)4500000000LL
int ncid, dimid;
int ndims_in, dimids_in[MAX_DIMS];
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int varid_in;
if (SIZEOF_SIZE_T == 8)
{
/* Create a file with one dim and nothing else. */
if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR;
if (nc_def_dim(ncid, LAT_NAME, VERY_LONG_LEN, &dimid)) ERR;
/* Check it out. */
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != ((SIZEOF_SIZE_T == 8) ? VERY_LONG_LEN : NC_MAX_UINT) ||
strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1) ERR;
if (nc_inq_dimid(ncid, LAT_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimlen(ncid, 0, &len_in)) ERR;
if (len_in != ((SIZEOF_SIZE_T == 8) ? VERY_LONG_LEN : NC_MAX_UINT)) ERR;
if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR;
if (ndims_in != 0) ERR;
if (nc_close(ncid)) ERR;
/* Reopen and check it out again. */
if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR;
/* Check it out. */
if (nc_inq_dim(ncid, dimid, name_in, &len_in)) ERR;
if (len_in != ((SIZEOF_SIZE_T == 8) ? VERY_LONG_LEN : NC_MAX_UINT) ||
strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1) ERR;
if (nc_inq_dimid(ncid, LAT_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_dimname(ncid, 0, name_in)) ERR;
if (strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimlen(ncid, 0, &len_in)) ERR;
if (len_in != ((SIZEOF_SIZE_T == 8) ? VERY_LONG_LEN : NC_MAX_UINT)) ERR;
if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR;
if (ndims_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
}
SUMMARIZE_ERR;
printf("*** Testing reference file with just one very long dimension...");
{
#define REF_FILE_NAME "ref_tst_dims.nc"
int ncid, dimid = 0;
int ndims_in, dimids_in[MAX_DIMS];
size_t len_in;
char name_in[NC_MAX_NAME + 1];
int varid_in;
char file_in[NC_MAX_NAME + 1];
int ret;
strcpy(file_in, "");
if (getenv("srcdir"))
{
strcat(file_in, getenv("srcdir"));
strcat(file_in, "/");
}
strcat(file_in, REF_FILE_NAME);
/* Reopen and check it out again. */
if (nc_open(file_in, NC_NOWRITE, &ncid)) ERR;
/* Check it out. */
ret = nc_inq_dim(ncid, dimid, name_in, &len_in);
if ((SIZEOF_SIZE_T >= 8 && ret) ||
(SIZEOF_SIZE_T < 8 && ret != NC_EDIMSIZE)) ERR;
if (SIZEOF_SIZE_T < 8)
{
if (len_in != NC_MAX_UINT) ERR;
}
else
{
if (len_in != VERY_LONG_LEN) ERR;
}
if (strcmp(name_in, LAT_NAME)) ERR;
if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR;
if (ndims_in != 1) ERR;
if (nc_inq_dimid(ncid, LAT_NAME, &varid_in)) ERR;
if (varid_in != 0) ERR;
if (nc_inq_unlimdims(ncid, &ndims_in, dimids_in)) ERR;
if (ndims_in != 0) ERR;
if (nc_close(ncid)) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
