void fill_from_netcdf(const int ncid, const int vertex_cell_id, const int vertices_of_vertex_id)
{
const unsigned int buffsize = std::max(m_vertex_of_cell.n_nodes(), m_vertices_of_vertex.n_nodes()) *
std::max(m_vertex_of_cell.neigh_dim(), m_vertices_of_vertex.neigh_dim());
std::vector<double> tmp(buffsize);
int ierror = nc_get_var_double(ncid, vertex_cell_id, &tmp[0]);
assert(ierror==NC_NOERR);
unsigned int n_nodes = m_vertex_of_cell.n_nodes();
unsigned int neigh_dim = m_vertex_of_cell.neigh_dim();
for(unsigned int node_it = 0; node_it != n_nodes; ++node_it)
{
for(unsigned int neigh_it = 0; neigh_it != neigh_dim; ++neigh_it)
{
assert(node_it + neigh_it*n_nodes < buffsize);
m_vertex_of_cell.at(node_it+1, neigh_it) = tmp[node_it + neigh_it*n_nodes];
}
}
ierror = nc_get_var_double(ncid, vertices_of_vertex_id, &tmp[0]);
assert(ierror==NC_NOERR);
n_nodes = m_vertices_of_vertex.n_nodes();
neigh_dim = m_vertices_of_vertex.neigh_dim();
for(unsigned int node_it = 0; node_it != n_nodes; ++node_it)
{
for(unsigned int neigh_it = 0; neigh_it != neigh_dim; ++neigh_it)
{
assert(node_it + neigh_it*n_nodes < buffsize);
m_vertices_of_vertex.at(node_it+1, neigh_it) = tmp[node_it + neigh_it*n_nodes];
}
}
}
void get_depths(char depth_file[], char depth_names[2][NC_MAX_NAME], double **lay_depth,
double **int_depth, size_t *nz) {
// Read the depths of the intended layers from a NetCDF file.
int ncid, status, layid, layvid, intvid, k;
size_t nl;
status = nc_open(depth_file,NC_NOWRITE, &ncid);
if (status != NC_NOERR) handle_error(status,depth_file,status);
status = nc_inq_dimid(ncid, depth_names[0], &layid);
if (status != NC_NOERR) handle_error(status,depth_names[0],status);
status = nc_inq_dimlen(ncid, layid, &nl);
if (status != NC_NOERR) handle_error(status,"Getting # Layers",0);
*nz = nl;
*lay_depth = (double *) calloc(nl, sizeof(double));
*int_depth = (double *) calloc(nl+1, sizeof(double));
if ((lay_depth == NULL) || (int_depth == NULL)) {
printf("Unable to allocate input densities.\n"); exit(-1);
}
status = nc_inq_varid (ncid, depth_names[0], &layvid);
if (status != NC_NOERR) handle_error(status,depth_names[0],0);
status = nc_get_var_double(ncid, layvid, *lay_depth);
if (status != NC_NOERR) handle_error(status,depth_names[0],0);
status = nc_inq_varid (ncid, depth_names[1], &intvid);
if (status != NC_NOERR) handle_error(status,depth_names[1],0);
status = nc_get_var_double(ncid, intvid, *int_depth);
if (status != NC_NOERR) handle_error(status,depth_names[1],0);
nc_close(ncid);
/* Check the sign convention and change to the HIM "height" convention. */
if ((*int_depth)[0] < (*int_depth)[1]) {
for (k=0;k<nl;k++) (*lay_depth)[k] *= -1.0;
for (k=0;k<=nl;k++) (*int_depth)[k] *= -1.0;
}
/* Check for inversions in grid. */
for (k=0;k<nl;k++) {
if ((*lay_depth)[k] > (*int_depth)[k])
printf("Inverted layer/interface %d/%d - %g / %g.\n",
k,k,(*lay_depth)[k],(*int_depth)[k]);
if ((*lay_depth)[k] < (*int_depth)[k+1])
printf("Inverted layer/interface %d/%d - %g / %g.\n",
k,k+1,(*lay_depth)[k],(*int_depth)[k+1]);
if ((*int_depth)[k] < (*int_depth)[k+1])
printf("Inverted interface %d/%d depths - %g / %g.\n",
k,k+1,(*int_depth)[k],(*int_depth)[k+1]);
}
}
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);
}
/*******************************************************************************
void get_double_data(const char *file, const char *name, double *data)
get double data of field with "name" from "file".
******************************************************************************/
void get_double_data(const char *file, const char *name, double *data)
{
int ncid, varid, status;
char msg[512];
#ifdef use_netCDF
status = nc_open(file, NC_NOWRITE, &ncid);
if(status != NC_NOERR) {
sprintf(msg, "in opening file %s", file);
handle_netcdf_error(msg, status);
}
status = nc_inq_varid(ncid, name, &varid);
if(status != NC_NOERR) {
sprintf(msg, "in getting varid of %s from file %s.", name, file);
handle_netcdf_error(msg, status);
}
status = nc_get_var_double(ncid, varid, data);
if(status != NC_NOERR) {
sprintf(msg, "in getting data of %s from file %s.", name, file);
handle_netcdf_error(msg, status);
}
status = nc_close(ncid);
if(status != NC_NOERR) {
sprintf(msg, "in closing file %s.", file);
handle_netcdf_error(msg, status);
}
#else
error_handler("read_mosaic: Add flag -Duse_netCDF when compiling");
#endif
}; /* get_double_data */
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 read_axes(char var_name[], double **array, size_t *nz, size_t *nx, size_t *ny) {
size_t count[MAX_VAR_DIMS];
int ncid, i, varid, ndims, dimids[MAX_VAR_DIMS], status;
char dimname[NC_MAX_NAME];
ncid = ncInid[0];
if (ncid < 0) {
printf("ERROR: Required file (%d) for reading axes of %s is not open.\n",0,var_name);
exit(-1);
}
// printf("Inquire unlimdim of %s - id %d.\n",in_file,ncid);
// status = nc_inq_unlimdim(ncid,&recdim);
//if (status != NC_NOERR) handle_error(status,var_name,status);
// printf("Done opening %s.\n",in_file);
status = nc_inq_varid(ncid,var_name,&varid);
if (status != NC_NOERR) handle_error(status,var_name,status);
status = nc_inq_varndims(ncid,varid,&ndims);
if (status != NC_NOERR) handle_error(status,var_name,status);
if (ndims < 3) {
printf("ERROR: Unable to determine array sizes from %d-D field %s in file 0.\n",
ndims, var_name); return -1;
}
status = nc_inq_vardimid(ncid,varid,dimids);
if (status != NC_NOERR) handle_error(status,var_name,status);
// printf("Get %d dim lengths %s.\n",ndims,in_file);
for (i=0;i<ndims;i++) {
status = nc_inq_dimlen(ncid,dimids[i],&count[i]);
if (status != NC_NOERR) handle_error(status,var_name,i);
}
*nz = count[ndims-3];
*ny = count[ndims-2];
*nx = count[ndims-1];
// printf("Done getting info about %s.\n",var_name);
if (*array == NULL) {
*array = (double *) calloc(*nz, sizeof(double));
if (*array == NULL) printf("Unable to allocate array of size %ld for %s.\n",(long) *nz,var_name);
}
status = nc_inq_dimname(ncid,dimids[ndims-3],dimname);
if (status != NC_NOERR) handle_error(status,var_name,dimids[ndims-3]);
status = nc_inq_varid(ncid, dimname, &varid);
if (status != NC_NOERR) handle_error(status,dimname,status);
status = nc_get_var_double(ncid,varid,*array);
if (status != NC_NOERR) handle_error(status,dimname,status);
if (status != NC_NOERR) return -1;
return 0;
}
/** Get the specified frame from amber netcdf file
* Coords are a 1 dimensional array of format X1,Y1,Z1,X2,Y2,Z2,...
*/
int Traj_AmberRestartNC::readFrame(int set,double *X, double *V,double *box, double *T) {
// Get temperature
if (TempVID_!=-1) {
if ( checkNCerr(nc_get_var_double(ncid_, TempVID_, T)) ) {
mprinterr("Error: Getting replica temperature.\n");
return 1;
}
if (debug_>1) mprintf("DEBUG: %s: Replica Temperature %lf\n",filename_.base(), T);
}
// Read Coords
start_[0] = 0;
start_[1] = 0;
count_[0] = Ncatom();
count_[1] = 3;
if ( checkNCerr(nc_get_vara_double(ncid_, coordVID_, start_, count_, X)) ) {
mprinterr("Error: Getting Coords\n");
return 1;
}
// Read Velocity
if (velocityVID_!=-1 && V!=0) {
if ( checkNCerr(nc_get_vara_double(ncid_, velocityVID_, start_, count_, V)) ) {
mprinterr("Error: Getting velocities\n");
return 1;
}
}
// Read box info
if (cellLengthVID_ != -1) {
count_[0] = 3;
count_[1] = 0;
if ( checkNCerr(nc_get_vara_double(ncid_, cellLengthVID_, start_, count_, box)) ) {
mprinterr("Error: Getting cell lengths.\n");
return 1;
}
if ( checkNCerr(nc_get_vara_double(ncid_, cellAngleVID_, start_, count_, box+3)) ) {
mprinterr("Error: Getting cell angles.\n");
return 1;
}
}
return 0;
}
/*********************************************************************
void mpp_get_var_value(int fid, int vid, void *data)
read part of var data, the part is defined by start and nread.
*********************************************************************/
void mpp_get_var_value(int fid, int vid, void *data)
{
int status;
int *data_i4;
short *data_i2;
float *data_r4;
char errmsg[512];
if(fid<0 || fid >=nfiles) mpp_error("mpp_io(mpp_get_var_value_block): invalid fid number, fid should be "
"a nonnegative integer that less than nfiles");
if(vid<0 || vid >=files[fid].nvar) mpp_error("mpp_io(mpp_get_var_value_block): invalid vid number, vid should be "
"a nonnegative integer that less than nvar");
switch(files[fid].var[vid].type) {
case NC_DOUBLE:case NC_FLOAT:
status = nc_get_var_double(files[fid].ncid, files[fid].var[vid].fldid, data);
break;
case NC_INT:
status = nc_get_var_int(files[fid].ncid, files[fid].var[vid].fldid, data);
break;
case NC_SHORT:
status = nc_get_var_short(files[fid].ncid, files[fid].var[vid].fldid, data);
break;
case NC_CHAR:
status = nc_get_var_text(files[fid].ncid, files[fid].var[vid].fldid, data);
break;
default:
sprintf(errmsg, "mpp_io(mpp_get_var_value): field %s in file %s has an invalid type, "
"the type should be NC_DOUBLE, NC_FLOAT, NC_INT, NC_SHORT or NC_CHAR",
files[fid].var[vid].name, files[fid].name );
mpp_error(errmsg);
}
if(status != NC_NOERR) {
sprintf(errmsg, "mpp_io(mpp_get_var_value): Error in getting value of variable %s from file %s",
files[fid].var[vid].name, files[fid].name );
netcdf_error(errmsg, status);
}
}; /* mpp_get_var_value */
void MDAL::Driver3Di::addBedElevation( MDAL::Mesh *mesh )
{
assert( mesh );
if ( 0 == mesh->facesCount() )
return;
size_t faceCount = mesh->facesCount();
// read Z coordinate of 3di computation nodes centers
int ncidZ = mNcFile.getVarId( "Mesh2DFace_zcc" );
double fillZ = mNcFile.getFillValue( ncidZ );
std::vector<double> coordZ( faceCount );
if ( nc_get_var_double( mNcFile.handle(), ncidZ, coordZ.data() ) )
return; //error reading the array
std::shared_ptr<DatasetGroup> group = std::make_shared< DatasetGroup >(
name(),
mesh,
mesh->uri(),
"Bed Elevation"
);
group->setIsOnVertices( false );
group->setIsScalar( true );
std::shared_ptr<MDAL::MemoryDataset> dataset = std::make_shared< MemoryDataset >( group.get() );
dataset->setTime( 0.0 );
double *values = dataset->values();
for ( size_t i = 0; i < faceCount; ++i )
{
values[i] = MDAL::safeValue( coordZ[i], fillZ );
}
dataset->setStatistics( MDAL::calculateStatistics( dataset ) );
group->setStatistics( MDAL::calculateStatistics( group ) );
group->datasets.push_back( dataset );
mesh->datasetGroups.push_back( group );
}
/*+++++++++++++++++++++++++
.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;
}
void MDAL::Driver3Di::populateFacesAndVertices( Vertices &vertices, Faces &faces )
{
assert( vertices.empty() );
size_t faceCount = mDimensions.size( CFDimensions::Face2D );
faces.resize( faceCount );
size_t verticesInFace = mDimensions.size( CFDimensions::MaxVerticesInFace );
size_t arrsize = faceCount * verticesInFace;
std::map<std::string, size_t> xyToVertex2DId;
// X coordinate
int ncidX = mNcFile.getVarId( "Mesh2DContour_x" );
double fillX = mNcFile.getFillValue( ncidX );
std::vector<double> faceVerticesX( arrsize );
if ( nc_get_var_double( mNcFile.handle(), ncidX, faceVerticesX.data() ) ) throw MDAL_Status::Err_UnknownFormat;
// Y coordinate
int ncidY = mNcFile.getVarId( "Mesh2DContour_y" );
double fillY = mNcFile.getFillValue( ncidY );
std::vector<double> faceVerticesY( arrsize );
if ( nc_get_var_double( mNcFile.handle(), ncidY, faceVerticesY.data() ) ) throw MDAL_Status::Err_UnknownFormat;
// now populate create faces and backtrack which vertices
// are used in multiple faces
for ( size_t faceId = 0; faceId < faceCount; ++faceId )
{
Face face;
for ( size_t faceVertexId = 0; faceVertexId < verticesInFace; ++faceVertexId )
{
size_t arrId = faceId * verticesInFace + faceVertexId;
Vertex vertex;
vertex.x = faceVerticesX[arrId];
vertex.y = faceVerticesY[arrId];
vertex.z = 0;
if ( MDAL::equals( vertex.x, fillX ) || MDAL::equals( vertex.y, fillY ) )
break;
size_t vertexId;
std::string key = std::to_string( vertex.x ) + "," + std::to_string( vertex.y );
const auto it = xyToVertex2DId.find( key );
if ( it == xyToVertex2DId.end() )
{
// new vertex
vertexId = vertices.size();
xyToVertex2DId[key] = vertexId;
vertices.push_back( vertex );
}
else
{
// existing vertex
vertexId = it->second;
}
face.push_back( vertexId );
}
faces[faceId] = face;
}
// Only now we have number of vertices, since we identified vertices that
// are used in multiple faces
mDimensions.setDimension( CFDimensions::Vertex2D, vertices.size() );
}
/*! \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() */
/*! \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() */
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)
{
namespace po = boost::program_options;
int ndiamonds_label=0;
int nmpi=0;
bool doLabels= false;
// Declare the supported options.
po::options_description desc("Allowed options");
desc.add_options()
("help", "produce help message")
("label", "label all cells and vertices")
("ndiamonds-label", po::value<int>(&ndiamonds_label)->default_value(1), "number of diamonds to label (-1 for all)")
("input-file", po::value< std::vector<std::string> >(), "input file")
("nmpi", po::value<int>(&nmpi)->default_value(1), "number of mpi")
("ndims", po::value<int>(&nmpi)->default_value(3), "number of dimension for the gmesh")
;
po::positional_options_description p;
p.add("input-file", -1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
po::notify(vm);
if (vm.count("help")) {
std::cout << desc << "\n";
return 1;
}
if(!vm.count("input-file"))
{
std::cout << "Error: need to specify input file" << std::endl;
std::cout << desc << std::endl;
return 1;
}
const std::string ncfilename = vm["input-file"].as< std::vector<std::string> >()[0];
if ( !boost::filesystem::exists( ncfilename ) )
{
std::cout << "Can't find netcdf file!" << std::endl;
return 1;
}
unsigned int ndims = 3;
if(vm.count("ndims"))
{
ndims = vm["ndims"].as<int>();
if(ndims != 3 && ndims != 2) {
std::cout << "Error: wrong number of dimensions" << std::endl;
return 1;
}
}
if(vm.count("label")) doLabels=true;
int ncid;
int ierror = nc_open(ncfilename.c_str(), NC_NOWRITE, & ncid);
assert(ierror==NC_NOERR);
int cell_dimid;
ierror = nc_inq_dimid(ncid, "cell", &cell_dimid);
assert(ierror==NC_NOERR);
size_t cell_dimlen;
ierror = nc_inq_dimlen(ncid, cell_dimid, &cell_dimlen);
assert(ierror==NC_NOERR);
assert(cell_dimlen%20==0);
int vertex_dimid;
ierror = nc_inq_dimid(ncid, "vertex", &vertex_dimid);
assert(ierror==NC_NOERR);
size_t vertex_dimlen;
ierror = nc_inq_dimlen(ncid, vertex_dimid, &vertex_dimlen);
assert(ierror==NC_NOERR);
int cartx_vert_id, carty_vert_id, cartz_vert_id;
ierror= nc_inq_varid(ncid, "cartesian_x_vertices", &cartx_vert_id);
assert(ierror==NC_NOERR);
ierror= nc_inq_varid(ncid, "cartesian_y_vertices", &carty_vert_id);
assert(ierror==NC_NOERR);
ierror= nc_inq_varid(ncid, "cartesian_z_vertices", &cartz_vert_id);
assert(ierror==NC_NOERR);
int lon_vert_id, lat_vert_id;
ierror= nc_inq_varid(ncid, "longitude_vertices", &lon_vert_id);
assert(ierror==NC_NOERR);
ierror= nc_inq_varid(ncid, "latitude_vertices", &lat_vert_id);
assert(ierror==NC_NOERR);
int cart_vert_numdim;
ierror = nc_inq_varndims(ncid, cartx_vert_id, &cart_vert_numdim);
assert(ierror==NC_NOERR && cart_vert_numdim==1);
ierror = nc_inq_varndims(ncid, carty_vert_id, &cart_vert_numdim);
assert(ierror==NC_NOERR && cart_vert_numdim==1);
ierror = nc_inq_varndims(ncid, cartz_vert_id, &cart_vert_numdim);
assert(ierror==NC_NOERR && cart_vert_numdim==1);
int cart_vert_dimids[1];
ierror = nc_inq_vardimid(ncid, cartx_vert_id, cart_vert_dimids);
assert(ierror==NC_NOERR && cart_vert_dimids[0] == vertex_dimid);
ierror = nc_inq_vardimid(ncid, carty_vert_id, cart_vert_dimids);
assert(ierror==NC_NOERR && cart_vert_dimids[0] == vertex_dimid);
ierror = nc_inq_vardimid(ncid, cartz_vert_id, cart_vert_dimids);
assert(ierror==NC_NOERR && cart_vert_dimids[0] == vertex_dimid);
int vertex_cell_id;
ierror= nc_inq_varid(ncid, "vertex_of_cell", &vertex_cell_id);
assert(ierror==NC_NOERR);
int vertex_cell_numdim;
ierror = nc_inq_varndims(ncid, vertex_cell_id, &vertex_cell_numdim);
assert(ierror==NC_NOERR && vertex_cell_numdim==2);
int vertex_cell_dimids[2];
size_t vertex_cell_dimlens[2];
ierror = nc_inq_vardimid(ncid, vertex_cell_id, vertex_cell_dimids);
assert(ierror==NC_NOERR);
ierror = nc_inq_dimlen(ncid, vertex_cell_dimids[0], &vertex_cell_dimlens[0]);
assert(ierror==NC_NOERR && vertex_cell_dimlens[0] == 3);
ierror = nc_inq_dimlen(ncid, vertex_cell_dimids[1], &vertex_cell_dimlens[1]);
assert(ierror==NC_NOERR);
assert(vertex_cell_dimlens[1] == cell_dimlen);
int vertices_of_vertex_id;
ierror= nc_inq_varid(ncid, "vertices_of_vertex", &vertices_of_vertex_id);
assert(ierror==NC_NOERR);
int vertices_of_vertex_numdim;
ierror = nc_inq_varndims(ncid, vertices_of_vertex_id, &vertices_of_vertex_numdim);
assert(ierror==NC_NOERR && vertices_of_vertex_numdim==2);
int vertices_of_vertex_dimids[2];
size_t vertices_of_vertex_dimlens[2];
ierror = nc_inq_vardimid(ncid, vertices_of_vertex_id, vertices_of_vertex_dimids);
assert(ierror==NC_NOERR);
ierror = nc_inq_dimlen(ncid, vertices_of_vertex_dimids[0], &vertices_of_vertex_dimlens[0]);
assert(ierror==NC_NOERR);
ierror = nc_inq_dimlen(ncid, vertices_of_vertex_dimids[1], &vertices_of_vertex_dimlens[1]);
assert(vertex_dimlen == vertices_of_vertex_dimlens[1]);
assert(ierror==NC_NOERR);
// extract data from netcdf
mesh icon_mesh(vertex_cell_dimlens[1], vertices_of_vertex_dimlens[1], vertex_cell_dimlens[0], vertices_of_vertex_dimlens[0]);
std::vector<double> cartx_vert, carty_vert, cartz_vert;
cartx_vert.resize( vertex_dimlen );
carty_vert.resize( vertex_dimlen );
cartz_vert.resize( vertex_dimlen );
if(ndims == 3) {
ierror = nc_get_var_double(ncid, cartx_vert_id, &cartx_vert[0]);
assert(ierror==NC_NOERR);
ierror= nc_get_var_double(ncid, carty_vert_id, &carty_vert[0]);
assert(ierror==NC_NOERR);
ierror= nc_get_var_double(ncid, cartz_vert_id, &cartz_vert[0]);
assert(ierror==NC_NOERR);
}
else {
ierror = nc_get_var_double(ncid, lon_vert_id, &cartx_vert[0]);
assert(ierror==NC_NOERR);
ierror = nc_get_var_double(ncid, lat_vert_id, &carty_vert[0]);
assert(ierror==NC_NOERR);
for(size_t i=0; i < vertex_dimlen; ++i)
cartz_vert[i] = 0;
}
icon_mesh.insert_cart_vert(cartx_vert, carty_vert, cartz_vert);
icon_mesh.fill_from_netcdf(ncid, vertex_cell_id, vertices_of_vertex_id);
if(ndims==2) {
icon_mesh.add_ghost_nodes();
}
icon_mesh.gmsh_render(doLabels, nmpi);
nc_close(ncid);
};
NCtable_t *NCtableOpen(int ncid, char *tablename)
{
int status, *dimids, dimid, i = 0, j = 0;
int ndims, nvars;
size_t nrecords;
size_t len;
char varname [NC_MAX_NAME];
nc_type type;
NCfield_t *field = (NCfield_t *) NULL;
NCtable_t *tbl = (NCtable_t *) NULL;
if((status = nc_inq_dimid (ncid,tablename,&dimid)) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); return ((NCtable_t *) NULL); }
if((status = nc_inq_dimlen (ncid,dimid,&nrecords)) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); return ((NCtable_t *) NULL); }
if((status = nc_inq_nvars (ncid,&nvars)) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); return ((NCtable_t *) NULL); }
if(nc_inq_ndims(ncid,&ndims) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); return ((NCtable_t *) NULL); }
if ((dimids = (int *) malloc(sizeof(int) * ndims)) == (int *) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); return (NCtable_t *) NULL; }
if ((tbl = (NCtable_t *) malloc(sizeof(NCtable_t))) == (NCtable_t *) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); free (dimids); return ((NCtable_t *) NULL); }
if ((tbl->Name = (char *) malloc (strlen(tablename) + 1)) == (char *) NULL)
{ CMmsgPrint (CMmsgSysError, "Memory allocation error in: %s %d",__FILE__,__LINE__); free (dimids); free (tbl); return ((NCtable_t *) NULL); }
strcpy(tbl->Name,tablename);
tbl->NFields = 0;
tbl->Fields = (NCfield_t *) NULL;
for(i = 0; i < nvars; i++)
{
if ((status = nc_inq_vartype(ncid,i,&type)) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
if ((len = _NCtableVarLen(ncid,i,dimid,dimids)) == NCfailed) continue;
if ((type != NC_CHAR) && (len > 1)) continue;
if((status = nc_inq_varname(ncid,i,varname)) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
if ((tbl->Fields = (NCfield_t *) realloc (tbl->Fields, sizeof (NCfield_t) * (tbl->NFields + 1))) == (NCfield_t *) NULL)
{ CMmsgPrint (CMmsgSysError, "Error allocating memory in: %s %d",__FILE__,__LINE__); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
field = tbl->Fields + tbl->NFields;
tbl->NFields += 1;
field->NRecords = nrecords;
field->Data = (void *) NULL;
field->Name = (char *) NULL;
field->Type = type;
field->Len = len;
if ((field->Name = malloc (strlen (varname) + 1)) == (char *) NULL)
{ CMmsgPrint (CMmsgSysError, "Error allocating memory in: %s %d",__FILE__,__LINE__); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
strcpy (field->Name,varname);
if (nc_get_att_double (ncid,i,NCnameVAScaleFactor,&field->Scale) != NC_NOERR) field->Scale = 1.0;
if (nc_get_att_double (ncid,i,NCnameVAAddOffset, &field->Offset) != NC_NOERR) field->Offset = 0.0;
switch(field->Type)
{
case NC_CHAR:
if ((field->Data = (void *) malloc(field->NRecords * field->Len * sizeof (char))) == (void *) NULL)
{ CMmsgPrint (CMmsgSysError, "Error allocating memory in: %s %d",__FILE__,__LINE__); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
if((status = nc_get_var_text(ncid,i,(char *) (field->Data))) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
break;
case NC_BYTE:
case NC_SHORT:
case NC_INT:
if ((field->Data = (void *) malloc(field->NRecords * field->Len * sizeof (int))) == (void *) NULL)
{ CMmsgPrint (CMmsgSysError, "Error allocating memory in: %s %d",__FILE__,__LINE__); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
if((status = nc_get_var_int(ncid,i,(int *) (field->Data))) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
if (nc_get_att_int (ncid,i,NCnameVAFillValue, &field->FillValue.Int) != NC_NOERR) field->FillValue.Int = INT_NOVALUE;
if (nc_get_att_double (ncid,i,NCnameVAMissingVal, &field->MissingVal) != NC_NOERR) field->MissingVal = FLOAT_NOVALUE;
break;
case NC_FLOAT:
case NC_DOUBLE:
if ((field->Data = (void *) malloc(field->NRecords * field->Len * sizeof (double))) == (void *) NULL)
{ CMmsgPrint (CMmsgSysError, "Error allocating memory in: %s %d",__FILE__,__LINE__); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
if((status = nc_get_var_double(ncid,i,(double *) (field->Data))) != NC_NOERR)
{ NCprintNCError (status,"NCtableOpen"); free (dimids); NCtableClose (tbl); return ((NCtable_t *) NULL); }
if (nc_get_att_double (ncid,i,NCnameVAFillValue, &field->FillValue.Float) != NC_NOERR) field->FillValue.Float = FLOAT_NOVALUE;
if (nc_get_att_double (ncid,i,NCnameVAMissingVal, &field->MissingVal) != NC_NOERR) field->MissingVal = FLOAT_NOVALUE;
break;
default: field->Data = (void *) NULL; break;
}
if(GetDebug()) CMmsgPrint (CMmsgUsrError, "Loaded: %s(dimid: %d)\n",field->Name,dimid);
}
if(GetDebug())
{
CMmsgPrint (CMmsgUsrError, "Dim: %d Name: %s Cols: %d Rows: %d\n",dimid,tbl->Name,tbl->NFields,field->NRecords);
for(i = 0; i < tbl->NFields; i++)
{
field = tbl->Fields + i;
CMmsgPrint (CMmsgUsrError, "\tField: %d Name: %s ",i,field->Name);
switch(field->Type)
{
case NC_CHAR:
if(field->Len == 1)
{
CMmsgPrint (CMmsgUsrError, "Type: char\n");
for(j = 0; j < 5; j++) CMmsgPrint (CMmsgUsrError, "\t\t%d %c\n",j,((char *) (field->Data)) [j]);
}
else
{
CMmsgPrint (CMmsgUsrError, "Type: string\n");
for(j = 0; j < 5; j++) CMmsgPrint (CMmsgUsrError, "\t\t%d %s\n",j,((char *) (field->Data)) + j * field->Len);
}
break;
case NC_BYTE:
case NC_SHORT:
case NC_INT:
CMmsgPrint (CMmsgUsrError, "Type: int\n");
for(j = 0; j < 5; j++) CMmsgPrint (CMmsgUsrError, "\t\t%d %i\n",j,((int *) (field->Data)) [j]);
break;
case NC_FLOAT:
case NC_DOUBLE:
CMmsgPrint (CMmsgUsrError, "Type: double\n");
for(j = 0; j < 5; j++) CMmsgPrint (CMmsgUsrError, "\t\t%d %f\n",j,((double *) (field->Data)) [j]);
break;
default: break;
}
}
}
return (tbl);
}
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;
}
/*******************************************************************************
Function name: Read2DMatrixNetCDF()
Purpose : Function to read a 2D array from a file.
Required :
FileName - name of input file
Matrix - address of array data into
NumberType - code for number type (taken from HDF, see comments at the
beginning of InitFileIO.c for more detail)
NY - Number of rows
NX - Number of columns
NDataSet - number of the dataset to read, i.e. the first matrix in a
file is number 0, etc. (this is not used for the NetCDF file,
since we can retrieve the variable by name).
VarName - Name of variable to retrieve
Returns : Number of elements read
Modifies : Matrix
Comments : NOTE that we cannot modify anything other than the returned
Matrix, because we have to stay compatible with Read2DMatrixBin
*******************************************************************************/
int Read2DMatrixNetCDF(char *FileName, void *Matrix, int NumberType, int NY,
int NX, int NDataSet, ...)
{
const char *Routine = "Read2DMatrixNetCDF";
char Str[BUFSIZE + 1];
char dimname[NC_MAX_NAME + 1];
char *VarName;
int dimids[3];
int ndims;
int ncid;
int ncstatus;
nc_type TempNumberType;
int varid;
size_t index;
double time;
int timid;
size_t count[3];
size_t start[3] = { 0, 0, 0 };
size_t dimlen;
size_t timelen;
va_list ap;
double *Ycoord;
double *Xcoord; /* lat, lon variables */
int LatisAsc, LonisAsc, flag; /* flag */
int lon_varid, lat_varid;
count[0] = 1;
count[1] = NY;
count[2] = NX;
/****************************************************************************/
/* GO THROUGH VARIABLE ARGUMENT LIST */
/****************************************************************************/
va_start(ap, NDataSet);
VarName = va_arg(ap, char *);
index = va_arg(ap, int);
/****************************************************************************/
/* QUERY NETDCF FILE */
/****************************************************************************/
ncstatus = nc_open(FileName, NC_NOWRITE, &ncid);
/* debugging if any file fails to be opened */
//printf("Trying to open %s\n", FileName);
nc_check_err(ncstatus, __LINE__, __FILE__);
/* check whether the variable exists and get its parameters */
ncstatus = nc_inq_varid(ncid, VarName, &varid);
nc_check_err(ncstatus, __LINE__, __FILE__);
ncstatus = nc_inq_var(ncid, varid, 0, &TempNumberType, &ndims, dimids, NULL);
nc_check_err(ncstatus, __LINE__, __FILE__);
if (TempNumberType != NumberType) {
sprintf(Str, "%s: nc_type for %s is different than expected.\n",
FileName, VarName);
ReportWarning(Str, 58);
}
/* make sure that the x and y dimensions have the correct sizes */
ncstatus = nc_inq_dim(ncid, dimids[1], dimname, &dimlen);
nc_check_err(ncstatus, __LINE__, __FILE__);
ncstatus = nc_inq_varid(ncid, dimname, &lat_varid);
nc_check_err(ncstatus, __LINE__, __FILE__);
if (dimlen != NY)
ReportError(VarName, 59);
Ycoord = (double *) calloc(dimlen, sizeof(double));
if (Ycoord == NULL)
ReportError((char *) Routine, 1);
/* Read the latitude coordinate variable data. */
ncstatus = nc_get_var_double(ncid, lat_varid, Ycoord);
nc_check_err(ncstatus, __LINE__, __FILE__);
/* A quick check if the lat, long are in a ascending order.
If so, matrix must be flipped so the first value in the matrix will be
assigned to the lower left corner cell that has lowest X (lon) & Y (lat) value.
(see more comments in the header of this C file). */
LatisAsc = 1;
if( Ycoord[0] > Ycoord[NY - 1] )
LatisAsc = 0;
ncstatus = nc_inq_dim(ncid, dimids[2], dimname, &dimlen);
nc_check_err(ncstatus, __LINE__, __FILE__);
ncstatus = nc_inq_varid(ncid, dimname, &lon_varid);
nc_check_err(ncstatus, __LINE__, __FILE__);
if (dimlen != NX)
ReportError(VarName, 60);
Xcoord = (double *) calloc(NX, sizeof(double));
if (Xcoord == NULL)
ReportError((char *) Routine, 1);
/* Read the latitude coordinate variable data. */
ncstatus = nc_get_var_double(ncid, lon_varid, Xcoord);
nc_check_err(ncstatus, __LINE__, __FILE__);
LonisAsc = 1;
if( Xcoord[0] > Xcoord[NX - 1] )
LonisAsc = 0;
if (LonisAsc == 0){
printf("The current program does not handle the cases when longitude or X \
values in the .nc input in an descending order. You can either change the input \
.nc file format outside of this program. or you can easily modify this program to \
fit your needs. \n");
ReportError("Improper NetCDF input files", 58);
}
/*ARGSUSED*/
int
main(int argc, char *argv[])
{
int cmode=NC_CLOBBER, omode, ret;
int id;
char buf[256];
#ifdef SYNCDEBUG
char *str = "one";
#endif
int ii;
size_t ui;
const struct tcdfvar *tvp = testvars;
union getret got;
const size_t initialsz = 8192;
size_t chunksz = 8192;
size_t align = 8192/32;
MPI_Init(&argc, &argv);
/* cmode |= NC_PNETCDF |NC_64BIT_OFFSET; */
cmode != NC_PNETCDF |NC_64BIT_DATA;
ret = nc_create_par(fname,cmode, MPI_COMM_WORLD, MPI_INFO_NULL, &id);
if(ret != NC_NOERR) {
fprintf(stderr,"Error %s in file %s at line %d\n",nc_strerror(ret),__FILE__,__LINE__);
exit(ret);
}
assert( nc_put_att_text(id, NC_GLOBAL,
"TITLE", 12, "another name") == NC_NOERR);
assert( nc_get_att_text(id, NC_GLOBAL,
"TITLE", buf) == NC_NOERR);
/* (void) printf("title 1 \"%s\"\n", buf); */
assert( nc_put_att_text(id, NC_GLOBAL,
"TITLE", strlen(fname), fname) == NC_NOERR);
assert( nc_get_att_text(id, NC_GLOBAL,
"TITLE", buf) == NC_NOERR);
buf[strlen(fname)] = 0;
/* (void) printf("title 2 \"%s\"\n", buf); */
assert( strcmp(fname, buf) == 0);
createtestdims(id, NUM_DIMS, sizes, dim_names);
testdims(id, NUM_DIMS, sizes, dim_names);
createtestvars(id, testvars, NUM_TESTVARS);
{
int ifill = -1; double dfill = -9999;
assert( nc_put_att_int(id, Long_id,
_FillValue, NC_INT, 1, &ifill) == NC_NOERR);
assert( nc_put_att_double(id, Double_id,
_FillValue, NC_DOUBLE, 1, &dfill) == NC_NOERR);
}
#ifdef REDEF
assert( nc__enddef(id, 0, align, 0, 2*align) == NC_NOERR );
assert( nc_put_var1_int(id, Long_id, indices[3], &birthday)
== NC_NOERR );
fill_seq(id);
assert( nc_redef(id) == NC_NOERR );
/* assert( nc_rename_dim(id,2, "a long dim name") == NC_NOERR); */
#endif
assert( nc_rename_dim(id,1, "IXX") == NC_NOERR);
assert( nc_inq_dim(id, 1, buf, &ui) == NC_NOERR);
/* (void) printf("dimrename: %s\n", buf); */
assert( nc_rename_dim(id,1, dim_names[1]) == NC_NOERR);
#ifdef ATTRX
assert( nc_rename_att(id, 1, "UNITS", "units") == NC_NOERR);
assert( nc_del_att(id, 4, "FIELDNAM")== NC_NOERR);
assert( nc_del_att(id, 2, "SCALEMIN")== NC_NOERR);
assert( nc_del_att(id, 2, "SCALEMAX")== NC_NOERR);
#endif /* ATTRX */
assert( nc__enddef(id, 0, align, 0, 2*align) == NC_NOERR );
#ifndef REDEF
fill_seq(id);
assert( nc_put_var1_int(id, Long_id, indices[3], &birthday)== NC_NOERR );
#endif
assert( nc_put_vara_schar(id, Byte_id, s_start, s_edges,
(signed char *)sentence)
== NC_NOERR);
assert( nc_put_var1_schar(id, Byte_id, indices[6], (signed char *)(chs+1))
== NC_NOERR);
assert( nc_put_var1_schar(id, Byte_id, indices[5], (signed char *)chs)
== NC_NOERR);
assert( nc_put_vara_text(id, Char_id, s_start, s_edges, sentence)
== NC_NOERR);
assert( nc_put_var1_text(id, Char_id, indices[6], (chs+1))
== NC_NOERR) ;
assert( nc_put_var1_text(id, Char_id, indices[5], chs)
== NC_NOERR);
assert( nc_put_var1_short(id, Short_id, indices[4], shs)
== NC_NOERR);
assert( nc_put_var1_float(id, Float_id, indices[2], &e)
== NC_NOERR);
assert( nc_put_var1_double(id, Double_id, indices[1], &zed)
== NC_NOERR);
assert( nc_put_var1_double(id, Double_id, indices[0], &pinot)
== NC_NOERR);
#ifdef SYNCDEBUG
(void) printf("Hit Return to sync\n");
gets(str);
nc_sync(id,0);
(void) printf("Sync done. Hit Return to continue\n");
gets(str);
#endif /* SYNCDEBUG */
ret = nc_close(id);
/* (void) printf("nc_close ret = %d\n\n", ret); */
/*
* read it
*/
omode = NC_NOWRITE;
omode = NC_NOWRITE | NC_PNETCDF;
if(ret != NC_NOERR)
{
(void) printf("Could not open %s: %s\n", fname,
nc_strerror(ret));
exit(1);
}
/* (void) printf("reopen id = %d for filename %s\n", */
/* id, fname); */
/* NC */
/* (void) printf("NC "); */
assert( nc_inq(id, &(cdesc->num_dims), &(cdesc->num_vars),
&(cdesc->num_attrs), &(cdesc->xtendim) ) == NC_NOERR);
assert((size_t) cdesc->num_dims == num_dims);
assert(cdesc->num_attrs == 1);
assert(cdesc->num_vars == NUM_TESTVARS);
/* (void) printf("done\n"); */
/* GATTR */
/* (void) printf("GATTR "); */
assert( nc_inq_attname(id, NC_GLOBAL, 0, adesc->mnem) == 0);
assert(strcmp("TITLE",adesc->mnem) == 0);
assert( nc_inq_att(id, NC_GLOBAL, adesc->mnem, &(adesc->type), &(adesc->len))== NC_NOERR);
assert( adesc->type == NC_CHAR );
assert( adesc->len == strlen(fname) );
assert( nc_get_att_text(id, NC_GLOBAL, "TITLE", buf)== NC_NOERR);
buf[adesc->len] = 0;
assert( strcmp(fname, buf) == 0);
/* VAR */
/* (void) printf("VAR "); */
assert( cdesc->num_vars == NUM_TESTVARS );
for(ii = 0; ii < cdesc->num_vars; ii++, tvp++ )
{
int jj;
assert( nc_inq_var(id, ii,
vdesc->mnem,
&(vdesc->type),
&(vdesc->ndims),
vdesc->dims,
&(vdesc->num_attrs)) == NC_NOERR);
if(strcmp(tvp->mnem , vdesc->mnem) != 0)
{
(void) printf("attr %d mnem mismatch %s, %s\n",
ii, tvp->mnem, vdesc->mnem);
continue;
}
if(tvp->type != vdesc->type)
{
(void) printf("attr %d type mismatch %d, %d\n",
ii, (int)tvp->type, (int)vdesc->type);
continue;
}
for(jj = 0; jj < vdesc->ndims; jj++ )
{
if(tvp->dims[jj] != vdesc->dims[jj] )
{
(void) printf(
"inconsistent dim[%d] for variable %d: %d != %d\n",
jj, ii, tvp->dims[jj], vdesc->dims[jj] );
continue;
}
}
/* VATTR */
/* (void) printf("VATTR\n"); */
for(jj=0; jj<vdesc->num_attrs; jj++ )
{
assert( nc_inq_attname(id, ii, jj, adesc->mnem) == NC_NOERR);
if( strcmp(adesc->mnem, reqattr[jj]) != 0 )
{
(void) printf("var %d attr %d mismatch %s != %s\n",
ii, jj, adesc->mnem, reqattr[jj] );
break;
}
}
if( nc_inq_att(id, ii, reqattr[0], &(adesc->type), &(adesc->len))
!= -1) {
assert( adesc->type == NC_CHAR );
assert( adesc->len == strlen(tvp->units) );
assert( nc_get_att_text(id,ii,reqattr[0],buf)== NC_NOERR);
buf[adesc->len] = 0;
assert( strcmp(tvp->units, buf) == 0);
}
if(
nc_inq_att(id, ii, reqattr[1], &(adesc->type), &(adesc->len))
!= -1)
{
assert( adesc->type == NC_DOUBLE );
assert( adesc->len == 1 );
assert( nc_get_att_double(id, ii, reqattr[1], &got.dbl)== NC_NOERR);
chkgot(adesc->type, got, tvp->validmin);
}
if(
nc_inq_att(id, ii, reqattr[2], &(adesc->type), &(adesc->len))
!= -1)
{
assert( adesc->type == NC_DOUBLE );
assert( adesc->len == 1 );
assert( nc_get_att_double(id, ii, reqattr[2], &got.dbl)== NC_NOERR);
chkgot(adesc->type, got, tvp->validmax);
}
if(
nc_inq_att(id, ii, reqattr[3], &(adesc->type), &(adesc->len))
!= -1)
{
assert( adesc->type == NC_DOUBLE );
assert( adesc->len ==1 );
assert( nc_get_att_double(id, ii, reqattr[3], &got.dbl)== NC_NOERR);
chkgot(adesc->type, got, tvp->scalemin);
}
if(
nc_inq_att(id, ii, reqattr[4], &(adesc->type), &(adesc->len))
!= -1)
{
assert( adesc->type == NC_DOUBLE );
assert( adesc->len == 1 );
assert( nc_get_att_double(id, ii, reqattr[4], &got.dbl)== NC_NOERR);
chkgot(adesc->type, got, tvp->scalemax);
}
if( nc_inq_att(id, ii, reqattr[5], &(adesc->type), &(adesc->len))== NC_NOERR)
{
assert( adesc->type == NC_CHAR );
assert( adesc->len == strlen(tvp->fieldnam) );
assert( nc_get_att_text(id,ii,reqattr[5],buf)== NC_NOERR);
buf[adesc->len] = 0;
assert( strcmp(tvp->fieldnam, buf) == 0);
}
}
/* (void) printf("fill_seq "); */
check_fill_seq(id);
/* (void) printf("Done\n"); */
assert( nc_get_var1_double(id, Double_id, indices[0], &got.dbl)== NC_NOERR);
/* (void) printf("got val = %f\n", got.dbl ); */
assert( nc_get_var1_double(id, Double_id, indices[1], &got.dbl)== NC_NOERR);
/* (void) printf("got val = %f\n", got.dbl ); */
assert( nc_get_var1_float(id, Float_id, indices[2], &got.fl[0])== NC_NOERR);
/* (void) printf("got val = %f\n", got.fl[0] ); */
assert( nc_get_var1_int(id, Long_id, indices[3], &got.in[0])== NC_NOERR);
/* (void) printf("got val = %d\n", got.in[0] ); */
assert( nc_get_var1_short(id, Short_id, indices[4], &got.sh[0])== NC_NOERR);
/* (void) printf("got val = %d\n", got.sh[0] ); */
assert( nc_get_var1_text(id, Char_id, indices[5], &got.by[0]) == NC_NOERR);
/* (void) printf("got NC_CHAR val = %c (0x%02x) \n", */
/* got.by[0] , got.by[0]); */
assert( nc_get_var1_text(id, Char_id, indices[6], &got.by[0]) == NC_NOERR);
/* (void) printf("got NC_CHAR val = %c (0x%02x) \n", */
/* got.by[0], got.by[0] ); */
(void) memset(buf,0,sizeof(buf));
assert( nc_get_vara_text(id, Char_id, s_start, s_edges, buf) == NC_NOERR);
/* (void) printf("got NC_CHAR val = \"%s\"\n", buf); */
assert( nc_get_var1_schar(id, Byte_id, indices[5],
(signed char *)&got.by[0])== NC_NOERR);
/* (void) printf("got val = %c (0x%02x) \n", got.by[0] , got.by[0]); */
assert( nc_get_var1_schar(id, Byte_id, indices[6],
(signed char *)&got.by[0])== NC_NOERR);
/* (void) printf("got val = %c (0x%02x) \n", got.by[0], got.by[0] ); */
(void) memset(buf,0,sizeof(buf));
assert( nc_get_vara_schar(id, Byte_id, s_start, s_edges,
(signed char *)buf)== NC_NOERR );
/* (void) printf("got val = \"%s\"\n", buf); */
{
double dbuf[NUM_RECS * SIZE_1 * SIZE_2];
assert(nc_get_var_double(id, Float_id, dbuf) == NC_NOERR);
/* (void) printf("got vals = %f ... %f\n", dbuf[0], */
/* dbuf[NUM_RECS * SIZE_1 * SIZE_2 -1] ); */
}
ret = nc_close(id);
/* (void) printf("re nc_close ret = %d\n", ret); */
MPI_Finalize();
return 0;
}
int
main(int argc, char **argv)
{
size_t sizehint = 2100000; /* default if not set on command line,
* exposes bug. It turns out any
* value between 2091953 and 2150032
* triggers bug, whereas all other
* values work fine. */
if (argc > 1) {
char *endptr, *str = argv[1];
errno = 0;
sizehint = strtol(str, &endptr, 0);
/* check for various possible errors */
if ((errno == ERANGE && (sizehint == LONG_MAX || sizehint == LONG_MIN))
|| (errno != 0 && sizehint == 0)) {
perror("strtol");
exit(EXIT_FAILURE);
}
if (endptr == str) {
fprintf(stderr, "No digits were found\n");
exit(EXIT_FAILURE);
}
}
printf("\n*** Testing nofill mode.\n");
{
printf("*** Create file in nofill mode, writing all values...");
if (create_file(FILE_NAME1, NC_NOFILL, &sizehint)) ERR;
SUMMARIZE_ERR;
}
{
printf("*** Create file with same data in fill mode, writing all values...");
if (create_file(FILE_NAME2, NC_FILL, &sizehint)) ERR;
SUMMARIZE_ERR;
}
{
int ncid1, ncid2;
int nvars1, nvars2;
int varid;
int badvars;
printf("*** Compare values in nofill mode and fill mode files...");
/* compare data in two files created with nofill mode and fill
* mode, which should be identical if all the data were written */
if (nc_open(FILE_NAME1, NC_NOWRITE, &ncid1)) ERR;
if (nc_open(FILE_NAME2, NC_NOWRITE, &ncid2)) ERR;
if (nc_inq_nvars(ncid1, &nvars1)) ERR;
if (nc_inq_nvars(ncid2, &nvars2)) ERR;
if (nvars1 != nvars2) ERR;
badvars = 0;
for(varid = 0; varid < nvars1; varid++) {
size_t nvals, nn;
int ndims, *dimids, dim;
nc_type vtype;
char varname1[NC_MAX_NAME];
char varname2[NC_MAX_NAME];
/* How many values in this variable to compare? */
if (nc_inq_varndims(ncid1, varid, &ndims)) ERR;
dimids = malloc((ndims + 1) * sizeof(int));
if (!dimids) ERR;
if (nc_inq_vardimid (ncid1, varid, dimids)) ERR;
nvals = 1;
for(dim = 0; dim < ndims; dim++) {
size_t len;
if (nc_inq_dimlen(ncid1, dimids[dim], &len)) ERR;
nvals *= len;
}
if (nc_inq_vartype(ncid1, varid, &vtype)) ERR;
if (nc_inq_varname(ncid1, varid, varname1)) ERR;
if (nc_inq_varname(ncid1, varid, varname2)) ERR;
if (vtype != NC_CHAR) { /* numeric data, just read in as doubles */
double *data1, *data2;
/* Allocate space to hold values in both files */
data1 = malloc((nvals + 1) * sizeof(double));
if (!data1) ERR;
data2 = malloc((nvals + 1) * sizeof(double));
if (!data2) ERR;
/* Read in values */
if (nc_get_var_double(ncid1, varid, data1)) ERR;
if (nc_get_var_double(ncid2, varid, data2)) ERR;
/* Compare values */
for(nn = 0; nn < nvals; nn++) {
if (data1[nn] != data2[nn]) {
badvars++;
fprintf(stderr,
"\tFrom nofill file, %s[%d] = %.15g\tFrom fill file, %s[%d] = %.15g\n",
varname1, nn, data1[nn], varname2, nn, data2[nn]);
break;
};
}
free(data1);
free(data2);
} else { /* character data */
char *data1, *data2;
/* Allocate space to hold values in both files */
data1 = malloc((nvals + 1) * sizeof(char));
if (!data1) ERR;
data2 = malloc((nvals + 1) * sizeof(char));
if (!data2) ERR;
/* Read in values */
if (nc_get_var_text(ncid1, varid, data1)) ERR;
if (nc_get_var_text(ncid2, varid, data2)) ERR;
/* Compare values */
for(nn = 0; nn < nvals; nn++) {
if (data1[nn] != data2[nn]) {
badvars++;
fprintf(stderr,
"\tFrom nofill file, %s[%d] = %d\tFrom fill file, %s[%d] = %d\n",
varname1, nn, data1[nn], varname2, nn, data2[nn]);
break;
};
}
free(data1);
free(data2);
}
free(dimids);
}
if(badvars > 0) ERR;
if (nc_close(ncid1)) ERR;
if (nc_close(ncid2)) ERR;
SUMMARIZE_ERR;
}
FINAL_RESULTS;
}
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;
}
int ex_get_set_dist_fact (int exoid,
ex_entity_type set_type,
ex_entity_id set_id,
void *set_dist_fact)
{
int dimid, dist_id, set_id_ndx;
int status;
char errmsg[MAX_ERR_LENGTH];
char* factptr = NULL;
exerrval = 0; /* clear error code */
/* first check if any sets are specified */
if ((status = nc_inq_dimid (exoid, ex_dim_num_objects(set_type), &dimid)) != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Warning: no %s sets stored in file id %d",
ex_name_of_object(set_type), exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_WARN);
}
/* Lookup index of set id in VAR_*S_IDS array */
set_id_ndx = ex_id_lkup(exoid,set_type,set_id);
if (exerrval != 0) {
if (exerrval == EX_NULLENTITY) {
sprintf(errmsg,
"Warning: %s set %"PRId64" is NULL in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,EX_NULLENTITY);
return (EX_WARN);
} else {
sprintf(errmsg,
"Error: failed to locate %s set %"PRId64" in VAR_*S_IDS array in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
/* setup more pointers based on set_type */
if (set_type == EX_NODE_SET) {
factptr = VAR_FACT_NS(set_id_ndx);
}
else if (set_type == EX_EDGE_SET) {
factptr = VAR_FACT_ES(set_id_ndx);
}
else if (set_type == EX_FACE_SET) {
factptr = VAR_FACT_FS(set_id_ndx);
}
else if (set_type == EX_SIDE_SET) {
factptr = VAR_FACT_SS(set_id_ndx);
}
if (set_type == EX_ELEM_SET) {
factptr = VAR_FACT_ELS(set_id_ndx);
}
/* inquire id's of previously defined dimensions and variables */
if ((status = nc_inq_varid(exoid, factptr, &dist_id)) != NC_NOERR) {
exerrval = status;
/* not an error for node sets because this is how we check that df's exist */
if (set_type == EX_NODE_SET) {
sprintf(errmsg,
"Warning: dist factors not stored for %s set %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id, exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_WARN); /* complain - but not too loud */
}
/* is an error for other sets */
else {
sprintf(errmsg,
"Error: failed to locate dist factors list for %s set %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
}
/* read in the distribution factors array */
if (ex_comp_ws(exoid) == 4) {
status = nc_get_var_float(exoid, dist_id, set_dist_fact);
} else {
status = nc_get_var_double(exoid, dist_id, set_dist_fact);
}
if (status != NC_NOERR) {
exerrval = status;
sprintf(errmsg,
"Error: failed to get dist factors list for %s set %"PRId64" in file id %d",
ex_name_of_object(set_type), set_id,exoid);
ex_err("ex_get_set_dist_fact",errmsg,exerrval);
return (EX_FATAL);
}
return (EX_NOERR);
}
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
}
/*+++++++++++++++++++++++++
.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;
}
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);
}
void init_ncdf_atmos(Atmosphere *atmos, Geometry *geometry, NCDF_Atmos_file *infile)
/* Initialises the input atmosphere file, gets dimensions and variable ids.
Also performs other basic RH initialisations like readAbundance */
{
const char routineName[] = "init_ncdf";
struct stat statBuffer;
int ierror, ncid, x_varid, y_varid, z_varid, has_B, sn_varid;
size_t nn;
size_t start[] = {0, 0};
size_t count[] = {1, 1};
char *filename;
/* --- Get abundances of background elements -- -------------- */
readAbundance(atmos);
/* --- Open input file for model atmosphere -- -------------- */
if ((ierror = nc_open_par(input.atmos_input ,NC_NOWRITE | NC_MPIIO, mpi.comm,
mpi.info, &infile->ncid))) ERR(ierror,routineName);
ncid = infile->ncid;
/* Is magnetic field included? */
if ((ierror = nc_get_att_int( ncid, NC_GLOBAL, "has_B", &has_B)))
ERR(ierror,routineName);
atmos->Stokes = FALSE;
if ((has_B) && (strcmp(input.Stokes_input, "none"))) atmos->Stokes = TRUE;
/* Get the dimids and values */
if ((ierror = nc_inq_dimid( ncid, "nx", &infile->nx_id))) ERR(ierror,routineName);
if ((ierror = nc_inq_dimlen(ncid, infile->nx_id, &infile->nx))) ERR(ierror,routineName);
if ((ierror = nc_inq_dimid( ncid, "ny", &infile->ny_id))) ERR(ierror,routineName);
if ((ierror = nc_inq_dimlen(ncid, infile->ny_id, &infile->ny))) ERR(ierror,routineName);
if ((ierror = nc_inq_dimid( ncid, "nz", &infile->nz_id))) ERR(ierror,routineName);
if ((ierror = nc_inq_dimlen(ncid, infile->nz_id, &infile->nz))) ERR(ierror,routineName);
if ((ierror = nc_inq_dimid( ncid, "nhydr", &infile->nhyd_id))) ERR(ierror,routineName);
if ((ierror = nc_inq_dimlen(ncid, infile->nhyd_id, &nn))) ERR(ierror,routineName);
/* get some values in atmos/geometry structures */
geometry->Ndep = (int) infile->nz;
atmos->Nspace = (long) infile->nz;
atmos->NHydr = (int) nn;
if (atmos->NHydr < 2 && !atmos->H_LTE) {
sprintf(messageStr, "NHydr has to be at least 2, not %d to run with"
" NLTE hydrogen populations in background\n", atmos->NHydr);
Error(ERROR_LEVEL_2, routineName, messageStr);
}
/* Get the varids */
if ((ierror=nc_inq_varid(ncid, TEMP_NAME, &infile->T_varid))) ERR(ierror,routineName);
if ((ierror=nc_inq_varid(ncid, NE_NAME, &infile->ne_varid))) ERR(ierror,routineName);
if ((ierror=nc_inq_varid(ncid, VZ_NAME, &infile->vz_varid))) ERR(ierror,routineName);
if ((ierror=nc_inq_varid(ncid, NH_NAME, &infile->nh_varid))) ERR(ierror,routineName);
if ((ierror=nc_inq_varid(ncid, "z", &z_varid))) ERR(ierror,routineName);
if ((ierror=nc_inq_varid(ncid, "y", &y_varid))) ERR(ierror,routineName);
if ((ierror=nc_inq_varid(ncid, "x", &x_varid))) ERR(ierror,routineName);
if ((ierror=nc_inq_varid(ncid, SNAPNAME, &sn_varid))) ERR(ierror,routineName);
/* Microturbulence, get ID if variable found */
if ((ierror=nc_inq_varid(ncid, VTURB_NAME, &infile->vturb_varid))) {
/* exception for variable not found (errcode -49)*/
if (ierror == -49) infile->vturb_varid = -1; else ERR(ierror,routineName);
}
if (atmos->Stokes) {
if ((ierror = nc_inq_varid(ncid, BX_NAME, &infile->Bx_varid)))
ERR(ierror,routineName);
if ((ierror = nc_inq_varid(ncid, BY_NAME, &infile->By_varid)))
ERR(ierror,routineName);
if ((ierror = nc_inq_varid(ncid, BZ_NAME, &infile->Bz_varid)))
ERR(ierror,routineName);
}
/* read things that don't depend on x, y */
start[0] = input.p15d_nt; count[0] = 1;
start[1] = 0; count[1] = infile->nz;
geometry->height = (double *) malloc(infile->nz * sizeof(double));
if ((ierror = nc_get_vara_double(ncid, z_varid, start, count, geometry->height)))
ERR(ierror,routineName);
infile->y = (double *) malloc(infile->ny * sizeof(double));
if ((ierror = nc_get_var_double(ncid, y_varid, infile->y))) ERR(ierror,routineName);
infile->x = (double *) malloc(infile->nx * sizeof(double));
if ((ierror = nc_get_var_double(ncid, x_varid, infile->x))) ERR(ierror,routineName);
if ((ierror = nc_get_var1_int(ncid, sn_varid, start, &mpi.snap_number)))
ERR(ierror,routineName);
/* allocate arrays */
geometry->vel = (double *) malloc(atmos->Nspace * sizeof(double));
atmos->T = (double *) malloc(atmos->Nspace * sizeof(double));
atmos->ne = (double *) malloc(atmos->Nspace * sizeof(double));
atmos->vturb = (double *) calloc(atmos->Nspace , sizeof(double)); /* default zero */
atmos->nHtot = (double *) malloc(atmos->Nspace * sizeof(double));
if (atmos->Stokes) {
atmos->B = (double *) malloc(atmos->Nspace * sizeof(double));
atmos->gamma_B = (double *) malloc(atmos->Nspace * sizeof(double));
atmos->chi_B = (double *) malloc(atmos->Nspace * sizeof(double));
}
/* some other housekeeping */
geometry->vboundary[TOP] = ZERO;
geometry->vboundary[BOTTOM] = THERMALIZED;
geometry->scale = GEOMETRIC;
/* --- Construct atmosID from filename and last modification date - */
// NOTE: perhaps later this should be built into the NetCDF file (description attr?)
stat(input.atmos_input, &statBuffer);
if ((filename = strrchr(input.atmos_input, '/')) != NULL)
filename++;
else
filename = input.atmos_input;
sprintf(atmos->ID, "%s (%.24s)", filename,
asctime(localtime(&statBuffer.st_mtime)));
/* --- Get angle-quadrature and copy geometry independent quantity
wmu to atmos structure. -- -------------- */
getAngleQuad(geometry);
atmos->wmu = geometry->wmu;
/* --- set up pointers for background opacities --- */
atmos->chi_b = NULL;
atmos->eta_b = NULL;
atmos->sca_b = NULL;
return;
}
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);
}
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;
}
