int32 OldRawIDLRead(int argc,char *argv[]) {
int n;
int x;
struct OldRawIDLFp *idlrawfp;
struct OldRawFp rawfp;
char combftmp[COMBF_SIZE+1];
struct RadarIDLParm *idlprm;
struct RawIDLData *idlraw;
struct RadarParm prm;
struct RawData raw;
IDL_FILE_STAT stat;
FILE *fp;
int s;
/* zero out the data structures */
memset(&prm,0,sizeof(struct RadarParm));
memset(&raw,0,sizeof(struct RawData));
memset(&combftmp,0,COMBF_SIZE+1);
idlrawfp=(struct OldRawIDLFp *) argv[0];
IDL_FileStat(idlrawfp->rawunit,&stat);
/* Find the file pointer */
fp=stat.fptr;
if (fp==NULL) return -1;
fflush(fp);
rawfp.rawfp=fileno(fp);
rawfp.inxfp=0;
OldRawIDLToRawFp(idlrawfp,&rawfp);
s=OldRawRead(&rawfp,&prm,&raw);
OldRawRawFpToIDL(&rawfp,idlrawfp);
if (s==-1) return -1;
/* get the structure pointers */
idlprm=(struct RadarIDLParm *) argv[1];
idlraw=(struct RawIDLData *) 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);
idlraw->revision.major=raw.revision.major;
idlraw->revision.minor=raw.revision.minor;
idlraw->thr=raw.thr;
for (n=0;n<prm.nrang;n++) {
idlraw->pwr0[n]=raw.pwr0[n];
for (x=0;x<prm.mplgs;x++) {
idlraw->acfd[x*MAX_RANGE+n]=raw.acfd[n][x][0];
idlraw->acfd[LAG_SIZE*MAX_RANGE+MAX_RANGE*x+n]=raw.acfd[n][x][1];
if (prm.xcf !=0) {
idlraw->xcfd[x*MAX_RANGE+n]=raw.xcfd[n][x][0];
idlraw->xcfd[LAG_SIZE*MAX_RANGE+MAX_RANGE*x+n]=raw.xcfd[n][x][1];
}
}
}
return s;
}
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;
}
int32 OldCnvMapIDLDecode(int argc,char *argv[]) {
int n;
int yr,mo,dy,hr,mt;
double sc;
unsigned char *ptr;
struct CnvMapIDLPrm *prm;
struct GridIDLStVec *stvec;
struct GridIDLGVec *gvec;
struct CnvMapData *map;
struct GridData *grd;
struct GridIDLGVec *mvec;
double *coef;
struct CnvMapIDLBnd *bnd;
char tmp[257];
memset(tmp,0,257);
ptr=((IDL_STRING *) argv[0])->s;
grd=(struct GridData *) (ptr);
ptr+=sizeof(struct GridData);
grd->sdata=(struct GridSVec *) (ptr);
ptr+=grd->stnum*sizeof(struct GridSVec);
grd->data=(struct GridGVec *) (ptr);
ptr+=grd->vcnum*sizeof(struct GridGVec);
map=(struct CnvMapData *) (ptr);
ptr+=sizeof(struct CnvMapData);
map->model=(struct GridGVec *) (ptr);
ptr+=map->num_model*sizeof(struct GridGVec);
map->coef=(double *) (ptr);
ptr+=map->num_coef*4*sizeof(double);
map->bnd_lat=(double *) (ptr);
ptr+=map->num_bnd*sizeof(double);
map->bnd_lon=(double *) (ptr);
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];
prm->stnum=grd->stnum;
prm->vcnum=grd->vcnum;
prm->xtd=grd->xtd;
TimeEpochToYMDHMS(grd->st_time,&yr,&mo,
&dy,&hr,&mt,
&sc);
prm->start.yr=yr;
prm->start.mo=mo;
prm->start.dy=dy;
prm->start.hr=hr;
prm->start.mt=mt;
prm->start.sc=sc;
TimeEpochToYMDHMS(grd->ed_time,&yr,&mo,
&dy,&hr,&mt,
&sc);
prm->end.yr=yr;
prm->end.mo=mo;
prm->end.dy=dy;
prm->end.hr=hr;
prm->end.mt=mt;
prm->end.sc=sc;
prm->major_rev=map->major_rev;
prm->minor_rev=map->minor_rev;
IDL_StrDelete(&prm->source,1);
if (map->source !=NULL) {
strncpy(tmp,map->source,256);
IDL_StrStore(&prm->source,tmp);
}
prm->modnum=map->num_model;
prm->doping_level=map->doping_level;
prm->model_wt=map->model_wt;
prm->error_wt=map->error_wt;
prm->imf_flag=map->imf_flag;
prm->imf_delay=map->imf_delay;
prm->Bx=map->Bx;
prm->By=map->By;
prm->Bz=map->Bz;
IDL_StrDelete(&prm->model[0],1);
if (map->imf_model[0] !=NULL) {
strncpy(tmp,map->imf_model[0],64);
IDL_StrStore(&prm->model[0],tmp);
}
IDL_StrDelete(&prm->model[1],1);
if (map->imf_model[1] !=NULL) {
strncpy(tmp,map->imf_model[1],64);
IDL_StrStore(&prm->model[1],tmp);
}
prm->hemisphere=map->hemisphere;
prm->fit_order=map->fit_order;
prm->latmin=map->latmin;
prm->coefnum=map->num_coef;
prm->chi_sqr=map->chi_sqr;
prm->chi_sqr_dat=map->chi_sqr_dat;
prm->rms_err=map->rms_err;
prm->lon_shft=map->lon_shft;
prm->lat_shft=map->lat_shft;
prm->mlt.st=map->mlt.start;
prm->mlt.ed=map->mlt.end;
prm->mlt.av=map->mlt.av;
prm->pot_drop=map->pot_drop;
prm->pot_drop_err=map->pot_drop_err;
prm->pot_max=map->pot_max;
prm->pot_max_err=map->pot_max_err;
prm->pot_min=map->pot_min;
prm->pot_min_err=map->pot_min_err;
prm->bndnum=map->num_bnd;
for (n=0;n<grd->stnum;n++) {
stvec[n].stid=grd->sdata[n].st_id;
stvec[n].chn=grd->sdata[n].chn;
stvec[n].npnt=grd->sdata[n].npnt;
stvec[n].freq=grd->sdata[n].freq0;
stvec[n].major_revision=grd->sdata[n].major_revision;
stvec[n].minor_revision=grd->sdata[n].minor_revision;
stvec[n].prog_id=grd->sdata[n].prog_id;
stvec[n].gsct=grd->sdata[n].gsct;
stvec[n].noise.mean=grd->sdata[n].noise.mean;
stvec[n].noise.sd=grd->sdata[n].noise.sd;
stvec[n].vel.min=grd->sdata[n].vel.min;
stvec[n].vel.max=grd->sdata[n].vel.max;
stvec[n].pwr.min=grd->sdata[n].pwr.min;
stvec[n].pwr.max=grd->sdata[n].pwr.max;
stvec[n].wdt.min=grd->sdata[n].wdt.min;
stvec[n].wdt.max=grd->sdata[n].wdt.max;
stvec[n].verr.min=grd->sdata[n].verr.min;
stvec[n].verr.max=grd->sdata[n].verr.max;
}
for (n=0;n<grd->vcnum;n++) {
gvec[n].stid=grd->data[n].st_id;
gvec[n].chn=grd->data[n].chn;
gvec[n].index=grd->data[n].index;
gvec[n].mlat=grd->data[n].mlat;
gvec[n].mlon=grd->data[n].mlon;
gvec[n].azm=grd->data[n].azm;
gvec[n].vel.median=grd->data[n].vel.median;
gvec[n].vel.sd=grd->data[n].vel.sd;
if (grd->xtd !=0) {
gvec[n].pwr.median=grd->data[n].pwr.median;
gvec[n].pwr.sd=grd->data[n].pwr.sd;
gvec[n].wdt.median=grd->data[n].wdt.median;
gvec[n].wdt.sd=grd->data[n].wdt.sd;
}
}
for (n=0;n<map->num_model;n++) {
mvec[n].mlat=map->model[n].mlat;
mvec[n].mlon=map->model[n].mlon;
mvec[n].azm=map->model[n].azm;
mvec[n].vel.median=map->model[n].vel.median;
}
for (n=0;n<map->num_coef;n++) {
coef[n]=map->coef[4*n];
coef[map->num_coef+n]=map->coef[4*n+1];
coef[2*map->num_coef+n]=map->coef[4*n+2];
coef[3*map->num_coef+n]=map->coef[4*n+3];
}
for (n=0;n<map->num_bnd;n++) {
bnd[n].lat=map->bnd_lat[n];
bnd[n].lon=map->bnd_lon[n];
}
return 0;
}
