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;
}