int main(int argc,char *argv[]) {
FILE *fp;
int yr,mo,dy,hr,mt;
double sc;
fp=fopen(argv[1],"r");
if (fp==NULL) {
fprintf(stderr,"File not found.\n");
exit(-1);
}
while(OldCnvMapFread(fp,&map,&grd) !=-1) {
TimeEpochToYMDHMS(map.st_time,&yr,&mo,&dy,&hr,&mt,&sc);
fprintf(stderr,"%.4d-%.2d-%.2d %.2d:%.2d:%.2d pnts=%d\n",
yr,mo,dy,hr,mt,(int) sc,grd.vcnum);
map.Bx=0.0;
map.By=0.0;
map.Bz=0.0;
OldCnvMapFwrite(stdout,&map,&grd);
}
fclose(fp);
return 0;
}
int main (int argc,char *argv[]) {
int arg;
unsigned char help=0;
unsigned char option=0;
unsigned char vb=0;
FILE *fp;
int yr,mo,dy,hr,mt;
double sc;
int s;
grd=GridMake();
map=CnvMapMake();
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 (CnvMapFread(fp,map,grd) !=-1) {
if (vb) {
TimeEpochToYMDHMS(map->st_time,&yr,&mo,&dy,&hr,&mt,&sc);
fprintf(stderr,"%.4d-%.2d-%.2d %.2d:%.2d:%.2d\n",
yr,mo,dy,hr,mt,(int) sc);
}
s=OldCnvMapFwrite(stdout,map,grd);
}
if (fp !=stdin) fclose(fp);
return 0;
}
static IDL_VPTR IDLOldCnvMapWrite(int argc,IDL_VPTR *argv) {
int s=0;
IDL_LONG unit=0;
IDL_FILE_STAT stat;
struct CnvMapData *map=NULL;
struct GridData *grd=NULL;
struct CnvMapIDLPrm *iprm=NULL;
struct GridIDLStVec *istvec=NULL;
struct GridIDLGVec *igvec=NULL;
struct GridIDLGVec *imvec=NULL;
struct CnvMapIDLBnd *ibnd=NULL;
double *icoef=NULL;
FILE *fp;
IDL_ENSURE_SCALAR(argv[0]);
IDL_ENSURE_STRUCTURE(argv[1]);
IDL_ENSURE_ARRAY(argv[2]);
IDL_ENSURE_ARRAY(argv[3]);
IDL_EXCLUDE_EXPR(argv[1]);
IDL_EXCLUDE_EXPR(argv[2]);
IDL_EXCLUDE_EXPR(argv[3]);
unit=IDL_LongScalar(argv[0]);
s=IDL_FileEnsureStatus(IDL_MSG_RET,unit,IDL_EFS_USER);
if (s==FALSE) {
s=-1;
return (IDL_GettmpLong(s));
}
/* Get information about the file */
IDL_FileFlushUnit(unit);
IDL_FileStat(unit,&stat);
/* Find the file pointer */
fp=stat.fptr;
if (fp==NULL) {
s=-1;
return (IDL_GettmpLong(s));
}
iprm=(struct CnvMapIDLPrm *) argv[1]->value.s.arr->data;
if (argv[2]->type==IDL_TYP_STRUCT)
istvec=(struct GridIDLStVec *) argv[2]->value.s.arr->data;
if (argv[3]->type==IDL_TYP_STRUCT)
igvec=(struct GridIDLGVec *) argv[3]->value.s.arr->data;
if (argv[4]->type==IDL_TYP_STRUCT)
imvec=(struct GridIDLGVec *) argv[4]->value.s.arr->data;
if (argv[5]->type==IDL_TYP_DOUBLE)
icoef=(double *) argv[5]->value.s.arr->data;
if (argv[6]->type==IDL_TYP_STRUCT)
ibnd=(struct CnvMapIDLBnd *) argv[6]->value.s.arr->data;
map=CnvMapMake();
grd=GridMake();
IDLCopyCnvMapPrmFromIDL(iprm,map,grd);
if (istvec !=NULL) IDLCopyGridStVecFromIDL(istvec,iprm->stnum,
argv[2]->value.s.arr->elt_len,grd);
else grd->stnum=0;
if (igvec !=NULL) IDLCopyGridGVecFromIDL(igvec,iprm->vcnum,
argv[3]->value.s.arr->elt_len,grd);
else grd->vcnum=0;
if (imvec !=NULL) IDLCopyCnvMapGVecFromIDL(imvec,
iprm->modnum,argv[4]->value.s.arr->elt_len,map);
else map->num_model=0;
if (ibnd !=NULL) IDLCopyCnvMapBndFromIDL(ibnd,
iprm->bndnum,argv[6]->value.s.arr->elt_len,map);
else map->num_bnd=0;
if (icoef !=NULL) {
int n=0;
map->coef=malloc(sizeof(double)*map->num_coef*4);
for (n=0;n<map->num_coef;n++) {
map->coef[4*n]=icoef[n];
map->coef[4*n+1]= icoef[map->num_coef+n];
map->coef[4*n+2]=icoef[2*map->num_coef+n];
map->coef[4*n+3]=icoef[3*map->num_coef+n];
}
} else map->num_coef=0;
s=OldCnvMapFwrite(fp,map,grd);
CnvMapFree(map);
GridFree(grd);
return (IDL_GettmpLong(s));
}
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;
}
