/* * Function for initializing Udunits-2 package. */ ut_system *utopen_ncl() { ut_system *us; const char *path = NULL; char udunits_file[_NhlMAXFNAMELEN]; extern int setenv(__const char *__name, __const char *__value, int __replace); /* * If NCARG_UDUNITS is set, then this directory is used to * look for the "udunits2.xml" file. * * Otherwise, the path within NCL ($NCARG_ROOT/lib/ncarg/udunits/) * is used. * * UDUNITS2_XML_PATH is not recognized internally by NCL. This is * because it could be very common for the user to have this set * for some other package, like Udunits, and this other file might * not be compatible with what NCL expects. * */ path = getenv("NCARG_UDUNITS"); if ( (void *)path == (void *)NULL) { path = _NGGetNCARGEnv("udunits"); } strcpy(udunits_file,path); strcat(udunits_file,_NhlPATHDELIMITER); strcat(udunits_file,"udunits2.xml"); /* * Internally set UDUNITS2_XML_PATH, forcing it to overwrite * any setting the user might have. */ (void)setenv("UDUNITS2_XML_PATH",udunits_file,1); /* Turn annoying "override" errors off */ ut_set_error_message_handler( ut_ignore ); /* Init udunits-2 lib */ us = ut_read_xml(NULL); /* Turn errors back on */ ut_set_error_message_handler( ut_write_to_stderr ); return(us); }
int main(int argc, char *argv[]) { char const *wks_type = "x11"; int appid,wid,vcid,vfid; int rlist,grlist; ng_size_t len_dims[3]; float reflen, ref; float x[a][b][c]; FILE * fd; int i,j,k; /* * Generate vector data array */ char filename[256]; const char *dir = _NGGetNCARGEnv("data"); sprintf( filename, "%s/asc/uvdata0.asc", dir ); fd = fopen(filename,"r"); for (k = 0; k < a; k++) { for (j = 0; j < b; j++) { for (i = 0; i < c; i++) { fscanf(fd,"%f", &x[k][j][i]); } } } /* * 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); grlist = NhlRLCreate(NhlGETRL); NhlRLClear(rlist); NhlRLSetString(rlist,NhlNappUsrDir,"./"); NhlCreate(&appid,"vc03",NhlappClass,NhlDEFAULT_APP,rlist); if (!strcmp(wks_type,"ncgm") || !strcmp(wks_type,"NCGM")) { /* * Create a meta file workstation. */ NhlRLClear(rlist); NhlRLSetString(rlist,NhlNwkMetaName,"./vc03c.ncgm"); NhlCreate(&wid,"vc03Work", 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,"vc03Work",NhlcairoWindowWorkstationClass,appid,rlist); } else if (!strcmp(wks_type,"oldps") || !strcmp(wks_type,"OLDPS")) { /* * Create an older-style PostScript workstation. */ NhlRLClear(rlist); NhlRLSetString(rlist,NhlNwkPSFileName,"vc03c.ps"); NhlCreate(&wid,"vc03Work",NhlpsWorkstationClass,appid,rlist); } else if (!strcmp(wks_type,"oldpdf") || !strcmp(wks_type,"OLDPDF")) { /* * Create an older-style PDF workstation. */ NhlRLClear(rlist); NhlRLSetString(rlist,NhlNwkPDFFileName,"vc03c.pdf"); NhlCreate(&wid,"vc03Work",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,"vc03c"); NhlRLSetString(rlist,NhlNwkFormat,(char*)wks_type); NhlCreate(&wid,"vc03Work",NhlcairoDocumentWorkstationClass,appid,rlist); } else if (!strcmp(wks_type,"png") || !strcmp(wks_type,"PNG")) { /* * Create a cairo PNG workstation. */ NhlRLClear(rlist); NhlRLSetString(rlist,NhlNwkFileName,"vc03c"); NhlRLSetString(rlist,NhlNwkFormat,(char*)wks_type); NhlCreate(&wid,"vc03Work",NhlcairoImageWorkstationClass,appid,rlist); } /* * 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) */ len_dims[0] = a; len_dims[1] = b; len_dims[2] = c; NhlRLClear(rlist); NhlRLSetMDFloatArray(rlist,NhlNvfDataArray,&x[0][0][0],3,len_dims); NhlRLSetFloat(rlist,NhlNvfXCStartV, -180.0); NhlRLSetFloat(rlist,NhlNvfXCEndV, 0.0); NhlRLSetFloat(rlist,NhlNvfYCStartV, 0.0); NhlRLSetFloat(rlist,NhlNvfYCEndV, 90.0); NhlRLSetFloat(rlist,NhlNvfYCStartSubsetV, 20.0); NhlRLSetFloat(rlist,NhlNvfYCEndSubsetV, 80.0); NhlCreate(&vfid,"vectorfield",NhlvectorFieldClass,appid,rlist); /* * Create a VectorPlot object, supplying the VectorField object as data */ NhlRLClear(rlist); NhlRLSetString(rlist,NhlNtiMainString, "Filled Arrow VectorPlot"); NhlRLSetFloat(rlist,NhlNvcRefMagnitudeF, 20.0); NhlRLSetString(rlist,NhlNvcFillArrowsOn, "True"); NhlRLSetFloat(rlist,NhlNvcMinFracLengthF, 0.2); NhlRLSetInteger(rlist,NhlNvcVectorFieldData,vfid); NhlCreate(&vcid,"vectorplot",NhlvectorPlotClass,wid,rlist); NhlRLClear(grlist); NhlRLGetFloat(grlist,NhlNvcRefLengthF,&reflen); NhlGetValues(vcid,grlist); ref= 1.5 * reflen; NhlRLClear(rlist); NhlRLSetFloat(rlist,NhlNvcRefLengthF,ref); NhlSetValues(vcid,rlist); NhlDraw(vcid); NhlFrame(wid); NhlRLClear(rlist); NhlRLSetString(rlist,NhlNtiMainString, "Variation #1:: Constant Width"); NhlRLSetFloat(rlist,NhlNvcFillArrowWidthF, 0.15); NhlRLSetFloat(rlist,NhlNvcFillArrowMinFracWidthF, 1.0); NhlSetValues(vcid,rlist); NhlDraw(vcid); NhlFrame(wid); NhlRLClear(rlist); NhlRLSetString(rlist,NhlNtiMainString, "Variation #2"); NhlRLSetFloat(rlist,NhlNvcFillArrowMinFracWidthF,0.25); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadMinFracXF,0.0); NhlRLSetFloat(rlist,NhlNvcFillArrowWidthF,0.2); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadXF,0.8); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadInteriorXF,0.7); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadYF,0.2); NhlSetValues(vcid,rlist); NhlDraw(vcid); NhlFrame(wid); NhlRLClear(rlist); NhlRLSetString(rlist,NhlNtiMainString,"Variation #3"); ref = 1.2 * reflen; NhlRLSetFloat(rlist,NhlNvcRefLengthF,ref); NhlRLSetFloat(rlist,NhlNvcFillArrowWidthF,0.3); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadXF,0.4); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadInteriorXF,0.35); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadYF,0.3); NhlSetValues(vcid,rlist); NhlDraw(vcid); NhlFrame(wid); NhlRLClear(rlist); NhlRLSetString(rlist,NhlNtiMainString,"Variation #4"); ref = 1.2 * reflen; NhlRLSetFloat(rlist,NhlNvcRefLengthF,ref); NhlRLSetFloat(rlist,NhlNvcFillArrowWidthF,0.2); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadXF,1.0); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadInteriorXF,1.0); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadYF,0.2); NhlSetValues(vcid,rlist); NhlDraw(vcid); NhlFrame(wid); NhlRLClear(rlist); NhlRLSetString(rlist,NhlNtiMainString,"Variation #5"); ref = 0.8 * reflen; NhlRLSetFloat(rlist,NhlNvcRefLengthF,ref); NhlRLSetFloat(rlist,NhlNvcFillArrowWidthF,0.2); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadXF,1.5); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadInteriorXF,1.0); NhlRLSetFloat(rlist,NhlNvcFillArrowHeadYF,0.5); NhlSetValues(vcid,rlist); NhlDraw(vcid); NhlFrame(wid); /* * Destroy the objects created, close the HLU library and exit. */ NhlDestroy(appid); NhlClose(); exit(0); }
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 errid = -1; int appid; int i, k = 0; int reset = 1; DIR *d; struct dirent *ent; #if defined(HPUX) shl_t so_handle; #else void *so_handle; #endif /* defined(HPUX) */ char buffer[4 * NCL_MAX_STRING]; void (*init_function) (void); char *libpath; char *scriptpath; char *pt; char *tmp = NULL; /* * Variables for command line options/arguments */ char *myName; /* argv[0]: program name (should be 'ncl') */ char **NCL_ARGV; int NCL_ARGC; /* local argv/argc -- future use for NCL scripts? */ int c; char **cargs = NULL; int nargs = 0; struct stat sbuf; int sr; FILE *tmpf = NULL; /* file variables for creating arguments */ char *tmpd = NULL; strcpy(buffer,(char *)GetNCARGPath("tmp")); sr = access(buffer,W_OK|X_OK|F_OK); if(sr != 0) { NhlPError(NhlWARNING,NhlEUNKNOWN, "\"%s\" tmp dir does not exist or is not writable: NCL functionality may be limited -- check TMPDIR environment variable", buffer); } #ifdef YYDEBUG extern int yydebug; yydebug = 1; #endif /* YYDEBUG */ error_fp = stderr; stdout_fp = stdout; stdin_fp = stdin; ncopts = NC_VERBOSE; cmd_line =isatty(fileno(stdin)); myName = NclMalloc(strlen(argv[0]) + 1); (void) strcpy(myName, argv[0]); /* * Save NCL argv, for command line processing later use */ NCL_ARGV = (char **) NclMalloc(argc * sizeof(char *)); for (i = 0; i < argc; i++) { NCL_ARGV[i] = (char *) NclMalloc((strlen(argv[i]) + 1) * sizeof(char *)); (void) strcpy(NCL_ARGV[i], argv[i]); } NCL_ARGC = argc; for(i = 0; i < _NclNumberOfFileFormats; ++i) NCLadvancedFileStructure[i] = 0; #ifdef NCLDEBUG for (i = 0; i < NCL_ARGC; i++, *NCL_ARGV++) (void) printf("NCL_ARGV[%d] = %s\n", i, *NCL_ARGV); #endif /* NCLDEBUG */ /* * Defined arguments * * -n element print: don't enumerate elements in print() * -x echo: turns on command echo * -V version: output NCARG/NCL version, exit * -o old behavior: retain former behavior for backwards incompatible changes * -h help: output options and exit * * -X override: echo every stmt regardless (unannounced option) * -Q override: don't echo copyright notice (unannounced option) */ opterr = 0; /* turn off getopt() msgs */ while ((c = getopt (argc, argv, "fhnoxVXQp")) != -1) { switch (c) { case 'p': NCLnoSysPager = 1; break; case 'n': NCLnoPrintElem = 1; break; case 'o': NCLoldBehavior = 1; break; case 'x': NCLecho = 1; break; /* NOT ADVERTISED! Will override "no echo" and print EVERYTHING! */ case 'X': NCLoverrideEcho = 1; break; /* NOT ADVERTISED! Will not echo copyright notice! */ case 'Q': NCLnoCopyright = 1; break; case 'V': (void) fprintf(stdout, "%s\n", GetNCLVersion()); exit(0); break; case 'f': for(i = 0; i < _NclNumberOfFileFormats; ++i) NCLadvancedFileStructure[i] = 1; break; case 'h': (void) fprintf(stdout, "Usage: ncl -fhnpxV <args> <file.ncl>\n"); (void) fprintf(stdout, "\t -f: Use New File Structure, and NetCDF4 features\n"); (void) fprintf(stdout, "\t -n: don't enumerate values in print()\n"); (void) fprintf(stdout, "\t -p: don't page output from the system() command\n"); (void) fprintf(stdout, "\t -o: retain former behavior for certain backwards-incompatible changes\n"); (void) fprintf(stdout, "\t -x: echo NCL commands\n"); (void) fprintf(stdout, "\t -V: print NCL version and exit\n"); (void) fprintf(stdout, "\t -h: print this message and exit\n"); exit(0); break; case '?': if (isprint(optopt)) (void) fprintf(stderr, "Unknown option `-%c'\n", optopt); else (void) fprintf(stderr, "Unknown option character `\\x%x'\n", optopt); break; default: break; } } /* * Announce NCL copyright notice, etc. */ if (!NCLnoCopyright) (void) fprintf(stdout, " Copyright (C) 1995-2013 - All Rights Reserved\n University Corporation for Atmospheric Research\n NCAR Command Language Version %s\n The use of this software is governed by a License Agreement.\n See http://www.ncl.ucar.edu/ for more details.\n", GetNCLVersion()); /* Process any user-defined arguments */ for (i = optind; i < argc; i++) { #ifdef NCLDEBUG (void) printf("Non-option argument %s\n", argv[i]); #endif /* NCLDEBUG */ /* * Is this a file of NCL commands? Can't assume ".ncl" tag, unfortunately. * Check for file's existence; the stat() call does not require access rights * but does require search path rights, so if this fails, the file could exist * but the user may not have permission to "see" it. */ sr = stat(argv[i], &sbuf); if (sr == 0) { #ifdef NCLDEBUG (void) printf("NCL commands file: %s\n", argv[i]); #endif /* NCLDEBUG */ nclf = argv[i]; continue; } if (sr < 0) { if (!strchr(argv[i], '=')) { /* argument is intended to be a file; can't locate it */ NhlPError(NhlFATAL, NhlEUNKNOWN, " can't find file \"%s\"\n", argv[i]); exit(NhlFATAL); } else { /* user-defined argument */ if (nargs == 0) cargs = (char **) NclMalloc(sizeof(char *)); else cargs = (char **) NclRealloc(cargs, (nargs + 1) * sizeof(char *)); cargs[nargs] = (char *) NclMalloc((strlen(argv[i]) + 2) * sizeof(char *)); (void) sprintf(cargs[nargs], "%s\n", argv[i]); nargs++; } } } if(nclf){ NCL_PROF_INIT(nclf); } else{ NCL_PROF_INIT("cmdline"); } error_fp = stderr; stdout_fp = stdout; stdin_fp = stdin; cur_line_text = NclMalloc((unsigned int) 512); cur_line_maxsize = 512; cur_line_text_pos = &(cur_line_text[0]); #ifdef NCLDEBUG thefptr = fopen("ncl.tree", "w"); theoptr = fopen("ncl.seq", "w"); #else thefptr = NULL; theoptr = NULL; #endif /* NCLDEBUG */ /* * Note: child processes should use _exit() instead of exit() to avoid calling the atexit() * functions prematurely */ NhlInitialize(); NhlVACreate(&appid, "ncl", NhlappClass, NhlDEFAULT_APP, NhlNappDefaultParent, 1, NhlNappUsrDir, "./", NULL); NhlPalLoadColormapFiles(NhlworkstationClass,False); errid = NhlErrGetID(); NhlVAGetValues(errid, NhlNerrFileName, &tmp, NULL); if ((tmp == NULL) || (!strcmp(tmp, "stderr"))) NhlVASetValues(errid, NhlNerrFilePtr, stdout, NULL); _NclInitMachine(); _NclInitSymbol(); _NclInitTypeClasses(); _NclInitDataClasses(); /* if the -o flag is specified do stuff to make NCL backwards compatible */ if (NCLoldBehavior) { _NclSetDefaultFillValues(NCL_5_DEFAULT_FILLVALUES); } /* Handle default directories */ if ((libpath = getenv("NCL_DEF_LIB_DIR")) != NULL) { d = opendir(_NGResolvePath(libpath)); if (d != NULL) { while((ent = readdir(d)) != NULL) { if (*ent->d_name != '.') { (void) sprintf(buffer, "%s/%s", _NGResolvePath(libpath), ent->d_name); #if defined (HPUX) so_handle = shl_load(buffer, BIND_IMMEDIATE, 0L); #else so_handle = dlopen(buffer, RTLD_NOW); if (so_handle == NULL) { NhlPError(NhlFATAL, NhlEUNKNOWN, "Could not open (%s): %s.", buffer, dlerror()); } #endif /* HPUX */ if (so_handle != NULL) { #if defined (HPUX) init_function = NULL; (void) shl_findsym(&so_handle, "Init", TYPE_UNDEFINED, (void *) &init_function); #else init_function = dlsym(so_handle, "Init"); #endif /* HPUX */ if (init_function != NULL) { (*init_function)(); } else { #if defined (HPUX) shl_unload(so_handle); #else dlclose(so_handle); #endif /* HPUX */ NhlPError(NhlWARNING, NhlEUNKNOWN, "Could not find Init() in external file %s, file not loaded.", buffer); } } } } } else { NhlPError(NhlWARNING, NhlEUNKNOWN, "Could not open default library path (%s), no libraries loaded.", libpath); } _NclResetNewSymStack(); } if (cmd_line == 1) { InitializeReadLine(1); /* * This next line is only to deal with an optimization bug with gcc * version 4.0.1 on MacOS 10.4. It apparently saw that "cmd_line" * was already of value 1 before it went into NclSetPromptFunc, so * when it optimized the code, it ignored the "cmd_line = 1" line * right after the NclSetPromptFunc call. Since NclSetPrompFunc * was setting cmd_line =2, this meant that the value of cmd_line * stayed 2, which is the wrong value. */ cmd_line = 0; NclSetPromptFunc(nclprompt, NULL); cmd_line = 1; cmd_line_is_set = 1; } else { InitializeReadLine(0); } /* Load default scripts */ /* These need to be loaded in alphabetical order to ensure that users can control * the order of loading. There is a BSD function scandir that would do it all but it * might not be standardized enough to be uniformly available on all systems, so for * now it must be coded just using readdir. */ if ((scriptpath = getenv("NCL_DEF_SCRIPTS_DIR")) != NULL) { d = opendir(_NGResolvePath(scriptpath)); if (d!= NULL) { int script_count = 0, alloc_count = 32; NrmQuark *qscript_names = NclMalloc(alloc_count * sizeof(NrmQuark)); while((ent = readdir(d)) != NULL) { if (*ent->d_name != '.') { (void) sprintf(buffer, "%s/%s", _NGResolvePath(scriptpath), ent->d_name); pt = strrchr(buffer, '.'); if (pt != NULL) { pt++; if (strncmp(pt, "ncl", 3) == 0) { if (script_count == alloc_count) { alloc_count *= 2; qscript_names = NclRealloc(qscript_names,alloc_count * sizeof(NrmQuark)); } qscript_names[script_count++] = NrmStringToQuark(ent->d_name); } } } } if (script_count == 0) { NhlPError(NhlWARNING, NhlEUNKNOWN, "No scripts found: scripts must have the \".ncl\" file extension."); } else { qsort(qscript_names,script_count,sizeof(NrmQuark),quark_comp); for (i = 0; i < script_count; i++) { (void) sprintf(buffer, "%s/%s", _NGResolvePath(scriptpath), NrmQuarkToString(qscript_names[i])); if (_NclPreLoadScript(buffer, 1) == NhlFATAL) { NhlPError(NhlFATAL, NhlEUNKNOWN, "Error loading default script."); } else { yyparse(reset); } } NclFree(qscript_names); } } else { NhlPError(NhlWARNING, NhlEUNKNOWN, " Could not open default script path (%s), no scripts loaded.", scriptpath); } } /* * Create the new args * * Ideally this would be done using calls to the parser/stack engine but there is * no clean interface to that process. Investigate _NclParseString() in the future. * * For now, create a temporary file with NCL commands and execute it. */ if (nargs) { cmd_line = 0; /* non-interactive */ tmpd = (char *) _NGGetNCARGEnv("tmp"); /* defaults to: /tmp */ (void) sprintf(buffer, "%s/ncl%d.ncl", tmpd, getpid()); tmpf = fopen(buffer, "w"); for (k = 0; k < nargs; k++) { if ((strstr(cargs[k], "=")) == (char *) NULL) NhlPError(NhlWARNING, NhlEUNKNOWN, " Improper assignment for variable %s", cargs[k]); else (void) fwrite(cargs[k], strlen(cargs[k]), 1, tmpf); } /* don't forget last newline; NCL requires it */ (void) fwrite("\n", 1, 1, tmpf); (void) fclose(tmpf); if (_NclPreLoadScript(buffer, 1) == NhlFATAL) { NhlPError(NhlFATAL, NhlEUNKNOWN, "Error initializing command line arguments."); (void) unlink(buffer); } else { yyparse(reset); } (void) unlink(buffer); cmd_line = 1; /* reset to default: interactive */ } /* Load utility script */ strcpy(buffer, _NGResolvePath("$NCARG_ROOT/lib/ncarg/nclscripts/utilities.ncl")); sr = stat(buffer, &sbuf); if(0 == sr) { if(_NclPreLoadScript(buffer, 1) == NhlFATAL) { NclReturnStatus = NclFileNotFound; NhlPError(NhlINFO, NhlEUNKNOWN, "Error loading NCL utility script."); } else yyparse(reset); } /* Load any provided script */ if (nclf != (char *) NULL) { (void) strcpy(buffer, _NGResolvePath(nclf)); if (_NclPreLoadScript(buffer, 0) == NhlFATAL) { NclReturnStatus = NclFileNotFound; NhlPError(NhlFATAL, NhlEUNKNOWN, "Error loading provided NCL script."); } else yyparse(reset); } else { yyparse(reset); } #ifdef NCLDEBUG (void) fclose(thefptr); (void) fprintf(stdout,"Number of unfreed objects %d\n",_NclNumObjs()); _NclObjsSize(stdout); _NclNumGetObjCals(stdout); _NclPrintUnfreedObjs(theoptr); (void) fprintf(stdout,"Number of constants used %d\n",number_of_constants); (void) fclose(theoptr); #endif /* NCLDEBUG */ NclFree(myName); _NclExit(NclReturnStatus); return NclReturnStatus; }
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); }
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); }