void VertexArray::_addNormal(float nx, float ny, float nz)
{
#if defined(HAVE_VISUDEV)
_normals.push_back(nx);
_normals.push_back(ny);
_normals.push_back(nz);
#else
// storing the normals as bytes hurts rendering performance, but it
// significantly reduces the memory footprint
char cx = float2char(nx);
char cy = float2char(ny);
char cz = float2char(nz);
_normals.push_back(cx);
_normals.push_back(cy);
_normals.push_back(cz);
#endif
}
void WriteWaveFile ( float * Data, int datalen, WAVHDR *Hdr, FILE *fp)
{
unsigned char *datachar;
short * datashort;
int SampleNum;
assert(fp);
if (Hdr->BitsPerSample == 8)
{
datachar = float2char(Data, datalen);
fseek(fp, 0, SEEK_END);
fwrite(datachar, datalen, sizeof(char), fp);
free(datachar);
}
else
{
datashort = float2short(Data, datalen);
fseek(fp, 0 , SEEK_END);
fwrite(datashort, datalen, sizeof(short), fp);
free(datashort);
}
}
void wapp2fb(FILE *input, FILE *output) /* includefile */
{
FILE *bptr, *fpou, *alfa[2];
int pixel[2];
double pra, pdec;
double bw, bandwidth, scale, power, hweight, tsamp_us, crate, lmst;
double *lag, *sum, *acf, *window, jan1, days, epoch, ras,des,rahr,dede;
float zerolag,*block,smin,smax;
int doit,i,j,k,two_nlags,nlags,stat,rec_size,idump,swap_bytes,ifnum,opened;
int filesize,headersize,beam,utsecs,iymdf[4],rah,ram,ded,dem;
unsigned char *cblock, zuc;
unsigned short *sblock, zus;
unsigned int zul;
char message[80], outfile[80];
void *dump;
static float realtime=0.0;
#ifdef FFTW
fftw_plan fftplan;
#endif
/* establish whether we need to swap bytes (WAPP is little endian) */
swap_bytes=big_endian();
/* initialise correlator parameters used below */
nlags=nchans;
two_nlags=2*nlags;
bandwidth=foff*nlags;
tsamp_us=tsamp*1.0e6;
if (bandwidth<0.0) bandwidth *= -1.0;
#ifdef FFTW
acf = fftw_malloc(sizeof(double) * two_nlags);
lag = fftw_malloc(sizeof(double) * two_nlags);
/* set up fftw table and acf array when computing power spectra */
fftplan=fftw_plan_r2r_1d(two_nlags,acf,lag,FFTW_R2HC,FFTW_PATIENT);
#endif
#ifndef FFTW
/* set up acf array when computing power spectra */
acf = (double *) malloc(two_nlags * sizeof(double));
lag = (double *) malloc(two_nlags * sizeof(double));
#endif
if (compute_spectra) {
/* ranges for scaling spectra */
smin=0.0;smax=3.0;
} else {
/* ranges for scaling correlation functions */
smin=-0.5;smax=1.0;
}
/* set up the weights for windowing of ACF to monimize FFT leakage */
if (hanning) {
/* Hanning window */
hweight=0.50;
} else if (hamming) {
/* Hamming window */
hweight=0.54;
} else {
/* no window (default) */
hweight=1.00;
}
/* define the smoothing window to be applied base on the above weight */
window = (double *) malloc(nlags * sizeof(double));
for (j=0; j<nlags; j++) window[j]=(hweight+(1.0-hweight)*cos(PI*j/nlags));
/* work out number of IFs to loop over */
if (sumifs && (nifs>1)) {
smin*=2.0;
smax*=2.0;
ifnum=2;
} else {
sumifs=0;
ifnum=nifs;
}
/* calculate required record size for reading - i.e. number of bytes/dump */
rec_size = nifs*nlags*(nbits/8);
dump = malloc(rec_size); /* pointer to the correlator dump */
/* correlator data rate */
crate = 1.0/(tsamp_us-WAPP_DEAD_TIME);
/* scale factor to normalize correlation functions */
if (bandwidth < 50.0)
bw=50.0; /* correct scaling for narrow-band use */
else
bw=bandwidth;
scale = crate/bw;
if (wapp_level==9) scale/=16.0; /* 9-level sampling */
if (wapp_sum) scale/=2.0; /* summed IFs (search mode) */
scale*=pow(2.0,(double)wapp_lagtrunc); /* needed for truncation modes */
/* now define a number of working arrays to store lags and spectra */
block = (float *) malloc(nlags * sizeof(float));
cblock = (unsigned char *) malloc(nlags * sizeof(unsigned char));
sblock = (unsigned short *) malloc(nlags * sizeof(unsigned short));
/* if the file is ALFA data --- do the demultiplexing to two files */
if (wapp_isalfa) {
angle_split(src_raj,&rah,&ram,&ras);
rahr=(double)rah+(double)ram/60.0+(double)ras/3600.0;
angle_split(src_dej,&ded,&dem,&des);
if (ded>0)
dede=(double)ded+(double)dem/60.0+(double)des/3600.0;
else
dede=(double)ded-(double)dem/60.0-(double)des/3600.0;
/* calculate local sidereal time in hours */
lmst=slaGmst(tstart)*12.0/4.0/atan(1.0)-4.4502051459439667;
if (lmst<0.0) lmst+=24.0;
slaDjcal(5,tstart,iymdf,&stat);
slaCaldj(iymdf[0],1,1,&jan1,&stat);
days=tstart-jan1+1.0;
epoch=(double)iymdf[0]+days/365.25;
utsecs=86400*(tstart-floor(tstart));
pixel[0]=(wapp_number-1)*2;
pixel[1]=pixel[0]+1;
puts("opening output files for demultiplexed ALFA data...");
for (i=0; i<2; i++) {
if (alfa_raj[pixel[i]] == 0.0) {
alfa_position(rahr,dede,lmst,epoch,alfa_ang,0.0,0.0,pixel[i],&pra,&pdec);
src_raj=h2hms(pra);
src_dej=deg2dms(pdec);
} else {
src_raj=h2hms(alfa_raj[pixel[i]]);
src_dej=deg2dms(alfa_dej[pixel[i]]);
}
sprintf(outfile,"%s_%.0f_%05d_%04d_%s_%d.fil",
project,floor(tstart),utsecs,
scan_number,source_name,pixel[i]);
alfa[i]=open_file(outfile,"wb");
puts(outfile);
filterbank_header(alfa[i]);
}
beam=0;
}
if (headerfile) {
/* write output ASCII header file */
fpou=open_file("head","w");
fprintf(fpou,"Original WAPP file: %s\n",inpfile);
fprintf(fpou,"Sample time (us): %f\n",tsamp_us);
fprintf(fpou,"Observation time (s): %f\n",wapp_obstime);
fprintf(fpou,"Time stamp (MJD): %18.12f\n",tstart);
fprintf(fpou,"Number of samples/record: %d\n",512);
fprintf(fpou,"Center freq (MHz): %f\n",fch1+(float)nlags*foff/2.0);
fprintf(fpou,"Channel band (kHz): %f\n",bandwidth*1000.0/nlags);
fprintf(fpou,"Number of channels/record: %d\n",nlags);
fprintf(fpou,"Nifs: %d\n",ifnum);
fprintf(fpou,"RA (J2000): %f\n",src_raj);
fprintf(fpou,"DEC (J2000): %f\n",src_dej);
fprintf(fpou,"Gal l: %.4f\n",srcl);
fprintf(fpou,"Gal b: %.4f\n",srcb);
fprintf(fpou,"Name: %s\n",source_name);
fprintf(fpou,"Lagformat: %d\n",wapp_lagformat);
fprintf(fpou,"Sum: %d\n",wapp_sum);
fprintf(fpou,"Level: %d\n",wapp_level);
fprintf(fpou,"AZ at start: %f\n",az_start);
fprintf(fpou,"ZA at start: %f\n",za_start);
fprintf(fpou,"AST at start: %f\n",ast0);
fprintf(fpou,"LST at start: %f\n",lst0);
fprintf(fpou,"Project ID: %s\n",project);
fprintf(fpou,"Observers: %s\n",culprits);
filesize=sizeof_file(inpfile);
fprintf(fpou,"File size (bytes): %d\n",filesize);
headersize=wapp_header_size+wapp_incfile_length;
fprintf(fpou,"Data size (bytes): %d\n",filesize-headersize);
fprintf(fpou,"Number of samples: %d\n",nsamples(inpfile,headersize,nbits,nifs,nchans));
fclose(fpou);
}
/* initialise various counters and flags */
opened=idump=i=j=0;
/* main loop reading data from infile until no more left to read */
while( (stat=read(wapp_file,dump,rec_size)) == rec_size) {
/* calculate elapsed time and determine whether we process this record */
realtime += (float) tsamp;
if ( (doit=process(realtime,start_time,final_time)) == -1) break;
if (doit) {
/* set ALFA beam output if necessary */
if (wapp_isalfa) {
output=alfa[beam]; /* set output file for this loop */
beam=!(beam); /* flip file for next iteration */
}
/* clear zerolag and blocksum arrays */
zerolag=0.0;
for (j=0; j<nlags; j++) block[j]=0.0;
/* loop over the IFs */
for (i=0; i<ifnum; i++) {
if (ifstream[i]=='Y') {
if (zerolagdump) {
/* only interested in the zero lag term for each IF */
switch (nbits) {
case 8:
zuc = *(((unsigned char *)dump)+i*nlags);
zerolag+=zuc;
break;
case 16:
zus = *(((unsigned short *)dump)+i*nlags);
if (swap_bytes) swap_short(&zus);
zerolag+=zus;
break;
case 32:
zul = *(((unsigned int *)dump)+i*nlags);
if (swap_bytes) swap_int(&zul);
zerolag+=zul;
break;
}
/* write out the data checking IF number for summed mode */
if ( (sumifs && (i==1)) || (!sumifs) ) {
if (obits==32) {
if (swapout) swap_float(&zerolag);
fwrite(&zerolag,sizeof(float),1,output);
} else {
sprintf(message,"cannot write %d bits in zerolag mode",obits);
error_message(message);
}
}
} else {
/* fill lag array with scaled CFs */
for (j=0; j<nlags; j++) {
switch (nbits) {
case 8:
zuc = *(((unsigned char *)dump)+j+i*nlags);
lag[j] = scale * (double) zuc - 1.0;
break;
case 16:
zus = *(((unsigned short *)dump)+j+i*nlags);
if (swap_bytes) swap_short(&zus);
lag[j] = scale * (double) zus - 1.0;
break;
case 32:
zul = *(((unsigned int *)dump)+j+i*nlags);
if (swap_bytes) swap_int(&zul);
lag[j] = scale * (double) zul - 1.0;
break;
}
}
/* calculate power and correct for finite level quantization */
power = inv_cerf(lag[0]);
power = 0.1872721836/power/power;
if (i<2) {
if (do_vanvleck) {
if (wapp_level==3) {
/* apply standard 3-level van vleck correction */
vanvleck3lev(lag,nlags);
} else if (wapp_level==9) {
/* apply 9-level van vleck correction */
vanvleck9lev(lag,nlags);
}
}
}
if (compute_spectra) {
/* form windowed even ACF in array */
for(j=1; j<nlags; j++) {
acf[j]=window[j]*lag[j]*power;
acf[two_nlags-j]=acf[j];
}
acf[nlags]=0.0;
acf[0]=lag[0]*power;
/* FFT the ACF (which is real and even) -> real and even FFT */
#ifdef FFTW
fftw_execute(fftplan);
#endif
#ifndef FFTW
rfft(two_nlags,acf,lag);
#endif
/* if the band needs to be flipped --- do it here */
if (wapp_flip) {
/* use acf as temporary array */
for (j=0;j<nlags;j++) acf[j]=lag[j];
k=nlags-1;
for (j=0;j<nlags;j++) {
lag[k]=acf[j];
k--;
}
}
/* add lags to block array */
for (j=0; j<nlags; j++) block[j]+=lag[j];
} else {
/* just copy correlation functions into block */
for (j=0; j<nlags; j++) block[j]=lag[j];
}
/* write out data block checking IF number for summed mode */
if ( (sumifs && (i==1)) || (!sumifs) ) {
if (obits==32) {
if (swapout) for (j=0; j<nlags; j++) swap_float(&block[j]);
fwrite(block,sizeof(float),nlags,output);
} else if (obits==16) {
float2short(block,nlags,smin,smax,sblock);
if (swapout) for (j=0; j<nlags; j++) swap_short(&sblock[j]);
fwrite(sblock,sizeof(unsigned short),nlags,output);
} else if (obits==8) {
float2char(block,nlags,smin,smax,cblock);
fwrite(cblock,sizeof(unsigned char),nlags,output);
} else if (obits==4) {
float2four(block,nlags,smin,smax,cblock);
fwrite(cblock,sizeof(unsigned char),nlags/2,output);
} else {
sprintf(message,"cannot write %d bits in wapp2fb",obits);
error_message(message);
}
}
} /* end of zerolagdump if */
if (!sumifs) { /* reset block and zerolag if not summing */
zerolag=0.0;
for (j=0; j<nlags; j++) block[j]=0.0;
}
} /* end of IFstream if */
} /* end of loop over IFs */
} /* end of processing if */
/* increment dump counter and update logfile every 512 dumps */
idump++;
if (idump%512 == 0) {
if (!opened) {
/* open up logfile */
open_log("filterbank.monitor");
opened=1;
}
sprintf(message,"time:%.1fs",realtime);
update_log(message);
}
} /* end of main read loop*/
/* job done - free up remaining arrays */
free(dump);free(block);free(sblock);free(cblock);free(window);
#ifdef FFTW
fftw_destroy_plan(fftplan);
fftw_free(acf); fftw_free(lag);
#endif
#ifndef FFTW
free(acf); free(lag);
#endif
}
void decimate_data(FILE *input, FILE *output) /*includefile*/
{
char string[80];
float *fblock,min,max,realtime,fsaved[2];
unsigned short *sblock;
unsigned char *cblock;
int nsaved=0,ns,nsblk,opened=0,nout;
nsblk=nchans*nifs*naddt;
fblock=(float *) malloc(nsblk*sizeof(float));
sblock=(unsigned short *) malloc(nsblk*sizeof(unsigned short));
cblock=(unsigned char *) malloc(nsblk*sizeof(unsigned short));
realtime=min=0.0;
max=(float) pow(2.0,(double)obits) -1.0;
/* main decimation loop */
while ((ns=read_block(input,nbits,fblock,nsblk))>0) {
add_channels(fblock,ns,naddc);
add_samples(fblock,nifs,nchans/naddc,naddt);
if (!opened) {
/* open up logfile */
open_log("decimate.monitor");
opened=1;
}
nout=ns/naddt/naddc;
switch (obits) {
case 32:
fwrite(fblock,sizeof(float),nout,output);
break;
case 16:
float2short(fblock,nout,min,max,sblock);
fwrite(sblock,sizeof(unsigned short),nout,output);
break;
case 8:
float2char(fblock,nout,min,max,cblock);
fwrite(cblock,sizeof(unsigned char),nout,output);
break;
case 4:
if (nout==1) {
/* must have at least two samples for four-bit packing save this one */
fsaved[nsaved]=fblock[0];
nsaved++;
if (nsaved==2) {
/* we have 2 saved! write out */
float2four(fsaved,nsaved,min,max,cblock);
fwrite(cblock,sizeof(unsigned char),1,output);
nsaved=0;
}
} else {
/* normal case */
float2four(fblock,nout,min,max,cblock);
fwrite(cblock,sizeof(unsigned char),nout/2,output);
}
break;
case 2:
float2two(fblock,nout,min,max,cblock);
fwrite(cblock,sizeof(unsigned char),nout/4,output);
break;
}
realtime+=(float) tsamp * (float) ns/(float) nchans/(float) nifs;
sprintf(string,"time:%.1fs",realtime);
update_log(string);
}
update_log("finished");
close_log();
}
void bpp2fb(FILE *input, FILE *output) /* includefile */
{
FILE *fpou;
int np,ns,nc,i,c,b,s,nchars,idump,doit,opened,nsblk,i1,i2,*chtab,blocksize;
float *tempblock, *datablock,realtime=0.0;
unsigned char *charblock,sample;
static unsigned char *charcarry;
unsigned short *shortblock;
char string[80];
int nshift[8] = {28,24,20,16,12,8,4,0};
static int ncarryover;
static int first = 1;
static int fileidx_start=1,file_count=1;
static double end_time;
double scantime,sample_start,sample_final;
int sample_skip,bytestart;
int bytefinal,fileidx_final,sample_diff,byte_diff=0;
int bpp_headersize = 32768;
int rd_jnq=0;
double sample_end,byte_end;
np=idump=opened=0;
ns=512;
blocksize=ns*nchans;
nc=nchans;
if(first) {
charcarry = (unsigned char *) malloc(sizeof(unsigned char)*blocksize);
ncarryover = 0;
first = 0;
scantime = (double)((double)bpp_search.file_size)/((double)(nchans/2))*bpp_search.samp_rate*1.e-6;
if(start_time){
fileidx_start = ceil(start_time/scantime);
file_count = fileidx_start;
sample_skip = floor(start_time/tsamp);
sample_start = sample_skip - (double)((fileidx_start-1)*(scantime/(double)tsamp));
bytestart = (sample_start*(double)nchans)/2.;
if(bytestart<blocksize/2){
bytestart+=(double)bpp_search.file_size-blocksize/2;
fileidx_start-=1;
file_count -=1;
sample_skip -= ns;
sample_start = sample_skip - (double)((fileidx_start-1)*(scantime/(double)tsamp));
}
realtime += sample_skip*(double)tsamp - scantime*(fileidx_start-1);
if((rd_jnq =fseek(input,bytestart,SEEK_CUR)< 0)) fprintf(stderr,"Error seeking to data byte %d in file\n",bytestart);
}
if(final_time){
sample_end = ceil(final_time/(double)tsamp);
fileidx_final = ceil(final_time/scantime);
sample_final = sample_end-(double)((fileidx_final-1)*scantime/tsamp);
byte_end = ceil(final_time/(double)tsamp)*(double)nchans/2;
bytefinal = (double)sample_final*(double)nchans/2;
end_time = (double)(byte_end/((double)nchans/2)*(double)tsamp);
fprintf(stderr,"Ending Time: \n");
fprintf(stderr," End File # %2d\n",fileidx_final);
fprintf(stderr," End Sample # %12.3f\n",sample_final);
fprintf(stderr," End Time (s) %12.5f (w.r.t. File # 1)\n",end_time);
if(start_time) {
end_time -= (double)((fileidx_start-1)*scantime);
fprintf(stderr," End Time (s) %12.5f (w.r.t. File # %d)\n",end_time,fileidx_start);
}
}
if (!final_time) end_time = 1000*scantime;
}
tempblock = (float *) malloc(sizeof(float)*blocksize);
datablock = (float *) malloc(sizeof(float)*blocksize);
charblock = (unsigned char *) malloc(sizeof(unsigned char)*blocksize);
shortblock = (unsigned short *) malloc(sizeof(unsigned short)*blocksize);
if (headerfile) {
/* write output ASCII header file */
fpou=open_file("head","w");
fprintf(fpou,"Original BPP file: %s\n",inpfile);
fprintf(fpou,"Sample time (us): %f\n",tsamp*1.0e6);
fprintf(fpou,"Number of samples/record: %d\n",ns);
fprintf(fpou,"Center freq (MHz): %f\n",fch1+(float)nchans*foff/2.0);
fprintf(fpou,"Channel band (kHz): %f\n",fabs(foff)*1000.0);
fprintf(fpou,"Number of channels/record: %d\n",nc);
fprintf(fpou,"Time stamp (MJD): %18.12f\n",tstart);
fprintf(fpou,"AZ at start: %f\n",az_start);
fprintf(fpou,"ZA at start: %f\n",za_start);
fprintf(fpou,"RA (J2000): %f\n",src_raj);
fprintf(fpou,"DEC (J2000): %f\n",src_dej);
fclose(fpou);
}
chtab=bpp_chans(bpp_search.bandwidth,bpp_search.mb_start_address,
bpp_search.mb_end_address,bpp_search.mb_start_board,
bpp_search.mb_end_board,bpp_search.cb_id,
bpp_search.aib_los,bpp_search.dfb_sram_freqs,
bpp_search.rf_lo);
/************************************************/
/* main loop over each record of input data file*/
/************************************************/
while (!feof(input)&& realtime<=end_time) {
/* read in a record */
if(!ncarryover) /* No data left from previous file */
nchars=fread(charblock,sizeof(unsigned char),blocksize/2,input);
if(ncarryover>0) { /* Add to partial block left from previous file */
nchars=fread(charblock,sizeof(unsigned char),(blocksize/2-ncarryover),input);
for(c=0;c<nchars;c++)
charblock[c+ncarryover] = charblock[c];
for(c=0;c<ncarryover;c++)
charblock[c] = charcarry[c];
ncarryover = 0;
nchars = blocksize/2;
fprintf(stderr," Starting at beginning of File # %d\n",file_count);
}
if(!ncarryover && nchars<blocksize/2) { /* Don't process, just keep */
ncarryover = nchars;
for(c=0;c<nchars;c++)
charcarry[c] = charblock[c];
file_count++;
if(final_time) end_time = end_time - (double)tsamp*(int)(scantime/(double)tsamp);
fprintf(stderr,"Advancing to file # %d\n",file_count);
/* if(final_time) fprintf(stderr," End time = %f (w.r.t. file # %d)\n",end_time,file_count);*/
/* fprintf(stderr," Realtime is %f\n",realtime);*/
}
else {
/* decide whether to process it */
if ( (doit=process(realtime,sample_skip*(double)tsamp,end_time)) == -1) {
fprintf(stderr,"realtime at time of break = %f (s)\n ",realtime);
break;
}
doit = 1;
if (doit) {
/* about to process this record, update log */
np++;
if (np%10 == 0) {
if (!opened) {
open_log("filterbank.monitor");
opened=1;
}
sprintf(string,"time:%.1fs",realtime);
update_log(string);
}
/* unscramble the 4-bit data into the float tempblock */
nsblk=0;
for (c=0;c<nchars;c++) {
char2ints(charblock[c],&i1,&i2);
tempblock[nsblk++] = (float) i2;
tempblock[nsblk++] = (float) i1;
}
/* update wallclock time */
realtime+=(float) (nsblk/nchans/nifs) * (float) tsamp;
if (sumifs) for (s=0;s<nsblk;s++) datablock[s]=0.0;
s=i1=i2=0;
/* loop over all samples, summing IFs 1+2 -> total power if neccessary */
while (s<nsblk) {
for (i=0;i<nifs;i++) {
for (c=0;c<nchans;c++) {
if (sumifs) {
if (i<2) datablock[i1+c]+=tempblock[i2+chtab[i*nchans+c]];
} else {
datablock[i1+i*nchans+c]=tempblock[i2+chtab[i*nchans+c]];
}
s++;
}
}
/* update internal counters */
i2+=nifs*nchans;
if (sumifs) {
i1+=nchans;
} else {
i1+=nifs*nchans;
}
}
/* divide by 2 to in sumif mode to allow for 4-bit packing */
if (sumifs) {
nsblk/=nifs;
for (s=0;s<nsblk;s++) datablock[s]/=2.0;
}
/* decide on how to write out data */
if (obits==32) {
/* user has requested floating point numbers in binary file */
if (swapout) for (s=0;s<nsblk;s++) swap_float(&datablock[s]);
fwrite(datablock,sizeof(float),nsblk,output);
} else if (obits==16) {
/* user has requested unsigned shorts in binary file */
float2short(datablock,nsblk,0.0,15.0,shortblock);
if (swapout) for (s=0;s<nsblk;s++) swap_short(&shortblock[s]);
fwrite(shortblock,sizeof(unsigned short),nsblk,output);
} else if (obits==8) {
/* user has requested unsigned chars in binary file */
float2char(datablock,nsblk,0.0,15.0,charblock);
fwrite(charblock,sizeof(unsigned char),nsblk,output);
} else if (obits==4) {
/* default is to write data out packed into character format */
float2four(datablock,nsblk,0.0,15.0,charblock);
fwrite(charblock,sizeof(unsigned char),nsblk/2,output);
}
else {
error_message("unknown bit format for writing");
}
}
/* update dumps read/processed */
idump+=ns;
}
}
}
void pspm2fb(FILE *input, FILE *output) /* includefile */
{
FILE *fpou;
int np=0,ns,nc,c,s,nints,rawdata[PSPM_INT_BLOCK],idump,doit,swap_bytes;
int i,opened=0,drift;
float datablock[PSPM_REA_BLOCK],datablock2[PSPM_REA_BLOCK],sum,realtime;
unsigned char charblock[PSPM_REA_BLOCK],sample;
unsigned short shortblock[PSPM_REA_BLOCK];
char string[80];
/* establish whether this is drift-mode data */
if (pspm_search.HEADER_TYPE == 0) {
drift=1;
} else {
drift=0;
}
idump=0;
/* establish whether we need to swap bytes (PSPM is big endian) */
swap_bytes=little_endian();
/* shorthand for number of samples and channels in a datablock */
ns=PSPM_SAM_BLOCK;
nc=PSPM_NCH_BLOCK;
if (headerfile) {
/* write output ASCII header file */
fpou=open_file("head","w");
fprintf(fpou,"Original PSPM file: %s\n",inpfile);
fprintf(fpou,"Sample time (us): %f\n",tsamp*1.0e6);
fprintf(fpou,"Number of samples/record: %d\n",ns);
fprintf(fpou,"Center freq (MHz): %f\n",fch1+(float)nchans*foff/2.0);
fprintf(fpou,"Channel band (kHz): %f\n",fabs(foff)*1000.0);
fprintf(fpou,"Number of channels/record: %d\n",nc);
fprintf(fpou,"Time stamp (MJD): %18.12f\n",tstart);
fprintf(fpou,"AZ at start: %f\n",az_start);
fprintf(fpou,"ZA at start: %f\n",za_start);
fprintf(fpou,"RA (J2000): %f\n",src_raj);
fprintf(fpou,"DEC (J2000): %f\n",src_dej);
fclose(fpou);
}
/* main loop over each record of input data file*/
while (!feof(input)) {
/* this is the time at that start of the block */
realtime=tsamp*idump;
/* read in a record and unscramble the channels */
nints=fread(rawdata,sizeof(int),PSPM_INT_BLOCK,input);
if ( (doit=process(realtime,start_time,final_time)) == -1) break;
if (doit) {
/* about to process this record, update log */
np++;
if (np%10 == 0) {
if (!opened) {
/* open up logfile */
open_log("filterbank.monitor");
opened=1;
}
sprintf(string,"time:%.1fs",realtime);
update_log(string);
}
if (swap_bytes) for (s=0;s<nints;s++) swap_int(&rawdata[s]);
/* unscramble the channels using Ingrid's C routine */
pspm_decode(rawdata,datablock);
/* if the -invert option was specified, flip the band */
i=0;
if (invert_band) {
for(s=0;s<ns;s++) {
for (c=nc-1;c>=0;c--) {
datablock2[i++]=datablock[s*nc+c];
}
}
for(i=0;i<ns*nc;i++)
datablock[i]=datablock2[i];
}
realtime+=(float) ns * (float) tsamp;
/* decide on how to write out data */
if (obits==32) {
/* user has requested floating point numbers in binary file */
if (swapout) for (s=0;s<ns*nc;s++) swap_float(&datablock[s]);
fwrite(datablock,sizeof(float),ns*nc,output);
} else if (obits==16) {
/* user has requested unsigned shorts in binary file */
float2short(datablock,ns*nc,0.0,15.0,shortblock);
if (swapout) for (s=0;s<ns*nc;s++) swap_short(&shortblock[s]);
fwrite(shortblock,sizeof(unsigned short),ns*nc,output);
} else if (obits==8) {
/* user has requested unsigned chars in binary file */
float2char(datablock,ns*nc,0.0,15.0,charblock);
fwrite(charblock,sizeof(unsigned char),ns*nc,output);
} else if (obits==4) {
/* default is to write data out packed into character format */
float2four(datablock,ns*nc,0.0,15.0,charblock);
fwrite(charblock,sizeof(unsigned char),ns*nc/2,output);
} else if (obits==0) {
/* special mode to write out in different order for old ddsp program */
for (c=0;c<nc;c++) {
for(s=0;s<ns;s++) {
sample=(unsigned char)datablock[s*nc+c];
fwrite(&sample,sizeof(unsigned char),1,output);
}
}
} else {
error_message("unknown bit format for writing");
}
}
/* update dumps read/processed */
idump+=ns;
/* break out if this is in drift-mode and we've read 9 beams */
if (drift && (idump == 4718592)) break;
}
}
