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;
}
struct DataMap *DataMapMerge(int num,struct DataMap **in) {
int n,x,c;
struct DataMap *out;
struct DataMapScalar *s;
struct DataMapArray *a;
struct DataMapArray *t;
out=DataMapMake();
for (n=0;n<num;n++) {
for (x=0;x<in[n]->snum;x++) {
s=in[n]->scl[x];
for (c=0;c<out->snum;c++) {
if (strcmp((out->scl[c])->name,s->name) !=0) continue;
if ((out->scl[c])->type != s->type) continue;
break;
}
if (c !=out->snum) { /* duplicate */
(out->scl[c])->data.vptr=s->data.vptr;
continue;
}
DataMapAddScalar(out,s->name,s->type,s->data.vptr);
}
for (x=0;x<in[n]->anum;x++) {
a=in[n]->arr[x];
for (c=0;c<out->anum;c++) {
if (strcmp((out->arr[c])->name,a->name) !=0) continue;
if ((out->arr[c])->type != a->type) continue;
if ((out->arr[c])->dim != a->dim) continue;
break;
}
if (c !=out->anum) { /* duplicate array */
t=DataMapMergeArray(a->name,out->arr[c],a);
DataMapFreeArray(out->arr[c]);
out->arr[c]=t;
continue;
}
DataMapAddArray(out,a->name,a->type,a->dim,a->rng,a->data.vptr);
}
}
return out;
}
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;
}
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;
}
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;
}
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;
}
