NcBool NcVar::sync(void) { if (the_name) { delete [] the_name; } if (the_cur) { delete [] the_cur; } if (cur_rec) { delete [] cur_rec; } char nam[NC_MAX_NAME]; if (the_file && NcError::set_err( nc_inq_varname(the_file->id(), the_id, nam) ) == NC_NOERR) { the_name = new char[1 + strlen(nam)]; strcpy(the_name, nam); } else { the_name = 0; return FALSE; } init_cur(); return TRUE; }
/* Note that space for returned value MUST already be declared! */ void R_nc_inq_varname( int *ncid, int *varid, char **varname, int *retval ) { *retval = nc_inq_varname(*ncid, *varid, varname[0] ); if( *retval != NC_NOERR ) REprintf( "Error in R_nc_inq_varname: %s\n", nc_strerror(*retval) ); }
/********************************************************************************* * Return the varid of the only var in the file, or -1 if more than one. */ int R_ncu_varid_onlyvar( int ncid ) { int ierr, nvars, varid, i, dimid; char varname[MAX_NC_NAME]; varid = -1; ierr = nc_inq_nvars( ncid, &nvars ); if( ierr != NC_NOERR ) error("Error reading from netcdf file!"); for( i=0; i<nvars; i++ ) { ierr = nc_inq_varname( ncid, i, varname ); if( ierr != NC_NOERR ) error("Error reading from netcdf file!"); ierr = nc_inq_dimid( ncid, varname, &dimid ); if( ierr != NC_NOERR ) { /* Did NOT find this var as a dim, means it is NOT a dimvar */ if( varid != -1 ) /* More than one non-dimvar dim in this file */ return( -1 ); varid = i; } } return( varid ); }
// NetcdfFile::NetcdfDebug() void NetcdfFile::NetcdfDebug() { int ndimsp, nvarsp, ngattsp,unlimdimidp; char varname[128]; // ncid: NetCDF ID, from a previous call to nc open or nc create. // ndimsp: Pointer to location for returned number of dimensions defined for // this netCDF dataset. // nvarsp: Pointer to location for returned number of variables defined for // this netCDF dataset. // ngattsp: Pointer to location for returned number of global attributes // defined for this netCDF dataset. // unlimdimidp: // Pointer to location for returned ID of the unlimited dimension, if // there is one for this netCDF dataset. If no unlimited length // dimension has been defined, -1 is returned. mprintf("========== BEG. NETCDF DEBUG ==========\n"); int err = nc_inq(ncid_, &ndimsp, &nvarsp, &ngattsp, &unlimdimidp); mprintf("nc_inq returned %i\n",err); if (err==NC_NOERR) mprintf("ndimsp=%i nvarsp=%i ngattsp=%i unlimdimidp=%i\n", ndimsp,nvarsp,ngattsp,unlimdimidp); else mprintf("NETCDF Error occurred.\n"); // Print name of each variable defined in netcdf file mprintf("NC VARIABLES:\n"); for (int i=0; i<nvarsp; i++) { err=nc_inq_varname(ncid_,i,varname); mprintf(" Var %i - ",i); if (err==NC_NOERR) mprintf("%s\n",varname); else mprintf("NETCDF Error occured.\n"); } mprintf("========== END NETCDF DEBUG ==========\n"); }
/* Define a coordinate system. This creates a var with contains a text * attribute, which is the names of the (coordinate) vars which make * up the axes of a coordinate system. */ int nccf_def_coord_system(int ncid, const char *name, int naxes, int *axis_varids, int *system_varid) { int dimid, a; int varid; char var_name[NC_MAX_NAME + 1]; char *coord_axes_str; int ret; /* naxes must be positive and less than max_dims. */ if (naxes < 0) return NC_EINVAL; if (naxes > NC_MAX_DIMS) return NC_EMAXDIMS; /* Create a scalar var, type NC_CHAR, to hold the attribute that * defines this system. */ if ((ret = nc_def_var(ncid, name, NC_CHAR, 0, NULL, &varid))) return ret; /* If the user wants it, return the varid of this system. */ if (system_varid) *system_varid = varid; /* malloc space for the string which will hold the names of all the * axes. */ if (!(coord_axes_str = malloc(naxes * NC_MAX_NAME + naxes))) return NC_NOERR; coord_axes_str[0] = 0; /* Store the names of the axes in an attribute. At the same time, * make sure that all the axis_varids are actually coordinate * variables - that is, there is a dimension withn the same * name. */ for (a = 0; a < naxes; a++) { if ((ret = nc_inq_varname(ncid, axis_varids[a], var_name))) break; if ((ret = nc_inq_dimid(ncid, var_name, &dimid))) break; strcat(coord_axes_str, var_name); if (a < naxes - 1) strcat(coord_axes_str, " "); } /* If we arrived here without error, then write the coord_axes_str * to the appropriate attribute, to save the system in the file. */ if (!ret) ret = nc_put_att_text(ncid, varid, COORDINATE_AXES, strlen(coord_axes_str) + 1, coord_axes_str); /* Free the memory we allocated. */ free(coord_axes_str); return ret; }
MNCAPI int MI2varname(int fd, int varid, char *varnm) { if (MI2_ISH5OBJ(fd)) { return (hdf_varname(fd, varid, varnm)); } else { return (nc_inq_varname(fd, varid, varnm)); } }
/* Given an ncid, check the file to make sure it has all the objects I * expect. */ int check_classic_file(int ncid) { int varid, dimid, attnum; size_t att_len; nc_type att_type; char name_in[sizeof(name_utf8) + 1], strings_in[sizeof(name_utf8) + 1]; /* Check the variable. */ if (nc_inq_varid(ncid, name_utf8, &varid)) ERR; if (nc_inq_varname(ncid, varid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; if (nc_inq_varid(ncid, norm_utf8, &varid)) ERR; name_in[0] = 0; if (nc_inq_varname(ncid, varid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; if (nc_get_var_text(ncid, varid, strings_in)) ERR; if (strncmp(name_utf8, strings_in, sizeof(name_utf8))) ERR; strings_in[0] = '\0'; /* Reset my string buffer. */ /* Check the dimension. */ if (nc_inq_dimid(ncid, name_utf8, &dimid)) ERR; if (nc_inq_dimname(ncid, dimid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; if (nc_inq_dimid(ncid, norm_utf8, &dimid)) ERR; if (nc_inq_dimname(ncid, dimid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; /* Check the attribute. We don't normalize data or attribute * values, so get exactly what was put for the value, but * normalized values for names. */ if (nc_inq_attid(ncid, varid, norm_utf8, &attnum)) ERR; if (attnum) ERR; attnum = 99; /* Reset. */ if (nc_inq_attid(ncid, varid, name_utf8, &attnum)) ERR; if (attnum) ERR; if (nc_inq_att(ncid, varid, norm_utf8, &att_type, &att_len)) ERR; if (att_type != NC_CHAR || att_len != sizeof(name_utf8)) ERR; if (nc_get_att_text(ncid, varid, norm_utf8, strings_in)) ERR; if (strncmp(name_utf8, strings_in, sizeof(name_utf8))) ERR; return NC_NOERR; }
/* byte_style is 1 for signed, 2 for unsigned */ void R_nc_get_vara_int( int *ncid, int *varid, int *start, int *count, int *byte_style, int *data, int *retval ) { int i, err, ndims; size_t s_start[MAX_NC_DIMS], s_count[MAX_NC_DIMS], tot_size, k; char vn[2048]; nc_type nct; err = nc_inq_varndims(*ncid, *varid, &ndims ); if( err != NC_NOERR ) REprintf( "Error in R_nc_get_vara_int while getting ndims: %s\n", nc_strerror(*retval) ); tot_size = 1L; for( i=0; i<ndims; i++ ) { s_start[i] = (size_t)start[i]; s_count[i] = (size_t)count[i]; tot_size *= s_count[i]; } *retval = nc_get_vara_int(*ncid, *varid, s_start, s_count, data ); if( *retval != NC_NOERR ) { nc_inq_varname( *ncid, *varid, vn ); REprintf( "Error in R_nc_get_vara_int: %s\n", nc_strerror(*retval) ); REprintf( "Var: %s Ndims: %d Start: ", vn, ndims ); for( i=0; i<ndims; i++ ) { REprintf( "%u", (unsigned int)s_start[i] ); if( i < ndims-1 ) REprintf( "," ); } REprintf( "Count: " ); for( i=0; i<ndims; i++ ) { REprintf( "%u", (unsigned int)s_count[i] ); if( i < ndims-1 ) REprintf( "," ); } } *retval = nc_inq_vartype( *ncid, *varid, &nct ); if( nct == NC_BYTE ) { /* netcdf library for reading from byte to int, as we do here, * is SIGNED. So, if user requests signed, we don't have to * do anything; only adjust if user asks for unsigned. */ if( *byte_style == 2 ) { /* unsigned */ for( k=0L; k<tot_size; k++ ) { if( data[k] < 0 ) data[k] += 256; } } } }
int nccf_def_var(int ncid, int varid, const char *units, const char *long_name, const char *standard_name, int ncoord_vars, int *coord_varids) { char coord_name[NC_MAX_NAME + 1]; char coords_str[CF_MAX_COORD_LEN + 1]; int c, ret; /* Write units. */ if (units) if ((ret = nc_put_att_text(ncid, varid, CF_UNITS, strlen(units) + 1, units))) return ret; /* Write long_name. */ if (long_name) if ((ret = nc_put_att_text(ncid, varid, CF_LONG_NAME, strlen(long_name) + 1, long_name))) return ret; /* Write standard_name. */ if (standard_name) if ((ret = nc_put_att_text(ncid, varid, CF_STANDARD_NAME, strlen(standard_name) + 1, standard_name))) return ret; /* Now add the "coordinates" atttribute, which holds a space * separated list of auxilary coordinate variables. */ if (ncoord_vars) { if (ncoord_vars > CF_MAX_COORDS) return CF_EMAXCOORDS; if (!coord_varids) return CF_EINVAL; strcpy(coords_str, ""); for (c = 0; c < ncoord_vars; c++) { /* Find the names of this coordinate var. */ if ((ret = nc_inq_varname(ncid, coord_varids[c], coord_name))) return ret; strcat(coords_str, coord_name); strcat(coords_str, " "); } if ((ret = nc_put_att_text(ncid, varid, CF_COORDINATES, strlen(coords_str) + 1, coords_str))) return ret; } return NC_NOERR; }
int bi::InputNetCDFBuffer::mapCoordDim(int ncVar) { int ncDim, j = 0; /* check dimensions */ std::vector<int> dimids = nc_inq_vardimid(ncid, ncVar); ncDim = dimids[j]; if (ncDim >= 0 && ncDim == nsDim) { ncDim = dimids[j++]; } BI_ERROR_MSG(ncDim >= 0 && dimids.size() <= 3, "Coordinate variable " << nc_inq_varname(ncid, ncVar) << " has invalid dimensions, must have optional ns dimension followed by one or two arbitrary dimensions"); return ncDim; }
NcVar::NcVar(NcFile* nc, int id) : NcTypedComponent(nc), the_id(id) { char nam[NC_MAX_NAME]; if (the_file && NcError::set_err( nc_inq_varname(the_file->id(), the_id, nam) ) == NC_NOERR) { the_name = new char[1 + strlen(nam)]; strcpy(the_name, nam); } else { the_name = 0; } init_cur(); }
void R_nc_get_vara_text( int *ncid, int *varid, int *start, int *count, char **tempstore, char **data, int *retval ) { int i, err, ndims; size_t s_start[MAX_NC_DIMS], s_count[MAX_NC_DIMS], nstr, slen; char vn[2048]; err = nc_inq_varndims(*ncid, *varid, &ndims ); if( err != NC_NOERR ) REprintf( "Error in R_nc_get_vara_text while getting ndims: %s\n", nc_strerror(*retval) ); nstr = 1L; for( i=0; i<ndims; i++ ) { s_start[i] = (size_t)start[i]; s_count[i] = (size_t)count[i]; if( i < (ndims-1) ) nstr *= s_count[i]; } slen = s_count[ndims-1]; *retval = nc_get_vara_text(*ncid, *varid, s_start, s_count, tempstore[0] ); if( *retval != NC_NOERR ) { nc_inq_varname( *ncid, *varid, vn ); REprintf( "Error in R_nc_get_vara_text: %s\n", nc_strerror(*retval) ); REprintf( "Var: %s Ndims: %d Start: ", vn, ndims ); for( i=0; i<ndims; i++ ) { REprintf( "%u", (unsigned int)s_start[i] ); if( i < ndims-1 ) REprintf( "," ); } REprintf( "Count: " ); for( i=0; i<ndims; i++ ) { REprintf( "%u", (unsigned int)s_count[i] ); if( i < ndims-1 ) REprintf( "," ); } } /* Now copy each string over to the final data array */ for( i=0; i<nstr; i++ ) { strncpy( data[i], tempstore[0]+i*slen, slen ); data[i][slen] = '\0'; } }
void R_nc4_put_vara_double( int *ncid, int *varid, int *start, int *count, double *data, int *retval ) { int i, ndims, err, verbose; size_t s_start[MAX_NC_DIMS], s_count[MAX_NC_DIMS]; char varname[MAX_NC_NAME]; verbose = 0; if( verbose ) { err = nc_inq_varname( *ncid, *varid, varname ); Rprintf( "R_nc4_put_vara_double: entering with ncid=%d, varid=%d (varname=%s)\n", *ncid, *varid, varname ); } /* Get # of dims for this var */ err = nc_inq_varndims( *ncid, *varid, &ndims ); if( err != NC_NOERR ) Rprintf( "Error on nc_inq_varndims call in R_nc4_put_vara_double: %s\n", nc_strerror(*retval) ); if( verbose ) Rprintf( "R_nc4_put_vara_double: for this var ndims=%d\n", ndims ); /* Copy over from ints to size_t */ for( i=0; i<ndims; i++ ) { s_start[i] = (size_t)start[i]; s_count[i] = (size_t)count[i]; } if( verbose ) { Rprintf( "R_nc4_put_vara_double: about to write with start=" ); for( i=0; i<ndims; i++ ) Rprintf("%d ", s_start[i] ); Rprintf( " count=" ); for( i=0; i<ndims; i++ ) Rprintf("%d ", s_count[i] ); Rprintf( "\n" ); } *retval = nc_put_vara_double(*ncid, *varid, s_start, s_count, data ); if( *retval != NC_NOERR ) Rprintf( "Error in R_nc4_put_vara_double: %s\n", nc_strerror(*retval) ); if( verbose ) Rprintf( "R_nc4_put_vara_double: returning with errval=%d\n", *retval ); }
int nccf_assign_transform(int ncid, int system_varid, int transform_varid) { char transform_name[NC_MAX_NAME + 1]; int ret; /* Find the name of the transform. */ if ((ret = nc_inq_varname(ncid, transform_varid, transform_name))) return ret; /* Write the transform name as an att of the system to which it * applies. */ if ((ret = nc_put_att_text(ncid, system_varid, COORDINATE_TRANSFORMS, strlen(transform_name) + 1, transform_name))) return ret; return NC_NOERR; }
/* Inquire about a coordinate system. */ EXTERNL int nccf_inq_coord_system(int ncid, int system_varid, char *name, int *naxes, int *axis_varids) { int ret; /* Get the name of this coordinate system, which is the same as the * name of this variable. */ if ((ret = nc_inq_varname(ncid, system_varid, name))) return ret; /* Look up the ids of the vars in the COORDINATE_AXES attribute. */ if ((ret = nccf_parse_coords(ncid, system_varid, COORDINATE_AXES, naxes, axis_varids))) return ret; return ret; }
/*! This function queries the name of a variable given its id. \param [in] ncid Groupd id (or File Id) \param [in] varId Id of desired variable \param [out] varName name of desired variable \return Status code */ int CNetCdfInterface::inqVarName(int ncid, int varId, StdString& varName) { char varNameBuff[NC_MAX_NAME + 1]; int status = nc_inq_varname(ncid, varId, varNameBuff); if (NC_NOERR != status) { StdString errormsg(nc_strerror(status)); StdStringStream sstr; sstr << "Error when calling function nc_inq_varname(ncid, varId, varNameBuff)" << std::endl << errormsg << std::endl << "Unable to get variable name: "<< varName << " given its id: " << varId << std::endl; StdString e = sstr.str(); throw CNetCdfException(e); } varName = varNameBuff; return status; }
/* DAN ROE * dan_netcdf_debug() * For use in printing various attributes of a previously opened netcdf file. */ void dan_netcdf_debug(int ncid) { #ifdef BINTRAJ int ndimsp, nvarsp, ngattsp,unlimdimidp; int err,i; char *name; /* ncid: NetCDF ID, from a previous call to nc open or nc create. * ndimsp: Pointer to location for returned number of dimensions defined for * this netCDF dataset. * nvarsp: Pointer to location for returned number of variables defined for * this netCDF dataset. * ngattsp: Pointer to location for returned number of global attributes * defined for this netCDF dataset. * unlimdimidp: * Pointer to location for returned ID of the unlimited dimension, if * there is one for this netCDF dataset. If no unlimited length * dimension has been defined, -1 is returned. */ name=(char*) safe_malloc(1024*sizeof(char)); fprintf(stdout,"========== BEG. NETCDF DEBUG ==========\n"); err=nc_inq(ncid,&ndimsp,&nvarsp,&ngattsp,&unlimdimidp); fprintf(stdout,"nc_inq returned %i\n",err); if (err==NC_NOERR) fprintf(stdout,"ndimsp=%i nvarsp=%i ngattsp=%i unlimdimidp=%i\n", ndimsp,nvarsp,ngattsp,unlimdimidp); else fprintf(stdout,"NETCDF Error occurred.\n"); /* Print name of each variable defined in netcdf file */ fprintf(stdout,"NC VARIABLES:\n"); for (i=0; i<nvarsp; i++) { err=nc_inq_varname(ncid,i,name); fprintf(stdout," Var %i - ",i); if (err==NC_NOERR) fprintf(stdout,"%s\n",name); else fprintf(stdout,"NETCDF Error occured.\n"); } fprintf(stdout,"========== END NETCDF DEBUG ==========\n"); safe_free(name); #endif return; }
/* Given the varid of a system, write an attribute to a varid, whcih * indicates that it (the var) partakes of the system. Recall that the * system is just a collection of var names which are axes of the * coordinate system. */ int nccf_assign_coord_system(int ncid, int varid, int system_varid) { char system_name[NC_MAX_NAME + 1]; char *systems_str; size_t len, new_len = 0; int ret; /* Find the name of this system. */ if ((ret = nc_inq_varname(ncid, system_varid, system_name))) return ret; /* Is the att already here? If so, get it's length, then it's * contents, then append a space and the new system name. */ ret = nc_inq_att(ncid, varid, COORDINATE_SYSTEMS, NULL, &len); if (ret != NC_ENOTATT && ret != NC_NOERR) return ret; if (!ret) new_len += len; new_len += strlen(system_name) + 1; if (!(systems_str = malloc(new_len))) return NC_NOERR; systems_str[0] = 0; if (!ret) { if ((ret = nc_get_att_text(ncid, varid, COORDINATE_SYSTEMS, systems_str))) return ret; strcat(systems_str, " "); } strcat(systems_str, system_name); /* Write an att, called _CoordinateSystems, which * contains a list of the system names related to this variable. */ ret = nc_put_att_text(ncid, varid, COORDINATE_SYSTEMS, strlen(systems_str) + 1, systems_str); /* Free the memory we allocated. */ free(systems_str); return ret; }
NCstate NCdataCopyAllAttibutes(int inNCid, int outNCid, bool overwrite) { int status, inVarid, outVarid, varnum; char varName[NC_MAX_NAME]; if (NCdataCopyAttributes(inNCid, NC_GLOBAL, outNCid, NC_GLOBAL, overwrite) == NCfailed) return (NCfailed); if ((status = nc_inq_nvars(inNCid, &varnum)) != NC_NOERR) { NCprintNCError (status, "NCdataCopyAttibutes"); return (NCfailed); } for (inVarid = 0; inVarid < varnum; ++inVarid) { if ((status = nc_inq_varname(inNCid, inVarid, varName)) != NC_NOERR) { NCprintNCError (status, "NCdataCopyAttibutes"); return (NCfailed); } if ((status = nc_inq_varid(outNCid, varName, &outVarid)) != NC_NOERR) continue; if (NCdataCopyAttributes(inNCid, inVarid, outNCid, outVarid, overwrite) == NCfailed) return (NCfailed); } return (NCsucceeded); }
/* Here are functions for coordinate axis stuff. */ int nccf_def_axis_type(int ncid, int varid, int axis_type) { int dimid; char var_name[NC_MAX_NAME + 1]; int ret; /* Is the axis type valid? */ if (axis_type < 0 || axis_type > NCCF_RADDIST) return NC_EINVAL; /* Make sure there's a dimension with the same name in this * ncid. */ if ((ret = nc_inq_varname(ncid, varid, var_name))) return ret; if ((ret = nc_inq_dimid(ncid, var_name, &dimid))) return ret; /* Now write the attribute which stores the axis type. */ if ((ret = nc_put_att_text(ncid, varid, COORDINATE_AXIS_TYPE, strlen(axis_type_name[axis_type]) + 1, axis_type_name[axis_type]))) return ret; /* For height we write another attribute, indicating up * vs. down. */ if (axis_type == NCCF_HEIGHT_UP) { if ((ret = nc_put_att_text(ncid, varid, COORDINATE_Z_IS_POSITIVE, strlen(Z_UP) + 1, Z_UP))) return ret; } else if (axis_type == NCCF_HEIGHT_DOWN) { if ((ret = nc_put_att_text(ncid, varid, COORDINATE_Z_IS_POSITIVE, strlen(Z_UP) + 1, Z_UP))) return ret; } return NC_NOERR; }
EXTERNL int nccf_inq_transform(int ncid, int transform_varid, char *name, size_t *type_len, char *transform_type, size_t *name_len, char *transform_name) { int ret; /* Find the name of the transform var, if desired. */ if (name) if ((ret = nc_inq_varname(ncid, transform_varid, name))) return ret; /* If the user wants the length of the transform_type, find it. */ if (type_len) if ((ret = nc_inq_attlen(ncid, transform_varid, TRANSFORM_TYPE, type_len))) return ret; /* If the user wants the transform type string, get it. */ if (transform_type) if ((ret = nc_get_att_text(ncid, transform_varid, TRANSFORM_TYPE, transform_type))) return ret; /* If the user wants the length of the transform_name, find it. */ if (type_len) if ((ret = nc_inq_attlen(ncid, transform_varid, TRANSFORM_NAME, name_len))) return ret; /* If the user wants the transform name string, get it. */ if (transform_name) if ((ret = nc_get_att_text(ncid, transform_varid, TRANSFORM_NAME, transform_name))) return ret; return NC_NOERR; }
void R_nc_get_vara_double( int *ncid, int *varid, int *start, int *count, double *data, int *retval ) { int i, err, ndims; size_t s_start[MAX_NC_DIMS], s_count[MAX_NC_DIMS]; char vn[2048]; err = nc_inq_varndims(*ncid, *varid, &ndims ); if( err != NC_NOERR ) REprintf( "Error in R_nc_get_vara_double while getting ndims: %s\n", nc_strerror(*retval) ); for( i=0; i<ndims; i++ ) { s_start[i] = (size_t)start[i]; s_count[i] = (size_t)count[i]; } *retval = nc_get_vara_double(*ncid, *varid, s_start, s_count, data ); if( *retval != NC_NOERR ) { nc_inq_varname( *ncid, *varid, vn ); REprintf( "Error in R_nc_get_vara_double: %s\n", nc_strerror(*retval) ); REprintf( "Var: %s Ndims: %d Start: ", vn, ndims ); for( i=0; i<ndims; i++ ) { REprintf( "%u", (unsigned int)s_start[i] ); if( i < ndims-1 ) REprintf( "," ); } REprintf( "Count: " ); for( i=0; i<ndims; i++ ) { REprintf( "%u", (unsigned int)s_count[i] ); if( i < ndims-1 ) REprintf( "," ); } } }
int main(int argc, char **argv) { printf("\n*** Testing UTF-8 names.\n"); printf("*** creating UTF-8 names in classic model netcdf files..."); { int ncid, varid, dimids[NDIMS]; int f; for (f = NC_FORMAT_CLASSIC; f < NC_FORMAT_NETCDF4_CLASSIC; f++) { if (nc_set_default_format(f, NULL)) ERR; if (nc_create(FILE_NAME, NC_CLOBBER, &ncid)) ERR; /* Define various netcdf objects with a Unicode UTF-8 encoded name * that must be normalized. Where possible, also use the utf8 * string as the value. The name will be normalized, but not the * value. */ if (nc_def_dim(ncid, name_utf8, NX, &dimids[0])) ERR; if (nc_def_var(ncid, name_utf8, NC_CHAR, NDIMS, dimids, &varid)) ERR; if (nc_put_att_text(ncid, varid, name_utf8, sizeof(name_utf8), name_utf8)) ERR; if (nc_enddef(ncid)) ERR; /* Write var data. */ if (nc_put_var_text(ncid, varid, name_utf8)) ERR; /* Check the file. */ check_classic_file(ncid); if (nc_close(ncid)) ERR; /* Reopen the file and check again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; check_classic_file(ncid); if (nc_close(ncid)) ERR; } /* next format */ } SUMMARIZE_ERR; #define DIM1_NAME "d1" #define VAR1_NAME "v1" #define ATT1_NAME "a1" printf("*** renaming to UTF-8 names in classic model netcdf files..."); { int ncid, varid, dimids[NDIMS]; int f; for (f = NC_FORMAT_CLASSIC; f < NC_FORMAT_NETCDF4_CLASSIC; f++) { if (nc_set_default_format(f, NULL)) ERR; if (nc_create(FILE_NAME, NC_CLOBBER, &ncid)) ERR; /* Create objects. */ if (nc_def_dim(ncid, DIM1_NAME, NX, &dimids[0])) ERR; if (nc_rename_dim(ncid, 0, name_utf8)) ERR; if (nc_def_var(ncid, name_utf8, NC_CHAR, NDIMS, dimids, &varid)) ERR; if (nc_put_att_text(ncid, varid, ATT1_NAME, sizeof(name_utf8), name_utf8)) ERR; if (nc_rename_att(ncid, 0, ATT1_NAME, name_utf8)) ERR; if (nc_enddef(ncid)) ERR; /* Write var data. */ if (nc_put_var_text(ncid, varid, name_utf8)) ERR; /* Check the file. */ check_classic_file(ncid); if (nc_close(ncid)) ERR; /* Reopen the file and check again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; check_classic_file(ncid); if (nc_close(ncid)) ERR; } /* next format */ } SUMMARIZE_ERR; printf("*** creating UTF-8 names in netcdf-4 file..."); { int ncid, varid, grpid, comp_typeid, enum_typeid, grpid2, grpid3; int dimids[NDIMS]; char my_int = ENUM_VALUE; if (nc_create(FILE_NAME, NC_NETCDF4 | NC_CLOBBER, &ncid)) ERR; /* Define various netcdf objects with a Unicode UTF-8 encoded name * that must be normalized. Where possible, also use the utf8 * string as the value. The name will be normalized, but not the * value. */ if (nc_def_grp(ncid, name_utf8, &grpid)) ERR; if (nc_def_dim(grpid, name_utf8, NX, &dimids[0])) ERR; if (nc_def_var(grpid, name_utf8, NC_CHAR, NDIMS, dimids, &varid)) ERR; if (nc_put_att_text(grpid, varid, name_utf8, sizeof(name_utf8), name_utf8)) ERR; if (nc_def_grp(grpid, "tmp", &grpid2)) ERR; if (nc_def_enum(grpid2, NC_BYTE, name_utf8, &enum_typeid)) ERR; if (nc_insert_enum(grpid2, enum_typeid, name_utf8, &my_int)) ERR; if (nc_def_grp(grpid2, "tmp", &grpid3)) ERR; if (nc_def_compound(grpid3, sizeof(struct comp), name_utf8, &comp_typeid)) ERR; if (nc_insert_compound(grpid3, comp_typeid, name_utf8, offsetof(struct comp, i), NC_INT)) ERR; /* Write var data. */ if (nc_put_var_text(grpid, varid, name_utf8)) ERR; /* Check the file. */ check_nc4_file(ncid); if (nc_close(ncid)) ERR; /* Reopen the file and check again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; check_nc4_file(ncid); if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** ensuring UTF-8 normaization is applied in rename..."); { int ncid, varid; char name_in[NC_MAX_NAME + 1]; if (nc_create(FILE_NAME, NC_NETCDF4 | NC_CLOBBER, &ncid)) ERR; if (nc_def_var(ncid, BORING_NAME, NC_CHAR, 0, NULL, &varid)) ERR; if (nc_rename_var(ncid, varid, name_utf8)) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (!strcmp(name_in, norm_utf8)) ERR; if (nc_close(ncid)) ERR; /* Reopen the file and check again. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (!strcmp(name_in, norm_utf8)) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; FINAL_RESULTS; }
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) { 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; }
/* Given an ncid, check the file to make sure it has all the objects I * expect. */ int check_nc4_file(int ncid) { int varid, dimid, attnum, grpid, grpid2, grpid3, numgrps; int numtypes, enum_typeid, comp_typeid; int class_in; size_t att_len, size_in, num_mem, nfields_in; nc_type att_type, base_type_in; char name_in[NC_MAX_NAME + 1], strings_in[NC_MAX_NAME + 1], value; /* Check the group. */ if (nc_inq_grps(ncid, &numgrps, &grpid)) ERR; if (numgrps != 1) ERR; name_in[0] = 0; if (nc_inq_grpname(grpid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; /* Check the variable. */ if (nc_inq_varid(grpid, name_utf8, &varid)) ERR; if (nc_inq_varname(grpid, varid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; if (nc_inq_varid(grpid, norm_utf8, &varid)) ERR; name_in[0] = 0; if (nc_inq_varname(grpid, varid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; if (nc_get_var(grpid, varid, strings_in)) ERR; if (strncmp(name_utf8, strings_in, sizeof(name_utf8))) ERR; strings_in[0] = '\0'; /* Reset my string buffer. */ /* Check the dimension. */ if (nc_inq_dimid(grpid, name_utf8, &dimid)) ERR; if (nc_inq_dimname(grpid, dimid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; if (nc_inq_dimid(grpid, norm_utf8, &dimid)) ERR; if (nc_inq_dimname(grpid, dimid, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; /* Check the attribute. We don't normalize data or attribute * values, so get exactly what was put for the value, but * normalized values for names. */ if (nc_inq_attid(grpid, varid, norm_utf8, &attnum)) ERR; if (attnum) ERR; attnum = 99; /* Reset. */ if (nc_inq_attid(grpid, varid, name_utf8, &attnum)) ERR; if (attnum) ERR; if (nc_inq_att(grpid, varid, norm_utf8, &att_type, &att_len)) ERR; if (att_type != NC_CHAR || att_len != sizeof(name_utf8)) ERR; if (nc_get_att_text(grpid, varid, norm_utf8, strings_in)) ERR; if (strncmp(name_utf8, strings_in, sizeof(name_utf8))) ERR; /* Check the enum type. */ if (nc_inq_grps(grpid, &numgrps, &grpid2)) ERR; if (numgrps != 1) ERR; if (nc_inq_typeids(grpid2, &numtypes, &enum_typeid)) ERR; if (numtypes != 1) ERR; if (nc_inq_user_type(grpid2, enum_typeid, name_in, &size_in, &base_type_in, &nfields_in, &class_in)) ERR; if (strncmp(norm_utf8, name_in, strlen(norm_utf8)) || size_in != 1 || base_type_in != NC_BYTE || nfields_in != 1 || class_in != NC_ENUM) ERR; name_in[0] = size_in = base_type_in = 0; if (nc_inq_enum(grpid2, enum_typeid, name_in, &base_type_in, &size_in, &num_mem)) ERR; if (strncmp(norm_utf8, name_in, strlen(norm_utf8)) || size_in != 1 || base_type_in != NC_BYTE || num_mem != 1) ERR; if (nc_inq_enum_member(grpid2, enum_typeid, 0, name_in, &value)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8)) || value != ENUM_VALUE) ERR; /* Check the compound type. */ if (nc_inq_grps(grpid2, &numgrps, &grpid3)) ERR; if (numgrps != 1) ERR; if (nc_inq_typeids(grpid3, &numtypes, &comp_typeid)) ERR; if (numtypes != 1) ERR; name_in[0] = 0; if (nc_inq_user_type(grpid3, comp_typeid, name_in, &size_in, &base_type_in, &nfields_in, &class_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8)) || size_in != sizeof(struct comp) || base_type_in != NC_NAT || nfields_in != 1 || class_in != NC_COMPOUND) ERR; size_in = nfields_in = 999; if (nc_inq_compound(grpid3, comp_typeid, name_in, &size_in, &nfields_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8)) || size_in != sizeof(struct comp) || nfields_in != 1) ERR; name_in[0] = 0; if (nc_inq_compound_fieldname(grpid3, comp_typeid, 0, name_in)) ERR; if (strncmp(norm_utf8, name_in, sizeof(norm_utf8))) ERR; return NC_NOERR; }
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) { #ifdef USE_PARALLEL MPI_Init(&argc, &argv); #endif int ncid, dimids[3]; int char_varid, byte_varid, ubyte_varid, short_varid, int_varid, float_varid, double_varid; int ushort_varid, uint_varid, int64_varid, uint64_varid; int i, j; unsigned char ubyte_out[DIM1_LEN][DIM2_LEN] = {{1, 128, 255},{1, 128, 255}}; signed char byte_in[DIM1_LEN][DIM2_LEN], byte_out[DIM1_LEN][DIM2_LEN] = {{-127, 1, 127},{-127, 1, 127}}; unsigned short ushort_out[DIM1_LEN][DIM2_LEN] = {{110, 128, 255},{110, 128, 255}}; short short_in[DIM1_LEN][DIM2_LEN], short_out[DIM1_LEN][DIM2_LEN] = {{-110, -128, 255},{-110, -128, 255}}; int int_in[DIM1_LEN][DIM2_LEN], int_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}}; float float_in[DIM1_LEN][DIM2_LEN], float_out[DIM1_LEN][DIM2_LEN] = {{-.1, 9999.99, 100.001},{-.1, 9999.99, 100.001}}; double double_in[DIM1_LEN][DIM2_LEN], double_out[DIM1_LEN][DIM2_LEN] = {{0.02, .1128, 1090.1},{0.02, .1128, 1090.1}}; unsigned int uint_in[DIM1_LEN][DIM2_LEN], uint_out[DIM1_LEN][DIM2_LEN] = {{0, 128, 255},{0, 128, 255}}; long long int64_in[DIM1_LEN][DIM2_LEN], int64_out[DIM1_LEN][DIM2_LEN] = {{-111, 777, 100},{-111, 777, 100}}; unsigned long long uint64_in[DIM1_LEN][DIM2_LEN]; unsigned long long uint64_out[DIM1_LEN][DIM2_LEN] = {{0, 10101, 9999999},{0, 10101, 9999999}}; char char_out[DIM1_LEN][DIM2_LEN][DIM3_LEN] = {{"lalala", "lololo", "lelele"}, {"lalala", "lololo", "lelele"}}; /*nc_set_log_level(4);*/ printf("\n*** Testing netcdf-4 variable functions.\n"); printf("*** testing netcdf-4 varids inq on netcdf-3 file..."); { int nvars_in, varids_in[2]; /* Create a netcdf-3 file with one dim and two vars. */ if (nc_create(FILE_NAME, 0, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR; if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR; if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR; if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR; if (nc_close(ncid)) ERR; /* Open the file and make sure nc_inq_varids yeilds correct * result. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in != 2 || varids_in[0] != 0 || varids_in[1] != 1) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** testing simple variables..."); { /* Create a file with a variable of each type. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR; if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR; if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR; if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR; if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR; if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR; if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR; if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR; if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR; if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR; if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR; if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR; if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR; if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR; if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR; if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR; if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR; if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR; if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR; if (nc_put_var_ubyte(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR; if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR; if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR; if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR; if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR; if (nc_close(ncid)) ERR; /* Open the file and check metadata. */ { nc_type xtype_in; int ndims_in, dimids_in[10], natts_in, varid_in; char name_in[NC_MAX_NAME+1]; if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE || ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] || dimids_in[1] != dimids[1]) ERR; if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR; if (varid_in != 1) ERR; if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR; if (varid_in != 2) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, VAR_BYTE_NAME)) ERR; if (nc_inq_varname(ncid, 1, name_in)) ERR; if (strcmp(name_in, VAR_CHAR_NAME)) ERR; if (nc_inq_varname(ncid, 2, name_in)) ERR; if (strcmp(name_in, VAR_SHORT_NAME)) ERR; if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR; if (xtype_in != NC_BYTE) ERR; if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR; if (xtype_in != NC_CHAR) ERR; if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR; if (xtype_in != NC_SHORT) ERR; if (nc_close(ncid)) ERR; } /* Open the file and check data. */ if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != byte_out[i][j]) ERR; if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (short_in[i][j] != short_out[i][j]) ERR; if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (int_in[i][j] != int_out[i][j]) ERR; if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (float_in[i][j] != float_out[i][j]) ERR; if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != double_out[i][j]) ERR; if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != double_out[i][j]) ERR; if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != double_out[i][j]) ERR; if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (uint_in[i][j] != uint_out[i][j]) ERR; if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (int64_in[i][j] != int64_out[i][j]) ERR; if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (uint64_in[i][j] != uint64_out[i][j]) ERR; if (nc_close(ncid)) ERR; /* Open the file and read everything as double. */ if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)byte_out[i][j]) ERR; if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)ubyte_out[i][j]) ERR; if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)short_out[i][j]) ERR; if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)ushort_out[i][j]) ERR; if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)int_out[i][j]) ERR; if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)uint_out[i][j]) ERR; if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)float_out[i][j]) ERR; if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)int64_out[i][j]) ERR; if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)uint64_out[i][j]) ERR; if (nc_close(ncid)) ERR; /* Open the file and read everything as NC_BYTE. */ if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR; if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR; if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)short_out[i][j]) ERR; if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR; if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)int_out[i][j]) ERR; if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR; if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)float_out[i][j]) ERR; if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR; if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define DEFLATE_LEVEL_4 4 printf("*** testing simple variables with deflation..."); { /* Create a file with a variable of each type. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_dim(ncid, DIM2_NAME, DIM2_LEN, &dimids[1])) ERR; if (nc_def_dim(ncid, DIM3_NAME, DIM3_LEN, &dimids[2])) ERR; if (nc_def_var(ncid, VAR_BYTE_NAME, NC_BYTE, 2, dimids, &byte_varid)) ERR; if (nc_def_var_deflate(ncid, byte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_CHAR_NAME, NC_CHAR, 3, dimids, &char_varid)) ERR; if (nc_def_var_deflate(ncid, byte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_SHORT_NAME, NC_SHORT, 2, dimids, &short_varid)) ERR; if (nc_def_var_deflate(ncid, short_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_INT_NAME, NC_INT, 2, dimids, &int_varid)) ERR; if (nc_def_var_deflate(ncid, int_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_FLOAT_NAME, NC_FLOAT, 2, dimids, &float_varid)) ERR; if (nc_def_var_deflate(ncid, float_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_DOUBLE_NAME, NC_DOUBLE, 2, dimids, &double_varid)) ERR; if (nc_def_var_deflate(ncid, double_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_UBYTE_NAME, NC_UBYTE, 2, dimids, &ubyte_varid)) ERR; if (nc_def_var_deflate(ncid, ubyte_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_USHORT_NAME, NC_USHORT, 2, dimids, &ushort_varid)) ERR; if (nc_def_var_deflate(ncid, ushort_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_UINT_NAME, NC_UINT, 2, dimids, &uint_varid)) ERR; if (nc_def_var_deflate(ncid, uint_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_INT64_NAME, NC_INT64, 2, dimids, &int64_varid)) ERR; if (nc_def_var_deflate(ncid, int64_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_def_var(ncid, VAR_UINT64_NAME, NC_UINT64, 2, dimids, &uint64_varid)) ERR; if (nc_def_var_deflate(ncid, uint64_varid, 0, 1, DEFLATE_LEVEL_4)) ERR; if (nc_put_var_schar(ncid, byte_varid, (signed char *)byte_out)) ERR; if (nc_put_var_text(ncid, char_varid, (char *)char_out)) ERR; if (nc_put_var_short(ncid, short_varid, (short *)short_out)) ERR; if (nc_put_var_int(ncid, int_varid, (int *)int_out)) ERR; if (nc_put_var_float(ncid, float_varid, (float *)float_out)) ERR; if (nc_put_var_double(ncid, double_varid, (double *)double_out)) ERR; if (nc_put_var_ubyte(ncid, ubyte_varid, (unsigned char *)ubyte_out)) ERR; if (nc_put_var_ushort(ncid, ushort_varid, (unsigned short *)ushort_out)) ERR; if (nc_put_var_uint(ncid, uint_varid, (unsigned int *)uint_out)) ERR; if (nc_put_var_longlong(ncid, int64_varid, (long long *)int64_out)) ERR; if (nc_put_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_out)) ERR; if (nc_close(ncid)) ERR; /* Open the file and check metadata. */ { nc_type xtype_in; int ndims_in, dimids_in[10], natts_in, varid_in; char name_in[NC_MAX_NAME+1]; if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimids_in, &natts_in)) ERR; if (strcmp(name_in, VAR_BYTE_NAME) || xtype_in != NC_BYTE || ndims_in != 2 || natts_in != 0 || dimids_in[0] != dimids[0] || dimids_in[1] != dimids[1]) ERR; if (nc_inq_varid(ncid, VAR_BYTE_NAME, &varid_in)) ERR; if (varid_in != 0) ERR; if (nc_inq_varid(ncid, VAR_CHAR_NAME, &varid_in)) ERR; if (varid_in != 1) ERR; if (nc_inq_varid(ncid, VAR_SHORT_NAME, &varid_in)) ERR; if (varid_in != 2) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, VAR_BYTE_NAME)) ERR; if (nc_inq_varname(ncid, 1, name_in)) ERR; if (strcmp(name_in, VAR_CHAR_NAME)) ERR; if (nc_inq_varname(ncid, 2, name_in)) ERR; if (strcmp(name_in, VAR_SHORT_NAME)) ERR; if (nc_inq_vartype(ncid, 0, &xtype_in)) ERR; if (xtype_in != NC_BYTE) ERR; if (nc_inq_vartype(ncid, 1, &xtype_in)) ERR; if (xtype_in != NC_CHAR) ERR; if (nc_inq_vartype(ncid, 2, &xtype_in)) ERR; if (xtype_in != NC_SHORT) ERR; if (nc_close(ncid)) ERR; } /* Open the file and check data. */ if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != byte_out[i][j]) ERR; if (nc_get_var_short(ncid, short_varid, (short *)short_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (short_in[i][j] != short_out[i][j]) ERR; if (nc_get_var_int(ncid, int_varid, (int *)int_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (int_in[i][j] != int_out[i][j]) ERR; if (nc_get_var_float(ncid, float_varid, (float *)float_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (float_in[i][j] != float_out[i][j]) ERR; if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != double_out[i][j]) ERR; if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != double_out[i][j]) ERR; if (nc_get_var_double(ncid, double_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != double_out[i][j]) ERR; if (nc_get_var_uint(ncid, uint_varid, (unsigned int *)uint_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (uint_in[i][j] != uint_out[i][j]) ERR; if (nc_get_var_longlong(ncid, int64_varid, (long long *)int64_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (int64_in[i][j] != int64_out[i][j]) ERR; if (nc_get_var_ulonglong(ncid, uint64_varid, (unsigned long long *)uint64_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (uint64_in[i][j] != uint64_out[i][j]) ERR; if (nc_close(ncid)) ERR; /* Open the file and read everything as double. */ if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_get_var_double(ncid, byte_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)byte_out[i][j]) ERR; if (nc_get_var_double(ncid, ubyte_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)ubyte_out[i][j]) ERR; if (nc_get_var_double(ncid, short_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)short_out[i][j]) ERR; if (nc_get_var_double(ncid, ushort_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)ushort_out[i][j]) ERR; if (nc_get_var_double(ncid, int_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)int_out[i][j]) ERR; if (nc_get_var_double(ncid, uint_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)uint_out[i][j]) ERR; if (nc_get_var_double(ncid, float_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)float_out[i][j]) ERR; if (nc_get_var_double(ncid, int64_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)int64_out[i][j]) ERR; if (nc_get_var_double(ncid, uint64_varid, (double *)double_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (double_in[i][j] != (double)uint64_out[i][j]) ERR; if (nc_close(ncid)) ERR; /* Open the file and read everything as NC_BYTE. */ if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_get_var_schar(ncid, byte_varid, (signed char *)byte_in)) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)byte_out[i][j]) ERR; if (nc_get_var_schar(ncid, ubyte_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)ubyte_out[i][j]) ERR; if (nc_get_var_schar(ncid, short_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)short_out[i][j]) ERR; if (nc_get_var_schar(ncid, ushort_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)ushort_out[i][j]) ERR; if (nc_get_var_schar(ncid, int_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)int_out[i][j]) ERR; if (nc_get_var_schar(ncid, uint_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)uint_out[i][j]) ERR; if (nc_get_var_schar(ncid, float_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)float_out[i][j]) ERR; if (nc_get_var_schar(ncid, int64_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)int64_out[i][j]) ERR; if (nc_get_var_schar(ncid, uint64_varid, (signed char *)byte_in) != NC_ERANGE) ERR; for (i = 0; i < DIM1_LEN; i++) for (j = 0; j < DIM2_LEN; j++) if (byte_in[i][j] != (signed char)uint64_out[i][j]) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define NDIMS4 1 #define NVARS4 1 #define DIM4_NAME "treaty_of_paris_1783" #define DIM4_LEN 5 #define VAR_NAME4 "John_Adams" #define DEFLATE_LEVEL 6 printf("*** testing netcdf-4 simple variable define..."); { int dimids[NDIMS4], dimids_in[NDIMS4]; int varid, varids_in[NVARS4]; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int shuffle_in, deflate_in, deflate_level; /* Create a netcdf-4 file with one dim and one var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM4_NAME, DIM4_LEN, &dimids[0])) ERR; if (dimids[0] != 0) ERR; if (nc_def_var(ncid, VAR_NAME4, NC_INT64, NDIMS4, dimids, &varid)) ERR; if (nc_def_var_deflate(ncid, varid, 0, 1, DEFLATE_LEVEL)) ERR; if (varid != 0) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != NVARS4) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in, &deflate_level)) ERR; if (shuffle_in ||!deflate_in || deflate_level != DEFLATE_LEVEL) ERR; if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS4 || nvars != NVARS4 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != NVARS4) ERR; if (varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR_NAME4) || xtype_in != NC_INT64 || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in, &deflate_level)) ERR; if (shuffle_in ||!deflate_in || deflate_level != DEFLATE_LEVEL) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define NDIMS5 1 #define NVARS5 5 #define DIM5_NAME "treaty_of_paris_1783" #define DIM5_LEN 5 printf("*** testing netcdf-4 less simple variable define..."); { int dimids[NDIMS5], dimids_in[NDIMS5]; int varid[NVARS5], varids_in[NVARS5]; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; char var_name[NVARS5][NC_MAX_NAME + 1] = {"Jean-Pierre_Blanchard", "Madame_Blanchard", "Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome", "Charles_F_Ritchel"}; int shuffle_in, deflate_in, deflate_level_in; int deflate_level[NVARS5]; int i; /* Set up options for this var. */ for (i = 0; i < NVARS5; i++) deflate_level[i] = i; /* Create a netcdf-4 file with one dim and two vars. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM5_NAME, DIM5_LEN, &dimids[0])) ERR; if (dimids[0] != 0) ERR; for (i = 0; i < NVARS5; i++) { if (nc_def_var(ncid, var_name[i], NC_INT64, NDIMS5, dimids, &varid[i])) ERR; if (varid[i] != i) ERR; if (nc_def_var_deflate(ncid, varid[i], 1, 1, deflate_level[i])) ERR; } /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != NVARS5) ERR; for (i = 0; i < NVARS5; i++) { if (varids_in[i] != i) ERR; if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in, &deflate_level_in)) ERR; if (!shuffle_in || !deflate_in || deflate_level_in != deflate_level[i]) ERR; } if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS5 || nvars != NVARS5 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != NVARS5) ERR; for (i = 0; i < NVARS5; i++) { if (varids_in[i] != i) ERR; if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, var_name[i]) || xtype_in != NC_INT64 || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in, &deflate_level_in)) ERR; if (!shuffle_in || !deflate_in || deflate_level_in != deflate_level[i]) ERR; } if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define NVARS 5 #define NDIMS 1 #define DIM6_NAME "airship_cross_sectional_area" #define DIM6_LEN 100 #define TEN_K_M2 10000.0 #define INCREMENT 1000.0 printf("*** testing more complex netcdf-4 variable defines..."); { int dimids[NDIMS], dimids_in[NDIMS]; int varid[NVARS], varids_in[NVARS]; int ndims, nvars, natts, unlimdimid; char var_name[NVARS][50] = {"Jean-Pierre_Blanchard", "Madame_Blanchard", "Giffard", "Stanislas_Charles_Henri_Dupuy_de_Lome", "Charles_F_Ritchel"}; double data[DIM6_LEN]; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int shuffle_in, deflate_in, deflate_level_in; int fletcher32_in; int i; /* Create some phoney data. */ for (i = 1, data[0] = TEN_K_M2; i < DIM6_LEN; i++) data[i] = data[i - 1] + INCREMENT; /* Create a netcdf-4 file with one dim and 5 NC_DOUBLE vars. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM6_NAME, DIM6_LEN, &dimids[0])) ERR; for (i = 0; i < NVARS; i++) { if (nc_def_var(ncid, var_name[i], NC_DOUBLE, NDIMS, dimids, &varid[i])) ERR; if (nc_def_var_deflate(ncid, varid[i], 0, 1, 0)) ERR; if (nc_def_var_fletcher32(ncid, varid[i], 1)) ERR; } /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS || nvars != NVARS || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != NVARS) ERR; for (i = 0; i < NVARS; i++) if (varids_in[i] != i) ERR; for (i = 0; i < NVARS; i++) { if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in, &deflate_level_in)) ERR; if (shuffle_in || !deflate_in || deflate_level_in != 0) ERR; if (nc_inq_var_fletcher32(ncid, varid[i], &fletcher32_in)) ERR; if (!fletcher32_in) ERR; } if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS || nvars != NVARS || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != NVARS) ERR; for (i = 0; i < NVARS; i++) if (varids_in[i] != i) ERR; for (i = 0; i < NVARS; i++) { if (nc_inq_var(ncid, i, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, var_name[i]) || xtype_in != NC_DOUBLE || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_deflate(ncid, varid[i], &shuffle_in, &deflate_in, &deflate_level_in)) ERR; if (shuffle_in || !deflate_in || deflate_level_in != 0) ERR; if (nc_inq_var_fletcher32(ncid, varid[i], &fletcher32_in)) ERR; if (!fletcher32_in) ERR; } if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define DIM7_LEN 2 #define DIM7_NAME "dim_7_from_Indiana" #define VAR7_NAME "var_7_from_Idaho" #define NDIMS 1 printf("*** testing fill values..."); { int dimids[NDIMS], dimids_in[NDIMS]; size_t index[NDIMS]; int varid, ndims, natts; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int shuffle_in, deflate_in, deflate_level_in; int fletcher32_in, no_fill; unsigned short ushort_data = 42, ushort_data_in, fill_value_in; /* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR; if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids, &varid)) ERR; /* Check stuff. */ if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in, &deflate_level_in)) ERR; if (shuffle_in || deflate_in) ERR; if (nc_inq_var_fletcher32(ncid, 0, &fletcher32_in)) ERR; if (fletcher32_in) ERR; if (nc_inq_var_fill(ncid, 0, &no_fill, &fill_value_in)) ERR; if (no_fill || fill_value_in != NC_FILL_USHORT) ERR; /* Write the second of two values. */ index[0] = 1; if (nc_put_var1_ushort(ncid, 0, index, &ushort_data)) ERR; /* Get the first value, and make sure we get the default fill * value for USHORT. */ index[0] = 0; if (nc_get_var1_ushort(ncid, 0, index, &ushort_data_in)) ERR; if (ushort_data_in != NC_FILL_USHORT) ERR; if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check stuff. */ if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, dimids_in, &natts)) ERR; if (strcmp(name_in, VAR7_NAME) || xtype_in != NC_USHORT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_deflate(ncid, 0, &shuffle_in, &deflate_in, &deflate_level_in)) ERR; if (shuffle_in || deflate_in) ERR; if (nc_inq_var_fletcher32(ncid, 0, &fletcher32_in)) ERR; if (fletcher32_in) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** testing more fill values..."); { int dimids[NDIMS]; size_t index[NDIMS]; int varid; int no_fill; unsigned short ushort_data = 42, ushort_data_in, fill_value_in; /* Create a netcdf-4 file with one dim and 1 NC_USHORT var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM7_NAME, DIM7_LEN, &dimids[0])) ERR; if (nc_def_var(ncid, VAR7_NAME, NC_USHORT, NDIMS, dimids, &varid)) ERR; if (nc_def_var_fill(ncid, varid, 1, NULL)) ERR; /* Check stuff. */ if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR; if (!no_fill) ERR; /* Write the second of two values. */ index[0] = 1; if (nc_put_var1_ushort(ncid, varid, index, &ushort_data)) ERR; /* Get the first value, and make sure we get the default fill * value for USHORT. */ index[0] = 0; if (nc_get_var1_ushort(ncid, varid, index, &ushort_data_in)) ERR; if (nc_close(ncid)) ERR; /* Open the file and check the same stuff. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check stuff. */ if (nc_inq_var_fill(ncid, varid, &no_fill, &fill_value_in)) ERR; if (!no_fill) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("*** testing lots of variables..."); #define DIM_A_NAME "x" #define DIM_A_LEN 10 #define NUM_VARS 2000 #define MAX_VARNAME 10 { /* This simple test failed on HDF5 1.7.58, but passes just fine * on 1.8.0 alpha5... */ int ncid, dimids[1], i; char varname[MAX_VARNAME]; int varids[NUM_VARS]; /* Create a file with three dimensions. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM_A_NAME, DIM_A_LEN, &dimids[0])) ERR; /* Create a large number of variables. */ for (i = 0; i < NUM_VARS; i++) { sprintf(varname, "a_%d", i); if (nc_def_var(ncid, varname, NC_FLOAT, 1, dimids, &varids[i])) ERR; } if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define NC3_CLASSIC_FILE "tst_pres_temp_4D_classic.nc" #define NC3_64BIT_OFFSET_FILE "tst_pres_temp_4D_64bit_offset.nc" #define NC3_NETCDF4_FILE "tst_pres_temp_4D_netcdf4.nc" #define NC3_NETCDF4_CLASSIC_FILE "tst_pres_temp_4D_netcdf4_classic.nc" printf("*** testing 4D example file in classic format..."); if (create_4D_example(NC3_CLASSIC_FILE, NC_CLOBBER)) ERR; if (check_4D_example(NC3_CLASSIC_FILE, NC_FORMAT_CLASSIC)) ERR; SUMMARIZE_ERR; printf("*** testing 4D example file in 64-bit offset format..."); if (create_4D_example(NC3_64BIT_OFFSET_FILE, NC_CLOBBER|NC_64BIT_OFFSET)) ERR; if (check_4D_example(NC3_64BIT_OFFSET_FILE, NC_FORMAT_64BIT)) ERR; SUMMARIZE_ERR; printf("*** testing 4D example file in netCDF-4/HDF5 format..."); if (create_4D_example(NC3_NETCDF4_FILE, NC_CLOBBER|NC_NETCDF4)) ERR; if (check_4D_example(NC3_NETCDF4_FILE, NC_FORMAT_NETCDF4)) ERR; SUMMARIZE_ERR; printf("*** testing 4D example file in netCDF-4/HDF5 format with classic model rules..."); if (create_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_CLOBBER|NC_NETCDF4|NC_CLASSIC_MODEL)) ERR; if (check_4D_example(NC3_NETCDF4_CLASSIC_FILE, NC_FORMAT_NETCDF4_CLASSIC)) ERR; SUMMARIZE_ERR; FINAL_RESULTS; #ifdef USE_PARALLEL MPI_Finalize(); #endif }
int check_4D_example(char *file_name, int expected_format) { int ncid; int format, ndims_in, nvars_in, natts_in; int dimid[NDIMS_EX]; int varid[NVARS_EX]; char dim_name_in[NDIMS_EX][NC_MAX_NAME]; char var_name_in[NVARS_EX][NC_MAX_NAME]; char name_in[NC_MAX_NAME + 1]; char units_in[NC_MAX_NAME + 1]; nc_type xtype_in; size_t len_in; int i; if (nc_open(file_name, 0, &ncid)) ERR; /* Count stuff. */ if (nc_inq_format(ncid, &format)) ERR; if (nc_inq_ndims(ncid, &ndims_in)) ERR; if (ndims_in != NDIMS_EX) ERR; if (nc_inq_nvars(ncid, &nvars_in)) ERR; if (nvars_in != NVARS_EX) ERR; if (nc_inq_natts(ncid, &natts_in)) ERR; if (natts_in != 0) ERR; if (format != expected_format) ERR; /* Check dimensions. */ ndims_in = 0; if (nc_inq_dimids(ncid, &ndims_in, dimid, 0)) ERR; if (ndims_in != NDIMS_EX) ERR; for (i = 0; i < NDIMS_EX; i++) { if (dimid[i] != i) ERR; if (nc_inq_dimname(ncid, i, dim_name_in[i])) ERR; } if (strcmp(dim_name_in[0], LVL_NAME) || strcmp(dim_name_in[1], LAT_NAME) || strcmp(dim_name_in[2], LON_NAME) || strcmp(dim_name_in[3], REC_NAME)) ERR; /* Check variables. */ nvars_in = 0; if (nc_inq_varids(ncid, &nvars_in, varid)) ERR; if (nvars_in != NVARS_EX) ERR; for (i = 0; i < NVARS_EX; i++) { if (varid[i] != i) ERR; if (nc_inq_varname(ncid, i, var_name_in[i])) ERR; } if (strcmp(var_name_in[0], LAT_NAME) || strcmp(var_name_in[1], LON_NAME) || strcmp(var_name_in[2], PRES_NAME) || strcmp(var_name_in[3], TEMP_NAME)) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR; if (strcmp(name_in, LAT_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimid[0] != 1 || natts_in != 1) ERR; if (nc_inq_var(ncid, 1, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR; if (strcmp(name_in, LON_NAME) || xtype_in != NC_FLOAT || ndims_in != 1 || dimid[0] != 2 || natts_in != 1) ERR; if (nc_inq_var(ncid, 2, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR; if (strcmp(name_in, PRES_NAME) || xtype_in != NC_FLOAT || ndims_in != 4 || dimid[0] != 3 || dimid[1] != 0 || dimid[2] != 1 || dimid[3] != 2 || natts_in != 1) ERR; if (nc_inq_var(ncid, 3, name_in, &xtype_in, &ndims_in, dimid, &natts_in)) ERR; if (strcmp(name_in, TEMP_NAME) || xtype_in != NC_FLOAT || ndims_in != 4 || dimid[0] != 3 || dimid[1] != 0 || dimid[2] != 1 || dimid[3] != 2 || natts_in != 1) ERR; /* Check variable atts. */ if (nc_inq_att(ncid, 0, UNITS, &xtype_in, &len_in)) ERR; if (xtype_in != NC_CHAR || len_in != strlen(DEGREES_NORTH)) ERR; if (nc_get_att_text(ncid, 0, UNITS, units_in)) ERR; if (strncmp(units_in, DEGREES_NORTH, strlen(DEGREES_NORTH))) ERR; if (nc_inq_att(ncid, 1, UNITS, &xtype_in, &len_in)) ERR; if (xtype_in != NC_CHAR || len_in != strlen(DEGREES_EAST)) ERR; if (nc_get_att_text(ncid, 1, UNITS, units_in)) ERR; if (strncmp(units_in, DEGREES_EAST, strlen(DEGREES_EAST))) ERR; if (nc_inq_att(ncid, 2, UNITS, &xtype_in, &len_in)) ERR; if (xtype_in != NC_CHAR || len_in != strlen(PRES_UNITS)) ERR; if (nc_get_att_text(ncid, 2, UNITS, units_in)) ERR; if (strncmp(units_in, PRES_UNITS, strlen(PRES_UNITS))) ERR; if (nc_inq_att(ncid, 3, UNITS, &xtype_in, &len_in)) ERR; if (xtype_in != NC_CHAR || len_in != strlen(TEMP_UNITS)) ERR; if (nc_get_att_text(ncid, 3, UNITS, units_in)) ERR; if (strncmp(units_in, TEMP_UNITS, strlen(TEMP_UNITS))) ERR; if (nc_close(ncid)) ERR; return err; }
int main(int argc, char **argv) { int ncid, dimids[NUM_DIMS]; int varid; int nvars_in, varids_in[NUM_DIMS]; signed char fill_value = 42, fill_value_in; nc_type xtype_in; size_t len_in; char name_in[NC_MAX_NAME + 1]; int attnum_in; int cnum; #ifdef USE_PARALLEL MPI_Init(&argc, &argv); #endif printf("\n*** Testing netcdf-4 variable functions, even more.\n"); for (cnum = 0; cnum < MAX_CNUM; cnum++) { int cmode; switch(cnum) { case 0: printf("*** Testing with classic format:\n"); cmode = 0; break; case 1: printf("*** Testing with 64-bit offset format:\n"); cmode = NC_64BIT_OFFSET; break; case 2: printf("*** Testing with HDF5:\n"); cmode = NC_NETCDF4|NC_CLOBBER; break; case 3: printf("*** Testing with HDF5, netCDF Classic Model:\n"); cmode = NC_CLASSIC_MODEL | NC_NETCDF4; } printf("**** testing simple fill value attribute creation..."); { /* Create a netcdf-4 file with one scalar var. Add fill * value. */ if (nc_create(FILE_NAME, cmode, &ncid)) ERR; if (nc_def_var(ncid, VAR_NAME, NC_BYTE, 0, NULL, &varid)) ERR; if (nc_enddef(ncid)) ERR; if (nc_redef(ncid)) ERR; if (nc_put_att_schar(ncid, varid, _FillValue, NC_BYTE, 1, &fill_value)) ERR; if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in != 1 || varids_in[0] != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, VAR_NAME)) ERR; if (nc_inq_att(ncid, varid, _FillValue, &xtype_in, &len_in)) ERR; if (xtype_in != NC_BYTE || len_in != 1) ERR; if (nc_get_att(ncid, varid, _FillValue, &fill_value_in)) ERR; if (fill_value_in != fill_value) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing simple fill value with data read..."); { size_t start[NUM_DIMS], count[NUM_DIMS]; signed char data = 99, data_in; /* Create a netcdf-4 file with one unlimited dim and one * var. Add fill value. */ if (nc_create(FILE_NAME, cmode, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_var(ncid, VAR_NAME, NC_BYTE, NUM_DIMS, dimids, &varid)) ERR; if (nc_enddef(ncid)) ERR; if (nc_redef(ncid)) ERR; if (nc_put_att_schar(ncid, varid, _FillValue, NC_BYTE, 1, &fill_value)) ERR; if (nc_enddef(ncid)) ERR; /* Write the second record. */ start[0] = 1; count[0] = 1; if (nc_put_vara_schar(ncid, varid, start, count, &data)) ERR; /* Read the first record, it should be the fill value. */ start[0] = 0; if (nc_get_vara_schar(ncid, varid, start, count, &data_in)) ERR; if (data_in != fill_value) ERR; /* Read the second record, it should be the value we just wrote * there. */ start[0] = 1; if (nc_get_vara_schar(ncid, varid, start, count, &data_in)) ERR; if (data_in != data) ERR; /* Close up. */ if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check metadata. */ if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in != 1 || varids_in[0] != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, VAR_NAME)) ERR; /* Check fill value att. */ if (nc_inq_att(ncid, varid, _FillValue, &xtype_in, &len_in)) ERR; if (xtype_in != NC_BYTE || len_in != 1) ERR; if (nc_get_att(ncid, varid, _FillValue, &fill_value_in)) ERR; if (fill_value_in != fill_value) ERR; /* Read the first record, it should be the fill value. */ start[0] = 0; if (nc_get_vara_schar(ncid, varid, start, count, &data_in)) ERR; if (data_in != fill_value) ERR; /* Read the second record, it should be the value we just wrote * there. */ start[0] = 1; if (nc_get_vara_schar(ncid, varid, start, count, &data_in)) ERR; if (data_in != data) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing fill value with one other attribute..."); { int losses_value = 192, losses_value_in; /* Create a netcdf-4 file with one dim and one var. Add another * attribute, then fill value. */ if (nc_create(FILE_NAME, cmode, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_var(ncid, VAR_NAME, NC_BYTE, NUM_DIMS, dimids, &varid)) ERR; if (nc_put_att_int(ncid, varid, LOSSES_NAME, NC_INT, 1, &losses_value)) ERR; if (nc_put_att_schar(ncid, varid, _FillValue, NC_BYTE, 1, &fill_value)) ERR; if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; if (nc_inq_att(ncid, 0, LOSSES_NAME, &xtype_in, &len_in)) ERR; if (xtype_in != NC_INT || len_in != 1) ERR; if (nc_get_att(ncid, 0, LOSSES_NAME, &losses_value_in)) ERR; if (losses_value_in != losses_value) ERR; if (nc_inq_att(ncid, 0, _FillValue, &xtype_in, &len_in)) ERR; if (xtype_in != NC_BYTE || len_in != 1) ERR; if (nc_get_att(ncid, 0, _FillValue, &fill_value_in)) ERR; if (fill_value_in != fill_value) ERR; if (nc_inq_attid(ncid, 0, LOSSES_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR; if (attnum_in != 1) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing fill value with three other attributes..."); { #define NUM_LEADERS 3 char leader[NUM_LEADERS][NC_MAX_NAME + 1] = {"hair_length_of_strategoi", "hair_length_of_Miltiades", "hair_length_of_Darius_I"}; short hair_length[NUM_LEADERS] = {3, 11, 4}; short short_in; int a; /* Create a netcdf file with one dim and one var. Add 3 * attributes, then fill value. */ if (nc_create(FILE_NAME, cmode, &ncid)) ERR; if (nc_def_dim(ncid, DIM1_NAME, DIM1_LEN, &dimids[0])) ERR; if (nc_def_var(ncid, VAR_NAME, NC_BYTE, NUM_DIMS, dimids, &varid)) ERR; for (a = 0; a < NUM_LEADERS; a++) if (nc_put_att_short(ncid, varid, leader[a], NC_SHORT, 1, &hair_length[a])) ERR; if (nc_put_att_schar(ncid, varid, _FillValue, NC_BYTE, 1, &fill_value)) ERR; if (nc_close(ncid)) ERR; /* Open the file. */ if (nc_open(FILE_NAME, NC_NOWRITE, &ncid)) ERR; /* Check our three hair-related attributes. */ for (a = 0; a < NUM_LEADERS; a++) { if (nc_inq_att(ncid, 0, leader[a], &xtype_in, &len_in)) ERR; if (xtype_in != NC_SHORT || len_in != 1) ERR; if (nc_get_att(ncid, 0, leader[a], &short_in)) ERR; if (short_in != hair_length[a]) ERR; if (nc_inq_attid(ncid, 0, leader[a], &attnum_in)) ERR; if (attnum_in != a) ERR; } /* Check our fill value attribute. */ if (nc_inq_att(ncid, 0, _FillValue, &xtype_in, &len_in)) ERR; if (xtype_in != NC_BYTE || len_in != 1) ERR; if (nc_get_att(ncid, 0, _FillValue, &fill_value_in)) ERR; if (fill_value_in != fill_value) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing fill value with simple example..."); { /* Dims stuff. */ #define NDIMS 3 #define VAR_DIMS 3 #define DIM_A "dim1" #define DIM_A_LEN 4 #define DIM_B "dim2" #define DIM_B_LEN 3 #define DIM_C "dim3" #define DIM_C_LEN NC_UNLIMITED /* Var stuff. */ #define CXX_VAR_NAME "P" /* Att stuff. */ #define NUM_ATTS 4 #define LONG_NAME "long_name" #define PRES_MAX_WIND "pressure at maximum wind" #define UNITS "units" #define HECTOPASCALS "hectopascals" int dimid[NDIMS], var_dimids[VAR_DIMS] = {2, 1, 0}; float fill_value = -9999.0f; char long_name[] = PRES_MAX_WIND; if (nc_create(FILE_NAME, cmode, &ncid)) ERR; /* Create dims. */ if (nc_def_dim(ncid, DIM_A, DIM_A_LEN, &dimid[0])) ERR; if (nc_def_dim (ncid, DIM_B, DIM_B_LEN, &dimid[1])) ERR; if (nc_def_dim(ncid, DIM_C, DIM_C_LEN, &dimid[2])) ERR; /* Create var. */ if (nc_def_var(ncid, CXX_VAR_NAME, NC_FLOAT, VAR_DIMS, var_dimids, &varid)) ERR; if (varid) ERR; if (nc_put_att(ncid, varid, LONG_NAME, NC_CHAR, strlen(long_name) + 1, long_name)) ERR; if (nc_put_att(ncid, varid, UNITS, NC_CHAR, strlen(UNITS) + 1, UNITS)) ERR; /* Check to ensure the atts have their expected attnums. */ if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; /* Now add a fill value. This will acutually cause HDF5 to * destroy the dataset and recreate it, recreating also the * three attributes that are attached to it. */ if (nc_put_att(ncid, varid, _FillValue, NC_FLOAT, 1, &fill_value)) ERR; /* Check to ensure the atts have their expected attnums. */ if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR; if (attnum_in != 2) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #ifndef NO_NETCDF_2 /* The following test is an attempt to recreate a problem occuring in the cxx tests. The file is created in c++ in nctsts.cpp. */ printf("**** testing fill value with example from cxx tests in v2 api..."); { /* Dims stuff. */ #define NDIMS_1 4 #define VAR_DIMS 3 #define LAT "lat" #define LAT_LEN 4 #define LON "lon" #define LON_LEN 3 #define FRTIMED "frtimed" #define FRTIMED_LEN NC_UNLIMITED #define TIMELEN "timelen" #define TIMELEN_LEN 20 /* Var stuff. */ #define CXX_VAR_NAME "P" /* Att stuff. */ #define NUM_ATTS 4 #define LONG_NAME "long_name" #define UNITS "units" int dimid[NDIMS_1], var_dimids[VAR_DIMS] = {2, 0, 1}; float fill_value = -9999.0f; char long_name[] = PRES_MAX_WIND; int i, attid[NUM_ATTS]; ncid = nccreate(FILE_NAME, NC_NETCDF4); /* Create dims. */ dimid[0] = ncdimdef(ncid, LAT, LAT_LEN); dimid[1] = ncdimdef(ncid, LON, LON_LEN); dimid[2] = ncdimdef(ncid, FRTIMED, FRTIMED_LEN); dimid[3] = ncdimdef(ncid, TIMELEN, TIMELEN_LEN); /* Just check our dimids to see that they are correct. */ for (i = 0; i < NDIMS_1; i++) if (dimid[i] != i) ERR; /* Create var. */ varid = ncvardef(ncid, CXX_VAR_NAME, NC_FLOAT, VAR_DIMS, var_dimids); if (varid) ERR; /* Add three atts to the var, long_name, units, and * valid_range. */ if (nc_put_att(ncid, varid, LONG_NAME, NC_CHAR, strlen(long_name) + 1, long_name)) ERR; if (nc_put_att(ncid, varid, UNITS, NC_CHAR, strlen(UNITS) + 1, UNITS)) ERR; /* Check to ensure the atts have their expected attnums. */ if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; /* Now add a fill value. This will acutually cause HDF5 to * destroy the dataset and recreate it, recreating also the * three attributes that are attached to it. */ attid[3] = ncattput(ncid, varid, _FillValue, NC_FLOAT, 1, &fill_value); /* Check to ensure the atts have their expected attnums. */ if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; ncclose(ncid); /* Open the file and check. */ ncid = ncopen(FILE_NAME, 0); if (nc_inq_attid(ncid, 0, LONG_NAME, &attnum_in)) ERR; if (attnum_in != 0) ERR; if (nc_inq_attid(ncid, 0, UNITS, &attnum_in)) ERR; if (attnum_in != 1) ERR; if (nc_inq_attid(ncid, 0, _FillValue, &attnum_in)) ERR; if (attnum_in != 2) ERR; ncclose(ncid); } SUMMARIZE_ERR; #endif /* NO_NETCDF_2 */ } printf("**** testing create order varids..."); #define UNITS "units" #define DIMNAME "x" #define VARNAME "data" { /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */ int ncid, dimid, varid, xvarid; char units[] = "zlotys"; if (nc_create(FILE_NAME, NC_NETCDF4|NC_CLASSIC_MODEL, &ncid)) ERR; if (nc_def_dim(ncid, DIMNAME, 1, &dimid)) ERR; if (nc_enddef(ncid)) ERR; if (nc_redef(ncid)) ERR; if (nc_def_var(ncid, DIMNAME, NC_INT, 1, &dimid, &xvarid)) ERR; if (nc_put_att_text(ncid, xvarid, UNITS, strlen(units), units)) ERR; if (nc_def_var(ncid, VARNAME, NC_INT, 1, &dimid, &varid)) ERR; if (nc_close(ncid)) ERR; if (nc_open(FILE_NAME, 0, &ncid)) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; #define RANK_wind 1 printf("**** testing simple variable renaming..."); { /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */ int ncid, lat_dim, time_dim, lon_dim, wind_id; size_t lat_len = 73, time_len = 10, lon_len = 145; int cdf_goober[1]; /* if (nc_set_default_format(NC_FORMAT_NETCDF4, NULL)) ERR;*/ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; /* define dimensions */ if (nc_def_dim(ncid, "a", lon_len, &lon_dim)) ERR; if (nc_def_dim(ncid, "b", lat_len, &lat_dim)) ERR; if (nc_def_dim(ncid, "c", time_len, &time_dim)) ERR; if (nc_put_att_text(ncid, NC_GLOBAL, "a", 3, "bar")) ERR; cdf_goober[0] = 2; if (nc_put_att_int(ncid, NC_GLOBAL, "b", NC_INT, 1, cdf_goober)) ERR; /* define variables */ if (nc_def_var(ncid, "aa", NC_FLOAT, RANK_wind, &lon_dim, &wind_id)) ERR; if (nc_close(ncid)) ERR; if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_rename_var(ncid, 0, "az")) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing dimension and variable renaming..."); { /* This test contributed by Jeff Whitaker of NOAA - Thanks Jeff! */ int ncid, lat_dim, time_dim, lon_dim, wind_id; size_t lat_len = 73, time_len = 10, lon_len = 145; int wind_dims[RANK_wind], wind_slobber[1], cdf_goober[1]; if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; /* define dimensions */ if (nc_def_dim(ncid, "lon", lon_len, &lon_dim)) ERR; if (nc_def_dim(ncid, "lat", lat_len, &lat_dim)) ERR; if (nc_def_dim(ncid, "time", time_len, &time_dim)) ERR; if (nc_put_att_text(ncid, NC_GLOBAL, "foo", 3, "bar")) ERR; cdf_goober[0] = 2; if (nc_put_att_int(ncid, NC_GLOBAL, "goober", NC_INT, 1, cdf_goober)) ERR; /* define variables */ wind_dims[0] = lon_dim; if (nc_def_var(ncid, "temp", NC_FLOAT, RANK_wind, wind_dims, &wind_id)) ERR; if (nc_put_att_text(ncid, wind_id, "bar", 3, "foo")) ERR; wind_slobber[0] = 3; if (nc_put_att_int(ncid, wind_id, "slobber", NC_INT, 1, wind_slobber)) ERR; if (nc_close(ncid)) ERR; /* re-open dataset*/ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_dimid(ncid, "lon", &lon_dim)) ERR; /* rename dimension */ if (nc_rename_dim(ncid, lon_dim, "longitude")) ERR; if (nc_inq_varid(ncid, "temp", &wind_id)) ERR; /* rename variable */ if (nc_rename_var(ncid, wind_id, "wind")) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; /* printf("*** testing 2D array of NC_CHAR..."); */ /* { */ /* int dimid[NDIMS_1], var_dimids[VAR_DIMS] = {2, 0, 1}; */ /* float fill_value = -9999.0f; */ /* char long_name[] = PRES_MAX_WIND; */ /* int i, attid[NUM_ATTS]; */ /* ncid = nccreate(FILE_NAME, NC_NETCDF4); */ /* /\* Create dims. *\/ */ /* dimid[0] = ncdimdef(ncid, LAT, LAT_LEN); */ /* dimid[1] = ncdimdef(ncid, LON, LON_LEN); */ /* /\* Create var. *\/ */ /* varid = ncvardef(ncid, CXX_VAR_NAME, NC_FLOAT, VAR_DIMS, var_dimids); */ /* if (varid) ERR; */ /* ncclose(ncid); */ /* /\* Open the file and check. *\/ */ /* ncid = ncopen(FILE_NAME, 0); */ /* ncclose(ncid); */ /* } */ /* SUMMARIZE_ERR; */ #define NDIMS 3 #define NNAMES 4 #define NLINES 13 /* printf("**** testing funny names for netCDF-4..."); */ /* { */ /* int ncid, wind_id; */ /* size_t len[NDIMS] = {7, 3, 1}; */ /* int dimids[NDIMS], dimids_in[NDIMS], ndims_in; */ /* char funny_name[NNAMES][NC_MAX_NAME] = {"\a\t", "\f\n", "\r\v", "\b"}; */ /* char name_in[NC_MAX_NAME + 1]; */ /* char *speech[NLINES] = {"who would fardels bear, ", */ /* "To grunt and sweat under a weary life, ", */ /* "But that the dread of something after death, ", */ /* "The undiscover'd country from whose bourn ", */ /* "No traveller returns, puzzles the will ", */ /* "And makes us rather bear those ills we have ", */ /* "Than fly to others that we know not of? ", */ /* "Thus conscience does make cowards of us all; ", */ /* "And thus the native hue of resolution ", */ /* "Is sicklied o'er with the pale cast of thought, ", */ /* "And enterprises of great pith and moment ", */ /* "With this regard their currents turn awry, ", */ /* "And lose the name of action."}; */ /* char *speech_in[NLINES]; */ /* int i; */ /* unsigned short nlines = NLINES; */ /* unsigned int nlines_in; */ /* if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; */ /* /\* Define dimensions. *\/ */ /* for (i = 0; i < NDIMS; i++) */ /* if (nc_def_dim(ncid, funny_name[i], len[i], &dimids[i])) ERR; */ /* /\* Write some global atts. *\/ */ /* if (nc_put_att_string(ncid, NC_GLOBAL, funny_name[0], NLINES, */ /* (const char **)speech)) ERR; */ /* if (nc_put_att_ushort(ncid, NC_GLOBAL, funny_name[1], NC_UINT, 1, &nlines)) ERR; */ /* /\* Define variables. *\/ */ /* if (nc_def_var(ncid, funny_name[3], NC_INT64, NDIMS, dimids, &wind_id)) ERR; */ /* if (nc_close(ncid)) ERR; */ /* /\* Open the file and check. *\/ */ /* if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; */ /* if (nc_inq_dimids(ncid, &ndims_in, dimids_in, 0)) ERR; */ /* if (ndims_in != NDIMS) ERR; */ /* for (i = 0; i < NDIMS; i++) */ /* { */ /* if (dimids_in[i] != i) ERR; */ /* if (nc_inq_dimname(ncid, i, name_in)) ERR; */ /* if (strcmp(name_in, funny_name[i])) ERR; */ /* } */ /* if (nc_get_att_string(ncid, NC_GLOBAL, funny_name[0], (char **)speech_in)) ERR; */ /* for (i = 0; i < NLINES; i++) */ /* if (strcmp(speech_in[i], speech[i])) ERR; */ /* if (nc_get_att_uint(ncid, NC_GLOBAL, funny_name[1], &nlines_in)) ERR; */ /* if (nlines_in != NLINES) ERR; */ /* if (nc_free_string(NLINES, (char **)speech_in)) ERR; */ /* if (nc_inq_varname(ncid, 0, name_in)) ERR; */ /* if (strcmp(name_in, funny_name[3])) ERR; */ /* if (nc_close(ncid)) ERR; */ /* } */ /* SUMMARIZE_ERR; */ printf("**** testing endianness..."); #define NDIMS4 1 #define DIM4_NAME "Joe" #define VAR_NAME4 "Ed" #define DIM4_LEN 10 { int dimids[NDIMS4], dimids_in[NDIMS4]; int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int data[DIM4_LEN], data_in[DIM4_LEN]; int endian_in; int i; for (i = 0; i < DIM4_LEN; i++) data[i] = i; /* 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_INT, NDIMS4, dimids, &varid)) ERR; if (nc_def_var_endian(ncid, varid, NC_ENDIAN_BIG)) ERR; if (varid != 0) ERR; if (nc_put_var_int(ncid, varid, data)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS4 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) 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_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_endian(ncid, 0, &endian_in)) ERR; if (endian_in != NC_ENDIAN_BIG) 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 != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) 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_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_endian(ncid, 0, &endian_in)) ERR; if (endian_in != NC_ENDIAN_BIG) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM4_LEN; i++) if (data[i] != data_in[i]) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing chunking..."); { #define NDIMS5 1 #define DIM5_NAME "D5" #define VAR_NAME5 "V5" #define DIM5_LEN 1000 int dimids[NDIMS5], dimids_in[NDIMS5]; int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int data[DIM5_LEN], data_in[DIM5_LEN]; int chunksize[NDIMS5] = {5}; int chunksize_in[NDIMS5]; int contiguous_in; int i, d; for (i = 0; i < DIM5_LEN; i++) data[i] = i; /* 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, DIM5_NAME, DIM5_LEN, &dimids[0])) ERR; if (dimids[0] != 0) ERR; if (nc_def_var(ncid, VAR_NAME5, NC_INT, NDIMS5, dimids, &varid)) ERR; if (nc_def_var_chunking(ncid, varid, 0, chunksize)) ERR; if (nc_put_var_int(ncid, varid, data)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS5 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) 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_NAME5) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS5; d++) if (chunksize[d] != chunksize_in[d]) ERR; if (contiguous_in != 0) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM5_LEN; i++) if (data[i] != data_in[i]) ERR_RET; 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(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS5 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) 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_NAME5) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS5; d++) if (chunksize[d] != chunksize_in[d]) ERR; if (contiguous_in != 0) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM5_LEN; i++) if (data[i] != data_in[i]) ERR_RET; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing contiguous storage..."); { #define NDIMS6 1 #define DIM6_NAME "D5" #define VAR_NAME6 "V5" #define DIM6_LEN 100 int dimids[NDIMS6], dimids_in[NDIMS6]; int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int data[DIM6_LEN], data_in[DIM6_LEN]; int chunksize_in[NDIMS6]; int contiguous_in; int i, d; for (i = 0; i < DIM6_LEN; i++) data[i] = i; /* 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, DIM6_NAME, DIM6_LEN, &dimids[0])) ERR; if (dimids[0] != 0) ERR; if (nc_def_var(ncid, VAR_NAME6, NC_INT, NDIMS6, dimids, &varid)) ERR; if (nc_def_var_chunking(ncid, varid, 1, NULL)) ERR; if (nc_put_var_int(ncid, varid, data)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS6 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) 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_NAME6) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS6; d++) if (chunksize_in[d] != 0) ERR; if (!contiguous_in) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM6_LEN; i++) if (data_in[i] != data[i]) ERR_RET; 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(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS6 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) 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_NAME6) || xtype_in != NC_INT || ndims != 1 || natts != 0 || dimids_in[0] != 0) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS6; d++) if (chunksize_in[d] != 0) ERR; if (!contiguous_in) ERR; if (nc_get_var_int(ncid, varid, data_in)) ERR; for (i = 0; i < DIM6_LEN; i++) if (data[i] != data_in[i]) ERR_RET; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing extreme numbers dude..."); { #define VAR_NAME7 "V5" #define DIM6_LEN 100 int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; /* unsigned long long data = 9223372036854775807ull, data_in;*/ unsigned long long data = 9223372036854775817ull, data_in; /* Create a netcdf-4 file with scalar var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_var(ncid, VAR_NAME7, NC_UINT64, 0, NULL, &varid)) ERR; if (nc_put_var_ulonglong(ncid, varid, &data)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1 || varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, NULL, &natts)) ERR; if (strcmp(name_in, VAR_NAME7) || xtype_in != NC_UINT64 || ndims != 0 || natts != 0) ERR; if (nc_get_var_ulonglong(ncid, varid, &data_in)) ERR; if (data_in != data) 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 != 0 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1 || varids_in[0] != 0) ERR; if (nc_inq_var(ncid, 0, name_in, &xtype_in, &ndims, NULL, &natts)) ERR; if (strcmp(name_in, VAR_NAME7) || xtype_in != NC_UINT64 || ndims != 0 || natts != 0) ERR; if (nc_get_var_ulonglong(ncid, varid, &data_in)) ERR; if (data_in != data) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing error codes for name clashes..."); { #define GENERIC_NAME "bob" int ncid, varid, numgrps, ntypes; /* Create a netcdf-4 file with one var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_var(ncid, GENERIC_NAME, NC_BYTE, 0, NULL, &varid)) ERR; /* These don'e work, becuase the name is already in use. Make * sure the correct error is returned. */ if (nc_def_grp(ncid, GENERIC_NAME, NULL) != NC_ENAMEINUSE) ERR; if (nc_def_opaque(ncid, 1, GENERIC_NAME, NULL) != NC_ENAMEINUSE) ERR; /* Close it. */ if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in != 1 || varids_in[0] != 0) ERR; if (nc_inq_varname(ncid, 0, name_in)) ERR; if (strcmp(name_in, GENERIC_NAME)) ERR; if (nc_inq_grps(ncid, &numgrps, NULL)) ERR; if (numgrps) ERR; if (nc_inq_typeids(ncid, &ntypes, NULL)) ERR; if (ntypes) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing error codes for name clashes some more..."); { #define GENERIC_NAME "bob" int ncid, varid, numgrps, ntypes; /* Create a netcdf-4 file with one type. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_opaque(ncid, 1, GENERIC_NAME, NULL)) ERR; /* These don'e work, becuase the name is already in use. Make * sure the correct error is returned. */ if (nc_def_grp(ncid, GENERIC_NAME, NULL) != NC_ENAMEINUSE) ERR; if (nc_def_var(ncid, GENERIC_NAME, NC_BYTE, 0, NULL, &varid) != NC_ENAMEINUSE) ERR; /* Close it. */ if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in) ERR; if (nc_inq_grps(ncid, &numgrps, NULL)) ERR; if (numgrps) ERR; if (nc_inq_typeids(ncid, &ntypes, NULL)) ERR; if (ntypes != 1) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing error codes for name clashes even more..."); { #define GENERIC_NAME "bob" int ncid, varid, numgrps, ntypes; /* Create a netcdf-4 file with one group. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_grp(ncid, GENERIC_NAME, NULL)) ERR; /* These don'e work, becuase the name is already in use. Make * sure the correct error is returned. */ if (nc_def_opaque(ncid, 1, GENERIC_NAME, NULL) != NC_ENAMEINUSE) ERR; if (nc_def_var(ncid, GENERIC_NAME, NC_BYTE, 0, NULL, &varid) != NC_ENAMEINUSE) ERR; /* Close it. */ if (nc_close(ncid)) ERR; /* Open the file and check. */ if (nc_open(FILE_NAME, NC_WRITE, &ncid)) ERR; if (nc_inq_varids(ncid, &nvars_in, varids_in)) ERR; if (nvars_in) ERR; if (nc_inq_grps(ncid, &numgrps, NULL)) ERR; if (numgrps != 1) ERR; if (nc_inq_typeids(ncid, &ntypes, NULL)) ERR; if (ntypes) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; printf("**** testing error code for too-large chunks..."); { #define NDIMS17 2 #define DIM17_NAME "personality" #define DIM17_NAME_2 "good_looks" #define VAR_NAME17 "ed" #define DIM17_LEN 2147483644 /* max dimension size - 2GB - 4. */ #define DIM17_2_LEN 1000 int dimids[NDIMS17], dimids_in[NDIMS17]; int varid; int ndims, nvars, natts, unlimdimid; nc_type xtype_in; char name_in[NC_MAX_NAME + 1]; int chunksize[NDIMS17] = {5, 5}; int bad_chunksize[NDIMS17] = {5, DIM17_LEN}; int chunksize_in[NDIMS17]; int contiguous_in; int d; /* Create a netcdf-4 file with two dims and one var. */ if (nc_create(FILE_NAME, NC_NETCDF4, &ncid)) ERR; if (nc_def_dim(ncid, DIM17_NAME, DIM17_LEN, &dimids[0])) ERR; if (nc_def_dim(ncid, DIM17_NAME_2, DIM17_2_LEN, &dimids[1])) ERR; if (dimids[0] != 0 || dimids[1] != 1) ERR; if (nc_def_var(ncid, VAR_NAME17, NC_UINT64, NDIMS17, dimids, &varid)) ERR; if (nc_def_var_chunking(ncid, varid, 0, bad_chunksize) != NC_EBADCHUNK) ERR; if (nc_def_var_chunking(ncid, varid, 0, chunksize)) ERR; /* Check stuff. */ if (nc_inq(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS17 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) 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_NAME17) || xtype_in != NC_UINT64 || ndims != 2 || natts != 0 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS17; d++) if (chunksize[d] != chunksize_in[d]) ERR; if (contiguous_in != 0) 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(ncid, &ndims, &nvars, &natts, &unlimdimid)) ERR; if (ndims != NDIMS17 || nvars != 1 || natts != 0 || unlimdimid != -1) ERR; if (nc_inq_varids(ncid, &nvars, varids_in)) ERR; if (nvars != 1) 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_NAME17) || xtype_in != NC_UINT64 || ndims != 2 || natts != 0 || dimids_in[0] != 0 || dimids_in[1] != 1) ERR; if (nc_inq_var_chunking(ncid, 0, &contiguous_in, chunksize_in)) ERR; for (d = 0; d < NDIMS17; d++) if (chunksize[d] != chunksize_in[d]) ERR; if (contiguous_in != 0) ERR; if (nc_close(ncid)) ERR; } SUMMARIZE_ERR; FINAL_RESULTS; #ifdef USE_PARALLEL MPI_Finalize(); #endif }