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;
}
char *DataMapEncodeBuffer(struct DataMap *ptr,int *size) {
int c,x,m,n;
char **tmp;
void *tbuf;
int tsze;
struct DataMapScalar *s=NULL;
struct DataMapArray *a=NULL;
char *buf=NULL;
int off=0;
int sze=0;
sze=DataMapSize(ptr);
if (size !=NULL) *size=sze;
buf=malloc(sze);
if (buf==NULL) return NULL;
ConvertFromInt(DATACODE,buf+off);
off+=sizeof(int32);
ConvertFromInt(sze,buf+off);
off+=sizeof(int32);
ConvertFromInt(ptr->snum,buf+off);
off+=sizeof(int32);
ConvertFromInt(ptr->anum,buf+off);
off+=sizeof(int32);
for (c=0;c<ptr->snum;c++) {
s=ptr->scl[c];
n=0;
while (s->name[n] !=0) n++;
memcpy(buf+off,s->name,n+1);
off+=n+1;
buf[off]=s->type;
off++;
switch (s->type) {
case DATACHAR:
buf[off]=s->data.cptr[0];
off++;
break;
case DATASHORT:
ConvertFromShort(*(s->data.sptr),buf+off);
off+=sizeof(int16);
break;
case DATAINT:
ConvertFromInt(*(s->data.iptr),buf+off);
off+=sizeof(int32);
break;
case DATALONG:
ConvertFromLong(*(s->data.lptr),buf+off);
off+=sizeof(int64);
break;
case DATAUCHAR:
buf[off]=s->data.ucptr[0];
off++;
break;
case DATAUSHORT:
ConvertFromUShort(*(s->data.usptr),buf+off);
off+=sizeof(uint16);
break;
case DATAUINT:
ConvertFromUInt(*(s->data.uiptr),buf+off);
off+=sizeof(uint32);
break;
case DATAULONG:
ConvertFromULong(*(s->data.ulptr),buf+off);
off+=sizeof(uint64);
break;
case DATAFLOAT:
ConvertFromFloat(*(s->data.fptr),buf+off);
off+=sizeof(float);
break;
case DATADOUBLE:
ConvertFromDouble(*(s->data.dptr),buf+off);
off+=sizeof(double);
break;
case DATASTRING:
tmp=(char **) s->data.vptr;
if (*tmp !=NULL) {
n=0;
while((*tmp)[n] !=0) n++;
memcpy(buf+off,*tmp,n+1);
off+=n+1;
} else {
buf[off]=0;
off+=1;
}
break;
default:
if (*s->data.mptr !=NULL) {
tbuf=DataMapEncodeBuffer(*s->data.mptr,&tsze);
ConvertFromInt(tsze,buf+off);
off+=sizeof(int32);
memcpy(buf+off,tbuf,tsze);
off+=tsze;
free(tbuf);
} else {
tsze=0;
ConvertFromInt(tsze,buf+off);
off+=sizeof(int32);
}
break;
}
}
for (c=0;c<ptr->anum;c++) {
a=ptr->arr[c];
n=0;
while (a->name[n] !=0) n++;
memcpy(buf+off,a->name,n+1);
off+=n+1;
buf[off]=a->type;
off++;
ConvertFromInt(a->dim,buf+off);
off+=sizeof(int32);
for (x=0;x<a->dim;x++) {
ConvertFromInt(a->rng[x],buf+off);
off+=sizeof(int32);
}
n=1;
for (x=0;x<a->dim;x++) n=a->rng[x]*n;
switch (a->type) {
case DATACHAR:
memcpy(buf+off,a->data.cptr,n);
off+=n;
break;
case DATASHORT:
for (x=0;x<n;x++) {
ConvertFromShort(a->data.sptr[x],buf+off);
off+=sizeof(int16);
}
break;
case DATAINT:
for (x=0;x<n;x++) {
ConvertFromInt(a->data.iptr[x],buf+off);
off+=sizeof(int32);
}
break;
case DATALONG:
for (x=0;x<n;x++) {
ConvertFromLong(a->data.lptr[x],buf+off);
off+=sizeof(int64);
}
break;
case DATAUCHAR:
memcpy(buf+off,a->data.cptr,n);
off+=n;
break;
case DATAUSHORT:
for (x=0;x<n;x++) {
ConvertFromUShort(a->data.usptr[x],buf+off);
off+=sizeof(uint16);
}
break;
case DATAUINT:
for (x=0;x<n;x++) {
ConvertFromUInt(a->data.uiptr[x],buf+off);
off+=sizeof(uint32);
}
break;
case DATAULONG:
for (x=0;x<n;x++) {
ConvertFromULong(a->data.ulptr[x],buf+off);
off+=sizeof(uint64);
}
break;
case DATAFLOAT:
for (x=0;x<n;x++) {
ConvertFromFloat(a->data.fptr[x],buf+off);
off+=sizeof(float);
}
break;
case DATADOUBLE:
for (x=0;x<n;x++) {
ConvertFromDouble(a->data.dptr[x],buf+off);
off+=sizeof(double);;
}
break;
case DATASTRING:
tmp=(char **) a->data.vptr;
for (x=0;x<n;x++) {
if (tmp[x] !=NULL) {
m=0;
while( (tmp[x])[m] !=0) m++;
memcpy(buf+off,tmp[x],m+1);
off+=m+1;
} else {
buf[off]=0;
off++;
}
}
break;
default:
for (x=0;x<n;x++) {
if (a->data.mptr[x] !=0) {
tbuf=DataMapEncodeBuffer(a->data.mptr[x],&tsze);
ConvertFromInt(tsze,buf+off);
off+=sizeof(int32);
memcpy(buf+off,tbuf,tsze);
off+=tsze;
free(tbuf);
} else {
tsze=0;
ConvertFromInt(tsze,buf+off);
off+=sizeof(int32);
}
}
}
}
return buf;
}
int DataMapSize(struct DataMap *ptr) {
int c,x,m,n;
char **tmp;
struct DataMapScalar *s=NULL;
struct DataMapArray *a=NULL;
int sze=0;
sze+=sizeof(int32)*4;
for (c=0;c<ptr->snum;c++) {
s=ptr->scl[c];
n=0;
while (s->name[n] !=0) n++;
sze+=n+1+1;
switch (s->type) {
case DATACHAR:
sze++;
break;
case DATASHORT:
sze+=sizeof(int16);
break;
case DATAINT:
sze+=sizeof(int32);
break;
case DATALONG:
sze+=sizeof(int64);
break;
case DATAUCHAR:
sze++;
break;
case DATAUSHORT:
sze+=sizeof(uint16);
break;
case DATAUINT:
sze+=sizeof(uint32);
break;
case DATAULONG:
sze+=sizeof(uint64);
break;
case DATAFLOAT:
sze+=sizeof(float);
break;
case DATADOUBLE:
sze+=sizeof(double);;
break;
case DATASTRING:
tmp=(char **) s->data.vptr;
if (*tmp !=NULL) {
n=0;
while((*tmp)[n] !=0) n++;
sze+=n+1;
} else sze++;
break;
case DATAMAP:
if (*s->data.mptr !=NULL)
sze+=sizeof(int32)+DataMapSize(*s->data.mptr);
else sze+=sizeof(int32);
break;
}
}
for (c=0;c<ptr->anum;c++) {
a=ptr->arr[c];
n=0;
while (a->name[n] !=0) n++;
sze+=n+1+1+4+4*a->dim;
n=1;
for (x=0;x<a->dim;x++) n=a->rng[x]*n;
switch (a->type) {
case DATACHAR:
sze+=n;
break;
case DATASHORT:
sze+=sizeof(int16)*n;
break;
case DATAINT:
sze+=sizeof(int32)*n;
break;
case DATALONG:
sze+=sizeof(int64)*n;
break;
case DATAUCHAR:
sze+=n;
break;
case DATAUSHORT:
sze+=sizeof(uint16)*n;
break;
case DATAUINT:
sze+=sizeof(uint32)*n;
break;
case DATAULONG:
sze+=sizeof(uint64)*n;
break;
case DATAFLOAT:
sze+=sizeof(float)*n;
break;
case DATADOUBLE:
sze+=sizeof(double)*n;
break;
case DATASTRING:
tmp=(char **) a->data.vptr;
for (x=0;x<n;x++) {
if (tmp[x] !=NULL) {
m=0;
while( (tmp[x])[m] !=0) m++;
sze+=m+1;
} else sze++;
}
break;
default:
for (x=0;x<n;x++) {
if (a->data.mptr[x] !=NULL)
sze+=sizeof(int32)+DataMapSize(a->data.mptr[x]);
else sze+=sizeof(int32);
}
break;
}
}
return sze;
}
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;
}
