static int value_count(grib_accessor* a,long* count) { grib_accessor_data_apply_bitmap *self =(grib_accessor_data_apply_bitmap*)a; size_t len = 0; int ret = 0; if(grib_find_accessor(a->parent->h,self->bitmap)) ret = grib_get_size(a->parent->h,self->bitmap,&len); else ret = grib_get_size(a->parent->h,self->coded_values,&len); *count=len; return ret; }
static int unpack_double(grib_accessor* a, double* val, size_t *len) { grib_accessor_data_g2shsimple_packing* self = (grib_accessor_data_g2shsimple_packing*)a; int err = GRIB_SUCCESS; size_t n_vals = 0; if((err = grib_get_size(grib_handle_of_accessor(a),self->coded_values,&n_vals)) != GRIB_SUCCESS) return err; self->dirty=0; /* n_vals = coded_n_vals+1; */ if(*len < n_vals) { *len = n_vals; return GRIB_ARRAY_TOO_SMALL; } if((err = grib_get_double_internal(grib_handle_of_accessor(a),self->real_part,val)) != GRIB_SUCCESS) return err; val++; if((err = grib_get_double_array_internal(grib_handle_of_accessor(a),self->coded_values,val,&n_vals)) != GRIB_SUCCESS) return err; *len = n_vals; return err; }
static int unpack_double(grib_accessor* a, double* val, size_t *len) { grib_accessor_data_g1shsimple_packing* self = (grib_accessor_data_g1shsimple_packing*)a; int err = GRIB_SUCCESS; size_t coded_n_vals = 0; size_t n_vals = 0; if((err = grib_get_size(a->parent->h,self->coded_values,&coded_n_vals)) != GRIB_SUCCESS) return err; n_vals = coded_n_vals + 1; if(*len < n_vals) { *len = n_vals; return GRIB_ARRAY_TOO_SMALL; } if((err = grib_get_double_internal(a->parent->h,self->real_part,val)) != GRIB_SUCCESS) return err; val++; if((err = grib_get_double_array_internal(a->parent->h,self->coded_values,val,&coded_n_vals)) != GRIB_SUCCESS) return err; grib_context_log(a->parent->h->context, GRIB_LOG_DEBUG, "grib_accessor_data_g1shsimple_packing_bitmap : unpack_double : creating %s, %d values", a->name, n_vals); *len = n_vals; return err; }
static long value_count(grib_accessor* a) { grib_accessor_latitudes* self = (grib_accessor_latitudes*)a; grib_handle* h=a->parent->h; grib_context* c=a->parent->h->context; double* val=NULL; int ret; long len; size_t size; if ((ret=grib_get_size(h,self->values,&size))!=GRIB_SUCCESS) { grib_context_log(h->context,GRIB_LOG_ERROR,"unable to get size of %s",self->values); return 0; } len=(long)size; if (self->distinct) { ret=get_distinct(a,&val,&len); if (ret!=GRIB_SUCCESS) return 0; if (self->save) { self->lats=val; self->size=len; } else { grib_context_free(c,val); } } return len; }
static int pack_long(grib_accessor* a, const long* val, size_t *len) { double* values=NULL; size_t size=0; int ret=0; grib_accessor_bits_per_value* self= (grib_accessor_bits_per_value*)a; grib_context* c=a->context; grib_handle* h=grib_handle_of_accessor(a); if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret; values=(double*)grib_context_malloc(c,size*sizeof(double)); if (!values) return GRIB_OUT_OF_MEMORY; if((ret = grib_get_double_array_internal(h,self->values,values,&size)) != GRIB_SUCCESS) { grib_context_free(c,values); return ret; } if((ret = grib_set_long_internal(h, self->bits_per_value,*val)) != GRIB_SUCCESS) return ret; if((ret = grib_set_double_array_internal(h, self->values,values,size)) != GRIB_SUCCESS) return ret; grib_context_free(c,values); return GRIB_SUCCESS; }
static int pack_long(grib_accessor* a, const long* val, size_t *len) { grib_accessor_element* self = (grib_accessor_element*)a; int ret = 0; size_t size=0; long* ar=NULL; grib_context* c=a->parent->h->context; if(*len < 1){ ret = GRIB_ARRAY_TOO_SMALL; return ret; } if((ret = grib_get_size(a->parent->h, self->array,&size)) != GRIB_SUCCESS) return ret; ar=grib_context_malloc_clear(c,size*sizeof(long)); if (!ar) { grib_context_log(c,GRIB_LOG_ERROR,"unable to allocate %d bytes",size*sizeof(long)); return GRIB_OUT_OF_MEMORY; } if((ret = grib_get_long_array_internal(a->parent->h, self->array,ar,&size)) != GRIB_SUCCESS) return ret; ar[self->element]=*val; if((ret = grib_set_long_array_internal(a->parent->h, self->array,ar,size)) != GRIB_SUCCESS) return ret; grib_context_free(c,ar); return ret; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=0; size_t size=0; grib_accessor_size* self = (grib_accessor_size*)a; ret=grib_get_size(grib_handle_of_accessor(a),self->accessor,&size); *val=(long)size; *len =1; return ret; }
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; }
static int value_count(grib_accessor* a,long* count) { grib_accessor_data_g1shsimple_packing *self =(grib_accessor_data_g1shsimple_packing*)a; size_t len = 0; int err=0; err=grib_get_size(a->parent->h,self->coded_values,&len); len += 1; *count=len; return err; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=GRIB_SUCCESS; size_t size=0; size_t i; double max,min,d,b; double *values=0; long binaryScaleFactor,decimalScaleFactor; grib_accessor_second_order_bits_per_value* self = (grib_accessor_second_order_bits_per_value*)a; if (self->bitsPerValue) { *val=self->bitsPerValue; return GRIB_SUCCESS; } if((ret = grib_get_size(a->parent->h, self->values,&size)) != GRIB_SUCCESS) { *val=self->bitsPerValue; return GRIB_SUCCESS; } if((ret = grib_get_long(a->parent->h, self->binaryScaleFactor,&binaryScaleFactor)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h, self->decimalScaleFactor,&decimalScaleFactor)) != GRIB_SUCCESS) return ret; values=grib_context_malloc_clear(a->parent->h->context,sizeof(double)*size); if (!values) { grib_context_log(a->parent->h->context,GRIB_LOG_FATAL,"%s unable to allocate %ld bytes", a->name,(long)size); return GRIB_OUT_OF_MEMORY; } if((ret = grib_get_double_array_internal(a->parent->h, self->values,values,&size)) != GRIB_SUCCESS) return ret; max=values[0]; min=max; for (i=1;i<size;i++) { if (max<values[i]) max=values[i]; if (min>values[i]) min=values[i]; } d=grib_power(-decimalScaleFactor,10); b=grib_power(-binaryScaleFactor,2); /* self->bitsPerValue=(long)ceil(log((double)((max-min)*d+1))/log(2.0))-binaryScaleFactor; */ self->bitsPerValue=number_of_bits((unsigned long)(fabs(max-min)*b*d)); *val=self->bitsPerValue; grib_context_free(a->parent->h->context,values); return ret; }
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; }
static int value_count(grib_accessor* a,long* count) { grib_accessor_data_apply_boustrophedonic_bitmap *self =(grib_accessor_data_apply_boustrophedonic_bitmap*)a; size_t len = 0; int ret = 0; /* This accessor is for data with a bitmap after all */ Assert(grib_find_accessor(a->parent->h, self->bitmap)); ret = grib_get_size(a->parent->h, self->bitmap, &len); *count=len; return ret; }
int grib_tool_new_handle_action(grib_runtime_options* options, grib_handle* h) { size_t i=0; int err=0; if (!options->skip) { double* v=NULL; size_t size=0; if ( options->repack ) { GRIB_CHECK_NOLINE(grib_get_size(h,"values",&size),0); v = (double*)calloc(size,sizeof(double)); if(!v) { fprintf(stderr,"failed to allocate %d bytes\n",(int)(size*sizeof(double))); exit(1); } GRIB_CHECK_NOLINE(grib_get_double_array(h,"values",v,&size),0); } if (options->set_values_count != 0) { err=grib_set_values(h,options->set_values,options->set_values_count); if( err != GRIB_SUCCESS && options->fail) exit(err); } if ( options->repack ) { if (grib_options_on("d:")) { for(i = 0; i< size; i++) v[i] = options->constant; } #if 0 if (grib_options_on("n:")) { for(i = 0; i< size; i++) v[i] = options->constant; } #endif if (err == GRIB_SUCCESS) { GRIB_CHECK_NOLINE(grib_set_double_array(h,"values",v,size),0); } free(v); } if( err != GRIB_SUCCESS && options->fail) exit(err); } if (!options->skip || !options->strict) grib_tools_write_message(options,h); return 0; }
static int value_count(grib_accessor* a,long* count) { grib_accessor_latlonvalues* self = (grib_accessor_latlonvalues*)a; grib_handle* h=grib_handle_of_accessor(a); int ret; size_t size; if ((ret=grib_get_size(h,self->values,&size))!=GRIB_SUCCESS) { grib_context_log(h->context,GRIB_LOG_ERROR,"unable to get size of %s",self->values); return ret; } *count=3*size; return ret; }
static long value_count(grib_accessor* a) { grib_accessor_sum* self = (grib_accessor_sum*)a; size_t n=0; int ret=0; ret = grib_get_size(a->parent->h, self->values,&n); if (ret) grib_context_log(a->parent->h->context,GRIB_LOG_ERROR, "%s is unable to get size of %s",a->name,self->values); return n; }
static int pack_double(grib_accessor* a, const double* val, size_t *len) { double* values=NULL; size_t size=0; double missingValue=0; long missingValuesPresent = 0; int ret=0,i=0; grib_accessor_offset_values* self= (grib_accessor_offset_values*)a; grib_context* c=a->context; grib_handle* h=grib_handle_of_accessor(a); if (*val==0) return GRIB_SUCCESS; if((ret = grib_get_double_internal(h,self->missingValue,&missingValue)) != GRIB_SUCCESS) { return ret; } if((ret=grib_get_long_internal(h,"missingValuesPresent",&missingValuesPresent)) != GRIB_SUCCESS) { return ret; } if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret; values=(double*)grib_context_malloc(c,size*sizeof(double)); if (!values) return GRIB_OUT_OF_MEMORY; if((ret = grib_get_double_array_internal(h,self->values,values,&size)) != GRIB_SUCCESS) { grib_context_free(c,values); return ret; } for (i=0;i<size;i++) { if (missingValuesPresent) { if (values[i]!=missingValue) values[i]+=*val; } else { values[i]+=*val; } } if((ret = grib_set_double_array_internal(h, self->values,values,size)) != GRIB_SUCCESS) return ret; grib_context_free(c,values); return GRIB_SUCCESS; }
static int unpack_double_element(grib_accessor* a, size_t idx,double* val) { size_t size; double* values; int err = 0; /* GRIB-564: The index idx relates to codedValues NOT values! */ err=grib_get_size(a->parent->h,"codedValues",&size); if (err) return err; if (idx > size) return GRIB_INVALID_NEAREST; values=(double*)grib_context_malloc_clear(a->parent->h->context,size*sizeof(double)); err=grib_get_double_array(a->parent->h,"codedValues",values,&size); if (err) return err; *val=values[idx]; grib_context_free(a->parent->h->context,values); return err; }
static int pack_long (grib_accessor* a, const long* val, size_t *len) { long missing=255; int ret=0; size_t size=0; double* values; grib_context* c=a->parent->h->context; grib_handle* h=a->parent->h; grib_accessor_gds_is_present* self = (grib_accessor_gds_is_present*)a; if (*val != 1) return GRIB_NOT_IMPLEMENTED; if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret; values=(double*)grib_context_malloc(c,size*sizeof(double)); if (!values) return GRIB_OUT_OF_MEMORY; if((ret = grib_get_double_array_internal(h,self->values,values,&size)) != GRIB_SUCCESS) { grib_context_free(c,values); return ret; } if((ret = grib_set_long_internal(h, self->gds_present,*val)) != GRIB_SUCCESS) return ret; if((ret = grib_set_long_internal(h, self->bitmap_present,*val)) != GRIB_SUCCESS) return ret; if((ret = grib_set_long_internal(h, self->grid_definition,missing)) != GRIB_SUCCESS) return ret; if((ret = grib_set_double_array_internal(h, self->values,values,size)) != GRIB_SUCCESS) return ret; grib_context_free(c,values); return GRIB_SUCCESS; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { size_t size=0; long* vector; grib_accessor_long_vector* self = (grib_accessor_long_vector*)a; grib_accessor* va=NULL; grib_accessor_abstract_long_vector* v =NULL; va=(grib_accessor*)grib_find_accessor(a->parent->h,self->vector); v=(grib_accessor_abstract_long_vector*)va; /*TODO implement the dirty mechanism to avoid to unpack every time */ grib_get_size(a->parent->h,self->vector,&size); vector=(long*)grib_context_malloc(a->parent->h->context,sizeof(long)*size); grib_unpack_long(va,vector,&size); grib_context_free(a->parent->h->context,vector); *val = v->v[self->index]; return GRIB_SUCCESS; }
static int pack_double(grib_accessor* a, const double* val, size_t *len) { double* values=NULL; double missingValue=0; size_t size=0; int ret=0,i=0; grib_accessor_scale_values* self= (grib_accessor_scale_values*)a; grib_context* c=a->parent->h->context; grib_handle* h=a->parent->h; if (*val==1) return GRIB_SUCCESS; if((ret = grib_get_double_internal(h,self->missingValue,&missingValue)) != GRIB_SUCCESS) { return ret; } if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret; values=(double*)grib_context_malloc(c,size*sizeof(double)); if (!values) return GRIB_OUT_OF_MEMORY; if((ret = grib_get_double_array_internal(h,self->values,values,&size)) != GRIB_SUCCESS) { grib_context_free(c,values); return ret; } for (i=0;i<size;i++) if (values[i]!=missingValue) values[i]*=*val; if((ret = grib_set_double_array_internal(h, self->values,values,size)) != GRIB_SUCCESS) return ret; grib_context_free(c,values); return GRIB_SUCCESS; }
static int init(grib_iterator* i,grib_handle *h, grib_arguments* args) { grib_iterator_gen* self = (grib_iterator_gen*) i; size_t dli=0; int ret = GRIB_SUCCESS; const char* rawdat = NULL; const char* snumberOfPoints=NULL; long numberOfPoints=0; self->carg = 1; snumberOfPoints = grib_arguments_get_name(h,args,self->carg++); self->missingValue = grib_arguments_get_name(h,args,self->carg++); rawdat = grib_arguments_get_name(h,args,self->carg++); i->h = h; /* We may not need to keep them */ i->args = args; if( (ret = grib_get_size(h,rawdat,&dli))!= GRIB_SUCCESS) return ret; if( (ret = grib_get_long_internal(h,snumberOfPoints,&numberOfPoints)) != GRIB_SUCCESS) return ret; if (numberOfPoints!=dli) { grib_context_log(h->context,GRIB_LOG_ERROR,"%s != size(%s) (%ld!=%ld)", snumberOfPoints,rawdat,numberOfPoints,dli); return GRIB_WRONG_GRID; } i->nv = dli; i->data = (double*)grib_context_malloc(h->context,(i->nv)*sizeof(double)); if( (ret = grib_get_double_array_internal(h,rawdat,i->data ,&(i->nv)))) return ret; i->e = -1; return ret; }
int main(int argc, char* argv[]) { grib_handle *h=NULL; grib_context* c=NULL; FILE* fin=NULL; double *values=NULL; char buffer[BUFF_SIZE]={0,}; char buf[BUFF_SIZE]={0,}; size_t length; int sec4len; flong ksec0[ISECTION_0]; flong ksec1[ISECTION_1]; flong ksec2[ISECTION_2]; flong ksec3[ISECTION_3]; flong ksec4[ISECTION_4]; flong miss=0; const void *msg; flong gribex_msg_len=0; double rsec2[RSECTION_2]; double rsec3[RSECTION_3]; size_t nvalues=0; double* gvalues; FILE* fout; int one=1; char finname[]="sh.grib"; fin = fopen(finname,"r"); if(!fin) {perror(finname);exit(1);} c=grib_context_get_default(); length=BUFF_SIZE; GRIB_CHECK(grib_read_any_from_file(c,fin,buffer,&length),0); fclose(fin); h=grib_handle_new_from_message_copy(c,buffer,length); GRIB_CHECK(grib_get_size(h,"values",&nvalues),0); values=(double*)grib_context_malloc_clear(c,sizeof(double)*nvalues); gvalues=(double*)grib_context_malloc_clear(c,sizeof(double)*nvalues); if (!values) { printf("%s: memory allocation error\n",argv[0]); exit(1); } if (!gvalues) { printf("%s: memory allocation error\n",argv[0]); exit(1); } GRIB_CHECK(grib_get_double_array(h,"values",values,&nvalues),0); GRIB_CHECK(grib_set_long(h,"computeLaplacianOperator",1),0); GRIB_CHECK(grib_set_double_array(h,"values",values,nvalues),0); grib_write_message(h,"out_grib_api.grib","w"); sec4len=nvalues+100000; /* decode with gribex*/ msg=(char*)buffer; gribex_msg_len=length; sec4len=nvalues+100000; gribex_check(cgribex( miss, ksec0,ksec1,ksec2,rsec2,ksec3,rsec3, ksec4,gvalues,sec4len, (char*)msg,&gribex_msg_len,"D")); /* encode values with gribex*/ gribex_msg_len=BUFF_SIZE; grsmkp_(&one); gribex_check(cgribex( miss, ksec0,ksec1,ksec2,rsec2,ksec3,rsec3, ksec4,gvalues,nvalues, buf,&gribex_msg_len,"C")); fout=fopen("out_gribex.grib","w"); if (!fout) {perror("out_gribex.grib");exit(1);} if (fwrite(buf,1,gribex_msg_len,fout)!=gribex_msg_len) { perror("out_gribex.grib"); exit(1); } fclose(fout); return 0; }
int grib_tool_new_handle_action(grib_runtime_options* options, grib_handle* h) { grib_rule* r = options->rules; int i; int err=0; double scale = 1; double offset = 0; int set = options->set_values_count; while(r) { if(r->condition) { long ok = 0; GRIB_CHECK_NOLINE(grib_expression_evaluate_long(h,r->condition,&ok),NULL); if(ok) { grib_rule_entry* e = r->entries; while(e) { if (!strcmp(e->name,"skip")) return 0; Assert(set < (sizeof(options->set_values)/sizeof(options->set_values[0]))); options->set_values[set].name = e->name; options->set_values[set].error=grib_expression_set_value(h, e->value,&(options->set_values[set])); set++; e = e->next; } } } r = r->next; } if(options->verbose) { printf("Applying %d:\n",options->infile->handle_count); grib_print_values(options->set_values, set); printf("\n"); } err=grib_set_values(h,options->set_values, set); if( err != GRIB_SUCCESS) { for(i = 0; i < options->set_values_count ; i++) { if(options->set_values[i].error != GRIB_SUCCESS && options->set_values[i].error != GRIB_CONCEPT_NO_MATCH && options->fail) grib_context_log(h->context,GRIB_LOG_ERROR,"unable to set key \"%s\" (%s)", options->set_values[i].name,grib_get_error_message( options->set_values[i].error)); } } grib_get_double(h,"scaleValuesBy",&scale); grib_get_double(h,"offsetValuesBy",&offset); if(scale != 1 || offset != 0) { double *v; size_t size; int i; GRIB_CHECK_NOLINE(grib_get_size(h,"values",&size),0); v = (double*)calloc(size,sizeof(double)); if(!v) { fprintf(stderr,"failed to allocate %ld bytes\n",(long)(size*sizeof(double))); exit(1); } GRIB_CHECK_NOLINE(grib_get_double_array(h,"values",v,&size),0); if(options->verbose) { printf("Applying scale=%g/offset=%g\n",scale,offset); } for(i = 0; i< size; i++) v[i] = v[i] * scale + offset; GRIB_CHECK_NOLINE(grib_set_double_array(h,"values",v,size),0); free(v); } grib_tools_write_message(options,h); 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 codes_get_size(grib_handle* h, const char* key,size_t *size) { return grib_get_size(h,key,size); }
static int find(grib_nearest* nearest, grib_handle* h, double inlat, double inlon,unsigned long flags, double* outlats,double* outlons, double *values, double *distances,int *indexes, size_t *len) { grib_nearest_latlon_reduced* self = (grib_nearest_latlon_reduced*) nearest; int ret=0,kk=0,ii=0,jj=0; int j=0; long* pla=NULL; long* pl=NULL; size_t nvalues=0; grib_iterator* iter=NULL; double lat=0,lon=0; long iradius; double radius; int ilat=0,ilon=0; if( (ret = grib_get_size(h,self->values_key,&nvalues))!= GRIB_SUCCESS) return ret; nearest->values_count = nvalues; if (grib_is_missing(h,self->radius,&ret)) { grib_context_log(h->context, GRIB_LOG_DEBUG,"Key '%s' is missing", self->radius); return ret ? ret : GRIB_GEOCALCULUS_PROBLEM; } if( (ret = grib_get_long(h,self->radius,&iradius))!= GRIB_SUCCESS) return ret; radius=((double)iradius)/1000.0; if (!nearest->h || (flags & GRIB_NEAREST_SAME_GRID)==0) { double dummy=0; double olat=1.e10; long n=0; ilat=0,ilon=0; if (grib_is_missing(h,self->Nj,&ret)) { grib_context_log(h->context, GRIB_LOG_DEBUG,"Key '%s' is missing", self->Nj); return ret ? ret : GRIB_GEOCALCULUS_PROBLEM; } if( (ret = grib_get_long(h,self->Nj,&n))!= GRIB_SUCCESS) return ret; self->lats_count=n; if (self->lats) grib_context_free(nearest->context,self->lats); self->lats=(double*)grib_context_malloc( nearest->context, self->lats_count* sizeof(double)); if (!self->lats) return GRIB_OUT_OF_MEMORY; if (self->lons) grib_context_free(nearest->context,self->lons); self->lons=(double*)grib_context_malloc( nearest->context, nearest->values_count*sizeof(double)); if (!self->lons) return GRIB_OUT_OF_MEMORY; iter=grib_iterator_new(h,0,&ret); if (ret) { grib_context_log(h->context,GRIB_LOG_ERROR,"unable to create iterator"); return ret; } while(grib_iterator_next(iter,&lat,&lon,&dummy)) { if (olat!=lat) { self->lats[ilat++]=lat; olat=lat; } self->lons[ilon++]=lon; } self->lats_count=ilat; grib_iterator_delete(iter); } nearest->h=h; if (!self->distances || (flags & GRIB_NEAREST_SAME_POINT)==0 || (flags & GRIB_NEAREST_SAME_GRID)==0) { double* lons=NULL; int nlon=0; size_t plsize=0; long nplm1=0; int nearest_lons_found=0; double lon_first,lon_last; int islocal=0; long plmax; double dimin; if ((ret=grib_get_double(h,self->lonFirst,&lon_first))!=GRIB_SUCCESS) { grib_context_log(h->context,GRIB_LOG_ERROR, "grib_nearest_latlon_reduced.find(): unable to get %s %s\n",self->lonFirst, grib_get_error_message(ret)); return ret; } if ((ret=grib_get_double(h,self->lonLast,&lon_last))!=GRIB_SUCCESS) { grib_context_log(h->context,GRIB_LOG_ERROR, "grib_nearest_latlon_reduced.find(): unable to get %s %s\n",self->lonLast, grib_get_error_message(ret)); return ret; } plsize=self->lats_count; if( (ret=grib_get_size(h,self->pl,&plsize))!= GRIB_SUCCESS) return ret; pla=(long*)grib_context_malloc(h->context,plsize*sizeof(long)); if (!pla) return GRIB_OUT_OF_MEMORY; if( (ret=grib_get_long_array(h,self->pl,pla,&plsize))!= GRIB_SUCCESS) return ret; pl=pla; while ((*pl)==0) {pl++;} plmax=pla[0]; for (j=0;j<plsize;j++) if (plmax<pla[j]) plmax=pla[j]; dimin=360.0/plmax; if ( 360-fabs(lon_last-lon_first) < 2 * dimin ) {islocal=0;} else {islocal=1;} if (islocal) for (j=0;j<plsize;j++) pla[j]--; /* printf("XXXX islocal=%d\n",islocal); */ while (inlon<0) inlon+=360; while (inlon>360) inlon-=360; ilat=self->lats_count; if (self->lats[ilat-1] > self->lats[0]) { if (inlat < self->lats[0] || inlat > self->lats[ilat-1]) return GRIB_OUT_OF_AREA; } else { if (inlat > self->lats[0] || inlat < self->lats[ilat-1]) return GRIB_OUT_OF_AREA; } if (!self->distances) self->distances=(double*)grib_context_malloc( nearest->context,4*sizeof(double)); if (!self->distances) return GRIB_OUT_OF_MEMORY; grib_binary_search(self->lats,ilat-1,inlat, &(self->j[0]),&(self->j[1])); nlon=0; for (jj=0;jj<self->j[0];jj++) nlon+=pl[jj]; nplm1=pl[self->j[0]]-1; lons=self->lons+nlon; nearest_lons_found=0; if (lons[nplm1]>lons[0]) { if (inlon< lons[0] || inlon > lons[nplm1]) { if (lons[nplm1]-lons[0]-360 <= lons[nplm1]-lons[nplm1-1]) { self->k[0]=0; self->k[1]=nplm1; nearest_lons_found=1; } else return GRIB_OUT_OF_AREA; } } else { if (inlon >lons[0] || inlon< lons[nplm1]) { if (lons[0]-lons[nplm1]-360 <= lons[0]-lons[1]) { self->k[0]=0; self->k[1]=nplm1; nearest_lons_found=1; } else return GRIB_OUT_OF_AREA; } } if (!nearest_lons_found) { grib_binary_search(lons,pl[self->j[0]]-1,inlon, &(self->k[0]),&(self->k[1])); } self->k[0]+=nlon; self->k[1]+=nlon; nlon=0; for (jj=0;jj<self->j[1];jj++) nlon+=pl[jj]; nplm1=pl[self->j[1]]-1; lons=self->lons+nlon; nearest_lons_found=0; if (lons[nplm1]>lons[0]) { if (inlon<lons[0] || inlon>lons[nplm1]) { if (lons[nplm1]-lons[0]-360 <= lons[nplm1]-lons[nplm1-1]) { self->k[2]=0; self->k[3]=nplm1; nearest_lons_found=1; } else return GRIB_OUT_OF_AREA; } } else { if (inlon>lons[0] || inlon<lons[nplm1]) { if (lons[0]-lons[nplm1]-360 <= lons[0]-lons[1]) { self->k[2]=0; self->k[3]=nplm1; nearest_lons_found=1; } else return GRIB_OUT_OF_AREA; } } if (!nearest_lons_found) { grib_binary_search(lons,pl[self->j[1]]-1,inlon, &(self->k[2]),&(self->k[3])); } self->k[2]+=nlon; self->k[3]+=nlon; kk=0; for (jj=0;jj<2;jj++) { for (ii=0;ii<2;ii++) { self->distances[kk]=grib_nearest_distance(radius,inlon,inlat, self->lons[self->k[kk]],self->lats[self->j[jj]]); kk++; } } grib_context_free(h->context,pla); } kk=0; for (jj=0;jj<2;jj++) { for (ii=0;ii<2;ii++) { distances[kk]=self->distances[kk]; outlats[kk]=self->lats[self->j[jj]]; outlons[kk]=self->lons[self->k[kk]]; grib_get_double_element_internal(h,self->values_key,self->k[kk],&(values[kk])); indexes[kk]=self->k[kk]; kk++; } } return GRIB_SUCCESS; }
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; }
static int compare_values(grib_handle* h1,grib_handle *h2,const char *name) { size_t len1 = 0; size_t len2 = 0; int err; int err1; int err2; int type1,type2; char *sval1 = NULL,*sval2 = NULL; unsigned char *uval1 = NULL,*uval2 = NULL; double *dval1 = NULL, *dval2 = NULL; long *lval1 = NULL, *lval2 = NULL; if((err = grib_get_native_type(h1,name,&type1)) != GRIB_SUCCESS) { printf("Oops... cannot get type of [%s] in 1st field: %s\n",name,grib_get_error_message(err)); return err; } if((err = grib_get_native_type(h2,name,&type2)) != GRIB_SUCCESS) { if(err == GRIB_NOT_FOUND) { printf("[%s] not found in 2nd field\n",name); return err; } printf("Oops... cannot get type of [%s] in 2nd field: %s\n",name,grib_get_error_message(err)); return err; } if(type1 != type2) { printf("Warning, [%s] has different types: 1st field: [%s], 2nd field: [%s]\n", name,grib_get_type_name(type1),grib_get_type_name(type2)); /* return GRIB_TYPE_MISMATCH; */ } if(type1 == GRIB_TYPE_LABEL) return err; if(type1 == GRIB_TYPE_SECTION) return err; if((err = grib_get_size(h1,name,&len1)) != GRIB_SUCCESS) { printf("Oops... cannot get size of [%s] in 1st field: %s\n",name,grib_get_error_message(err)); return err; } if((err = grib_get_size(h2,name,&len2)) != GRIB_SUCCESS) { if(err == GRIB_NOT_FOUND) { printf("[%s] not found in 2nd field\n",name); return err; } printf("Oops... cannot get size of [%s] in 2nd field: %s\n",name,grib_get_error_message(err)); return err; } if(len1 != len2) { printf("[%s] has different size: 1st field: %ld, 2nd field: %ld\n",name,(long)len1,(long)len2); return GRIB_COUNT_MISMATCH; } switch(type1) { case GRIB_TYPE_STRING: sval1 = (char*)grib_context_malloc(h1->context,len1*sizeof(char)); sval2 = (char*)grib_context_malloc(h2->context,len2*sizeof(char)); if((err1 = grib_get_string(h1,name,sval1,&len1)) != GRIB_SUCCESS) { printf("Oops... cannot get string value of [%s] in 1st field: %s\n", name,grib_get_error_message(err1)); } if((err2 = grib_get_string(h2,name,sval2,&len2)) != GRIB_SUCCESS) { printf("Oops... cannot get string value of [%s] in 2nd field: %s\n", name,grib_get_error_message(err2)); } if(err1 == GRIB_SUCCESS && err2 == GRIB_SUCCESS) { if(strcmp(sval1,sval2) != 0) { printf("[%s] string values are different: [%s] and [%s]\n", name,sval1,sval2); err1 = GRIB_VALUE_MISMATCH; } } grib_context_free(h1->context,sval1); grib_context_free(h2->context,sval2); if(err1) return err1; if(err2) return err2; break; case GRIB_TYPE_LONG: lval1 = (long*)grib_context_malloc(h1->context,len1*sizeof(long)); lval2 = (long*)grib_context_malloc(h2->context,len2*sizeof(long)); if((err1 = grib_get_long_array(h1,name,lval1,&len1)) != GRIB_SUCCESS) { printf("Oops... cannot get long value of [%s] in 1st field: %s\n", name,grib_get_error_message(err1)); } if((err2 = grib_get_long_array(h2,name,lval2,&len2)) != GRIB_SUCCESS) { printf("Oops... cannot get long value of [%s] in 2nd field: %s\n", name,grib_get_error_message(err2)); } if(err1 == GRIB_SUCCESS && err2 == GRIB_SUCCESS) { int i; for(i = 0; i < len1; i++) if(lval1[i] != lval2[i]) { if(len1 == 1) printf("[%s] long values are different: [%ld] and [%ld]\n", name,lval1[i],lval2[i]); else printf("[%s] long value %d of %ld are different: [%ld] and [%ld]\n", name,i,(long)len1,lval1[i],lval2[i]); err1 = GRIB_VALUE_MISMATCH; break; } } grib_context_free(h1->context,lval1); grib_context_free(h2->context,lval2); if(err1) return err1; if(err2) return err2; break; case GRIB_TYPE_DOUBLE: dval1 = (double*)grib_context_malloc(h1->context,len1*sizeof(double)); dval2 = (double*)grib_context_malloc(h2->context,len2*sizeof(double)); if((err1 = grib_get_double_array(h1,name,dval1,&len1)) != GRIB_SUCCESS) { printf("Oops... cannot get double value of [%s] in 1st field: %s\n", name,grib_get_error_message(err1)); } if((err2 = grib_get_double_array(h2,name,dval2,&len2)) != GRIB_SUCCESS) { printf("Oops... cannot get double value of [%s] in 2nd field: %s\n", name,grib_get_error_message(err2)); } if(err1 == GRIB_SUCCESS && err2 == GRIB_SUCCESS) { int i; for(i = 0; i < len1; i++) if(!same(dval1[i],dval2[i])) { if(len1 == 1) printf("[%s] double values are different: [%g] and [%g], diff: %g\n", name,dval1[i],dval2[i],dval1[i] - dval2[i]); else printf("[%s] double value %d of %ld are different: [%g] and [%g], diff: %g\n", name,i,(long)len1,dval1[i],dval2[i],dval1[i] - dval2[i]); err1 = GRIB_VALUE_MISMATCH; break; } } grib_context_free(h1->context,dval1); grib_context_free(h2->context,dval2); if(err1) return err1; if(err2) return err2; break; case GRIB_TYPE_BYTES: uval1 = (unsigned char*)grib_context_malloc(h1->context,len1*sizeof(unsigned char)); uval2 = (unsigned char*)grib_context_malloc(h2->context,len2*sizeof(unsigned char)); if((err1 = grib_get_bytes(h1,name,uval1,&len1)) != GRIB_SUCCESS) { printf("Oops... cannot get bytes value of [%s] in 1st field: %s\n", name,grib_get_error_message(err1)); } if((err2 = grib_get_bytes(h2,name,uval2,&len2)) != GRIB_SUCCESS) { printf("Oops... cannot get bytes value of [%s] in 2nd field: %s\n", name,grib_get_error_message(err2)); } if(err1 == GRIB_SUCCESS && err2 == GRIB_SUCCESS) { if(memcmp(uval1,uval2,len1) != 0) { int i; for(i = 0; i < len1; i++) if(uval1[i] != uval2[i]) { if(len1 == 1) printf("[%s] byte values are different: [%02x] and [%02x]\n", name,uval1[i],uval2[i]); else printf("[%s] byte value %d of %ld are different: [%02x] and [%02x]\n", name,i,(long)len1,uval1[i],uval2[i]); err1 = GRIB_VALUE_MISMATCH; break; } err1 = GRIB_VALUE_MISMATCH; } } grib_context_free(h1->context,uval1); grib_context_free(h2->context,uval2); if(err1) return err1; if(err2) return err2; break; case GRIB_TYPE_LABEL: break; default: printf("Cannot compare [%s], unsupported type %d\n",name,type1); return GRIB_UNABLE_TO_COMPARE_ACCESSORS; break; } return GRIB_SUCCESS; }
int main(int argc, char* argv[]) { flong ksec0[ISECTION_0]; flong ksec1[ISECTION_1]; flong ksec2[ISECTION_2]; flong ksec3[ISECTION_3]; flong ksec4[ISECTION_4]; double rsec2[RSECTION_2]; double rsec3[RSECTION_3]; flong sec4len; flong miss=0; const void *msg; flong gribex_msg_len=0; grib_handle *h=NULL; grib_context* c=NULL; FILE* fin=NULL; /*char finname[]="/marsdev/data/p4/grib_api/main/data/exp/performance/sh.grib";*/ char* finname; double *values=NULL; size_t nvalues=0; int count,e=0; int maxnvalues; unsigned char buffer[50000000]; size_t length = sizeof(buffer); int repeat=300; grib_timer *taen,*tade,*tgen,*tgde; taen=grib_get_timer(0,"grib_api encoding", 0, 0); tgen=grib_get_timer(0,"gribex encoding", 0, 0); tade=grib_get_timer(0,"grib_api decoding", 0, 0); tgde=grib_get_timer(0,"gribex decoding", 0, 0); if (argc != 2) usage(argv[0]); finname=argv[1]; fin = fopen(finname,"r"); if(!fin) {perror(finname);exit(1);} c=grib_context_get_default(); GRIB_CHECK(grib_read_any_from_file(c,fin,buffer,&length),0); fclose(fin); /* unpack all data with grib_api */ maxnvalues=0; h=grib_handle_new_from_message_copy(c,buffer,length); GRIB_CHECK(e,0); /* decode values with grib_api*/ 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); } if (maxnvalues<nvalues) maxnvalues=nvalues; printf("decoding with grib_api\n"); grib_timer_start(tade); for (count=0;count<repeat;count++) { GRIB_CHECK(grib_get_double_array(h,"values",values,&nvalues),0); } grib_timer_stop(tade,0); printf("%d messages decoded\n",count); /* encode values with grib_api*/ printf("encoding with grib_api\n"); grib_timer_start(taen); for (count=0;count<repeat;count++) { GRIB_CHECK(grib_set_double_array(h,"values",values,nvalues),0); } grib_timer_stop(taen,0); printf("%d messages encoded\n",count); grib_handle_delete(h); grib_context_free(c,values); /* decode with gribex */ msg=(char*)buffer; sec4len=maxnvalues+100000; values = (double*)grib_context_malloc(c,sizeof(double)*(sec4len)); printf("decoding with gribex\n"); grib_timer_start(tgde); for (count=0;count<repeat;count++) { gribex_msg_len=length; gribex_check(cgribex( miss, ksec0,ksec1,ksec2,rsec2,ksec3,rsec3, ksec4,values,sec4len, (char*)msg,&gribex_msg_len,"D")); } grib_timer_stop(tgde,0); printf("%d messages decoded\n",count); #if 0 printf("encoding with gribex\n"); buflen=nvalues+100000; buf=(char*)grib_context_malloc(c,buflen*sizeof(char)); grib_timer_start(tgen); for (count=0;count<repeat;count++) { gribex_msg_len=buflen; gribex_check(cgribex( miss, ksec0,ksec1,ksec2,rsec2,ksec3,rsec3, ksec4,values,nvalues, buf,&gribex_msg_len,"C")); } grib_timer_stop(tgen,0); printf("%d messages encoded\n",count); #endif grib_print_all_timers(); grib_context_free(c,values); return 0; }