int dsel(struct dirent *dp) {
#else
int dsel(const struct dirent *dp) {
#endif
if (dp->d_name[0]=='.') return 0;
return 1;
}
int test_file_epoch(char *fname,double stime,double etime) {
long yr,mo,dy,hr,mt,sc,ms;
double fstime=0,fetime=0;
int max=0;
CDFid id;
CDFstatus status;
double *dptr;
char *varlist[]={"Epoch",NULL};
status=CDFopen(fname,&id);
if (status !=CDF_OK) return -1;
max=RCDFMaxRecR(id,varlist[0]);
if (max>0) {
status=RCDFReadR(id,0,varlist,data);
dptr=(double *) data[0].data;
EPOCHbreakdown(dptr[0],&yr,&mo,&dy,&hr,&mt,&sc,&ms);
fstime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc+(ms/1000.0));
status=RCDFReadR(id,max-1,varlist,data);
dptr=(double *) data[0].data;
EPOCHbreakdown(dptr[0],&yr,&mo,&dy,&hr,&mt,&sc,&ms);
fetime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc+(ms/1000.0));
}
max=RCDFMaxRecZ(id,varlist[0]);
if (max>0) {
status=RCDFReadZ(id,0,varlist,data);
dptr=(double *) data[0].data;
EPOCHbreakdown(dptr[0],&yr,&mo,&dy,&hr,&mt,&sc,&ms);
fstime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc+(ms/1000.0));
status=RCDFReadZ(id,max-1,varlist,data);
dptr=(double *) data[0].data;
EPOCHbreakdown(dptr[0],&yr,&mo,&dy,&hr,&mt,&sc,&ms);
fetime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc+(ms/1000.0));
}
CDFclose(&id);
if (stime>fetime) return 0;
if (etime<fstime) return 0;
return 1;
}
struct RfileIndex *RfileLoadIndex(FILE *fp) {
int syr,smo,sdy,shr,smt,eyr,emo,edy,ehr,emt;
double ssc,esc;
double tme;
int off;
char line[LMAX];
struct RfileIndex *ptr;
ptr=malloc(sizeof(struct RfileIndex));
ptr->time.start=malloc(sizeof(double)*FILE_STEP);
ptr->time.end=malloc(sizeof(double)*FILE_STEP);
ptr->offset=malloc(sizeof(int)*FILE_STEP);
ptr->num=0;
while (RfileReadLine(fp,LMAX,line)==0) {
if (sscanf(line,"%d %d %d %d %d %lg %d %d %d %d %d %lg %d",
&syr,&smo,&sdy,&shr,&smt,&ssc,
&eyr,&emo,&edy,&ehr,&emt,&esc,&off) !=13)
break;
tme=TimeYMDHMSToEpoch(syr,smo,sdy,shr,smt,ssc);
if (ptr->num==0) ptr->st_time=tme;
ptr->time.start[ptr->num]=tme;
tme=TimeYMDHMSToEpoch(eyr,emo,edy,ehr,emt,esc);
ptr->ed_time=tme;
ptr->time.end[ptr->num]=tme;
ptr->offset[ptr->num]=off;
ptr->num++;
if ((ptr->num % FILE_STEP)==0) {
int inc;
inc=FILE_STEP*(ptr->num/FILE_STEP+1);
ptr->time.start=realloc(ptr->time.start,sizeof(double)*inc);
ptr->time.end=realloc(ptr->time.end,sizeof(double)*inc);
ptr->offset=realloc(ptr->offset,sizeof(int)*inc);
}
}
ptr->time.start=realloc(ptr->time.start,sizeof(double)*ptr->num);
ptr->time.end=realloc(ptr->time.end,sizeof(double)*ptr->num);
ptr->offset=realloc(ptr->offset,sizeof(int)*ptr->num);
return ptr;
}
void IDLCopyGridPrmFromIDL(struct GridIDLPrm *iprm,
struct GridData *grd) {
grd->st_time=TimeYMDHMSToEpoch(iprm->start.yr,iprm->start.mo,iprm->start.dy,
iprm->start.hr,iprm->start.mt,iprm->start.sc);
grd->ed_time=TimeYMDHMSToEpoch(iprm->end.yr,iprm->end.mo,iprm->end.dy,
iprm->end.hr,iprm->end.mt,iprm->end.sc);
grd->stnum=iprm->stnum;
grd->vcnum=iprm->vcnum;
grd->xtd=iprm->xtd;
}
int windmfi_imf(CDFid id,struct imfdata *ptr,double stime,double etime) {
long yr,mo,dy,hr,mt,sc,ms;
double rtime;
int i,cnt=0;
char *varlist[]={"Epoch3","B3GSM","B3GSE",NULL};
struct RCDFData *data=NULL;
int max;
int rmax;
int status;
double *dptr;
float *fptr;
strcpy(ptr->sat,"we");
strcpy(ptr->ins,"mfi");
cnt=ptr->cnt;
rmax=RCDFMaxRecZ(id,varlist[0]);
max=cnt+rmax;
if (rmax==0) return -1;
data=RCDFMake(3);
if (ptr->time==NULL) ptr->time=malloc(sizeof(double)*max);
else ptr->time=realloc(ptr->time,sizeof(double)*max);
if (ptr->BGSMc==NULL) ptr->BGSMc=malloc(3*sizeof(float)*max);
else ptr->BGSMc=realloc(ptr->BGSMc,3*sizeof(float)*max);
if (ptr->BGSEc==NULL) ptr->BGSEc=malloc(3*sizeof(float)*max);
else ptr->BGSEc=realloc(ptr->BGSEc,3*sizeof(float)*max);
for (i=0;i<rmax;i++) {
status=RCDFReadZ(id,i,varlist,data);
if (status==0) {
dptr=(double *) data[0].data;
EPOCHbreakdown(dptr[0],&yr,&mo,&dy,&hr,&mt,&sc,&ms);
rtime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc+(ms/1000.0));
if (rtime<stime) continue;
if (rtime>etime) break;
ptr->time[cnt]=rtime;
fptr=(float *) data[1].data;
ptr->BGSMc[cnt*3]=fptr[0];
ptr->BGSMc[cnt*3+1]=fptr[1];
ptr->BGSMc[cnt*3+2]=fptr[2];
fptr=(float *) data[2].data;
ptr->BGSEc[cnt*3]=fptr[0];
ptr->BGSEc[cnt*3+1]=fptr[1];
ptr->BGSEc[cnt*3+2]=fptr[2];
cnt++;
}
}
RCDFFree(data,3);
ptr->cnt=cnt;
return 0;
}
double oldfit_scan(double ctime,struct OldFitFp *fitfp,int rflg,
struct RadarParm *prm,struct FitData *fit,
int bmnum,int chnum,int cpid,int sflg,int scan) {
double atime;
int flg=1;
if (rflg) {
if (OldFitRead(fitfp,prm,fit)==-1) return -1;
}
while (1) {
atime=TimeYMDHMSToEpoch(prm->time.yr,prm->time.mo,prm->time.dy,
prm->time.hr,prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
if (atime<ctime) flg=0;
if ((bmnum !=-1) && (prm->bmnum !=bmnum)) flg=0;
if ((sflg) && (prm->scan !=scan)) flg=0;
if (chnum !=-1) {
if ((chnum==2) && (prm->channel!=2)) flg=0;
if ((chnum==1) && (prm->channel==2)) flg=0;
}
if ((cpid !=-1) && (prm->cp !=cpid)) flg=0;
if (flg==1) break;
if (OldFitRead(fitfp,prm,fit)==-1) return -1;
flg=1;
}
return atime;
}
void plot_title(struct Grplot *grplot,double stime,double etime,
char *sat,char *plot,int mode,
unsigned int color,float width,char *fontname,
float fontsize) {
char title[256];
char *motxt[]={"GSM","GSE",0};
int yr,mo,dy,hr,mt;
int dayno;
double sc;
double yrsec;
TimeEpochToYMDHMS(stime,&yr,&mo,&dy,&hr,&mt,&sc);
yrsec=stime-TimeYMDHMSToEpoch(yr,1,1,0,0,0);
dayno=1+yrsec/(24*3600);
sprintf(title,"%s %s (%s) %s %.2d %.4d (Dayno=%.2d)",
sat,plot,motxt[mode],mtxt[mo-1],dy,yr,dayno);
GrplotXaxisTitle(grplot,0,0x02,strlen(title),title,
fontname,fontsize,color,0x0f);
}
int impmag_pos(CDFid id,struct posdata *ptr,double stime,double etime) {
long yr,mo,dy,hr,mt,sc,ms;
double rtime;
int i,cnt=0;
char *varlist[]={"Epoch","SC_pos_sm","SC_pos_se",0,NULL};
struct RCDFData *data=NULL;
int max;
int rmax;
int status;
double *dptr;
float *fptr;
strcpy(ptr->sat,"i8");
strcpy(ptr->ins,"mag");
cnt=ptr->cnt;
rmax=RCDFMaxRecR(id,varlist[0]);
max=cnt+rmax;
if (max==0) return -1;
data=RCDFMake(3);
if (ptr->time==NULL) ptr->time=malloc(sizeof(double)*max);
else ptr->time=realloc(ptr->time,sizeof(double)*max);
if (ptr->PGSM==NULL) ptr->PGSM=malloc(3*sizeof(float)*max);
else ptr->PGSM=realloc(ptr->PGSM,3*sizeof(float)*max);
if (ptr->PGSE==NULL) ptr->PGSE=malloc(3*sizeof(float)*max);
else ptr->PGSE=realloc(ptr->PGSE,3*sizeof(float)*max);
for (i=0;i<rmax;i++) {
status=RCDFReadR(id,i,varlist,data);
if (status==0) {
dptr=(double *) data[0].data;
EPOCHbreakdown(dptr[0],&yr,&mo,&dy,&hr,&mt,&sc,&ms);
rtime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc+(ms/1000.0));
if (rtime<stime) continue;
if (rtime>etime) break;
ptr->time[cnt]=rtime;
fptr=(float *) data[1].data;
ptr->PGSM[cnt*3]=fptr[0]/6370.0;
ptr->PGSM[cnt*3+1]=fptr[1]/6370.0;
ptr->PGSM[cnt*3+2]=fptr[2]/6370.0;
fptr=(float *) data[2].data;
ptr->PGSE[cnt*3]=fptr[0]/6370.0;
ptr->PGSE[cnt*3+1]=fptr[1]/6370.0;
ptr->PGSE[cnt*3+2]=fptr[1]/6370.0;
cnt++;
}
}
RCDFFree(data,3);
ptr->cnt=cnt;
return 0;
}
int set_schedule(struct scd_blk *ptr) {
int yr,mo,dy,hr,mt,sc,us;
double stime;
int c;
TimeReadClock(&yr,&mo,&dy,&hr,&mt,&sc,&us);
stime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc);
for (c=0;(c<ptr->num) && (ptr->entry[c].stime<=stime);c++);
return c;
}
int test_schedule(struct scd_blk *ptr) {
int yr,mo,dy,hr,mt,sc,us;
double current_time;
TimeReadClock(&yr,&mo,&dy,&hr,&mt,&sc,&us);
current_time=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc);
if (ptr->cnt<0) return 0;
if (ptr->cnt==ptr->num) return 0;
if (current_time>=ptr->entry[ptr->cnt].stime) return 1;
return 0;
}
double strdate(char *text) {
double tme;
int val;
int yr,mo,dy;
val=atoi(text);
dy=val % 100;
mo=(val / 100) % 100;
yr=(val / 10000);
if (yr<1970) yr+=1900;
tme=TimeYMDHMSToEpoch(yr,mo,dy,0,0,0);
return tme;
}
int CFitSeek(struct CFitfp *ptr,
int yr,int mo,int dy,int hr,int mt,int sc,double *atme) {
struct CFitdata *cfit=NULL;
int status=0;
double tval;
int bjmp=0;
tval=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc);
cfit=CFitMake();
cfit->frang=0;
cfit->rsep=0;
if (cfit==NULL) return -1;
if (tval<ptr->ctime) {
/* rewind the file */
if (ptr->fbuf==NULL) gzseek(ptr->fp,0,SEEK_SET);
else ptr->fptr=0;
ptr->ctime=0;
ptr->blen=0;
}
if (tval>=ptr->ctime) {
do {
bjmp=ptr->blen;
status=CFitRead(ptr,cfit);
} while ((tval>=ptr->ctime) && (status !=-1));
if (status!=-1) {
if (ptr->fbuf==NULL) gzseek(ptr->fp,-(ptr->blen+bjmp),SEEK_CUR);
else ptr->fptr-=ptr->blen+bjmp;
} else return -1;
}
/* get the actual time */
do {
status=CFitRead(ptr,cfit);
} while (status !=0);
if (ptr->fbuf==NULL) gzseek(ptr->fp,-ptr->blen,SEEK_CUR);
else ptr->fptr-=ptr->blen;
if (atme !=NULL) {
*atme=ptr->ctime;
}
CFitFree(cfit);
if (status==-1) return 0;
return 0;
}
int main(int argc,char *argv[]) {
int yr=2004;
int mo=8;
int dy=30;
int hr=12;
int mt=0;
double sc=0;
double tval,tsince,jdoy;
struct SGP4TLE tle;
struct SGP4 sgp4;
struct SGP4XYZVector pos,vel;
struct SGP4Geodetic geo;
tval=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc);
SGP4DecodeTLE(txt,&tle);
SGP4Setup(&sgp4,&tle);
tsince=SGP4EpochToTsince(tval,&tle);
jdoy=SGP4EpochToJdoy(tval);
SGP4Calculate(tsince,&sgp4,&tle,&pos,&vel);
SGP4GeodeticPosition(jdoy,&pos,&geo);
fprintf(stdout,"SGP4GeodeticPosition\n");
fprintf(stdout,"Spacecraft ID: %d\n",tle.catnr);
fprintf(stdout,"Date: %.4d-%.2d-%.2d %.2d:%.2d:%.2d\n",
yr,mo,dy,hr,mt,(int) sc);
fprintf(stdout,"Latitude: %g\n",geo.lat);
fprintf(stdout,"Longitude: %g\n",geo.lon);
fprintf(stdout,"Altitude: %g\n",geo.alt);
return 0;
}
double oldfit_find(struct OldFitFp *fitfp,struct RadarParm *prm,
struct FitData *fit,double sdate,
double stime) {
int status;
int yr,mo,dy,hr,mt;
double sc;
double atime;
if (OldFitRead(fitfp,prm,fit)==-1) return -1;
atime=TimeYMDHMSToEpoch(prm->time.yr,prm->time.mo,prm->time.dy,
prm->time.hr,prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
if ((stime==-1) && (sdate==-1)) return atime;
if (stime==-1) stime= ( (int) atime % (24*3600));
if (sdate==-1) stime+=atime - ( (int) atime % (24*3600));
else stime+=sdate;
TimeEpochToYMDHMS(stime,&yr,&mo,&dy,&hr,&mt,&sc);
if (atime>=stime) return stime;
status=OldFitSeek(fitfp,yr,mo,dy,hr,mt,sc,NULL);
if (status==-1) return -1;
if (OldFitRead(fitfp,prm,fit)==-1) return -1;
return stime;
}
int FitToCFit(double min_pwr,struct CFitdata *ptr,
struct RadarParm *prm,
struct FitData *fit) {
int i,num=0,rng;
ptr->version.major=CFIT_MAJOR_REVISION;
ptr->version.minor=CFIT_MINOR_REVISION;
/* time stamp the record */
ptr->time=TimeYMDHMSToEpoch(prm->time.yr,prm->time.mo,
prm->time.dy,
prm->time.hr,prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
ptr->stid=prm->stid;
ptr->scan=prm->scan;
ptr->cp=prm->cp;
ptr->bmnum=prm->bmnum;
ptr->bmazm=prm->bmazm;
ptr->channel=prm->channel;
ptr->intt.sc=prm->intt.sc;
ptr->intt.us=prm->intt.us;
ptr->frang=prm->frang;
ptr->rsep=prm->rsep;
ptr->rxrise=prm->rxrise;
ptr->tfreq=prm->tfreq;
ptr->noise=prm->noise.search;
ptr->atten=prm->atten;
ptr->nave=prm->nave;
ptr->nrang=prm->nrang;
for (i=0;i<prm->nrang;i++) {
if (fit->rng[i].qflg!=1) continue;
if ((min_pwr !=0) && (fit->rng[i].p_0 <= min_pwr)) continue;
num++;
}
CFitSetRng(ptr,num);
num=0;
for (i=0;i<prm->nrang;i++) {
if (fit->rng[i].qflg!=1) continue;
if ((min_pwr !=0) && (fit->rng[i].p_0 <= min_pwr)) continue;
ptr->rng[num]=i;
num++;
}
if (num>0) {
for (i=0;i<num;i++) {
rng=ptr->rng[i];
ptr->data[i].gsct=fit->rng[rng].gsct;
ptr->data[i].p_0=fit->rng[rng].p_0;
ptr->data[i].p_0_e=0;
ptr->data[i].v=fit->rng[rng].v;
ptr->data[i].v_e=fit->rng[rng].v_err;
ptr->data[i].p_l=fit->rng[rng].p_l;
ptr->data[i].p_l_e=fit->rng[rng].p_l_err;
ptr->data[i].w_l=fit->rng[rng].w_l;
ptr->data[i].w_l_e=fit->rng[rng].w_l_err;
}
}
return 0;
}
int main(int argc,char *argv[]) {
int arg=0,farg;
int yr,mo,dy,hr,mt,isc,usc;
double sc;
int st=0;
FILE *fp;
char *envstr;
char *tmetxt=NULL,*dtetxt=NULL;
double tval=0,dval=0;
char *nlab[2]= {"","name:"};
char *slab[2]= {"","status:"};
char *olab[2]= {"","operator:"};
char *clab[2]= {"","code:"};
char *ilab[2]= {"","id:"};
char *hlab[2]= {"","location:"};
char *plab[2]= {"","pole:"};
unsigned char nflg=0;
unsigned char sflg=0;
unsigned char oflg=0;
unsigned char cflg=0;
unsigned char iflg=0;
unsigned char hflg=0;
unsigned char pflg=0;
unsigned char lflg=0;
unsigned char aflg=0;
unsigned char stflg=0;
unsigned char edflg=0;
unsigned char vb=0;
unsigned char help=0;
unsigned char option=0;
int status,c;
char *tmp=NULL;
char ststr[1024];
int stid[256];
int stcnt=0;
char *nldstr="\n";
char *tdstr="\t";
char *dstr=NULL;
OptionAdd(&opt,"-help",'x',&help);
OptionAdd(&opt,"-option",'x',&option);
OptionAdd(&opt,"vb",'x',&vb);
OptionAdd(&opt,"n",'x',&nflg);
OptionAdd(&opt,"s",'x',&sflg);
OptionAdd(&opt,"o",'x',&oflg);
OptionAdd(&opt,"c",'x',&cflg);
OptionAdd(&opt,"i",'x',&iflg);
OptionAdd(&opt,"h",'x',&hflg);
OptionAdd(&opt,"p",'x',&pflg);
OptionAdd(&opt,"st",'x',&stflg);
OptionAdd(&opt,"ed",'x',&edflg);
OptionAdd(&opt,"l",'x',&lflg);
OptionAdd(&opt,"a",'x',&aflg);
OptionAdd(&opt,"t",'t',&tmetxt);
OptionAdd(&opt,"d",'t',&dtetxt);
OptionAdd(&opt,"delim",'t',&dstr);
farg=OptionProcess(1,argc,argv,&opt,NULL);
if (help==1) {
OptionPrintInfo(stdout,hlpstr);
exit(0);
}
if (option==1) {
OptionDump(stdout,&opt);
exit(0);
}
if (arg==argc) {
OptionPrintInfo(stdout,errstr);
exit(-1);
}
if (tmetxt !=NULL) tval=strtime(tmetxt);
if (dtetxt !=NULL) dval=strdate(dtetxt);
tval+=dval;
if (tval !=0) TimeEpochToYMDHMS(tval,&yr,&mo,&dy,&hr,&mt,&sc);
else {
TimeReadClock(&yr,&mo,&dy,&hr,&mt,&isc,&usc);
sc=isc;
tval=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc);
}
if (dstr==NULL) {
if (lflg) dstr=tdstr;
else dstr=nldstr;
}
envstr=getenv("SD_RADAR");
if (envstr==NULL) {
fprintf(stderr,"Environment variable 'SD_RADAR' must be defined.\n");
exit(-1);
}
fp=fopen(envstr,"r");
if (fp==NULL) {
fprintf(stderr,"Could not locate radar information file.\n");
exit(-1);
}
network=RadarLoad(fp);
fclose(fp);
if (network==NULL) {
fprintf(stderr,"Failed to read radar information.\n");
exit(-1);
}
envstr=getenv("SD_HDWPATH");
if (envstr==NULL) {
fprintf(stderr,"Environment variable 'SD_HDWPATH' must be defined.\n");
exit(-1);
}
RadarLoadHardware(envstr,network);
for (arg=farg; arg<argc; arg++) {
strcpy(ststr,argv[arg]);
tmp=strtok(ststr,",");
do {
if (isdigit(tmp[0])) stid[stcnt]=atoi(tmp);
else stid[stcnt]=RadarGetID(network,tmp);
if (stid[stcnt] !=-1) stcnt++;
} while ((tmp=strtok(NULL,",")) !=NULL);
}
if (stcnt==0) {
stcnt=network->rnum;
for (st=0; st<stcnt; st++) stid[st]=network->radar[st].id;
}
for (st=0; st<stcnt; st++) {
status=RadarGetStatus(network,stid[st]);
/* if ((aflg) && (status !=1)) continue; */
radar=RadarGetRadar(network,stid[st]);
if (radar==NULL) continue;
if (aflg) {
if (radar->st_time==-1) continue;
if (tval<radar->st_time) continue;
if ((radar->ed_time !=-1) && (tval>radar->ed_time)) continue;
}
if (iflg==1) fprintf(stdout,"%s%d%s",ilab[vb],stid[st],dstr);
if (cflg==1) {
fprintf(stdout,"%s",clab[vb]);
for (c=0; (c<RadarGetCodeNum(network,stid[st])); c++)
if (c !=0) fprintf(stdout,",%s",RadarGetCode(network,stid[st],c));
else fprintf(stdout,"%s",RadarGetCode(network,stid[st],c));
fprintf(stdout,"%s",dstr);
}
if (nflg==1)
fprintf(stdout,"%s\"%s\"%s",nlab[vb],RadarGetName(network,stid[st]),
dstr);
if (sflg==1) {
fprintf(stdout,"%s",slab[vb]);
if (status==1) fprintf(stdout,"active");
else if (status==0) fprintf(stdout,"under construction");
else if (status==-1) fprintf(stdout,"defunct");
fprintf(stdout,"%s",dstr);
}
if (oflg==1) fprintf(stdout,"%s\"%s\"%s",olab[vb],
RadarGetOperator(network,stid[st]),dstr);
if (stflg) {
if (radar->st_time !=-1) {
TimeEpochToYMDHMS(radar->st_time,&yr,&mo,&dy,&hr,&mt,&sc);
fprintf(stdout,"%.4d%.2d%.2d%s",yr,mo,dy,dstr);
} else fprintf(stdout,"-%s",dstr);
}
if (edflg) {
if (radar->ed_time !=-1) {
TimeEpochToYMDHMS(radar->ed_time,&yr,&mo,&dy,&hr,&mt,&sc);
fprintf(stdout,"%.4d%.2d%.2d%s",yr,mo,dy,dstr);
} else fprintf(stdout,"-%s",dstr);
}
TimeEpochToYMDHMS(tval,&yr,&mo,&dy,&hr,&mt,&sc);
site=RadarYMDHMSGetSite(RadarGetRadar(network,stid[st]),
yr,mo,dy,hr,mt,(int) sc);
if (hflg) {
if (site !=NULL) fprintf(stdout,"%s%g,%g,%g,%g%s",hlab[vb],
site->geolat,site->geolon,
site->alt,
site->boresite,dstr);
else fprintf(stdout,"unknown%s",dstr);
}
if (pflg) {
if (site !=NULL) {
if (site->geolat>0) fprintf(stdout,"%snorth",plab[vb]);
else fprintf(stdout,"%ssouth",plab[vb]);
} else if (radar->site !=NULL) {
if (radar->site[0].geolat>0) fprintf(stdout,"%snorth",plab[vb]);
else fprintf(stdout,"%ssouth",plab[vb]);
} else fprintf(stdout,"unknown");
fprintf(stdout,"%s",dstr);
}
if (lflg) fprintf(stdout,"\n");
}
return 0;
}
/********************** function write_sounding_record() ************************/
void write_sounding_record( char *progname, struct RadarParm *prm, struct FitData *fit, struct sounder_struct *sounder_data, int *act_snd_rec)
{
int i;
struct header_struct
{
double stime;
unsigned char site_id;
unsigned char beam_no;
unsigned short freq;
unsigned short noise;
unsigned short frange;
unsigned short rsep;
unsigned char gsct[10];
unsigned char qflg[10];
char program_name[40];
short unused1;
short unused2;
short unused3;
} header;
struct data_struct
{
short vel;
unsigned short width;
unsigned short AOA;
short unused1;
short unused2;
unsigned char unused3;
unsigned char pwr;
} data;
char data_path[100], data_filename[50], filename[80];
int byte, good_ranges[300];
double min_vel=-3000, max_vel=3000;
double max_width=1000;
double min_power=0, max_power=50;
double min_AOA=0, max_AOA=90.;
char *snd_dir;
FILE *out;
struct sounder_struct *act_snd_data;
/* set up the data directory */
/* get the snd data dir */
snd_dir= getenv("SD_SND_PATH");
if( snd_dir==NULL )
sprintf( data_path,"/data/ros/snd/");
else
memcpy( data_path,snd_dir,strlen(snd_dir));
/* make up the filename */
/* YYYYMMDDHH */
sprintf( data_filename, "%04d%02d%02d%02d%s", prm->time.yr, prm->time.mo, prm->time.dy, (prm->time.hr/ 2)* 2, ststr);
/* finally make the filename */
sprintf( filename, "%s/%s.snd", data_path, data_filename);
fprintf(stderr,"Sound Data File: %s\n",filename);
/* open the output file */
out= fopen(filename,"a");
if( out==NULL ) {
/* crap. might as well go home */
return;
}
/* make the header */
/* initialize the unused values */
header.unused1= prm->atten;
header.unused2= 0x0FFE;
header.unused3= 0x0FFE;
data.unused1= 0x0FFE;
data.unused2= 0x0FFE;
data.unused3= 0xFE;
header.stime= TimeYMDHMSToEpoch( prm->time.yr, prm->time.mo, prm->time.dy, prm->time.hr, prm->time.mt, prm->time.sc);
header.site_id= prm->stid;
header.beam_no= prm->bmnum;
header.freq= prm->tfreq;
header.noise= prm->noise.mean;
header.frange= prm->frang;
header.rsep= prm->rsep;
memcpy( header.program_name, progname, sizeof( header.program_name));
/* zero out the gscat and qual bytes */
for( i=0; i<10; i++ ) {
header.gsct[i]= 0;
header.qflg[i]= 0;
}
/* now fill them in */
byte= 0;
for( i=0; i< SND_NRANG; i++ ) {
byte=i/8;
if( fit->rng[i].gsct==1 ) header.gsct[byte]+=(0x01<<(i%8));
if( fit->rng[i].qflg==1 ) {
header.qflg[byte]+= (0x01<<(i%8));
good_ranges[i]=1;
} else {
good_ranges[i]=0;
}
}
/* write out the header */
fwrite( &header, sizeof( header), 1, out);
/* scale the fit data into the char/shorts */
for( i=0; i< SND_NRANG; i++ ) {
/* only do the good ranges */
if( good_ranges[i] ) {
/* do the power */
if( fit->rng[i].p_l < min_power ) data.pwr= 0;
else if ( fit->rng[i].p_l > max_power ) data.pwr= 255;
else data.pwr= 255* fit->rng[i].p_l/ (max_power - min_power);
/* do the AOA */
if( fit->elv[i].normal < 0 ) data.AOA= 0;
else if( fit->elv[i].normal > 90.0 ) data.AOA= 65535;
else data.AOA= 65535* fit->elv[i].normal/ (max_AOA-min_AOA);
/* do the velocity */
if( fit->rng[i].v < 0 ) {
if( fit->rng[i].v < min_vel ) data.vel=-32768;
else data.vel= -(32767/ min_vel)* fit->rng[i].v-1;
} else {
if( fit->rng[i].v > max_vel ) data.vel=32767;
else data.vel=(32767/ max_vel)* fit->rng[i].v;
}
/* do the width */
if( fit->rng[i].w_l > max_width ) data.width= 65535;
else data.width= ( 65535/ max_width)* fit->rng[i].w_l;
/* write out the data structure */
fwrite( &data, sizeof( data), 1, out);
}
}
fclose(out);
/* Fill the next sounder data record */
act_snd_data= sounder_data + *act_snd_rec;
act_snd_data->stime= TimeYMDHMSToEpoch( prm->time.yr, prm->time.mo, prm->time.dy, prm->time.hr, prm->time.mt, prm->time.sc);
memcpy( act_snd_data->program_name, progname, sizeof(act_snd_data->program_name));
act_snd_data->site_id= prm->stid;
act_snd_data->beam_num= prm->bmnum;
act_snd_data->freq= prm->tfreq;
act_snd_data->noise= prm->noise.mean;
act_snd_data->frange= prm->frang;
act_snd_data->rsep= prm->rsep;
for( i=0; i< SND_NRANG; i++ ) {
act_snd_data->pwr[ i]= fit->rng[ i].p_l;
act_snd_data->vel[ i]= fit->rng[ i].v;
act_snd_data->width[ i]= fit->rng[ i].w_l;
act_snd_data->AOA[ i]= fit->elv[ i].normal;
act_snd_data->gsct[ i]= fit->rng[ i].gsct;
act_snd_data->qflg[ i]= fit->rng[ i].qflg;
}
*act_snd_rec= *act_snd_rec + 1;
if ( *act_snd_rec >= NUM_SND_DATA) *act_snd_rec= 0;
}
struct fitfp *fit_open(char *fitfile,char *inxfile) {
int r1_pat[]={4,2,1,2,2,17,4,2,2,14,4,4,2,4,
2,PULSE_PAT_LEN,2,2*LAG_TAB_LEN,1,ORIG_COMBF_SIZE,4,3,
2,2*ORIG_MAX_RANGE,1,ORIG_MAX_RANGE,0,0};
int status=0;
union fit_out r;
struct fitfp *ptr=NULL;
int16 tmp,i,j;
int32 inx_buf[4];
struct radar_parms *prms=NULL;
char *tmpbuf;
ptr=malloc(sizeof(struct fitfp));
if (ptr==NULL) return NULL;
ptr->fitfp=-1;
ptr->inxfp=-1;
ptr->ibuf=NULL;
ptr->fbuf=NULL;
ptr->iptr=0;
ptr->fptr=0;
ptr->ctime=-1;
ptr->stime=-1;
ptr->etime=-1;
ptr->fitfp=open(fitfile,O_RDONLY);
if (ptr->fitfp==-1) {
free(ptr);
return NULL;
}
fstat(ptr->fitfp,&ptr->fstat);
/* buffering disabled as it is actually slower to load into memory!
ptr->fbuf=malloc(ptr->fstat.st_size);
if (ptr->fbuf !=NULL) {
if (read(ptr->fitfp,ptr->fbuf,
ptr->fstat.st_size) !=ptr->fstat.st_size) {
close(ptr->fitfp);
free(ptr->fbuf);
free(ptr);
return NULL;
}
close(ptr->fitfp);
ptr->fitfp=-1;
}
*/
if (inxfile !=NULL) { /* open the index file */
ptr->inxfp=open(inxfile,O_RDONLY);
if (ptr->inxfp !=-1) {
fstat(ptr->inxfp,&ptr->istat);
ptr->ibuf=malloc(ptr->istat.st_size);
if ((ptr->ibuf !=NULL) &&
(read(ptr->inxfp,ptr->ibuf,ptr->istat.st_size)
!=ptr->istat.st_size)) free(ptr->ibuf);
close(ptr->inxfp);
ptr->inxfp=-1;
}
}
if (ptr->fitfp !=-1) {
ConvertReadShort(ptr->fitfp,&tmp);
ptr->fit_recl=tmp;
ConvertReadShort(ptr->fitfp,&tmp);
ptr->inx_recl=tmp;
tmpbuf=malloc(ptr->fit_recl);
if (tmpbuf !=NULL) { /* get the header information */
memset(tmpbuf,0,ptr->fit_recl);
status=(read(ptr->fitfp,tmpbuf,ptr->fit_recl) !=ptr->fit_recl);
/* now decode the header information */
if (status==0) {
for (i=0;(tmpbuf[i] !='\n') && (tmpbuf[i] !=0) && (i<80);i++)
ptr->header[i]=tmpbuf[i];
ptr->header[i]=0;
j=i+1;
for (i=0;(tmpbuf[j+i] !='\n') && (tmpbuf[j+i] !=0) && (i<32);i++)
ptr->date[i]=tmpbuf[j+i];
ptr->date[i]=0;
j+=i+1;
for (i=0;(tmpbuf[j+i] !=0) && (i<256);i++)
ptr->extra[i]=tmpbuf[j+i];
ptr->extra[i]=0;
/* okay extra the version information - look for the '.' */
for (i=0;(ptr->header[i] !='.') && (ptr->header[i] !=0);i++);
if (ptr->header[i] !=0) {
tmpbuf[i]=0; /* work backwards for the major number */
for (j=0;(ptr->header[i-1-j] !=' ') && ((i-1-j)>0);j++)
tmpbuf[i-1-j]=ptr->header[i-1-j];
ptr->major_rev=atoi(tmpbuf+i-j);
for (j=0;(ptr->header[i+1+j] !=' ') &&
(ptr->header[i+1+j] !=0);i++) tmpbuf[j]=ptr->header[i+1+j];
tmpbuf[j]=0;
ptr->minor_rev=atoi(tmpbuf);
}
}
free(tmpbuf);
}
lseek(ptr->fitfp,ptr->fit_recl,SEEK_SET);
/* read the first parameter block se we can determine the year */
status=(read(ptr->fitfp,&r,sizeof(union fit_out)) !=sizeof(union fit_out));
if (status==0) {
ConvertBlock( (unsigned char *) &r,r1_pat);
status=(r.r1.rrn !=0);
prms=(struct radar_parms *) &(r.r1.plist[0]);
}
lseek(ptr->fitfp,ptr->fit_recl,SEEK_SET);
} else {
ConvertToShort(ptr->fbuf,&tmp);
ptr->fit_recl=tmp;
ConvertToShort(ptr->fbuf+2,&tmp);
ptr->inx_recl=tmp;
ptr->fptr=ptr->fit_recl;
memcpy( (unsigned char *) &r,
ptr->fbuf+ptr->fit_recl,sizeof(union fit_out));
ConvertBlock( (unsigned char *) &r,r1_pat);
status=(r.r1.rrn !=0);
prms=(struct radar_parms *) &(r.r1.plist[0]);
}
if (status !=0) {
if (ptr->fitfp !=-1) close(ptr->fitfp);
if (ptr->fbuf !=NULL) free(ptr->fbuf);
if (ptr->inxfp !=-1) close(ptr->inxfp);
if (ptr->ibuf !=NULL) free(ptr->ibuf);
free(ptr);
return NULL;
}
ptr->ctime=TimeYMDHMSToEpoch(prms->YEAR,prms->MONTH,prms->DAY,
prms->HOUR,prms->MINUT,prms->SEC);
ptr->stime=ptr->ctime;
if (fit_read_inx(ptr,inx_buf,-1)==0) {
if (inx_buf[0] > inx_buf[1]) prms->YEAR++;
/* generate the end time of the file */
ptr->etime=TimeYMDHMSToEpoch(prms->YEAR,1,1,0,0,0)
+inx_buf[1];
ptr->inx_srec=inx_buf[2]-2;
ptr->inx_erec=inx_buf[3];
} else { /* corrupt index file */
if (ptr->inxfp !=-1) close(ptr->inxfp);
if (ptr->ibuf !=NULL) free(ptr->ibuf);
ptr->ibuf=NULL;
ptr->inxfp=-1;
}
ptr->fitread=fit_read_current;
return ptr;
}
int RfileSeek(FILE *fp,
int yr,int mo,int dy,int hr,int mt,double sc,
struct RfileIndex *inx,
double *aval) {
int status=0;
int tval;
tval=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc);
if (inx !=NULL) {
int rec=0,prec=-1;
int st_rec;
int ed_rec;
/* search using index records */
double st_time,ed_time;
st_time=inx->st_time;
ed_time=inx->ed_time;
st_rec=0;
ed_rec=inx->num;
if (tval<st_time) { /* before start of file */
if (aval !=NULL) *aval=st_time;
fseek(fp,inx->offset[st_rec],SEEK_SET);
return 0;
} else if (tval>ed_time) { /* after end of file */
if (aval !=NULL) *aval=st_time;
fseek(fp,inx->offset[ed_rec-1],SEEK_SET);
return 0;
}
do {
prec=rec;
rec=st_rec+(int) ((tval-st_time)*(ed_rec-st_rec))/(ed_time-st_time);
if (inx->time.start[rec]==tval) break;
if (inx->time.start[rec]<tval) {
st_rec=rec;
st_time=inx->time.start[rec];
} else {
ed_rec=rec;
ed_time=inx->time.end[rec];
}
} while (prec != rec);
if (aval !=NULL) *aval=inx->time.start[rec];
fseek(fp,inx->offset[rec],SEEK_SET);
return 0;
} else {
int ptr=0,pptr=0;
double tme[2];
void *tptr[2];
tptr[0]=tme;
/* search manually */
ptr=ftell(fp);
status=RfileRead(fp,0,NULL,tptr);
if (status==0) {
if (tme[0]>tval) fseek(fp,0,SEEK_SET); /* need to rewind to start */
} else {
fseek(fp,0,SEEK_SET); /* set to the start of the file */
status=0;
}
if (aval !=NULL) *aval=tme[0];
while ((tval>tme[0]) && (status !=-1)) {
pptr=ptr;
ptr=ftell(fp);
status=RfileRead(fp,0,NULL,tptr);
if (aval !=NULL) *aval=tme[0];
}
if (status==-1) {
fseek(fp,pptr,SEEK_SET);
return -1;
}
fseek(fp,ptr,SEEK_SET);
}
return 0;
}
int RfileRead(FILE *fp,int num,RfileDecoder *decode,
void **ptr) {
double st_time,ed_time;
int syr,smo,sdy,shr,smt,ssc;
int eyr,emo,edy,ehr,emt,esc;
int i,j,k,l,ka,kb,s;
int nblks;
int nprm=0,npnt=0;
int sptr;
int txt=0;
char line[LMAX];
char name[LMAX];
char type[LMAX];
char unit[LMAX];
char *tcmp[]={"text","char","float","double","short","long","int",0};
char *tcnv[]={"%s","%c","%g","%lg","%d","%d","%d",0};
char tmp[1024]; /* buffer to store parameters */
struct RfileData *data=NULL;
sptr=ftell(fp);
s=fgetc(fp);
if (s==0) return RfileReadRaw(fp,num,decode,ptr);
line[0]=s;
if (RfileReadLine(fp,LMAX-1,line+1) !=0) return -1;
if (sscanf(line,"%d %d %d %d %d %d %d %d %d %d %d %d",
&syr,&smo,&sdy,&shr,&smt,&ssc,
&eyr,&emo,&edy,&ehr,&emt,&esc) !=12) return -1;
st_time=TimeYMDHMSToEpoch(syr,smo,sdy,shr,smt,ssc);
ed_time=TimeYMDHMSToEpoch(eyr,emo,edy,ehr,emt,esc);
if (num==0) { /* no decoders - but we may still want the time */
if (ptr !=NULL) {
((double *) ptr[0])[0]=st_time;
((double *) ptr[0])[1]=ed_time;
}
}
if (RfileReadLine(fp,LMAX,line) !=0) return -1;
if (sscanf(line,"%d",&nblks) !=1) return -1;
for (i=0;i<nblks;i++) {
if (RfileReadLine(fp,LMAX,line) !=0) break;
if (sscanf(line,"%d %d",&npnt,&nprm) !=2) break;
if (num !=0) {
if (data !=NULL) data=realloc(data,sizeof(struct RfileData)*nprm);
else data=malloc(sizeof(struct RfileData)*nprm);
memset(data,0,sizeof(struct RfileData)*nprm);
}
if (RfileReadLine(fp,LMAX,line) !=0) break;
if (num !=0) {
ka=0;
kb=0;
name[0]=0;
for (j=0;j<nprm;j++) {
/* skip spaces */
for (k=ka;((line[k]==' ') || (line[k]=='\t') || (line[k]=='\n')) &&
(line[k] !=0);k++);
ka=k;
for (k=ka;(line[k]!=' ') && (line[k]!='\t') &&(line[k]!='\n') &&
(line[k] !=0);k++);
kb=k;
if (j>0) strcat(name," ");
strncat(name,line+ka,kb-ka);
ka=kb;
}
}
if (RfileReadLine(fp,LMAX,line) !=0) break;
if (num !=0) {
ka=0;
kb=0;
unit[0]=0;
for (j=0;j<nprm;j++) {
/* skip spaces */
for (k=ka;((line[k]==' ') || (line[k]=='\t') || (line[k]=='\n')) &&
(line[k] !=0);k++);
ka=k;
for (k=ka;(line[k]!=' ') && (line[k]!='\t') && (line[k]!='\n') &&
(line[k] !=0);k++);
kb=k;
if (j>0) strcat(unit," ");
strncat(unit,line+ka,kb-ka);
ka=kb;
}
}
if (RfileReadLine(fp,LMAX,line) !=0) break;
if (num !=0) {
ka=0;
kb=0;
type[0]=0;
for (j=0;j<nprm;j++) {
/* skip spaces */
for (k=ka;((line[k]==' ') || (line[k]=='\t') || (line[k]=='\n')) &&
(line[k] !=0);k++);
ka=k;
for (k=ka;(line[k]!=' ') && (line[k]!='\t') && (line[k]!='\n') &&
(line[k] !=0);k++);
kb=k;
if (j>0) strcat(type," ");
strncat(type,line+ka,kb-ka);
ka=kb;
}
txt=0;
ka=0;
kb=0;
for (j=0;j<nprm;j++) {
for (k=ka;(type[k]!=' ') && (type[k]!='\t') && (type[k]!='\n') &&
(type[k] !=0);k++);
kb=k;
for (k=0;(tcmp[k] !=0) && (strncmp(type+ka,tcmp[k],kb-ka) !=0);k++);
if (tcmp[k]==0) k=0;
data[j].type=k;
if (k==0) txt=1;
ka=kb+1;
}
if (npnt==0) { /* tell loaders about empty records */
for (k=0;k<num;k++) {
s=(decode[k])(name,unit,type,st_time,ed_time,
npnt,nprm,0,data,ptr[k]);
if (s==-1) break;
}
if (k !=num) break;
}
}
for (l=0;l<npnt;l++) {
if (RfileReadLine(fp,LMAX,line) !=0) break;
if (num !=0) {
ka=0;
for (j=0;j<nprm;j++) {
for (k=ka;((line[k]==' ') || (line[k]=='\t') || (line[k]=='\n')) &&
(line[k] !=0);k++);
ka=k;
for (k=ka;(line[k]!=' ') && (line[k]!='\t') && (line[k]!='\n') &&
(line[k] !=0);k++);
if (sscanf(line+ka,tcnv[data[j].type],tmp) !=1) break;
if (data[j].type==1) data[j].data.cval=*tmp;
else if (data[j].type==2) data[j].data.fval=*((float *) tmp);
else if (data[j].type==3) data[j].data.dval=*((double *) tmp);
else if (data[j].type==4) data[j].data.ival=*((int *) tmp);
else if (data[j].type==5) data[j].data.ival=*((int *) tmp);
else if (data[j].type==6) data[j].data.ival=*((int *) tmp);
else {
if (data[j].data.tval !=NULL)
data[j].data.tval=realloc(data[j].data.tval,strlen(tmp)+1);
else data[j].data.tval=malloc(strlen(tmp)+1);
strcpy(data[j].data.tval,tmp);
}
ka=k;
}
if (j !=nprm) break;
for (k=0;k<num;k++) {
s=(decode[k])(name,unit,type,st_time,ed_time,
npnt,nprm,l,data,ptr[k]);
if (s==-1) break;
}
if (k !=num) break;
}
}
/* free text strings */
if (num !=0) {
if (txt==1) {
for (k=0;k<nprm;k++) if ((data[k].type==0) &&
(data[k].data.tval !=NULL)) free(data[k].data.tval);
}
if (l != npnt) break;
}
}
if (num !=0) free(data);
if (i<nblks) return -1;
return ftell(fp)-sptr;
}
int raw_read_current(struct rawfp *fp,struct rawdata *raw_data) {
/* read raw data block from file */
int radar_parms_pat[]={1,2,2,17,4,2,2,14,4,4,2,4,0,0};
int i;
int16 range;
int j;
int16 prev_range;
int xcf_data;
unsigned int stat;
int16 num_byte;
int32 rec_num=0;
unsigned char *inbuf;
unsigned char *inbuf_ptr;
xcf_data = 0;
prev_range = -1;
inbuf=malloc(sizeof(struct rawdata));
/* zero out the raw data buffer */
memset(raw_data,0,sizeof(struct rawdata));
fp->rlen=0;
do {
if (ConvertReadShort(fp->rawfp,&num_byte) !=0) {
free(inbuf);
return -1;
}
fp->rlen+=num_byte;
fp->ptr+=num_byte;
num_byte = num_byte - 2;
stat = read(fp->rawfp,inbuf,num_byte);
if(stat != num_byte) {
free(inbuf);
return -1;
}
inbuf_ptr=inbuf;
ConvertToInt(inbuf_ptr,&rec_num);
} while (rec_num==0);
inbuf_ptr = inbuf_ptr + 12; /* skip rec_num + rawwrite */
num_byte = num_byte - 12;
/* zero out the raw data buffer */
/* copy radar_parms */
ConvertBlock(inbuf_ptr,radar_parms_pat);
memcpy((void *) &(raw_data->PARMS),inbuf_ptr,sizeof(struct radar_parms));
inbuf_ptr = inbuf_ptr + sizeof(struct radar_parms);
num_byte = num_byte - sizeof(struct radar_parms);
/* copy the pulse pattern */
for (i=0;i<raw_data->PARMS.MPPUL;i++) {
ConvertToShort(inbuf_ptr,&raw_data->PULSE_PATTERN[i]);
inbuf_ptr+=sizeof(int16);
num_byte-=sizeof(int16);
}
/* copy the lag table */
for(j=0;j < 2; ++j)
for(i=0; i < raw_data->PARMS.MPLGS; ++i) {
ConvertToShort(inbuf_ptr,&raw_data->LAG_TABLE[j][i]);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
/* copy comment buffer */
memcpy(raw_data->COMBF,inbuf_ptr,ORIG_COMBF_SIZE);
inbuf_ptr = inbuf_ptr + ORIG_COMBF_SIZE;
num_byte = num_byte - ORIG_COMBF_SIZE;
/* decompress and copy the lag-0 powers */
for(i=0 ; i < raw_data->PARMS.NRANG ; ++i) {
raw_data->pwr0[i] = dcmpr(inbuf_ptr);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
/* decompress and copy acfs */
while ( num_byte > 0 ) {
ConvertToShort(inbuf_ptr,&range);
--range;
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
if((range <= prev_range) && (raw_data->PARMS.XCF))
xcf_data = 1;
for(i = 0; i < raw_data->PARMS.MPLGS ; ++i) {
for(j=0 ; j < 2; ++j) {
if (xcf_data) raw_data->xcfd[range][i][j] = dcmpr(inbuf_ptr);
else raw_data->acfd[range][i][j] = dcmpr(inbuf_ptr);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
}
prev_range = range;
}
fp->ctime=TimeYMDHMSToEpoch(raw_data->PARMS.YEAR,
raw_data->PARMS.MONTH,
raw_data->PARMS.DAY,
raw_data->PARMS.HOUR,
raw_data->PARMS.MINUT,
raw_data->PARMS.SEC);
free(inbuf);
return 0;
}
struct OldRawFp *OldRawOpenFd(int rawfd,int inxfd) {
int radar_parms_pat[]={1,2,2,17,4,2,2,14,4,4,2,4,0,0};
unsigned char *inbuf=NULL;
int16 num_byte;
int32 rec_num;
int stat;
struct radar_parms *prm;
struct OldRawFp *ptr=NULL;
int status=0;
int j;
inbuf=malloc(sizeof(struct rawdata));
if (inbuf==NULL) return NULL;
ptr=malloc(sizeof(struct OldRawFp));
if (ptr==NULL) return NULL;
ptr->rawfp=rawfd;
ptr->stime=-1;
ptr->ctime=-1;
ptr->frec=0;
ptr->rlen=0;
ptr->ptr=0;
fstat(ptr->rawfp,&ptr->rstat);
if (ConvertReadShort(ptr->rawfp,&num_byte) !=0) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
num_byte = num_byte - 2;
stat = read(ptr->rawfp,inbuf,num_byte);
if (stat != num_byte) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
ConvertToInt(inbuf,&rec_num);
ptr->frec=num_byte+2;
ptr->rlen=num_byte+2;
ptr->ptr=num_byte+2;
if (rec_num==0) { /* decode header to get the threshold */
char tmp[256];
char *str;
strcpy(tmp,(char *) (inbuf+sizeof(struct rawrechdr)-sizeof(int16)+1));
ptr->thr=3;
str=strtok(tmp," ");
if (str==NULL) status=-1;
if ((status==0) && (strcmp(str,"version") !=0)) status=-1;
if (status==0) str=strtok(NULL," ");
if (str==NULL) status=-1;
for (j=0;str[j] !=0;j++) if (str[j]=='.') break;
if (str[j]==0) {
ptr->major_rev=atoi(str);
} else {
str[j]=0;
ptr->major_rev=atoi(str);
ptr->minor_rev=atoi(str+j+1);
}
if (status==0) str=strtok(NULL," ");
if (str==NULL) status=-1;
if ((status==0) && (strcmp(str,"threshold") !=0)) status=-1;
if (status==0) str=strtok(NULL," ");
if (str==NULL) status=-1;
if (status==0) ptr->thr=atoi(str);
}
if (rec_num !=0) { /* not the header so rewind the file */
lseek(ptr->rawfp,0L,SEEK_SET);
ptr->rlen=0;
}
/* read the first record so that we can determine the start time of
the file */
if (ConvertReadShort(ptr->rawfp,&num_byte) !=0) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
num_byte = num_byte - 2;
stat = read(ptr->rawfp,inbuf,num_byte);
if (stat != num_byte) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
ConvertToInt(inbuf,&rec_num);
/* now decode the parameter block */
ConvertBlock(inbuf+12,radar_parms_pat);
prm=(struct radar_parms *) (inbuf+12);
ptr->stime=TimeYMDHMSToEpoch(prm->YEAR,prm->MONTH,prm->DAY,
prm->HOUR,prm->MINUT,prm->SEC);
ptr->ctime=ptr->stime;
/* rewind to the first record */
lseek(ptr->rawfp,ptr->frec,SEEK_SET);
ptr->rawread=OldRawReadCurrent;
free(inbuf);
return ptr;
}
struct rawfp *raw_open(char *rawfile,char *inxfile) {
int radar_parms_pat[]= {1,2,2,17,4,2,2,14,4,4,2,4,0,0};
unsigned char *inbuf=NULL;
int16 num_byte;
int32 rec_num;
int stat;
struct radar_parms *prm;
struct rawfp *ptr=NULL;
inbuf=malloc(sizeof(struct rawdata));
if (inbuf==NULL) return NULL;
ptr=malloc(sizeof(struct rawfp));
if (ptr==NULL) return NULL;
ptr->rawfp=open(rawfile,O_RDONLY);
ptr->stime=-1;
ptr->ctime=-1;
ptr->frec=0;
ptr->rlen=0;
ptr->ptr=0;
if (ptr->rawfp==-1) {
free(ptr);
free(inbuf);
return NULL;
}
fstat(ptr->rawfp,&ptr->rstat);
if (ConvertReadShort(ptr->rawfp,&num_byte) !=0) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
num_byte = num_byte - 2;
stat = read(ptr->rawfp,inbuf,num_byte);
if (stat != num_byte) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
ConvertToInt(inbuf,&rec_num);
ptr->frec=num_byte+2;
ptr->rlen=num_byte+2;
ptr->ptr=num_byte+2;
if (rec_num !=0) { /* not the header so rewind the file */
lseek(ptr->rawfp,0L,SEEK_SET);
ptr->rlen=0;
}
/* read the first record so that we can determine the start time of
the file */
if (ConvertReadShort(ptr->rawfp,&num_byte) !=0) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
num_byte = num_byte - 2;
stat = read(ptr->rawfp,inbuf,num_byte);
if (stat != num_byte) {
close(ptr->rawfp);
free(ptr);
free(inbuf);
return NULL;
}
ConvertToInt(inbuf,&rec_num);
/* now decode the parameter block */
ConvertBlock(inbuf+12,radar_parms_pat);
prm=(struct radar_parms *) (inbuf+12);
ptr->stime=TimeYMDHMSToEpoch(prm->YEAR,prm->MONTH,prm->DAY,
prm->HOUR,prm->MINUT,prm->SEC);
/* rewind to the first record */
lseek(ptr->rawfp,ptr->frec,SEEK_SET);
ptr->rawread=raw_read_current;
free(inbuf);
return ptr;
}
void write_sounding_record_new( char *progname, struct RadarParm *prm, struct FitData *fit, struct sounder_struct *sounder_data, int *act_snd_rec)
{
int i;
struct header_struct
{
int32_t stime;
int16_t site_id;
int16_t beam_no;
int16_t freq;
int16_t noise;
int16_t frange;
int16_t rsep;
int16_t gsct[ SND_NRANG];
int16_t qflg[ SND_NRANG];
char program_name[40];
} header;
struct data_struct
{
int16_t pwr;
int16_t vel;
int16_t width;
int16_t AOA;
} data;
char data_path[100], data_filename[50], filename[80];
int good_ranges[ SND_NRANG];
char *snd_dir;
FILE *out;
struct sounder_struct *act_snd_data;
/* set up the data directory */
/* get the snd data dir */
snd_dir= getenv("SD_SND_PATH");
if( snd_dir==NULL )
sprintf( data_path,"/data/ros/snd/");
else {
memcpy( data_path,snd_dir,strlen(snd_dir));
data_path[ strlen( snd_dir)]= '/';
data_path[ strlen( snd_dir) + 1]= 0;
}
/* make up the filename */
/* YYYYMMDDHH */
sprintf( data_filename, "%04d%02d%02d%02d%s", prm->time.yr, prm->time.mo, prm->time.dy, (prm->time.hr/ 2)* 2, ststr);
/* finally make the filename */
sprintf( filename, "%s%s.snd", data_path, data_filename);
/* open the output file */
fprintf(stderr,"Sound Data File: %s\n",filename);
out= fopen(filename,"a");
if( out==NULL ) {
/* crap. might as well go home */
return;
}
/* make the header */
header.stime= TimeYMDHMSToEpoch( prm->time.yr, prm->time.mo, prm->time.dy, prm->time.hr, prm->time.mt, prm->time.sc);
header.site_id= prm->stid;
header.beam_no= prm->bmnum;
header.freq= prm->tfreq;
header.noise= prm->noise.mean;
header.frange= prm->frang;
header.rsep= prm->rsep;
memcpy( header.program_name, progname, sizeof( header.program_name));
/* zero out the gscat and qual bytes */
for( i=0; i< SND_NRANG; i++ ) {
header.gsct[i]= fit->rng[i].gsct;
header.qflg[i]= fit->rng[i].qflg;
good_ranges[ i]= ( fit->rng[i].qflg == 1);
}
/* write out the header */
fwrite( &header, sizeof( header), 1, out);
/* scale the fit data into the char/shorts */
for( i=0; i< SND_NRANG; i++ ) {
/* only do the good ranges */
if( good_ranges[i] ) {
/* do the power */
data.pwr= fit->rng[i].p_l;
/* do the velocity */
data.vel= fit->rng[i].v;
/* do the AOA */
data.AOA= fit->elv[i].normal;
/* do the width */
data.width= fit->rng[i].w_l;
/* write out the data structure */
fwrite( &data, sizeof( data), 1, out);
}
}
fclose(out);
/* Fill the next sounder data record */
act_snd_data= sounder_data + *act_snd_rec;
act_snd_data->stime= TimeYMDHMSToEpoch( prm->time.yr, prm->time.mo, prm->time.dy, prm->time.hr, prm->time.mt, prm->time.sc);
memcpy( act_snd_data->program_name, progname, sizeof(act_snd_data->program_name));
act_snd_data->site_id= prm->stid;
act_snd_data->beam_num= prm->bmnum;
act_snd_data->freq= prm->tfreq;
act_snd_data->noise= prm->noise.mean;
act_snd_data->frange= prm->frang;
act_snd_data->rsep= prm->rsep;
for( i=0; i< SND_NRANG; i++ ) {
act_snd_data->pwr[ i]= fit->rng[ i].p_l;
act_snd_data->vel[ i]= fit->rng[ i].v;
act_snd_data->width[ i]= fit->rng[ i].w_l;
act_snd_data->AOA[ i]= fit->elv[ i].normal;
act_snd_data->gsct[ i]= fit->rng[ i].gsct;
act_snd_data->qflg[ i]= fit->rng[ i].qflg;
}
*act_snd_rec= *act_snd_rec + 1;
if ( *act_snd_rec >= NUM_SND_DATA) *act_snd_rec= 0;
}
int acemfi_imf(CDFid id,struct imfdata *ptr,double stime,double etime,
int cnv) {
long yr,mo,dy,hr,mt,sc,ms;
double rtime;
int i,cnt=0;
char *varlist[]={"Epoch","BGSEc","BGSM",NULL};
struct RCDFData *data=NULL;
int max;
int rmax;
int status;
double *dptr;
float *fptr;
double gsex,gsey,gsez;
double gsmx,gsmy,gsmz;
if (cnv==1) varlist[2]=NULL;
strcpy(ptr->sat,"ac");
strcpy(ptr->ins,"mfi");
cnt=ptr->cnt;
rmax=RCDFMaxRecR(id,varlist[0]);
max=cnt+rmax;
if (rmax==0) return -1;
data=RCDFMake(3);
if (ptr->time==NULL) ptr->time=malloc(sizeof(double)*max);
else ptr->time=realloc(ptr->time,sizeof(double)*max);
if (ptr->BGSMc==NULL) ptr->BGSMc=malloc(3*sizeof(float)*max);
else ptr->BGSMc=realloc(ptr->BGSMc,3*sizeof(float)*max);
if (ptr->BGSEc==NULL) ptr->BGSEc=malloc(3*sizeof(float)*max);
else ptr->BGSEc=realloc(ptr->BGSEc,3*sizeof(float)*max);
for (i=0;i<rmax;i++) {
status=RCDFReadR(id,i,varlist,data);
if (status==0) {
dptr=(double *) data[0].data;
EPOCHbreakdown(dptr[0],&yr,&mo,&dy,&hr,&mt,&sc,&ms);
rtime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc+(ms/1000.0));
if (rtime<stime) continue;
if (rtime>etime) break;
ptr->time[cnt]=rtime;
fptr=(float *) data[1].data;
ptr->BGSEc[cnt*3]=fptr[0];
ptr->BGSEc[cnt*3+1]=fptr[1];
ptr->BGSEc[cnt*3+2]=fptr[2];
if (cnv==1) {
gsex=fptr[0];
gsey=fptr[1];
gsez=fptr[2];
GeoPackRecalc(yr,mo,dy,hr,mt,(sc+1.0*ms/1000.0));
GeoPackGseGsm(gsex,gsey,gsez,&gsmx,&gsmy,&gsmz);
ptr->BGSMc[cnt*3]=gsmx;
ptr->BGSMc[cnt*3+1]=gsmy;
ptr->BGSMc[cnt*3+2]=gsmz;
} else {
fptr=(float *) data[2].data;
ptr->BGSMc[cnt*3]=fptr[0];
ptr->BGSMc[cnt*3+1]=fptr[1];
ptr->BGSMc[cnt*3+2]=fptr[2];
}
cnt++;
}
}
RCDFFree(data,3);
ptr->cnt=cnt;
return 0;
}
int OldFitReadRadarScan(struct OldFitFp *fp,int *state,
struct RadarScan *ptr,
struct RadarParm *prm,struct FitData *fit,
int tlen,
int lock,int chn) {
int fstatus=0;
int flg=0;
int n=0;
int r;
struct RadarBeam *tmp;
struct RadarBeam *bm;
if (ptr==NULL) return -1;
if (fit==NULL) return -1;
if (state==NULL) return -1;
if (*state!=1) {
if (chn==0) fstatus=OldFitRead(fp,prm,fit);
else {
do {
fstatus=OldFitRead(fp,prm,fit); /* read first fit record */
if (fstatus==-1) break;
/* The logic below will handle mono/stereo mixed days.
* If the channel is set to zero then the file is mono
* and we should treat the data as channel A.
*/
} while ( ((chn==2) && (prm->channel !=2)) ||
((chn==1) && (prm->channel ==2)));
}
if (fstatus==-1) return -1;
}
if (*state !=2) {
ptr->stid=prm->stid;
ptr->version.major=prm->revision.major;
ptr->version.minor=prm->revision.minor;
ptr->st_time=TimeYMDHMSToEpoch(prm->time.yr,prm->time.mo,
prm->time.dy,
prm->time.hr,prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
if ((tlen !=0) && (lock !=0)) ptr->st_time=tlen*(int) (ptr->st_time/tlen);
RadarScanReset(ptr);
}
*state=1;
do {
n=ptr->num;
if (ptr->bm==NULL) ptr->bm=malloc(sizeof(struct RadarBeam));
else {
tmp=realloc(ptr->bm,sizeof(struct RadarBeam)*(n+1));
if (tmp==NULL) {
flg=-1;
break;
}
ptr->bm=tmp;
}
bm=&ptr->bm[n];
bm->time=TimeYMDHMSToEpoch(prm->time.yr,prm->time.mo,
prm->time.dy,
prm->time.hr,prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
bm->scan=prm->scan;
bm->bm=prm->bmnum;
bm->cpid=prm->cp;
bm->intt.sc=prm->intt.sc;
bm->intt.us=prm->intt.us;
bm->nave=prm->nave;
bm->frang=prm->frang;
bm->rsep=prm->rsep;
bm->rxrise=prm->rxrise;
bm->freq=prm->tfreq;
bm->noise=prm->noise.search;
bm->atten=prm->atten;
bm->channel=prm->channel;
bm->nrang=prm->nrang;
for (r=0;r<MAX_RANGE;r++) bm->sct[r]=0;
for (r=0;r<bm->nrang;r++) {
bm->sct[r]=(fit->rng[r].qflg==1);
bm->rng[r].gsct=fit->rng[r].gsct;
bm->rng[r].p_0=fit->rng[r].p_0;
bm->rng[r].p_0_e=0;
bm->rng[r].v=fit->rng[r].v;
bm->rng[r].p_l=fit->rng[r].p_l;
bm->rng[r].w_l=fit->rng[r].w_l;
bm->rng[r].v_e=fit->rng[r].v_err;
}
ptr->num++;
ptr->ed_time=TimeYMDHMSToEpoch(prm->time.yr,prm->time.mo,
prm->time.dy,
prm->time.hr,prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
if (ptr->num>100) {
flg=-1;
break;
}
if (chn==0) fstatus=OldFitRead(fp,prm,fit);
else {
do {
fstatus=OldFitRead(fp,prm,fit);
if (fstatus==-1) break;
/* The logic below will handle mono/stereo mixed days.
* If the channel is set to zero then the file is mono
* and we should treat the data as channel A.
*/
} while ( ((chn==2) && (prm->channel !=2)) ||
((chn==1) && (prm->channel ==2)));
}
if (fstatus==-1) flg=2;
else {
if (tlen==0) {
if (prm->scan==1) flg=1;
} else if (ptr->ed_time-ptr->st_time>=tlen) flg=1;
}
} while (flg==0);
if (flg>0) flg--;
if (flg==1) *state=2;
return flg;
}
int main (int argc,char *argv[]) {
int arg;
unsigned char help=0;
unsigned char option=0;
unsigned char vb=0;
FILE *fp;
struct RadarParm *prm;
struct IQ *iq;
unsigned int *badtr=NULL;
int16 *samples=NULL;
int sze=0;
double tval;
prm=RadarParmMake();
iq=IQMake();
OptionAdd(&opt,"-help",'x',&help);
OptionAdd(&opt,"-option",'x',&option);
OptionAdd(&opt,"vb",'x',&vb);
arg=OptionProcess(1,argc,argv,&opt,NULL);
if (help==1) {
OptionPrintInfo(stdout,hlpstr);
exit(0);
}
if (option==1) {
OptionDump(stdout,&opt);
exit(0);
}
if (arg==argc) fp=stdin;
else fp=fopen(argv[arg],"r");
if (fp==NULL) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
while (IQFread(fp,prm,iq,&badtr,&samples) !=-1) {
if (vb)
fprintf(stderr,"%d-%d-%d %d:%d:%d beam=%d\n",prm->time.yr,prm->time.mo,
prm->time.dy,prm->time.hr,prm->time.mt,prm->time.sc,prm->bmnum);
tval=TimeYMDHMSToEpoch(prm->time.yr,
prm->time.mo,
prm->time.dy,
prm->time.hr,
prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
ConvertFwriteDouble(stdout,tval);
ConvertFwriteInt(stdout,sze);
sze+=IQWrite(-1,prm,iq,badtr,samples);
}
if (fp !=stdin) fclose(fp);
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 windswe_plasma(CDFid id,struct plasmadata *ptr,double stime,double etime) {
long yr,mo,dy,hr,mt,sc,ms;
double rtime;
int i,cnt=0;
char *varlist[]={"Epoch","V_GSM","V_GSE","THERMAL_SPD","Np",NULL};
struct RCDFData *data=NULL;
int max;
int rmax;
int status;
double *dptr;
float *fptr;
float Mp=1.6e-27;
float Vx;
int pcnt=0;
strcpy(ptr->sat,"we");
strcpy(ptr->ins,"swe");
cnt=ptr->cnt;
rmax=RCDFMaxRecR(id,varlist[0]);
max=cnt+rmax;
if (rmax==0) return -1;
data=RCDFMake(5);
if (ptr->time==NULL) ptr->time=malloc(sizeof(double)*max);
else ptr->time=realloc(ptr->time,sizeof(double)*max);
if (ptr->VGSM==NULL) ptr->VGSM=malloc(3*sizeof(float)*max);
else ptr->VGSM=realloc(ptr->VGSM,3*sizeof(float)*max);
if (ptr->VGSE==NULL) ptr->VGSE=malloc(3*sizeof(float)*max);
else ptr->VGSE=realloc(ptr->VGSE,3*sizeof(float)*max);
if (ptr->vth==NULL) ptr->vth=malloc(sizeof(float)*max);
else ptr->vth=realloc(ptr->vth,sizeof(float)*max);
if (ptr->den==NULL) ptr->den=malloc(sizeof(float)*max);
else ptr->den=realloc(ptr->den,sizeof(float)*max);
if (ptr->pre==NULL) ptr->pre=malloc(sizeof(float)*max);
else ptr->pre=realloc(ptr->pre,sizeof(float)*max);
for (i=0;i<rmax;i++) {
status=RCDFReadR(id,i,varlist,data);
if (status==0) {
dptr=(double *) data[0].data;
EPOCHbreakdown(dptr[0],&yr,&mo,&dy,&hr,&mt,&sc,&ms);
rtime=TimeYMDHMSToEpoch(yr,mo,dy,hr,mt,sc+(ms/1000.0));
if (rtime<stime) continue;
if (rtime>etime) break;
ptr->time[cnt]=rtime;
fptr=(float *) data[1].data;
ptr->VGSM[cnt*3]=fptr[0];
ptr->VGSM[cnt*3+1]=fptr[1];
ptr->VGSM[cnt*3+2]=fptr[2];
fptr=(float *) data[2].data;
ptr->VGSE[cnt*3]=fptr[0];
ptr->VGSE[cnt*3+1]=fptr[1];
ptr->VGSE[cnt*3+2]=fptr[2];
fptr=(float *) data[3].data;
ptr->vth[cnt]=fptr[0];
fptr=(float *) data[4].data;
ptr->den[cnt]=fptr[0];
Vx=ptr->VGSM[3*cnt];
if ((ptr->den[cnt]>0) && (Vx > -10000)) {
ptr->pre[cnt]=(ptr->den[cnt]*Mp*1e6)*
fabs(Vx*1e3)*fabs(Vx*1e3)*1e9;
pcnt++;
} else ptr->pre[cnt]=ptr->den[cnt];
cnt++;
}
}
if (pcnt==0) memset(ptr->pre,0,sizeof(float)*cnt);
ptr->cnt=cnt;
return 0;
}
int main (int argc,char *argv[]) {
int arg=0;
int status=0;
double atime;
char *stmestr=NULL;
char *etmestr=NULL;
char *sdtestr=NULL;
char *edtestr=NULL;
char *exstr=NULL;
double stime=-1;
double etime=-1;
double extime=0;
double sdate=-1;
double edate=-1;
int yr,mo,dy,hr,mt;
double sc;
unsigned char vb=0;
unsigned char help=0;
unsigned char option=0;
FILE *fp=NULL;
int n;
prm=RadarParmMake();
iq=IQMake();
OptionAdd(&opt,"-help",'x',&help);
OptionAdd(&opt,"-option",'x',&option);
OptionAdd(&opt,"vb",'x',&vb);
OptionAdd(&opt,"st",'t',&stmestr);
OptionAdd(&opt,"et",'t',&etmestr);
OptionAdd(&opt,"sd",'t',&sdtestr);
OptionAdd(&opt,"ed",'t',&edtestr);
OptionAdd(&opt,"ex",'t',&exstr);
arg=OptionProcess(1,argc,argv,&opt,NULL);
if (help==1) {
OptionPrintInfo(stdout,hlpstr);
exit(0);
}
if (option==1) {
OptionDump(stdout,&opt);
exit(0);
}
if (exstr !=NULL) extime=strtime(exstr);
if (stmestr !=NULL) stime=strtime(stmestr);
if (etmestr !=NULL) etime=strtime(etmestr);
if (sdtestr !=NULL) sdate=strdate(sdtestr);
if (edtestr !=NULL) edate=strdate(edtestr);
if ((argc-arg)>1) {
fp=fopen(argv[arg+1],"r");
if (fp==NULL) {
fprintf(stderr,"Index not found.\n");
exit(-1);
}
inx=IQIndexFload(fp);
fclose(fp);
if (inx==NULL) {
fprintf(stderr,"Error loading index.\n");
exit(-1);
}
}
if (arg==argc) fp=stdin;
else fp=fopen(argv[arg],"r");
if (fp==NULL) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
if (IQFread(fp,prm,iq,&badtr,&samples)==-1) {
fprintf(stderr,"Error reading file\n");
exit(-1);
}
atime=TimeYMDHMSToEpoch(prm->time.yr,
prm->time.mo,
prm->time.dy,
prm->time.hr,
prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
/* skip here */
if ((stime !=-1) || (sdate !=-1)) {
/* we must skip the start of the files */
int yr,mo,dy,hr,mt;
double sc;
if (stime==-1) stime= ( (int) atime % (24*3600));
if (sdate==-1) stime+=atime - ( (int) atime % (24*3600));
else stime+=sdate;
TimeEpochToYMDHMS(stime,&yr,&mo,&dy,&hr,&mt,&sc);
status=IQFseek(fp,yr,mo,dy,hr,mt,sc,NULL,inx);
if (status ==-1) {
fprintf(stderr,"File does not contain the requested interval.\n");
exit(-1);
}
if (IQFread(fp,prm,iq,&badtr,&samples)==-1) {
fprintf(stderr,"Error reading file\n");
exit(-1);
}
} else stime=atime;
if (etime !=-1) {
if (edate==-1) etime+=atime - ( (int) atime % (24*3600));
else etime+=edate;
}
if (extime !=0) etime=stime+extime;
do {
fprintf(stderr,"%s\n",prm->origin.time);
fprintf(stderr,"%s\n",prm->origin.command);
fprintf(stderr,"%s\n",prm->combf);
fprintf(stderr,"%d:",prm->mppul);
for (n=0;n<prm->mppul;n++) fprintf(stderr,"%d ",prm->pulse[n]);
fprintf(stderr,"\n");
fprintf(stderr,"%d\n",prm->mplgs);
for (n=0;n<=prm->mplgs;n++) fprintf(stderr,"%d,%d ",
prm->lag[0][n],prm->lag[1][n]);
fprintf(stderr,"\n");
IQFwrite(stdout,prm,iq,badtr,samples);
atime=TimeYMDHMSToEpoch(prm->time.yr,
prm->time.mo,
prm->time.dy,
prm->time.hr,
prm->time.mt,
prm->time.sc+prm->time.us/1.0e6);
TimeEpochToYMDHMS(atime,&yr,&mo,&dy,&hr,&mt,&sc);
if (vb==1) fprintf(stderr,"%d-%d-%d %d:%d:%d\n",yr,mo,dy,hr,mt,(int) sc);
if ((etime !=-1) && (atime>=etime)) break;
status=IQFread(fp,prm,iq,&badtr,&samples);
} while (status !=-1);
if (fp !=stdin) fclose(fp);
return 0;
}
int32 OldCnvMapIDLWrite(int argc,char *argv[]) {
int n;
struct CnvMapIDLPrm *prm;
struct GridIDLStVec *stvec;
struct GridIDLGVec *gvec;
struct GridIDLGVec *mvec;
double *coef;
struct CnvMapIDLBnd *bnd;
struct GridData grd;
struct CnvMapData map;
IDL_FILE_STAT stat;
FILE *fp;
int unit;
int s;
unit = *( (int32 *) argv[0]);
/* Make sure that the "STDIO" keyword was used to
* open the file in IDL.
*/
s=IDL_FileEnsureStatus(IDL_MSG_RET,unit,IDL_EFS_STDIO);
if (s==FALSE) return -1;
/* Get information about the file */
IDL_FileStat(unit,&stat);
/* Find the file pointer */
fp=stat.fptr;
if (fp==NULL) return -1;
fflush(fp);
/* get the structure pointers */
prm=(struct CnvMapIDLPrm *) argv[1];
stvec=(struct GridIDLStVec *) argv[2];
gvec=(struct GridIDLGVec *) argv[3];
mvec=(struct GridIDLGVec *) argv[4];
coef=(double *) argv[5];
bnd=(struct CnvMapIDLBnd *) argv[6];
memset(&grd,0,sizeof(struct GridData));
memset(&map,0,sizeof(struct CnvMapData));
/* load up the data structures */
grd.st_time=TimeYMDHMSToEpoch(prm->start.yr,prm->start.mo,prm->start.dy,
prm->start.hr,prm->start.mt,prm->start.sc);
grd.ed_time=TimeYMDHMSToEpoch(prm->end.yr,prm->end.mo,prm->end.dy,
prm->end.hr,prm->end.mt,prm->end.sc);
grd.stnum=prm->stnum;
grd.vcnum=prm->vcnum;
grd.xtd=prm->xtd;
map.num_model=prm->modnum;
map.num_coef=prm->coefnum;
map.num_bnd=prm->bndnum;
grd.sdata=malloc(sizeof(struct GridSVec)*grd.stnum);
if (grd.sdata==NULL) return -1;
if (grd.vcnum !=0) {
grd.data=malloc(sizeof(struct GridGVec)*grd.vcnum);
if (grd.data==NULL) {
free(grd.sdata);
return -1;
}
}
if (map.num_model !=0) {
map.model=malloc(sizeof(struct GridGVec)*map.num_model);
if (map.model==NULL) {
if (grd.data !=NULL) free(grd.data);
free(grd.sdata);
return -1;
}
}
if (map.num_coef !=0) {
map.coef=malloc(sizeof(double)*4*map.num_coef);
if (map.coef==NULL) {
if (map.model !=NULL) free(map.model);
if (grd.data !=NULL) free(grd.data);
free(grd.sdata);
return -1;
}
}
if (map.num_bnd !=0) {
map.bnd_lat=malloc(sizeof(double)*map.num_bnd);
if (map.bnd_lat==NULL) {
if (map.coef !=NULL) free(map.coef);
if (map.model !=NULL) free(map.model);
if (grd.data !=NULL) free(grd.data);
free(grd.sdata);
return -1;
}
}
if (map.num_bnd !=0) {
map.bnd_lon=malloc(sizeof(double)*map.num_bnd);
if (map.bnd_lon==NULL) {
if (map.bnd_lat !=NULL) free(map.bnd_lat);
if (map.coef !=NULL) free(map.coef);
if (map.model !=NULL) free(map.model);
if (grd.data !=NULL) free(grd.data);
free(grd.sdata);
return -1;
}
}
map.st_time=grd.st_time;
map.ed_time=grd.ed_time;
map.major_rev=prm->major_rev;
map.minor_rev=prm->minor_rev;
if (prm->source.slen !=0) {
n=prm->source.slen;
if (n>256) n=256;
strncpy(map.source,prm->source.s,n);
}
map.num_model=prm->modnum;
map.doping_level=prm->doping_level;
map.model_wt=prm->model_wt;
map.error_wt=prm->error_wt;
map.imf_flag=prm->imf_flag;
map.imf_delay=prm->imf_delay;
map.Bx=prm->Bx;
map.By=prm->By;
map.Bz=prm->Bz;
if (prm->model[0].slen !=0) {
n=prm->model[0].slen;
if (n>64) n=64;
strncpy(map.imf_model[0],prm->model[0].s,n);
}
if (prm->model[1].slen !=0) {
n=prm->model[1].slen;
if (n>64) n=64;
strncpy(map.imf_model[1],prm->model[1].s,n);
}
map.hemisphere=prm->hemisphere;
map.fit_order=prm->fit_order;
map.latmin=prm->latmin;
map.num_coef=prm->coefnum;
map.chi_sqr=prm->chi_sqr;
map.chi_sqr_dat=prm->chi_sqr_dat;
map.rms_err=prm->rms_err;
map.lon_shft=prm->lon_shft;
map.lat_shft=prm->lat_shft;
map.mlt.start=prm->mlt.st;
map.mlt.end=prm->mlt.ed;
map.mlt.av=prm->mlt.av;
map.pot_drop=prm->pot_drop;
map.pot_drop_err=prm->pot_drop_err;
map.pot_max=prm->pot_max;
map.pot_max_err=prm->pot_max_err;
map.pot_min=prm->pot_min;
map.pot_min_err=prm->pot_min_err;
map.num_bnd=prm->bndnum;
for (n=0;n<grd.stnum;n++) {
grd.sdata[n].st_id=stvec[n].stid;
grd.sdata[n].chn=stvec[n].chn;
grd.sdata[n].npnt=stvec[n].npnt;
grd.sdata[n].freq0=stvec[n].freq;
grd.sdata[n].major_revision=stvec[n].major_revision;
grd.sdata[n].minor_revision=stvec[n].minor_revision;
grd.sdata[n].prog_id=stvec[n].prog_id;
grd.sdata[n].gsct=stvec[n].gsct;
grd.sdata[n].noise.mean=stvec[n].noise.mean;
grd.sdata[n].noise.sd=stvec[n].noise.sd;
grd.sdata[n].vel.min=stvec[n].vel.min;
grd.sdata[n].vel.max=stvec[n].vel.max;
grd.sdata[n].pwr.min=stvec[n].pwr.min;
grd.sdata[n].pwr.max=stvec[n].pwr.max;
grd.sdata[n].wdt.min=stvec[n].wdt.min;
grd.sdata[n].wdt.max=stvec[n].wdt.max;
grd.sdata[n].verr.min=stvec[n].verr.min;
grd.sdata[n].verr.max=stvec[n].verr.max;
}
for (n=0;n<grd.vcnum;n++) {
grd.data[n].st_id=gvec[n].stid;
grd.data[n].chn=gvec[n].chn;
grd.data[n].index=gvec[n].index;
grd.data[n].mlat=gvec[n].mlat;
grd.data[n].mlon=gvec[n].mlon;
grd.data[n].azm=gvec[n].azm;
grd.data[n].vel.median=gvec[n].vel.median;
grd.data[n].vel.sd=gvec[n].vel.sd;
if (grd.xtd !=0) {
grd.data[n].pwr.median=gvec[n].pwr.median;
grd.data[n].pwr.sd=gvec[n].pwr.sd;
grd.data[n].wdt.median=gvec[n].wdt.median;
grd.data[n].wdt.sd=gvec[n].wdt.sd;
}
}
for (n=0;n<map.num_model;n++) {
map.model[n].mlat=mvec[n].mlat;
map.model[n].mlon=mvec[n].mlon;
map.model[n].azm=mvec[n].azm;
map.model[n].vel.median=mvec[n].vel.median;
}
for (n=0;n<map.num_coef;n++) {
map.coef[4*n]=coef[n];
map.coef[4*n+1]=coef[map.num_coef+n];
map.coef[4*n+2]=coef[2*map.num_coef+n];
map.coef[4*n+3]=coef[3*map.num_coef+n];
}
for (n=0;n<map.num_bnd;n++) {
map.bnd_lat[n]=bnd[n].lat;
map.bnd_lon[n]=bnd[n].lon;
}
s=OldCnvMapFwrite(fp,&map,&grd);
free(grd.sdata);
if (grd.data !=NULL) free(grd.data);
if (map.model !=NULL) free(map.model);
if (map.coef !=NULL) free(map.coef);
if (map.bnd_lat !=NULL) free(map.bnd_lat);
if (map.bnd_lon !=NULL) free(map.bnd_lon);
return s;
}
