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;
}
