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