int RawRead(int fid,struct RadarParm *prm,struct RawData *raw) { int s; struct DataMap *ptr; ptr=DataMapRead(fid); if (ptr==NULL) return -1; s=RadarParmDecode(ptr,prm); if (s !=0) { DataMapFree(ptr); return s; } s=RawDecode(ptr,raw); DataMapFree(ptr); return s; }
void DataMapFreeArray(struct DataMapArray *ptr) { if (ptr==NULL) return; if ((ptr->mode & 0x04) && (ptr->data.vptr !=NULL) && (ptr->type==DATASTRING)) { int s=1,n; char **v=NULL; for (n=0;n<ptr->dim;n++) s=s*ptr->rng[n]; v=((char **) ptr->data.vptr); for (n=0;n<s;n++) if (v[n] !=NULL) free(v[n]); } if ((ptr->mode & 0x04) && (ptr->data.mptr !=NULL) && (ptr->type==DATAMAP)) { int s=1,n; for (n=0;n<ptr->dim;n++) s=s*ptr->rng[n]; for (n=0;n<s;n++) if (ptr->data.mptr[n] !=NULL) DataMapFree(ptr->data.mptr[n]); } if ((ptr->mode & 0x01) && (ptr->rng !=NULL)) free(ptr->rng); if (ptr->name !=NULL) free(ptr->name); if ((ptr->mode & 0x02) && (ptr->data.vptr !=NULL)) free(ptr->data.vptr); free(ptr); return; }
int FitRead(int fid,struct RadarParm *prm, struct FitData *fit) { int s; struct DataMap *ptr; ptr=DataMapRead(fid); if (ptr==NULL) return -1; s=RadarParmDecode(ptr,prm); if (s !=0) { DataMapFree(ptr); return s; } s=FitDecode(ptr,fit); DataMapFree(ptr); return s; }
unsigned char *fitpacket(struct RadarParm *prm, struct FitData *fit,int *size) { int sze=0; unsigned char *buf; struct DataMap *data; data=DataMapMake(); RadarParmEncode(data,prm); FitEncode(data,prm,fit); buf=DataMapEncodeBuffer(data,&sze); if (size !=NULL) *size=sze; DataMapFree(data); return buf; }
void DataMapFreeScalar(struct DataMapScalar *ptr) { if (ptr==NULL) return; if (ptr->name !=NULL) free(ptr->name); if ((ptr->mode & 0x04) && (ptr->data.vptr !=NULL) && (ptr->type==DATASTRING) && (*((char **) ptr->data.vptr) !=NULL)) free(* (char **) ptr->data.vptr); if ((ptr->mode & 0x04) && (ptr->data.mptr !=NULL) && (ptr->type==DATAMAP) && (*ptr->data.mptr !=NULL)) DataMapFree(*ptr->data.mptr); if ((ptr->mode !=0) && (ptr->data.vptr !=NULL)) free(ptr->data.vptr); free(ptr); return; }
int MergeWrite(int fid,struct MergeData *data) { int s; struct DataMap *ptr=NULL; ptr=DataMapMake(); if (ptr==NULL) return -1; s=MergeEncode(ptr,data); if (s==0) { if (fid !=-1) s=DataMapWrite(fid,ptr); else s=DataMapSize(ptr); } DataMapFree(ptr); return s; }
int FitWrite(int fid,struct RadarParm *prm, struct FitData *fit) { int s; struct DataMap *ptr=NULL; ptr=DataMapMake(); if (ptr==NULL) return -1; s=RadarParmEncode(ptr,prm); if (s==0) s=FitEncode(ptr,prm,fit); if (s==0) { if (fid !=-1) s=DataMapWrite(fid,ptr); else s=DataMapSize(ptr); } DataMapFree(ptr); return s; }
int main(int argc,char *argv[]) { int t,n; float set[3]={0.1,0.2,10.2}; int32 dim=1; int32 rng[1]={3}; struct DataMap *dmap; dmap=DataMapMake(); DataMapAddArray(dmap,"set",DATAFLOAT,dim,rng,&set); for (t=0;t<100;t++) { for (n=0;n<3;n++) set[n]=set[n]+0.1; DataMapFwrite(stdout,dmap); } DataMapFree(dmap); return 0; }
int main(int argc,char *argv[]) { int arg; int sock; int remote_port=0; char *host; int flag,status,size; unsigned char help=0; unsigned char option=0; unsigned char *buffer=NULL; unsigned char stream=255; char **tmp; struct DataMap *ptr; struct DataMapScalar *s; struct DataMapArray *a; int c,n,x; int sval=255; unsigned char dflg=0; OptionAdd(&opt,"-help",'x',&help); OptionAdd(&opt,"-option",'x',&option); OptionAdd(&opt,"d",'x',&dflg); OptionAdd(&opt,"s",'i',&sval); arg=OptionProcess(1,argc,argv,&opt,NULL); if (help==1) { OptionPrintInfo(stdout,hlpstr); exit(0); } if (option==1) { OptionDump(stdout,&opt); exit(0); } if (argc-arg<2) { OptionPrintInfo(stderr,errstr); exit(-1); } host=argv[argc-2]; remote_port=atoi(argv[argc-1]); stream=sval; sock=ConnexOpen(host,remote_port,NULL); if (sock<0) { fprintf(stderr,"Could not connect to host.\n"); exit(-1); } status=(write(sock,&stream,sizeof(char)) !=1); if (status !=0) { fprintf(stderr,"Could not set stream to host.\n"); exit(-1); } do { status=ConnexRead(1,&sock,&buffer,&size,&flag,NULL); if (status==-1) break; if (flag !=-1) { fprintf(stderr,"Message size:%d\n",size); if (size==0) continue; ptr=DataMapDecodeBuffer(buffer,size); if (ptr==NULL) fprintf(stderr,"Not a recognized message.\n"); else { fprintf(stdout,"scalars:\n"); for (c=0; c<ptr->snum; c++) { s=ptr->scl[c]; switch (s->type) { case DATACHAR: fprintf(stdout,"\tchar"); break; case DATASHORT: fprintf(stdout,"\tshort"); break; case DATAINT: fprintf(stdout,"\tint"); break; case DATAFLOAT: fprintf(stdout,"\tfloat"); break; case DATADOUBLE: fprintf(stdout,"\tdouble"); break; case DATASTRING: fprintf(stdout,"\tstring"); break; } fprintf(stdout,"\t%c%s%c",'"',s->name,'"'); fprintf(stdout," = "); switch (s->type) { case DATACHAR: fprintf(stdout,"%d",*(s->data.cptr)); break; case DATASHORT: fprintf(stdout,"%d",*(s->data.sptr)); break; case DATAINT: fprintf(stdout,"%d",*(s->data.iptr)); break; case DATAFLOAT: fprintf(stdout,"%g",*(s->data.fptr)); break; case DATADOUBLE: fprintf(stdout,"%g",*(s->data.dptr)); break; case DATASTRING: tmp=(char **) s->data.vptr; fprintf(stdout,"%c%s%c",'"',*tmp,'"'); break; } fprintf(stdout,"\n"); } fprintf(stdout,"arrays:\n"); for (c=0; c<ptr->anum; c++) { a=ptr->arr[c]; switch (a->type) { case DATACHAR: fprintf(stdout,"\tchar"); break; case DATASHORT: fprintf(stdout,"\tshort"); break; case DATAINT: fprintf(stdout,"\tint"); break; case DATAFLOAT: fprintf(stdout,"\tfloat"); break; case DATADOUBLE: fprintf(stdout,"\tdouble"); break; case DATASTRING: fprintf(stdout,"\tstring"); break; } fprintf(stdout,"\t%c%s%c",'"',a->name,'"'); fprintf(stdout," "); for (x=0; x<a->dim; x++) fprintf(stdout,"[%d]",a->rng[x]); if (dflg) { fprintf(stdout,"="); n=1; for (x=0; x<a->dim; x++) n=a->rng[x]*n; for (x=0; x<n; x++) { if (x % a->rng[a->dim-1]==0) fprintf(stdout,"\n\t\t"); else if (x !=0) fprintf(stdout,",\t"); switch (a->type) { case DATACHAR: fprintf(stdout,"%d",a->data.cptr[x]); break; case DATASHORT: fprintf(stdout,"%d",a->data.sptr[x]); break; case DATAINT: fprintf(stdout,"%d",a->data.iptr[x]); break; case DATAFLOAT: fprintf(stdout,"%g",a->data.fptr[x]); break; case DATADOUBLE: fprintf(stdout,"%g",a->data.dptr[x]); break; case DATASTRING: tmp=(char **) a->data.vptr; fprintf(stdout,"%c%s%c",'"',tmp[x],'"'); break; } } fprintf(stdout,"\n"); } else fprintf(stdout,"\n"); } DataMapFree(ptr); } } } while(1); fprintf(stderr,"Connection failed.\n"); return 0; }
int GridRead(int fid,struct GridData *gp) { int c,x,n; struct DataMap *ptr; struct DataMapScalar *s; struct DataMapArray *a; int size=0; int yr,mo,dy,hr,mt; double sc; void *tmp; char *sname[]={"start.year","start.month","start.day","start.hour", "start.minute","start.second", "end.year","end.month","end.day","end.hour", "end.minute","end.second",0}; int stype[]={DATASHORT,DATASHORT,DATASHORT,DATASHORT,DATASHORT,DATADOUBLE, DATASHORT,DATASHORT,DATASHORT,DATASHORT,DATASHORT,DATADOUBLE}; struct DataMapScalar *sdata[12]; char *aname[]={"stid","channel","nvec", "freq","major.revision","minor.revision", "program.id","noise.mean","noise.sd","gsct", "v.min","v.max","p.min","p.max","w.min","w.max","ve.min", "ve.max", "vector.mlat","vector.mlon","vector.kvect", "vector.stid","vector.channel","vector.index", "vector.vel.median","vector.vel.sd", "vector.pwr.median","vector.pwr.sd", "vector.wdt.median","vector.wdt.sd",0}; int atype[]={DATASHORT,DATASHORT,DATASHORT, DATAFLOAT,DATASHORT,DATASHORT, DATASHORT,DATAFLOAT,DATAFLOAT,DATASHORT, DATAFLOAT,DATAFLOAT,DATAFLOAT,DATAFLOAT,DATAFLOAT,DATAFLOAT, DATAFLOAT,DATAFLOAT, DATAFLOAT,DATAFLOAT,DATAFLOAT, DATASHORT,DATASHORT,DATAINT, DATAFLOAT,DATAFLOAT, DATAFLOAT,DATAFLOAT, DATAFLOAT,DATAFLOAT}; struct DataMapArray *adata[40]; ptr=DataMapReadBlock(fid,&size); if (ptr==NULL) return -1; for (c=0;sname[c] !=0;c++) sdata[c]=NULL; for (c=0;aname[c] !=0;c++) adata[c]=NULL; for (c=0;c<ptr->snum;c++) { s=ptr->scl[c]; for (x=0;sname[x] !=0;x++) if ((strcmp(s->name,sname[x])==0) && (s->type==stype[x])) { sdata[x]=s; break; } } for (c=0;c<ptr->anum;c++) { a=ptr->arr[c]; for (x=0;aname[x] !=0;x++) { if ((strcmp(a->name,aname[x])==0) && (a->type==atype[x])) { adata[x]=a; break; } } } for (x=0;sname[x] !=0;x++) if (sdata[x]==NULL) break; if ((sname[x] !=0) && (sdata[x]==NULL)) { DataMapFree(ptr); return -1; } for (x=0;x<18;x++) if (adata[x]==NULL) break; if (x !=18) { DataMapFree(ptr); return -1; } yr=*(sdata[0]->data.sptr); mo=*(sdata[1]->data.sptr); dy=*(sdata[2]->data.sptr); hr=*(sdata[3]->data.sptr); mt=*(sdata[4]->data.sptr); sc=*(sdata[5]->data.dptr); gp->st_time=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc); yr=*(sdata[6]->data.sptr); mo=*(sdata[7]->data.sptr); dy=*(sdata[8]->data.sptr); hr=*(sdata[9]->data.sptr); mt=*(sdata[10]->data.sptr); sc=*(sdata[11]->data.dptr); gp->ed_time=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc); gp->stnum=adata[0]->rng[0]; if (gp->stnum==0) { DataMapFree(ptr); return -1; } if (gp->sdata !=NULL) { tmp=realloc(gp->sdata,sizeof(struct GridSVec)*gp->stnum); if (tmp==NULL) { DataMapFree(ptr); return -1; } gp->sdata=tmp; } else gp->sdata=malloc(sizeof(struct GridSVec)*gp->stnum); if (gp->sdata==NULL) { DataMapFree(ptr); return -1; } for (n=0;n<gp->stnum;n++) { gp->sdata[n].st_id=adata[0]->data.sptr[n]; gp->sdata[n].chn=adata[1]->data.sptr[n]; gp->sdata[n].npnt=adata[2]->data.sptr[n]; gp->sdata[n].freq0=adata[3]->data.fptr[n]; gp->sdata[n].major_revision=adata[4]->data.sptr[n]; gp->sdata[n].minor_revision=adata[5]->data.sptr[n]; gp->sdata[n].prog_id=adata[6]->data.sptr[n]; gp->sdata[n].noise.mean=adata[7]->data.fptr[n]; gp->sdata[n].noise.sd=adata[8]->data.fptr[n]; gp->sdata[n].gsct=adata[9]->data.sptr[n]; gp->sdata[n].vel.min=adata[10]->data.fptr[n]; gp->sdata[n].vel.max=adata[11]->data.fptr[n]; gp->sdata[n].pwr.min=adata[12]->data.fptr[n]; gp->sdata[n].pwr.max=adata[13]->data.fptr[n]; gp->sdata[n].wdt.min=adata[14]->data.fptr[n]; gp->sdata[n].wdt.max=adata[15]->data.fptr[n]; gp->sdata[n].verr.min=adata[16]->data.fptr[n]; gp->sdata[n].verr.max=adata[17]->data.fptr[n]; } if (adata[18] !=NULL) gp->vcnum=adata[18]->rng[0]; else { gp->vcnum=0; if (gp->data !=NULL) free(gp->data); gp->data=NULL; DataMapFree(ptr); return size; } if (gp->data !=NULL) { tmp=realloc(gp->data,sizeof(struct GridGVec)*gp->vcnum); if (tmp==NULL) { DataMapFree(ptr); return -1; } gp->data=tmp; } else gp->data=malloc(sizeof(struct GridGVec)*gp->vcnum); if (gp->data==NULL) { DataMapFree(ptr); return -1; } for (n=26;n<30;n++) if (adata[n] !=NULL) { gp->xtd=1; break; } for (n=0;n<gp->vcnum;n++) { gp->data[n].mlat=adata[18]->data.fptr[n]; gp->data[n].mlon=adata[19]->data.fptr[n]; gp->data[n].azm=adata[20]->data.fptr[n]; gp->data[n].st_id=adata[21]->data.sptr[n]; gp->data[n].chn=adata[22]->data.sptr[n]; gp->data[n].index=adata[23]->data.lptr[n]; gp->data[n].vel.median=adata[24]->data.fptr[n]; gp->data[n].vel.sd=adata[25]->data.fptr[n]; gp->data[n].pwr.median=0; gp->data[n].pwr.sd=0; gp->data[n].wdt.median=0; gp->data[n].wdt.sd=0; if (adata[26] !=NULL) gp->data[n].pwr.median=adata[26]->data.fptr[n]; if (adata[27] !=NULL) gp->data[n].pwr.sd=adata[27]->data.fptr[n]; if (adata[28] !=NULL) gp->data[n].wdt.median=adata[28]->data.fptr[n]; if (adata[29] !=NULL) gp->data[n].wdt.sd=adata[29]->data.fptr[n]; } DataMapFree(ptr); return size; }
int main(int argc,char *argv[]) { int status=0; struct DataMap *ptr=NULL; struct DataMapScalar *sx=NULL,*sy=NULL; struct DataMapArray *ax=NULL,*ay=NULL; struct DimMap *dx=NULL; unsigned char vbflg=0; unsigned char help=0; unsigned char option=0; unsigned char zflg=0; FILE *fp=NULL; int c,i; gzFile zfp=0; int x=0,n=0; OptionAdd(&opt,"-help",'x',&help); OptionAdd(&opt,"-option",'x',&option); OptionAdd(&opt,"vb",'x',&vbflg); OptionAdd(&opt,"z",'x',&zflg); if (argc>1) { arg=OptionProcess(1,argc,argv,&opt,NULL); if (help==1) { OptionPrintInfo(stdout,hlpstr); exit(0); } if (option==1) { OptionDump(stdout,&opt); exit(0); } if (zflg) { zfp=gzopen(argv[arg],"r"); if (zfp==0) { fprintf(stderr,"File not found.\n"); exit(-1); } } else { fp=fopen(argv[arg],"r"); if (fp==NULL) { fprintf(stderr,"File not found.\n"); exit(-1); } } } else { OptionPrintInfo(stdout,errstr); exit(-1); } while (1) { if (zflg) ptr=DataMapReadZ(zfp); else ptr=DataMapFread(fp); if (ptr==NULL) break; for (c=0;c<ptr->snum;c++) { sx=ptr->scl[c]; for (n=0;n<snum;n++) { sy=sptr[n]; if (strcmp(sx->name,sy->name) !=0) continue; if (sx->type !=sy->type) continue; break; } if (n==snum) { /* copy the scalar */ if (sptr==NULL) sptr=malloc(sizeof(struct DataMapScalar *)); else { struct DataMapScalar **tmp; tmp=realloc(sptr,(snum+1)*sizeof(struct DataMapScalar *)); if (tmp==NULL) break; sptr=tmp; } sptr[snum]=DataMapMakeScalar(sx->name,0,sx->type,NULL); snum++; } } if (c !=ptr->snum) { status=-1; break; } for (c=0;c<ptr->anum;c++) { ax=ptr->arr[c]; for (n=0;n<anum;n++) { ay=aptr[n]; if (strcmp(ax->name,ay->name) !=0) continue; if (ax->type != ay->type) continue; if (ax->dim != ay->dim) continue; break; } if (n !=anum) { /* check the ranges */ for (i=0;i<ax->dim;i++) if (ax->rng[i]>rptr[roff[n]+i]) rptr[roff[n]+i]=ax->rng[i]; } if (n==anum) { /* copy the array */ if (roff==NULL) roff=malloc(sizeof(int32)); else { int32 *tmp; tmp=realloc(roff,(anum+1)*sizeof(int32)); if (tmp==NULL) break; roff=tmp; } roff[anum]=rnum; if (rptr==NULL) rptr=malloc(sizeof(int32)*ax->dim); else { int32 *tmp; tmp=realloc(rptr,(rnum+ax->dim)*sizeof(int32)); if (tmp==NULL) break; rptr=tmp; } for (i=0;i<ax->dim;i++) rptr[rnum+i]=ax->rng[i]; rnum+=ax->dim; if (aptr==NULL) aptr=malloc(sizeof(struct DataMapArray *)); else { struct DataMapArray **tmp; tmp=realloc(aptr,(anum+1)*sizeof(struct DataMapArray *)); if (tmp==NULL) break; aptr=tmp; } aptr[anum]=DataMapMakeArray(ax->name,0,ax->type,ax->dim,NULL, NULL); anum++; } } if (c !=ptr->anum) { status=-1; break; } DataMapFree(ptr); } if (zflg) gzclose(zfp); else fclose(fp); if (status==-1) { fprintf(stderr,"Error processing file.\n"); exit(-1); } for (n=0;n<anum;n++) { ax=aptr[n]; ax->rng=rptr+roff[n]; for (c=0;c<ax->dim;c++) if (ax->rng[c]==0) break; /* bad data */ if (c !=ax->dim) ax->dim=0; } cdfsname=malloc(sizeof(char *)*snum); if (cdfsname==NULL) { fprintf(stderr,"Could not allocate scalar name table.\n"); exit(-1); } cdfaname=malloc(sizeof(char *)*anum); if (cdfaname==NULL) { fprintf(stderr,"Could not allocate array name table.\n"); exit(-1); } for (n=0;n<snum;n++) { sx=sptr[n]; cdfsname[n]=malloc(strlen(sx->name)+1); for (c=0;sx->name[c] !=0;c++) if (isalnum(sx->name[c])) cdfsname[n][c]=sx->name[c]; else cdfsname[n][c]='_'; cdfsname[n][c]=0; x=0; for (c=0;c<n;c++) if (strncmp(cdfsname[c],cdfsname[n], strlen(cdfsname[n]))==0) x++;; if (x !=0) { char *tmp; char txt[4]; x++; sprintf(txt,"%.3d",x); tmp=realloc(cdfsname[n],strlen(cdfsname[n])+4); if (tmp==NULL) break; cdfsname[n]=tmp; strcat(cdfsname[n],txt); } } if (n !=snum) { fprintf(stderr,"Error generating names.\n"); exit(-1); } for (n=0;n<anum;n++) { ax=aptr[n]; cdfaname[n]=NULL; if (ax->dim==0) continue; cdfaname[n]=malloc(strlen(ax->name)+1); for (c=0;ax->name[c] !=0;c++) if (isalnum(ax->name[c])) cdfaname[n][c]=ax->name[c]; else cdfaname[n][c]='_'; cdfaname[n][c]=0; for (c=0;c<n;c++) if (strncmp(cdfaname[c],cdfaname[n], strlen(cdfaname[n]))==0) x++; if (x !=0) { char *tmp; char txt[4]; x++; sprintf(txt,"%.3d",x); tmp=realloc(cdfaname[n],strlen(cdfaname[n])+4); if (tmp==NULL) break; cdfaname[n]=tmp; strcat(cdfaname[n],txt); } } if (n !=anum) { fprintf(stderr,"Error generating names.\n"); exit(-1); } /* build the dimension table */ for (n=0;n<snum;n++) { sx=sptr[n]; if (sx->type != DATASTRING) continue; if (dnum==0) dptr=malloc(sizeof(struct DimMap *)); else { struct DimMap **tmp; tmp=realloc(dptr,(dnum+1)*sizeof(struct DimMap *)); if (tmp==NULL) break; dptr=tmp; } dx=malloc(sizeof(struct DimMap)); dptr[dnum]=dx; dx->flg=0; dx->num=n; dx->dim=0; dx->value=STRINGSIZE; dx->name=malloc(strlen(cdfsname[n])+1); strcpy(dx->name,cdfsname[n]); x=0; for (c=0;c<dnum;c++) if (strncmp(dptr[c]->name,dx->name, strlen(dx->name))==0) x++; if (x !=0) { char *tmp; char txt[4]; x++; sprintf(txt,"%.3d",x); tmp=realloc(dx->name,strlen(dx->name)+4); if (tmp==NULL) break; dx->name=tmp; strcat(dx->name,txt); } dnum++; } if (n !=snum) { fprintf(stderr,"Error building dimension table.\n"); exit(-1); } for (n=0;n<anum;n++) { ax=aptr[n]; if (ax->dim==0) continue; for (i=0;i<ax->dim;i++) { if (dnum==0) dptr=malloc(sizeof(struct DimMap *)); else { struct DimMap **tmp; tmp=realloc(dptr,(dnum+1)*sizeof(struct DimMap *)); if (tmp==NULL) break; dptr=tmp; } dx=malloc(sizeof(struct DimMap)); dptr[dnum]=dx; dx->flg=1; dx->num=n; dx->dim=i; dx->value=ax->rng[i]; dx->name=malloc(strlen(cdfaname[n])+1); strcpy(dx->name,cdfaname[n]); x=0; for (c=0;c<dnum;c++) if (strncmp(dptr[c]->name,dx->name, strlen(dx->name))==0) x++; if (x !=0) { char *tmp; char txt[4]; x++; sprintf(txt,"%.3d",x); tmp=realloc(dx->name,strlen(dx->name)+4); if (tmp==NULL) break; dx->name=tmp; strcat(dx->name,txt); } dnum++; } if (ax->type==DATASTRING) { if (dnum==0) dptr=malloc(sizeof(struct DimMap *)); else { struct DimMap **tmp; tmp=realloc(dptr,(dnum+1)*sizeof(struct DimMap *)); if (tmp==NULL) break; dptr=tmp; } dx=malloc(sizeof(struct DimMap)); dptr[dnum]=dx; dx->flg=1; dx->num=n; dx->dim=i; dx->value=STRINGSIZE; dx->name=malloc(strlen(cdfaname[n])+1); strcpy(dx->name,cdfaname[n]); x=0; for (c=0;c<dnum;c++) if (strncmp(dptr[c]->name,dx->name, strlen(dx->name))==0) x++; if (x !=0) { char *tmp; char txt[4]; x++; sprintf(txt,"%.3d",x); tmp=realloc(dx->name,strlen(dx->name)+4); if (tmp==NULL) break; dx->name=tmp; strcat(dx->name,txt); } dnum++; } } if (n !=anum) { fprintf(stderr,"Error building dimension table.\n"); exit(-1); } fp=fopen(argv[2],"w"); fprintf(fp,"netcdf dmap {\n\n"); fprintf(fp,"dimensions:\n"); fprintf(fp,"\tblock=unlimited;\n"); for (n=0;n<dnum;n++) { dx=dptr[n]; fprintf(fp,"\t%s=%d;\n",dx->name,dx->value); } fprintf(fp,"variables:\n"); for (n=0;n<snum;n++) { fprintf(fp,"\t"); sx=sptr[n]; switch(sx->type) { case DATACHAR: fprintf(fp,"char"); break; case DATASHORT: fprintf(fp,"short"); break; case DATAINT: fprintf(fp,"int"); break; case DATAFLOAT: fprintf(fp,"float"); break; case DATADOUBLE: fprintf(fp,"double"); break; case DATASTRING: fprintf(fp,"char"); } fprintf(fp," %s",cdfsname[n]); if (sx->type==DATASTRING) { for (x=0;x<dnum;x++) { dx=dptr[x]; if (dx->flg !=0) continue; if (dx->num==n) break; } fprintf(fp,"(block,%s);\n",dx->name); } else fprintf(fp,"(block);\n"); } for (n=0;n<anum;n++) { fprintf(fp,"\t"); ax=aptr[n]; if (ax->dim==0) continue; switch(ax->type) { case DATACHAR: fprintf(fp,"char"); break; case DATASHORT: fprintf(fp,"short"); break; case DATAINT: fprintf(fp,"int"); break; case DATAFLOAT: fprintf(fp,"float"); break; case DATADOUBLE: fprintf(fp,"double"); break; case DATASTRING: fprintf(fp,"char"); } fprintf(fp," %s",cdfaname[n]); fprintf(fp,"(block"); for (x=0;x<dnum;x++) { dx=dptr[x]; if (dx->flg !=1) continue; if (dx->num!=n) continue; fprintf(fp,",%s",dx->name); } fprintf(fp,");\n"); } fprintf(fp,"}"); fclose(fp); fp=fopen(argv[3],"w"); for (n=0;n<snum;n++) { fprintf(fp,"\t"); sx=sptr[n]; switch(sx->type) { case DATACHAR: fprintf(fp,"char 0"); break; case DATASHORT: fprintf(fp,"short 0"); break; case DATAINT: fprintf(fp,"int 0"); break; case DATAFLOAT: fprintf(fp,"float 0"); break; case DATADOUBLE: fprintf(fp,"double 0"); break; case DATASTRING: fprintf(fp,"string 0"); } fprintf(fp," %c%s%c=%s;\n",'"',sx->name,'"',cdfsname[n]); } for (n=0;n<anum;n++) { fprintf(fp,"\t"); ax=aptr[n]; if (ax->dim==0) continue; switch(ax->type) { case DATACHAR: fprintf(fp,"char"); break; case DATASHORT: fprintf(fp,"short"); break; case DATAINT: fprintf(fp,"int"); break; case DATAFLOAT: fprintf(fp,"float"); break; case DATADOUBLE: fprintf(fp,"double"); break; case DATASTRING: fprintf(fp,"string"); } fprintf(fp," %d",ax->dim); fprintf(fp," %c%s%c=%s;\n",'"',ax->name,'"',cdfaname[n]); } fclose(fp); return 0; }
int main(int argc,char *argv[]) { int status=0; struct DataMap *ptr; struct DataMapScalar *sx=NULL,*sy=NULL; struct DataMapArray *ax=NULL,*ay=NULL; char buf[1024]; unsigned char vbflg=0; FILE *fp; int c,i; int x=0,n; int tab; char *cdfname=NULL; char *cdfdef={"dmapcdf"}; int block=0; int rnum=0,znum=0; int nelm=0; unsigned char help=0; unsigned char option=0; OptionAdd(&opt,"-help",'x',&help); OptionAdd(&opt,"-option",'x',&option); OptionAdd(&opt,"vb",'x',&vbflg); if (argc>1) { arg=OptionProcess(1,argc,argv,&opt,NULL); if (help==1) { OptionPrintInfo(stdout,hlpstr); exit(0); } if (option==1) { OptionDump(stdout,&opt); exit(0); } fp=fopen(argv[arg],"r"); if (fp==NULL) { fprintf(stderr,"File not found.\n"); exit(-1); } } else { OptionPrintInfo(stdout,errstr); exit(-1); } if (cdfname==NULL) cdfname=cdfdef; while ((ptr=DataMapFread(fp)) !=NULL) { for (c=0;c<ptr->snum;c++) { sx=ptr->scl[c]; for (n=0;n<snum;n++) { sy=sptr[n]; if (strcmp(sx->name,sy->name) !=0) continue; if (sx->type !=sy->type) continue; break; } if (n==snum) { /* copy the scalar */ if (sptr==NULL) sptr=malloc(sizeof(struct DataMapScalar *)); else { struct DataMapScalar **tmp; tmp=realloc(sptr,(snum+1)*sizeof(struct DataMapScalar *)); if (tmp==NULL) break; sptr=tmp; } sptr[snum]=DataMapMakeScalar(sx->name,sx->type,NULL); snum++; } } if (c !=ptr->snum) { status=-1; break; } for (c=0;c<ptr->anum;c++) { ax=ptr->arr[c]; for (n=0;n<anum;n++) { ay=aptr[n]; if (strcmp(ax->name,ay->name) !=0) continue; if (ax->type != ay->type) continue; if (ax->dim != ay->dim) continue; break; } if (n !=anum) { /* check the ranges */ for (i=0;i<ax->dim;i++) if (ax->rng[i]>rptr[roff[n]+i]) rptr[roff[n]+i]=ax->rng[i]; } if (n==anum) { /* copy the array */ if (roff==NULL) roff=malloc(sizeof(int32)); else { int32 *tmp; tmp=realloc(roff,(anum+1)*sizeof(int32)); if (tmp==NULL) break; roff=tmp; } roff[anum]=rnum; if (rptr==NULL) rptr=malloc(sizeof(int32)*ax->dim); else { int32 *tmp; tmp=realloc(rptr,(rnum+ax->dim)*sizeof(int32)); if (tmp==NULL) break; rptr=tmp; } for (i=0;i<ax->dim;i++) rptr[rnum+i]=ax->rng[i]; rnum+=ax->dim; if (aptr==NULL) aptr=malloc(sizeof(struct DataMapArray *)); else { struct DataMapArray **tmp; tmp=realloc(aptr,(anum+1)*sizeof(struct DataMapArray *)); if (tmp==NULL) break; aptr=tmp; } aptr[anum]=DataMapMakeArray(ax->name,ax->type,ax->dim,NULL, NULL); anum++; } } if (c !=ptr->anum) { status=-1; break; } DataMapFree(ptr); block++; } fclose(fp); if (status==-1) { fprintf(stderr,"Error processing file.\n"); exit(-1); } for (n=0;n<anum;n++) { ax=aptr[n]; ax->rng=rptr+roff[n]; for (c=0;c<ax->dim;c++) if (ax->rng[c]==0) break; /* bad data */ if (c !=ax->dim) ax->dim=0; } cdfsname=malloc(sizeof(char *)*snum); if (cdfsname==NULL) { fprintf(stderr,"Could not allocate scalar name table.\n"); exit(-1); } cdfaname=malloc(sizeof(char *)*anum); if (cdfaname==NULL) { fprintf(stderr,"Could not allocate array name table.\n"); exit(-1); } for (n=0;n<snum;n++) { sx=sptr[n]; cdfsname[n]=malloc(strlen(sx->name)+1); for (c=0;sx->name[c] !=0;c++) if (isalnum(sx->name[c])) cdfsname[n][c]=sx->name[c]; else cdfsname[n][c]='_'; cdfsname[n][c]=0; x=0; for (c=0;c<n;c++) if (strncmp(cdfsname[c],cdfsname[n], strlen(cdfsname[n]))==0) x++;; if (x !=0) { char *tmp; char txt[4]; x++; sprintf(txt,"%.3d",x); tmp=realloc(cdfsname[n],strlen(cdfsname[n])+4); if (tmp==NULL) break; cdfsname[n]=tmp; strcat(cdfsname[n],txt); } } if (n !=snum) { fprintf(stderr,"Error generating names.\n"); exit(-1); } for (n=0;n<anum;n++) { ax=aptr[n]; cdfaname[n]=NULL; if (ax->dim==0) continue; cdfaname[n]=malloc(strlen(ax->name)+1); for (c=0;ax->name[c] !=0;c++) if (isalnum(ax->name[c])) cdfaname[n][c]=ax->name[c]; else cdfaname[n][c]='_'; cdfaname[n][c]=0; for (c=0;c<n;c++) if (strncmp(cdfaname[c],cdfaname[n], strlen(cdfaname[n]))==0) x++; if (x !=0) { char *tmp; char txt[4]; x++; sprintf(txt,"%.3d",x); tmp=realloc(cdfaname[n],strlen(cdfaname[n])+4); if (tmp==NULL) break; cdfaname[n]=tmp; strcat(cdfaname[n],txt); } } if (n !=anum) { fprintf(stderr,"Error generating names.\n"); exit(-1); } rnum=snum; znum=anum; fp=fopen(argv[2],"w"); fprintf(fp,"#header\n"); fprintf(fp," CDF NAME: %s\n",cdfname); fprintf(fp," DATA ENCODING: NETWORK\n"); fprintf(fp," MAJORITY: ROW\n"); fprintf(fp," FORMAT: SINGLE\n\n"); fprintf(fp, "! Variables G.Attributes V.Attributes Records Dims Sizes\n"); fprintf(fp, "! --------- ------------ ------------ ------- ---- -----\n"); fprintf(fp, " %d/%d 0 0 %d/z 0\n", rnum,znum,block); fprintf(fp,"\n#GLOBALattributes\n"); fprintf(fp,"\n#VARIABLEattributes\n"); fprintf(fp,"\n#variables\n\n"); for (n=0;n<snum;n++) { sx=sptr[n]; fprintf(fp,"! Variable Data Number Record Dimension\n"); fprintf(fp,"! Name Type Elements Variance Variances\n"); fprintf(fp,"! -------- ---- -------- -------- ---------\n"); fprintf(fp,"\n"); sprintf(buf," %c%s%c",'"',cdfsname[n],'"'); fprintf(fp,buf); tab=18-strlen(buf); if (tab>0) for (c=0;c<tab;c++) fprintf(fp," "); else fprintf(fp," "); switch (sx->type) { case DATACHAR: fprintf(fp,"CDF_CHAR "); break; case DATASHORT: fprintf(fp,"CDF_INT2 "); break; case DATAINT: fprintf(fp,"CDF_INT4 "); break; case DATAFLOAT: fprintf(fp,"CDF_FLOAT "); break; case DATADOUBLE: fprintf(fp,"CDF_DOUBLE"); break; case DATASTRING: fprintf(fp,"CDF_CHAR "); break; } nelm=1; if (sx->type==DATASTRING) nelm=STRINGSIZE; fprintf(fp," %d T ",nelm); fprintf(fp,"\n\n"); fprintf(fp,"! Attribute Data Value\n"); fprintf(fp,"! Name Type\n"); fprintf(fp,"! -------- ---- --------\n"); fprintf(fp,"\n.\n\n"); } fprintf(fp,"\n#zVariables\n\n"); for (n=0;n<anum;n++) { ax=aptr[n]; fprintf(fp,"! Variable Data Number"); fprintf(fp," Record Dimension\n"); fprintf(fp,"! Name Type Elements Dims"); fprintf(fp," Sizes Variance Variances\n"); fprintf(fp, "! -------- ---- -------- ----"); fprintf(fp," ----- -------- ---------\n"); fprintf(fp,"\n"); sprintf(buf," %c%s%c",'"',cdfaname[n],'"'); fprintf(fp,buf); tab=18-strlen(buf); if (tab>0) for (c=0;c<tab;c++) fprintf(fp," "); else fprintf(fp," "); switch (ax->type) { case DATACHAR: fprintf(fp,"CDF_CHAR "); break; case DATASHORT: fprintf(fp,"CDF_INT2 "); break; case DATAINT: fprintf(fp,"CDF_INT4 "); break; case DATAFLOAT: fprintf(fp,"CDF_FLOAT "); break; case DATADOUBLE: fprintf(fp,"CDF_DOUBLE"); break; case DATASTRING: fprintf(fp,"CDF_CHAR "); break; } nelm=1; if (ax->type==DATASTRING) nelm=STRINGSIZE; fprintf(fp," %d %d ",nelm,ax->dim); for (c=0;c<ax->dim;c++) fprintf(fp,"%d ",ax->rng[c]); fprintf(fp," T "); for (c=0;c<ax->dim;c++) fprintf(fp,"T "); fprintf(fp,"\n\n"); fprintf(fp,"! Attribute Data Value\n"); fprintf(fp,"! Name Type\n"); fprintf(fp,"! -------- ---- --------\n"); fprintf(fp,"\n.\n\n"); } fprintf(fp,"#end\n\n"); fp=fopen(argv[3],"w"); for (n=0;n<snum;n++) { fprintf(fp,"\t"); sx=sptr[n]; switch(sx->type) { case DATACHAR: fprintf(fp,"char 0"); break; case DATASHORT: fprintf(fp,"short 0"); break; case DATAINT: fprintf(fp,"int 0"); break; case DATAFLOAT: fprintf(fp,"float 0"); break; case DATADOUBLE: fprintf(fp,"double 0"); break; case DATASTRING: fprintf(fp,"string 0"); } fprintf(fp," %c%s%c=%s;\n",'"',sx->name,'"',cdfsname[n]); } for (n=0;n<anum;n++) { fprintf(fp,"\t"); ax=aptr[n]; if (ax->dim==0) continue; switch(ax->type) { case DATACHAR: fprintf(fp,"char"); break; case DATASHORT: fprintf(fp,"short"); break; case DATAINT: fprintf(fp,"int"); break; case DATAFLOAT: fprintf(fp,"float"); break; case DATADOUBLE: fprintf(fp,"double"); break; case DATASTRING: fprintf(fp,"string"); } fprintf(fp," %d",ax->dim); fprintf(fp," %c%s%c=%s;\n",'"',ax->name,'"',cdfaname[n]); } fclose(fp); return 0; }
struct DataMap *DataMapDecodeBuffer(unsigned char *buf,int size) { int c,x,n,i; int32 sn,an; int32 code,sze; char *name; unsigned char *tmp; char type; unsigned int off=0; struct DataMap *ptr; struct DataMapScalar *s; struct DataMapArray *a; ptr=DataMapMake(); if (ptr==NULL) return NULL; ConvertToInt(buf+off,&code); off+=sizeof(int32); ConvertToInt(buf+off,&sze); off+=sizeof(int32); ConvertToInt(buf+off,&sn); off+=sizeof(int32); ConvertToInt(buf+off,&an); off+=sizeof(int32); if (sn>0) { ptr->snum=sn; ptr->scl=malloc(sizeof(struct DataMapScalar *)*sn); if (ptr->scl==NULL) { DataMapFree(ptr); return NULL; } for (c=0;c<sn;c++) ptr->scl[c]=NULL; } if (an>0) { ptr->anum=an; ptr->arr=malloc(sizeof(struct DataMapArray *)*an); if (ptr->arr==NULL) { DataMapFree(ptr); return NULL; } for (c=0;c<an;c++) ptr->arr[c]=NULL; } for (c=0;c<sn;c++) { n=0; while ((buf[off+n] !=0) && (off+n<size)) n++; if (off+n>=size) break; name=malloc(n+1); if (name==NULL) break; memcpy(name,buf+off,n+1); off+=n+1; type=buf[off]; off++; s=malloc(sizeof(struct DataMapScalar)); if (s==NULL) { free(name); break; } s->name=name; s->mode=1; s->type=type; ptr->scl[c]=s; switch (s->type) { case DATACHAR: s->data.vptr=malloc(sizeof(char)); if (s->data.vptr==NULL) break; s->data.cptr[0]=buf[off]; off++; break; case DATASHORT: s->data.vptr=malloc(sizeof(int16)); if (s->data.vptr==NULL) break; ConvertToShort(buf+off,s->data.sptr); off+=sizeof(int16); break; case DATAINT: s->data.vptr=malloc(sizeof(int32)); if (s->data.vptr==NULL) break; ConvertToInt(buf+off,s->data.iptr); off+=sizeof(int32); break; case DATAFLOAT: s->data.vptr=malloc(sizeof(float)); if (s->data.vptr==NULL) break; ConvertToFloat(buf+off,s->data.fptr); off+=sizeof(float); break; case DATADOUBLE: s->data.vptr=malloc(sizeof(double)); if (s->data.vptr==NULL) break; ConvertToDouble(buf+off,s->data.dptr); off+=sizeof(double); break; default: n=0; while ((buf[off+n] !=0) && (off+n<size)) n++; if (off+n>=size) break; s->data.vptr=malloc(sizeof(char *)); if (s->data.vptr==NULL) break; tmp=realloc(ptr->buf,ptr->sze+n+1); if (tmp==NULL) break; ptr->buf=tmp; memcpy(ptr->buf+ptr->sze,buf+off,n+1); off+=n+1; *(s->data.optr)=ptr->sze; ptr->sze+=n+1; break; } } if (c !=sn) { DataMapFree(ptr); return NULL; } for (c=0;c<an;c++) { n=0; while ((buf[off+n] !=0) && (off+n<size)) n++; if (off+n>=size) break; name=malloc(n+1); if (name==NULL) break; memcpy(name,buf+off,n+1); off+=n+1; type=buf[off]; off++; a=malloc(sizeof(struct DataMapArray)); if (a==NULL) { free(name); break; } a->name=name; a->mode=3; a->type=type; ptr->arr[c]=a; ConvertToInt(buf+off,(int32 *) &(a->dim)); off+=sizeof(int32); a->rng=malloc(a->dim*sizeof(int32)); if (a->rng==NULL) break; for (x=0;x<a->dim;x++) { ConvertToInt(buf+off,&a->rng[x]); off+=sizeof(int32); } if (x!=a->dim) break; n=1; for (x=0;x<a->dim;x++) n=a->rng[x]*n; switch (a->type) { case DATACHAR: a->data.vptr=malloc(sizeof(char)*n); if (a->data.vptr==NULL) break; memcpy(a->data.cptr,buf+off,sizeof(char)*n); off+=sizeof(char)*n; break; case DATASHORT: a->data.vptr=malloc(sizeof(int16)*n); if (a->data.vptr==NULL) break; for (x=0;x<n;x++) { ConvertToShort(buf+off,&a->data.sptr[x]); off+=sizeof(int16); } break; case DATAINT: a->data.vptr=malloc(sizeof(int32)*n); if (a->data.vptr==NULL) break; for (x=0;x<n;x++) { ConvertToInt(buf+off,&a->data.iptr[x]); off+=sizeof(int32); } break; case DATAFLOAT: a->data.vptr=malloc(sizeof(float)*n); if (a->data.vptr==NULL) break; for (x=0;x<n;x++) { ConvertToFloat(buf+off,&a->data.fptr[x]); off+=sizeof(float); } break; case DATADOUBLE: a->data.vptr=malloc(sizeof(double)*n); if (a->data.vptr==NULL) break; for (x=0;x<n;x++) { ConvertToDouble(buf+off,&a->data.dptr[x]); off+=sizeof(double); } break; default: a->data.vptr=malloc(sizeof(char *)*n); if (a->data.vptr==NULL) break; for (x=0;x<n;x++) { i=0; while ((buf[off+i] !=0) && (off+i<size)) i++; if (off+i>=size) break; tmp=realloc(ptr->buf,ptr->sze+i+1); if (tmp==NULL) break; ptr->buf=tmp; memcpy(ptr->buf+ptr->sze,buf+off,i+1); a->data.optr[x]=ptr->sze; ptr->sze+=i+1; off+=i+1; } if (x !=n) break; } } if (c !=an) { DataMapFree(ptr); return NULL; } for (c=0;c<ptr->snum;c++) { if (ptr->scl[c]==NULL) continue; s=ptr->scl[c]; if (s->type==DATASTRING) *((char **) s->data.vptr)=(char *) (ptr->buf+*(s->data.optr)); } for (c=0;c<ptr->anum;c++) { if (ptr->arr[c]==NULL) continue; a=ptr->arr[c]; if (a->type==DATASTRING) { n=1; for (x=0;x<a->dim;x++) n=a->rng[x]*n; for (x=0;x<n;x++) ( (char **) a->data.vptr)[x]=(char *) (ptr->buf+a->data.optr[x]); } } return ptr; }
int GridWrite(int fid,struct GridData *ptr) { struct DataMap *data; int s; int32 stnum=0; int32 npnt=0; int16 syr,smo,sdy,shr,smt; double ssc; int16 eyr,emo,edy,ehr,emt; double esc; int yr,mo,dy,hr,mt; double sc; int16 *stid=NULL; int16 *chn=NULL; int16 *nvec=NULL; float *freq=NULL; int16 *major_rev=NULL; int16 *minor_rev=NULL; int16 *progid=NULL; float *noise_mean=NULL; float *noise_sd=NULL; int16 *gsct=NULL; float *v_min=NULL; float *v_max=NULL; float *p_min=NULL; float *p_max=NULL; float *w_min=NULL; float *w_max=NULL; float *ve_min=NULL; float *ve_max=NULL; float *gmlon=NULL; float *gmlat=NULL; float *kvect=NULL; int16 *vstid=NULL; int16 *vchn=NULL; int32 *index=NULL; float *vlos=NULL; float *vlos_sd=NULL; float *pwr=NULL; float *pwr_sd=NULL; float *wdt=NULL; float *wdt_sd=NULL; int size=0; unsigned char *buf=NULL; unsigned char *bptr=NULL; int xtd=0; int n,p; for (n=0;n<ptr->stnum;n++) if (ptr->sdata[n].st_id !=-1) stnum++; if (stnum==0) return 0; size=stnum*(11*sizeof(float)+7*sizeof(int16)); xtd=ptr->xtd; for (n=0;n<ptr->vcnum;n++) if (ptr->data[n].st_id !=-1) npnt++; size+=npnt*(3*sizeof(float)+sizeof(int32)+ 2*sizeof(int16)+(2+4*xtd)*sizeof(float)); if (size==0) return 0; buf=malloc(size); if (buf==NULL) return -1; bptr=buf; stid=(int16 *) bptr; bptr+=stnum*sizeof(int16); chn=(int16 *) bptr; bptr+=stnum*sizeof(int16); nvec=(int16 *) bptr; bptr+=stnum*sizeof(int16); freq=(float *) bptr; bptr+=stnum*sizeof(float); major_rev=(int16 *) bptr; bptr+=stnum*sizeof(int16); minor_rev=(int16 *) bptr; bptr+=stnum*sizeof(int16); progid=(int16 *) bptr; bptr+=stnum*sizeof(int16); noise_mean=(float *) bptr; bptr+=stnum*sizeof(float); noise_sd=(float *) bptr; bptr+=stnum*sizeof(float); gsct=(int16 *) bptr; bptr+=stnum*sizeof(int16); v_min=(float *) bptr; bptr+=stnum*sizeof(float); v_max=(float *) bptr; bptr+=stnum*sizeof(float); p_min=(float *) bptr; bptr+=stnum*sizeof(float); p_max=(float *) bptr; bptr+=stnum*sizeof(float); w_min=(float *) bptr; bptr+=stnum*sizeof(float); w_max=(float *) bptr; bptr+=stnum*sizeof(float); ve_min=(float *) bptr; bptr+=stnum*sizeof(float); ve_max=(float *) bptr; bptr+=stnum*sizeof(float); n=0; for (p=0;p<ptr->stnum;p++) if (ptr->sdata[p].st_id !=-1) { stid[n]=ptr->sdata[p].st_id; chn[n]=ptr->sdata[p].chn; nvec[n]=ptr->sdata[p].npnt; freq[n]=ptr->sdata[p].freq0; major_rev[n]=ptr->sdata[p].major_revision; minor_rev[n]=ptr->sdata[p].minor_revision; progid[n]=ptr->sdata[p].prog_id; noise_mean[n]=ptr->sdata[p].noise.mean; noise_sd[n]=ptr->sdata[p].noise.sd; gsct[n]=ptr->sdata[p].gsct; v_min[n]=ptr->sdata[p].vel.min; v_max[n]=ptr->sdata[p].vel.max; p_min[n]=ptr->sdata[p].pwr.min; p_max[n]=ptr->sdata[p].pwr.max; w_min[n]=ptr->sdata[p].wdt.min; w_max[n]=ptr->sdata[p].wdt.max; ve_min[n]=ptr->sdata[p].verr.min; ve_max[n]=ptr->sdata[p].verr.max; n++; } if (npnt !=0) { gmlon=(float *) bptr; bptr+=npnt*sizeof(float); gmlat=(float *) bptr; bptr+=npnt*sizeof(float); kvect=(float *) bptr; bptr+=npnt*sizeof(float); vstid=(int16 *) bptr; bptr+=npnt*sizeof(int16); vchn=(int16 *) bptr; bptr+=npnt*sizeof(int16); index=(int32 *) bptr; bptr+=npnt*sizeof(int32); vlos=(float *) bptr; bptr+=npnt*sizeof(float); vlos_sd=(float *) bptr; bptr+=npnt*sizeof(float); if (xtd) { pwr=(float *) bptr; bptr+=npnt*sizeof(float); pwr_sd=(float *) bptr; bptr+=npnt*sizeof(float); wdt=(float *) bptr; bptr+=npnt*sizeof(float); wdt_sd=(float *) bptr; bptr+=npnt*sizeof(float); } n=0; for (p=0;p<ptr->vcnum;p++) if (ptr->data[p].st_id !=-1) { gmlat[n]=ptr->data[p].mlat; gmlon[n]=ptr->data[p].mlon; kvect[n]=ptr->data[p].azm; vstid[n]=ptr->data[p].st_id; vchn[n]=ptr->data[p].chn; index[n]=ptr->data[p].index; vlos[n]=ptr->data[p].vel.median; vlos_sd[n]=ptr->data[p].vel.sd; if (xtd) { pwr[n]=ptr->data[p].pwr.median; pwr_sd[n]=ptr->data[p].pwr.sd; wdt[n]=ptr->data[p].wdt.median; wdt_sd[n]=ptr->data[p].wdt.sd; } n++; } } TimeEpochToYMDHMS(ptr->ed_time,&yr,&mo,&dy,&hr,&mt,&sc); eyr=yr; emo=mo; edy=dy; ehr=hr; emt=mt; esc=sc; TimeEpochToYMDHMS(ptr->st_time,&yr,&mo,&dy,&hr,&mt,&sc); syr=yr; smo=mo; sdy=dy; shr=hr; smt=mt; ssc=sc; data=DataMapMake(); DataMapAddScalar(data,"start.year",DATASHORT,&syr); DataMapAddScalar(data,"start.month",DATASHORT,&smo); DataMapAddScalar(data,"start.day",DATASHORT,&sdy); DataMapAddScalar(data,"start.hour",DATASHORT,&shr); DataMapAddScalar(data,"start.minute",DATASHORT,&smt); DataMapAddScalar(data,"start.second",DATADOUBLE,&ssc); DataMapAddScalar(data,"end.year",DATASHORT,&eyr); DataMapAddScalar(data,"end.month",DATASHORT,&emo); DataMapAddScalar(data,"end.day",DATASHORT,&edy); DataMapAddScalar(data,"end.hour",DATASHORT,&ehr); DataMapAddScalar(data,"end.minute",DATASHORT,&emt); DataMapAddScalar(data,"end.second",DATADOUBLE,&esc); DataMapAddArray(data,"stid",DATASHORT,1,&stnum,stid); DataMapAddArray(data,"channel",DATASHORT,1,&stnum,chn); DataMapAddArray(data,"nvec",DATASHORT,1,&stnum,nvec); DataMapAddArray(data,"freq",DATAFLOAT,1,&stnum,freq); DataMapAddArray(data,"major.revision",DATASHORT,1,&stnum,major_rev); DataMapAddArray(data,"minor.revision",DATASHORT,1,&stnum,minor_rev); DataMapAddArray(data,"program.id",DATASHORT,1,&stnum,progid ); DataMapAddArray(data,"noise.mean",DATAFLOAT,1,&stnum,noise_mean); DataMapAddArray(data,"noise.sd",DATAFLOAT,1,&stnum,noise_sd); DataMapAddArray(data,"gsct",DATASHORT,1,&stnum ,gsct); DataMapAddArray(data,"v.min",DATAFLOAT,1,&stnum,v_min); DataMapAddArray(data,"v.max",DATAFLOAT,1,&stnum,v_max); DataMapAddArray(data,"p.min",DATAFLOAT,1,&stnum,p_min); DataMapAddArray(data,"p.max",DATAFLOAT,1,&stnum,p_max); DataMapAddArray(data,"w.min",DATAFLOAT,1,&stnum,w_min); DataMapAddArray(data,"w.max",DATAFLOAT,1,&stnum,w_max); DataMapAddArray(data,"ve.min",DATAFLOAT,1,&stnum,ve_min); DataMapAddArray(data,"ve.max",DATAFLOAT,1,&stnum,ve_max); if (npnt !=0) { DataMapAddArray(data,"vector.mlat",DATAFLOAT,1,&npnt,gmlat); DataMapAddArray(data,"vector.mlon",DATAFLOAT,1,&npnt,gmlon); DataMapAddArray(data,"vector.kvect",DATAFLOAT,1,&npnt,kvect); DataMapAddArray(data,"vector.stid",DATASHORT,1,&npnt,vstid); DataMapAddArray(data,"vector.channel",DATASHORT,1,&npnt,vchn); DataMapAddArray(data,"vector.index",DATAINT,1,&npnt,index); DataMapAddArray(data,"vector.vel.median",DATAFLOAT,1,&npnt,vlos); DataMapAddArray(data,"vector.vel.sd",DATAFLOAT,1,&npnt,vlos_sd); if (xtd) { DataMapAddArray(data,"vector.pwr.median",DATAFLOAT,1,&npnt,pwr); DataMapAddArray(data,"vector.pwr.sd",DATAFLOAT,1,&npnt,pwr_sd); DataMapAddArray(data,"vector.wdt.median",DATAFLOAT,1,&npnt,wdt); DataMapAddArray(data,"vector.wdt.sd",DATAFLOAT,1,&npnt,wdt_sd); } } if (fid !=-1) s=DataMapWrite(fid,data); else s=DataMapSize(data); DataMapFree(data); free(buf); return s; }
struct DataMap *DataMapDecodeBuffer(char *buf,int size) { int c,x,n,i,e; int32 sn,an; int32 code,sze; char *name; char *tmp; char type; unsigned int off=0; int32 tsze; struct DataMap *ptr; struct DataMapScalar *s; struct DataMapArray *a; ptr=DataMapMake(); if (ptr==NULL) return NULL; ConvertToInt(buf+off,&code); off+=sizeof(int32); ConvertToInt(buf+off,&sze); off+=sizeof(int32); ConvertToInt(buf+off,&sn); off+=sizeof(int32); ConvertToInt(buf+off,&an); off+=sizeof(int32); if (sn>0) { ptr->snum=sn; ptr->scl=malloc(sizeof(struct DataMapScalar *)*sn); if (ptr->scl==NULL) { DataMapFree(ptr); return NULL; } for (c=0;c<sn;c++) ptr->scl[c]=NULL; } if (an>0) { ptr->anum=an; ptr->arr=malloc(sizeof(struct DataMapArray *)*an); if (ptr->arr==NULL) { DataMapFree(ptr); return NULL; } for (c=0;c<an;c++) ptr->arr[c]=NULL; } for (c=0;c<sn;c++) { e=0; n=0; while ((buf[off+n] !=0) && (off+n<size)) n++; if (off+n>=size) break; name=malloc(n+1); if (name==NULL) break; memcpy(name,buf+off,n+1); off+=n+1; type=buf[off]; off++; s=malloc(sizeof(struct DataMapScalar)); if (s==NULL) { free(name); break; } s->name=name; s->mode=6; s->type=type; ptr->scl[c]=s; switch (s->type) { case DATACHAR: s->data.vptr=malloc(sizeof(char)); if (s->data.vptr==NULL) { e=1; break; } s->data.cptr[0]=buf[off]; off++; break; case DATASHORT: s->data.vptr=malloc(sizeof(int16)); if (s->data.vptr==NULL) { e=1; break; } ConvertToShort(buf+off,s->data.sptr); off+=sizeof(int16); break; case DATAINT: s->data.vptr=malloc(sizeof(int32)); if (s->data.vptr==NULL) { e=1; break; } ConvertToInt(buf+off,s->data.iptr); off+=sizeof(int32); break; case DATALONG: s->data.vptr=malloc(sizeof(int64)); if (s->data.vptr==NULL) { e=1; break; } ConvertToLong(buf+off,s->data.lptr); off+=sizeof(int64); break; case DATAUCHAR: s->data.vptr=malloc(sizeof(unsigned char)); if (s->data.vptr==NULL) { e=1; break; } s->data.ucptr[0]=buf[off]; off++; break; case DATAUSHORT: s->data.vptr=malloc(sizeof(uint16)); if (s->data.vptr==NULL) { e=1; break; } ConvertToUShort(buf+off,s->data.usptr); off+=sizeof(uint16); break; case DATAUINT: s->data.vptr=malloc(sizeof(uint32)); if (s->data.vptr==NULL) { e=1; break; } ConvertToUInt(buf+off,s->data.uiptr); off+=sizeof(uint32); break; case DATAULONG: s->data.vptr=malloc(sizeof(uint64)); if (s->data.vptr==NULL) { e=1; break; } ConvertToULong(buf+off,s->data.ulptr); off+=sizeof(uint64); break; case DATAFLOAT: s->data.vptr=malloc(sizeof(float)); if (s->data.vptr==NULL) { e=1; break; } ConvertToFloat(buf+off,s->data.fptr); off+=sizeof(float); break; case DATADOUBLE: s->data.vptr=malloc(sizeof(double)); if (s->data.vptr==NULL) { e=1; break; } ConvertToDouble(buf+off,s->data.dptr); off+=sizeof(double); break; case DATASTRING: n=0; while ((buf[off+n] !=0) && (off+n<size)) n++; if (off+n>=size) { e=1; break; } s->data.vptr=malloc(sizeof(char *)); if (s->data.vptr==NULL) { e=1; break; } if (n !=0) { tmp=malloc(n+1); if (tmp==NULL) { e=1; break; } memcpy(tmp,buf+off,n+1); off+=n+1; *( (char **) s->data.vptr)=tmp; } else { *( (char **) s->data.vptr)=NULL; off++; } break; default: s->data.vptr=malloc(sizeof(struct DataMap *)); if (s->data.vptr==NULL) { e=1; break; } ConvertToInt(buf+off,&tsze); off+=sizeof(int32); if (tsze !=0) { *s->data.mptr=DataMapDecodeBuffer(buf+off,tsze); off+=tsze; } else *s->data.mptr=NULL; } if (e==1) break; } if (c !=sn) { DataMapFree(ptr); return NULL; } for (c=0;c<an;c++) { e=0; n=0; while ((buf[off+n] !=0) && (off+n<size)) n++; if (off+n>=size) break; name=malloc(n+1); if (name==NULL) break; memcpy(name,buf+off,n+1); off+=n+1; type=buf[off]; off++; a=malloc(sizeof(struct DataMapArray)); if (a==NULL) { free(name); break; } a->name=name; a->mode=7; a->type=type; ptr->arr[c]=a; ConvertToInt(buf+off,(int32 *) &(a->dim)); off+=sizeof(int32); a->rng=malloc(a->dim*sizeof(int32)); if (a->rng==NULL) break; for (x=0;x<a->dim;x++) { ConvertToInt(buf+off,&a->rng[x]); off+=sizeof(int32); } if (x!=a->dim) break; n=1; for (x=0;x<a->dim;x++) n=a->rng[x]*n; switch (a->type) { case DATACHAR: a->data.vptr=malloc(sizeof(char)*n); if (a->data.vptr==NULL) { e=1; break; } memcpy(a->data.cptr,buf+off,sizeof(char)*n); off+=sizeof(char)*n; break; case DATASHORT: a->data.vptr=malloc(sizeof(int16)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { ConvertToShort(buf+off,&a->data.sptr[x]); off+=sizeof(int16); } break; case DATAINT: a->data.vptr=malloc(sizeof(int32)*n); if (a->data.vptr==NULL) { break; e=1; } for (x=0;x<n;x++) { ConvertToInt(buf+off,&a->data.iptr[x]); off+=sizeof(int32); } break; case DATALONG: a->data.vptr=malloc(sizeof(int64)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { ConvertToLong(buf+off,&a->data.lptr[x]); off+=sizeof(int64); } break; case DATAUCHAR: a->data.vptr=malloc(sizeof(unsigned char)*n); if (a->data.vptr==NULL) { e=1; break; } memcpy(a->data.cptr,buf+off,sizeof(unsigned char)*n); off+=sizeof(unsigned char)*n; break; case DATAUSHORT: a->data.vptr=malloc(sizeof(uint16)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { ConvertToUShort(buf+off,&a->data.usptr[x]); off+=sizeof(uint16); } break; case DATAUINT: a->data.vptr=malloc(sizeof(uint32)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { ConvertToUInt(buf+off,&a->data.uiptr[x]); off+=sizeof(uint32); } break; case DATAULONG: a->data.vptr=malloc(sizeof(uint64)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { ConvertToULong(buf+off,&a->data.ulptr[x]); off+=sizeof(uint64); } break; case DATAFLOAT: a->data.vptr=malloc(sizeof(float)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { ConvertToFloat(buf+off,&a->data.fptr[x]); off+=sizeof(float); } break; case DATADOUBLE: a->data.vptr=malloc(sizeof(double)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { ConvertToDouble(buf+off,&a->data.dptr[x]); off+=sizeof(double); } break; case DATASTRING: a->data.vptr=malloc(sizeof(char *)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { i=0; while ((buf[off+i] !=0) && (off+i<size)) i++; if (off+i>=size) break; if (i !=0) { tmp=malloc(i+1); if (tmp==NULL) break; memcpy(tmp,buf+off,i+1); ((char **) a->data.vptr)[x]=tmp; } else ((char **) a->data.vptr)[x]=NULL; off+=i+1; } if (x !=n) e=1; break; default: a->data.mptr=malloc(sizeof(struct DataMap *)*n); if (a->data.vptr==NULL) { e=1; break; } for (x=0;x<n;x++) { ConvertToInt(buf+off,&tsze); off+=sizeof(int32); if (tsze !=0) { a->data.mptr[x]=DataMapDecodeBuffer(buf+off,tsze); off+=tsze; } else a->data.mptr[x]=0; } } if (e==1) break; } if (c !=an) { DataMapFree(ptr); return NULL; } return ptr; }
int main(int argc,char *argv[]) { struct DataMap *ptr; struct DataMapScalar *sx,*sy; struct DataMapArray *ax,*ay; size_t index[256]; size_t start[256]; size_t count[256]; int s; unsigned char vbflg=0; unsigned char help=0; unsigned char option=0; unsigned char zflg=0; FILE *fp=NULL; gzFile zfp=0; FILE *mapfp; int n,c,x; int ncid; int block=0; int varid; int strsze; char **strptr; char *tmpbuf=NULL; OptionAdd(&opt,"-help",'x',&help); OptionAdd(&opt,"-option",'x',&option); OptionAdd(&opt,"vb",'x',&vbflg); OptionAdd(&opt,"z",'x',&zflg); if (argc>1) { arg=OptionProcess(1,argc,argv,&opt,NULL); if (help==1) { OptionPrintInfo(stdout,hlpstr); exit(0); } if (option==1) { OptionDump(stdout,&opt); exit(0); } if (zflg) { zfp=gzopen(argv[arg],"r"); if (zfp==0) { fprintf(stderr,"File not found.\n"); exit(-1); } } else { fp=fopen(argv[arg],"r"); if (fp==NULL) { fprintf(stderr,"File not found.\n"); exit(-1); } } } else { OptionPrintInfo(stdout,errstr); exit(-1); } /* load the map */ mapfp=fopen(argv[arg+1],"r"); loadmap(mapfp); fclose(mapfp); s=nc_open(argv[arg+2],NC_WRITE,&ncid); if (s !=NC_NOERR) { fprintf(stderr,"Error opening CDF file.\n"); exit(-1); } block=0; while (1) { if (zflg) ptr=DataMapReadZ(zfp); else ptr=DataMapFread(fp); if (ptr==NULL) break; for (c=0;c<ptr->snum;c++) { sx=ptr->scl[c]; for (n=0;n<snum;n++) { sy=sptr[n]; if (strcmp(sx->name,sy->name) !=0) continue; if (sx->type !=sy->type) continue; break; } if (n !=snum) { /* mapped variable */ s=nc_inq_varid(ncid,cdfsname[n],&varid); if (s !=NC_NOERR) { fprintf(stderr,"Error accessing CDF file.\n"); exit(-1); } index[0]=block; switch (sx->type) { case DATACHAR: s=nc_put_var1_text(ncid,varid,index,sx->data.cptr); break; case DATASHORT: s=nc_put_var1_short(ncid,varid,index,sx->data.sptr); break; case DATAINT: s=nc_put_var1_int(ncid,varid,index,sx->data.iptr); break; case DATAFLOAT: s=nc_put_var1_float(ncid,varid,index,sx->data.fptr); break; case DATADOUBLE: s=nc_put_var1_double(ncid,varid,index,sx->data.dptr); break; case DATASTRING: start[0]=block; start[1]=0; count[0]=1; count[1]=strlen(*((char **) sx->data.vptr))+1; s=nc_put_vara_text(ncid,varid,start,count, *((char **) sx->data.vptr)); break; } if (s !=NC_NOERR) { fprintf(stderr,"Error writing CDF file (%d).\n",s); exit(-1); } } } for (c=0;c<ptr->anum;c++) { ax=ptr->arr[c]; for (n=0;n<anum;n++) { ay=aptr[n]; if (strcmp(ax->name,ay->name) !=0) continue; if (ax->type !=ay->type) continue; if (ax->dim !=ay->dim) continue; break; } if (n !=anum) { /* mapped variable */ s=nc_inq_varid(ncid,cdfaname[n],&varid); if (s !=NC_NOERR) { fprintf(stderr,"Error accessing CDF file.\n"); exit(-1); } start[0]=block; count[0]=1; n=1; for (x=0;x<ax->dim;x++) { start[1+x]=0; count[1+x]=ax->rng[x]; n=n*ax->rng[x]; } if (ax->type==DATASTRING) { int ndims; int dimids[NC_MAX_VAR_DIMS]; size_t dimlen; s=nc_inq_varndims(ncid,varid,&ndims); if (s !=NC_NOERR) { fprintf(stderr,"Error accessing CDF file.\n"); exit(-1); } s=nc_inq_vardimid(ncid,varid,dimids); if (s !=NC_NOERR) { fprintf(stderr,"Error accessing CDF file.\n"); exit(-1); } if (ndims-2!=ax->dim) { fprintf(stderr,"Error matching dimensions.\n"); exit(-1); } s=nc_inq_dimlen(ncid,dimids[ndims-1],&dimlen); if (s !=NC_NOERR) { fprintf(stderr,"Error accessing CDF file.\n"); exit(-1); } strsze=dimlen; tmpbuf=malloc(n*strsze); if (tmpbuf==NULL) { fprintf(stderr,"Failed to allocate buffer.\n"); exit(-1); } memset(tmpbuf,0,n*strsze); start[1+ax->dim]=0; count[1+ax->dim]=strsze; strptr=(char **) ax->data.vptr; for (x=0;x<n;x++) strncpy(tmpbuf+x*strsze,strptr[x],strsze); } switch (ax->type) { case DATACHAR: s=nc_put_vara_text(ncid,varid,start,count,ax->data.cptr); break; case DATASHORT: s=nc_put_vara_short(ncid,varid,start,count,ax->data.sptr); break; case DATAINT: s=nc_put_vara_int(ncid,varid,start,count,ax->data.iptr); break; case DATAFLOAT: s=nc_put_vara_float(ncid,varid,start,count,ax->data.fptr); break; case DATADOUBLE: s=nc_put_vara_double(ncid,varid,start,count,ax->data.dptr); break; case DATASTRING: s=nc_put_vara_text(ncid,varid,start,count,tmpbuf); break; } if (tmpbuf !=NULL) { free(tmpbuf); tmpbuf=NULL; } if (s !=NC_NOERR) { fprintf(stderr,"Error writing CDF file (%d).\n",s); exit(-1); } } } DataMapFree(ptr); block++; } nc_close(ncid); if (zflg) gzclose(zfp); else fclose(fp); return 0; }
int GridTableWrite(int fid,struct GridTable *ptr,char *logbuf,int xtd) { struct DataMap *data; int s; int32 stnum=1; int32 npnt=0; int16 syr,smo,sdy,shr,smt; double ssc; int16 eyr,emo,edy,ehr,emt; double esc; int yr,mo,dy,hr,mt; double sc; int16 stid[1]; int16 chn[1]; int16 nvec[1]; float freq[1]; int16 major_rev[1]; int16 minor_rev[1]; int16 progid[1]; float noise_mean[1]; float noise_sd[1]; int16 gsct[1]; float v_min[1]; float v_max[1]; float p_min[1]; float p_max[1]; float w_min[1]; float w_max[1]; float ve_min[1]; float ve_max[1]; int n,p; int size=0; unsigned char *buf=NULL; float *gmlon=NULL; float *gmlat=NULL; float *kvect=NULL; int16 *vstid=NULL; int16 *vchn=NULL; int32 *index=NULL; float *vlos=NULL; float *vlos_sd=NULL; float *pwr=NULL; float *pwr_sd=NULL; float *wdt=NULL; float *wdt_sd=NULL; npnt=0; for (p=0;p<ptr->pnum;p++) if (ptr->pnt[p].cnt!=0) npnt++; stid[0]=ptr->st_id; chn[0]=ptr->chn; nvec[0]=npnt; freq[0]=ptr->freq; major_rev[0]=MAJOR_REVISION; minor_rev[0]=MINOR_REVISION; progid[0]=ptr->prog_id; noise_mean[0]=ptr->noise.mean; noise_sd[0]=ptr->noise.sd; gsct[0]=ptr->gsct; v_min[0]=ptr->min[0]; v_max[0]=ptr->max[0]; p_min[0]=ptr->min[1]; p_max[0]=ptr->max[1]; w_min[0]=ptr->min[2]; w_max[0]=ptr->max[2]; ve_min[0]=ptr->min[3]; ve_max[0]=ptr->max[3]; if (npnt !=0) { size=npnt*(3*sizeof(float)+sizeof(int32)+2*sizeof(int16)+ (2+4*xtd)*sizeof(float)); buf=malloc(size); if (buf==NULL) return -1; gmlon=(float *) (buf); gmlat=(float *) (buf+sizeof(float)*npnt); kvect=(float *) (buf+2*sizeof(float)*npnt); vstid=(int16 *) (buf+3*sizeof(float)*npnt); vchn=(int16 *) (buf+3*sizeof(float)*npnt+sizeof(int16)*npnt); index=(int32 *) (buf+3*sizeof(float)*npnt+2*sizeof(int16)*npnt); vlos=(float *) (buf+3*sizeof(float)*npnt+ sizeof(32)*npnt+ 2*sizeof(int16)*npnt); vlos_sd=(float *) (buf+3*sizeof(float)*npnt+ sizeof(32)*npnt+ 2*sizeof(int16)*npnt+ sizeof(float)*npnt); if (xtd) { pwr=(float *) (buf+3*sizeof(float)*npnt+ sizeof(int32)*npnt+ 2*sizeof(int16)*npnt+ 2*sizeof(float)*npnt); pwr_sd=(float *) (buf+3*sizeof(float)*npnt+ sizeof(int32)*npnt+ 2*sizeof(int16)*npnt+ 3*sizeof(float)*npnt); wdt=(float *) (buf+3*sizeof(float)*npnt+ sizeof(int32)*npnt+ 2*sizeof(int16)*npnt+ 4*sizeof(float)*npnt); wdt_sd=(float *) (buf+3*sizeof(float)*npnt+ sizeof(int32)*npnt+ 2*sizeof(int16)*npnt+ 5*sizeof(float)*npnt); } n=0; for (p=0;p<ptr->pnum;p++) { if (ptr->pnt[p].cnt==0) continue; gmlat[n]=ptr->pnt[p].mlat; gmlon[n]=ptr->pnt[p].mlon; kvect[n]=ptr->pnt[p].azm; vstid[n]=ptr->st_id; vchn[n]=ptr->chn; index[n]=ptr->pnt[p].ref; vlos[n]=ptr->pnt[p].vel.median; vlos_sd[n]=ptr->pnt[p].vel.sd; if (xtd) { pwr[n]=ptr->pnt[p].pwr.median; pwr_sd[n]=ptr->pnt[p].pwr.sd; wdt[n]=ptr->pnt[p].wdt.median; wdt_sd[n]=ptr->pnt[p].wdt.sd; } n++; } } TimeEpochToYMDHMS(ptr->ed_time,&yr,&mo,&dy,&hr,&mt,&sc); eyr=yr; emo=mo; edy=dy; ehr=hr; emt=mt; esc=sc; TimeEpochToYMDHMS(ptr->st_time,&yr,&mo,&dy,&hr,&mt,&sc); syr=yr; smo=mo; sdy=dy; shr=hr; smt=mt; ssc=sc; if (logbuf !=NULL) sprintf(logbuf,"%d-%d-%d %d:%d:%d %d:%d:%d pnts=%d (%d)", syr,smo,sdy,shr,smt,(int) ssc, ehr,emt,(int) esc,ptr->npnt,ptr->st_id); data=DataMapMake(); DataMapAddScalar(data,"start.year",DATASHORT,&syr); DataMapAddScalar(data,"start.month",DATASHORT,&smo); DataMapAddScalar(data,"start.day",DATASHORT,&dy); DataMapAddScalar(data,"start.hour",DATASHORT,&shr); DataMapAddScalar(data,"start.minute",DATASHORT,&smt); DataMapAddScalar(data,"start.second",DATADOUBLE,&ssc); DataMapAddScalar(data,"end.year",DATASHORT,&eyr); DataMapAddScalar(data,"end.month",DATASHORT,&emo); DataMapAddScalar(data,"end.day",DATASHORT,&edy); DataMapAddScalar(data,"end.hour",DATASHORT,&ehr); DataMapAddScalar(data,"end.minute",DATASHORT,&emt); DataMapAddScalar(data,"end.second",DATADOUBLE,&esc); DataMapAddArray(data,"stid",DATASHORT,1,&stnum,stid); DataMapAddArray(data,"channel",DATASHORT,1,&stnum,chn); DataMapAddArray(data,"nvec",DATASHORT,1,&stnum,nvec); DataMapAddArray(data,"freq",DATAFLOAT,1,&stnum,freq); DataMapAddArray(data,"major.revision",DATASHORT,1,&stnum,major_rev); DataMapAddArray(data,"minor.revision",DATASHORT,1,&stnum,minor_rev); DataMapAddArray(data,"program.id",DATASHORT,1,&stnum,progid); DataMapAddArray(data,"noise.mean",DATAFLOAT,1,&stnum,noise_mean); DataMapAddArray(data,"noise.sd",DATAFLOAT,1,&stnum,noise_sd); DataMapAddArray(data,"gsct",DATASHORT,1,&stnum ,gsct); DataMapAddArray(data,"v.min",DATAFLOAT,1,&stnum,v_min); DataMapAddArray(data,"v.max",DATAFLOAT,1,&stnum,v_max); DataMapAddArray(data,"p.min",DATAFLOAT,1,&stnum,p_min); DataMapAddArray(data,"p.max",DATAFLOAT,1,&stnum,p_max); DataMapAddArray(data,"w.min",DATAFLOAT,1,&stnum,w_min); DataMapAddArray(data,"w.max",DATAFLOAT,1,&stnum,w_max); DataMapAddArray(data,"ve.min",DATAFLOAT,1,&stnum,ve_min); DataMapAddArray(data,"ve.max",DATAFLOAT,1,&stnum,ve_max); if (npnt !=0) { DataMapAddArray(data,"vector.mlat",DATAFLOAT,1,&npnt,gmlat); DataMapAddArray(data,"vector.mlon",DATAFLOAT,1,&npnt,gmlon); DataMapAddArray(data,"vector.kvect",DATAFLOAT,1,&npnt,kvect); DataMapAddArray(data,"vector.stid",DATASHORT,1,&npnt,vstid); DataMapAddArray(data,"vector.channel",DATASHORT,1,&npnt,vchn); DataMapAddArray(data,"vector.index",DATAINT,1,&npnt,index); DataMapAddArray(data,"vector.vel.median",DATAFLOAT,1,&npnt,vlos); DataMapAddArray(data,"vector.vel.sd",DATAFLOAT,1,&npnt,vlos_sd); if (xtd) { DataMapAddArray(data,"vector.pwr.median",DATAFLOAT,1,&npnt,pwr); DataMapAddArray(data,"vector.pwr.sd",DATAFLOAT,1,&npnt,pwr_sd); DataMapAddArray(data,"vector.wdt.median",DATAFLOAT,1,&npnt,wdt); DataMapAddArray(data,"vector.wdt.sd",DATAFLOAT,1,&npnt,wdt_sd); } } if (fid !=-1) s=DataMapWrite(fid,data); else s=DataMapSize(data); DataMapFree(data); free(buf); return s; }