static void check_fill_seq(int id) { size_t vindices[NUM_DIMS]; size_t *cc, *mm; union getret got; int ii = 0; /*float val;*/ sizes[0] = NUM_RECS; cc = vindices; while (cc < &vindices[num_dims]) *cc++ = 0; /* ripple counter */ cc = vindices; mm = sizes; while (*vindices < *sizes) { while (*cc < *mm) { if (mm == &sizes[num_dims - 1]) { if(nc_get_var1_float(id, Float_id, vindices, &got.fl[0]) == -1) goto bad_ret; /* val = (float) ii; */ /* if(val != got.fl[0]) */ /* { */ /* parray("indices", NUM_DIMS, vindices); */ /* (void) printf("\t%f != %f\n", val, got.fl[0]); */ /* } */ (*cc)++; ii++; continue; } cc++; mm++; } if(cc == vindices) break; *cc = 0; cc--; mm--; (*cc)++; } return; bad_ret : (void) printf("couldn't get a var in check_fill_seq() %d\n", ii); return; }
//***************************************************************************************** //Remplit les valeurs de la variable dimension. void cdf_fill_dim( int ncfrid, int nctoid, s_nc_dimension* to, s_nc_dimension* from, size_t start){ //***************************************************************************************** int status; float value1, value2; size_t i,q; q=start; value2=-100.0; for(i=0;i<to->length;i++){ H(nc_get_var1_float(ncfrid, from->varid, &q, &value1)) if(value1<value2) value2=value1+MODULO_DEG; else value2=value1; H(nc_put_var1_float(nctoid, to->varid, &i, &value2)) q=(q+1)%(from->length); } return; }
int ex_get_time (int exoid, int time_step, void *time_value) { int status; int varid; size_t start[1]; char errmsg[MAX_ERR_LENGTH]; exerrval = 0; /* clear error code */ /* inquire previously defined variable */ if ((status = nc_inq_varid(exoid, VAR_WHOLE_TIME, &varid)) != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to locate time variable in file id %d", exoid); ex_err("ex_get_time",errmsg,exerrval); return (EX_FATAL); } /* read time value */ start[0] = --time_step; if (ex_comp_ws(exoid) == 4) { status = nc_get_var1_float(exoid, varid, start, time_value); } else { status = nc_get_var1_double(exoid, varid, start, time_value); } if (status != NC_NOERR) { exerrval = status; sprintf(errmsg, "Error: failed to get time value in file id %d", exoid); ex_err("ex_get_time",errmsg,exerrval); return (EX_FATAL); } return (EX_NOERR); }
int extract_unary_single(int mpi_rank,int mpi_size, int ncid,int vlid,int ncidout,int vlidout,int ndims,nc_type vtype,size_t *shape,size_t *begins,size_t *ends, ptrdiff_t *strides,size_t preLen,size_t *outLen){ int i,j,res; size_t *divider=(size_t *)malloc(sizeof(size_t)*ndims); //input divider size_t *dividerOut=(size_t *)malloc(sizeof(size_t)*ndims); // output divider size_t *start=(size_t*)malloc(sizeof(size_t)*ndims); //start position for reading element from input file size_t *startOut=(size_t*)malloc(sizeof(size_t)*ndims); //start position for writing element to output file size_t *shapeOut=(size_t*)malloc(sizeof(size_t)*ndims); //output dimension shape int lenOut=1; for(i=0;i<ndims;++i){ shapeOut[i]=(ends[i]-begins[i])/strides[i]+1; lenOut*=shapeOut[i]; } if(outLen!=NULL) *outLen=lenOut; getDivider(ndims,shape,divider); getDivider(ndims,shapeOut,dividerOut); /* decide element boundary for each mpi process */ size_t beginOut; size_t endOut; if(lenOut>=mpi_size){ beginOut=mpi_rank*(lenOut/mpi_size); if(mpi_rank!=mpi_size-1) endOut=(mpi_rank+1)*(lenOut/mpi_size); else endOut=lenOut; }else{ //mpi_size is bigger than lenOut if(mpi_rank<lenOut){ beginOut=mpi_rank; endOut=mpi_rank+1; }else{ beginOut=0; endOut=0; } } printf("mpi_rank %d, beginOut %d, endOut %d\n",mpi_rank,beginOut,endOut); void *data=malloc(sizeof(double)); size_t rem,remIn; for(i=beginOut;i<endOut;++i){ rem=i+preLen; remIn=i; for(j=0;j<ndims;++j){ startOut[j]=rem/dividerOut[j]; start[j]=begins[j]+(remIn/dividerOut[j])*strides[j]; rem=rem%dividerOut[j]; remIn=remIn%dividerOut[j]; } switch(vtype){ case NC_BYTE: if((res=nc_get_var1_uchar(ncid,vlid,start,data))) BAIL(res); if((res=nc_put_var1_uchar(ncidout,vlidout,startOut,(unsigned char *)data))) BAIL(res); break; case NC_CHAR: if((res=nc_get_var1_schar(ncid,vlid,start,(signed char *)data))) BAIL(res); if((res=nc_put_var1_schar(ncidout,vlidout,startOut,(signed char *)data))) BAIL(res); break; case NC_SHORT: if((res=nc_get_var1_short(ncid,vlid,start,data))) BAIL(res); if((res=nc_put_var1_short(ncidout,vlidout,startOut,(short *)data))) BAIL(res); break; case NC_INT: if((res=nc_get_var1_int(ncid,vlid,start,(int *)data))) BAIL(res); if((res=nc_put_var1_int(ncidout,vlidout,startOut,(int *)data))) BAIL(res); break; case NC_FLOAT: if((res=nc_get_var1_float(ncid,vlid,start,data))) BAIL(res); if((res=nc_put_var1_float(ncidout,vlidout,startOut,(float *)data))) BAIL(res); break; case NC_DOUBLE: if((res=nc_get_var1_double(ncid,vlid,start,data))) BAIL(res); if((res=nc_put_var1_double(ncidout,vlidout,startOut,(double *)data))) BAIL(res); break; default: printf("Unknown data type\n"); } } /*free resourses*/ free(divider); free(dividerOut); free(start); free(startOut); free(shapeOut); free(data); return 0; }
sta_struct *decode_fsl2(int cdfid, long miss, int *iret) { int ndims,nvars,natts,nunlim; int tmpint[20]; int ier,i,j,unlimsiz; int wmoStaNum_id,wmoStaNum,staName_id; char staName[20]; int staLat_id,staLon_id,staElev_id,timeObs_id,levels_id; int uwnd_id,vwnd_id,wwnd_id,uv_qual_id,w_qual_id,levelMode_id; int sigma_uv_id,sigma_w_id; int sfc_sped_id,sfc_drct_id,sfc_pres_id,sfc_temp_id,sfc_relh_id,sfc_rain_id; float staLat,staLon,staElev,level; float uwnd,vwnd,wwnd,sigma_uv,sigma_w; int uv_qual,w_qual,levelMode; float sfc_sped,sfc_drct,sfc_pres,sfc_temp,sfc_relh,sfc_rain; double timeObs; nc_type xtype; int nvdims,nvatts,time_interval; size_t dimsiz,var_i[5],vc[5],namelen; float ufill,vfill,wfill; float pfill,tfill,dfill,sfill,rfill,rrfill; float fmiss,e; time_t obs_time; char timestr[80],*atttext; int year,month,day,hour,minute; struct tm *gmt_time=NULL,new_time; sta_struct *stadat,*head=NULL; prof_data *plev,*plast; udebug("decoding fsl2\0"); fmiss = (float)miss; ier = nc_inq(cdfid,&ndims,&nvars,&natts,&nunlim); ier = nc_inq_atttype(cdfid,NC_GLOBAL,"avgTimePeriod",&xtype); if(xtype == NC_CHAR) { ier = nc_inq_attlen(cdfid,NC_GLOBAL,"avgTimePeriod",&namelen); udebug("AvgTimPeriod name len is %d",namelen); atttext = (char *)malloc(namelen + 1); ier = nc_get_att_text(cdfid,NC_GLOBAL,"avgTimePeriod",atttext); sscanf(atttext,"%d",tmpint); udebug("AvgTimPeriod type is NC_CHAR %s VAL %d",atttext,tmpint[0]); free(atttext); } else { ier = nc_get_att_int(cdfid,NC_GLOBAL,"avgTimePeriod",tmpint); } udebug("AvgTimPeriod is %d\0",tmpint[0]); time_interval = tmpint[0]; ier = 0; ier += nc_inq_varid(cdfid,"wmoStaNum",&wmoStaNum_id); ier += nc_inq_varid(cdfid,"staName",&staName_id); ier += nc_inq_varid(cdfid,"staLat",&staLat_id); ier += nc_inq_varid(cdfid,"staLon",&staLon_id); ier += nc_inq_varid(cdfid,"staElev",&staElev_id); ier += nc_inq_varid(cdfid,"timeObs",&timeObs_id); ier += nc_inq_varid(cdfid,"levels",&levels_id); ier += nc_inq_varid(cdfid,"uComponent",&uwnd_id); ier += nc_inq_varid(cdfid,"vComponent",&vwnd_id); ier += nc_inq_varid(cdfid,"wComponent",&wwnd_id); ier += nc_get_att_float(cdfid,uwnd_id,"_FillValue",&ufill); ier += nc_get_att_float(cdfid,vwnd_id,"_FillValue",&vfill); ier += nc_get_att_float(cdfid,wwnd_id,"_FillValue",&wfill); ier += nc_inq_varid(cdfid,"uvQualityCode",&uv_qual_id); ier += nc_inq_varid(cdfid,"wQualityCode",&w_qual_id); ier += nc_inq_varid(cdfid,"windSpeedStdDev",&sigma_uv_id); ier += nc_inq_varid(cdfid,"wStdDev",&sigma_w_id); ier += nc_inq_varid(cdfid,"levelMode",&levelMode_id); ier += nc_inq_varid(cdfid,"windSpeedSfc",&sfc_sped_id); ier += nc_inq_varid(cdfid,"windDirSfc",&sfc_drct_id); ier += nc_inq_varid(cdfid,"pressure",&sfc_pres_id); ier += nc_inq_varid(cdfid,"temperature",&sfc_temp_id); ier += nc_inq_varid(cdfid,"relHumidity",&sfc_relh_id); ier += nc_inq_varid(cdfid,"rainRate",&sfc_rain_id); ier += nc_get_att_float(cdfid,sfc_sped_id,"_FillValue",&sfill); ier += nc_get_att_float(cdfid,sfc_drct_id,"_FillValue",&dfill); ier += nc_get_att_float(cdfid,sfc_pres_id,"_FillValue",&pfill); ier += nc_get_att_float(cdfid,sfc_temp_id,"_FillValue",&tfill); ier += nc_get_att_float(cdfid,sfc_relh_id,"_FillValue",&rfill); ier += nc_get_att_float(cdfid,sfc_rain_id,"_FillValue",&rrfill); if(ier != 0) { uerror("could not get station information\0"); *iret = -1; return(NULL); } ier = nc_inq_vardimid(cdfid,staName_id,tmpint); ier += nc_inq_dimlen(cdfid,tmpint[1],&namelen); tmpint[0] = 0;tmpint[1] = 0; ier += nc_inq_var(cdfid,wmoStaNum_id,NULL, &xtype, &nvdims, tmpint, &nvatts); ier += nc_inq_dimlen(cdfid,tmpint[0],&dimsiz); if(ier == 0) unlimsiz = dimsiz; for(i=0;i<unlimsiz;i++) { var_i[0] = i; var_i[1] = 0; vc[0] = 1; vc[1] = namelen-1; memset(staName,'\0',20); ier = nc_get_vara_text(cdfid,staName_id,var_i,vc,staName); ier = nc_get_var1_int(cdfid,wmoStaNum_id,var_i,&wmoStaNum); ier = nc_get_var1_float(cdfid,staLat_id,var_i,&staLat); ier = nc_get_var1_float(cdfid,staLon_id,var_i,&staLon); ier = nc_get_var1_float(cdfid,staElev_id,var_i,&staElev); ier = nc_get_var1_float(cdfid,sfc_sped_id,var_i,&sfc_sped); ier = nc_get_var1_float(cdfid,sfc_drct_id,var_i,&sfc_drct); ier = nc_get_var1_float(cdfid,sfc_pres_id,var_i,&sfc_pres); ier = nc_get_var1_float(cdfid,sfc_temp_id,var_i,&sfc_temp); ier = nc_get_var1_float(cdfid,sfc_relh_id,var_i,&sfc_relh); ier = nc_get_var1_float(cdfid,sfc_rain_id,var_i,&sfc_rain); ier = nc_get_var1_double(cdfid,timeObs_id,var_i,&timeObs); obs_time = (time_t) timeObs; gmt_time = gmtime(&obs_time); new_time = *gmt_time; timestr[0] = '\0'; strftime(timestr,80,"%Y %m %d %H %M",&new_time); sscanf(timestr,"%d %d %d %d %d",&year,&month,&day,&hour,&minute); udebug("Station %3d %8d %s = %6.2f %7.2f %5.0f %s\0",i,wmoStaNum, staName,staLat,staLon,staElev,timestr); stadat = (sta_struct *)malloc(sizeof(sta_struct)); if(stadat == NULL) { uerror("Could not allocate station data structure\0"); exit(-2); } stadat->wmoStaNum = wmoStaNum; stadat->staName = (char *)malloc(strlen(staName)+1); strcpy(stadat->staName,staName); stadat->staLat = staLat; stadat->staLon = staLon; stadat->staElev = staElev; stadat->timeObs = timeObs; stadat->year = year; stadat->month = month; stadat->day = day; stadat->hour = hour; stadat->minute = minute; stadat->time_interval = time_interval; stadat->pdata = NULL; stadat->rdata = NULL; stadat->sfc_pres = fmiss; stadat->sfc_temp = fmiss; stadat->sfc_sped = fmiss; stadat->sfc_drct = fmiss; stadat->sfc_relh = fmiss; stadat->sfc_rain_rate = fmiss; stadat->sfc_rain_amt = fmiss; stadat->sfc_dwpc = fmiss; if(sfc_pres != pfill) stadat->sfc_pres = sfc_pres; if(sfc_temp != tfill) stadat->sfc_temp = sfc_temp - 273.15; if(sfc_sped != sfill) stadat->sfc_sped = sfc_sped; if(sfc_drct != dfill) stadat->sfc_drct = sfc_drct; if(sfc_relh != rfill) stadat->sfc_relh = sfc_relh; if(sfc_rain != rrfill) stadat->sfc_rain_rate = sfc_rain; if((stadat->sfc_temp != fmiss)&&(stadat->sfc_relh != fmiss)) { VAPOR_PRES(stadat->sfc_temp+273.15,&e); e = e * (stadat->sfc_relh / 100.); t_from_e(e,&stadat->sfc_dwpc); stadat->sfc_dwpc = stadat->sfc_dwpc - 273.15; } ier = nc_inq_var(cdfid,levels_id,NULL, &xtype, &nvdims, tmpint, &nvatts); if(ier == 0) { ier = nc_inq_dimlen(cdfid,tmpint[0],&dimsiz); stadat->numlevs = dimsiz; plast = stadat->pdata; for(j=0;j<stadat->numlevs;j++) { var_i[0] = j; ier = nc_get_var1_float(cdfid,levels_id,var_i,&level); ier = nc_get_var1_int(cdfid,levelMode_id,var_i,&levelMode); var_i[0] = i; var_i[1] = j; ier = nc_get_var1_float(cdfid,uwnd_id,var_i,&uwnd); ier = nc_get_var1_float(cdfid,vwnd_id,var_i,&vwnd); ier = nc_get_var1_float(cdfid,wwnd_id,var_i,&wwnd); ier = nc_get_var1_int(cdfid,uv_qual_id,var_i,&uv_qual); ier = nc_get_var1_int(cdfid,w_qual_id,var_i,&w_qual); ier = nc_get_var1_float(cdfid,sigma_uv_id,var_i,&sigma_uv); ier = nc_get_var1_float(cdfid,sigma_w_id,var_i,&sigma_w); plev = (prof_data *)malloc(sizeof(prof_data)); if(plev != NULL) { plev->level = level; if(uwnd == ufill) uwnd = fmiss; if(vwnd == vfill) vwnd = fmiss; if(wwnd == wfill) wwnd = fmiss; if(uv_qual != 0) { uwnd = fmiss; vwnd = fmiss; } if(w_qual != 0) wwnd = fmiss; if((uwnd == fmiss)||(vwnd == fmiss)) sigma_uv = fmiss; if(wwnd == fmiss) sigma_w = fmiss; plev->u = uwnd; plev->v = vwnd; plev->w = wwnd; plev->sigma_uv = sigma_uv; plev->sigma_w = sigma_w; plev->levmode = levelMode; plev->nextlev = NULL; if(plast == NULL) stadat->pdata = plev; else plast->nextlev = plev; plast = plev; } } } else stadat->numlevs = 0; stadat->next = head; head = stadat; } return(head); }
/* * Get a single numeric value from a variable of an open netCDF file. */ static void c_ncvgt1 ( int ncid, /* netCDF ID */ int varid, /* variable ID */ const size_t* indices,/* multidim index of data to be read */ void* value, /* pointer to data value to be read */ int* rcode /* returned error code */ ) { int status; nc_type datatype; if ((status = nc_inq_vartype(ncid, varid, &datatype)) == 0) { switch (datatype) { case NC_CHAR: status = NC_ECHAR; break; case NC_BYTE: # if NF_INT1_IS_C_SIGNED_CHAR status = nc_get_var1_schar(ncid, varid, indices, (signed char*)value); # elif NF_INT1_IS_C_SHORT status = nc_get_var1_short(ncid, varid, indices, (short*)value); # elif NF_INT1_IS_C_INT status = nc_get_var1_int(ncid, varid, indices, (int*)value); # elif NF_INT1_IS_C_LONG status = nc_get_var1_long(ncid, varid, indices, (long*)value); # endif break; case NC_SHORT: # if NF_INT2_IS_C_SHORT status = nc_get_var1_short(ncid, varid, indices, (short*)value); # elif NF_INT2_IS_C_INT status = nc_get_var1_int(ncid, varid, indices, (int*)value); # elif NF_INT2_IS_C_LONG status = nc_get_var1_long(ncid, varid, indices, (long*)value); # endif break; case NC_INT: # if NF_INT_IS_C_INT status = nc_get_var1_int(ncid, varid, indices, (int*)value); # elif NF_INT_IS_C_LONG status = nc_get_var1_long(ncid, varid, indices, (long*)value); # endif break; case NC_FLOAT: # if NF_REAL_IS_C_FLOAT status = nc_get_var1_float(ncid, varid, indices, (float*)value); # elif NF_REAL_IS_C_DOUBLE status = nc_get_var1_double(ncid, varid, indices, (double*)value); # endif break; case NC_DOUBLE: # if NF_DOUBLEPRECISION_IS_C_FLOAT status = nc_get_var1_float(ncid, varid, indices, (float*)value); # elif NF_DOUBLEPRECISION_IS_C_DOUBLE status = nc_get_var1_double(ncid, varid, indices, (double*)value); # endif break; } } if (status == 0) *rcode = 0; else { nc_advise("NCVGT1", status, ""); *rcode = ncerr; } }
OSErr NetCDFWindMoverCurv::TextRead(char *path, TMap **newMap, char *topFilePath) // don't want a map { // this code is for curvilinear grids OSErr err = 0; long i,j, numScanned, indexOfStart = 0; int status, ncid, latIndexid, lonIndexid, latid, lonid, recid, timeid, numdims; size_t latLength, lonLength, recs, t_len, t_len2; float timeVal; char recname[NC_MAX_NAME], *timeUnits=0, month[10]; char dimname[NC_MAX_NAME], s[256], topPath[256]; WORLDPOINTFH vertexPtsH=0; float *lat_vals=0,*lon_vals=0,yearShift=0.; static size_t timeIndex,ptIndex[2]={0,0}; static size_t pt_count[2]; Seconds startTime, startTime2; double timeConversion = 1.; char errmsg[256] = "",className[256]=""; char fileName[64],*modelTypeStr=0; Point where; OSType typeList[] = { 'NULL', 'NULL', 'NULL', 'NULL' }; MySFReply reply; Boolean bTopFile = false, fIsNavy = false; // for now keep code around but probably don't need Navy curvilinear wind //VelocityFH velocityH = 0; char outPath[256]; if (!path || !path[0]) return 0; strcpy(fPathName,path); strcpy(s,path); SplitPathFile (s, fileName); strcpy(fFileName, fileName); // maybe use a name from the file status = nc_open(path, NC_NOWRITE, &ncid); //if (status != NC_NOERR) {err = -1; goto done;} if (status != NC_NOERR) { #if TARGET_API_MAC_CARBON err = ConvertTraditionalPathToUnixPath((const char *) path, outPath, kMaxNameLen) ; status = nc_open(outPath, NC_NOWRITE, &ncid); #endif if (status != NC_NOERR) {err = -1; goto done;} } // check number of dimensions - 2D or 3D status = nc_inq_ndims(ncid, &numdims); if (status != NC_NOERR) {err = -1; goto done;} status = nc_inq_attlen(ncid,NC_GLOBAL,"generating_model",&t_len2); if (status != NC_NOERR) {fIsNavy = false; /*goto done;*/} else { fIsNavy = true; // may only need to see keyword is there, since already checked grid type modelTypeStr = new char[t_len2+1]; status = nc_get_att_text(ncid, NC_GLOBAL, "generating_model", modelTypeStr); if (status != NC_NOERR) {fIsNavy = false; goto done;} modelTypeStr[t_len2] = '\0'; strcpy(fFileName, modelTypeStr); } GetClassName(className); if (!strcmp("NetCDF Wind",className)) SetClassName(fFileName); //first check that name is now the default and not set by command file ("NetCDF Wind") //if (fIsNavy) { status = nc_inq_dimid(ncid, "time", &recid); //Navy //if (status != NC_NOERR) {err = -1; goto done;} if (status != NC_NOERR) { status = nc_inq_unlimdim(ncid, &recid); // issue of time not being unlimited dimension if (status != NC_NOERR) {err = -1; goto done;} } } /*else { status = nc_inq_unlimdim(ncid, &recid); // issue of time not being unlimited dimension if (status != NC_NOERR) {err = -1; goto done;} }*/ //if (fIsNavy) status = nc_inq_varid(ncid, "time", &timeid); if (status != NC_NOERR) { status = nc_inq_varid(ncid, "ProjectionHr", &timeid); if (status != NC_NOERR) {err = -1; goto done;} } // if (status != NC_NOERR) {/*err = -1; goto done;*/timeid=recid;} //if (!fIsNavy) //status = nc_inq_attlen(ncid, recid, "units", &t_len); // recid is the dimension id not the variable id //else // LAS has them in order, and time is unlimited, but variable/dimension names keep changing so leave this way for now status = nc_inq_attlen(ncid, timeid, "units", &t_len); if (status != NC_NOERR) { timeUnits = 0; // files should always have this info timeConversion = 3600.; // default is hours startTime2 = model->GetStartTime(); // default to model start time //err = -1; goto done; } else { DateTimeRec time; char unitStr[24], junk[10]; timeUnits = new char[t_len+1]; //if (!fIsNavy) //status = nc_get_att_text(ncid, recid, "units", timeUnits); // recid is the dimension id not the variable id //else status = nc_get_att_text(ncid, timeid, "units", timeUnits); if (status != NC_NOERR) {err = -1; goto done;} timeUnits[t_len] = '\0'; // moved this statement before StringSubstitute, JLM 5/2/10 StringSubstitute(timeUnits, ':', ' '); StringSubstitute(timeUnits, '-', ' '); StringSubstitute(timeUnits, 'T', ' '); StringSubstitute(timeUnits, 'Z', ' '); numScanned=sscanf(timeUnits, "%s %s %hd %hd %hd %hd %hd %hd", unitStr, junk, &time.year, &time.month, &time.day, &time.hour, &time.minute, &time.second) ; if (numScanned==5) {time.hour = 0; time.minute = 0; time.second = 0; } else if (numScanned==7) // has two extra time entries ?? time.second = 0; else if (numScanned<8) //else if (numScanned!=8) { //timeUnits = 0; // files should always have this info //timeConversion = 3600.; // default is hours //startTime2 = model->GetStartTime(); // default to model start time err = -1; TechError("NetCDFWindMoverCurv::TextRead()", "sscanf() == 8", 0); goto done; } else { // code goes here, trouble with the DAYS since 1900 format, since converts to seconds since 1904 if (time.year ==1900) {time.year += 40; time.day += 1; /*for the 1900 non-leap yr issue*/ yearShift = 40.;} DateToSeconds (&time, &startTime2); // code goes here, which start Time to use ?? if (!strcmpnocase(unitStr,"HOURS") || !strcmpnocase(unitStr,"HOUR")) timeConversion = 3600.; else if (!strcmpnocase(unitStr,"MINUTES") || !strcmpnocase(unitStr,"MINUTE")) timeConversion = 60.; else if (!strcmpnocase(unitStr,"SECONDS") || !strcmpnocase(unitStr,"SECOND")) timeConversion = 1.; else if (!strcmpnocase(unitStr,"DAYS") || !strcmpnocase(unitStr,"DAY")) timeConversion = 24.*3600.; } } if (fIsNavy) { status = nc_inq_dimid(ncid, "gridy", &latIndexid); //Navy if (status != NC_NOERR) {err = -1; goto done;} status = nc_inq_dimlen(ncid, latIndexid, &latLength); if (status != NC_NOERR) {err = -1; goto done;} status = nc_inq_dimid(ncid, "gridx", &lonIndexid); //Navy if (status != NC_NOERR) {err = -1; goto done;} status = nc_inq_dimlen(ncid, lonIndexid, &lonLength); if (status != NC_NOERR) {err = -1; goto done;} // option to use index values? status = nc_inq_varid(ncid, "grid_lat", &latid); if (status != NC_NOERR) {err = -1; goto done;} status = nc_inq_varid(ncid, "grid_lon", &lonid); if (status != NC_NOERR) {err = -1; goto done;} } else { for (i=0;i<numdims;i++) { if (i == recid) continue; status = nc_inq_dimname(ncid,i,dimname); if (status != NC_NOERR) {err = -1; goto done;} if (!strncmpnocase(dimname,"X",1) || !strncmpnocase(dimname,"LON",3) || !strncmpnocase(dimname,"nx",2)) { lonIndexid = i; } if (!strncmpnocase(dimname,"Y",1) || !strncmpnocase(dimname,"LAT",3) || !strncmpnocase(dimname,"ny",2)) { latIndexid = i; } } status = nc_inq_dimlen(ncid, latIndexid, &latLength); if (status != NC_NOERR) {err = -1; goto done;} status = nc_inq_dimlen(ncid, lonIndexid, &lonLength); if (status != NC_NOERR) {err = -1; goto done;} status = nc_inq_varid(ncid, "LATITUDE", &latid); if (status != NC_NOERR) { status = nc_inq_varid(ncid, "lat", &latid); if (status != NC_NOERR) { status = nc_inq_varid(ncid, "latitude", &latid); if (status != NC_NOERR) {err = -1; goto done;} } } status = nc_inq_varid(ncid, "LONGITUDE", &lonid); if (status != NC_NOERR) { status = nc_inq_varid(ncid, "lon", &lonid); if (status != NC_NOERR) { status = nc_inq_varid(ncid, "longitude", &lonid); if (status != NC_NOERR) {err = -1; goto done;} } } } pt_count[0] = latLength; pt_count[1] = lonLength; vertexPtsH = (WorldPointF**)_NewHandleClear(latLength*lonLength*sizeof(WorldPointF)); if (!vertexPtsH) {err = memFullErr; goto done;} lat_vals = new float[latLength*lonLength]; lon_vals = new float[latLength*lonLength]; if (!lat_vals || !lon_vals) {err = memFullErr; goto done;} status = nc_get_vara_float(ncid, latid, ptIndex, pt_count, lat_vals); if (status != NC_NOERR) {err = -1; goto done;} status = nc_get_vara_float(ncid, lonid, ptIndex, pt_count, lon_vals); if (status != NC_NOERR) {err = -1; goto done;} for (i=0;i<latLength;i++) { for (j=0;j<lonLength;j++) { //if (lat_vals[(latLength-i-1)*lonLength+j]==fill_value) // this would be an error //lat_vals[(latLength-i-1)*lonLength+j]=0.; //if (lon_vals[(latLength-i-1)*lonLength+j]==fill_value) //lon_vals[(latLength-i-1)*lonLength+j]=0.; INDEXH(vertexPtsH,i*lonLength+j).pLat = lat_vals[(latLength-i-1)*lonLength+j]; INDEXH(vertexPtsH,i*lonLength+j).pLong = lon_vals[(latLength-i-1)*lonLength+j]; } } fVertexPtsH = vertexPtsH; status = nc_inq_dim(ncid, recid, recname, &recs); if (status != NC_NOERR) {err = -1; goto done;} if (recs<=0) {strcpy(errmsg,"No times in file. Error opening NetCDF wind file"); err = -1; goto done;} fTimeHdl = (Seconds**)_NewHandleClear(recs*sizeof(Seconds)); if (!fTimeHdl) {err = memFullErr; goto done;} for (i=0;i<recs;i++) { Seconds newTime; // possible units are, HOURS, MINUTES, SECONDS,... timeIndex = i; //if (!fIsNavy) //status = nc_get_var1_float(ncid, recid, &timeIndex, &timeVal); // recid is the dimension id not the variable id //else status = nc_get_var1_float(ncid, timeid, &timeIndex, &timeVal); if (status != NC_NOERR) {err = -1; goto done;} newTime = RoundDateSeconds(round(startTime2+timeVal*timeConversion)); //INDEXH(fTimeHdl,i) = startTime2+(long)(timeVal*timeConversion -yearShift*3600.*24.*365.25); // which start time where? //if (i==0) startTime = startTime2+(long)(timeVal*timeConversion -yearShift*3600.*24.*365.25); INDEXH(fTimeHdl,i) = newTime-yearShift*3600.*24.*365.25; // which start time where? if (i==0) startTime = newTime-yearShift*3600.*24.*365.25; } if (model->GetStartTime() != startTime || model->GetModelTime()!=model->GetStartTime()) { if (true) // maybe use NOAA.ver here? { short buttonSelected; //buttonSelected = MULTICHOICEALERT(1688,"Do you want to reset the model start time to the first time in the file?",FALSE); if(!gCommandFileRun) // also may want to skip for location files... buttonSelected = MULTICHOICEALERT(1688,"Do you want to reset the model start time to the first time in the file?",FALSE); else buttonSelected = 1; // TAP user doesn't want to see any dialogs, always reset (or maybe never reset? or send message to errorlog?) switch(buttonSelected){ case 1: // reset model start time //bTopFile = true; model->SetModelTime(startTime); model->SetStartTime(startTime); model->NewDirtNotification(DIRTY_RUNBAR); // must reset the runbar break; case 3: // don't reset model start time //bTopFile = false; break; case 4: // cancel err=-1;// user cancel goto done; } } //model->SetModelTime(startTime); //model->SetStartTime(startTime); //model->NewDirtNotification(DIRTY_RUNBAR); // must reset the runbar } fNumRows = latLength; fNumCols = lonLength; status = nc_close(ncid); if (status != NC_NOERR) {err = -1; goto done;} //err = this -> SetInterval(errmsg); //if(err) goto done; // look for topology in the file // for now ask for an ascii file, output from Topology save option // need dialog to ask for file //if (fIsNavy) // for now don't allow for wind files {if (topFilePath[0]) {err = ReadTopology(topFilePath,newMap); goto done;}} if (!gCommandFileRun) { short buttonSelected; buttonSelected = MULTICHOICEALERT(1688,"Do you have an extended topology file to load?",FALSE); switch(buttonSelected){ case 1: // there is an extended top file bTopFile = true; break; case 3: // no extended top file bTopFile = false; break; case 4: // cancel err=-1;// stay at this dialog goto done; } } if(bTopFile) { #if TARGET_API_MAC_CARBON mysfpgetfile(&where, "", -1, typeList, (MyDlgHookUPP)0, &reply, M38c, MakeModalFilterUPP(STDFilter)); if (!reply.good)/* return USERCANCEL;*/ { /*if (recs>0) err = this -> ReadTimeData(indexOfStart,&velocityH,errmsg); else {strcpy(errmsg,"No times in file. Error opening NetCDF file"); err = -1;} if(err) goto done;*/ err = dynamic_cast<NetCDFWindMoverCurv *>(this)->ReorderPoints(newMap,errmsg); //err = ReorderPoints(fStartData.dataHdl,newMap,errmsg); // if u, v input separately only do this once? goto done; } else strcpy(topPath, reply.fullPath); #else where = CenteredDialogUpLeft(M38c); sfpgetfile(&where, "", (FileFilterUPP)0, -1, typeList, (DlgHookUPP)0, &reply, M38c, (ModalFilterUPP)MakeUPP((ProcPtr)STDFilter, uppModalFilterProcInfo)); if (!reply.good) { /*if (recs>0) err = this -> ReadTimeData(indexOfStart,&velocityH,errmsg); else {strcpy(errmsg,"No times in file. Error opening NetCDF file"); err = -1;} if(err) goto done;*/ err = dynamic_cast<NetCDFWindMoverCurv *>(this)->ReorderPoints(newMap,errmsg); //err = ReorderPoints(fStartData.dataHdl,newMap,errmsg); /*if (err)*/ goto done; } my_p2cstr(reply.fName); #ifdef MAC GetFullPath(reply.vRefNum, 0, (char *)reply.fName, topPath); #else strcpy(topPath, reply.fName); #endif #endif strcpy (s, topPath); err = ReadTopology(topPath,newMap); goto done; } /*if (recs>0) err = this -> ReadTimeData(indexOfStart,&velocityH,errmsg); else {strcpy(errmsg,"No times in file. Error opening NetCDF wind file"); err = -1;} if(err) goto done;*/ err = dynamic_cast<NetCDFWindMoverCurv *>(this)->ReorderPoints(newMap,errmsg); //err = ReorderPoints(fStartData.dataHdl,newMap,errmsg); done: if (err) { printNote("Error opening NetCDF wind file"); if(fGrid) { fGrid ->Dispose(); delete fGrid; fGrid = 0; } if(vertexPtsH) {DisposeHandle((Handle)vertexPtsH); vertexPtsH = 0; fVertexPtsH = 0;} } if (timeUnits) delete [] timeUnits; if (lat_vals) delete [] lat_vals; if (lon_vals) delete [] lon_vals; if (modelTypeStr) delete [] modelTypeStr; //if (velocityH) {DisposeHandle((Handle)velocityH); velocityH = 0;} return err; }
/*! \internal */ int cpy_var_val(int in_id,int out_id,char *var_nm) /* int in_id: input netCDF input-file ID int out_id: input netCDF output-file ID char *var_nm: input variable name */ { /* Routine to copy the variable data from an input netCDF file * to an output netCDF file. */ int *dim_id; int idx; int nbr_dim; int var_in_id; int var_out_id; size_t *dim_cnt; size_t *dim_sz; size_t *dim_srt; size_t var_sz=1L; nc_type var_type_in, var_type_out; void *void_ptr = NULL; /* Get the var_id for the requested variable from both files. */ (void)nc_inq_varid(in_id, var_nm, &var_in_id); (void)nc_inq_varid(out_id,var_nm, &var_out_id); /* Get the number of dimensions for the variable. */ (void)nc_inq_vartype( out_id, var_out_id, &var_type_out); (void)nc_inq_varndims(out_id, var_out_id, &nbr_dim); (void)nc_inq_vartype( in_id, var_in_id, &var_type_in); (void)nc_inq_varndims(in_id, var_in_id, &nbr_dim); /* Allocate space to hold the dimension IDs */ dim_cnt = malloc(nbr_dim*sizeof(size_t)); dim_id=malloc(nbr_dim*sizeof(int)); dim_sz=malloc(nbr_dim*sizeof(size_t)); dim_srt=malloc(nbr_dim*sizeof(size_t)); /* Get the dimension IDs from the input file */ (void)nc_inq_vardimid(in_id, var_in_id, dim_id); /* Get the dimension sizes and names from the input file */ for(idx=0;idx<nbr_dim;idx++){ /* NB: For the unlimited dimension, ncdiminq() returns the maximum value used so far in writing data for that dimension. Thus if you read the dimension sizes from the output file, then the ncdiminq() returns dim_sz=0 for the unlimited dimension until a variable has been written with that dimension. This is the reason for always reading the input file for the dimension sizes. */ (void)nc_inq_dimlen(in_id,dim_id[idx],dim_cnt+idx); /* Initialize the indicial offset and stride arrays */ dim_srt[idx]=0L; var_sz*=dim_cnt[idx]; } /* end loop over dim */ /* Allocate enough space to hold the variable */ if (var_sz > 0) void_ptr=malloc(var_sz * type_size(var_type_in)); /* Get the variable */ /* if variable is float or double, convert if necessary */ if(nbr_dim==0){ /* variable is a scalar */ if (var_type_in == NC_INT && var_type_out == NC_INT) { nc_get_var1_int(in_id, var_in_id, 0L, void_ptr); nc_put_var1_int(out_id, var_out_id, 0L, void_ptr); } else if (var_type_in == NC_INT64 && var_type_out == NC_INT64) { nc_get_var1_longlong(in_id, var_in_id, 0L, void_ptr); nc_put_var1_longlong(out_id, var_out_id, 0L, void_ptr); } else if (var_type_in == NC_FLOAT) { nc_get_var1_float(in_id, var_in_id, 0L, void_ptr); nc_put_var1_float(out_id, var_out_id, 0L, void_ptr); } else if (var_type_in == NC_DOUBLE) { nc_get_var1_double(in_id, var_in_id, 0L, void_ptr); nc_put_var1_double(out_id, var_out_id, 0L, void_ptr); } else if (var_type_in == NC_CHAR) { nc_get_var1_text(in_id, var_in_id, 0L, void_ptr); nc_put_var1_text(out_id, var_out_id, 0L, void_ptr); } else { assert(1==0); } } else { /* variable is a vector */ if (var_type_in == NC_INT && var_type_out == NC_INT) { (void)nc_get_var_int(in_id, var_in_id, void_ptr); (void)nc_put_var_int(out_id, var_out_id, void_ptr); } else if (var_type_in == NC_INT64 && var_type_out == NC_INT64) { (void)nc_get_var_longlong(in_id, var_in_id, void_ptr); (void)nc_put_var_longlong(out_id, var_out_id, void_ptr); } else if (var_type_in == NC_FLOAT) { (void)nc_get_var_float(in_id, var_in_id, void_ptr); (void)nc_put_var_float(out_id, var_out_id, void_ptr); } else if (var_type_in == NC_DOUBLE) { (void)nc_get_var_double(in_id, var_in_id, void_ptr); (void)nc_put_var_double(out_id, var_out_id, void_ptr); } else if (var_type_in == NC_CHAR) { (void)nc_get_var_text(in_id, var_in_id, void_ptr); (void)nc_put_var_text(out_id, var_out_id, void_ptr); } else { assert(1==0); } } /* end if variable is an array */ /* Free the space that held the dimension IDs */ (void)free(dim_cnt); (void)free(dim_id); (void)free(dim_sz); (void)free(dim_srt); /* Free the space that held the variable */ (void)free(void_ptr); return(EX_NOERR); } /* end cpy_var_val() */
/*ARGSUSED*/ int main(int argc, char *argv[]) { int cmode=NC_CLOBBER, omode, ret; int id; char buf[256]; #ifdef SYNCDEBUG char *str = "one"; #endif int ii; size_t ui; const struct tcdfvar *tvp = testvars; union getret got; const size_t initialsz = 8192; size_t chunksz = 8192; size_t align = 8192/32; MPI_Init(&argc, &argv); /* cmode |= NC_PNETCDF |NC_64BIT_OFFSET; */ cmode != NC_PNETCDF |NC_64BIT_DATA; ret = nc_create_par(fname,cmode, MPI_COMM_WORLD, MPI_INFO_NULL, &id); if(ret != NC_NOERR) { fprintf(stderr,"Error %s in file %s at line %d\n",nc_strerror(ret),__FILE__,__LINE__); exit(ret); } assert( nc_put_att_text(id, NC_GLOBAL, "TITLE", 12, "another name") == NC_NOERR); assert( nc_get_att_text(id, NC_GLOBAL, "TITLE", buf) == NC_NOERR); /* (void) printf("title 1 \"%s\"\n", buf); */ assert( nc_put_att_text(id, NC_GLOBAL, "TITLE", strlen(fname), fname) == NC_NOERR); assert( nc_get_att_text(id, NC_GLOBAL, "TITLE", buf) == NC_NOERR); buf[strlen(fname)] = 0; /* (void) printf("title 2 \"%s\"\n", buf); */ assert( strcmp(fname, buf) == 0); createtestdims(id, NUM_DIMS, sizes, dim_names); testdims(id, NUM_DIMS, sizes, dim_names); createtestvars(id, testvars, NUM_TESTVARS); { int ifill = -1; double dfill = -9999; assert( nc_put_att_int(id, Long_id, _FillValue, NC_INT, 1, &ifill) == NC_NOERR); assert( nc_put_att_double(id, Double_id, _FillValue, NC_DOUBLE, 1, &dfill) == NC_NOERR); } #ifdef REDEF assert( nc__enddef(id, 0, align, 0, 2*align) == NC_NOERR ); assert( nc_put_var1_int(id, Long_id, indices[3], &birthday) == NC_NOERR ); fill_seq(id); assert( nc_redef(id) == NC_NOERR ); /* assert( nc_rename_dim(id,2, "a long dim name") == NC_NOERR); */ #endif assert( nc_rename_dim(id,1, "IXX") == NC_NOERR); assert( nc_inq_dim(id, 1, buf, &ui) == NC_NOERR); /* (void) printf("dimrename: %s\n", buf); */ assert( nc_rename_dim(id,1, dim_names[1]) == NC_NOERR); #ifdef ATTRX assert( nc_rename_att(id, 1, "UNITS", "units") == NC_NOERR); assert( nc_del_att(id, 4, "FIELDNAM")== NC_NOERR); assert( nc_del_att(id, 2, "SCALEMIN")== NC_NOERR); assert( nc_del_att(id, 2, "SCALEMAX")== NC_NOERR); #endif /* ATTRX */ assert( nc__enddef(id, 0, align, 0, 2*align) == NC_NOERR ); #ifndef REDEF fill_seq(id); assert( nc_put_var1_int(id, Long_id, indices[3], &birthday)== NC_NOERR ); #endif assert( nc_put_vara_schar(id, Byte_id, s_start, s_edges, (signed char *)sentence) == NC_NOERR); assert( nc_put_var1_schar(id, Byte_id, indices[6], (signed char *)(chs+1)) == NC_NOERR); assert( nc_put_var1_schar(id, Byte_id, indices[5], (signed char *)chs) == NC_NOERR); assert( nc_put_vara_text(id, Char_id, s_start, s_edges, sentence) == NC_NOERR); assert( nc_put_var1_text(id, Char_id, indices[6], (chs+1)) == NC_NOERR) ; assert( nc_put_var1_text(id, Char_id, indices[5], chs) == NC_NOERR); assert( nc_put_var1_short(id, Short_id, indices[4], shs) == NC_NOERR); assert( nc_put_var1_float(id, Float_id, indices[2], &e) == NC_NOERR); assert( nc_put_var1_double(id, Double_id, indices[1], &zed) == NC_NOERR); assert( nc_put_var1_double(id, Double_id, indices[0], &pinot) == NC_NOERR); #ifdef SYNCDEBUG (void) printf("Hit Return to sync\n"); gets(str); nc_sync(id,0); (void) printf("Sync done. Hit Return to continue\n"); gets(str); #endif /* SYNCDEBUG */ ret = nc_close(id); /* (void) printf("nc_close ret = %d\n\n", ret); */ /* * read it */ omode = NC_NOWRITE; omode = NC_NOWRITE | NC_PNETCDF; if(ret != NC_NOERR) { (void) printf("Could not open %s: %s\n", fname, nc_strerror(ret)); exit(1); } /* (void) printf("reopen id = %d for filename %s\n", */ /* id, fname); */ /* NC */ /* (void) printf("NC "); */ assert( nc_inq(id, &(cdesc->num_dims), &(cdesc->num_vars), &(cdesc->num_attrs), &(cdesc->xtendim) ) == NC_NOERR); assert((size_t) cdesc->num_dims == num_dims); assert(cdesc->num_attrs == 1); assert(cdesc->num_vars == NUM_TESTVARS); /* (void) printf("done\n"); */ /* GATTR */ /* (void) printf("GATTR "); */ assert( nc_inq_attname(id, NC_GLOBAL, 0, adesc->mnem) == 0); assert(strcmp("TITLE",adesc->mnem) == 0); assert( nc_inq_att(id, NC_GLOBAL, adesc->mnem, &(adesc->type), &(adesc->len))== NC_NOERR); assert( adesc->type == NC_CHAR ); assert( adesc->len == strlen(fname) ); assert( nc_get_att_text(id, NC_GLOBAL, "TITLE", buf)== NC_NOERR); buf[adesc->len] = 0; assert( strcmp(fname, buf) == 0); /* VAR */ /* (void) printf("VAR "); */ assert( cdesc->num_vars == NUM_TESTVARS ); for(ii = 0; ii < cdesc->num_vars; ii++, tvp++ ) { int jj; assert( nc_inq_var(id, ii, vdesc->mnem, &(vdesc->type), &(vdesc->ndims), vdesc->dims, &(vdesc->num_attrs)) == NC_NOERR); if(strcmp(tvp->mnem , vdesc->mnem) != 0) { (void) printf("attr %d mnem mismatch %s, %s\n", ii, tvp->mnem, vdesc->mnem); continue; } if(tvp->type != vdesc->type) { (void) printf("attr %d type mismatch %d, %d\n", ii, (int)tvp->type, (int)vdesc->type); continue; } for(jj = 0; jj < vdesc->ndims; jj++ ) { if(tvp->dims[jj] != vdesc->dims[jj] ) { (void) printf( "inconsistent dim[%d] for variable %d: %d != %d\n", jj, ii, tvp->dims[jj], vdesc->dims[jj] ); continue; } } /* VATTR */ /* (void) printf("VATTR\n"); */ for(jj=0; jj<vdesc->num_attrs; jj++ ) { assert( nc_inq_attname(id, ii, jj, adesc->mnem) == NC_NOERR); if( strcmp(adesc->mnem, reqattr[jj]) != 0 ) { (void) printf("var %d attr %d mismatch %s != %s\n", ii, jj, adesc->mnem, reqattr[jj] ); break; } } if( nc_inq_att(id, ii, reqattr[0], &(adesc->type), &(adesc->len)) != -1) { assert( adesc->type == NC_CHAR ); assert( adesc->len == strlen(tvp->units) ); assert( nc_get_att_text(id,ii,reqattr[0],buf)== NC_NOERR); buf[adesc->len] = 0; assert( strcmp(tvp->units, buf) == 0); } if( nc_inq_att(id, ii, reqattr[1], &(adesc->type), &(adesc->len)) != -1) { assert( adesc->type == NC_DOUBLE ); assert( adesc->len == 1 ); assert( nc_get_att_double(id, ii, reqattr[1], &got.dbl)== NC_NOERR); chkgot(adesc->type, got, tvp->validmin); } if( nc_inq_att(id, ii, reqattr[2], &(adesc->type), &(adesc->len)) != -1) { assert( adesc->type == NC_DOUBLE ); assert( adesc->len == 1 ); assert( nc_get_att_double(id, ii, reqattr[2], &got.dbl)== NC_NOERR); chkgot(adesc->type, got, tvp->validmax); } if( nc_inq_att(id, ii, reqattr[3], &(adesc->type), &(adesc->len)) != -1) { assert( adesc->type == NC_DOUBLE ); assert( adesc->len ==1 ); assert( nc_get_att_double(id, ii, reqattr[3], &got.dbl)== NC_NOERR); chkgot(adesc->type, got, tvp->scalemin); } if( nc_inq_att(id, ii, reqattr[4], &(adesc->type), &(adesc->len)) != -1) { assert( adesc->type == NC_DOUBLE ); assert( adesc->len == 1 ); assert( nc_get_att_double(id, ii, reqattr[4], &got.dbl)== NC_NOERR); chkgot(adesc->type, got, tvp->scalemax); } if( nc_inq_att(id, ii, reqattr[5], &(adesc->type), &(adesc->len))== NC_NOERR) { assert( adesc->type == NC_CHAR ); assert( adesc->len == strlen(tvp->fieldnam) ); assert( nc_get_att_text(id,ii,reqattr[5],buf)== NC_NOERR); buf[adesc->len] = 0; assert( strcmp(tvp->fieldnam, buf) == 0); } } /* (void) printf("fill_seq "); */ check_fill_seq(id); /* (void) printf("Done\n"); */ assert( nc_get_var1_double(id, Double_id, indices[0], &got.dbl)== NC_NOERR); /* (void) printf("got val = %f\n", got.dbl ); */ assert( nc_get_var1_double(id, Double_id, indices[1], &got.dbl)== NC_NOERR); /* (void) printf("got val = %f\n", got.dbl ); */ assert( nc_get_var1_float(id, Float_id, indices[2], &got.fl[0])== NC_NOERR); /* (void) printf("got val = %f\n", got.fl[0] ); */ assert( nc_get_var1_int(id, Long_id, indices[3], &got.in[0])== NC_NOERR); /* (void) printf("got val = %d\n", got.in[0] ); */ assert( nc_get_var1_short(id, Short_id, indices[4], &got.sh[0])== NC_NOERR); /* (void) printf("got val = %d\n", got.sh[0] ); */ assert( nc_get_var1_text(id, Char_id, indices[5], &got.by[0]) == NC_NOERR); /* (void) printf("got NC_CHAR val = %c (0x%02x) \n", */ /* got.by[0] , got.by[0]); */ assert( nc_get_var1_text(id, Char_id, indices[6], &got.by[0]) == NC_NOERR); /* (void) printf("got NC_CHAR val = %c (0x%02x) \n", */ /* got.by[0], got.by[0] ); */ (void) memset(buf,0,sizeof(buf)); assert( nc_get_vara_text(id, Char_id, s_start, s_edges, buf) == NC_NOERR); /* (void) printf("got NC_CHAR val = \"%s\"\n", buf); */ assert( nc_get_var1_schar(id, Byte_id, indices[5], (signed char *)&got.by[0])== NC_NOERR); /* (void) printf("got val = %c (0x%02x) \n", got.by[0] , got.by[0]); */ assert( nc_get_var1_schar(id, Byte_id, indices[6], (signed char *)&got.by[0])== NC_NOERR); /* (void) printf("got val = %c (0x%02x) \n", got.by[0], got.by[0] ); */ (void) memset(buf,0,sizeof(buf)); assert( nc_get_vara_schar(id, Byte_id, s_start, s_edges, (signed char *)buf)== NC_NOERR ); /* (void) printf("got val = \"%s\"\n", buf); */ { double dbuf[NUM_RECS * SIZE_1 * SIZE_2]; assert(nc_get_var_double(id, Float_id, dbuf) == NC_NOERR); /* (void) printf("got vals = %f ... %f\n", dbuf[0], */ /* dbuf[NUM_RECS * SIZE_1 * SIZE_2 -1] ); */ } ret = nc_close(id); /* (void) printf("re nc_close ret = %d\n", ret); */ MPI_Finalize(); return 0; }
void AmberNetcdf::init(const char* name, const uint natoms) { int retval; retval = nc_open(name, NC_NOWRITE, &_ncid); if (retval) throw(FileOpenError(name, "", retval)); // May want to preserve code here in the future... // Read and validate global attributes... readGlobalAttributes(); if (_conventions.empty() || _conventionVersion.empty()) throw(FileOpenError(name, "Unable to find convention global attributes. Is this really an Amber NetCDF trajectory?")); if (_conventions.find("AMBER") == std::string::npos) throw(FileOpenError(name, "Cannot find AMBER tag in global attribues. Is this really an Amber NetCDF trajectory?")); if (_conventionVersion != std::string("1.0")) throw(FileOpenError(name, "Convention version is '" + _conventionVersion + "', but only 1.0 is supported for Amber NetCDF trajectories.")); // Verify # of atoms match... int atom_id; retval = nc_inq_dimid(_ncid, "atom", &atom_id); if (retval) throw(FileOpenError(name, "Cannot read atom id"), retval); retval = nc_inq_dimlen(_ncid, atom_id, &_natoms); if (retval) throw(FileOpenError(name, "Cannot read atom length", retval)); if (_natoms != natoms) throw(FileOpenError(name, "AmberNetcdf has different number of atoms than expected")); // Get nframes int frame_id; retval = nc_inq_dimid(_ncid, "frame", &frame_id); if (retval) throw(FileOpenError(name, "Cannot read frame information", retval)); retval = nc_inq_dimlen(_ncid, frame_id, &_nframes); // Check for periodic cells... retval = nc_inq_varid(_ncid, "cell_lengths", &_cell_lengths_id); _periodic = !retval; // Any additional validation should go here... // Get coord-id for later use... retval = nc_inq_varid(_ncid, "coordinates", &_coord_id); if (retval) throw(FileOpenError(name, "Cannot get id for coordinates", retval)); // Attempt to determine timestep by looking at dT between frames 1 & 2 if (_nframes >= 2) { int time_id; retval = nc_inq_varid(_ncid, "time", &time_id); if (!retval) { float t0, t1; size_t idx[1]; idx[0] = 0; retval = nc_get_var1_float(_ncid, time_id, idx, &t0); if (retval) throw(FileOpenError(name, "Cannot get first time point", retval)); idx[0] = 1; retval = nc_get_var1_float(_ncid, time_id, idx, &t1); if (retval) throw(FileOpenError(name, "Cannot get second time point", retval)); // Assume units are in picoseconds _timestep = (t1-t0)*1e-12; } } // Now cache the first frame... readRawFrame(0); cached_first = true; }