static void compare_files(const char* file1,const char* file2,FILE* out) { FILE *f1 = fopen(file1,"r"); FILE *f2 = fopen(file2,"r"); int e1 = 0; int e2 = 0; grib_handle *h1; grib_handle *h2; const void* b1; const void* b2; size_t s1; size_t s2; int count = 0; if(!f1) { perror(file1); exit(1); } if(!f2) { perror(file2); exit(1); } h1 = grib_handle_new_from_file(NULL,f1,&e1); h2 = grib_handle_new_from_file(NULL,f2,&e2); while(h1 && h2) { ++count; GRIB_CHECK(grib_get_message(h1,&b1,&s1),file1); GRIB_CHECK(grib_get_message(h2,&b2,&s2),file2); compare_handles(count,h1,h2,out); grib_handle_delete(h1); grib_handle_delete(h2); e1 = e2 = 0; h1 = grib_handle_new_from_file(NULL,f1,&e1); h2 = grib_handle_new_from_file(NULL,f2,&e2); } GRIB_CHECK(e1,file1); GRIB_CHECK(e2,file2); if(h1 != h2) { fprintf(stderr,"%s: Premature eof on %s\n",prog,h1 == 0 ? file1 : file2); exit(1); } }
static void compare_files(const char* file1,const char* file2, blacklist* bl) { FILE *f1 = fopen(file1,"r"); FILE *f2 = fopen(file2,"r"); int e1 = 0; int e2 = 0; grib_handle *h1; grib_handle *h2; int count = 0; int err = 0; grib_context* c=grib_context_get_default( ); grib_multi_support_off(c); if(!f1) { perror(file1); exit(1); } if(!f2) { perror(file2); exit(1); } h1 = grib_handle_new_from_file(c,f1,&e1); h2 = grib_handle_new_from_file(c,f2,&e2); while(h1 && h2) { ++count; printf("..............................\n"); if(compare_handles(h1,h2,bl)) err++; printf("..............................\n"); if(compare_handles(h2,h1,bl)) err++; grib_handle_delete(h1); grib_handle_delete(h2); e1 = e2 = 0; h1 = grib_handle_new_from_file(c,f1,&e1); h2 = grib_handle_new_from_file(c,f2,&e2); } GRIB_CHECK(e1,file1); GRIB_CHECK(e2,file2); if(h1 != h2) { fprintf(stderr,"%s: Premature eof on %s\n",prog,h1 == 0 ? file1 : file2); exit(1); } if(err) exit(1); }
static grib_handle* try_template(grib_context* c,const char* dir,const char* name) { char path[1024]; grib_handle *g = NULL; int err = 0; sprintf(path,"%s/%s.tmpl",dir,name); if (c->debug==-1) { printf("GRIB_API DEBUG: try_template path='%s'\n", path); } if(access(path,F_OK) == 0) { FILE* f = fopen(path,"r"); if(!f) { grib_context_log(c,GRIB_LOG_PERROR,"cannot open %s",path); return NULL; } g = grib_handle_new_from_file(c,f,&err); if (!g) { grib_context_log(c,GRIB_LOG_ERROR,"cannot create GRIB handle from %s",path); } fclose(f); } return g; }
void validate(const char* path) { FILE *f = fopen(path,"r"); grib_handle *h = 0; int err; int count = 0; if(!f) { fprintf(stderr,"%s: %s\n",path,strerror(errno)); exit(1); } while( (h= grib_handle_new_from_file(0,f,&err)) != NULL) { ++field; split(h); grib_handle_delete(h); count++; param = "unknown"; } fclose(f); if(err) { fprintf(stderr,"%s: grib_handle_new_from_file: %s\n",path,grib_get_error_message(err)); exit(1); } if(count == 0) { fprintf(stderr,"%s does not contain any GRIBs\n",path); exit(1); } }
int dump_file(const char* file,const char* out) { FILE *f = fopen(file,"r"); FILE *o = fopen(out,"w"); int e = 0; grib_handle *h; const void* b; size_t s; int count = 0; char identifier[10]; size_t size = sizeof(identifier); if(!f) { perror(file); exit(1); } h = grib_handle_new_from_file(NULL,f,&e); while(h) { GRIB_CHECK(grib_get_message(h,&b,&s),file); GRIB_CHECK(grib_get_string(h,"identifier",identifier,&size),file); ++count; fprintf(o,"%s { # %d\n",identifier,count); dump_handle(o,h); fprintf(o,"};\n"); grib_handle_delete(h); e = 0; h = grib_handle_new_from_file(NULL,f,&e); } GRIB_CHECK(e,file); return 0; }
grib_handle * GribFile::getNextHandle_() { int errorCode = 0; grib_handle * gribHandle = grib_handle_new_from_file( 0, gribFile_, & errorCode ); GRIB_CHECK( errorCode, 0 ); return gribHandle; }
int main(int argc, char** argv) { int err = 0; FILE* in = NULL; FILE* of = NULL; long step; char* filename=NULL; char* ofilename=NULL; grib_handle *h = NULL; grib_multi_handle *mh=NULL; if (argc < 3) usage(argv[0]); filename=argv[1]; ofilename=argv[2]; /* open input file */ in = fopen(filename,"r"); if(!in) { printf("ERROR: unable to open file %s\n",filename); return 1; } /* new grib handle from input file */ h = grib_handle_new_from_file(0,in,&err); GRIB_CHECK(err,0); /* create a new empty multi field handle */ mh=grib_multi_handle_new(0); if (!mh) { printf("unable to create multi field handle\n"); exit(1); } for (step=12;step<=120;step+=12) { /* set step */ grib_set_long(h,"step",step); /* append h to mh repeating the sections preceding section 4 */ grib_multi_handle_append(h,4,mh); } /* open output file */ of=fopen(ofilename,"w"); if(!of) { printf("ERROR: unable to open file %s\n",ofilename); exit(1); } /* write multi fields handle to output file */ grib_multi_handle_write(mh,of); fclose(of); /* clean memory */ grib_handle_delete(h); grib_multi_handle_delete(mh); fclose(in); return 0; }
int main(int argc, char* argv[]) { FILE* f; int err=0; char infile[]="../../data/reduced_gaussian_model_level.grib1"; grib_handle *h=NULL; grib_context* c=grib_context_get_default(); grib_values values[2]; int nvalues=2; int i; char* name = NULL; f=fopen(infile,"r"); if (!f) { perror(infile); exit(1); } h=grib_handle_new_from_file(c,f,&err); if (!h) { printf("unable to create handle from file %s\n",infile); exit(err); } fclose(f); values[0].type=GRIB_TYPE_LONG; values[0].name="centre"; values[0].long_value=98; values[1].type=GRIB_TYPE_LONG; values[1].name="level"; values[1].long_value=2; /*GRIB_VALUE_DIFFERENT -> value is different*/ err=grib_values_check(h,values,nvalues); if (err) { for (i=0;i<nvalues;i++) { if (values[i].error==err) name=(char*)values[i].name; } printf("ERROR: \"%s\" %s\n",name,grib_get_error_message(err)); } values[1].name="levelll"; err=grib_values_check(h,values,nvalues); if (err) { for (i=0;i<nvalues;i++) { if (values[i].error==err) name=(char*)values[i].name; } printf("ERROR: \"%s\" %s\n",name,grib_get_error_message(err)); } return 0; }
int main ( int argc, char* argv[]) { grib_handle *hfrom,*hto,*h; FILE *in; char *in_name,*in_name1,*out_name; int err=0; int what=0; if (argc<4) usage(argv[0]); in_name=argv[1]; in_name1=argv[2]; out_name=argv[3]; in=fopen(in_name,"r"); if (!in) { perror(in_name); exit(1); } hfrom=grib_handle_new_from_file(0,in,&err); GRIB_CHECK(err,0); fclose(in); in=fopen(in_name1,"r"); if (!in) { perror(in_name1); exit(1); } hto=grib_handle_new_from_file(0,in,&err); GRIB_CHECK(err,0); fclose(in); what=GRIB_SECTION_PRODUCT | GRIB_SECTION_LOCAL; h=grib_util_sections_copy(hfrom,hto,what,&err); GRIB_CHECK(err,0); err=grib_write_message(h,out_name,"w"); return err; }
int main(int argc, char** argv) { int err = 0,i; double *values = NULL; double max,min,average; size_t values_len= 0; FILE* in = NULL; char* filename ; grib_handle *h = NULL; if (argc<2) usage(argv[0]); filename=argv[1]; in = fopen(filename,"r"); if(!in) { printf("ERROR: unable to open file %s\n",filename); return 1; } /* create new handle from a message in a file*/ h = grib_handle_new_from_file(0,in,&err); if (h == NULL) { printf("Error: unable to create handle from file %s\n",filename); } /* get the size of the values array*/ GRIB_CHECK(grib_get_size(h,"values",&values_len),0); values = (double*)malloc(values_len*sizeof(double)); /* get data values*/ GRIB_CHECK(grib_get_double_array(h,"values",values,&values_len),0); for(i = 0; i < values_len; i++) printf("%d %.10e\n",i+1,values[i]); free(values); GRIB_CHECK(grib_get_double(h,"max",&max),0); GRIB_CHECK(grib_get_double(h,"min",&min),0); GRIB_CHECK(grib_get_double(h,"average",&average),0); printf("%d values found in %s\n",(int)values_len,filename); printf("max=%.10e min=%.10e average=%.10e\n",max,min,average); grib_handle_delete(h); fclose(in); return 0; }
int main(int argc, char** argv) { int err = 0,i; double *values = NULL; size_t values_len= 0; double element_value=0; FILE* in = NULL; char* filename ; grib_handle *h = NULL; if (argc<2) usage(argv[0]); filename=argv[1]; in = fopen(filename,"r"); if(!in) { printf("ERROR: unable to open file %s\n",filename); return 1; } /* create new handle from a message in a file*/ h = grib_handle_new_from_file(0,in,&err); if (h == NULL) { printf("Error: unable to create handle from file %s\n",filename); } /* get the size of the values array*/ GRIB_CHECK(grib_get_size(h,"values",&values_len),0); values = (double*)malloc(values_len*sizeof(double)); /* get data values*/ GRIB_CHECK(grib_get_double_array(h,"values",values,&values_len),0); if (values_len < 100) exit(1); for (i = 0; i < 100; i++) { /* get double element */ GRIB_CHECK(grib_get_double_element(h,"values",i,&element_value),0); if (element_value != values[i]) { exit(1); } } free(values); grib_handle_delete(h); fclose(in); return 0; }
void validate(const char* path) { FILE *f = fopen(path,"r"); grib_handle *h = 0; int err; int count = 0; const char* base = path; const char* p = path; file = path; field = 0; while(*p) { if(*p == '/') base = p+1; p++; } if(!f) { printf("%s: %s\n",path,strerror(errno)); error++; return; } while( (h= grib_handle_new_from_file(0,f,&err)) != NULL) { ++field; verify(h,path,base); grib_handle_delete(h); count++; param = "unknown"; } fclose(f); if(err) { printf("%s: grib_handle_new_from_file: %s\n",path,grib_get_error_message(err)); error++; return; } if(count == 0) { printf("%s does not contain any GRIBs\n",path); error++; return; } }
int main(int argc, char** argv) { int err = 0; long parameterCategory=0,parameterNumber=0,discipline=0; FILE* in = NULL; char* filename = "../../data/multi.grib2"; grib_handle *h = NULL; /* turn on support for multi fields messages */ grib_multi_support_on(0); /* turn off support for multi fields messages */ /* grib_multi_support_off(0); */ in = fopen(filename,"r"); if(!in) { printf("ERROR: unable to open file %s\n",filename); return 1; } while ((h = grib_handle_new_from_file(0,in,&err)) != NULL ) { GRIB_CHECK(err,0); GRIB_CHECK(grib_get_long(h,"discipline",&discipline),0); printf("discipline=%ld\n",discipline); GRIB_CHECK(grib_get_long(h,"parameterCategory",¶meterCategory),0); printf("parameterCategory=%ld\n",parameterCategory); GRIB_CHECK(grib_get_long(h,"parameterNumber",¶meterNumber),0); printf("parameterNumber=%ld\n",parameterNumber); if ( discipline == 0 && parameterCategory==2) { if (parameterNumber == 2) printf("-------- u -------\n"); if (parameterNumber == 3) printf("-------- v -------\n"); } grib_handle_delete(h); } fclose(in); return 0; }
void InputGrib::getLocationsCore(std::vector<Location>& iLocations) const { #ifdef WITH_GRIB std::string filename = getLocationFilename(); FILE* fid = fopen(filename.c_str(),"r"); if(!fid) { Global::logger->write("No sample file available for Grib", Logger::error); } else { int err = 0; grib_handle* h = grib_handle_new_from_file(0,fid,&err); if (h == NULL) { std::stringstream ss; ss << "Unable to create handle from file " << filename; Global::logger->write(ss.str(),Logger::error); } // Iterate over all locations grib_iterator* iter=grib_iterator_new(h,0,&err); if (err != GRIB_SUCCESS) GRIB_CHECK(err,0); int id = 0; double lat, lon; double value; while(grib_iterator_next(iter,&lat,&lon,&value)) { float elev = 0;//elevs[i]; assert(lat <= 90 && lat >= -90); Location loc(getName(), id, lat, lon); loc.setElev(elev); iLocations.push_back(loc); id++; } grib_iterator_delete(iter); grib_handle_delete(h); } fclose(fid); #else Global::logger->write("InputGrib: Program not compiled with GRIB", Logger::error); #endif }
int main(int argc, char** argv) { int err = 0; size_t size=0; FILE* in = NULL; char* infile = "../../data/regular_latlon_surface.grib1"; FILE* out = NULL; char* outfile = "out.grib1"; grib_handle *h = NULL; const void* buffer = NULL; size_t values_len; double* values; double missing=9999; int i=0; in = fopen(infile,"r"); if(!in) { printf("ERROR: unable to open input file %s\n",infile); return 1; } out = fopen(outfile,"w"); if(!out) { printf("ERROR: unable to open output file %s\n",outfile); fclose(in); return 1; } h = grib_handle_new_from_file(0,in,&err); if (h == NULL) { printf("Error: unable to create handle from file %s\n",infile); } GRIB_CHECK(grib_set_double(h,"missingValue",missing),0); /* get the size of the values array*/ GRIB_CHECK(grib_get_size(h,"values",&values_len),0); values = (double*)malloc(values_len*sizeof(double)); /* get data values*/ GRIB_CHECK(grib_get_double_array(h,"values",values,&values_len),0); GRIB_CHECK(grib_set_long(h,"bitmapPresent",1),0); for(i = 0; i < 10; i++) values[i]=missing; GRIB_CHECK(grib_set_double_array(h,"values",values,values_len),0); /* get the coded message in a buffer */ GRIB_CHECK(grib_get_message(h,&buffer,&size),0); /* write the buffer in a file*/ if(fwrite(buffer,1,size,out) != size) { perror(outfile); exit(1); } /* delete handle */ grib_handle_delete(h); fclose(in); fclose(out); return 0; }
int main(int argc, char* argv[]) { grib_handle *h1,*h2; int ret=0; FILE *f1,*f2; char* infile1; char* infile2; double *v1,*v2,*v,*gv; double *lon1,*lon2,*lon,*glon; double *lat1,*lat2,*lat,*glat; size_t size1,size2,size,gsize; double err1,err2,err; int i,j; grib_context* c; grib_iterator *iter1,*iter2; c=grib_context_get_default(); if (argc < 3) usage(argv[0]); infile1=argv[1]; infile2=argv[2]; f1=fopen(infile1,"r"); if (!f1) { perror(infile1); exit(1); } f2=fopen(infile2,"r"); if (!f2) { perror(infile2); exit(1); } while ((h1=grib_handle_new_from_file(0,f1,&ret))!=NULL) { if ((h2=grib_handle_new_from_file(c,f2,&ret))==NULL) { printf("unable to create handle from file %s\n",infile2); GRIB_CHECK(ret,0); exit(1); } GRIB_CHECK(grib_get_size(h1,"values",&size1),0); v1=malloc(size1*sizeof(double)); if (!v1) {printf("unable to allocate v1\n");exit(1);} lat1=malloc(size1*sizeof(double)); if (!lat1) {printf("unable to allocate lat1\n");exit(1);} lon1=malloc(size1*sizeof(double)); if (!lon1) {printf("unable to allocate lon1\n");exit(1);} GRIB_CHECK(grib_get_double(h1,"packingError",&err1),0); iter1=grib_iterator_new(h1,0,&ret); GRIB_CHECK(ret,0); GRIB_CHECK(grib_get_size(h2,"values",&size2),0); v2=malloc(size2*sizeof(double)); if (!v2) {printf("unable to allocate v2\n");exit(1);} lat2=malloc(size2*sizeof(double)); if (!lat2) {printf("unable to allocate lat2\n");exit(1);} lon2=malloc(size2*sizeof(double)); if (!lon2) {printf("unable to allocate lon2\n");exit(1);} GRIB_CHECK(grib_get_double(h2,"packingError",&err2),0); iter2=grib_iterator_new(h2,0,&ret); GRIB_CHECK(ret,0); lat=lat1; lon=lon1; v=v1; while(grib_iterator_next(iter1,lat,lon,v)) { lat++; if (*lon < 0 ) *lon+=360; lon++; v++; } lat=lat2; lon=lon2; v=v2; while(grib_iterator_next(iter2,lat,lon,v)) { lat++; if (*lon < 0 ) *lon+=360; lon++; v++; } if (size1 > size2) { lat=lat2;lon=lon2;v=v2; size=size2; glat=lat1;glon=lon1;gv=v1; gsize=size1; } else { lat=lat1;lon=lon1;v=v1; size=size1; glat=lat2;glon=lon2;gv=v2; gsize=size2; } if (err1>err2) err=err1; else err=err2; j=0; for (i=0;i<size;i++) { while (j < gsize && ( lat[i]!=glat[j] || lon[i]!=glon[j] ) ) j++; if (j == gsize) { j=0; while (j < gsize && ( lat[i]!=glat[j] || lon[i]!=glon[j] ) ) j++; } if (j==gsize) { printf("lat=%g lon=%g not found in global\n",lat[i],lon[i]); exit(1); } if (fabs(v[i]-gv[j])>err) { ret=1; printf("lat=%g lon=%g sub area value=%g global value=%g\n", lat[i],lon[i],v[i],gv[j]); } } free(v);free(gv);free(lat);free(glat);free(lon);free(glon); } fclose(f1); fclose(f2); return ret; }
int main(int argc, char *argv[]) { grib_handle* h = NULL; FILE* f = NULL; int i = 0; int err = 0; char *mode = "file"; for(i = 1; i < argc; i++) { if(argv[i][0] == '-') { mode = argv[i]+1; continue; } f = fopen(argv[i],"r"); if(!f) { perror(argv[i]); exit(1); } while((h = grib_handle_new_from_file(0,f,&err)) != NULL) { long width; long height; double max, min; double *values = NULL; size_t count; int i; GRIB_CHECK(grib_get_size(h,"values",&count),0); values = (double *)malloc(sizeof(double)*count); GRIB_CHECK(grib_get_long(h,"Ni",&width),0); GRIB_CHECK(grib_get_long(h,"Nj",&height),0); GRIB_CHECK(grib_get_double_array(h,"values",values,&count),0); max=values[0]; min=values[0]; for (i=1; i<count;++i) { if(values[i]>max) max = values[i]; if(values[i]<min) min = values[i]; } /* PPM header */ printf("P5\n%ld %ld\n255\n",width,height); for (i=0; i<count;++i) { char c = (values[i] - min)*255 / (max - min); printf("%c",c); } grib_handle_delete(h); } fclose(f); if(err) { fprintf(stderr,"%s\n",grib_get_error_message(err)); exit(1); } } return 0; }
int main(int argc, char** argv) { int err = 0; FILE* in = NULL; FILE* of = NULL; long edition, step; char* filename=NULL; char* ofilename=NULL; grib_handle *h = NULL; grib_multi_handle *mh=NULL; const int start_section = 4; /* Grib2 Product Definition Section */ if (argc < 3) usage(argv[0]); filename=argv[1]; ofilename=argv[2]; /* open input file */ in = fopen(filename,"r"); if(!in) { fprintf(stderr, "ERROR: unable to open input file %s\n",filename); return 1; } /* new grib handle from input file */ h = grib_handle_new_from_file(0,in,&err); GRIB_CHECK(err,0); GRIB_CHECK(grib_get_long(h,"edition",&edition),0); if (edition != 2) { fprintf(stderr, "ERROR: Input grib must be edition 2 for multi fields\n"); exit(1); } /* create a new empty multi field handle */ mh=grib_multi_handle_new(0); if (!mh) { fprintf(stderr,"ERROR: Unable to create multi field handle\n"); exit(1); } for (step=12;step<=120;step+=12) { /* set step */ grib_set_long(h,"step",step); /* append h to mh repeating from section 4 */ /* i.e. starting from section 4 all the sections to the end of the message will be copied */ grib_multi_handle_append(h, start_section, mh); } /* open output file */ of=fopen(ofilename,"w"); if(!of) { fprintf(stderr, "ERROR: unable to open output file %s\n",ofilename); exit(1); } /* write multi fields handle to output file */ grib_multi_handle_write(mh,of); fclose(of); /* release memory */ grib_handle_delete(h); grib_multi_handle_delete(mh); fclose(in); return 0; }
int main(int argc, const char *argv[]) { int i,j; FILE *in,*out; int e; grib_handle *result = NULL,*h; double* values = NULL; double *tmp = NULL; size_t size,count; fprintf(stderr, "\nWARNING: The tool %s is deprecated.\n\n", argv[0]); if(argc < 3) usage(argv[0]); out = fopen(argv[argc-1],"w"); if(!out) { perror(argv[argc-1]); exit(1); } for(i = 1; i < argc-1; i++) { in = fopen(argv[i],"r"); if(!in) { perror(argv[i]); exit(1); } while( (h = grib_handle_new_from_file(NULL,in,&e)) != NULL ) { if(result == NULL) { GRIB_CHECK(grib_get_size(h,"values",&size),argv[i]); values = (double*)calloc(size,sizeof(double)); assert(values); tmp = (double*)calloc(size,sizeof(double)); assert(tmp); result = h; } GRIB_CHECK(grib_get_size(h,"values",&count),argv[i]); assert(count == size); GRIB_CHECK(grib_get_double_array(h,"values",tmp,&count),argv[i]); assert(count == size); for(j = 0; j < count; j++) values[j] += tmp[j]; if(h != result) grib_handle_delete(h); } GRIB_CHECK(e,argv[argc-2]); } if(result) { const void *buffer; GRIB_CHECK(grib_set_double_array(result,"values",values,size),argv[i]); GRIB_CHECK(grib_get_message(result,&buffer,&size),argv[0]); if(fwrite(buffer,1,size,out) != size) { perror(argv[argc-1]); exit(1); } grib_handle_delete(result); } if(fclose(out)) { perror(argv[argc-1]); exit(1); } return 0; }
int main(int argc, char** argv) { int err = 0; size_t size=0; FILE* in = NULL; char* infile = "../../data/regular_latlon_surface.grib1"; FILE* out = NULL; char* outfile = "out.precision.grib1"; grib_handle *h = NULL; const void* buffer = NULL; double* values1=NULL; double* values2=NULL; double maxa=0; double maxv=0,minv=0; double maxr=0,r=0; long decimalPrecision; long bitsPerValue1=0, bitsPerValue2=0; int i=0; in = fopen(infile,"r"); if(!in) { printf("ERROR: unable to open input file %s\n",infile); return 1; } out = fopen(outfile,"w"); if(!out) { printf("ERROR: unable to open output file %s\n",outfile); fclose(in); return 1; } /* create a new handle from a message in a file */ h = grib_handle_new_from_file(0,in,&err); if (h == NULL) { printf("Error: unable to create handle from file %s\n",infile); } /* bitsPerValue before changing the packing parameters */ GRIB_CHECK(grib_get_long(h,"bitsPerValue",&bitsPerValue1),0); assert(bitsPerValue1 == 16); /* get the size of the values array*/ GRIB_CHECK(grib_get_size(h,"values",&size),0); assert(size == 496); values1 = (double*)malloc(size*sizeof(double)); /* get data values before changing the packing parameters*/ GRIB_CHECK(grib_get_double_array(h,"values",values1,&size),0); /* changing decimal precision to 2 means that 2 decimal digits are preserved when packing. */ decimalPrecision=2; GRIB_CHECK(grib_set_long(h,"changeDecimalPrecision",decimalPrecision),0); /* bitsPerValue after changing the packing parameters */ GRIB_CHECK(grib_get_long(h,"bitsPerValue",&bitsPerValue2),0); assert(bitsPerValue2 == 12); values2 = (double*)malloc(size*sizeof(double)); /* get data values after changing the packing parameters*/ GRIB_CHECK(grib_get_double_array(h,"values",values2,&size),0); /* computing error */ maxa=0; maxr=0; maxv=values2[0]; minv=maxv; for (i=0;i<size;i++) { double a=fabs(values2[i]-values1[i]); if ( values2[i] > maxv ) maxv=values2[i]; if ( values2[i] < minv ) minv=values2[i]; if ( values2[i] !=0 ) r=fabs((values2[i]-values1[i])/values2[i]); if ( a > maxa ) maxa=a; if ( r > maxr ) maxr=r; } printf("max absolute error = %g\n",maxa); printf("max relative error = %g\n",maxr); printf("min value = %g\n",minv); printf("max value = %g\n",maxv); assert(fabs(minv - EXPECTED_MIN) < EPSILON); assert(fabs(maxv - EXPECTED_MAX) < EPSILON); /* get the coded message in a buffer */ GRIB_CHECK(grib_get_message(h,&buffer,&size),0); /* write the buffer in a file*/ if(fwrite(buffer,1,size,out) != size) { perror(argv[1]); exit(1); } grib_handle_delete(h); fclose(in); fclose(out); return 0; }
int main(int argc, char* argv[]) { grib_handle *h=NULL; grib_context* c=NULL; FILE* fin=NULL; FILE* fout=NULL; char* finname; char* ofilename; char defofilename[]="ccsds_perf.out"; double *values=NULL; int append=0; size_t nvalues=0; int count,e=0; int repeatccsds=1; int repeatsimple=1; grib_timer *tes,*tds,*tej,*tdj; char grid_ccsds[]="grid_ccsds"; size_t grid_ccsds_l=strlen(grid_ccsds); char grid_simple[]="grid_simple"; size_t grid_simple_l=strlen(grid_simple); char packingType[50]={0,}; size_t len=50; char param[50]={0,}; char gridType[50]={0,}; char outfilename[255]={0,}; size_t filesize_ccsds=0; size_t filesize_simple=0; double perc=0; long bitsPerValue=0; int iarg=1; char grid[20]={0,}; char shortName[20]={0,}; long level; char levelType[20]={0,}; tes=grib_get_timer(0,"encoding simple", 0, 0); tds=grib_get_timer(0,"decoding simple", 0, 0); tej=grib_get_timer(0,"encoding ccsds", 0, 0); tdj=grib_get_timer(0,"decoding ccsds", 0, 0); if (argc != 4 && argc != 6 ) usage(argv[0]); if (!strcmp(argv[iarg],"-w")) { append=0; iarg++; ofilename=argv[iarg]; iarg++; } else if (!strcmp(argv[iarg],"-a")) { append=1; iarg++; ofilename=argv[iarg]; iarg++; } else { append=0; ofilename=defofilename; } finname=argv[iarg++]; repeatsimple=atoi(argv[iarg++]); bitsPerValue=atoi(argv[iarg++]); fin = fopen(finname,"r"); if(!fin) {perror(finname);exit(1);} if (append) fout = fopen(ofilename,"a"); else fout = fopen(ofilename,"w"); if(!fout) {perror(ofilename);exit(1);} c=grib_context_get_default(); e=0; h=grib_handle_new_from_file(c,fin,&e); fclose(fin); GRIB_CHECK(e,0); len=50; grib_get_string(h,"shortName",param,&len); len=20; grib_get_string(h,"levelType",levelType,&len); if (!strcmp(levelType,"pl")) { GRIB_CHECK(grib_get_long(h,"level",&level),0); sprintf(shortName,"%s%ld",param,level); } else { sprintf(shortName,"%s",param); } grib_set_long(h,"editionNumber",2); GRIB_CHECK(grib_get_size(h,"values",&nvalues),0); values=(double*)grib_context_malloc(c,sizeof(double)*nvalues); if (!values) { printf("%s: memory allocation error\n",argv[0]); exit(1); } len=50; grib_get_string(h,"gridType",gridType,&len); len=50; grib_get_string(h,"packingType",packingType,&len); GRIB_CHECK(grib_get_double_array(h,"values",values,&nvalues),0); grib_set_long(h,"bitsPerValue",bitsPerValue); GRIB_CHECK(grib_set_double_array(h,"values",values,nvalues),0); printf("--------------------------------\n"); printf("- %s - gridType=%s packingType=%s numberOfValues=%ld bitsPerValue=%ld\n", param,gridType,packingType,(long)nvalues,bitsPerValue); if (!strcmp(packingType,"spectral_complex") || !strcmp(packingType,"spectral_simple")) { printf("unable to process spectral data\n"); exit(1); } if (!strcmp(gridType,"reduced_gg") || !strcmp(gridType,"regular_gg")) { long N; grib_get_long(h,"N",&N); printf(" N=%ld\n",N); sprintf(grid,"%ld",N); } if (!strcmp(gridType,"regular_ll")) { double Di,Dj; grib_get_double(h,"DiInDegrees",&Di); grib_get_double(h,"DjInDegrees",&Dj); printf(" Di=%g Dj=%g\n",Di,Dj); sprintf(grid,"%g/%g",Di,Dj); } if (!append) fprintf(fout, "shortName gridType numberOfValues bitsPerValue grid sizeSimple sizeccsds encodeccsds encodeSimple decodeccsds decodeSimple\n"); /* decode values grid_simple */ if (strcmp(packingType,grid_simple)) grib_set_string(h,"packingType",grid_simple,&grid_simple_l); /* printf("decoding simple\n"); */ grib_timer_start(tds); for (count=0;count<repeatsimple;count++) GRIB_CHECK(grib_get_double_array(h,"values",values,&nvalues),0); grib_timer_stop(tds,0); /* printf("%d messages decoded\n\n",count); */ *outfilename='\0'; sprintf(outfilename,"%s_%s_%ld_simple.grib2",param,gridType,bitsPerValue); filesize_simple=grib_handle_write(h,outfilename); printf("file size simple = %ld\n",(long)filesize_simple); /* encode values grid_simple*/ /* printf("encoding simple\n"); */ grib_timer_start(tes); for (count=0;count<repeatsimple;count++) GRIB_CHECK(grib_set_double_array(h,"values",values,nvalues),0); grib_timer_stop(tes,0); /* printf("%d messages encoded \n\n",count); */ /* decode values grid_ccsds */ grib_set_string(h,"packingType",grid_ccsds,&grid_ccsds_l); /* printf("decoding ccsds\n"); */ grib_timer_start(tdj); for (count=0;count<repeatccsds;count++) GRIB_CHECK(grib_get_double_array(h,"values",values,&nvalues),0); grib_timer_stop(tdj,0); /* printf("%d messages decoded\n\n",count); */ *outfilename='\0'; sprintf(outfilename,"%s_%s_%ld_ccsds.grib2",param,gridType,bitsPerValue); filesize_ccsds=grib_handle_write(h,outfilename); printf("file size ccsds = %ld\n",(long)filesize_ccsds); perc=(double)filesize_simple/(double)filesize_ccsds; printf("compression ratio = %g \n",perc); printf("space savings = %g \n",(1.0-1.0/perc)*100); /* encode values grid_ccsds*/ /* printf("encoding ccsds\n"); */ grib_timer_start(tej); for (count=0;count<repeatccsds;count++) GRIB_CHECK(grib_set_double_array(h,"values",values,nvalues),0); grib_timer_stop(tej,0); /* printf("%d messages encoded \n\n",count); */ grib_handle_delete(h); grib_context_free(c,values); print_timer(tej,repeatccsds); print_timer(tdj,repeatccsds); print_timer(tes,repeatsimple); print_timer(tds,repeatsimple); printf("--------------------------------\n\n"); fprintf(fout,"%s %s %ld %ld %s %ld %ld %g %g %g %g\n", shortName,gridType,(long)nvalues,bitsPerValue, grid,(long)filesize_simple,(long)filesize_ccsds,tej->timer_/repeatccsds,tes->timer_/repeatsimple,tdj->timer_/repeatccsds,tds->timer_/repeatsimple); return 0; }
int main(int argc, char** argv) { int err = 0; double *values = NULL; size_t values_len= 0; size_t i = 0; double latitudeOfFirstGridPointInDegrees; double longitudeOfFirstGridPointInDegrees; double latitudeOfLastGridPointInDegrees; double longitudeOfLastGridPointInDegrees; double jDirectionIncrementInDegrees; double iDirectionIncrementInDegrees; long numberOfPointsAlongAParallel; long numberOfPointsAlongAMeridian; double average = 0; FILE* in = NULL; char* filename = "../data/regular_latlon_surface.grib1"; grib_handle *h = NULL; in = fopen(filename,"r"); if(!in) { printf("ERROR: unable to open file %s\n",filename); return 1; } /* create new handle from a message in a file*/ h = grib_handle_new_from_file(0,in,&err); if (h == NULL) { printf("Error: unable to create handle from file %s\n",filename); } /* get as a long*/ GRIB_CHECK(grib_get_long(h,"numberOfPointsAlongAParallel",&numberOfPointsAlongAParallel),0); printf("numberOfPointsAlongAParallel=%ld\n",numberOfPointsAlongAParallel); /* get as a long*/ GRIB_CHECK(grib_get_long(h,"numberOfPointsAlongAMeridian",&numberOfPointsAlongAMeridian),0); printf("numberOfPointsAlongAMeridian=%ld\n",numberOfPointsAlongAMeridian); /* get as a double*/ GRIB_CHECK(grib_get_double(h,"latitudeOfFirstGridPointInDegrees",&latitudeOfFirstGridPointInDegrees),0); printf("latitudeOfFirstGridPointInDegrees=%g\n",latitudeOfFirstGridPointInDegrees); /* get as a double*/ GRIB_CHECK(grib_get_double(h,"longitudeOfFirstGridPointInDegrees",&longitudeOfFirstGridPointInDegrees),0); printf("longitudeOfFirstGridPointInDegrees=%g\n",longitudeOfFirstGridPointInDegrees); /* get as a double*/ GRIB_CHECK(grib_get_double(h,"latitudeOfLastGridPointInDegrees",&latitudeOfLastGridPointInDegrees),0); printf("latitudeOfLastGridPointInDegrees=%g\n",latitudeOfLastGridPointInDegrees); /* get as a double*/ GRIB_CHECK(grib_get_double(h,"longitudeOfLastGridPointInDegrees",&longitudeOfLastGridPointInDegrees),0); printf("longitudeOfLastGridPointInDegrees=%g\n",longitudeOfLastGridPointInDegrees); /* get as a double*/ GRIB_CHECK(grib_get_double(h,"jDirectionIncrementInDegrees",&jDirectionIncrementInDegrees),0); printf("jDirectionIncrementInDegrees=%g\n",jDirectionIncrementInDegrees); /* get as a double*/ GRIB_CHECK(grib_get_double(h,"iDirectionIncrementInDegrees",&iDirectionIncrementInDegrees),0); printf("iDirectionIncrementInDegrees=%g\n",iDirectionIncrementInDegrees); /* get the size of the values array*/ GRIB_CHECK(grib_get_size(h,"values",&values_len),0); values = malloc(values_len*sizeof(double)); /* get data values*/ GRIB_CHECK(grib_get_double_array(h,"values",values,&values_len),0); average = 0; for(i = 0; i < values_len; i++) average += values[i]; average /=(double)values_len; free(values); printf("There are %d values, average is %g\n",(int)values_len,average); grib_handle_delete(h); fclose(in); return 0; }
int main(int argc, char** argv) { FILE* fin=0; int ret=0; char* fname=0; float lat,lon; double *vlat,*vlon; int npoints=0,i=0,n=0; grib_handle* h; double *outlats,*outlons,*values,*lsm_values,*distances; int* indexes; long step=0; char time[10]={0,}; char date[10]={0,}; long parameter=0; size_t len=0; long iid=0; long *id=NULL; if (argc < 2) usage(argv[0]); fname=argv[1]; fin=fopen(fname,"r"); if(!fin) { perror(fname); exit(1); } npoints=0; while (fscanf(fin,"%ld %g %g",&iid,&lat,&lon) != EOF) npoints++; fclose(fin); id=(long*)malloc(npoints*sizeof(long)); if (!id) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(long)));exit(1);} vlat=(double*)malloc(npoints*sizeof(double)); if (!vlat) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(double)));exit(1);} vlon=(double*)malloc(npoints*sizeof(double)); if (!vlon) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(double)));exit(1);} outlats=(double*)malloc(npoints*sizeof(double)); if (!outlats) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(double)));exit(1);} outlons=(double*)malloc(npoints*sizeof(double)); if (!outlons) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(double)));exit(1);} values=(double*)malloc(npoints*sizeof(double)); if (!values) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(double)));exit(1);} lsm_values=(double*)malloc(npoints*sizeof(double)); if (!lsm_values) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(double)));exit(1);} distances=(double*)malloc(npoints*sizeof(double)); if (!distances) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(double)));exit(1);} indexes=(int*)malloc(npoints*sizeof(int)); if (!indexes) {printf("unable to allocate %ld bytes\n",(long)(npoints*sizeof(double)));exit(1);} fname=argv[1]; fin=fopen(fname,"r"); if(!fin) { perror(fname); exit(1); } i=0; while (fscanf(fin,"%ld %g %g",&iid,&lat,&lon) != EOF) { id[i]=iid;vlat[i]=lat; while(lon < 0) lon+=360; vlon[i]=lon; i++; } fclose(fin); fname=argv[2]; fin=fopen(fname,"r"); if(!fin) { perror(fname); exit(1); } h=grib_handle_new_from_file(0,fin,&ret); if (!h || ret!=GRIB_SUCCESS) {printf(" unable to create handle\n");exit(1);} grib_nearest_find_multiple(h,1,vlat,vlon,npoints, outlats,outlons,lsm_values,distances,indexes); grib_handle_delete(h); fclose(fin); for (n=3;n<=argc-1;n++) { fname=argv[n]; fin=fopen(fname,"r"); if(!fin) { perror(fname); exit(1); } while ((h=grib_handle_new_from_file(0,fin,&ret))!=NULL) { grib_get_double_elements(h,"values",indexes,npoints,values); GRIB_CHECK(grib_get_length(h, "date", &len),0); grib_get_string(h,"date",date,&len); GRIB_CHECK(grib_get_length(h, "time", &len),0); grib_get_string(h,"time",time,&len); grib_get_long(h,"step",&step); grib_get_long(h,"parameter",¶meter); printf("# %s %s %ld %ld\n",date,time,step,parameter); grib_handle_delete(h); for (i=0;i<npoints;i++) printf("%ld %g %g %g %g\n", id[i],outlats[i],outlons[i], lsm_values[i],values[i]); } fclose(fin); } return ret; }
int main(int argc, char** argv) { int err = 0; size_t i = 0; size_t count; size_t size; long numberOfContributingSpectralBands; long values[1024]; FILE* in = NULL; char* filename = "../../data/satellite.grib"; grib_handle *h = NULL; in = fopen(filename,"r"); if(!in) { printf("ERROR: unable to open file %s\n",filename); return 1; } /* create new handle from a message in a file*/ h = grib_handle_new_from_file(0,in,&err); if (h == NULL) { printf("Error: unable to create handle from file %s\n",filename); } numberOfContributingSpectralBands = 2; GRIB_CHECK(grib_set_long(h,"numberOfContributingSpectralBands",numberOfContributingSpectralBands),0); numberOfContributingSpectralBands = 9; GRIB_CHECK(grib_set_long(h,"numberOfContributingSpectralBands",numberOfContributingSpectralBands),0); /* get as a long*/ GRIB_CHECK(grib_get_long(h,"numberOfContributingSpectralBands",&numberOfContributingSpectralBands),0); printf("numberOfContributingSpectralBands=%ld\n",numberOfContributingSpectralBands); /* get as a long*/ GRIB_CHECK(grib_get_size(h,"scaledValueOfCentralWaveNumber",&count),0); printf("count=%ld\n",(long)count); assert(count < sizeof(values)/sizeof(values[0])); size = count; GRIB_CHECK(grib_get_long_array(h,"scaledValueOfCentralWaveNumber",values,&size),0); assert(size == count); for(i=0;i<count;i++) printf("scaledValueOfCentralWaveNumber %lu = %ld\n",(unsigned long)i,values[i]); for(i=0;i<count;i++) values[i] = -values[i]; size = count; /* size--; */ GRIB_CHECK(grib_set_long_array(h,"scaledValueOfCentralWaveNumber",values,size),0); assert(size == count); grib_handle_delete(h); fclose(in); return 0; }
int main(int argc, char* argv[]) { int order,count,i,j,k,l; FILE *f1,*f2; double *m1,*m2,*dm; int ret=0; long numberOfValues; double geast,gwest,gnorth,gsouth; double *east,*west,*north,*south; grib_handle *h1,*h2; grib_context *c=grib_context_get_default(); int split=1; fprintf(stderr, "\nWARNING: The tool %s is deprecated.\n\n", argv[0]); if (argc!=5) usage(argv[0]); split=atoi(argv[1]); order=atoi(argv[2]); f1=fopen(argv[3],"r"); if (!f1) { perror(argv[3]); exit(1); } f2=fopen(argv[4],"r"); if (!f2) { perror(argv[4]); exit(1); } m1=(double*)grib_context_malloc_clear(c,sizeof(double)*order*order); m2=(double*)grib_context_malloc_clear(c,sizeof(double)*order*order); dm=(double*)grib_context_malloc_clear(c,sizeof(double)*order*order); east=(double*)grib_context_malloc_clear(c,sizeof(double)*split); south=(double*)grib_context_malloc_clear(c,sizeof(double)*split); north=(double*)grib_context_malloc_clear(c,sizeof(double)*split); west=(double*)grib_context_malloc_clear(c,sizeof(double)*split); count=0; while ((h1=grib_handle_new_from_file(0,f1,&ret))!=NULL && (h2=grib_handle_new_from_file(0,f2,&ret))!=NULL) { get_box(h1,&geast,&gnorth,&gwest,&gsouth); if (split>1) { double inc=0; double d=(gwest-geast)/split; inc=0; for (i=0;i<split;i++) { east[i]=geast+inc; inc+=d; west[i]=geast+inc; } d=(gnorth-gsouth)/split; inc=0; for (i=0;i<split;i++) { south[i]=gsouth+inc; inc+=d; north[i]=gsouth+inc; } } else { east[0]=geast; north[0]=gnorth; south[0]=gsouth; west[0]=gwest; } for (k=0;k<split;k++) { for (l=0;l<split;l++) { printf("- %d - east=%.3f \twest=%.3f \tsouth=%.3f \tnorth=%.3f\n",count+1,east[k],west[k],south[l],north[l]); grib_moments(h1,east[k],north[l],west[k],south[l],order,m1,&numberOfValues); grib_moments(h2,east[k],north[l],west[k],south[l],order,m2,&numberOfValues); printf("numberOfValues=%ld\n",numberOfValues); for (i=0;i<order;i++) { for (j=0;j<order;j++) { printf(" (%d,%d) ",i,j); } } printf("\n"); for (i=0;i<order*order;i++) printf("% .2e ",m1[i]); printf("\n"); for (i=0;i<order*order;i++) printf("% .2e ",m2[i]); printf("\n"); for (i=0;i<order*order;i++) printf("% .2e ",fabs((m1[i]-m2[i])/m2[i])); printf("\n\n"); } } grib_handle_delete(h2); grib_handle_delete(h1); count++; } grib_context_free(c,m1); grib_context_free(c,m2); grib_context_free(c,dm); grib_context_free(c,east); grib_context_free(c,south); grib_context_free(c,north); grib_context_free(c,west); fclose(f1); fclose(f2); return 0; }
int main(int argc, char** argv) { int err = 0; size_t values_len=0; double *values = NULL; char error_msg[100] ; size_t slong = sizeof(long) * 8 ; int i; FILE* in = NULL; char* filename ; grib_handle *h = NULL; if (argc<2) usage(argv[0]); filename=argv[1]; in = fopen(filename,"r"); if(!in) { printf("ERROR: unable to open file %s\n",filename); return 1; } /* create new handle from a message in a file*/ h = grib_handle_new_from_file(0,in,&err); if (h == NULL) { printf("Error: unable to create handle from file %s\n",filename); } for (i=0;i<255;i++) { /* get the size of the values array*/ GRIB_CHECK(grib_get_size(h,"values",&values_len),0); values = malloc(values_len*sizeof(double)); err = grib_get_double_array(h,"values",values,&values_len); GRIB_CHECK(grib_set_long(h,"bitsPerValue",i),0); err = grib_set_double_array(h,"values",values,values_len); free(values); values = 0; /* * check if encoding of the data fails when the number of bpv * is not supported; bpv allowed on decoding is bpv < size of long */ if (i < slong && err == 0) { /* do nothing */ } else if (i >= slong && err == GRIB_INVALID_BPV) { /* do nothing */ } else { sprintf(error_msg,"Error decoding when bpv=%d. Error message:%s",i,grib_get_error_message(err)); perror(error_msg); exit(1); } values = malloc(values_len*sizeof(double)); err = grib_get_double_array(h,"values",values,&values_len); /* * check if decoding of the data fails when the number of bpv * is not supported; bpv allowed on decoding is bpv <= size of long */ if (i <= slong && err == 0) { /* do nothing */ } else if (i > slong && err == GRIB_INVALID_BPV) { /* do nothing */ } else { sprintf(error_msg,"Error decoding when bpv=%d. Error message:%s",i,grib_get_error_message(err)); perror(error_msg); exit(1); } free(values); values = 0; } grib_handle_delete(h); h=0; fclose(in); return 0; }
int main(int argc, char** argv) { FILE* fin=0; int ret=0; char* fname=0; float lat,lon; double *vlat,*vlon; int npoints=0,i=0,n=0; grib_handle* h; double *outlats,*outlons,*values,*lsm_values,*distances; size_t* indexes; if (argc < 2) usage(argv[0]); fname=argv[1]; fin=fopen(fname,"r"); if(!fin) { perror(fname); exit(1); } npoints=0; while (fscanf(fin,"%g %g",&lat,&lon) != EOF) npoints++; fclose(fin); vlat=(double*)malloc(npoints*sizeof(double)); if (!vlat) {printf("unable to allocate %d bytes\n",npoints*sizeof(double));exit(1);} vlon=(double*)malloc(npoints*sizeof(double)); if (!vlon) {printf("unable to allocate %d bytes\n",npoints*sizeof(double));exit(1);} outlats=(double*)malloc(npoints*sizeof(double)); if (!outlats) {printf("unable to allocate %d bytes\n",npoints*sizeof(double));exit(1);} outlons=(double*)malloc(npoints*sizeof(double)); if (!outlons) {printf("unable to allocate %d bytes\n",npoints*sizeof(double));exit(1);} values=(double*)malloc(npoints*sizeof(double)); if (!values) {printf("unable to allocate %d bytes\n",npoints*sizeof(double));exit(1);} lsm_values=(double*)malloc(npoints*sizeof(double)); if (!lsm_values) {printf("unable to allocate %d bytes\n",npoints*sizeof(double));exit(1);} distances=(double*)malloc(npoints*sizeof(double)); if (!distances) {printf("unable to allocate %d bytes\n",npoints*sizeof(double));exit(1);} indexes=(size_t*)malloc(npoints*sizeof(double)); if (!indexes) {printf("unable to allocate %d bytes\n",npoints*sizeof(double));exit(1);} fname=argv[1]; fin=fopen(fname,"r"); if(!fin) { perror(fname); exit(1); } i=0; while (fscanf(fin,"%g %g",&lat,&lon) != EOF) {vlat[i]=lat; vlon[i]=lon>0 ? lon : lon+360; i++;} fclose(fin); fname=argv[2]; fin=fopen(fname,"r"); if(!fin) { perror(fname); exit(1); } h=grib_handle_new_from_file(0,fin,&ret); if (!h || ret!=GRIB_SUCCESS) {printf(" unable to create handle\n");exit(1);} grib_nearest_find_multiple(h,1,vlat,vlon,npoints, outlats,outlons,lsm_values,distances,indexes); grib_handle_delete(h); fclose(fin); for (n=3;n<=argc-1;n++) { fname=argv[n]; fin=fopen(fname,"r"); if(!fin) { perror(fname); exit(1); } while ((h=grib_handle_new_from_file(0,fin,&ret))!=NULL) { grib_get_double_elements(h,"values",indexes,npoints,values); grib_handle_delete(h); for (i=0;i<npoints;i++) printf("%g %g %g %g %g %g\n", vlat[i],vlon[i], outlats[i],outlons[i], lsm_values[i],values[i]); } fclose(fin); } return ret; }
/* The options have been parsed and the structure grib_runtime_options* options has been loaded. Initialisation and startup can be done here */ int grib_tool_init(grib_runtime_options* options) { char *theEnd = NULL, *end1=NULL; size_t size=4; int ret=0; double min=0,max=0; int i=0; char* p=NULL; if (options->latlon && grib_options_on("j")) { options->verbose=0; json_latlon=1; } if (options->latlon) { lat = strtod(options->latlon,&theEnd); if (*theEnd != ',') { printf("ERROR: wrong latitude value\n"); exit(1); } lon= strtod(++theEnd,&end1); mode=GRIB_NEAREST_SAME_POINT | GRIB_NEAREST_SAME_GRID; if (end1 && *end1 == ',') { end1++; if (*end1 != '0') { p=end1; while (*p != ',' && *p !='\0') p++; if (*end1 == '4') { options->latlon_mode=4; } else if (*end1 == '1') { options->latlon_mode=1; } else { printf("ERROR %s: wrong mode given in option -l\n",grib_tool_name); exit(1); } } if (*p == ',') { p++; options->latlon_mask=strdup(p); } } } if (options->latlon && options->latlon_mask) { FILE* f=NULL; grib_handle* hh; int idx=0, land_found=0; double min_overall = 0.0; int idx_overall = -1; f=fopen(options->latlon_mask,"r"); if(!f) { perror(options->latlon_mask); exit(1); } hh=grib_handle_new_from_file(0,f,&ret); fclose(f); GRIB_CHECK_NOLINE(ret,0); n=grib_nearest_new(hh,&ret); GRIB_CHECK_NOLINE(ret,0); GRIB_CHECK_NOLINE(grib_nearest_find(n,hh,lat,lon,mode, options->lats,options->lons,options->mask_values,options->distances,options->indexes,&size),0); grib_nearest_delete(n); n=NULL; grib_handle_delete(hh); options->latlon_idx=-1; max=options->distances[0]; for (i=0;i<4;i++) if (max<options->distances[i]) {max=options->distances[i];} min=max; min_overall=max; /* See GRIB-213 */ for (i=0;i<4;i++) { if (min_overall >= options->distances[i]) { /* find overall min and index ignoring mask */ min_overall = options->distances[i]; idx_overall = i; } if ((min >= options->distances[i]) && (options->mask_values[i] >= 0.5)) { land_found=1; /* found at least one point which is land */ min = options->distances[i]; idx = i; } } if (land_found) { options->latlon_idx=idx; } else { options->latlon_idx=idx_overall; /* all points were sea, so pick the min overall */ } if (options->latlon_idx<0){ min=0; options->latlon_idx=0; for (i=1;i<4;i++) if (min>options->distances[i]) { min = options->distances[i]; options->latlon_idx=i; } } } if (json_latlon) printf("[\n"); return 0; }
float InputGrib::getValueCore(const Key::Input& iKey) const { #ifdef WITH_GRIB // Check that date hasn't been checked before std::map<int,std::map<float, bool> >::const_iterator it0 = mMissingFiles.find(iKey.date); if(it0 != mMissingFiles.end()) { // Date has missing files std::map<float, bool>::const_iterator it1 = it0->second.find(iKey.offset); if(it1 != it0->second.end()) { writeMissingToCache(iKey); return Global::MV; } } std::string localVariable; bool found = getLocalVariableName(iKey.variable, localVariable); assert(found); int numLocations = Input::getNumLocations(); std::string filename = getFilename(iKey); std::stringstream ss; ss << "InputGrib: Loading " << filename << " " << iKey.date << " " << iKey.offset << " " << iKey.location << " " << localVariable; Global::logger->write(ss.str(), Logger::message); bool foundVariable = false; FILE* fid = fopen(filename.c_str(),"r"); float value = Global::MV; if(fid) { // GRIB File found int err = 0; grib_handle* h = NULL; // double s = Global::clock(); // Try to use an index to read file as this is much faster. Fall back on just reading the // GRIB file. grib_index* gribIndex = getIndex(iKey, localVariable); bool validIndex = (gribIndex != NULL); if(!validIndex) { std::stringstream ss; ss << "InputGrib: No index file available for " << filename; Global::logger->write(ss.str(), Logger::message); } int counter = 1; // Loop over available variables (in index or in file) while(1) { // Read message from file or index if(!validIndex) { h = grib_handle_new_from_file(0,fid,&err); } else { h = grib_handle_new_from_index(gribIndex,&err); } if(h == NULL) break; // No more messages to process std::string currVariable = getVariableName(h); std::stringstream ss; ss << "InputGrib: Reading message #" << counter << ": " << currVariable; Global::logger->write(ss.str(), Logger::message); // Check if the current variable is defined in the variable list int variableId; found = getVariableIdFromLocalVariable(currVariable, variableId); if(!found) { std::stringstream ss; ss << "InputGrib: Found variable " << currVariable << " in " << filename << " but this is not mapped to any variable in namelist" << std::endl; Global::logger->write(ss.str(), Logger::message); } else { // Only read the current variable if necessary if(mCacheOtherVariables || currVariable == localVariable) { std::vector<float> currValues; currValues.resize(numLocations, Global::MV); int numValid = 0; // Check that the message has the right number of locations size_t N; GRIB_CHECK(grib_get_size(h,"values",&N),0); if(N == numLocations) { foundVariable = foundVariable || (currVariable == localVariable); double* arr = new double[N]; GRIB_CHECK(grib_get_double_array(h,"values",arr,&N),0); currValues.assign(arr, arr + numLocations); for(int i = 0; i < (int) currValues.size(); i++) { if(currValues[i] == mMV) currValues[i] = Global::MV; else numValid++; } std::stringstream ss; ss << "InputGrib: Number of valid values: " << numValid; Global::logger->write(ss.str(), Logger::message); delete arr; } else { std::stringstream ss; ss << "GribInput: Discarding variable " << currVariable << " in " << filename << " because it has incorrect number of locations"; Global::logger->write(ss.str(), Logger::debug); } Key::Input key = iKey; key.offset = getOffset(h); // Cache values for(int i = 0; i < numLocations; i++) { key.location = i; key.variable = variableId; if(key.location == iKey.location && currVariable == localVariable) { // Found the value value = currValues[i]; } if(mCacheOtherLocations || key.location == iKey.location) { //if(currVariable == localVariable) // std::cout << currValues[i] << std::endl; Input::addToCache(key, currValues[i]); } } } } if(h) { grib_handle_delete(h); } // Quit reading file if we have found the variable we need if(!mCacheOtherVariables && (currVariable == localVariable)) { break; } counter++; } if(!foundVariable) { // File was there, but couldn't find variable std::stringstream ss; ss << "InputGrib: Could not find variable " << localVariable << " in " << filename; Global::logger->write(ss.str(), Logger::warning); writeMissingToCache(iKey); } if(validIndex) { grib_index_delete(gribIndex); } // double e = Global::clock(); //std::cout << "Grib read time: " << e - s << " seconds" << std::endl; fclose(fid); return value; } else { // GRIB file not found std::stringstream ss; ss << "GribInput: File not found: " << filename; Global::logger->write(ss.str(), Logger::message); std::vector<float> currValues; currValues.resize(numLocations, Global::MV); for(int i = 0; i < numLocations; i++) { Key::Input key = iKey; key.location = i; if(mCacheOtherLocations || key.location == iKey.location) Input::addToCache(key, currValues[i]); } return Global::MV; } #else return Global::MV; #endif }
int grib_tool_init(grib_runtime_options* options) { char *end = NULL, *end1=NULL; size_t size=4; int ret=0; double min=0,max=0; int i=0; char* p=NULL; options->print_header=0; options->print_statistics=0; options->default_print_width=-1; if (options->latlon) { lat = strtod(options->latlon,&end); if (*end != ',') { printf("ERROR: wrong latitude value\n"); exit(1); } lon= strtod(++end,&end1); mode=GRIB_NEAREST_SAME_POINT | GRIB_NEAREST_SAME_GRID; if (end1 && *end1 == ',') { end1++; if (*end1 != '0') { p=end1; while (*p != ',' && *p !='\0') p++; if (*end1 == '4') { options->latlon_mode=4; } else if (*end1 == '1') { options->latlon_mode=1; } else { printf("ERROR %s: wrong mode given in option -l\n",grib_tool_name); exit(1); } } if (*p == ',') { p++; options->latlon_mask=strdup(p); } } } if (options->latlon && options->latlon_mask) { FILE* f=NULL; grib_handle* hh; f=fopen(options->latlon_mask,"r"); if(!f) { perror(options->latlon_mask); exit(1); } hh=grib_handle_new_from_file(0,f,&ret); fclose(f); GRIB_CHECK_NOLINE(ret,0); n=grib_nearest_new(hh,&ret); GRIB_CHECK_NOLINE(ret,0); GRIB_CHECK_NOLINE(grib_nearest_find(n,hh,lat,lon,mode, options->lats,options->lons,options->mask_values,options->distances,options->indexes,&size),0); grib_nearest_delete(n); n=NULL; grib_handle_delete( hh); options->latlon_idx=-1; max=options->distances[0]; for (i=0;i<4;i++) if (max<options->distances[i]) {max=options->distances[i];} min=max; for (i=0;i<4;i++) { if ((min >= options->distances[i]) && (options->mask_values[i] >= 0.5)) { options->latlon_idx=i; min = options->distances[i]; } } if (options->latlon_idx<0){ min=0; options->latlon_idx=0; for (i=1;i<4;i++) if (min>options->distances[i]) { min = options->distances[i]; options->latlon_idx=i; } } } return 0; }