grib_iarray* grib_iarray_resize_to(grib_iarray* v,size_t newsize)
{
long* newv;
size_t i;
grib_context* c=v->context;
if (newsize<v->size) return v;
if (!c) c=grib_context_get_default();
newv=(long*)grib_context_malloc_clear(c,newsize*sizeof(long));
if (!newv) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_iarray_resize unable to allocate %d bytes\n",sizeof(long)*newsize);
return NULL;
}
for (i=0;i<v->n;i++) newv[i]=v->v[i];
v->v-=v->number_of_pop_front;
grib_context_free(c,v->v);
v->v=newv;
v->size=newsize;
v->number_of_pop_front=0;
return v;
}
grib_iarray* grib_iarray_new(grib_context* c,size_t size,size_t incsize)
{
grib_iarray* v=NULL;
if (!c) c=grib_context_get_default();
v=(grib_iarray*)grib_context_malloc(c,sizeof(grib_iarray));
if (!v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_iarray_new unable to allocate %d bytes\n",sizeof(grib_iarray));
return NULL;
}
v->context=c;
v->size=size;
v->n=0;
v->incsize=incsize;
v->v=(long*)grib_context_malloc(c,sizeof(long)*size);
v->number_of_pop_front=0;
if (!v->v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_iarray_new unable to allocate %d bytes\n",sizeof(long)*size);
return NULL;
}
return v;
}
void grib_oarray_delete(grib_context* c,grib_oarray* v)
{
if (!v) return;
if (!c) grib_context_get_default();
if (v->v) grib_context_free(c,v->v);
grib_context_free(c,v);
}
static grib_concept_index_entry* index_entry_new(grib_context* c,grib_concept_index_keys* keys) {
grib_concept_index_entry* entry=NULL;
Assert(keys);
if (!c) c=grib_context_get_default();
entry=grib_context_malloc_clear(c,sizeof(grib_concept_index_entry));
if (!entry)
grib_context_log(c,GRIB_LOG_FATAL,"grib_concept_index_entry unable to allocate");
e=entry;
while (keys && keys->name) {
e->name=grib_context_strdup(c,keys->name);
e->type=keys->type;
e->next=grib_context_malloc_clear(c,sizeof(grib_concept_index_entry));
if (!e->next)
grib_context_log(c,GRIB_LOG_FATAL,"grib_concept_index_entry unable to allocate");
e=e->next;
keys=keys->next;
}
return entry;
}
int main(int argc, char *argv[])
{
FILE *f=NULL;
char* infname=NULL;
int ret=0;
grib_context* gc;
grib_handle* h;
FILE* of=NULL;
const void* buffer=NULL;
size_t size=0;
char* ofname=NULL;
if ( argc < 3 ) usage(argv[0]);
infname=argv[1];
ofname=argv[2];
f = fopen(infname,"r");
if(!f) {
perror(infname);
exit(1);
}
gc = grib_context_get_default();
h=grib_handle_new(gc);
if (!h) {
printf("Error: unable to create handle\n");
exit(1);
}
GRIB_CHECK(grib_load_from_text_file(h,f),infname);
if(fclose(f)) {
perror(infname);
exit(1);
}
of = fopen(ofname,"w");
if(!of) {
perror(ofname);
exit(1);
}
grib_get_message(h,&buffer,&size);
if(fwrite(buffer,1,size,of) != size) {
perror(ofname);
exit(1);
}
if(fclose(of)) {
perror(ofname);
exit(1);
}
return ret;
}
static void compare_files(const char* file1,const char* file2, blacklist* bl)
{
FILE *f1 = fopen(file1,"r");
FILE *f2 = fopen(file2,"r");
int e1 = 0;
int e2 = 0;
grib_handle *h1;
grib_handle *h2;
int count = 0;
int err = 0;
grib_context* c=grib_context_get_default( );
grib_multi_support_off(c);
if(!f1) {
perror(file1);
exit(1);
}
if(!f2) {
perror(file2);
exit(1);
}
h1 = grib_handle_new_from_file(c,f1,&e1);
h2 = grib_handle_new_from_file(c,f2,&e2);
while(h1 && h2)
{
++count;
printf("..............................\n");
if(compare_handles(h1,h2,bl)) err++;
printf("..............................\n");
if(compare_handles(h2,h1,bl)) err++;
grib_handle_delete(h1);
grib_handle_delete(h2);
e1 = e2 = 0;
h1 = grib_handle_new_from_file(c,f1,&e1);
h2 = grib_handle_new_from_file(c,f2,&e2);
}
GRIB_CHECK(e1,file1);
GRIB_CHECK(e2,file2);
if(h1 != h2)
{
fprintf(stderr,"%s: Premature eof on %s\n",prog,h1 == 0 ? file1 : file2);
exit(1);
}
if(err) exit(1);
}
int main(int argc,char* argv[]) {
struct stat finfo;
char shortName[20]={0,};
size_t len=20;
grib_handle* h=NULL;
size_t fsize;
unsigned char* data=NULL;
unsigned char* p=NULL;
void* pdata=NULL;
int error=0;
int count=0;
char* filename=NULL;
FILE* f=NULL;
long level=0;
grib_context* c=grib_context_get_default();
if (argc==3 && !strcmp(argv[1],"-m")) {
grib_multi_support_on(0);
filename=argv[2];
}
else if (argc==2) filename=argv[1];
else usage(argv[0]);
f=fopen(filename,"r");
if (!f) {perror(filename);exit(1);}
fstat(fileno((FILE*)f),&finfo);
fsize=finfo.st_size;
data=(unsigned char*)malloc(fsize);
p=data;
if (!data) {
fprintf(stderr,"unable to allocate %ld bytes\n",(long)fsize);
exit(1);
}
if( fread(data, 1, fsize, f) != fsize) {
perror(filename);
exit(1);
}
fclose(f);
pdata=&data;
while ((h=grib_handle_new_from_multi_message(c,(void**)pdata,&fsize,&error))!=NULL) {
count++;
len=20;
GRIB_CHECK(grib_get_string(h,"shortName",shortName,&len),"shortName");
GRIB_CHECK(grib_get_long(h,"level",&level),"level");
printf("%d %s %ld\n",count,shortName,level);
grib_handle_delete(h);
}
free(p);
return 0;
}
void grib_context_delete( grib_context* c){
if (!c) c=grib_context_get_default();
grib_hash_keys_delete( c->keys);
grib_trie_delete(c->def_files);
grib_context_reset( c );
if(c != &default_grib_context)
grib_context_free_persistent(&default_grib_context,c);
}
char *grib_context_full_path(grib_context* c,const char* basename)
{
int err=0;
char full[1024]={0,};
grib_string_list* dir=NULL;
grib_string_list* fullpath=0;
if (!c) c=grib_context_get_default();
GRIB_PTHREAD_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&mutex_c);
if(*basename == '/' || *basename == '.') {
GRIB_MUTEX_UNLOCK(&mutex_c);
return (char*)basename;
} else {
if ((fullpath=grib_trie_get(c->def_files,basename))!=NULL) {
GRIB_MUTEX_UNLOCK(&mutex_c);
return fullpath->value;
}
if (!c->grib_definition_files_dir)
err=init_definition_files_dir(c);
if (err != GRIB_SUCCESS) {
grib_context_log(c,GRIB_LOG_ERROR,
"Unable to find definition files directory");
GRIB_MUTEX_UNLOCK(&mutex_c);
return NULL;
}
dir=c->grib_definition_files_dir;
while (dir) {
sprintf(full,"%s/%s",dir->value,basename);
if (!access(full,F_OK)) {
fullpath=grib_context_malloc_clear_persistent(c,sizeof(grib_string_list));
Assert(fullpath);
fullpath->value=grib_context_strdup(c,full);
grib_trie_insert(c->def_files,basename,fullpath);
grib_context_log(c,GRIB_LOG_DEBUG,"Found def file %s",full);
GRIB_MUTEX_UNLOCK(&mutex_c);
return fullpath->value;
}
dir=dir->next;
}
}
/* Store missing files so we don't check for them again and again */
grib_trie_insert(c->def_files,basename,&grib_file_not_found);
/*grib_context_log(c,GRIB_LOG_ERROR,"Def file \"%s\" not found",basename);*/
GRIB_MUTEX_UNLOCK(&mutex_c);
full[0]=0;
return NULL;
}
void grib_oarray_delete_content(grib_context* c,grib_oarray* v)
{
int i;
if (!v | !v->v) return;
if (!c) grib_context_get_default();
for (i=0;i<v->n;i++) {
if (v->v[i]) grib_context_free(c,v->v[i]);
v->v[i]=0;
}
v->n=0;
}
void* grib_context_buffer_malloc(const grib_context* c, size_t size){
void* p = NULL;
if (!c) c=grib_context_get_default();
if(size == 0) return p;
else p=c->alloc_buffer_mem(c,size);
if(!p) {
grib_context_log(c,GRIB_LOG_FATAL,"grib_context_buffer_malloc: error allocating %lu bytes",(unsigned long)size);
exit(1);
}
return p;
}
long* grib_iarray_get_array(grib_iarray* v)
{
long* vv;
size_t i;
grib_context* c=grib_context_get_default();
vv=(long*)grib_context_malloc_clear(c,sizeof(long)*v->n);
for (i=0;i<v->n;i++) vv[i]=v->v[i];
return vv;
}
int main(int argc, char* argv[])
{
FILE* f;
int err=0;
char infile[]="../../data/reduced_gaussian_model_level.grib1";
grib_handle *h=NULL;
grib_context* c=grib_context_get_default();
grib_values values[2];
int nvalues=2;
int i;
char* name = NULL;
f=fopen(infile,"r");
if (!f) {
perror(infile);
exit(1);
}
h=grib_handle_new_from_file(c,f,&err);
if (!h) {
printf("unable to create handle from file %s\n",infile);
exit(err);
}
fclose(f);
values[0].type=GRIB_TYPE_LONG;
values[0].name="centre";
values[0].long_value=98;
values[1].type=GRIB_TYPE_LONG;
values[1].name="level";
values[1].long_value=2;
/*GRIB_VALUE_DIFFERENT -> value is different*/
err=grib_values_check(h,values,nvalues);
if (err) {
for (i=0;i<nvalues;i++) {
if (values[i].error==err) name=(char*)values[i].name;
}
printf("ERROR: \"%s\" %s\n",name,grib_get_error_message(err));
}
values[1].name="levelll";
err=grib_values_check(h,values,nvalues);
if (err) {
for (i=0;i<nvalues;i++) {
if (values[i].error==err) name=(char*)values[i].name;
}
printf("ERROR: \"%s\" %s\n",name,grib_get_error_message(err));
}
return 0;
}
void* grib_context_realloc(const grib_context* c, void *p,size_t size){
void* q;
if (!c) c=grib_context_get_default();
q=c->realloc_mem(c,p,size);
if(!q) {
grib_context_log(c,GRIB_LOG_FATAL,"grib_context_realloc: error allocating %lu bytes",(unsigned long)size);
exit(1);
}
return q;
}
/* --------------- grib_fieldset functions ------------------*/
grib_fieldset* grib_fieldset_new_from_files(grib_context* c,char* filenames[],
int nfiles, char** keys,int nkeys,
char* where_string,char* order_by_string,int* err) {
int i=0;
int ret=GRIB_SUCCESS;
grib_order_by* ob=NULL;
grib_fieldset* set=0;
if (!c) c=grib_context_get_default( );
if (( (!keys || nkeys==0) && !order_by_string )
|| !filenames ) {
*err=GRIB_INVALID_ARGUMENT;
return NULL;
}
if (order_by_string) {
ob=grib_fieldset_new_order_by(c,order_by_string);
if (!ob) {
*err=GRIB_INVALID_ORDERBY;
return NULL;
}
}
if ( !keys || nkeys==0 ) {
set=grib_fieldset_create_from_order_by(c,ob,err);
} else {
set=grib_fieldset_create_from_keys(c,keys,nkeys,err);
}
*err=GRIB_SUCCESS;
for (i=0;i<nfiles;i++) {
ret=grib_fieldset_add(set,filenames[i]);
if (ret != GRIB_SUCCESS) {
*err=ret;
return NULL;
}
}
if (where_string) grib_fieldset_apply_where(set,where_string);
if (order_by_string) {
if (!set->order_by && ob) *err=grib_fieldset_set_order_by(set,ob);
if (*err!=GRIB_SUCCESS) return NULL;
grib_fieldset_sort(set,0,set->size-1);
grib_fieldset_rewind(set);
}
return set;
}
grib_iarray* grib_iarray_new_from_array(grib_context* c,long* a,size_t size)
{
size_t i;
grib_iarray* v;
if (!c) c=grib_context_get_default();
v=grib_iarray_new(c,size,100);
for (i=0;i<size;i++) v->v[i]=a[i];
v->n=size;
v->number_of_pop_front=0;
v->context=c;
return v;
}
grib_darray* grib_darray_resize(grib_context* c,grib_darray* v) {
int newsize=v->incsize+v->size;
if (!c) c=grib_context_get_default();
v->v=grib_context_realloc(c,v->v,newsize*sizeof(double));
v->size=newsize;
if (!v->v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_darray_resize unable to allocate %d bytes\n",sizeof(double)*newsize);
return NULL;
}
return v;
}
grib_concept_index* grib_concept_index_new_from_concept(grib_context* c,grib_concept_value* concept,int *err) {
grib_concept_index* index;
if (!c) c=grib_context_get_default();
index=grib_context_malloc_clear_persistent(c,sizeof(grib_concept_index));
index->keys=grib_context_malloc_clear_persistent(c,sizeof(grib_concept_index_key));
index->conditions=grib_context_malloc_clear_persistent(c,sizeof(grib_conditions_tree));
index->conditions=grib_context_malloc_clear_persistent(c,sizeof(grib_conditions_tree));
index->context=c;
while (concept) {
index_add_conditions(index,concept->conditions,err);
concept=concept->next;
}
return index;
}
static int init_definition_files_dir(grib_context* c) {
int err=0;
char* path=NULL;
char* p=NULL;
char* dir=NULL;
grib_string_list* next=NULL;
if (!c) c=grib_context_get_default();
if (c->grib_definition_files_dir) return 0;
if (!c->grib_definition_files_path) return GRIB_NO_DEFINITIONS;
path=c->grib_definition_files_path;
GRIB_PTHREAD_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&mutex_c);
p=path;
while(*p!=':' && *p!='\0') p++;
if (*p != ':') {
c->grib_definition_files_dir=(grib_string_list*)grib_context_malloc_clear_persistent(c,sizeof(grib_string_list));
c->grib_definition_files_dir->value=grib_context_strdup(c,path);
} else {
dir=strtok(path,":");
while (dir != NULL) {
if (next) {
next->next=(grib_string_list*)grib_context_malloc_clear_persistent(c,sizeof(grib_string_list));
next=next->next;
} else {
c->grib_definition_files_dir=(grib_string_list*)grib_context_malloc_clear_persistent(c,sizeof(grib_string_list));
next=c->grib_definition_files_dir;
}
next->value=grib_context_strdup(c,dir);
dir=strtok(NULL,":");
}
}
GRIB_MUTEX_UNLOCK(&mutex_c);
return err;
}
grib_context* grib_context_new(grib_context* parent)
{
grib_context* c;
#if GRIB_PTHREADS
pthread_mutexattr_t attr;
#endif
if (!parent) parent=grib_context_get_default();
GRIB_PTHREAD_ONCE(&once,&init);
GRIB_MUTEX_LOCK(&(parent->mutex));
c = (grib_context*)grib_context_malloc_clear_persistent(&default_grib_context,sizeof(grib_context));
c->inited = default_grib_context.inited;
c->debug = default_grib_context.debug;
c->real_mode = default_grib_context.real_mode;
c->free_mem = default_grib_context.free_mem;
c->alloc_mem = default_grib_context.alloc_mem;
c->free_persistent_mem = default_grib_context.free_persistent_mem;
c->alloc_persistent_mem= default_grib_context.alloc_persistent_mem;
c->read = default_grib_context.read;
c->write = default_grib_context.write;
c->tell = default_grib_context.tell;
c->output_log = default_grib_context.output_log;
c->print = default_grib_context.print ;
c->user_data = default_grib_context.user_data;
c->def_files = default_grib_context.def_files;
#if GRIB_PTHREADS
pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&mutex_c,&attr);
pthread_mutexattr_destroy(&attr);
#endif
GRIB_MUTEX_UNLOCK(&(parent->mutex));
return c;
}
int main(int argc, char *argv[])
{
int i = 0;
int fail = 0;
grib_context* c = grib_context_get_default();
grib_action* a=NULL;
for(i = 1; i < argc; i++){
/* printf("%s ... \n",argv[i]);fflush(stdout); */
if(!(a=grib_parse_file(c,argv[i])))
{
fail++;
printf("FAILED\n");
exit(1);
} else print_names(a);
}
return fail;
}
grib_darray* grib_darray_new(grib_context* c,size_t size,size_t incsize) {
grib_darray* v=NULL;
if (!c) c=grib_context_get_default();
v=(grib_darray*)grib_context_malloc(c,sizeof(grib_darray));
if (!v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_darray_new unable to allocate %d bytes\n",sizeof(grib_darray));
return NULL;
}
v->size=size;
v->n=0;
v->incsize=incsize;
v->v=(double*)grib_context_malloc(c,sizeof(double)*size);
if (!v->v) {
grib_context_log(c,GRIB_LOG_ERROR,
"grib_darray_new unable to allocate %d bytes\n",sizeof(double)*size);
return NULL;
}
return v;
}
static void default_log(const grib_context* c, int level, const char* mess){
if (!c) c=grib_context_get_default();
if(level == GRIB_LOG_ERROR) {
fprintf(c->log_stream, "GRIB_API ERROR : %s\n", mess);
/*Assert(1==0);*/
}
if(level == GRIB_LOG_FATAL) fprintf(c->log_stream, "GRIB_API ERROR : %s\n", mess);
if(level == GRIB_LOG_DEBUG && c->debug>0) fprintf(c->log_stream, "GRIB_API DEBUG : %s\n", mess);
if(level == GRIB_LOG_WARNING) fprintf(c->log_stream, "GRIB_API WARNING : %s\n", mess);
if(level == GRIB_LOG_INFO) fprintf(c->log_stream, "GRIB_API INFO : %s\n", mess);
if(level == GRIB_LOG_FATAL) { Assert(0);}
if(getenv("GRIB_API_FAIL_IF_LOG_MESSAGE"))
{
long n = atol(getenv("GRIB_API_FAIL_IF_LOG_MESSAGE"));
if(n >= 1 && level == GRIB_LOG_ERROR) Assert(0);
if(n >= 2 && level == GRIB_LOG_WARNING) Assert(0);
}
}
void grib_context_reset(grib_context* c){
if (!c) c=grib_context_get_default();
if(c->grib_reader)
{
grib_action_file *fr = c->grib_reader->first;
grib_action_file *fn = fr;
grib_action* a;
while(fn){
fr = fn;
fn = fn->next;
a = fr->root;
while(a)
{
grib_action *na = a->next;
grib_free_action(c, a);
a = na;
}
grib_context_free_persistent(c, fr->filename);
grib_context_free_persistent(c, fr);
}
grib_context_free_persistent(c, c->grib_reader);
}
c->grib_reader = NULL;
if(c->codetable) grib_codetable_delete(c);
c->codetable = NULL;
if(c->grib_definition_files_dir)
grib_context_free(c,c->grib_definition_files_dir);
if(c->multi_support_on)
grib_multi_support_reset(c);
}
int main(int argc,char* argv[]) {
char* file;
int err=0;
grib_handle* h;
char identifier[7]={0,};
size_t len=7;
grib_context* c=grib_context_get_default();
if (argc>2) usage(argv[0]);
file=argv[1];
h=grib_handle_new_from_nc_file(c,file,&err);
grib_get_string(h,"identifier",identifier,&len);
printf("%s\n",identifier);
GRIB_CHECK(err,0);
return err;
}
int main(int argc, char *argv[])
{
int i = 0;
int fail = 0;
grib_context* c = grib_context_get_default();
grib_action* a=NULL;
for(i = 1; i < argc; i++) {
a=grib_parse_file(c,argv[i]);
if (!a)
{
fail++;
printf("FAILED\n");
exit(1);
}
while (a) {
if (*(a->name) != '_') printf("%s\n",a->name);
a=a->next;
}
}
return fail;
}
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;
}
grib_context* codes_context_get_default(void)
{
return grib_context_get_default();
}
static grib_fieldset* grib_fieldset_create_from_keys(grib_context* c,char** keys,int nkeys,
int* err) {
grib_fieldset* set=0;
size_t msize=0,size=0;
int i=0;
int type=0;
int default_type=GRIB_TYPE_STRING;
if (!c) c=grib_context_get_default( );
size=GRIB_START_ARRAY_SIZE;
msize=sizeof(grib_fieldset);
set=(grib_fieldset*)grib_context_malloc_clear(c,msize);
if (!set) {
grib_context_log(c, GRIB_LOG_ERROR,
"grib_fieldset_create : Cannot malloc %d bytes",msize);
return NULL;
}
set->context=c;
set->fields_array_size=size;
set->size=0;
set->current=-1;
set->fields=0;
set->filter=0;
set->order=0;
set->columns=0;
set->where=0;
set->order_by=0;
set->fields=grib_fieldset_create_fields(set->context,size);
set->order=grib_fieldset_create_int_array(c,size);
set->filter=grib_fieldset_create_int_array(c,size);
for (i=0;i<set->filter->size;i++)
set->filter->el[i]=i;
set->columns=(grib_column*)grib_context_malloc_clear(c,sizeof(grib_column)*nkeys);
if (!set->columns) {
grib_context_log(c,GRIB_LOG_ERROR,"grib_fieldset_new_query: memory allocation error");
*err=GRIB_OUT_OF_MEMORY;
return NULL;
}
for (i=0;i<nkeys;i++) {
char* key=grib_context_strdup(c,keys[i]);
char* p=key;
while(*p != ':' && *p != '\0') p++;
if (*p==':') {
type = grib_type_to_int(*(p+1));
*p='\0';
} else {
type = default_type;
}
*err=grib_fieldset_new_column(set,i,key,type);
grib_context_free(c,key);
}
set->columns_size=nkeys;
return set;
}
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;
}
