/*
* Open an existing netCDF file for access.
*/
static int
c_ncopn(
const char *pathname, /* file name for netCDF to be opened */
int rwmode, /* either NCWRITE or NCNOWRIT */
int *rcode /* returned error code */
)
{
int ncid = -1;
#if CDF_ROUTINE_NAME
cdf_routine_name = "NCOPN";
#endif
if (rwmode != NC_NOWRITE && rwmode != NC_WRITE)
{
*rcode = NC_EINVAL;
nc_advise("NCOPN", *rcode,
"bad flag, did you forget to include netcdf.inc?");
}
else
{
if (pathname == NULL) {
*rcode = NC_EINVAL;
}
else
{
*rcode = ((ncid = ncopen (pathname, rwmode)) == -1)
? ncerr
: 0;
}
if (*rcode != 0)
{
nc_advise("NCOPN", *rcode, "");
*rcode = ncerr;
}
}
return ncid;
}
/*
* Open an existing netCDF file for access.
*/
extern int
c_ncopn(
const char *pathname, /* file name for netCDF to be opened */
int rwmode, /* either NCWRITE or NCNOWRIT */
int *rcode /* returned error code */
)
{
int ncid = -1;
/* Include NC_LOCK in check, in case NC_LOCK is ever implemented */
if (rwmode < 0 ||
rwmode > NC_WRITE + NC_SHARE + NC_CLASSIC_MODEL + NC_LOCK)
{
*rcode = NC_EINVAL;
nc_advise("NCOPN", *rcode,
"bad flag, did you forget to include netcdf.inc?");
}
else
{
if (pathname == NULL) {
*rcode = NC_EINVAL;
}
else
{
*rcode = ((ncid = ncopen (pathname, rwmode)) == -1)
? ncerr
: 0;
}
if (*rcode != 0)
{
nc_advise("NCOPN", *rcode, "");
*rcode = ncerr;
}
}
return ncid;
}
int
main(int argc, char **argv)
{
/*nc_set_log_level(3);*/
printf("\n*** Testing netcdf-4 v2 API functions.\n");
printf("*** testing simple opens and creates...");
{
int ncid, varid, varid_in, dimids[2];
/* Turn off the crashing whenever there is a problem. */
ncopts = NC_VERBOSE;
/* Create an empty file. */
if ((ncid = nccreate(FILE_NAME, NC_CLOBBER)) == -1) ERR;
if (ncclose(ncid) == -1) ERR;
/* Open the file, go into redef, and add some dims and vars. */
if ((ncid = ncopen(FILE_NAME, NC_WRITE)) == -1) ERR;
if (ncredef(ncid) == -1) ERR;
if ((dimids[0] = ncdimdef(ncid, DIM1_NAME, DIM1_SIZE)) == -1) ERR;
if ((dimids[1] = ncdimdef(ncid, DIM2_NAME, DIM2_SIZE)) == -1) ERR;
if ((varid = ncvardef(ncid, VAR1_NAME, NC_DOUBLE, NDIMS, dimids)) == -1) ERR;
if ((varid_in = ncvarid(ncid, VAR1_NAME)) == -1) ERR;
if (varid_in != varid) ERR;
if ((varid = ncvardef(ncid, VAR2_NAME, NC_INT, NDIMS, dimids)) == -1) ERR;
if ((varid_in = ncvarid(ncid, VAR2_NAME)) == -1) ERR;
if (varid_in != varid) ERR;
if ((varid = ncvardef(ncid, VAR3_NAME, NC_SHORT, NDIMS, dimids)) == -1) ERR;
if ((varid_in = ncvarid(ncid, VAR3_NAME)) == -1) ERR;
if (varid_in != varid) ERR;
if (ncclose(ncid) == -1) ERR;
}
SUMMARIZE_ERR;
FINAL_RESULTS;
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : OpenFiles
@INPUT : parent_file -> The name of the minc file to create the child
from, or NULL if there is no parent file.
child_file -> The name of the child file to be created.
tm_stamp -> A string to be prepended to the history attribute.
@OUTPUT : parent_CDF -> The cdfid of the opened parent file, or -1 if
no parent file was given.
child_CDF -> The cdfid of the created child file.
@RETURNS : TRUE if all went well
FALSE if error opening parent file (but only if one was supplied)
FALSE if error creating child file
@DESCRIPTION: Opens the (optional) parent MINC file, and creates the (required)
new MINC file. Also creates the root variable (using
micreate_std_variable) in the child file.
@METHOD :
@GLOBALS : none
@CALLS : NetCDF routines
MINC routines
@CREATED : May 31, 1993 by MW
@MODIFIED : Aug 11, 1993, GPW - added provisions for no parent file.
Oct 27, 1993, GPW - moved from micreate.c to micreateimage.c;
removed copying of attributes and history update; renamed
from CreateChild to OpenFiles.
---------------------------------------------------------------------------- */
Boolean OpenFiles (char parent_file[], char child_file[],
int *parent_CDF, int *child_CDF)
{
struct stat statbuf; /* used to check that created file exists */
/*
* If a filename for the parent MINC file was supplied, open the file;
* else return -1 for *parent_CDF.
*/
if (parent_file != NULL)
{
*parent_CDF = ncopen (parent_file, NC_NOWRITE);
if (*parent_CDF == MI_ERROR)
{
sprintf (ErrMsg, "Error opening input file %s: %s\n",
parent_file, NCErrMsg (ncerr, errno));
return (FALSE);
}
}
else
{
*parent_CDF = -1;
}
/*
* Create the child file, bomb if any error. N.B. we call nccreate()
* with a mode of NC_NOCLOBBER here because if we use NC_CLOBBER and
* the file is uncreatable (eg. permission denied), then the NetCDF
* code incorrectly attempts to delete the file; this results in
* errno being clobbered, so we'd print out an inaccurate error
* message here.
*/
*child_CDF = nccreate (child_file,
gClobberFlag ? NC_CLOBBER : NC_NOCLOBBER);
if (*child_CDF == MI_ERROR)
{
sprintf (ErrMsg, "Error creating file %s: %s\n",
child_file, NCErrMsg (ncerr, errno));
ncclose (*parent_CDF);
return (FALSE);
}
/*
* Now just check to make sure the file exists and has non-zero size
* (because NetCDF fails to report disk full!)
*/
if (stat (child_file, &statbuf) != 0)
{
sprintf (ErrMsg, "File %s was not created: disk may be full\n",
child_file);
ncclose (*parent_CDF);
ncclose (*child_CDF);
return (FALSE);
}
/*
if (statbuf.st_size == 0)
{
sprintf (ErrMsg, "Error creating file %s: disk may be full\n",
child_file);
ncclose (*parent_CDF);
ncclose (*child_CDF);
return (FALSE);
}
*/
#ifdef DEBUG
printf ("OpenFiles:\n");
printf (" Parent file %s, CDF %d\n", parent_file, *parent_CDF);
printf (" Child file %s, CDF %d\n\n", child_file, *child_CDF);
#endif
/* The parent file is now open for reading, and the child file is */
/* created and opened for definition. */
return (TRUE);
} /* OpenFiles () */
int main(int argc, char *argv[])
{
int i, j, d, h;
int appid, wid, cnid, vcid, stid, txid, amid, mpid, tmid, stdmid;
long stid_len;
int vfield, vfield2, sfield, sfield2;
int rlist;
ng_size_t len_dims[2];
long strt[1], cnt[1];
long latlen, lonlen;
long timelen;
int *timestep;
int ncid[6], uid, vid, u5id, v5id, pid, tid;
int latid, lonid;
float *lon, *lat;
float *X, *Y;
char filename[256];
char *rftime;
const char *dir = _NGGetNCARGEnv("data");
char hour[3], day[3], mainstring[17];
extern void get_2d_array(float *, long, long, int, int, long);
char const *wks_type = "x11";
/*
* Initialize the high level utility library
*/
NhlInitialize();
/*
* Create an application object.
*/
rlist = NhlRLCreate(NhlSETRL);
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNappUsrDir,"./");
NhlRLSetString(rlist,NhlNappDefaultParent,"True");
NhlCreate(&appid,"st04",NhlappClass,NhlDEFAULT_APP,rlist);
if (!strcmp(wks_type,"ncgm") || !strcmp(wks_type,"NCGM")) {
/*
* Create a meta file workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkMetaName,"./st04c.ncgm");
NhlRLSetString(rlist,NhlNwkColorMap,"temp1");
NhlCreate(&wid,"st04Work",
NhlncgmWorkstationClass,NhlDEFAULT_APP,rlist);
}
else if (!strcmp(wks_type,"x11") || !strcmp(wks_type,"X11")) {
/*
* Create an X workstation.
*/
NhlRLClear(rlist);
NhlRLSetInteger(rlist,NhlNwkPause,True);
NhlRLSetString(rlist,NhlNwkColorMap,"temp1");
NhlCreate(&wid,"st04Work",NhlcairoWindowWorkstationClass,appid,rlist);
}
else if (!strcmp(wks_type,"oldps") || !strcmp(wks_type,"OLDPS")) {
/*
* Create an older-style PostScript workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkPSFileName,"st04c.ps");
NhlRLSetString(rlist,NhlNwkColorMap,"temp1");
NhlCreate(&wid,"st04Work",NhlpsWorkstationClass,appid,rlist);
}
else if (!strcmp(wks_type,"oldpdf") || !strcmp(wks_type,"OLDPDF")) {
/*
* Create an older-style PDF workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkPDFFileName,"st04c.pdf");
NhlRLSetString(rlist,NhlNwkColorMap,"temp1");
NhlCreate(&wid,"st04Work",NhlpdfWorkstationClass,appid,rlist);
}
else if (!strcmp(wks_type,"pdf") || !strcmp(wks_type,"PDF") ||
!strcmp(wks_type,"ps") || !strcmp(wks_type,"PS")) {
/*
* Create a cairo PS/PDF workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkFileName,"st04c");
NhlRLSetString(rlist,NhlNwkFormat,(char*)wks_type);
NhlRLSetString(rlist,NhlNwkColorMap,"temp1");
NhlCreate(&wid,"st04Work",NhlcairoDocumentWorkstationClass,appid,rlist);
}
else if (!strcmp(wks_type,"png") || !strcmp(wks_type,"PNG")) {
/*
* Create a cairo PNG workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkFileName,"st04c");
NhlRLSetString(rlist,NhlNwkFormat,(char*)wks_type);
NhlRLSetString(rlist,NhlNwkColorMap,"temp1");
NhlCreate(&wid,"st04Work",NhlcairoImageWorkstationClass,appid,rlist);
}
/*
* Open the netCDF files.
*/
for( i = 0; i <= 5; i++ ) {
sprintf( filename, "%s/cdf/%s", dir, cdffiles[i] );
ncid[i] = ncopen(filename,NC_NOWRITE);
}
/*
* Get the lat/lon dimensions (they happen to be the
* same for all files in this case)
*/
latid = ncdimid(ncid[0],"lat");
lonid = ncdimid(ncid[0],"lon");
ncdiminq(ncid[0],latid,(char *)0,&latlen);
ncdiminq(ncid[0],lonid,(char *)0,&lonlen);
len_dims[0] = latlen;
len_dims[1] = lonlen;
/*
* Get the variable ids
*/
uid = ncvarid(ncid[0],"u");
vid = ncvarid(ncid[1],"v");
pid = ncvarid(ncid[2],"p");
tid = ncvarid(ncid[3],"t");
u5id = ncvarid(ncid[4],"u");
v5id = ncvarid(ncid[5],"v");
latid = ncvarid(ncid[0],"lat");
lonid = ncvarid(ncid[0],"lon");
/*
* allocate space for arrays
*/
X = (float *)malloc(sizeof(float)*latlen*lonlen);
Y = (float *)malloc(sizeof(float)*latlen*lonlen);
lat = (float *)malloc(sizeof(float)*latlen);
lon = (float *)malloc(sizeof(float)*lonlen);
/*
* Get lat/lon values (they are the same for all files)
*/
strt[0] = 0;
cnt[0] = latlen;
ncvarget(ncid[0],latid,(long const *)strt,(long const *)cnt,lat);
cnt[0] = lonlen;
ncvarget(ncid[0],lonid,(long const *)strt,(long const *)cnt,lon);
/*
* Get U and V data values
*/
get_2d_array(X,latlen,lonlen,ncid[0],uid,0);
get_2d_array(Y,latlen,lonlen,ncid[1],vid,0);
/*
* Create a VectorField of the surface wind data
*/
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNvfUDataArray,X,2,len_dims);
NhlRLSetMDFloatArray(rlist,NhlNvfVDataArray,Y,2,len_dims);
NhlRLSetFloat(rlist,NhlNvfXCStartV,lon[0]);
NhlRLSetFloat(rlist,NhlNvfYCStartV,lat[0]);
NhlRLSetFloat(rlist,NhlNvfXCEndV,lon[lonlen-1]);
NhlRLSetFloat(rlist,NhlNvfYCEndV,lat[latlen-1]);
NhlRLSetFloat(rlist,NhlNvfMissingUValueV,-9999.0);
NhlCreate(&vfield,"VectorField",NhlvectorFieldClass,appid,rlist);
/*
* Create a VectorField of 500 millibar wind data
*
* Get U and V values
*/
get_2d_array(X,latlen,lonlen,ncid[4],u5id,0);
get_2d_array(Y,latlen,lonlen,ncid[5],v5id,0);
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNvfUDataArray,X,2,len_dims);
NhlRLSetMDFloatArray(rlist,NhlNvfVDataArray,Y,2,len_dims);
NhlRLSetFloat(rlist,NhlNvfXCStartV,lon[0]);
NhlRLSetFloat(rlist,NhlNvfYCStartV,lat[0]);
NhlRLSetFloat(rlist,NhlNvfXCEndV,lon[lonlen-1]);
NhlRLSetFloat(rlist,NhlNvfYCEndV,lat[latlen-1]);
NhlRLSetFloat(rlist,NhlNvfMissingUValueV,-9999.0);
NhlCreate(&vfield2,"VectorField",NhlvectorFieldClass,appid,rlist);
/*
* Create a ScalarField of surface pressure
*
* Get P data values
*/
get_2d_array(X,latlen,lonlen,ncid[2],pid,0);
for( i = 0; i < latlen*lonlen; i++ ) {
if( X[i] != -9999.0 ) {
X[i] /= 100.;
}
}
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNsfDataArray,X,2,len_dims);
NhlRLSetFloat(rlist,NhlNsfXCStartV,lon[0]);
NhlRLSetFloat(rlist,NhlNsfYCStartV,lat[0]);
NhlRLSetFloat(rlist,NhlNsfXCEndV,lon[lonlen-1]);
NhlRLSetFloat(rlist,NhlNsfYCEndV,lat[latlen-1]);
NhlRLSetFloat(rlist,NhlNsfMissingValueV,-9999.0);
NhlCreate(&sfield,"ScalarField",NhlscalarFieldClass,appid,rlist);
/*
* Create a ScalarField of surface temperature
* (convert from Kelvin to Farenheit)
*
* Get T data values
*/
get_2d_array(X,latlen,lonlen,ncid[3],tid,0);
/*
* Convert to Fahrenheit
*/
for( i = 0; i < latlen*lonlen; i++ ) {
if( X[i] != -9999.0) {
X[i] = (X[i] - 273.15) * 9.0/5.0 + 32.0;
}
}
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNsfDataArray,X,2,len_dims);
NhlRLSetFloat(rlist,NhlNsfXCStartV,lon[0]);
NhlRLSetFloat(rlist,NhlNsfYCStartV,lat[0]);
NhlRLSetFloat(rlist,NhlNsfXCEndV,lon[lonlen-1]);
NhlRLSetFloat(rlist,NhlNsfYCEndV,lat[latlen-1]);
NhlRLSetFloat(rlist,NhlNsfMissingValueV,-9999.0);
NhlCreate(&sfield2,"ScalarField2",NhlscalarFieldClass,appid,rlist);
/*
* Create a ContourPlot with surface temperature data
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNcnFillOn,"true");
NhlRLSetString(rlist,NhlNcnLinesOn,"false");
NhlRLSetString(rlist,NhlNcnFillDrawOrder,"predraw");
NhlRLSetInteger(rlist,NhlNcnScalarFieldData,sfield2);
NhlCreate(&cnid,"contourplot",NhlcontourPlotClass,wid,rlist);
/*
* Create a VectorPlot with the surface wind and pressure data
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNvcUseScalarArray,"true");
NhlRLSetInteger(rlist,NhlNvcVectorFieldData,vfield);
NhlRLSetInteger(rlist,NhlNvcScalarFieldData,sfield);
NhlCreate(&vcid,"vectorplot",NhlvectorPlotClass,wid,rlist);
/*
* Create a StreamlinePlot with 500 mb wind data
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNpmTitleDisplayMode,"always");
NhlRLSetString(rlist,NhlNtiMainFuncCode,"~");
NhlRLSetInteger(rlist,NhlNstVectorFieldData,vfield2);
NhlCreate(&stid,"streamlineplot",NhlstreamlinePlotClass,wid,rlist);
/*
* Create an annotation used to explain the streamline data
*/
NhlCreate(&txid,"streamlineplotanno",NhltextItemClass,wid,0);
amid = NhlAddAnnotation(stid,txid);
/*
* Create a map object
*/
NhlRLClear(rlist);
/* NhlRLSetString(rlist,NhlNvpUseSegments,"true"); */
NhlCreate(&mpid,"mapplot",NhlmapPlotClass,wid,rlist);
/*
* Overlay everything on the MapPlot. The last object overlaid will
* appear on top
*/
NhlAddOverlay(mpid,cnid,-1);
NhlAddOverlay(mpid,vcid,-1);
NhlAddOverlay(mpid,stid,-1);
/*
* Variables for manipulating the title string
*/
tmid = ncdimid(ncid[1],"timestep");
ncdiminq(ncid[1],tmid,(char *)0,&timelen);
tmid = ncvarid(ncid[1],"timestep");
timestep = (int *)malloc(sizeof(int)*timelen);
strt[0] = 0;
cnt[0] = timelen;
ncvarget(ncid[1],tmid,(long const *)strt,(long const *)cnt,timestep);
sprintf( hour, "00");
sprintf( day, "05");
stdmid = ncdimid(ncid[1],"timelen");
ncdiminq(ncid[1], stdmid, (char *)0, &stid_len );
tmid = ncvarid(ncid[1],"reftime");
rftime = (char *)malloc((stid_len+1)*sizeof(char));
strt[0] = 0; cnt[0] = stid_len;
ncvarget(ncid[1],tmid,(long const *)strt,(long const *)cnt,rftime);
for( i = 0; i <= TIMESTEPS-1; i++ ) {
if (i != 17 && i != 36 && i != 37) {
/*
* Figure out the hour and day from the timestep, convert to strings
* and build the title string
*/
d = timestep[i] / 24 + 5;
h = timestep[i] % 24;
if (h > 9) {
sprintf( hour, "%d", h );
}
else {
sprintf( hour, "0%d", h );
}
if (d > 9) {
sprintf(day, "%d", d );
}
else {
sprintf(day, "0%d", d );
}
/*
* Set the new title string
*/
strcpy(mainstring, rftime);
sprintf(&mainstring[8], "%2s %2s:00", day, hour);
printf("%s\n",mainstring);
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNtiMainString,mainstring);
NhlSetValues(stid,rlist);
/*
* Modify the data objects with data for the current time step
*
* Get U and V values
*/
get_2d_array(X,latlen,lonlen,ncid[0],uid,i);
get_2d_array(Y,latlen,lonlen,ncid[1],vid,i);
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNvfUDataArray,X,2,len_dims);
NhlRLSetMDFloatArray(rlist,NhlNvfVDataArray,Y,2,len_dims);
NhlSetValues(vfield,rlist);
/*
* Get U and V values
*/
get_2d_array(X,latlen,lonlen,ncid[4],u5id,i);
get_2d_array(Y,latlen,lonlen,ncid[5],v5id,i);
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNvfUDataArray,X,2,len_dims);
NhlRLSetMDFloatArray(rlist,NhlNvfVDataArray,Y,2,len_dims);
NhlSetValues(vfield2,rlist);
/*
* Get P values
*/
get_2d_array(X,latlen,lonlen,ncid[2],pid,i);
for( j = 0; j < latlen*lonlen; j++ ) {
if( X[j] != -9999.0 ) {
X[j] /= 100.;
}
}
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNsfDataArray,X,2,len_dims);
NhlSetValues(sfield,rlist);
/*
* Get T values
*/
get_2d_array(X,latlen,lonlen,ncid[3],tid,i);
/*
* Convert to Fahrenheit
*/
for( j = 0; j < latlen*lonlen; j++ ) {
if( X[j] != -9999.0) {
X[j] = (X[j] - 273.15) * 9.0/5.0 + 32.0;
}
}
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNsfDataArray,X,2,len_dims);
NhlSetValues(sfield2,rlist);
/*
* Draw the plot
*/
NhlDraw(mpid);
NhlFrame(wid);
}
}
/*
* Destroy the workstation object and exit.
*/
NhlDestroy(wid);
NhlClose();
exit(0);
}
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
}
int
wr_dpi(Dpi *d,
char *filename,
int verbosity)
{
int err = 0;
int status = 0;
int u = 0; /* short hand for unit... */
struct Shadow_Identifiers si;
memset(&si, 0, sizeof(struct Shadow_Identifiers));
/*
* From the C interface guide the basic calling sequence is given
* for the case of adding new dimensions, variables and attributes to
* an existing netCDF dataset.
*
* nc_open();
* nc_redef();
* nc_def_dim();
* nc_def_var();
* nc_put_att();
* nc_enddef();
* nc_put_var();
* nc_close();
*
*/
/*
* Open the file.
*/
#ifdef NETCDF_3
err = nc_open(filename, NC_WRITE, &u);
if ( err != NC_NOERR )
{
EH(-1, "nc_open() problem.");
}
#endif
#ifdef NETCDF_2
err = ncopen(filename, NC_WRITE);
EH(err, "ncopen() problem.");
u = err;
#endif
/*
* Go into define mode.
*/
#ifdef NETCDF_3
err = nc_redef(u);
if ( err != NC_NOERR )
{
EH(-1, "nc_redef() problem.");
}
#endif
#ifdef NETCDF_2
err = ncredef(u);
EH(err, "ncredef() problem.");
#endif
/*
* Define each of the netCDF dimensions that will be needed to describe
* the extent of netCDF variables that are arrays.
*/
define_dimension(u, DIM_LEN_EB_NUM_PRIVATE_ELEMS,
d->len_eb_num_private_elems,
&si.len_eb_num_private_elems);
define_dimension(u, DIM_LEN_ELEM_VAR_TAB_GLOBAL,
d->len_elem_var_tab_global,
&si.len_elem_var_tab_global);
define_dimension(u, DIM_LEN_ELEM_ELEM_LIST, /* new e-e */
d->len_elem_elem_list,
&si.len_elem_elem_list);
define_dimension(u, DIM_LEN_NODE_DESCRIPTION,
d->len_node_description,
&si.len_node_description);
define_dimension(u, DIM_LEN_NS_NODE_LIST,
d->len_ns_node_list,
&si.len_ns_node_list);
define_dimension(u, DIM_LEN_NS_DISTFACT_LIST,
d->len_ns_distfact_list,
&si.len_ns_distfact_list);
define_dimension(u, DIM_LEN_SS_ELEM_LIST,
d->len_ss_elem_list,
&si.len_ss_elem_list);
define_dimension(u, DIM_LEN_SS_DISTFACT_LIST,
d->len_ss_distfact_list,
&si.len_ss_distfact_list);
define_dimension(u, DIM_LEN_STRING,
d->len_string,
&si.len_string);
define_dimension(u, DIM_LEN_PTR_SET_MEMBERSHIP,
d->len_ptr_set_membership,
&si.len_ptr_set_membership);
define_dimension(u, DIM_LEN_SET_MEMBERSHIP,
d->len_set_membership,
&si.len_set_membership);
define_dimension(u, DIM_NUM_ELEM_BLOCKS,
d->num_elem_blocks,
&si.num_elem_blocks);
define_dimension(u, DIM_NUM_ELEM_BLOCKS_GLOBAL,
d->num_elem_blocks_global,
&si.num_elem_blocks_global);
define_dimension(u, DIM_NUM_ELEMS,
d->num_elems,
&si.num_elems);
define_dimension(u, DIM_NUM_GLOBAL_NODE_DESCRIPTIONS,
d->num_global_node_descriptions,
&si.num_global_node_descriptions);
define_dimension(u, DIM_NUM_NEIGHBORS,
d->num_neighbors,
&si.num_neighbors);
define_dimension(u, DIM_NUM_NODE_SETS,
d->num_node_sets,
&si.num_node_sets);
define_dimension(u, DIM_NUM_NODE_SETS_GLOBAL,
d->num_node_sets_global,
&si.num_node_sets_global);
define_dimension(u, DIM_NUM_NODES,
d->num_nodes,
&si.num_nodes);
define_dimension(u, DIM_NUM_PROPS_EB, d->num_props_eb,
&si.num_props_eb);
define_dimension(u, DIM_NUM_PROPS_NS,
d->num_props_ns,
&si.num_props_ns);
define_dimension(u, DIM_NUM_PROPS_SS,
d->num_props_ss,
&si.num_props_ss);
define_dimension(u, DIM_NUM_SIDE_SETS,
d->num_side_sets,
&si.num_side_sets);
define_dimension(u, DIM_NUM_SIDE_SETS_GLOBAL,
d->num_side_sets_global,
&si.num_side_sets_global);
define_dimension(u, DIM_NUM_UNIVERSE_NODES,
d->num_universe_nodes,
&si.num_universe_nodes);
if (d->num_side_sets_global > 0) {
define_dimension(u, DIM_LEN_SS_BLOCK_INDEX_GLOBAL,
d->num_side_sets_global + 1,
&si.len_ss_block_index_global);
define_dimension(u, DIM_LEN_SS_BLOCK_LIST_GLOBAL,
d->ss_block_index_global[d->num_side_sets_global],
&si.len_ss_block_list_global);
} else {
define_dimension(u, DIM_LEN_SS_BLOCK_INDEX_GLOBAL,
0,
&si.len_ss_block_index_global);
define_dimension(u, DIM_LEN_SS_BLOCK_LIST_GLOBAL,
0,
&si.len_ss_block_list_global);
}
/*
* Define variables. Arrays only get defined if their respective dimensions
* are greater than zero.
*
* Also, this handy routine uses two arguments for the possibility of
* up to 2D arrays. Dummy arguments of "-1" are inserted for 1D arrays
* or for scalar variables ( zero dimensional arrays).
*/
define_variable(u, VAR_DPI_VERSION_STRING, NC_CHAR, 1,
si.len_string, -1,
d->len_string, -1,
&si.dpi_version_string);
define_variable(u, VAR_EB_ELEM_TYPE_GLOBAL, NC_CHAR, 2,
si.num_elem_blocks_global, si.len_string,
d->num_elem_blocks_global, d->len_string,
&si.eb_elem_type_global);
define_variable(u, VAR_EB_ID_GLOBAL, NC_INT, 1,
si.num_elem_blocks_global, -1,
d->num_elem_blocks_global, -1,
&si.eb_id_global);
define_variable(u, VAR_EB_INDEX_GLOBAL, NC_INT, 1,
si.num_elem_blocks, -1,
d->num_elem_blocks, -1,
&si.eb_index_global);
define_variable(u, VAR_EB_NUM_ATTR_GLOBAL, NC_INT, 1,
si.num_elem_blocks_global, -1,
d->num_elem_blocks_global, -1,
&si.eb_num_attr_global);
define_variable(u, VAR_EB_NUM_ELEMS_GLOBAL, NC_INT, 1,
si.num_elem_blocks_global, -1,
d->num_elem_blocks_global, -1,
&si.eb_num_elems_global);
define_variable(u, VAR_EB_NUM_NODES_PER_ELEM_GLOBAL, NC_INT, 1,
si.num_elem_blocks_global, -1,
d->num_elem_blocks_global, -1,
&si.eb_num_nodes_per_elem_global);
define_variable(u, VAR_EB_NUM_PRIVATE_ELEMS, NC_INT, 1,
si.num_elem_blocks, -1,
d->num_elem_blocks, -1,
&si.eb_num_private_elems);
if ( d->num_props_eb > 1 ) /* Properties are weird, recall. */
{
define_variable(u, VAR_EB_PROP_GLOBAL, NC_INT, 2,
si.num_props_eb, si.num_elem_blocks_global,
d->num_props_eb, d->num_elem_blocks_global,
&si.eb_prop_global);
}
if ( d->num_elems > 0 )
{
define_variable(u, VAR_ELEM_INDEX_GLOBAL, NC_INT, 1,
si.num_elems, -1,
d->num_elems, -1,
&si.elem_index_global);
}
if ( d->len_elem_var_tab_global > 0 )
{
define_variable(u, VAR_ELEM_VAR_TAB_GLOBAL, NC_INT, 1,
si.len_elem_var_tab_global, -1,
d->len_elem_var_tab_global, -1,
&si.elem_var_tab_global);
}
if ( d->len_elem_elem_list > 0 )
{
define_variable(u, VAR_ELEM_OWNER, NC_INT, 1,
si.num_elems, -1,
d->num_elems, -1,
&si.elem_owner);
define_variable(u, VAR_ELEM_ELEM_LIST_GLOBAL, NC_INT, 1,
si.len_elem_elem_list, -1,
d->len_elem_elem_list, -1,
&si.elem_elem_list_global);
define_variable(u, VAR_ELEM_ELEM_TWST_GLOBAL, NC_INT, 1,
si.len_elem_elem_list, -1,
d->len_elem_elem_list, -1,
&si.elem_elem_twst_global);
define_variable(u, VAR_ELEM_ELEM_FACE_GLOBAL, NC_INT, 1,
si.len_elem_elem_list, -1,
d->len_elem_elem_list, -1,
&si.elem_elem_face_global);
define_variable(u, VAR_ELEM_ELEM_PROC_GLOBAL, NC_INT, 1,
si.len_elem_elem_list, -1,
d->len_elem_elem_list, -1,
&si.elem_elem_proc_global);
}
define_variable(u, VAR_GLOBAL_NODE_DESCRIPTION, NC_INT, 2,
si.num_global_node_descriptions, si.len_node_description,
d->num_global_node_descriptions, d->len_node_description,
&si.global_node_description);
define_variable(u, VAR_MY_NAME, NC_INT, 0,
-1, -1,
-1, -1,
&si.my_name);
define_variable(u, VAR_NEIGHBOR, NC_INT, 1,
si.num_neighbors, -1,
d->num_neighbors, -1,
&si.neighbor);
if ( d->num_nodes > 0 )
{
define_variable(u, VAR_NODE_INDEX_GLOBAL, NC_INT, 1,
si.num_nodes, -1,
d->num_nodes, -1,
&si.node_index_global);
}
define_variable(u, VAR_NS_DISTFACT_INDEX_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_distfact_index_global);
define_variable(u, VAR_NS_DISTFACT_LEN_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.ns_distfact_len_global);
define_variable(u, VAR_NS_DISTFACT_LIST_INDEX_GLOBAL, NC_INT, 1,
si.len_ns_distfact_list, -1,
d->len_ns_distfact_list, -1,
&si.ns_distfact_list_index_global);
define_variable(u, VAR_NS_ID_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_id_global);
define_variable(u, VAR_NS_INDEX_GLOBAL, NC_INT, 1,
si.num_node_sets, -1,
d->num_node_sets, -1,
&si.ns_index_global);
define_variable(u, VAR_NS_NODE_INDEX_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_node_index_global);
define_variable(u, VAR_NS_NODE_LEN_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.ns_node_len_global);
define_variable(u, VAR_NS_NODE_LIST_INDEX_GLOBAL, NC_INT, 1,
si.len_ns_node_list, -1,
d->len_ns_node_list, -1,
&si.ns_node_list_index_global);
define_variable(u, VAR_NS_NUM_DISTFACTS_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_num_distfacts_global);
define_variable(u, VAR_NS_NUM_NODES_GLOBAL, NC_INT, 1,
si.num_node_sets_global, -1,
d->num_node_sets_global, -1,
&si.ns_num_nodes_global);
if ( d->num_props_ns > 1 )
{
define_variable(u, VAR_NS_PROP_GLOBAL, NC_INT, 2,
si.num_props_ns, si.num_node_sets_global,
d->num_props_ns, d->num_node_sets_global,
&si.ns_prop_global);
}
define_variable(u, VAR_NUM_BOUNDARY_NODES, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_boundary_nodes);
define_variable(u, VAR_NUM_DOFS_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_dofs_global);
define_variable(u, VAR_NUM_ELEMS_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_elems_global);
define_variable(u, VAR_NUM_EXTERNAL_NODES, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_external_nodes);
define_variable(u, VAR_NUM_INTERNAL_NODES, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_internal_nodes);
define_variable(u, VAR_NUM_NODES_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.num_nodes_global);
define_variable(u, VAR_PTR_SET_MEMBERSHIP, NC_INT, 1,
si.len_ptr_set_membership, -1,
d->len_ptr_set_membership, -1,
&si.ptr_set_membership);
define_variable(u, VAR_SET_MEMBERSHIP, NC_INT, 1,
si.len_set_membership, -1,
d->len_set_membership, -1,
&si.set_membership);
define_variable(u, VAR_SS_DISTFACT_INDEX_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_distfact_index_global);
define_variable(u, VAR_SS_DISTFACT_LIST_INDEX_GLOBAL, NC_INT, 1,
si.len_ss_distfact_list, -1,
d->len_ss_distfact_list, -1,
&si.ss_distfact_list_index_global);
define_variable(u, VAR_SS_DISTFACT_LEN_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.ss_distfact_len_global);
define_variable(u, VAR_SS_ELEM_INDEX_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_elem_index_global);
define_variable(u, VAR_SS_ELEM_LEN_GLOBAL, NC_INT, 0,
-1, -1,
-1, -1,
&si.ss_elem_len_global);
define_variable(u, VAR_SS_ELEM_LIST_INDEX_GLOBAL, NC_INT, 1,
si.len_ss_elem_list, -1,
d->len_ss_elem_list, -1,
&si.ss_elem_list_index_global);
define_variable(u, VAR_SS_ID_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_id_global);
define_variable(u, VAR_SS_INDEX_GLOBAL, NC_INT, 1,
si.num_side_sets, -1,
d->num_side_sets, -1,
&si.ss_index_global);
define_variable(u, VAR_SS_NUM_DISTFACTS_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_num_distfacts_global);
define_variable(u, VAR_SS_NUM_SIDES_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_num_sides_global);
if ( d->num_props_ss > 1 )
{
define_variable(u, VAR_SS_PROP_GLOBAL, NC_INT, 2,
si.num_props_ss, si.num_side_sets_global,
d->num_props_ss, d->num_side_sets_global,
&si.ss_prop_global);
}
if ( d->num_side_sets_global > 0 )
{
define_variable(u, VAR_SS_INTERNAL_GLOBAL, NC_INT, 1,
si.num_side_sets_global, -1,
d->num_side_sets_global, -1,
&si.ss_internal_global);
define_variable(u, VAR_SS_BLOCK_INDEX_GLOBAL, NC_INT, 1,
si.len_ss_block_index_global, -1,
d->num_side_sets_global + 1, -1,
&si.ss_block_index_global);
define_variable(u, VAR_SS_BLOCK_LIST_GLOBAL, NC_INT, 1,
si.len_ss_block_list_global, -1,
d->ss_block_index_global[d->num_side_sets_global], -1,
&si.ss_block_list_global);
}
define_variable(u, VAR_UNDEFINED_BASIC_EQNVAR_ID, NC_INT, 0,
-1, -1,
-1, -1,
&si.undefined_basic_eqnvar_id);
/*
* Leave define mode.
*/
#ifdef NETCDF_3
err = nc_enddef(u);
if ( err != NC_NOERR )
{
EH(-1, "nc_enddef() problem.");
}
#endif
#ifdef NETCDF_2
err = ncendef(u);
EH(err, "ncendef() problem.");
#endif
/*
* Put variable values.
*
* This form is good for scalars, 1d arrays and 2d arrays. Any more and
* you'll need to add another argument to the list for the backward
* compatible to netCDF implementation to work properly. We'll assume
* that start[] arrays that ncvarput() uses will be full of zeroes.
* If not, then you'll need to do that case by hand.
*/
put_variable(u, NC_CHAR, 1,
d->len_string, -1,
si.dpi_version_string, d->dpi_version_string);
put_variable(u, NC_CHAR, 2,
d->num_elem_blocks_global, d->len_string,
si.eb_elem_type_global, &(d->eb_elem_type_global[0][0]));
put_variable(u, NC_INT, 1,
d->num_elem_blocks_global, -1,
si.eb_id_global, d->eb_id_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks, -1,
si.eb_index_global, d->eb_index_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks_global, -1,
si.eb_num_attr_global, d->eb_num_attr_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks_global, -1,
si.eb_num_elems_global, d->eb_num_elems_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks_global, -1,
si.eb_num_nodes_per_elem_global,
d->eb_num_nodes_per_elem_global);
put_variable(u, NC_INT, 1,
d->num_elem_blocks, -1,
si.eb_num_private_elems, d->eb_num_private_elems);
if ( d->num_props_eb > 1 )
{
put_variable(u, NC_INT, 2,
d->num_props_eb, d->num_elem_blocks_global,
si.eb_prop_global, &(d->eb_prop_global[0][0]));
}
if ( d->num_elems > 0 )
{
put_variable(u, NC_INT, 1,
d->num_elems, -1,
si.elem_index_global, d->elem_index_global);
put_variable(u, NC_INT, 1, d->num_elems, -1, si.elem_owner,
d->elem_owner);
}
if ( d->len_elem_var_tab_global > 0 )
{
put_variable(u, NC_INT, 1,
d->len_elem_var_tab_global, -1,
si.elem_var_tab_global, d->elem_var_tab_global);
}
if ( d->len_elem_elem_list > 0 )
{
put_variable(u, NC_INT, 1, d->len_elem_elem_list, -1,
si.elem_elem_list_global, d->elem_elem_list_global);
put_variable(u, NC_INT, 1, d->len_elem_elem_list, -1,
si.elem_elem_face_global, d->elem_elem_face_global);
put_variable(u, NC_INT, 1, d->len_elem_elem_list, -1,
si.elem_elem_twst_global, d->elem_elem_twst_global);
put_variable(u, NC_INT, 1, d->len_elem_elem_list, -1,
si.elem_elem_proc_global, d->elem_elem_proc_global);
}
put_variable(u, NC_INT, 2,
d->num_global_node_descriptions, d->len_node_description,
si.global_node_description,&(d->global_node_description[0][0]));
put_variable(u, NC_INT, 0,
-1, -1,
si.my_name, &(d->my_name));
put_variable(u, NC_INT, 1,
d->num_neighbors, -1,
si.neighbor, d->neighbor);
if ( d->num_nodes > 0 )
{
put_variable(u, NC_INT, 1,
d->num_nodes, -1,
si.node_index_global, d->node_index_global);
}
put_variable(u, NC_INT, 0,
-1, -1,
si.ns_distfact_len_global, &(d->ns_distfact_len_global));
put_variable(u, NC_INT, 0,
-1, -1,
si.ns_node_len_global, &(d->ns_node_len_global));
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_id_global, d->ns_id_global);
put_variable(u, NC_INT, 1,
d->num_node_sets, -1,
si.ns_index_global, d->ns_index_global);
put_variable(u, NC_INT, 1,
d->len_ns_distfact_list, -1,
si.ns_distfact_list_index_global,
d->ns_distfact_list_index_global);
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_distfact_index_global, d->ns_distfact_index_global);
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_node_index_global, d->ns_node_index_global);
put_variable(u, NC_INT, 1,
d->len_ns_node_list, -1,
si.ns_node_list_index_global,
d->ns_node_list_index_global);
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_num_distfacts_global, d->ns_num_distfacts_global);
put_variable(u, NC_INT, 1,
d->num_node_sets_global, -1,
si.ns_num_nodes_global, d->ns_num_nodes_global);
if ( d->num_props_ns > 1 )
{
put_variable(u, NC_INT, 2,
d->num_props_ns, d->num_node_sets_global,
si.ns_prop_global, &(d->ns_prop_global[0][0]));
}
put_variable(u, NC_INT, 0,
-1, -1,
si.num_boundary_nodes, &(d->num_boundary_nodes));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_dofs_global, &(d->num_dofs_global));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_elems_global, &(d->num_elems_global));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_external_nodes, &(d->num_external_nodes));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_internal_nodes, &(d->num_internal_nodes));
put_variable(u, NC_INT, 0,
-1, -1,
si.num_nodes_global, &(d->num_nodes_global));
put_variable(u, NC_INT, 1,
d->len_ptr_set_membership, -1,
si.ptr_set_membership, d->ptr_set_membership);
put_variable(u, NC_INT, 1,
d->len_set_membership, -1,
si.set_membership, d->set_membership);
put_variable(u, NC_INT, 1, d->num_side_sets_global, -1,
si.ss_distfact_index_global, d->ss_distfact_index_global);
put_variable(u, NC_INT, 0, -1, -1,
si.ss_distfact_len_global, &(d->ss_distfact_len_global));
if ( d->len_ss_distfact_list > 0 )
{
put_variable(u, NC_INT, 1, d->len_ss_distfact_list, -1,
si.ss_distfact_list_index_global,
d->ss_distfact_list_index_global);
}
put_variable(u, NC_INT, 1, d->num_side_sets_global, -1,
si.ss_elem_index_global, d->ss_elem_index_global);
put_variable(u, NC_INT, 0, -1, -1,
si.ss_elem_len_global, &(d->ss_elem_len_global));
if ( d->len_ss_elem_list > 0 )
{
put_variable(u, NC_INT, 1, d->len_ss_elem_list, -1,
si.ss_elem_list_index_global, d->ss_elem_list_index_global);
}
put_variable(u, NC_INT, 1,
d->num_side_sets_global, -1,
si.ss_id_global, d->ss_id_global);
if ( d->num_side_sets > 0 )
{
put_variable(u, NC_INT, 1,
d->num_side_sets, -1,
si.ss_index_global, d->ss_index_global);
}
put_variable(u, NC_INT, 1,
d->num_side_sets_global, -1,
si.ss_num_distfacts_global, d->ss_num_distfacts_global);
put_variable(u, NC_INT, 1,
d->num_side_sets_global, -1,
si.ss_num_sides_global, d->ss_num_sides_global);
if ( d->num_props_ss > 1 )
{
put_variable(u, NC_INT, 2,
d->num_props_ss, d->num_side_sets_global,
si.ss_prop_global, &(d->ss_prop_global[0][0]));
}
put_variable(u, NC_INT, 0,
-1, -1,
si.undefined_basic_eqnvar_id, &(d->undefined_basic_eqnvar_id));
if (d->num_side_sets_global > 0) {
put_variable(u, NC_INT, 1,
d->num_side_sets_global, -1,
si.ss_internal_global, d->ss_internal_global);
put_variable(u, NC_INT, 1,
d->num_side_sets_global+1, -1,
si.ss_block_index_global, d->ss_block_index_global);
put_variable(u, NC_INT, 1,
d->ss_block_index_global[d->num_side_sets_global], -1,
si.ss_block_list_global, d->ss_block_list_global);
}
/*
* Close the file (flush buffers).
*/
#ifdef NETCDF_3
err = nc_close(u);
if ( err != NC_NOERR )
{
EH(-1, "nc_close() problem.");
}
#endif
#ifdef NETCDF_2
err = ncclose(u);
EH(err, "ncclose()");
#endif
return(status);
}
/* Open an input netCDF file and get some information about it */
int process_ncinfile(char *ncname, unsigned char appendnc, int outncfid,
char *outncname, int *nfiles, unsigned char verbose)
{
struct fileinfo ncinfile; /* Information about an input netCDF file */
int nfiles2; /* Number of files in the decomposed domain */
int d, v, n; /* Loop variables */
int dimid; /* ID of a dimension */
int decomp[4]; /* "domain_decomposition" information */
char attname[MAX_NC_NAME]; /* Name of a global or variable attribute */
unsigned char ncinfileerror=0; /* Were there any file errors? */
/* Open an input netCDF file; return if not openable - possibly IEEE */
if ((ncinfile.ncfid=ncopen(ncname,NC_NOWRITE))==(-1)) return(2);
/* Determine the number of files in the decomposed domain */
if (ncattget(ncinfile.ncfid,NC_GLOBAL,"NumFilesInSet",
(void *)&nfiles2)==(-1))
{
if (*nfiles==1)
{
fprintf(stderr,"Error: missing the \"NumFilesInSet\" global attribute!\n");
return(1);
}
else if (*nfiles==(-1))
{
fprintf(stderr,"Warning: missing the \"NumFilesInSet\" global attribute.\n");
}
}
*nfiles=nfiles2;
/* Get some general information about the input netCDF file */
if (ncinquire(ncinfile.ncfid,&(ncinfile.ndims),&(ncinfile.nvars),
&(ncinfile.ngatts),&(ncinfile.recdim))==(-1))
{
fprintf(stderr,"Error: cannot read the file's metadata!\n");
ncclose(ncinfile.ncfid);
return(1);
}
/* Get some information about the dimensions */
for (d=0; d < ncinfile.ndims; d++)
{
if ((ncdiminq(ncinfile.ncfid,d,ncinfile.dimname[d],
&(ncinfile.dimsize[d])))==(-1))
{
fprintf(stderr,"Error: cannot read dimension #%d's metadata!\n",d);
ncclose(ncinfile.ncfid);
return(1);
}
ncinfile.dimfullsize[d]=ncinfile.dimsize[d];
ncinfile.dimstart[d]=1;
ncinfile.dimend[d]=(-1);
}
/* Get some information about the variables */
for (v=0; v < ncinfile.nvars; v++)
{
if ((ncvarinq(ncinfile.ncfid,v,ncinfile.varname[v],
&(ncinfile.datatype[v]),&(ncinfile.varndims[v]),
ncinfile.vardim[v],&(ncinfile.natts[v])))==(-1))
{
fprintf(stderr,"Error: cannot read variable #%d's metadata!\n",v);
ncclose(ncinfile.ncfid);
return(1);
}
/* If the variable is also a dimension then get decomposition info */
if ((dimid=ncdimid(ncinfile.ncfid,ncinfile.varname[v]))!=(-1))
{
if (ncattget(ncinfile.ncfid,v,"domain_decomposition",
(void *)decomp)!=(-1))
{
ncinfile.dimfullsize[dimid]=decomp[1]-decomp[0]+1;
ncinfile.dimstart[dimid]=decomp[2]-(decomp[0]-1);
ncinfile.dimend[dimid]=decomp[3]-(decomp[0]-1);
}
else
{
ncinfile.dimfullsize[dimid]=ncinfile.dimsize[dimid];
ncinfile.dimstart[dimid]=1;
ncinfile.dimend[dimid]=(-1);
}
}
}
#if DEBUG==1
print_debug(&ncinfile,verbose);
#endif
/* If the output netCDF file was just created then define its structure */
if (!appendnc)
{
#if DEBUG==1
printf("Creating output netCDF file... \"%s\"\n",outncname);
#endif
/* Define the dimensions */
for (d=0; d < ncinfile.ndims; d++)
{
if (d==ncinfile.recdim)
ncdimdef(outncfid,ncinfile.dimname[d],NC_UNLIMITED);
else ncdimdef(outncfid,ncinfile.dimname[d],ncinfile.dimfullsize[d]);
}
/* Define the variables and copy their attributes */
for (v=0; v < ncinfile.nvars; v++)
{
ncvardef(outncfid,ncinfile.varname[v],ncinfile.datatype[v],
ncinfile.varndims[v],ncinfile.vardim[v]);
for (n=0; n < ncinfile.natts[v]; n++)
{
ncattname(ncinfile.ncfid,v,n,attname);
if (!strcmp(attname,"domain_decomposition")) continue;
else
{
if (ncattcopy(ncinfile.ncfid,v,attname,outncfid,v)==(-1))
{
fprintf(stderr,"Error: cannot copy variable \"%s\"'s attributes!\n",
ncinfile.varname[v]);
return(1);
}
}
}
}
/* Copy the global attributes */
for (n=0; n < ncinfile.ngatts; n++)
{
ncattname(ncinfile.ncfid,NC_GLOBAL,n,attname);
if (!strcmp(attname,"NumFilesInSet")) continue;
else if (!strcmp(attname,"filename"))
ncattput(outncfid,NC_GLOBAL,attname,NC_CHAR,strlen(outncname),
(void *)outncname);
else
{
if (ncattcopy(ncinfile.ncfid,NC_GLOBAL,attname,outncfid,
NC_GLOBAL)==(-1))
{
fprintf(stderr,"Error: cannot copy the file's global attributes!\n");
return(1);
}
}
}
/* Definitions done */
ncendef(outncfid);
}
/* Copy all the data values of the dimensions and variables */
ncinfileerror=copy_nc_data(&ncinfile,outncfid,appendnc,verbose);
/* Done */
ncclose(ncinfile.ncfid);
return(ncinfileerror);
}
int main(int argc, char *argv[])
{
unsigned char verbose=0; /* Print some progress information? */
unsigned char appendnc=0; /* Append to an existing netCDF file? */
unsigned char removein=0; /* Remove the ".####" decomposed input files? */
int nstart=0; /* PE number of the first input netCDF file */
int nend; /* PE number of the last input netCDF file */
int outputarg=(-1); /* Argument # of the output netCDF file */
int inputarg=(-1); /* Argument # of first input netCDF file */
struct stat statbuf; /* Dummy structure for file-testing "stat" call */
int outncfid; /* ID of the output netCDF file */
char outfilename[2048], *strptr; /* Name of the output netCDF file */
int outlen; /* Length of the output filename */
char infilename[2048]; /* Name of an input file */
unsigned char infileerror=0; /* Were there any file errors? */
int nfiles=(-1); /* Number of files in the decomposed domain */
int a; /* Loop variable */
/* Check the command-line arguments */
if (argc < 2)
{
usage();
return(1);
}
for (a=1; a < argc; a++)
{
if (!strcmp(argv[a],"-v")) verbose=1;
else if (!strcmp(argv[a],"-a")) appendnc=1;
else if (!strcmp(argv[a],"-r")) removein=1;
else if (!strcmp(argv[a],"-n"))
{
a++;
if (a < argc) nstart=atoi(argv[a]);
else
{
usage();
return(1);
}
}
else
{
outputarg=a;
break;
}
}
if (outputarg==(-1))
{
usage();
return(1);
}
if (argc-1 > outputarg) inputarg=outputarg+1;
sprintf(outfilename,argv[outputarg]);
outlen=strlen(outfilename);
if (outlen > 4)
{
strptr=outfilename+outlen-5;
if (!strcmp(strptr,".0000")) outfilename[outlen-5]='\0';
}
/* Disable fatal returns from netCDF library functions */
ncopts=0;
/* Create a new netCDF output file */
if (!appendnc)
{
if (stat(outfilename,&statbuf)==0)
{
fprintf(stderr,"Error: output file seems to exist already!\n");
return(1);
}
if ((outncfid=nccreate(outfilename,NC_NOCLOBBER))==(-1))
{
fprintf(stderr,"Error: cannot create the output netCDF file!\n");
return(1);
}
ncsetfill(outncfid,NC_NOFILL);
}
/* Open an existing netCDF file for appending */
else
{
if ((outncfid=ncopen(outfilename,NC_WRITE))==(-1))
{
fprintf(stderr,"Error: cannot open the output netCDF file for appending!\n");
return(1);
}
}
/* No input files are specified on the command-line */
if (inputarg==(-1))
{
nend=nstart+1;
for (a=nstart; a < nend; a++)
{
sprintf(infilename,"%s.%04d",outfilename,a);
if (verbose) printf("Processing... \"%s\"",infilename);
#if DEBUG==1
else if (!verbose) printf("\nfile=%s\n",infilename);
#endif
if (stat(infilename,&statbuf)!=0)
{
if (verbose) printf("\n");
fprintf(stderr,"Error: cannot read the input file \"%s\"!\n",
infilename);
if (a==0) infileerror=3;
else infileerror=1;
break;
}
infileerror=process_ncinfile(infilename,appendnc,outncfid,
outfilename,&nfiles,verbose);
if (infileerror==2)
{
printf("IEEE input files are not currently supported!\n");
infileerror=3;
break;
}
else if (infileerror==1) break;
if (a==nstart && nfiles > 0) nend=nstart+nfiles;
appendnc=1;
if (verbose)
{
if ((nend-a-1)==1) printf("\n(1 file to go)\n");
else printf("\n(%d files to go)\n",nend-a-1);
}
}
}
/* Loop over all the specified input files */
else
for (a=inputarg; a < argc; a++)
{
if (verbose) printf("Processing... \"%s\"",argv[a]);
#if DEBUG==1
else if (!verbose) printf("\nfile=%s\n",argv[a]);
#endif
if (stat(argv[a],&statbuf)!=0)
{
if (verbose) printf("\n");
fprintf(stderr,"Error: cannot read the input file \"%s\"!\n",
argv[a]);
if (a==inputarg) infileerror=3;
else infileerror=1;
break;
}
infileerror=process_ncinfile(argv[a],appendnc,outncfid,outfilename,
&nfiles,verbose);
if (infileerror==2)
{
printf("IEEE input files are not currently supported!\n");
infileerror=3;
break;
}
else if (infileerror==1) return(1);
appendnc=1;
if (verbose)
{
if ((argc-a-1)==1) printf("\n(1 file to go)\n");
else printf("\n(%d files to go)\n",argc-a-1);
}
}
/* Clean up... return 1 on error, otherwise 0 */
ncclose(outncfid);
if (!infileerror)
{
if (removein)
{
/* No input files are specified on the command-line */
if (inputarg==(-1))
{
for (a=nstart; a < nend; a++)
{
sprintf(infilename,"%s.%04d",outfilename,a);
if (verbose)
{
if ((nend-a-1)==1)
printf("Removing... \"%s\" (1 file to go)\n",infilename);
else
printf("Removing... \"%s\" (%d files to go)\n",infilename,
nend-a-1);
}
unlink(infilename);
}
}
/* Loop over all the specified input files */
else
for (a=inputarg; a < argc; a++)
{
printf("Removing... \"%s\" (%d files to go)\n",argv[a],
argc-a-1);
unlink(argv[a]);
}
}
}
else if (infileerror==3)
{
unlink(outfilename);
infileerror=1;
}
return(infileerror);
}
/*
* TODO, lots of declared, but unused variables here
*/
static void do_netcdfquery_proc(Widget, XtPointer, XtPointer)
{
int setno, src;
char xvar[256], yvar[256];
char buf[256], fname[512];
XmString xms;
XmString *s, cs;
int *pos_list;
int i, j, pos_cnt, cnt;
char *cstr;
int cdfid; /* netCDF id */
int ndims, nvars, ngatts, recdim;
int var_id;
long start[2];
long count[2];
char varname[256];
nc_type datatype = 0;
int dim[100], natts;
long dimlen[100];
long len;
int x_id, y_id;
nc_type xdatatype = 0;
nc_type ydatatype = 0;
int xndims, xdim[10], xnatts;
int yndims, ydim[10], ynatts;
long nx, ny;
int atlen;
char attname[256];
char atcharval[256];
extern int ncopts;
ncopts = 0; /* no crash on error */
set_wait_cursor();
strcpy(fname, xv_getstr(netcdf_file_item));
if ((cdfid = ncopen(fname, NC_NOWRITE)) == -1)
{
errwin("Can't open file.");
goto out2;
}
if (XmListGetSelectedPos(netcdf_listx_item, &pos_list, &pos_cnt))
{
XtVaGetValues(netcdf_listx_item,
XmNselectedItemCount, &cnt,
XmNselectedItems, &s,
NULL);
cs = XmStringCopy(*s);
if (XmStringGetLtoR(cs, charset, &cstr))
{
strcpy(xvar, cstr);
XtFree(cstr);
}
XmStringFree(cs);
}
else
{
errwin("Need to select X, either variable name or INDEX");
goto out1;
}
if (XmListGetSelectedPos(netcdf_listy_item, &pos_list, &pos_cnt))
{
XtVaGetValues(netcdf_listy_item,
XmNselectedItemCount, &cnt,
XmNselectedItems, &s,
NULL);
cs = XmStringCopy(*s);
if (XmStringGetLtoR(cs, charset, &cstr))
{
strcpy(yvar, cstr);
XtFree(cstr);
}
XmStringFree(cs);
}
else
{
errwin("Need to select Y");
goto out1;
}
if (strcmp(xvar, "INDEX") == 0)
{
stufftext("X is the index of the Y variable\n", STUFF_START);
}
else
{
if ((x_id = ncvarid(cdfid, xvar)) == -1)
{
char ebuf[256];
sprintf(ebuf, "do_query(): No such variable %s for X", xvar);
errwin(ebuf);
goto out1;
}
ncvarinq(cdfid, x_id, NULL, &xdatatype, &xndims, xdim, &xnatts);
ncdiminq(cdfid, xdim[0], NULL, &nx);
sprintf(buf, "X is %s, data type %s \t length [%d]\n", xvar, getcdf_type(xdatatype), nx);
stufftext(buf, STUFF_TEXT);
sprintf(buf, "\t%d Attributes:\n", xnatts);
stufftext(buf, STUFF_TEXT);
for (i = 0; i < xnatts; i++)
{
atcharval[0] = 0;
ncattname(cdfid, x_id, i, attname);
ncattinq(cdfid, x_id, attname, &datatype, &atlen);
switch (datatype)
{
case NC_CHAR:
ncattget(cdfid, x_id, attname, (void *)atcharval);
break;
}
sprintf(buf, "\t\t%s: %s\n", attname, atcharval);
stufftext(buf, STUFF_TEXT);
}
}
if ((y_id = ncvarid(cdfid, yvar)) == -1)
{
char ebuf[256];
sprintf(ebuf, "do_query(): No such variable %s for Y", yvar);
errwin(ebuf);
goto out1;
}
ncvarinq(cdfid, y_id, NULL, &ydatatype, &yndims, ydim, &ynatts);
ncdiminq(cdfid, ydim[0], NULL, &ny);
sprintf(buf, "Y is %s, data type %s \t length [%d]\n", yvar, getcdf_type(ydatatype), ny);
stufftext(buf, STUFF_TEXT);
sprintf(buf, "\t%d Attributes:\n", ynatts);
stufftext(buf, STUFF_TEXT);
for (i = 0; i < ynatts; i++)
{
atcharval[0] = 0;
ncattname(cdfid, y_id, i, attname);
ncattinq(cdfid, y_id, attname, &datatype, &atlen);
switch (datatype)
{
case NC_CHAR:
ncattget(cdfid, y_id, attname, (void *)atcharval);
break;
}
sprintf(buf, "\t\t%s: %s\n", attname, atcharval);
stufftext(buf, STUFF_TEXT);
}
out1:
;
ncclose(cdfid);
out2:
;
stufftext("\n", STUFF_STOP);
unset_wait_cursor();
}
int ex_open (const char *path,
int mode,
int *comp_ws,
int *io_ws,
float *version)
{
int exoid;
nclong file_wordsize;
char errmsg[MAX_ERR_LENGTH];
exerrval = 0; /* clear error code */
/* set error handling mode to no messages, non-fatal errors */
ex_opts(exoptval); /* call required to set ncopts first time through */
if (mode == EX_READ) /* READ ONLY */
{
#if defined(__LIBCATAMOUNT__)
if ((exoid = ncopen (path, NC_NOWRITE)) < 0)
#else
if ((exoid = ncopen (path, NC_NOWRITE|NC_SHARE)) < 0)
#endif
{
/* NOTE: netCDF returns an id of -1 on an error - but no error code! */
if (ncerr == 0)
exerrval = EX_FATAL;
else
exerrval = ncerr;
sprintf(errmsg,"Error: failed to open %s read only",path);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
}
else if (mode == EX_WRITE) /* READ/WRITE */
{
#if defined(__LIBCATAMOUNT__)
if ((exoid = ncopen (path, NC_WRITE)) < 0)
#else
if ((exoid = ncopen (path, NC_WRITE|NC_SHARE)) < 0)
#endif
{
/* NOTE: netCDF returns an id of -1 on an error - but no error code! */
if (ncerr == 0)
exerrval = EX_FATAL;
else
exerrval = ncerr;
sprintf(errmsg,"Error: failed to open %s write only",path);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
/* turn off automatic filling of netCDF variables */
if (ncsetfill (exoid, NC_NOFILL) == -1)
{
exerrval = ncerr;
sprintf(errmsg,
"Error: failed to set nofill mode in file id %d",
exoid);
ex_err("ex_open", errmsg, exerrval);
return (EX_FATAL);
}
}
else
{
exerrval = EX_BADFILEMODE;
sprintf(errmsg,"Error: invalid file open mode: %d",mode);
ex_err("ex_open",errmsg,exerrval);
return (EX_FATAL);
}
/* determine version of EXODUS II file, and the word size of
* floating point values stored in the file
*/
if (ncattget (exoid, NC_GLOBAL, ATT_VERSION, version) == -1)
{
exerrval = ncerr;
sprintf(errmsg,"Error: failed to get database version for file id: %d",
exoid);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
/* check ExodusII file version - old version 1.x files are not supported */
if (*version < 2.0)
{
exerrval = EX_FATAL;
sprintf(errmsg,"Error: Unsupported file version %.2f in file id: %d",
*version, exoid);
ex_err("ex_open",errmsg,exerrval);
return(EX_FATAL);
}
if (ncattget (exoid, NC_GLOBAL, ATT_FLT_WORDSIZE, &file_wordsize) == -1)
{ /* try old (prior to db version 2.02) attribute name */
if (ncattget (exoid,NC_GLOBAL,ATT_FLT_WORDSIZE_BLANK,&file_wordsize) == -1)
{
exerrval = EX_FATAL;
sprintf(errmsg,"Error: failed to get file wordsize from file id: %d",
exoid);
ex_err("ex_open",errmsg,exerrval);
return(exerrval);
}
}
/* initialize floating point size conversion.
*/
if (ex_conv_ini( exoid, comp_ws, io_ws, file_wordsize ) != EX_NOERR ) {
exerrval = EX_FATAL;
sprintf(errmsg,
"Error: failed to init conversion routines in file id %d",
exoid);
ex_err("ex_open", errmsg, exerrval);
return (EX_FATAL);
}
return (exoid);
}
void update_netcdfs(void)
{
int i, j;
char buf[256], fname[512];
XmString xms;
int cdfid; /* netCDF id */
int ndims, nvars, ngatts, recdim;
int var_id;
long start[2];
long count[2];
char varname[256];
nc_type datatype = 0;
int dim[100], natts;
long dimlen[100];
long len;
extern int ncopts;
ncopts = 0; /* no crash on error */
if (netcdf_frame != NULL)
{
strcpy(fname, xv_getstr(netcdf_file_item));
set_wait_cursor();
XmListDeleteAllItems(netcdf_listx_item);
XmListDeleteAllItems(netcdf_listy_item);
xms = XmStringCreateLtoR("INDEX", charset);
XmListAddItemUnselected(netcdf_listx_item, xms, 0);
XmStringFree(xms);
if (strlen(fname) < 2)
{
unset_wait_cursor();
return;
}
if ((cdfid = ncopen(fname, NC_NOWRITE)) == -1)
{
errwin("Can't open file.");
unset_wait_cursor();
return;
}
ncinquire(cdfid, &ndims, &nvars, &ngatts, &recdim);
/*
printf("%d %d %d %d\n", ndims, nvars, ngatts, recdim);
*/
for (i = 0; i < ndims; i++)
{
ncdiminq(cdfid, i, NULL, &dimlen[i]);
}
for (i = 0; i < nvars; i++)
{
ncvarinq(cdfid, i, varname, &datatype, &ndims, dim, &natts);
if ((var_id = ncvarid(cdfid, varname)) == -1)
{
char ebuf[256];
sprintf(ebuf, "update_netcdfs(): No such variable %s", varname);
errwin(ebuf);
continue;
}
if (ndims != 1)
{
continue;
}
ncdiminq(cdfid, dim[0], (char *)NULL, &len);
sprintf(buf, "%s", varname);
xms = XmStringCreateLtoR(buf, charset);
XmListAddItemUnselected(netcdf_listx_item, xms, 0);
XmListAddItemUnselected(netcdf_listy_item, xms, 0);
XmStringFree(xms);
}
ncclose(cdfid);
unset_wait_cursor();
}
}
int main(int argc, char *argv[])
{
char const *wks_type = "x11";
int appid,wid,vcid,vfid, sfid, mpid;
int rlist;
float U[73][73],V[73][73], PSL[73][73];
char smindist0[6] ;
char smindist1[5] ;
char smindist2[4] ;
char title[35];
char smindist[7] ;
char slongitude[100] ;
/*
* Declare variables for getting information from netCDF file.
*/
int uv, p, u_id, v_id, p_id, lon_id, lat_id, FRAME_COUNT;
int i, mindistval, longitudeval;
ng_size_t icount[3];
float val;
long start[2], count[2], lonlen, latlen;
float CenLonF;
char filenameUV[256];
char filenamePsl[256];
const char *dirUV = _NGGetNCARGEnv("data");
const char *dirPsl = _NGGetNCARGEnv("data");
/*
* Generate vector data array
*/
FRAME_COUNT=13;
/*
* Open the netCDF file.
*/
sprintf( filenameUV, "%s/cdf/941110_UV.cdf", dirUV );
uv = ncopen(filenameUV,NC_NOWRITE);
/*
* Open the netCDF file.
*/
sprintf( filenamePsl, "%s/cdf/941110_P.cdf", dirPsl );
p = ncopen(filenamePsl,NC_NOWRITE);
/*
* Initialize the high level utility library
*/
NhlInitialize();
/*
* Create an application context. Set the app dir to the current
* directory so the application looks for a resource file in the working
* directory.
*/
rlist = NhlRLCreate(NhlSETRL);
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNappUsrDir,"./");
NhlCreate(&appid,"vc06",NhlappClass,NhlDEFAULT_APP,rlist);
if (!strcmp(wks_type,"ncgm") || !strcmp(wks_type,"NCGM")) {
/*
* Create a meta file workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkMetaName,"./vc06c.ncgm");
NhlCreate(&wid,"vc06Work",
NhlncgmWorkstationClass,NhlDEFAULT_APP,rlist);
}
else if (!strcmp(wks_type,"x11") || !strcmp(wks_type,"X11")) {
/*
* Create an X workstation.
*/
NhlRLClear(rlist);
NhlRLSetInteger(rlist,NhlNwkPause,True);
NhlCreate(&wid,"vc06Work",NhlcairoWindowWorkstationClass,appid,rlist);
}
else if (!strcmp(wks_type,"oldps") || !strcmp(wks_type,"OLDPS")) {
/*
* Create an older-style PostScript workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkPSFileName,"vc06c.ps");
NhlCreate(&wid,"vc06Work",NhlpsWorkstationClass,appid,rlist);
}
else if (!strcmp(wks_type,"oldpdf") || !strcmp(wks_type,"OLDPDF")) {
/*
* Create an older-style PDF workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkPDFFileName,"vc06c.pdf");
NhlCreate(&wid,"vc06Work",NhlpdfWorkstationClass,appid,rlist);
}
else if (!strcmp(wks_type,"pdf") || !strcmp(wks_type,"PDF") ||
!strcmp(wks_type,"ps") || !strcmp(wks_type,"PS")) {
/*
* Create a cairo PS/PDF workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkFileName,"vc06c");
NhlRLSetString(rlist,NhlNwkFormat,(char*)wks_type);
NhlCreate(&wid,"vc06Work",NhlcairoDocumentWorkstationClass,appid,rlist);
}
else if (!strcmp(wks_type,"png") || !strcmp(wks_type,"PNG")) {
/*
* Create a cairo PNG workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkFileName,"vc06c");
NhlRLSetString(rlist,NhlNwkFormat,(char*)wks_type);
NhlCreate(&wid,"vc06Work",NhlcairoImageWorkstationClass,appid,rlist);
}
/*
* Get the U and V and lat/lon dimensions.
*/
lat_id = ncdimid(uv,"lat");
lon_id = ncdimid(uv,"lon");
u_id = ncvarid(uv,"u");
v_id = ncvarid(uv,"v");
ncdiminq(uv,lat_id,(char *)0,&latlen);
ncdiminq(uv,lon_id,(char *)0,&lonlen);
start[0] = start[1] = 0;
count[0] = latlen; count[1] = lonlen;
ncvarget(uv,u_id,(long const *)start,(long const *)count,U);
ncvarget(uv,v_id,(long const *)start,(long const *)count,V);
/*
* Create a VectorField data object using the data set defined above.
* By default the array bounds will define the data boundaries (zero-based,
* as in C language conventions)
*/
icount[0] = latlen; icount[1] = lonlen;
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNvfUDataArray,&U[0][0],2,icount);
NhlRLSetMDFloatArray(rlist,NhlNvfVDataArray,&V[0][0],2,icount);
NhlRLSetFloat(rlist,NhlNvfXCStartV, -180.0);
NhlRLSetFloat(rlist,NhlNvfXCEndV, 180.0);
NhlRLSetFloat(rlist,NhlNvfYCStartV,-90.0);
NhlRLSetFloat(rlist,NhlNvfYCEndV, 90.0);
NhlCreate(&vfid,"vectorfield",NhlvectorFieldClass,appid,rlist);
/*
* Get the PSL and lat/lon dimensions.
*/
lat_id = ncdimid(p,"lat");
lon_id = ncdimid(p,"lon");
p_id = ncvarid(p,"Psl");
ncdiminq(p,lat_id,(char *)0,&latlen);
ncdiminq(p,lon_id,(char *)0,&lonlen);
start[0] = start[1] = 0;
count[0] = latlen; count[1] = lonlen;
ncvarget(p,p_id,(long const *)start,(long const *)count,PSL);
icount[0] = latlen; icount[1] = lonlen;
NhlRLClear(rlist);
NhlRLSetMDFloatArray(rlist,NhlNsfDataArray,&PSL[0][0],2,icount);
NhlRLSetFloat(rlist,NhlNsfXCStartV, -180.0);
NhlRLSetFloat(rlist,NhlNsfXCEndV, 180.0);
NhlRLSetFloat(rlist,NhlNsfYCStartV, -90.0);
NhlRLSetFloat(rlist,NhlNsfYCEndV, 90.0);
NhlCreate(&sfid,"scalarfield",NhlscalarFieldClass,appid,rlist);
/*
* Create a VectorPlot object, supplying the VectorField object as data
* Setting vcMonoFillArrowFillColor False causes VectorPlot to color the
* vector arrows individually based, by default, on the vector magnitude.
* Also supply the ScalarField object that will be used to determine the
* color of each individual vector arrow.
* Setting vcMonoVectorLineColor False causes VectorPlot to color the
* vector arrows individually and setting vcUseScalarArray True results
* in VectorPlot applying the colors based on the contents of the scalarfield.
*/
NhlRLClear(rlist);
NhlRLSetFloat(rlist,NhlNvcRefMagnitudeF, 20.0);
NhlRLSetString(rlist,NhlNvcUseScalarArray, "True");
NhlRLSetString(rlist,NhlNvcFillArrowsOn, "True");
NhlRLSetString(rlist,NhlNvcMonoFillArrowFillColor, "False");
NhlRLSetFloat(rlist,NhlNvcMinFracLengthF, 0.25);
NhlRLSetInteger(rlist,NhlNvcVectorFieldData,vfid);
NhlRLSetInteger(rlist,NhlNvcScalarFieldData,sfid);
NhlCreate(&vcid,"vectorplot",NhlvectorPlotClass,wid,rlist);
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNmpProjection, "ORTHOGRAPHIC");
NhlRLSetFloat(rlist,NhlNmpCenterLatF, 50);
NhlCreate(&mpid,"mapplot",NhlmapPlotClass,wid,rlist);
NhlAddOverlay(mpid,vcid, -1);
/*
* Strings used to create fixed length numbers
*/
strcpy(smindist0 ,"0.000");
strcpy(smindist1 ,"0.00");
strcpy( smindist2 ,"0.0");
/*
* Create FRAME_COUNT frames, increasing the value of vcMinDistanceF
* and decreasing the value of mpCenterLonF at each successive frame.
*
* Note that the first frame and the last frame are equivalent in
* longitude.
*/
for(i = (FRAME_COUNT-1);i > -1; i--){
NhlRLClear(rlist);
CenLonF = i * 360./(FRAME_COUNT-1);
NhlRLSetFloat(rlist,NhlNmpCenterLonF,CenLonF);
NhlSetValues(mpid,rlist);
/*
* create fixed length strings representing the current longitude
* and the value of vcMinDistanceF
*/
longitudeval = (int)(i * 360./(FRAME_COUNT-1) + 0.5);
sprintf(slongitude,"%d:S:o:N:",longitudeval);
val = ((FRAME_COUNT-1) - i) * 0.0175/(FRAME_COUNT-1);
mindistval = (int)(10000*val + 0.5);
if (mindistval < 10){
sprintf(smindist,"%s%d",smindist0,mindistval);
}
else {
if (mindistval < 100){
sprintf(smindist,"%s%d",smindist1,mindistval);
}
else {
sprintf(smindist,"%s%d",smindist2,mindistval);
}
}
NhlRLClear(rlist);
strcpy(title,"Varying vcMinDistanceF :: ");
strcat(title,smindist);
NhlRLSetString(rlist,NhlNtiMainString,title);
NhlRLSetString(rlist,NhlNtiXAxisString,slongitude);
NhlRLSetFloat(rlist,NhlNvcMinDistanceF,val);
NhlSetValues(vcid,rlist);
NhlDraw(mpid);
NhlFrame(wid);
}/*end for*/
/*
* Destroy the objects created, close the HLU library and exit.
*/
NhlDestroy(mpid);
NhlDestroy(wid);
NhlDestroy(appid);
NhlClose();
exit(0);
}
int main()
{
/*
* Declare variables for the HLU routine calls.
*/
int appid, workid, field1, con1;
int srlist, i, j, k;
ng_size_t icount[2];
float cmap[NCOLORS][3];
/*
* Declare variables for getting information from netCDF file.
*/
int ncid, lon_id, lat_id, level_id, temp_id;
float temp[10][33], special_value;
float lon[36], lat[33], level[10];
float min_lat, min_level, max_lat, max_level;
long start[4], count[4], lonlen, latlen, levellen;
char filename[256], string[50];
const char *dir = _NGGetNCARGEnv("data");
/*
* Default is to create an NCGM file.
*/
char const *wks_type = "ncgm";
/*
* Initialize the HLU library and set up resource template.
*/
NhlInitialize();
srlist = NhlRLCreate(NhlSETRL);
/*
* Create Application object.
*/
NhlRLClear(srlist);
NhlRLSetString(srlist,NhlNappDefaultParent,"True");
NhlRLSetString(srlist,NhlNappUsrDir,"./");
NhlCreate(&appid,"cn08",NhlappClass,NhlDEFAULT_APP,srlist);
cmap[0][0] = 0.0; cmap[0][1] = 0.0; cmap[0][2] = 0.0;
cmap[1][0] = 1.0; cmap[1][1] = 1.0; cmap[1][2] = 1.0;
cmap[2][0] = 1.0; cmap[2][1] = 1.0; cmap[2][2] = 1.0;
cmap[3][0] = 1.0; cmap[3][1] = 0.0; cmap[3][2] = 0.0;
cmap[4][0] = 0.0; cmap[4][1] = 1.0; cmap[4][2] = 0.0;
cmap[5][0] = 0.0; cmap[5][1] = 0.0; cmap[5][2] = 1.0;
cmap[6][0] = 1.0; cmap[6][1] = 1.0; cmap[6][2] = 0.0;
cmap[7][0] = 0.0; cmap[7][1] = 1.0; cmap[7][2] = 1.0;
cmap[8][0] = 1.0; cmap[8][1] = 0.0; cmap[8][2] = 1.0;
cmap[9][0] = 0.5; cmap[9][1] = 0.0; cmap[9][2] = 0.0;
cmap[10][0] = 0.5; cmap[10][1] = 1.0; cmap[10][2] = 1.0;
cmap[11][0] = 0.0; cmap[11][1] = 0.0; cmap[11][2] = 0.5;
cmap[12][0] = 1.0; cmap[12][1] = 1.0; cmap[12][2] = 0.5;
cmap[13][0] = 0.5; cmap[13][1] = 0.0; cmap[13][2] = 1.0;
cmap[14][0] = 1.0; cmap[14][1] = 0.5; cmap[14][2] = 0.0;
cmap[15][0] = 0.0; cmap[15][1] = 0.5; cmap[15][2] = 1.0;
cmap[16][0] = 0.5; cmap[16][1] = 1.0; cmap[16][2] = 0.0;
cmap[17][0] = 0.5; cmap[17][1] = 0.0; cmap[17][2] = 0.5;
cmap[18][0] = 0.5; cmap[18][1] = 1.0; cmap[18][2] = 0.5;
cmap[19][0] = 1.0; cmap[19][1] = 0.5; cmap[19][2] = 1.0;
cmap[20][0] = 0.0; cmap[20][1] = 0.5; cmap[20][2] = 0.0;
cmap[21][0] = 0.5; cmap[21][1] = 0.5; cmap[21][2] = 1.0;
cmap[22][0] = 1.0; cmap[22][1] = 0.0; cmap[22][2] = 0.5;
icount[0] = NCOLORS;
icount[1] = 3;
if (!strcmp(wks_type,"ncgm") || !strcmp(wks_type,"NCGM")) {
/*
* Create a meta file object.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkMetaName,"./cn08c.ncgm");
NhlCreate(&workid,"cn08Work",NhlncgmWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"x11") || !strcmp(wks_type,"X11")) {
/*
* Create an X11 workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkPause,"True");
NhlCreate(&workid,"cn08Work",NhlcairoWindowWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"oldps") || !strcmp(wks_type,"OLDPS")) {
/*
* Create an older-style PostScript workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkPSFileName,"./cn08c.ps");
NhlCreate(&workid,"cn08Work",NhlpsWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"oldpdf") || !strcmp(wks_type,"OLDPDF")) {
/*
* Create an older-style PDF workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkPDFFileName,"./cn08c.pdf");
NhlCreate(&workid,"cn08Work",NhlpdfWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"pdf") || !strcmp(wks_type,"PDF") ||
!strcmp(wks_type,"ps") || !strcmp(wks_type,"PS")) {
/*
* Create a cairo PS/PDF workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkFileName,"./cn08c");
NhlRLSetString(srlist,NhlNwkFormat,(char*)wks_type);
NhlCreate(&workid,"cn08Work",NhlcairoDocumentWorkstationClass,
NhlDEFAULT_APP,srlist);
}
else if (!strcmp(wks_type,"png") || !strcmp(wks_type,"PNG")) {
/*
* Create a cairo PNG workstation.
*/
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNwkColorMap,&cmap[0][0],2,icount);
NhlRLSetString(srlist,NhlNwkFileName,"./cn08c");
NhlRLSetString(srlist,NhlNwkFormat,(char*)wks_type);
NhlCreate(&workid,"cn08Work",NhlcairoImageWorkstationClass,
NhlDEFAULT_APP,srlist);
}
/*
* Open data file containing grid of global temperatures.
*/
sprintf( filename, "%s/cdf/contour.cdf", dir );
ncid = ncopen(filename,NC_NOWRITE);
/*
* Get the lat/lon/level dimensions.
*/
lat_id = ncdimid(ncid,"lat");
lon_id = ncdimid(ncid,"lon");
level_id = ncdimid(ncid,"level");
ncdiminq(ncid,lat_id,(char *)0,&latlen);
ncdiminq(ncid,lon_id,(char *)0,&lonlen);
ncdiminq(ncid,level_id,(char *)0,&levellen);
/*
* Read in temperature values and convert from degrees F to degrees K.
*/
temp_id = ncvarid(ncid,"T");
start[0] = start[1] = start[2] = start[3] = 0;
count[0] = 1; count[1] = levellen; count[2] = latlen; count[3] = 1;
ncvarget(ncid,temp_id,(long const *)start,(long const *)count,temp);
ncattget(ncid,temp_id,"_FillValue",&special_value);
for( j = 0; j < levellen; j++ ) {
for( k = 0; k < latlen; k++ ) {
temp[j][k] = (temp[j][k] - 273.15) * 9./5. + 32.;
}
}
/*
* Read in lat/lon/level values.
*/
lat_id = ncvarid(ncid,"lat");
count[0] = latlen;
ncvarget(ncid,lat_id,(long const *)start,(long const *)count,lat);
lon_id = ncvarid(ncid,"lon");
count[0] = lonlen;
ncvarget(ncid,lon_id,(long const *)start,(long const *)count,lon);
level_id = ncvarid(ncid,"level");
count[0] = levellen;
ncvarget(ncid,level_id,(long const *)start,(long const *)count,level);
/*
* Set up initial scalar field with longitude of temperature data.
*/
icount[0] = levellen; icount[1] = latlen;
NhlRLClear(srlist);
NhlRLSetMDFloatArray(srlist,NhlNsfDataArray,&temp[0][0],2,icount);
NhlRLSetFloat(srlist,NhlNsfMissingValueV,special_value);
NhlRLSetFloat(srlist,NhlNsfXCStartV,lat[0]);
NhlRLSetFloat(srlist,NhlNsfXCEndV,lat[latlen-1]);
NhlRLSetFloatArray(srlist,NhlNsfXArray,lat,latlen);
NhlRLSetFloatArray(srlist,NhlNsfYArray,level,levellen);
NhlCreate(&field1,"field1",NhlscalarFieldClass,appid,srlist);
/*
* Determine extents of grid
*/
if(lat[0] < lat[latlen-1]) {
min_lat = lat[0];
max_lat = lat[latlen-1];
}
else {
max_lat = lat[0];
min_lat = lat[latlen-1];
}
if(level[0] < level[levellen-1]) {
min_level = level[0];
max_level = level[levellen-1];
}
else {
max_level = level[0];
min_level = level[levellen-1];
}
/*
* Create contour using manual spacing.
*/
NhlRLClear(srlist);
NhlRLSetFloat(srlist,NhlNvpXF,.2);
NhlRLSetFloat(srlist,NhlNvpYF,.8);
NhlRLSetFloat(srlist,NhlNvpWidthF, .6);
NhlRLSetFloat(srlist,NhlNvpHeightF, .6);
NhlRLSetString(srlist,NhlNcnFillOn, "True");
NhlRLSetInteger(srlist,NhlNcnScalarFieldData, field1);
NhlRLSetString(srlist,NhlNcnLevelSelectionMode, "ManualLevels");
NhlRLSetInteger(srlist,NhlNcnMaxLevelCount, 25);
NhlRLSetFloat(srlist,NhlNcnMinLevelValF, -80.0);
NhlRLSetFloat(srlist,NhlNcnMaxLevelValF, 110.0);
NhlRLSetFloat(srlist,NhlNcnLevelSpacingF, 10.0);
NhlRLSetFloat(srlist,NhlNtrXMinF, min_lat);
NhlRLSetFloat(srlist,NhlNtrXMaxF, max_lat);
NhlRLSetFloat(srlist,NhlNtrYMinF, min_level);
NhlRLSetFloat(srlist,NhlNtrYMaxF, max_level);
NhlRLSetString(srlist,NhlNtrYReverse, "True");
sprintf(string,"Longitude %g Degrees", lon[0] );
NhlRLSetString(srlist,NhlNtiMainString,string);
NhlCreate(&con1,"con1",NhlcontourPlotClass,workid,srlist);
/*
* Draw first step
*/
NhlDraw(con1);
NhlFrame(workid);
/*
* Loop on remaining longitude values and reset the title every
* iteration.
*/
for( i = 1; i <= lonlen-1; i++ ) {
/*
* Read in temperature values and convert from degrees F to degrees K.
*/
start[0] = start[1] = start[2] = 0;
start[3] = i;
count[0] = 1; count[1] = levellen;
count[2] = latlen; count[3] = 1;
ncvarget(ncid,temp_id,(long const *)start,(long const *)count,
temp);
for( j = 0; j < levellen; j++ ) {
for( k = 0; k < latlen; k++ ) {
temp[j][k] = (temp[j][k] - 273.15) * 9./5. + 32.;
}
}
NhlRLClear(srlist);
icount[0] = levellen; icount[1] = latlen;
NhlRLSetMDFloatArray(srlist,NhlNsfDataArray,&temp[0][0],2,icount);
/*
* Create new scalar field.
*/
NhlSetValues(field1,srlist);
NhlRLClear(srlist);
sprintf(string,"Longitude %g Degrees", lon[i] );
NhlRLSetString(srlist,NhlNtiMainString,string);
NhlSetValues(con1,srlist);
NhlDraw(con1);
NhlFrame(workid);
}
/*
* Close the netCDF file.
*/
ncclose(ncid);
/*
* NhlDestroy destroys the given id and all of its children.
*/
NhlRLDestroy(srlist);
NhlDestroy(appid);
/*
* Restores state.
*/
NhlClose();
exit(0);
}
void
mexFunction (
INT nlhs,
Matrix * plhs[],
INT nrhs,
const Matrix * prhs[]
)
{
char * opname;
OPCODE opcode;
Matrix * mat;
int status;
char * path;
int cmode;
int mode;
int cdfid;
int ndims;
int nvars;
int natts;
int recdim;
char * name;
long length;
int dimid;
nc_type datatype;
int * dim;
int varid;
long * coords;
VOIDP value;
long * start;
long * count;
int * intcount;
long * stride;
long * imap;
long recnum;
int nrecvars;
int * recvarids;
long * recsizes;
VOIDPP datap; /* pointers for record access. */
int len;
int incdf;
int invar;
int outcdf;
int outvar;
int attnum;
char * attname;
char * newname;
int fillmode;
int i;
int m;
int n;
char * p;
char buffer[MAX_BUFFER];
DOUBLE * pr;
DOUBLE addoffset;
DOUBLE scalefactor;
int autoscale; /* do auto-scaling if this flag is non-zero. */
/* Disable the NC_FATAL option from ncopts. */
if (ncopts & NC_FATAL) {
ncopts -= NC_FATAL;
}
/* Display usage if less than one input argument. */
if (nrhs < 1) {
Usage();
return;
}
/* Convert the operation name to its opcode. */
opname = Mat2Str(prhs[0]);
for (i = 0; i < strlen(opname); i++) {
opname[i] = (char) tolower((int) opname[i]);
}
p = opname;
if (strncmp(p, "nc", 2) == 0) { /* Trim away "nc". */
p += 2;
}
i = 0;
opcode = NONE;
while (ops[i].opcode != NONE) {
if (!strcmp(p, ops[i].opname)) {
opcode = ops[i].opcode;
if (ops[i].nrhs > nrhs) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few input arguments.\n");
}
else if (0 && ops[i].nlhs > nlhs) { /* Disabled. */
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: Too few output arguments.\n");
}
break;
}
else {
i++;
}
}
if (opcode == NONE) {
mexPrintf("MEXCDF: opname = %s\n", opname);
mexErrMsgTxt("MEXCDF: No such operation.\n");
}
Free((VOIDPP) & opname);
/* Extract the cdfid by number. */
switch (opcode) {
case USAGE:
case CREATE:
case OPEN:
case TYPELEN:
case SETOPTS:
case ERR:
case PARAMETER:
break;
default:
cdfid = Scalar2Int(prhs[1]);
break;
}
/* Extract the dimid by number or name. */
switch (opcode) {
case DIMINQ:
case DIMRENAME:
if (mxIsNumeric(prhs[2])) {
dimid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
Free((VOIDPP) & name);
}
break;
default:
break;
}
/* Extract the varid by number or name. */
switch (opcode) {
case VARINQ:
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
case VARRENAME:
case VARCOPY:
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTNAME:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[2])) {
varid = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
if (varid == -1) {
varid = Parameter(prhs[2]);
}
}
break;
default:
break;
}
/* Extract the attname by name or number. */
switch (opcode) {
case ATTPUT:
case ATTINQ:
case ATTGET:
case ATTCOPY:
case ATTRENAME:
case ATTDEL:
if (mxIsNumeric(prhs[3])) {
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
}
else {
attname = Mat2Str(prhs[3]);
}
break;
default:
break;
}
/* Extract the "add_offset" and "scale_factor" attributes. */
switch (opcode) {
case VARPUT1:
case VARGET1:
case VARPUT:
case VARGET:
case VARPUTG:
case VARGETG:
addoffset = Add_Offset(cdfid, varid);
scalefactor = Scale_Factor(cdfid, varid);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
break;
default:
break;
}
/* Perform the NetCDF operation. */
switch (opcode) {
case USAGE:
Usage();
break;
case CREATE:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
cmode = Parameter(prhs[2]);
}
else {
cmode = NC_NOCLOBBER; /* Default. */
}
cdfid = nccreate(path, cmode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case OPEN:
path = Mat2Str(prhs[1]);
if (nrhs > 2) {
mode = Parameter(prhs[2]);
}
else {
mode = NC_NOWRITE; /* Default. */
}
cdfid = ncopen(path, mode);
plhs[0] = Int2Scalar(cdfid);
plhs[1] = Int2Scalar((cdfid >= 0) ? 0 : -1);
Free((VOIDPP) & path);
break;
case REDEF:
status = ncredef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ENDEF:
status = ncendef(cdfid);
plhs[0] = Int2Scalar(status);
break;
case CLOSE:
status = ncclose(cdfid);
plhs[0] = Int2Scalar(status);
break;
case INQUIRE:
status = ncinquire(cdfid, & ndims, & nvars, & natts, & recdim);
if (nlhs > 1) {
plhs[0] = Int2Scalar(ndims);
plhs[1] = Int2Scalar(nvars);
plhs[2] = Int2Scalar(natts);
plhs[3] = Int2Scalar(recdim);
plhs[4] = Int2Scalar(status);
}
else { /* Default to 1 x 5 row vector. */
plhs[0] = mxCreateFull(1, 5, REAL);
pr = mxGetPr(plhs[0]);
if (status == 0) {
pr[0] = (DOUBLE) ndims;
pr[1] = (DOUBLE) nvars;
pr[2] = (DOUBLE) natts;
pr[3] = (DOUBLE) recdim;
}
pr[4] = (DOUBLE) status;
}
break;
case SYNC:
status = ncsync(cdfid);
plhs[0] = Int2Scalar(status);
break;
case ABORT:
status = ncabort(cdfid);
plhs[0] = Int2Scalar(status);
break;
case DIMDEF:
name = Mat2Str(prhs[2]);
length = Parameter(prhs[3]);
dimid = ncdimdef(cdfid, name, length);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMID:
name = Mat2Str(prhs[2]);
dimid = ncdimid(cdfid, name);
plhs[0] = Int2Scalar(dimid);
plhs[1] = Int2Scalar((dimid >= 0) ? 0 : dimid);
Free((VOIDPP) & name);
break;
case DIMINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncdiminq(cdfid, dimid, name, & length);
plhs[0] = Str2Mat(name);
plhs[1] = Long2Scalar(length);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case DIMRENAME:
name = Mat2Str(prhs[3]);
status = ncdimrename(cdfid, dimid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARDEF:
name = Mat2Str(prhs[2]);
datatype = (nc_type) Parameter(prhs[3]);
ndims = Scalar2Int(prhs[4]);
if (ndims == -1) {
ndims = Count(prhs[5]);
}
dim = Mat2Int(prhs[5]);
varid = ncvardef(cdfid, name, datatype, ndims, dim);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARID:
name = Mat2Str(prhs[2]);
varid = ncvarid(cdfid, name);
Free((VOIDPP) & name);
plhs[0] = Int2Scalar(varid);
plhs[1] = Int2Scalar((varid >= 0) ? 0 : varid);
break;
case VARINQ:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
plhs[0] = Str2Mat(name);
plhs[1] = Int2Scalar(datatype);
plhs[2] = Int2Scalar(ndims);
plhs[3] = Int2Mat(dim, 1, ndims);
plhs[4] = Int2Scalar(natts);
plhs[5] = Int2Scalar(status);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
break;
case VARPUT1:
coords = Mat2Long(prhs[3]);
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[4]);
}
else {
mat = prhs[4];
}
if (mat == NULL) {
mat = prhs[4];
}
pr = mxGetPr(mat);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
status = ncvarput1(cdfid, varid, coords, buffer);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARGET1:
coords = Mat2Long(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
mat = Int2Scalar(0);
pr = mxGetPr(mat);
status = ncvarget1(cdfid, varid, coords, buffer);
status = Convert(opcode, datatype, 1, buffer, scalefactor, addoffset, pr);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & coords);
break;
case VARPUT:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
autoscale = (nrhs > 6 && Scalar2Int(prhs[6]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[5]);
}
else {
mat = prhs[5];
}
if (mat == NULL) {
mat = prhs[5];
}
pr = mxGetPr(mat);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarput(cdfid, varid, start, count, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & start);
Free((VOIDPP) & count);
break;
case VARGET:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
autoscale = (nrhs > 5 && Scalar2Int(prhs[5]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvarget(cdfid, varid, start, count, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
plhs[0] = mat;
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARPUTG:
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
if (nrhs > 7) {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[7]);
}
else {
mat = prhs[7];
}
if (mat == NULL) {
mat = prhs[7];
}
}
else {
if (datatype == NC_CHAR) {
mat = SetStr(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
}
pr = mxGetPr(mat);
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
len = 0;
if (ndims > 0) {
len = 1;
for (i = 0; i < ndims; i++) {
len *= count[i];
}
}
autoscale = (nrhs > 8 && Scalar2Int(prhs[8]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
status = ncvarputg(cdfid, varid, start, count, stride, imap, value);
Free((VOIDPP) & value);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARGETG:
start = Mat2Long(prhs[3]);
count = Mat2Long(prhs[4]);
intcount = Mat2Int(prhs[4]);
stride = Mat2Long(prhs[5]);
imap = NULL;
autoscale = (nrhs > 7 && Scalar2Int(prhs[7]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
name = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
dim = (int *) mxCalloc(MAX_NC_DIMS, sizeof(int));
status = ncvarinq(cdfid, varid, name, & datatype, & ndims, dim, & natts);
datatype = RepairBadDataType(datatype);
for (i = 0; i < ndims; i++) {
if (count[i] == -1) {
status = ncdiminq(cdfid, dim[i], name, & count[i]);
count[i] -= start[i];
}
}
Free((VOIDPP) & name);
Free((VOIDPP) & dim);
m = 0;
n = 0;
if (ndims > 0) {
m = count[0];
n = count[0];
for (i = 1; i < ndims; i++) {
n *= count[i];
if (count[i] > 1) {
m = count[i];
}
}
n /= m;
}
len = m * n;
if (ndims < 2) {
m = 1;
n = len;
}
for (i = 0; i < ndims; i++) {
intcount[i] = count[ndims-i-1]; /* Reverse order. */
}
if (MEXCDF_4 || ndims < 2) {
mat = mxCreateFull(m, n, mxREAL); /* mxCreateDoubleMatrix */
}
# if MEXCDF_5
else {
mat = mxCreateNumericArray(ndims, intcount, mxDOUBLE_CLASS, mxREAL);
}
# endif
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncvargetg(cdfid, varid, start, count, stride, imap, value);
status = Convert(opcode, datatype, len, value, scalefactor, addoffset, pr);
Free((VOIDPP) & value);
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[0] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & stride);
Free((VOIDPP) & intcount);
Free((VOIDPP) & count);
Free((VOIDPP) & start);
break;
case VARRENAME:
name = Mat2Str(prhs[3]);
status = ncvarrename(cdfid, varid, name);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & name);
break;
case VARCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[3]);
outvar = -1;
/* outvar = ncvarcopy(incdf, invar, outcdf); */
plhs[0] = Int2Scalar(outvar);
plhs[1] = Int2Scalar((outvar >= 0) ? 0 : outvar);
break;
case ATTPUT:
datatype = (nc_type) Parameter(prhs[4]);
datatype = RepairBadDataType(datatype);
if (datatype == NC_CHAR) {
mat = SetNum(prhs[6]);
}
else {
mat = prhs[6];
}
if (mat == NULL) {
mat = prhs[6];
}
len = Scalar2Int(prhs[5]);
if (len == -1) {
len = Count(mat);
}
pr = mxGetPr(mat);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
status = ncattput(cdfid, varid, attname, datatype, len, value);
if (value != NULL) {
Free((VOIDPP) & value);
}
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTINQ:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
plhs[0] = Int2Scalar((int) datatype);
plhs[1] = Int2Scalar(len);
plhs[2] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTGET:
status = ncattinq(cdfid, varid, attname, & datatype, & len);
datatype = RepairBadDataType(datatype);
value = (VOIDP) mxCalloc(len, nctypelen(datatype));
status = ncattget(cdfid, varid, attname, value);
mat = mxCreateDoubleMatrix(1, len, mxREAL);
pr = mxGetPr(mat);
status = Convert(opcode, datatype, len, value, (DOUBLE) 1.0, (DOUBLE) 0.0, pr);
if (value != NULL) {
Free((VOIDPP) & value);
}
if (datatype == NC_CHAR) {
plhs[0] = SetStr(mat);
}
else {
plhs[0] = mat;
}
if (plhs[0] == NULL) {
/* prhs[4] = mat; */
plhs[0] = mat; /* ZYDECO 24Jan2000 */
}
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTCOPY:
incdf = cdfid;
invar = varid;
outcdf = Scalar2Int(prhs[4]);
if (mxIsNumeric(prhs[5])) {
outvar = Scalar2Int(prhs[2]);
}
else {
name = Mat2Str(prhs[5]);
outvar = ncvarid(cdfid, name);
Free((VOIDPP) & name);
}
status = ncattcopy(incdf, invar, attname, outcdf, outvar);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTNAME:
attnum = Scalar2Int(prhs[3]);
attname = (char *) mxCalloc(MAX_NC_NAME, sizeof(char));
status = ncattname(cdfid, varid, attnum, attname);
plhs[0] = Str2Mat(attname);
plhs[1] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case ATTRENAME:
newname = Mat2Str(prhs[4]);
status = ncattrename(cdfid, varid, attname, newname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
Free((VOIDPP) & newname);
break;
case ATTDEL:
status = ncattdel(cdfid, varid, attname);
plhs[0] = Int2Scalar(status);
Free((VOIDPP) & attname);
break;
case RECPUT:
recnum = Scalar2Long(prhs[2]);
pr = mxGetPr(prhs[3]);
autoscale = (nrhs > 4 && Scalar2Int(prhs[4]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if (Count(prhs[3]) < n) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[0] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
p = (char *) value;
pr = mxGetPr(prhs[3]);
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
status = ncrecput(cdfid, recnum, datap);
plhs[0] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECGET:
recnum = Scalar2Long(prhs[2]);
autoscale = (nrhs > 3 && Scalar2Int(prhs[3]) != 0);
if (!autoscale) {
scalefactor = 1.0;
addoffset = 0.0;
}
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
datap = (VOIDPP) mxCalloc(MAX_VAR_DIMS, sizeof(VOIDP));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status == -1) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[1] = Int2Scalar(status);
break;
}
if (nrecvars == 0) {
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
plhs[0] = mxCreateFull(0, 0, REAL);
break;
}
length = 0;
n = 0;
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
length += recsizes[i];
n += (recsizes[i] / nctypelen(datatype));
}
if ((value = (VOIDP) mxCalloc((int) length, sizeof(char))) == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
if (value == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
length = 0;
p = value;
for (i = 0; i < nrecvars; i++) {
datap[i] = p;
p += recsizes[i];
}
if ((status = ncrecget(cdfid, recnum, datap)) == -1) {
plhs[1] = Int2Scalar(status);
break;
}
m = 1;
plhs[0] = mxCreateFull(m, n, REAL);
if (plhs[0] == NULL) {
status = -1;
plhs[1] = Int2Scalar(status);
break;
}
pr = mxGetPr(plhs[0]);
p = (char *) value;
for (i = 0; i < nrecvars; i++) {
status = ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
if (status == -1) {
plhs[1] = Int2Scalar(status);
break;
}
length = recsizes[i] / nctypelen(datatype);
if (autoscale) {
addoffset = Add_Offset(cdfid, recvarids[i]);
scalefactor = Scale_Factor(cdfid, recvarids[i]);
if (scalefactor == 0.0) {
scalefactor = 1.0;
}
}
Convert(opcode, datatype, length, (VOIDP) p, scalefactor, addoffset, pr);
pr += length;
p += recsizes[i];
}
plhs[1] = Int2Scalar(status);
Free ((VOIDPP) & value);
Free ((VOIDPP) & datap);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case RECINQ:
recvarids = (int *) mxCalloc(MAX_VAR_DIMS, sizeof(int));
recsizes = (long *) mxCalloc(MAX_VAR_DIMS, sizeof(long));
status = ncrecinq(cdfid, & nrecvars, recvarids, recsizes);
if (status != -1) {
for (i = 0; i < nrecvars; i++) {
ncvarinq(cdfid, recvarids[i], NULL, & datatype, NULL, NULL, NULL);
datatype = RepairBadDataType(datatype);
recsizes[i] /= nctypelen(datatype);
}
m = 1;
n = nrecvars;
plhs[0] = Int2Mat(recvarids, m, n);
plhs[1] = Long2Mat(recsizes, m, n);
}
plhs[2] = Int2Scalar(status);
Free ((VOIDPP) & recsizes);
Free ((VOIDPP) & recvarids);
break;
case TYPELEN:
datatype = (nc_type) Parameter(prhs[1]);
len = nctypelen(datatype);
plhs[0] = Int2Scalar(len);
plhs[1] = Int2Scalar((len >= 0) ? 0 : 1);
break;
case SETFILL:
fillmode = Scalar2Int(prhs[1]);
status = ncsetfill(cdfid, fillmode);
plhs[0] = Int2Scalar(status);
plhs[1] = Int2Scalar(0);
break;
case SETOPTS:
plhs[0] = Int2Scalar(ncopts);
plhs[1] = Int2Scalar(0);
ncopts = Scalar2Int(prhs[1]);
break;
case ERR:
plhs[0] = Int2Scalar(ncerr);
ncerr = 0;
plhs[1] = Int2Scalar(0);
break;
case PARAMETER:
if (nrhs > 1) {
plhs[0] = Int2Scalar(Parameter(prhs[1]));
plhs[1] = Int2Scalar(0);
}
else {
i = 0;
while (strcmp(parms[i].name, "NONE") != 0) {
mexPrintf("%12d %s\n", parms[i].code, parms[i].name);
i++;
}
plhs[0] = Int2Scalar(0);
plhs[1] = Int2Scalar(-1);
}
break;
default:
break;
}
return;
}
int main ()
{
/*
* If zoom = 0 then this script will animate the entire United States.
* If zoom = 1 then this script will animate just the Great Lakes region
* of the United States.
*
*/
int ZOOM=0;
int i, j, k, u_id, v_id, p_id, t_id, *time, *timestep;
int rlist, uf, vf, pf, tf, tim_id, lat_id, lon_id, tit_id;
int appid, wid, vfield, sfield, sfield2, mapid, vcid, cnid;
int title_id1, title_id2, txid1;
long timlen, latlen, lonlen, titlen;
long start [3] = {0,0,0}, count [3]={0,0,0};
float MinLat, MaxLat, MinLon, MaxLon;
float *U, *V, *P, *T, *lat, *lon;
ng_size_t len_dims[2];
char Uname [256], Vname [256], Pname [256], Tname [256];
char *reftime;
char title [256];
const char *dir = _NGGetNCARGEnv ("data");
extern void get_2d_array(float *, long, long, int, int, long);
const char *wks_type = "ncgm";
/*
* Create an application object. It will look for a resource file
* named vc09.res
*/
NhlInitialize();
rlist= NhlRLCreate (NhlSETRL);
NhlRLClear (rlist);
NhlRLSetString (rlist,NhlNappUsrDir,"./");
NhlRLSetString (rlist,NhlNappDefaultParent,"True");
NhlCreate (&appid, "vc09", NhlappClass, NhlDEFAULT_APP, rlist);
/*
* Create an ncgmWorkstation object.
*/
if (!strcmp(wks_type,"ncgm") || !strcmp(wks_type,"NCGM")) {
NhlRLClear (rlist);
NhlRLSetString (rlist, NhlNwkMetaName, "./vc09c.ncgm");
NhlRLSetString (rlist, NhlNwkColorMap, "temp1");
NhlCreate (&wid, "vc09Work", NhlncgmWorkstationClass,
NhlDEFAULT_APP, rlist);
}
else if (!strcmp(wks_type,"x11") || !strcmp(wks_type,"X11")) {
/*
* Create an X11 workstation.
*/
NhlRLClear (rlist);
NhlRLSetString (rlist, NhlNwkPause, "True");
NhlRLSetString (rlist, NhlNwkColorMap, "temp1");
NhlCreate (&wid, "vc09Work", NhlcairoWindowWorkstationClass,
NhlDEFAULT_APP, rlist);
}
else if (!strcmp(wks_type,"oldps") || !strcmp(wks_type,"OLDPS")) {
/*
* Create an older-style PostScript workstation.
*/
NhlRLClear (rlist);
NhlRLSetString (rlist, NhlNwkPSFileName, "vc09c.ps");
NhlRLSetString (rlist, NhlNwkColorMap, "temp1");
NhlCreate (&wid, "vc09Work", NhlpsWorkstationClass,
NhlDEFAULT_APP, rlist);
}
else if (!strcmp(wks_type,"oldpdf") || !strcmp(wks_type,"OLDPDF")) {
/*
* Create an older-style PDF workstation.
*/
NhlRLClear (rlist);
NhlRLSetString (rlist, NhlNwkPDFFileName, "vc09c.pdf");
NhlRLSetString (rlist, NhlNwkColorMap, "temp1");
NhlCreate (&wid, "vc09Work", NhlpdfWorkstationClass,
NhlDEFAULT_APP, rlist);
}
else if (!strcmp(wks_type,"pdf") || !strcmp(wks_type,"PDF") ||
!strcmp(wks_type,"ps") || !strcmp(wks_type,"PS")) {
/*
* Create a cairo PS/PDF Workstation object.
*/
NhlRLClear (rlist);
NhlRLSetString (rlist, NhlNwkFileName, "vc09c");
NhlRLSetString (rlist, NhlNwkFormat,(char*)wks_type);
NhlRLSetString (rlist, NhlNwkColorMap, "temp1");
NhlCreate (&wid, "vc09Work", NhlcairoDocumentWorkstationClass,
NhlDEFAULT_APP, rlist);
}
else if (!strcmp(wks_type,"png") || !strcmp(wks_type,"PNG")) {
/*
* Create a cairo PNG Workstation object.
*/
NhlRLClear (rlist);
NhlRLSetString (rlist, NhlNwkFileName, "vc09c");
NhlRLSetString (rlist, NhlNwkFormat,(char*)wks_type);
NhlRLSetString (rlist, NhlNwkColorMap, "temp1");
NhlCreate (&wid, "vc09Work", NhlcairoImageWorkstationClass,
NhlDEFAULT_APP, rlist);
}
/*
* Open the netcdf files.
*/
sprintf (Uname, "%s/cdf/Ustorm.cdf",dir);
sprintf (Vname, "%s/cdf/Vstorm.cdf",dir);
sprintf (Pname, "%s/cdf/Pstorm.cdf",dir);
sprintf (Tname, "%s/cdf/Tstorm.cdf",dir);
uf = ncopen (Uname, NC_NOWRITE);
vf = ncopen (Vname, NC_NOWRITE);
pf = ncopen (Pname, NC_NOWRITE);
tf = ncopen (Tname, NC_NOWRITE);
lat_id = ncdimid (uf,"lat");
lon_id = ncdimid (uf,"lon");
tim_id = ncdimid (vf,"timestep");
tit_id = ncdimid (vf,"timelen");
ncdiminq (uf,lat_id,(char *)0,&latlen);
ncdiminq (uf,lon_id,(char *)0,&lonlen);
ncdiminq (vf,tim_id,(char *)0,&timlen);
ncdiminq (vf,tit_id,(char *)0,&titlen);
len_dims [0] = latlen;
len_dims [1] = lonlen;
U = (float *)malloc(sizeof(float)*latlen*lonlen);
V = (float *)malloc(sizeof(float)*latlen*lonlen);
P = (float *)malloc(sizeof(float)*latlen*lonlen);
T = (float *)malloc(sizeof(float)*latlen*lonlen);
lat = (float *)malloc(sizeof(float)*latlen);
lon = (float *)malloc(sizeof(float)*lonlen);
u_id = ncvarid (uf,"u");
v_id = ncvarid (vf,"v");
p_id = ncvarid (pf,"p");
t_id = ncvarid (tf,"t");
lat_id = ncvarid (uf,"lat");
lon_id = ncvarid (uf,"lon");
tim_id = ncvarid (vf,"timestep");
tit_id = ncvarid (vf,"reftime");
start[2] = start[1] = start[0] =0;
count[0] = latlen;
count [1] = count [2] = 0;
ncvarget(uf,lat_id,(long const *)start,(long const *)count,lat);
count[0] = lonlen;
ncvarget(uf, lon_id, (long const *)start, (long const *)count, lon);
count [0] = timlen;
timestep = (int *) malloc (sizeof (int) * timlen);
ncvarget (vf, tim_id, (long const *)start, (long const *)count, timestep);
count [0] = titlen;
reftime = (char *) malloc (sizeof (char) * (titlen+1));
ncvarget (vf, tit_id, (long const *)start, (long const *)count, reftime);
/*
* Get U and V data values
*/
get_2d_array (U, latlen, lonlen, uf, u_id, 0);
get_2d_array (V, latlen, lonlen, vf, v_id, 0);
get_2d_array (P, latlen, lonlen, pf, p_id, 0);
get_2d_array (T, latlen, lonlen, tf, t_id, 0);
for (i=0; i < latlen*lonlen; i++) {
if (P[i] != -9999.0 ) P [i] /= 100.0;
if (T[i] != -9999.0 ) T [i] = (T[i] - 273.15) * 9.0 / 5.0 + 32.0;
}
NhlRLClear (rlist);
NhlRLSetMDFloatArray (rlist, NhlNvfUDataArray, U, 2, len_dims);
NhlRLSetMDFloatArray (rlist, NhlNvfVDataArray, V, 2, len_dims);
NhlRLSetFloat (rlist, NhlNvfXCStartV, lon [0] );
NhlRLSetFloat (rlist, NhlNvfYCStartV, lat [0] );
NhlRLSetFloat (rlist, NhlNvfXCEndV, lon [lonlen-1]);
NhlRLSetFloat (rlist, NhlNvfYCEndV, lat [latlen-1]);
NhlRLSetInteger (rlist, NhlNvfXCStride, 2);
NhlRLSetInteger (rlist, NhlNvfYCStride, 2);
NhlRLSetFloat (rlist, NhlNvfMissingUValueV, -9999.0);
NhlCreate (&vfield, "VectorField", NhlvectorFieldClass, appid, rlist);
NhlRLClear (rlist);
NhlRLSetMDFloatArray (rlist, NhlNsfDataArray, P, 2, len_dims);
NhlRLSetFloat (rlist, NhlNsfXCStartV, lon [0] );
NhlRLSetFloat (rlist, NhlNsfYCStartV, lat [0] );
NhlRLSetFloat (rlist, NhlNsfXCEndV, lon [lonlen - 1]);
NhlRLSetFloat (rlist, NhlNsfYCEndV, lat [latlen - 1]);
NhlRLSetInteger (rlist, NhlNsfXCStride, 2);
NhlRLSetInteger (rlist, NhlNsfYCStride, 2);
NhlRLSetFloat (rlist, NhlNsfMissingValueV, -9999.0);
NhlCreate (&sfield, "ScalarField", NhlscalarFieldClass, appid, rlist);
NhlRLClear (rlist);
NhlRLSetMDFloatArray (rlist, NhlNsfDataArray, T, 2, len_dims);
NhlRLSetFloat (rlist, NhlNsfXCStartV, lon [0]);
NhlRLSetFloat (rlist, NhlNsfYCStartV, lat [0]);
NhlRLSetFloat (rlist, NhlNsfXCEndV, lon [lonlen - 1]);
NhlRLSetFloat (rlist, NhlNsfYCEndV, lat [latlen - 1]);
NhlRLSetInteger (rlist, NhlNsfXCStride, 2);
NhlRLSetInteger (rlist, NhlNsfYCStride, 2);
NhlRLSetFloat (rlist, NhlNsfMissingValueV, -9999.0);
NhlCreate (&sfield2, "ScalarField2", NhlscalarFieldClass, appid, rlist);
/*
* To zoom in on a certain area of the first plot adjust the following
* four numbers.
*
* The following four numbers will cause the plots to display the
* entire United States.
*/
if (ZOOM == 0) {
MinLat = 18.0;
MaxLat = 65.0;
MinLon = -128.0;
MaxLon = -58.0;
}
else
/*
* The Following four numbers will zoom in on the great lakes region of
* the United States.
*/
if (ZOOM == 1) {
MinLat = 40.0;
MaxLat = 60.0;
MinLon = -100.0;
MaxLon = -58.0;
}
/*
* Create a map object
*/
NhlRLClear (rlist);
NhlRLSetFloat (rlist, NhlNvpXF, 0.03);
NhlRLSetFloat (rlist, NhlNvpYF, 0.85);
NhlRLSetFloat (rlist, NhlNvpWidthF, 0.8);
NhlRLSetFloat (rlist, NhlNvpHeightF, 0.8);
NhlRLSetString (rlist, NhlNvpUseSegments, "true");
NhlRLSetFloat (rlist, NhlNmpMinLatF, MinLat);
NhlRLSetFloat (rlist, NhlNmpMaxLatF, MaxLat);
NhlRLSetFloat (rlist, NhlNmpMinLonF, MinLon);
NhlRLSetFloat (rlist, NhlNmpMaxLonF, MaxLon);
NhlRLSetFloat (rlist, NhlNmpCenterLonF, -100.0);
NhlRLSetFloat (rlist, NhlNmpCenterLatF, 40.0);
NhlRLSetString (rlist, NhlNmpGridAndLimbDrawOrder, "predraw");
NhlCreate (&mapid, "map", NhlmapPlotClass, wid, rlist);
NhlRLClear (rlist);
NhlRLSetString (rlist, NhlNcnFillOn, "True");
NhlRLSetString (rlist, NhlNcnLinesOn, "False");
NhlRLSetString (rlist, NhlNcnFillDrawOrder, "predraw");
NhlRLSetInteger (rlist, NhlNcnScalarFieldData, sfield);
NhlRLSetString (rlist, NhlNpmLabelBarDisplayMode, "always");
NhlRLSetFloat (rlist, NhlNpmLabelBarHeightF, 0.075);
NhlRLSetFloat (rlist, NhlNpmLabelBarWidthF, 0.6);
NhlRLSetString (rlist, NhlNlbOrientation, "horizontal");
NhlRLSetString (rlist, NhlNlbPerimOn, "False");
NhlRLSetString (rlist, NhlNpmLabelBarSide, "top");
NhlCreate (&cnid,"contourplot", NhlcontourPlotClass, wid, rlist);
/*
* Create a VectorPlot object using the above data field.
*/
NhlRLClear(rlist);
NhlRLSetString (rlist, NhlNvcUseScalarArray, "true");
NhlRLSetInteger (rlist, NhlNvcVectorFieldData, vfield);
NhlRLSetInteger (rlist, NhlNvcScalarFieldData, sfield2);
NhlRLSetFloat (rlist, NhlNvcMinFracLengthF, 0.33);
NhlRLSetString (rlist, NhlNvcMonoLineArrowColor, "false");
NhlRLSetString (rlist, NhlNvcVectorDrawOrder, "predraw");
NhlRLSetString (rlist, NhlNpmLabelBarDisplayMode, "always");
NhlRLSetFloat (rlist, NhlNpmLabelBarWidthF, 0.1);
NhlRLSetString (rlist, NhlNlbPerimOn, "False");
NhlCreate (&vcid, "vectorplot", NhlvectorPlotClass, wid, rlist);
sprintf (title, "%s + %d", reftime, timestep [0]);
NhlRLClear (rlist);
NhlRLSetFloat (rlist, NhlNvpXF, 0.03);
NhlRLSetFloat (rlist, NhlNvpYF, 0.85);
NhlRLSetFloat (rlist, NhlNvpWidthF, 0.8);
NhlRLSetFloat (rlist, NhlNvpHeightF, 0.8);
NhlRLSetString (rlist, NhlNtiMainFuncCode, "~");
NhlRLSetInteger(rlist, NhlNtiMainFont, 25);
NhlRLSetString (rlist, NhlNtiMainString, title);
NhlCreate (&title_id1, "Titles", NhltitleClass, wid, rlist);
NhlRLClear (rlist);
NhlRLSetFloat (rlist, NhlNvpXF, 0.03);
NhlRLSetFloat (rlist, NhlNvpYF, 0.9);
NhlRLSetFloat (rlist, NhlNvpWidthF, 0.8);
NhlRLSetFloat (rlist, NhlNvpHeightF, 0.8);
NhlRLSetString (rlist, NhlNtiMainString, "January 1996 Snow Storm");
NhlRLSetInteger (rlist, NhlNtiMainFont, 25 );
NhlCreate (&title_id2, "Titles", NhltitleClass, wid, rlist);
NhlRLClear (rlist);
NhlRLSetFloat (rlist, NhlNtxPosXF, 0.25);
NhlRLSetFloat (rlist, NhlNtxPosYF, 0.08);
NhlRLSetFloat (rlist, NhlNtxFontHeightF, 0.015 );
NhlRLSetString (rlist, NhlNtxString, "Contours represent pressure field.:C:Vectors represent wind direction:C:colored by temperature." );
NhlCreate (&txid1, "text", NhltextItemClass, wid, rlist);
NhlAddOverlay(mapid,cnid,-1);
NhlAddOverlay(mapid,vcid,-1);
time = (int *) malloc (sizeof (int) * timlen);
for (i = 0; i < timlen; i++) time [i] = timestep [i];
j= 2*(timlen - 1)/3;
for (i = j; i < timlen; i++)
{
if ((time[i] != 102) && (time[i] != 222) && (time[i] != 216)) {
get_2d_array (U, latlen, lonlen, uf, u_id, i);
get_2d_array (V, latlen, lonlen, vf, v_id, i);
get_2d_array (P, latlen, lonlen, pf, p_id, i);
get_2d_array (T, latlen, lonlen, tf, t_id, i);
NhlRLClear (rlist);
NhlRLSetMDFloatArray (rlist, NhlNvfUDataArray, U, 2, len_dims);
NhlRLSetMDFloatArray (rlist, NhlNvfVDataArray, V, 2, len_dims);
NhlSetValues (vfield,rlist);
for (k=0; k < latlen*lonlen; k++) {
if (P[k] != -9999.0 ) P [k] /= 100.0;
if (T[k] != -9999.0 ) T [k] = (T[k] - 273.15) * 9.0 / 5.0 + 32.0;
}
NhlRLClear (rlist);
NhlRLSetMDFloatArray (rlist, NhlNsfDataArray, P, 2, len_dims);
NhlSetValues (sfield, rlist);
NhlRLClear (rlist);
NhlRLSetMDFloatArray (rlist, NhlNsfDataArray, T, 2, len_dims);
NhlSetValues (sfield2,rlist);
sprintf (title, "%s + %d", reftime, timestep [i]);
NhlRLClear (rlist);
NhlRLSetString (rlist, NhlNtiMainString, title);
NhlSetValues (title_id1, rlist);
NhlDraw (mapid);
NhlDraw (title_id1);
NhlDraw (title_id2);
NhlDraw (txid1);
NhlFrame (wid);
}
}
/*
* Close the Netcdf files.
*/
ncclose (uf);
ncclose (vf);
ncclose (pf);
ncclose (tf);
/*
* Destroy the workstation object and exit.
*/
NhlDestroy (wid);
NhlClose ();
exit(0);
}
