static int pack_double(grib_accessor* a, const double* cval, size_t *len)
{
char type[]="grid_second_order";
size_t size=strlen(type);
grib_set_string(a->parent->h,"packingType",type,&size);
return grib_set_double_array(a->parent->h,"values",cval,*len);
}
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 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 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_set_double_array(grib_handle* h, const char* key, const double* vals, size_t length)
{
return grib_set_double_array(h,key,vals,length);
}
static int execute(grib_action* a, grib_handle *h)
{
grib_action_set_darray* self = (grib_action_set_darray*) a;
return grib_set_double_array(h,self->name,self->darray->v,self->darray->n);
}
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;
}
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 main(int argc,const char** argv)
{
grib_handle *h = NULL;
size_t size = 0;
double* vdouble = NULL;
FILE* f = NULL;
const void* buffer = NULL;
if(argc != 2) {
fprintf(stderr,"usage: %s out\n",argv[0]);
exit(1);
}
h = grib_handle_new_from_samples(NULL,"GRIB2");
if(!h) {
fprintf(stderr,"Cannot create grib handle\n");
exit(1);
}
GRIB_CHECK(grib_set_long(h,"parametersVersion",1),0);
GRIB_CHECK(grib_set_long(h,"truncateLaplacian",0),0);
GRIB_CHECK(grib_set_long(h,"truncateDegrees",0),0);
GRIB_CHECK(grib_set_long(h,"dummy",1),0);
GRIB_CHECK(grib_set_long(h,"changingPrecision",0),0);
GRIB_CHECK(grib_set_long(h,"unitsFactor",1),0);
GRIB_CHECK(grib_set_long(h,"unitsBias",0),0);
GRIB_CHECK(grib_set_long(h,"timeRangeIndicatorFromStepRange",-1),0);
GRIB_CHECK(grib_set_long(h,"missingValue",9999),0);
/* 0 = Meteorological products (grib2/tables/4/0.0.table) */
GRIB_CHECK(grib_set_long(h,"discipline",0),0);
GRIB_CHECK(grib_set_long(h,"editionNumber",2),0);
/* 98 = European Center for Medium-Range Weather Forecasts (grib1/0.table) */
GRIB_CHECK(grib_set_long(h,"centre",98),0);
GRIB_CHECK(grib_set_long(h,"subCentre",0),0);
/* 4 = Version implemented on 7 November 2007 (grib2/tables/1.0.table) */
GRIB_CHECK(grib_set_long(h,"tablesVersion",4),0);
/* 0 = Local tables not used (grib2/tables/4/1.1.table) */
GRIB_CHECK(grib_set_long(h,"localTablesVersion",0),0);
/* 1 = Start of forecast (grib2/tables/4/1.2.table) */
GRIB_CHECK(grib_set_long(h,"significanceOfReferenceTime",1),0);
GRIB_CHECK(grib_set_long(h,"year",2007),0);
GRIB_CHECK(grib_set_long(h,"month",3),0);
GRIB_CHECK(grib_set_long(h,"day",23),0);
GRIB_CHECK(grib_set_long(h,"hour",12),0);
GRIB_CHECK(grib_set_long(h,"minute",0),0);
GRIB_CHECK(grib_set_long(h,"second",0),0);
GRIB_CHECK(grib_set_long(h,"dataDate",20070323),0);
GRIB_CHECK(grib_set_long(h,"dataTime",1200),0);
/* 0 = Operational products (grib2/tables/4/1.3.table) */
GRIB_CHECK(grib_set_long(h,"productionStatusOfProcessedData",0),0);
/* 2 = Analysis and forecast products (grib2/tables/4/1.4.table) */
GRIB_CHECK(grib_set_long(h,"typeOfProcessedData",2),0);
GRIB_CHECK(grib_set_long(h,"selectStepTemplateInterval",1),0);
GRIB_CHECK(grib_set_long(h,"selectStepTemplateInstant",1),0);
GRIB_CHECK(grib_set_long(h,"grib2LocalSectionPresent",0),0);
/* 0 = Specified in Code table 3.1 (grib2/tables/4/3.0.table) */
GRIB_CHECK(grib_set_long(h,"sourceOfGridDefinition",0),0);
GRIB_CHECK(grib_set_long(h,"numberOfDataPoints",496),0);
GRIB_CHECK(grib_set_long(h,"numberOfOctectsForNumberOfPoints",0),0);
/* 0 = There is no appended list (grib2/tables/4/3.11.table) */
GRIB_CHECK(grib_set_long(h,"interpretationOfNumberOfPoints",0),0);
GRIB_CHECK(grib_set_long(h,"PLPresent",0),0);
/* 0 = Latitude/longitude. Also called equidistant cylindrical, or Plate Carree (grib2/tables/4/3.1.table) */
GRIB_CHECK(grib_set_long(h,"gridDefinitionTemplateNumber",0),0);
/* 0 = Earth assumed spherical with radius = 6,367,470.0 m (grib2/tables/4/3.2.table) */
GRIB_CHECK(grib_set_long(h,"shapeOfTheEarth",0),0);
GRIB_CHECK(grib_set_missing(h,"scaleFactorOfRadiusOfSphericalEarth"),0);
GRIB_CHECK(grib_set_missing(h,"scaledValueOfRadiusOfSphericalEarth"),0);
GRIB_CHECK(grib_set_missing(h,"scaleFactorOfEarthMajorAxis"),0);
GRIB_CHECK(grib_set_missing(h,"scaledValueOfEarthMajorAxis"),0);
GRIB_CHECK(grib_set_missing(h,"scaleFactorOfEarthMinorAxis"),0);
GRIB_CHECK(grib_set_missing(h,"scaledValueOfEarthMinorAxis"),0);
GRIB_CHECK(grib_set_long(h,"radius",6367470),0);
GRIB_CHECK(grib_set_long(h,"Ni",16),0);
GRIB_CHECK(grib_set_long(h,"Nj",31),0);
GRIB_CHECK(grib_set_long(h,"basicAngleOfTheInitialProductionDomain",0),0);
GRIB_CHECK(grib_set_long(h,"mBasicAngle",0),0);
GRIB_CHECK(grib_set_long(h,"angleMultiplier",1),0);
GRIB_CHECK(grib_set_long(h,"mAngleMultiplier",1000000),0);
GRIB_CHECK(grib_set_missing(h,"subdivisionsOfBasicAngle"),0);
GRIB_CHECK(grib_set_long(h,"angleDivisor",1000000),0);
GRIB_CHECK(grib_set_long(h,"latitudeOfFirstGridPoint",60000000),0);
GRIB_CHECK(grib_set_long(h,"longitudeOfFirstGridPoint",0),0);
/* 48 = 00110000
(3=1) i direction increments given
(4=1) j direction increments given
(5=0) Resolved u- and v- components of vector quantities relative to easterly and northerly directions
See grib2/tables/[tablesVersion]/3.3.table */
GRIB_CHECK(grib_set_long(h,"resolutionAndComponentFlags",48),0);
GRIB_CHECK(grib_set_long(h,"iDirectionIncrementGiven",1),0);
GRIB_CHECK(grib_set_long(h,"jDirectionIncrementGiven",1),0);
GRIB_CHECK(grib_set_long(h,"uvRelativeToGrid",0),0);
GRIB_CHECK(grib_set_long(h,"latitudeOfLastGridPoint",0),0);
GRIB_CHECK(grib_set_long(h,"longitudeOfLastGridPoint",30000000),0);
GRIB_CHECK(grib_set_long(h,"iDirectionIncrement",2000000),0);
GRIB_CHECK(grib_set_long(h,"jDirectionIncrement",2000000),0);
/* 0 = 00000000
(1=0) Points of first row or column scan in the +i (+x) direction
(2=0) Points of first row or column scan in the -j (-y) direction
(3=0) Adjacent points in i (x) direction are consecutive
(4=0) All rows scan in the same direction
See grib2/tables/[tablesVersion]/3.4.table */
GRIB_CHECK(grib_set_long(h,"scanningMode",0),0);
GRIB_CHECK(grib_set_long(h,"iScansNegatively",0),0);
GRIB_CHECK(grib_set_long(h,"jScansPositively",0),0);
GRIB_CHECK(grib_set_long(h,"jPointsAreConsecutive",0),0);
GRIB_CHECK(grib_set_long(h,"alternativeRowScanning",0),0);
GRIB_CHECK(grib_set_long(h,"iScansPositively",1),0);
/* ITERATOR */
/* NEAREST */
GRIB_CHECK(grib_set_long(h,"timeRangeIndicator",0),0);
GRIB_CHECK(grib_set_long(h,"NV",0),0);
GRIB_CHECK(grib_set_long(h,"neitherPresent",0),0);
/* 0 = Analysis or forecast at a horizontal level or in a horizontal layer at a point in time (grib2/tables/4/4.0.table) */
GRIB_CHECK(grib_set_long(h,"productDefinitionTemplateNumber",0),0);
/* Parameter information */
/* 0 = Temperature (grib2/tables/4/4.1.0.table) */
GRIB_CHECK(grib_set_long(h,"parameterCategory",0),0);
/* 0 = Temperature (K) (grib2/tables/4/4.2.0.0.table) */
GRIB_CHECK(grib_set_long(h,"parameterNumber",0),0);
/* 0 = Analysis (grib2/tables/4/4.3.table) */
GRIB_CHECK(grib_set_long(h,"typeOfGeneratingProcess",0),0);
GRIB_CHECK(grib_set_long(h,"backgroundProcess",255),0);
GRIB_CHECK(grib_set_long(h,"generatingProcessIdentifier",128),0);
GRIB_CHECK(grib_set_long(h,"hoursAfterDataCutoff",0),0);
GRIB_CHECK(grib_set_long(h,"minutesAfterDataCutoff",0),0);
/* 1 = Hour (grib2/tables/4/4.4.table) */
GRIB_CHECK(grib_set_long(h,"indicatorOfUnitOfTimeRange",1),0);
/* 1 = Hour (stepUnits.table) */
GRIB_CHECK(grib_set_long(h,"stepUnits",1),0);
GRIB_CHECK(grib_set_long(h,"forecastTime",0),0);
/* 1 = Ground or water surface (grib2/tables/4/4.5.table) */
GRIB_CHECK(grib_set_long(h,"typeOfFirstFixedSurface",1),0);
GRIB_CHECK(grib_set_missing(h,"scaleFactorOfFirstFixedSurface"),0);
GRIB_CHECK(grib_set_missing(h,"scaledValueOfFirstFixedSurface"),0);
/* 255 = Missing (grib2/tables/4/4.5.table) */
GRIB_CHECK(grib_set_long(h,"typeOfSecondFixedSurface",255),0);
GRIB_CHECK(grib_set_missing(h,"scaleFactorOfSecondFixedSurface"),0);
GRIB_CHECK(grib_set_missing(h,"scaledValueOfSecondFixedSurface"),0);
GRIB_CHECK(grib_set_long(h,"level",0),0);
GRIB_CHECK(grib_set_long(h,"bottomLevel",0),0);
GRIB_CHECK(grib_set_long(h,"topLevel",0),0);
GRIB_CHECK(grib_set_long(h,"dummyc",0),0);
GRIB_CHECK(grib_set_long(h,"PVPresent",0),0);
/* grib 2 Section 5 DATA REPRESENTATION SECTION */
GRIB_CHECK(grib_set_long(h,"numberOfValues",496),0);
/* 0 = Grid point data - simple packing (grib2/tables/4/5.0.table) */
GRIB_CHECK(grib_set_long(h,"dataRepresentationTemplateNumber",0),0);
GRIB_CHECK(grib_set_long(h,"decimalScaleFactor",0),0);
GRIB_CHECK(grib_set_long(h,"bitsPerValue",0),0);
/* 0 = Floating point (grib2/tables/4/5.1.table) */
GRIB_CHECK(grib_set_long(h,"typeOfOriginalFieldValues",0),0);
GRIB_CHECK(grib_set_long(h,"representationMode",0),0);
/* grib 2 Section 6 BIT-MAP SECTION */
/* 255 = A bit map does not apply to this product (grib2/tables/4/6.0.table) */
GRIB_CHECK(grib_set_long(h,"bitMapIndicator",255),0);
GRIB_CHECK(grib_set_long(h,"bitmapPresent",0),0);
/* grib 2 Section 7 data */
size = 496;
vdouble = (double*)calloc(size,sizeof(double));
if(!vdouble) {
fprintf(stderr,"failed to allocate %lu bytes\n",size*sizeof(double));
exit(1);
}
vdouble[ 0] = 1; vdouble[ 1] = 1; vdouble[ 2] = 1; vdouble[ 3] = 1;
vdouble[ 4] = 1; vdouble[ 5] = 1; vdouble[ 6] = 1; vdouble[ 7] = 1;
vdouble[ 8] = 1; vdouble[ 9] = 1; vdouble[ 10] = 1; vdouble[ 11] = 1;
vdouble[ 12] = 1; vdouble[ 13] = 1; vdouble[ 14] = 1; vdouble[ 15] = 1;
vdouble[ 16] = 1; vdouble[ 17] = 1; vdouble[ 18] = 1; vdouble[ 19] = 1;
vdouble[ 20] = 1; vdouble[ 21] = 1; vdouble[ 22] = 1; vdouble[ 23] = 1;
vdouble[ 24] = 1; vdouble[ 25] = 1; vdouble[ 26] = 1; vdouble[ 27] = 1;
vdouble[ 28] = 1; vdouble[ 29] = 1; vdouble[ 30] = 1; vdouble[ 31] = 1;
vdouble[ 32] = 1; vdouble[ 33] = 1; vdouble[ 34] = 1; vdouble[ 35] = 1;
vdouble[ 36] = 1; vdouble[ 37] = 1; vdouble[ 38] = 1; vdouble[ 39] = 1;
vdouble[ 40] = 1; vdouble[ 41] = 1; vdouble[ 42] = 1; vdouble[ 43] = 1;
vdouble[ 44] = 1; vdouble[ 45] = 1; vdouble[ 46] = 1; vdouble[ 47] = 1;
vdouble[ 48] = 1; vdouble[ 49] = 1; vdouble[ 50] = 1; vdouble[ 51] = 1;
vdouble[ 52] = 1; vdouble[ 53] = 1; vdouble[ 54] = 1; vdouble[ 55] = 1;
vdouble[ 56] = 1; vdouble[ 57] = 1; vdouble[ 58] = 1; vdouble[ 59] = 1;
vdouble[ 60] = 1; vdouble[ 61] = 1; vdouble[ 62] = 1; vdouble[ 63] = 1;
vdouble[ 64] = 1; vdouble[ 65] = 1; vdouble[ 66] = 1; vdouble[ 67] = 1;
vdouble[ 68] = 1; vdouble[ 69] = 1; vdouble[ 70] = 1; vdouble[ 71] = 1;
vdouble[ 72] = 1; vdouble[ 73] = 1; vdouble[ 74] = 1; vdouble[ 75] = 1;
vdouble[ 76] = 1; vdouble[ 77] = 1; vdouble[ 78] = 1; vdouble[ 79] = 1;
vdouble[ 80] = 1; vdouble[ 81] = 1; vdouble[ 82] = 1; vdouble[ 83] = 1;
vdouble[ 84] = 1; vdouble[ 85] = 1; vdouble[ 86] = 1; vdouble[ 87] = 1;
vdouble[ 88] = 1; vdouble[ 89] = 1; vdouble[ 90] = 1; vdouble[ 91] = 1;
vdouble[ 92] = 1; vdouble[ 93] = 1; vdouble[ 94] = 1; vdouble[ 95] = 1;
vdouble[ 96] = 1; vdouble[ 97] = 1; vdouble[ 98] = 1; vdouble[ 99] = 1;
vdouble[ 100] = 1; vdouble[ 101] = 1; vdouble[ 102] = 1; vdouble[ 103] = 1;
vdouble[ 104] = 1; vdouble[ 105] = 1; vdouble[ 106] = 1; vdouble[ 107] = 1;
vdouble[ 108] = 1; vdouble[ 109] = 1; vdouble[ 110] = 1; vdouble[ 111] = 1;
vdouble[ 112] = 1; vdouble[ 113] = 1; vdouble[ 114] = 1; vdouble[ 115] = 1;
vdouble[ 116] = 1; vdouble[ 117] = 1; vdouble[ 118] = 1; vdouble[ 119] = 1;
vdouble[ 120] = 1; vdouble[ 121] = 1; vdouble[ 122] = 1; vdouble[ 123] = 1;
vdouble[ 124] = 1; vdouble[ 125] = 1; vdouble[ 126] = 1; vdouble[ 127] = 1;
vdouble[ 128] = 1; vdouble[ 129] = 1; vdouble[ 130] = 1; vdouble[ 131] = 1;
vdouble[ 132] = 1; vdouble[ 133] = 1; vdouble[ 134] = 1; vdouble[ 135] = 1;
vdouble[ 136] = 1; vdouble[ 137] = 1; vdouble[ 138] = 1; vdouble[ 139] = 1;
vdouble[ 140] = 1; vdouble[ 141] = 1; vdouble[ 142] = 1; vdouble[ 143] = 1;
vdouble[ 144] = 1; vdouble[ 145] = 1; vdouble[ 146] = 1; vdouble[ 147] = 1;
vdouble[ 148] = 1; vdouble[ 149] = 1; vdouble[ 150] = 1; vdouble[ 151] = 1;
vdouble[ 152] = 1; vdouble[ 153] = 1; vdouble[ 154] = 1; vdouble[ 155] = 1;
vdouble[ 156] = 1; vdouble[ 157] = 1; vdouble[ 158] = 1; vdouble[ 159] = 1;
vdouble[ 160] = 1; vdouble[ 161] = 1; vdouble[ 162] = 1; vdouble[ 163] = 1;
vdouble[ 164] = 1; vdouble[ 165] = 1; vdouble[ 166] = 1; vdouble[ 167] = 1;
vdouble[ 168] = 1; vdouble[ 169] = 1; vdouble[ 170] = 1; vdouble[ 171] = 1;
vdouble[ 172] = 1; vdouble[ 173] = 1; vdouble[ 174] = 1; vdouble[ 175] = 1;
vdouble[ 176] = 1; vdouble[ 177] = 1; vdouble[ 178] = 1; vdouble[ 179] = 1;
vdouble[ 180] = 1; vdouble[ 181] = 1; vdouble[ 182] = 1; vdouble[ 183] = 1;
vdouble[ 184] = 1; vdouble[ 185] = 1; vdouble[ 186] = 1; vdouble[ 187] = 1;
vdouble[ 188] = 1; vdouble[ 189] = 1; vdouble[ 190] = 1; vdouble[ 191] = 1;
vdouble[ 192] = 1; vdouble[ 193] = 1; vdouble[ 194] = 1; vdouble[ 195] = 1;
vdouble[ 196] = 1; vdouble[ 197] = 1; vdouble[ 198] = 1; vdouble[ 199] = 1;
vdouble[ 200] = 1; vdouble[ 201] = 1; vdouble[ 202] = 1; vdouble[ 203] = 1;
vdouble[ 204] = 1; vdouble[ 205] = 1; vdouble[ 206] = 1; vdouble[ 207] = 1;
vdouble[ 208] = 1; vdouble[ 209] = 1; vdouble[ 210] = 1; vdouble[ 211] = 1;
vdouble[ 212] = 1; vdouble[ 213] = 1; vdouble[ 214] = 1; vdouble[ 215] = 1;
vdouble[ 216] = 1; vdouble[ 217] = 1; vdouble[ 218] = 1; vdouble[ 219] = 1;
vdouble[ 220] = 1; vdouble[ 221] = 1; vdouble[ 222] = 1; vdouble[ 223] = 1;
vdouble[ 224] = 1; vdouble[ 225] = 1; vdouble[ 226] = 1; vdouble[ 227] = 1;
vdouble[ 228] = 1; vdouble[ 229] = 1; vdouble[ 230] = 1; vdouble[ 231] = 1;
vdouble[ 232] = 1; vdouble[ 233] = 1; vdouble[ 234] = 1; vdouble[ 235] = 1;
vdouble[ 236] = 1; vdouble[ 237] = 1; vdouble[ 238] = 1; vdouble[ 239] = 1;
vdouble[ 240] = 1; vdouble[ 241] = 1; vdouble[ 242] = 1; vdouble[ 243] = 1;
vdouble[ 244] = 1; vdouble[ 245] = 1; vdouble[ 246] = 1; vdouble[ 247] = 1;
vdouble[ 248] = 1; vdouble[ 249] = 1; vdouble[ 250] = 1; vdouble[ 251] = 1;
vdouble[ 252] = 1; vdouble[ 253] = 1; vdouble[ 254] = 1; vdouble[ 255] = 1;
vdouble[ 256] = 1; vdouble[ 257] = 1; vdouble[ 258] = 1; vdouble[ 259] = 1;
vdouble[ 260] = 1; vdouble[ 261] = 1; vdouble[ 262] = 1; vdouble[ 263] = 1;
vdouble[ 264] = 1; vdouble[ 265] = 1; vdouble[ 266] = 1; vdouble[ 267] = 1;
vdouble[ 268] = 1; vdouble[ 269] = 1; vdouble[ 270] = 1; vdouble[ 271] = 1;
vdouble[ 272] = 1; vdouble[ 273] = 1; vdouble[ 274] = 1; vdouble[ 275] = 1;
vdouble[ 276] = 1; vdouble[ 277] = 1; vdouble[ 278] = 1; vdouble[ 279] = 1;
vdouble[ 280] = 1; vdouble[ 281] = 1; vdouble[ 282] = 1; vdouble[ 283] = 1;
vdouble[ 284] = 1; vdouble[ 285] = 1; vdouble[ 286] = 1; vdouble[ 287] = 1;
vdouble[ 288] = 1; vdouble[ 289] = 1; vdouble[ 290] = 1; vdouble[ 291] = 1;
vdouble[ 292] = 1; vdouble[ 293] = 1; vdouble[ 294] = 1; vdouble[ 295] = 1;
vdouble[ 296] = 1; vdouble[ 297] = 1; vdouble[ 298] = 1; vdouble[ 299] = 1;
vdouble[ 300] = 1; vdouble[ 301] = 1; vdouble[ 302] = 1; vdouble[ 303] = 1;
vdouble[ 304] = 1; vdouble[ 305] = 1; vdouble[ 306] = 1; vdouble[ 307] = 1;
vdouble[ 308] = 1; vdouble[ 309] = 1; vdouble[ 310] = 1; vdouble[ 311] = 1;
vdouble[ 312] = 1; vdouble[ 313] = 1; vdouble[ 314] = 1; vdouble[ 315] = 1;
vdouble[ 316] = 1; vdouble[ 317] = 1; vdouble[ 318] = 1; vdouble[ 319] = 1;
vdouble[ 320] = 1; vdouble[ 321] = 1; vdouble[ 322] = 1; vdouble[ 323] = 1;
vdouble[ 324] = 1; vdouble[ 325] = 1; vdouble[ 326] = 1; vdouble[ 327] = 1;
vdouble[ 328] = 1; vdouble[ 329] = 1; vdouble[ 330] = 1; vdouble[ 331] = 1;
vdouble[ 332] = 1; vdouble[ 333] = 1; vdouble[ 334] = 1; vdouble[ 335] = 1;
vdouble[ 336] = 1; vdouble[ 337] = 1; vdouble[ 338] = 1; vdouble[ 339] = 1;
vdouble[ 340] = 1; vdouble[ 341] = 1; vdouble[ 342] = 1; vdouble[ 343] = 1;
vdouble[ 344] = 1; vdouble[ 345] = 1; vdouble[ 346] = 1; vdouble[ 347] = 1;
vdouble[ 348] = 1; vdouble[ 349] = 1; vdouble[ 350] = 1; vdouble[ 351] = 1;
vdouble[ 352] = 1; vdouble[ 353] = 1; vdouble[ 354] = 1; vdouble[ 355] = 1;
vdouble[ 356] = 1; vdouble[ 357] = 1; vdouble[ 358] = 1; vdouble[ 359] = 1;
vdouble[ 360] = 1; vdouble[ 361] = 1; vdouble[ 362] = 1; vdouble[ 363] = 1;
vdouble[ 364] = 1; vdouble[ 365] = 1; vdouble[ 366] = 1; vdouble[ 367] = 1;
vdouble[ 368] = 1; vdouble[ 369] = 1; vdouble[ 370] = 1; vdouble[ 371] = 1;
vdouble[ 372] = 1; vdouble[ 373] = 1; vdouble[ 374] = 1; vdouble[ 375] = 1;
vdouble[ 376] = 1; vdouble[ 377] = 1; vdouble[ 378] = 1; vdouble[ 379] = 1;
vdouble[ 380] = 1; vdouble[ 381] = 1; vdouble[ 382] = 1; vdouble[ 383] = 1;
vdouble[ 384] = 1; vdouble[ 385] = 1; vdouble[ 386] = 1; vdouble[ 387] = 1;
vdouble[ 388] = 1; vdouble[ 389] = 1; vdouble[ 390] = 1; vdouble[ 391] = 1;
vdouble[ 392] = 1; vdouble[ 393] = 1; vdouble[ 394] = 1; vdouble[ 395] = 1;
vdouble[ 396] = 1; vdouble[ 397] = 1; vdouble[ 398] = 1; vdouble[ 399] = 1;
vdouble[ 400] = 1; vdouble[ 401] = 1; vdouble[ 402] = 1; vdouble[ 403] = 1;
vdouble[ 404] = 1; vdouble[ 405] = 1; vdouble[ 406] = 1; vdouble[ 407] = 1;
vdouble[ 408] = 1; vdouble[ 409] = 1; vdouble[ 410] = 1; vdouble[ 411] = 1;
vdouble[ 412] = 1; vdouble[ 413] = 1; vdouble[ 414] = 1; vdouble[ 415] = 1;
vdouble[ 416] = 1; vdouble[ 417] = 1; vdouble[ 418] = 1; vdouble[ 419] = 1;
vdouble[ 420] = 1; vdouble[ 421] = 1; vdouble[ 422] = 1; vdouble[ 423] = 1;
vdouble[ 424] = 1; vdouble[ 425] = 1; vdouble[ 426] = 1; vdouble[ 427] = 1;
vdouble[ 428] = 1; vdouble[ 429] = 1; vdouble[ 430] = 1; vdouble[ 431] = 1;
vdouble[ 432] = 1; vdouble[ 433] = 1; vdouble[ 434] = 1; vdouble[ 435] = 1;
vdouble[ 436] = 1; vdouble[ 437] = 1; vdouble[ 438] = 1; vdouble[ 439] = 1;
vdouble[ 440] = 1; vdouble[ 441] = 1; vdouble[ 442] = 1; vdouble[ 443] = 1;
vdouble[ 444] = 1; vdouble[ 445] = 1; vdouble[ 446] = 1; vdouble[ 447] = 1;
vdouble[ 448] = 1; vdouble[ 449] = 1; vdouble[ 450] = 1; vdouble[ 451] = 1;
vdouble[ 452] = 1; vdouble[ 453] = 1; vdouble[ 454] = 1; vdouble[ 455] = 1;
vdouble[ 456] = 1; vdouble[ 457] = 1; vdouble[ 458] = 1; vdouble[ 459] = 1;
vdouble[ 460] = 1; vdouble[ 461] = 1; vdouble[ 462] = 1; vdouble[ 463] = 1;
vdouble[ 464] = 1; vdouble[ 465] = 1; vdouble[ 466] = 1; vdouble[ 467] = 1;
vdouble[ 468] = 1; vdouble[ 469] = 1; vdouble[ 470] = 1; vdouble[ 471] = 1;
vdouble[ 472] = 1; vdouble[ 473] = 1; vdouble[ 474] = 1; vdouble[ 475] = 1;
vdouble[ 476] = 1; vdouble[ 477] = 1; vdouble[ 478] = 1; vdouble[ 479] = 1;
vdouble[ 480] = 1; vdouble[ 481] = 1; vdouble[ 482] = 1; vdouble[ 483] = 1;
vdouble[ 484] = 1; vdouble[ 485] = 1; vdouble[ 486] = 1; vdouble[ 487] = 1;
vdouble[ 488] = 1; vdouble[ 489] = 1; vdouble[ 490] = 1; vdouble[ 491] = 1;
vdouble[ 492] = 1; vdouble[ 493] = 1; vdouble[ 494] = 1; vdouble[ 495] = 1;
GRIB_CHECK(grib_set_double_array(h,"values",vdouble,size),0);
free(vdouble);
GRIB_CHECK(grib_set_long(h,"dirty_statistics",1),0);
GRIB_CHECK(grib_set_long(h,"changeDecimalPrecision",0),0);
GRIB_CHECK(grib_set_long(h,"decimalPrecision",0),0);
GRIB_CHECK(grib_set_long(h,"setBitsPerValue",0),0);
/* Save the message */
f = fopen(argv[1],"w");
if(!f) {
perror(argv[1]);
exit(1);
}
GRIB_CHECK(grib_get_message(h,&buffer,&size),0);
if(fwrite(buffer,1,size,f) != size) {
perror(argv[1]);
exit(1);
}
if(fclose(f)) {
perror(argv[1]);
exit(1);
}
grib_handle_delete(h);
return 0;
}
static void compare_handles(int n,grib_handle* h1,grib_handle* h2,FILE* out)
{
size_t len1 = 0;
size_t len2 = 0;
double *dval1 = NULL, *dval2 = NULL, *dval3 = NULL;
double maxe = 0,mine = 0;
double maxa = 0,mina = 0;
int i,maxi = 0,maxai = 0;
double lat,lon;
GRIB_CHECK(grib_get_size(h1,"values",&len1),NULL);
GRIB_CHECK(grib_get_size(h2,"values",&len2),NULL);
if(len1 != len2)
{
printf("Field size mismatch %ld != %ld\n",(long)len1,(long)len2);
exit(1);
}
dval1 = (double*)grib_context_malloc(h1->context,len1*sizeof(double));
Assert(dval1);
dval2 = (double*)grib_context_malloc(h2->context,len2*sizeof(double));
Assert(dval2);
if(out)
dval3 = (double*)grib_context_malloc(h2->context,len2*sizeof(double));
Assert(dval2);
GRIB_CHECK(grib_get_double_array(h1,"values",dval1,&len1),NULL);
GRIB_CHECK(grib_get_double_array(h2,"values",dval2,&len2),NULL);
for(i = 0; i < len1; i++)
{
double e = err(dval1[i],dval2[i]);
double a = fabs(dval1[i]-dval2[i]);
if(i == 0) maxe = mine = e;
if(i == 0) maxa = mina = a;
if(out) dval3[i] = absolute ? a : e;
if(e < mine) mine = e;
if(e > maxe) {
maxe = e;
maxi = i;
}
if(a < mina) mina = a;
if(a > maxa) {
maxa = a;
maxai = i;
}
}
if(out)
{
const void *buffer;
size_t size;
GRIB_CHECK(grib_set_long(h1,"generatingProcessIdentifier",255),NULL); /* To prevent Magics to scale the field */
GRIB_CHECK(grib_set_long(h1,"numberOfBitsContainingEachPackedValue",24),NULL);
GRIB_CHECK(grib_set_double_array(h1,"values",dval3,len1),NULL);
GRIB_CHECK(grib_get_message(h1,&buffer,&size),NULL);
if(fwrite(buffer,1,size,out) != size)
{
perror(outname);
exit(1);
}
}
printf("Field %ld: min relative error: %g%%, max relative error: %g%% [%g,%g,%g]\n",(long)n,mine*100,maxe*100,
dval1[maxi],dval2[maxi],fabs(dval1[maxi]-dval2[maxi]));
if(location(h1,maxi,&lat,&lon))
printf(" latitude = %g, longitude = %g\n",lat,lon);
printf("Field %ld: min absolute error: %g, max absolute error: %g [%g,%g]\n",(long)n,mina,maxa,
dval1[maxai],dval2[maxai]);
if(location(h1,maxai,&lat,&lon))
printf(" latitude = %g, longitude = %g\n",lat,lon);
grib_context_free(h1->context,dval1);
grib_context_free(h2->context,dval2);
grib_context_free(h2->context,dval3);
}
int grib_init_accessor_from_handle(grib_loader* loader,grib_accessor* ga,grib_arguments* default_value)
{
grib_handle* h = (grib_handle*)loader->data;
int ret = GRIB_SUCCESS;
size_t len = 0;
char* sval = NULL;
unsigned char* uval = NULL;
long* lval = NULL;
double* dval = NULL;
static int first = 1;
static const char* missing = 0;
const char* name = NULL;
int k = 0;
grib_handle *g;
int e, pack_missing = 0;
grib_context_log(h->context,GRIB_LOG_DEBUG, "XXXXX Copying %s", ga->name);
if(default_value)
{
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying: setting %s to default value",
ga->name);
grib_pack_expression(ga,grib_arguments_get_expression(h,default_value,0));
}
if( (ga->flags & GRIB_ACCESSOR_FLAG_NO_COPY) ||
((ga->flags & GRIB_ACCESSOR_FLAG_EDITION_SPECIFIC) &&
loader->changing_edition ) ||
(ga->flags & GRIB_ACCESSOR_FLAG_FUNCTION) ||
( (ga->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) &&
!(ga->flags & GRIB_ACCESSOR_FLAG_COPY_OK) ) )
{
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying %s ignored", ga->name);
return GRIB_SUCCESS;
}
#if 0
if(h->values)
if(copy_values(h,ga) == GRIB_SUCCESS)
{
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying: setting %s to multi-set-value", ga->name);
return GRIB_SUCCESS;
}
#endif
#if 0
if(h->loader)
h->loader->init_accessor(h->loader,ga,default_value);
#else
/* COMEBACK here
this is needed if we reparse during reparse....
*/
g = h;
while(g)
{
if(g->values) {
if(copy_values(g,ga) == GRIB_SUCCESS) {
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying: setting %s to multi-set-value", ga->name);
return GRIB_SUCCESS;
}
}
g = g->main;
}
#endif
/* Check if the same name exists in the original message ... */
k = 0;
while( (k < MAX_ACCESSOR_NAMES) &&
((name = ga->all_names[k]) != NULL) &&
((ret = grib_get_size(h,name,&len)) != GRIB_SUCCESS)) k++;
if(ret != GRIB_SUCCESS)
{
name = ga->name;
if(first)
{
missing = getenv("GRIB_PRINT_MISSING");
first = 0;
}
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying [%s] failed: %s",
name,grib_get_error_message(ret));
if(missing)
{
fprintf(stdout,"REPARSE: no value for %s",name);
if(default_value)
fprintf(stdout," (default value)");
fprintf(stdout,"\n");
}
return GRIB_SUCCESS;
}
/* we copy also virtual keys*/
if(len == 0) {
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying %s failed, length is 0", name);
return GRIB_SUCCESS;
}
if((ga->flags & GRIB_ACCESSOR_FLAG_CAN_BE_MISSING) && grib_is_missing(h,name,&e) && e == GRIB_SUCCESS && len == 1)
{
grib_pack_missing(ga);
pack_missing = 1;
}
switch(grib_accessor_get_native_type(ga))
{
case GRIB_TYPE_STRING:
/* len = len > 1024 ? len : 1024; */
grib_get_string_length(h,name,&len);
sval = (char*)grib_context_malloc(h->context,len);
ret = grib_get_string_internal(h,name,sval,&len);
if(ret == GRIB_SUCCESS)
{
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying string %s to %s", sval, name);
ret = grib_pack_string(ga,sval,&len);
}
grib_context_free(h->context,sval);
break;
case GRIB_TYPE_LONG:
lval = (long*)grib_context_malloc(h->context,len*sizeof(long));
ret = grib_get_long_array_internal(h,name,lval,&len);
if(ret == GRIB_SUCCESS)
{
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying %d long(s) %d to %s", len, lval[0], name);
if(ga->same)
{
ret = grib_set_long_array(ga->parent->h,ga->name,lval,len);
/* Allow for lists to be resized */
if((ret == GRIB_WRONG_ARRAY_SIZE || ret == GRIB_ARRAY_TOO_SMALL) && loader->list_is_resized)
ret = GRIB_SUCCESS;
}
else
{
/* See GRIB-492. This is NOT an ideal solution! */
if (*lval == GRIB_MISSING_LONG || pack_missing)
{
; /* No checks needed */
}
else
{
/* If we have just one key of type long which has one octet, then do not exceed maximum value */
const long num_octets = ga->length;
if (len == 1 && num_octets == 1 && *lval > 255)
{
*lval = 0; /* Reset to a reasonable value */
}
}
ret = grib_pack_long(ga,lval,&len);
}
}
grib_context_free(h->context,lval);
break;
case GRIB_TYPE_DOUBLE:
dval = (double*)grib_context_malloc(h->context,len*sizeof(double));
ret = grib_get_double_array_internal(h,name,dval,&len);
if(ret == GRIB_SUCCESS)
{
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying %d double(s) %g to %s", len, dval[0], name);
if(ga->same)
{
ret = grib_set_double_array(ga->parent->h,ga->name,dval,len);
/* Allow for lists to be resized */
if((ret == GRIB_WRONG_ARRAY_SIZE || ret == GRIB_ARRAY_TOO_SMALL) && loader->list_is_resized)
ret = GRIB_SUCCESS;
}
else ret = grib_pack_double(ga,dval,&len);
}
grib_context_free(h->context,dval);
break;
case GRIB_TYPE_BYTES:
uval = (unsigned char*)grib_context_malloc(h->context,len*sizeof(char));
ret = grib_get_bytes_internal(h,name,uval,&len);
if(ret == GRIB_SUCCESS)
{
grib_context_log(h->context,GRIB_LOG_DEBUG, "Copying %d byte(s) to %s", len, name);
ret = grib_pack_bytes(ga,uval,&len);
}
grib_context_free(h->context,uval);
break;
case GRIB_TYPE_LABEL:
break;
default:
grib_context_log(h->context,GRIB_LOG_ERROR, "Copying %s, cannot establish type %d [%s]"
, name,grib_accessor_get_native_type(ga),ga->creator->cclass->name);
break;
}
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=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;
}
static int pack_double(grib_accessor* a, const double* val, size_t *len)
{
grib_accessor_data_g1complex_packing* self =
(grib_accessor_data_g1complex_packing*)a;
int ret = GRIB_SUCCESS;
long seclen=0;
long sub_j= 0;
long sub_k= 0;
long sub_m= 0;
long n= 0;
long half_byte= 0;
long bits_per_value =0;
size_t buflen =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;
grib_accessor_class* super = *(a->cclass->super);
if (*len ==0) return GRIB_NO_VALUES;
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);
}
if((ret = grib_get_long_internal(a->parent->h,self->sub_j,&sub_j)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->sub_k,&sub_k)) != GRIB_SUCCESS)
return ret;
if((ret = grib_get_long_internal(a->parent->h,self->sub_m,&sub_m)) != GRIB_SUCCESS)
return ret;
self->dirty=1;
Assert ((sub_j== sub_k) && (sub_m== sub_j));
ret = super->pack_double(a,val,len);
if(ret == GRIB_SUCCESS){
n = a->offset + 4*((sub_k+1)*(sub_k+2));
#if 1
/* Octet number starts from beginning of message but shouldn't */
if((ret = grib_set_long_internal(a->parent->h,self->N,n)) != GRIB_SUCCESS)
return ret;
#else
ret = grib_get_long_internal(a->parent->h,self->offsetsection,&offsetsection);
if(ret != GRIB_SUCCESS) return ret;
if((ret = grib_set_long_internal(a->parent->h,self->N,n-offsetsection))
!= GRIB_SUCCESS) return ret;
#endif
ret = grib_get_long_internal(a->parent->h,self->bits_per_value,&bits_per_value);
if(ret != GRIB_SUCCESS) return ret;
ret = grib_get_long_internal(a->parent->h,self->seclen,&seclen);
if(ret != GRIB_SUCCESS) return ret;
buflen = 32*(sub_k+1)*(sub_k+2)+(*len-(sub_k+1)*(sub_k+2))*bits_per_value+18*8;
half_byte = seclen*8-buflen;
if (a->parent->h->context->debug==-1) {
printf("GRIB_API DEBUG: half_byte=%ld\n",half_byte);
}
ret = grib_set_long_internal(a->parent->h,self->half_byte, half_byte);
if(ret != GRIB_SUCCESS) return ret;
}
return ret;
}
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 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[]) {
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[]) {
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_init_accessor_from_array(grib_loader* loader,grib_accessor* ga,grib_arguments* default_value)
{
grib_handle* h = ga->parent->h;
int retval =GRIB_SUCCESS;
char* strvalue;
size_t len=0;
int type=0;
double* dvalue=0;
long* lvalue=0;
long lval=0;
double dval=0;
int i=0;
grib_associative_array* ar=NULL;
grib_runtime_type* value=NULL;
ar=(grib_associative_array*)loader->data;
grib_context_log(h->context,GRIB_LOG_DEBUG, "Initialize %s", ga->name);
retval= grib_associative_array_get(ar,ga->name,&value);
if((retval != GRIB_ARRAY_SUCCESS) && default_value) {
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to default value", ga->name);
grib_pack_expression(ga,grib_arguments_get_expression(h,default_value,0));
return GRIB_SUCCESS;
}
if(ga->flags & GRIB_ACCESSOR_FLAG_READ_ONLY)
{
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s ignored (read only)", ga->name);
return GRIB_SUCCESS;
}
if (retval != GRIB_ARRAY_SUCCESS) {
grib_context_log(h->context,GRIB_LOG_DEBUG,
"Grib array error %d",retval);
if ((ga->flags & GRIB_ACCESSOR_FLAG_CAN_BE_MISSING)) {
grib_context_log(h->context,GRIB_LOG_DEBUG,
"Setting %s ignored (optional or can be missing)", ga->name);
return GRIB_SUCCESS;
} else {
grib_context_log(h->context,GRIB_LOG_ERROR, "%s required", ga->name);
return retval;
}
}
if (value && grib_runtimetype_get_type(value,&type) == GRIB_RUNTIMETYPE_SUCCESS) {
if (type == GRIB_RUNTIMETYPE_CHAR ) {
grib_runtimetype_get_char(value,&strvalue,&len);
switch(grib_accessor_get_native_type(ga)) {
case GRIB_TYPE_STRING:
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to string %s",
ga->name, strvalue);
grib_set_string_internal(h,ga->name,strvalue,&len);
break;
case GRIB_TYPE_LONG:
if (!strcmp(strvalue,"MISSING")) lval=GRIB_MISSING_LONG;
else lval=atol(strvalue);
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to long %d", ga->name, lval);
grib_set_long_internal(h,ga->name,lval);
break;
case GRIB_TYPE_DOUBLE:
if (!strcmp(strvalue,"MISSING")) dval=GRIB_MISSING_DOUBLE;
else if (sscanf(strvalue,"%lg",&dval)!=1) {
grib_context_log(h->context,GRIB_LOG_ERROR, "Unable to set %s wrong value format", ga->name);
}
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to double %lg (%s)", ga->name, dval,strvalue);
grib_set_double_internal(h,ga->name,dval);
break;
case GRIB_TYPE_BYTES:
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to string %s",
ga->name, strvalue);
grib_set_bytes_internal(h,ga->name,(unsigned char*)strvalue,&len);
break;
case GRIB_TYPE_LABEL:
break;
default:
grib_context_log(h->context,GRIB_LOG_ERROR, "Setting %s, cannot establish type %d [%s]"
, ga->name,grib_accessor_get_native_type(ga),ga->creator->cclass->name);
break;
}
} else {
if (grib_runtimetype_get_double(value,&dvalue,&len) == GRIB_RUNTIMETYPE_SUCCESS) {
switch(grib_accessor_get_native_type(ga)) {
case GRIB_TYPE_LONG:
lvalue=(long*)malloc(sizeof(long)*len);
for (i=0;i<len;i++) lvalue[i]=(long)dvalue[i];
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting long array %s",ga->name);
grib_set_long_array(h,ga->name,lvalue,len);
free(lvalue);
break;
case GRIB_TYPE_DOUBLE:
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting double array %s",ga->name);
grib_set_double_array(h,ga->name,dvalue,len);
break;
default:
grib_context_log(h->context,GRIB_LOG_ERROR, "Setting array %s, wrong type [%d]"
, ga->name,grib_accessor_get_native_type(ga));
break;
}
} else
grib_context_log(h->context,GRIB_LOG_ERROR, "Unable to set %s to double, wrong type (%d)",
ga->name,type);
}
#if 0
switch(grib_accessor_get_native_type(ga))
{
case GRIB_TYPE_STRING:
if (grib_runtimetype_get_char(value,&strvalue,&strvalue_size) == GRIB_RUNTIMETYPE_SUCCESS) {
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to string %s",
ga->name, strvalue);
len=strlen(strvalue);
grib_set_string_internal(h,ga->name,strvalue,&len);
} else
grib_context_log(h->context,GRIB_LOG_ERROR, "Unable to set %s to string, wrong type",
ga->name);
break;
case GRIB_TYPE_LONG:
if (grib_runtimetype_get_long(value,&lval,&len) == GRIB_RUNTIMETYPE_SUCCESS) {
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to long %d", ga->name, lval);
grib_set_long_internal(h,ga->name,*lval);
} else
grib_context_log(h->context,GRIB_LOG_ERROR, "Unable to set %s to long, wrong type",
ga->name);
break;
case GRIB_TYPE_DOUBLE:
if (grib_runtimetype_get_double(value,&dval,&len) == GRIB_RUNTIMETYPE_SUCCESS) {
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to long %d", ga->name, dval);
grib_set_double_internal(h,ga->name,*dval);
} else
grib_context_log(h->context,GRIB_LOG_ERROR, "Unable to set %s to double, wrong type",
ga->name);
break;
case GRIB_TYPE_BYTES:
if (grib_runtimetype_get_char(value,&strvalue,&len) == GRIB_RUNTIMETYPE_SUCCESS) {
grib_context_log(h->context,GRIB_LOG_DEBUG, "Setting %s to string %s",
ga->name, strvalue);
grib_set_bytes_internal(h,ga->name,(unsigned char*)strvalue,&len);
} else
grib_context_log(h->context,GRIB_LOG_ERROR, "Unable to set %s to string, wrong type",
ga->name);
break;
case GRIB_TYPE_LABEL:
break;
default:
grib_context_log(h->context,GRIB_LOG_ERROR, "Setting %s, cannot establish type %d [%s]"
, ga->name,grib_accessor_get_native_type(ga),ga->creator->cclass->name);
break;
}
#endif
}
return retval;
}