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 get_box(grib_handle *h,double *east,double *north,double *west,double *south) { int ret=0; long iScansNegatively,jScansPositively; ret=grib_get_long(h,"iScansNegatively",&iScansNegatively); if (ret) return ret; ret=grib_get_long(h,"jScansPositively",&jScansPositively); if (ret) return ret; if (iScansNegatively) { grib_get_double(h,"longitudeOfFirstGridPointInDegrees",west); grib_get_double(h,"longitudeOfLastGridPointInDegrees",east); } else { grib_get_double(h,"longitudeOfFirstGridPointInDegrees",east); grib_get_double(h,"longitudeOfLastGridPointInDegrees",west); } if (jScansPositively) { grib_get_double(h,"latitudeOfFirstGridPointInDegrees",south); grib_get_double(h,"latitudeOfLastGridPointInDegrees",north); } else { grib_get_double(h,"latitudeOfFirstGridPointInDegrees",north); grib_get_double(h,"latitudeOfLastGridPointInDegrees",south); } if (*east>*west) *east-=360; return ret; }
int grib_fieldset_column_copy_from_handle(grib_handle* h,grib_fieldset* set,int i) { int err=0; long lval=0; double dval=0; char sval[1024]; size_t slen=1024; if (!set || !h || set->columns[i].type == 0) return GRIB_INVALID_ARGUMENT; if (set->columns[i].size >= set->columns[i].values_array_size) grib_fieldset_columns_resize(set,set->columns[i].values_array_size+GRIB_ARRAY_INCREMENT); switch (set->columns[i].type) { case GRIB_TYPE_LONG: err=grib_get_long(h,set->columns[i].name,&lval); set->columns[i].long_values[set->columns[i].size]=lval; break; case GRIB_TYPE_DOUBLE: err=grib_get_double(h,set->columns[i].name,&dval); set->columns[i].double_values[set->columns[i].size]=dval; break; case GRIB_TYPE_STRING: err=grib_get_string(h,set->columns[i].name,sval,&slen); set->columns[i].string_values[set->columns[i].size]=grib_context_strdup(h->context,sval); break; } set->columns[i].errors[set->columns[i].size]=err; set->columns[i].size++; return err; }
double dget(grib_handle *h,const char* what) { int e; double val; if((e = grib_get_double(h,what,&val)) != GRIB_SUCCESS) { fprintf(stderr,"%s, field %d [%s]: cannot get %s: %s\n",file,field,param,what,grib_get_error_message(e)); exit(1); val = -1; } return val; }
static grib_values* get_key_values(grib_runtime_options* options,grib_handle* h) { int i=0; int ret=0; char value[MAX_STRING_LEN]={0,}; char* notfound="not found"; for (i=0;i<options->print_keys_count;i++) { size_t len=MAX_STRING_LEN; ret=GRIB_SUCCESS; if (grib_is_missing(h,options->print_keys[i].name,&ret) && ret==GRIB_SUCCESS) { options->print_keys[i].type=GRIB_TYPE_MISSING; sprintf(value,"MISSING"); } else if ( ret != GRIB_NOT_FOUND ){ if (options->print_keys[i].type == GRIB_TYPE_UNDEFINED) { grib_get_native_type(h,options->print_keys[i].name,&(options->print_keys[i].type)); } switch (options->print_keys[i].type) { case GRIB_TYPE_STRING: ret=grib_get_string( h,options->print_keys[i].name,value,&len); break; case GRIB_TYPE_DOUBLE: ret=grib_get_double( h,options->print_keys[i].name, &(options->print_keys[i].double_value)); sprintf(value,"%g",options->print_keys[i].double_value); break; case GRIB_TYPE_LONG: ret=grib_get_long( h,options->print_keys[i].name, &(options->print_keys[i].long_value)); sprintf(value,"%ld",(long)options->print_keys[i].long_value); break; default: fprintf(dump_file,"invalid type for %s\n",options->print_keys[i].name); exit(1); } } if (ret != GRIB_SUCCESS) { if (options->fail) GRIB_CHECK_NOLINE(ret,options->print_keys[i].name); if (ret == GRIB_NOT_FOUND) strcpy(value,notfound); else { fprintf(dump_file,"%s %s\n",grib_get_error_message(ret),options->print_keys[i].name); exit(ret); } } options->print_keys[i].string_value=strdup(value); } return options->print_keys; }
static void print_key_values(grib_runtime_options* options,grib_handle* h) { int i; int ret=0; char* s="\"keys\" : {"; double dvalue=0; long lvalue=0; char value[MAX_STRING_LEN]; size_t len=MAX_STRING_LEN; for (i=0;i<options->print_keys_count;i++) { ret=GRIB_SUCCESS; printf("%s",s); len=MAX_STRING_LEN; printf("\"%s\" : ",options->print_keys[i].name); if (grib_is_missing(h,options->print_keys[i].name,&ret) && ret==GRIB_SUCCESS) printf("\"missing\""); else if ( ret == GRIB_SUCCESS ) { if (options->print_keys[i].type == GRIB_TYPE_UNDEFINED) grib_get_native_type(h,options->print_keys[i].name,&(options->print_keys[i].type)); switch (options->print_keys[i].type) { case GRIB_TYPE_STRING: ret=grib_get_string( h,options->print_keys[i].name,value,&len); printf("\"%s\"",value); break; case GRIB_TYPE_DOUBLE: ret=grib_get_double( h,options->print_keys[i].name,&dvalue); printf("%g",dvalue); break; case GRIB_TYPE_LONG: ret=grib_get_long( h,options->print_keys[i].name,&lvalue); printf("%ld",lvalue); break; default: printf("invalid_type"); break; } } if (ret == GRIB_NOT_FOUND) printf("null"); s=", "; } printf("}"); }
int main(int argc, char* argv[]) { int i; grib_handle *h=NULL; grib_handle *hso=NULL; grib_context* c=NULL; FILE* fin=NULL; FILE* fout=NULL; char* finname; char* ofilename; char defofilename[]="so_perf.out"; double *values=NULL; double gvalues[1000000]={0,}; double sovalues[1000000]={0,}; int append=0; size_t nvalues=0; int count,e=0; int repeatso=1; int repeatsimple=1; grib_timer *tes,*tds,*teso,*tdso; 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_so=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,}; 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 packingError=0; double rsec2[RSECTION_2]; double rsec3[RSECTION_3]; tes=grib_get_timer(0,"encoding simple", 0, 0); tds=grib_get_timer(0,"decoding simple", 0, 0); teso=grib_get_timer(0,"encoding so", 0, 0); tdso=grib_get_timer(0,"decoding so", 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);} c=grib_context_get_default(); length=BUFF_SIZE; GRIB_CHECK(grib_read_any_from_file(c,fin,buffer,&length),0); fclose(fin); 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_message_copy(c,buffer,length); 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_clear(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); GRIB_CHECK(grib_get_double(h,"packingError",&packingError),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 sizeso encodeso encodeSimple decodeso decodeSimple\n"); sec4len=nvalues+100000; /* decode values grid_simple */ if (strcmp(packingType,grid_simple)) grib_set_string(h,"packingType",grid_simple,&grid_simple_l); 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); *outfilename='\0'; sprintf(outfilename,"%s_%s_%ld_%ld_simple.grib1",param,gridType,bitsPerValue,(long)nvalues); filesize_simple=grib_handle_write(h,outfilename); printf("file size simple = %ld\n",(long)filesize_simple); /* encode values grid_simple*/ 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); /* decode with gribex*/ msg=(char*)buffer; gribex_msg_len=BUFF_SIZE; sec4len=nvalues+100000; gribex_check(cgribex( miss, ksec0,ksec1,ksec2,rsec2,ksec3,rsec3, ksec4,gvalues,sec4len, (char*)msg,&gribex_msg_len,"D")); /* encode values second order with gribex*/ ksec4[1] = bitsPerValue; /* to indicate complex packing. */ ksec4[3] = 64; /* to indicate extended flags are present. */ ksec4[5] = 16; ksec4[9] = 16; ksec4[11] = 8; ksec4[12] = 4; ksec4[13] = 0; ksec4[14] = -1; gribex_msg_len=BUFF_SIZE; grib_timer_start(teso); gribex_check(cgribex( miss, ksec0,ksec1,ksec2,rsec2,ksec3,rsec3, ksec4,gvalues,nvalues, buf,&gribex_msg_len,"K")); grib_timer_stop(teso,0); hso=grib_handle_new_from_message_copy(c,buf,gribex_msg_len); GRIB_CHECK(grib_get_double_array(h,"values",sovalues,&nvalues),0); *outfilename='\0'; sprintf(outfilename,"%s_%s_%ld_%ld_so.grib1",param,gridType,bitsPerValue,(long)nvalues); filesize_so=grib_handle_write(hso,outfilename); printf("file size so = %ld\n",(long)filesize_so); perc=(double)filesize_simple/(double)filesize_so; printf("compression ratio = %g \n",perc); printf("space savings = %g \n",(1.0-1.0/perc)*100); grib_handle_delete(h); /* decode values second order */ /* decode with gribex*/ msg=(char*)buf; gribex_msg_len=BUFF_SIZE; sec4len=nvalues+100000; grib_timer_start(tdso); gribex_check(cgribex( miss, ksec0,ksec1,ksec2,rsec2,ksec3,rsec3, ksec4,gvalues,sec4len, (char*)msg,&gribex_msg_len,"D")); grib_timer_stop(tdso,0); for (i=0;i<nvalues;i++) { if (fabs(gvalues[i]-values[i])>packingError) { printf("++++++++ Wrong coding\n"); printf("packingError=%g gvalues[%d]=%.20e values[%d]=%.20e abs. err=%g \n",packingError,i, gvalues[i],i,values[i],gvalues[i]-values[i]); } } for (i=0;i<nvalues;i++) { if (fabs(gvalues[i]-sovalues[i])>packingError) { printf("++++++++ Wrong coding\n"); printf("packingError=%g gvalues[%d]=%.20e sovalues[%d]=%.20e abs. err=%g \n",packingError,i, gvalues[i],i,sovalues[i],gvalues[i]-sovalues[i]); } } grib_handle_delete(hso); grib_context_free(c,values); print_timer(teso,repeatso); print_timer(tdso,repeatso); print_timer(tes,repeatsimple); print_timer(tds,repeatsimple); 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_so,teso->timer_/repeatso,tes->timer_/repeatsimple,tdso->timer_/repeatso,tds->timer_/repeatsimple); 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; }
static int pack_double(grib_accessor* a, const double* cval, size_t *len) { grib_accessor_data_g1simple_packing* self = (grib_accessor_data_g1simple_packing*)a; grib_accessor_class* super = *(a->cclass->super); size_t n_vals = *len; long half_byte = 0; int ret = 0; long offsetdata = 0; long offsetsection = 0; double reference_value = 0; long binary_scale_factor = 0; long bits_per_value = 0; long decimal_scale_factor = 0; double decimal = 1; size_t buflen = 0; unsigned char* buf = NULL; unsigned char* encoded = NULL; double divisor = 1; int i; long off = 0; grib_context* c=a->parent->h->context; grib_handle* h=a->parent->h; char* ieee_packing_s=NULL; char* packingType_s=NULL; char* precision_s=NULL; double units_factor=1.0; double units_bias=0.0; double* val=(double*)cval; double missingValue=9999.0; long constantFieldHalfByte=0; int err=0; if(*len != 0) { if(self->units_factor && (grib_get_double_internal(a->parent->h,self->units_factor,&units_factor)== GRIB_SUCCESS)) { grib_set_double_internal(a->parent->h,self->units_factor,1.0); } if(self->units_bias && (grib_get_double_internal(a->parent->h,self->units_bias,&units_bias)== GRIB_SUCCESS)) { grib_set_double_internal(a->parent->h,self->units_bias,0.0); } if (units_factor != 1.0) { if (units_bias != 0.0) for (i=0;i<n_vals;i++) val[i]=val[i]*units_factor+units_bias; else for (i=0;i<n_vals;i++) val[i]*=units_factor; } else if (units_bias != 0.0) for (i=0;i<n_vals;i++) val[i]+=units_bias; if (c->ieee_packing && self->ieee_packing) { long precision=c->ieee_packing==32 ? 1 : 2; size_t lenstr=strlen(self->ieee_packing); packingType_s=grib_context_strdup(c,self->packingType); ieee_packing_s=grib_context_strdup(c,self->ieee_packing); precision_s=grib_context_strdup(c,self->precision); grib_set_string(h,packingType_s,ieee_packing_s,&lenstr); grib_set_long(h,precision_s,precision); grib_context_free(c,packingType_s); grib_context_free(c,ieee_packing_s); grib_context_free(c,precision_s); return grib_set_double_array(h,"values",val,*len); } } ret = super->pack_double(a,val,len); switch (ret) { case GRIB_CONSTANT_FIELD: ret=grib_get_long(a->parent->h,"constantFieldHalfByte",&constantFieldHalfByte); if (ret) constantFieldHalfByte=0; if((ret = grib_set_long_internal(a->parent->h,self->half_byte, constantFieldHalfByte)) != GRIB_SUCCESS) return ret; grib_buffer_replace(a, NULL, 0,1,1); return GRIB_SUCCESS; break; case GRIB_NO_VALUES: ret=grib_get_long(a->parent->h,"constantFieldHalfByte",&constantFieldHalfByte); if (ret) constantFieldHalfByte=0; /* TODO move to def file */ grib_get_double(a->parent->h,"missingValue", &missingValue); if((err = grib_set_double_internal(a->parent->h,self->reference_value, missingValue)) != GRIB_SUCCESS) return err; if((ret = grib_set_long_internal(a->parent->h,self->binary_scale_factor, binary_scale_factor)) != GRIB_SUCCESS) return ret; if((ret = grib_set_long_internal(a->parent->h,self->half_byte, constantFieldHalfByte)) != GRIB_SUCCESS) return ret; grib_buffer_replace(a, NULL, 0,1,1); return GRIB_SUCCESS; break; case GRIB_INVALID_BPV: grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"unable to compute packing parameters\n"); return ret; case GRIB_SUCCESS: break; default: grib_context_log(a->parent->h->context,GRIB_LOG_FATAL,"unable to compute packing parameters\n"); return ret; } if((ret = grib_get_double_internal(a->parent->h,self->reference_value, &reference_value)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h,self->binary_scale_factor, &binary_scale_factor)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h,self->bits_per_value,&bits_per_value)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h,self->decimal_scale_factor, &decimal_scale_factor)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h,self->offsetdata,&offsetdata)) != GRIB_SUCCESS) return ret; if((ret = grib_get_long_internal(a->parent->h,self->offsetsection,&offsetsection)) != GRIB_SUCCESS) return ret; decimal = grib_power(decimal_scale_factor,10) ; divisor = grib_power(-binary_scale_factor,2); buflen = (((bits_per_value*n_vals)+7)/8)*sizeof(unsigned char); if((buflen + (offsetdata-offsetsection)) %2) { buflen++; /* a->length++; a->parent->h->buffer->ulength++; */ } half_byte = (buflen*8)-((*len)*bits_per_value); grib_context_log(a->parent->h->context,GRIB_LOG_DEBUG, "HALF byte: buflen=%d bits_per_value=%ld len=%d half_byte=%ld\n", buflen,bits_per_value,*len,half_byte); Assert(half_byte <= 0x0f); if((ret = grib_set_long_internal(a->parent->h,self->half_byte, half_byte)) != GRIB_SUCCESS) return ret; buf = (unsigned char*)grib_context_buffer_malloc_clear(a->parent->h->context,buflen); encoded = buf; grib_encode_double_array(n_vals,val,bits_per_value,reference_value,decimal,divisor,encoded,&off); grib_context_log(a->parent->h->context, GRIB_LOG_DEBUG, "grib_accessor_data_g1simple_packing : pack_double : packing %s, %d values", a->name, n_vals); grib_buffer_replace(a, buf, buflen,1,1); grib_context_buffer_free(a->parent->h->context,buf); return GRIB_SUCCESS; }
int codes_get_double(grib_handle* h, const char* key, double* value) { return grib_get_double(h,key,value); }
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; }
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_reduced* self = (grib_nearest_reduced*) nearest; int ret=0,kk=0,ii=0,jj=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); 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; long global=0; double lon_first,lon_last; long row_count,ilon_first,ilon_last; /*TODO global from the def file*/ global=1; grib_get_long(h,"global",&global); if (!global) { /*TODO longitudeOfFirstGridPointInDegrees from the def file*/ if ((ret=grib_get_double(h,"longitudeOfFirstGridPointInDegrees",&lon_first))!=GRIB_SUCCESS) { grib_context_log(h->context,GRIB_LOG_ERROR, "grib_nearest_reduced.find(): unable to get longitudeOfFirstGridPointInDegrees %s\n", grib_get_error_message(ret)); return ret; } /*TODO longitudeOfLastGridPointInDegrees from the def file*/ if ((ret=grib_get_double(h,"longitudeOfLastGridPointInDegrees",&lon_last))!=GRIB_SUCCESS) { grib_context_log(h->context,GRIB_LOG_ERROR, "grib_nearest_reduced.find(): unable to get longitudeOfLastGridPointInDegrees %s\n", grib_get_error_message(ret)); return ret; } /* if (lon_last<0) lon_last+=360; */ /* if (lon_first<0) lon_first+=360; */ } else { 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])); 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++;} nlon=0; if (global) { for (jj=0;jj<self->j[0];jj++) nlon+=pl[jj]; nplm1=pl[self->j[0]]-1; } else { nlon=0; for (jj=0;jj<self->j[0];jj++) { row_count=0;ilon_first=0;ilon_last=0; grib_get_reduced_row(pl[jj],lon_first,lon_last,&row_count,&ilon_first,&ilon_last); nlon+=row_count; } row_count=0;ilon_first=0;ilon_last=0; grib_get_reduced_row(pl[self->j[0]],lon_first,lon_last,&row_count,&ilon_first,&ilon_last); nplm1=row_count-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) { if (!global) { row_count=0;ilon_first=0;ilon_last=0; grib_get_reduced_row(pl[self->j[0]],lon_first,lon_last,&row_count,&ilon_first,&ilon_last); } else { row_count=pl[self->j[0]]; } grib_binary_search(lons,row_count-1,inlon, &(self->k[0]),&(self->k[1])); } self->k[0]+=nlon; self->k[1]+=nlon; nlon=0; if (global) { for (jj=0;jj<self->j[1];jj++) nlon+=pl[jj]; nplm1=pl[self->j[1]]-1; } else { long row_count,ilon_first,ilon_last; for (jj=0;jj<self->j[1];jj++) { row_count=0;ilon_first=0;ilon_last=0; grib_get_reduced_row(pl[jj],lon_first,lon_last,&row_count,&ilon_first,&ilon_last); nlon+=row_count; } row_count=0;ilon_first=0;ilon_last=0; grib_get_reduced_row(pl[self->j[1]],lon_first,lon_last,&nplm1,&ilon_first,&ilon_last); nplm1--; } 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) { if (!global) { row_count=0;ilon_first=0;ilon_last=0; grib_get_reduced_row(pl[self->j[1]],lon_first,lon_last,&row_count,&ilon_first,&ilon_last); } else { row_count=pl[self->j[1]]; } grib_binary_search(lons,row_count-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) { 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=0; int i=0; in = fopen(infile,"r"); if(!in) { printf("ERROR: unable to open file %s\n",infile); return 1; } out = fopen(outfile,"w"); if(!in) { printf("ERROR: unable to open file %s\n",outfile); 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_get_double(h,"missingValue",&missing),0); /* 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); 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 *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; }
static int unpack_double (grib_accessor* a, double* val, size_t *len) { grib_accessor_statistics* self = (grib_accessor_statistics*)a; int ret = 0,i=0; double* values; size_t size=0; double max,min,avg,sd,value,skew,kurt,x; double missing=0; long number_of_missing=0; grib_context* c=a->parent->h->context; grib_handle* h=a->parent->h; if (!a->dirty) return GRIB_SUCCESS; if ( (ret=grib_get_size(h,self->values,&size)) != GRIB_SUCCESS) return ret; grib_context_log(a->parent->h->context,GRIB_LOG_DEBUG, "grib_accessor_statistics: computing statistics for %d values",size); if((ret=grib_get_double(a->parent->h,self->missing_value,&missing)) != GRIB_SUCCESS) return ret; values=(double*)grib_context_malloc_clear(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; } number_of_missing=0; i=0; while (i<size && values[i] == missing ) {i++;number_of_missing++;} max=values[i]; min=values[i]; avg=values[i]; for (i=number_of_missing+1;i<size;i++) { value=values[i]; if (value > max && value != missing) max=value; if (value < min && value != missing) min=value; if (value != missing) avg+=value; else number_of_missing++; } avg/=(size-number_of_missing); sd=0; skew=0; kurt=0; for (i=0;i<size;i++) { if (values[i] != missing) { x=(avg-values[i])*(avg-values[i]); sd+=x; x*=(avg-values[i]); skew+=x; kurt+=x*(avg-values[i]); } } kurt=kurt; if (size-number_of_missing!=0) sd=sqrt(sd/(size-number_of_missing)); skew=skew; a->dirty=0; grib_context_free(c,values); self->v[0]=max; self->v[1]=min; self->v[2]=avg; self->v[3]=number_of_missing; self->v[4]=sd; self->v[5]=skew; self->v[6]=kurt; self->v[7]= sd == 0 ? 1 : 0; for (i=0;i<self->number_of_elements;i++) val[i]=self->v[i]; return ret; }
float InputGrib::getOffset(grib_handle* iH) { double offset; int err = grib_get_double(iH, "stepRange", &offset); assert(err == 0); return (float) offset; }