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;
}
int main(int argc,char *argv[]) {
int drec=2,dnum;
struct RadarParm prm;
struct FitData fit;
struct OldFitFp *fp;
fp=OldFitOpen(argv[1],NULL);
if (fp==NULL) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
OldFitHeaderFwrite(stdout,"Demonstration Code","fitacf","4.00");
while(OldFitRead(fp,&prm,&fit) !=-1) {
fprintf(stderr,"%.4d-%.2d-%.2d %.2d:%.2d:%.2d\n",
prm.time.yr,prm.time.mo,prm.time.dy,
prm.time.hr,prm.time.mt,prm.time.sc);
prm.cp=1000;
dnum=OldFitFwrite(stdout,&prm,&fit,NULL);
drec+=dnum;
}
OldFitClose(fp);
return 0;
}
int main(int argc,char *argv[]) {
struct RadarParm prm;
struct FitData fit;
struct OldFitFp *fp;
if (argc==2)
fp=OldFitOpen(argv[1],NULL);
else
fp=OldFitOpen(argv[1],argv[2]);
if (fp==NULL) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
while(OldFitRead(fp,&prm,&fit) !=-1) {
fprintf(stdout,"%.4d-%.2d-%.2d %.2d:%.2d:%.2d\n",
prm.time.yr,prm.time.mo,prm.time.dy,
prm.time.hr,prm.time.mt,prm.time.sc);
}
OldFitClose(fp);
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 main(int argc,char *argv[]) {
struct RadarParm prm;
struct FitData fit;
struct OldFitFp *fp;
int yr=2004,mo=11,dy=10,hr=12,mt=0;
double sc=0,atme;
int s;
if (argc==2) fp=OldFitOpen(argv[1],NULL);
else fp=OldFitOpen(argv[1],argv[2]);
if (fp==NULL) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
s=OldFitSeek(fp,yr,mo,dy,hr,mt,(int) sc,&atme);
if (s==-1) {
fprintf(stderr,"file does not contain that interval.\n");
exit(-1);
}
fprintf(stdout,"Requested:%.4d-%.2d-%.2d %.2d:%.2d:%.2d\n",
yr,mo,dy,hr,mt,(int) sc);
TimeEpochToYMDHMS(atme,&yr,&mo,&dy,&hr,&mt,&sc);
fprintf(stdout,"Found:%.4d-%.2d-%.2d %.2d:%.2d:%.2d\n",
yr,mo,dy,hr,mt,(int) sc);
while(OldFitRead(fp,&prm,&fit) !=-1) {
fprintf(stdout,"%.4d-%.2d-%.2d %.2d:%.2d:%.2d\n",
prm.time.yr,prm.time.mo,prm.time.dy,
prm.time.hr,prm.time.mt,prm.time.sc);
}
OldFitClose(fp);
return 0;
}
int32 OldFitIDLRead(int argc,char *argv[]) {
int n;
struct OldFitIDLFp *idlfitfp;
struct OldFitFp fitfp;
char combftmp[COMBF_SIZE+1];
struct RadarIDLParm *idlprm;
struct FitIDLData *idlfit;
struct RadarParm prm;
struct FitData fit;
IDL_FILE_STAT stat;
FILE *ffp=NULL,*ifp=NULL;
int s;
/* zero out the data structures */
memset(&prm,0,sizeof(struct RadarParm));
memset(&fit,0,sizeof(struct FitData));
memset(&combftmp,0,COMBF_SIZE+1);
idlfitfp=(struct OldFitIDLFp *) argv[0];
IDL_FileStat(idlfitfp->fitunit,&stat);
/* Find the file pointer */
ffp=stat.fptr;
fflush(ffp);
if (ffp==NULL) return -1;
if (idlfitfp->inxunit !=-1) {
IDL_FileStat(idlfitfp->inxunit,&stat);
ifp=stat.fptr;
}
if (ifp !=NULL) fflush(ifp);
fitfp.fitfp=fileno(ffp);
if (ifp !=NULL) fitfp.inxfp=fileno(ifp);
else fitfp.inxfp=-1;
OldFitIDLToFitFp(idlfitfp,&fitfp);
s=OldFitRead(&fitfp,&prm,&fit);
OldFitFitFpToIDL(&fitfp,idlfitfp);
if (s==-1) return -1;
/* get the structure pointers */
idlprm=(struct RadarIDLParm *) argv[1];
idlfit=(struct FitIDLData *) argv[2];
/* load up the structures.
*
* Note: We do not do a direct memcpy as the possibility
* exists that the IDL data structure is different from
* the C data structure.
*
*/
idlprm->revision.major=prm.revision.major;
idlprm->revision.minor=prm.revision.minor;
idlprm->origin.code=prm.origin.code;
IDL_StrDelete(&idlprm->origin.time,1);
IDL_StrDelete(&idlprm->origin.command,1);
idlprm->cp=prm.cp;
idlprm->stid=prm.stid;
idlprm->time.yr=prm.time.yr;
idlprm->time.mo=prm.time.mo;
idlprm->time.dy=prm.time.dy;
idlprm->time.hr=prm.time.hr;
idlprm->time.mt=prm.time.mt;
idlprm->time.sc=prm.time.sc;
idlprm->time.us=prm.time.us;
idlprm->txpow=prm.txpow;
idlprm->nave=prm.nave;
idlprm->atten=prm.atten;
idlprm->lagfr=prm.lagfr;
idlprm->smsep=prm.smsep;
idlprm->ercod=prm.ercod;
idlprm->stat.agc=prm.stat.agc;
idlprm->stat.lopwr=prm.stat.lopwr;
idlprm->noise.search=prm.noise.search;
idlprm->noise.mean=prm.noise.mean;
idlprm->channel=prm.channel;
idlprm->bmnum=prm.bmnum;
idlprm->bmazm=prm.bmazm;
idlprm->scan=prm.scan;
idlprm->rxrise=prm.rxrise;
idlprm->intt.sc=prm.intt.sc;
idlprm->intt.us=prm.intt.us;
idlprm->txpl=prm.txpl;
idlprm->mpinc=prm.mpinc;
idlprm->mppul=prm.mppul;
idlprm->mplgs=prm.mplgs;
idlprm->nrang=prm.nrang;
idlprm->frang=prm.frang;
idlprm->rsep=prm.rsep;
idlprm->xcf=prm.xcf;
idlprm->tfreq=prm.tfreq;
idlprm->offset=prm.offset;
idlprm->mxpwr=prm.mxpwr;
idlprm->lvmax=prm.lvmax;
for (n=0;n<prm.mppul;n++) idlprm->pulse[n]=prm.pulse[n];
for (n=0;n<prm.mplgs;n++) {
idlprm->lag[n]=prm.lag[n][0];
idlprm->lag[LAG_SIZE+n]=prm.lag[n][1];
}
strncpy(combftmp,prm.combf,COMBF_SIZE);
IDL_StrDelete(&idlprm->combf,1);
IDL_StrStore(&idlprm->combf,combftmp);
idlfit->revision.major=fit.revision.major;
idlfit->revision.minor=fit.revision.minor;
idlfit->noise.sky=fit.noise.skynoise;
idlfit->noise.lag0=fit.noise.lag0;
idlfit->noise.vel=fit.noise.vel;
for (n=0;n<prm.nrang;n++) {
idlfit->pwr0[n]=fit.rng[n].p_0;
idlfit->nlag[n]=fit.rng[n].nump;
idlfit->qflg[n]=fit.rng[n].qflg;
idlfit->gflg[n]=fit.rng[n].gsct;
idlfit->p_l[n]=fit.rng[n].p_l;
idlfit->p_l_e[n]=fit.rng[n].p_l_err;
idlfit->p_s[n]=fit.rng[n].p_s;
idlfit->p_s_e[n]=fit.rng[n].p_s_err;
idlfit->v[n]=fit.rng[n].v;
idlfit->v_e[n]=fit.rng[n].v_err;
idlfit->w_l[n]=fit.rng[n].w_l;
idlfit->w_l_e[n]=fit.rng[n].w_l_err;
idlfit->w_s[n]=fit.rng[n].w_s;
idlfit->w_s_e[n]=fit.rng[n].w_s_err;
idlfit->sd_l[n]=fit.rng[n].sdev_l;
idlfit->sd_s[n]=fit.rng[n].sdev_s;
idlfit->sd_phi[n]=fit.rng[n].sdev_phi;
if (prm.xcf !=0) {
idlfit->elv_low[n]=fit.elv[n].low;
idlfit->elv[n]=fit.elv[n].normal;
idlfit->elv_high[n]=fit.elv[n].high;
idlfit->x_qflg[n]=fit.xrng[n].qflg;
idlfit->x_gflg[n]=fit.xrng[n].gsct;
idlfit->x_p_l[n]=fit.xrng[n].p_l;
idlfit->x_p_l_e[n]=fit.xrng[n].p_l_err;
idlfit->x_p_s[n]=fit.xrng[n].p_s;
idlfit->x_p_s_e[n]=fit.xrng[n].p_s_err;
idlfit->x_v[n]=fit.xrng[n].v;
idlfit->x_v_e[n]=fit.xrng[n].v_err;
idlfit->x_w_l[n]=fit.xrng[n].w_l;
idlfit->x_w_l_e[n]=fit.xrng[n].w_l_err;
idlfit->x_w_s[n]=fit.xrng[n].w_s;
idlfit->x_w_s_e[n]=fit.xrng[n].w_s_err;
idlfit->x_sd_l[n]=fit.xrng[n].sdev_l;
idlfit->x_sd_s[n]=fit.xrng[n].sdev_s;
idlfit->x_sd_phi[n]=fit.xrng[n].sdev_phi;
idlfit->phi0[n]=fit.xrng[n].phi0;
idlfit->phi0_e[n]=fit.xrng[n].phi0_err;
}
}
return s;
}
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;
}
