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;
}
}
}
main(int argc, char *argv[])
{
int numerate,i,j,k,l,stream,nsperdmp,nsamps,indexing,indexnow;
int ifchan[16],frchan[4096],ifnum,chnum,ns,charout,sample;
float time_of_pulse, width_of_pulse, time, time_start, time_end;
char message[80],byte;
unsigned char c;
unsigned short s;
float f[8];
/* zero IF and frequency channel arrays */
for (i=0;i<16;i++) ifchan[i]=0;
for (i=0;i<4096;i++) frchan[i]=0;
/* default case is to read from standard input */
input=stdin;
charout=numerate=stream=0;
indexing=1;
/* parse command line if arguments were given */
if (argc>1) {
i=1;
while (i<argc) {
if (strings_equal(argv[i],"help")) {
reader_help();
exit(0);
} else if (strings_equal(argv[1],"version")) {
printf("PROGRAM: %s SIGPROC version: %.1f\n",argv[0],SIGPROC_VERSION);
exit(0);
} else if (strings_equal(argv[i],"-i")) {
i++;
ifchan[atoi(argv[i])-1]=1;
} else if (strings_equal(argv[i],"-c")) {
i++;
frchan[atoi(argv[i])-1]=1;
} else if (strings_equal(argv[i],"-t")) {
i++;
time_of_pulse = atof(argv[i]);
fprintf(stderr,"centering on time %f s\n",time_of_pulse);
} else if (strings_equal(argv[i],"-w")) {
i++;
width_of_pulse = atof(argv[i]);
fprintf(stderr,"with width %f s\n",width_of_pulse);
} else if (strings_equal(argv[i],"-numerate")) {
numerate=1;
} else if (strings_equal(argv[i],"-noindex")) {
indexing=0;
} else if (strings_equal(argv[i],"-stream")) {
stream=1;
} else if (strings_equal(argv[i],"-byte")) {
charout=1;
} else if (file_exists(argv[i])) {
input=open_file(argv[i],"rb");
} else {
reader_help();
sprintf(message,"unknown argument (%s) passed to reader",argv[i]);
error_message(message);
}
i++;
}
}
time_start = time_of_pulse - width_of_pulse/2.;
time_end = time_of_pulse + width_of_pulse/2.;
sample = 0;
/* try to read the header */
if (!read_header(input)) error_message("error reading header\n");
/* check what IF and frequency channels (if any the user has selected) */
j=0;
for (i=0; i<nifs; i++) if (ifchan[i]) j++;
if (j==0) for (i=0; i<nifs; i++) ifchan[i]=1;
j=0;
for (i=0; i<nchans; i++) if (frchan[i]) j++;
if (j==0) for (i=0; i<nchans; i++) frchan[i]=1;
/* number of samples to read per dump */
nsperdmp=nifs*nchans;
/* initialize loop counters and flags */
ifnum=chnum=nsamps=l=0;
indexnow=1;
if (stream && indexing) numerate=1;
while (!feof(input)) {
/* unpack the sample(s) if necessary */
switch (nbits) {
case 1:
fread(&c,1,1,input);
for (i=0;i<8;i++) {
f[i]=c&1;
c>>=1;
}
ns=8;
break;
case 4:
fread(&c,1,1,input);
char2ints(c,&j,&k);
f[0]=(float) j;
f[1]=(float) k;
ns=2;
break;
case 8:
fread(&c,nbits/8,1,input);
f[0]=(float) c;
ns=1;
break;
case 16:
fread(&s,nbits/8,1,input);
f[0]=(float) s;
ns=1;
break;
case 32:
fread(&f[0],nbits/8,1,input);
ns=1;
break;
default:
sprintf(message,"cannot read %d bits per sample...\n",nbits);
error_message(message);
break;
}
for (i=0; i<ns; i++) {
if (charout) {
byte=(char) f[i];
putchar(byte);
} else {
/* time stamp or index the data if needed */
time = (double) tsamp * (double) l;
if (time > time_end) exit(0);
if (indexnow && stream) {
puts("#START");
} else if (indexnow && indexing && time >= time_start && time <= time_end) {
/* if (numerate)
printf("%d ",l);
else
printf("# %f\n",time); */
}
indexnow=0;
/* print sample if it is one of the ones selected */
if (ifchan[ifnum] && frchan[chnum] && time >= time_start && time <= time_end) {
if (stream && numerate) printf("%d ",nsamps);
printf("%d %d %f \n",l,chnum,f[i]);
}
nsamps++;
chnum++;
if (chnum==nchans) {
chnum=0;
ifnum++;
if (ifnum==nifs) ifnum=0;
}
/* put newline and terminator if in streaming mode */
if (stream) {
if ((nsamps%nchans)==0) puts("#STOP");
}
/* put newline if this is the last sample of the dump */
if ((nsamps%nsperdmp)==0) {
nsamps=0;
indexnow=1;
l++;
}
}
}
}
}
main(int argc, char *argv[])
{
FILE *output;
int numerate,i,j,k,l,nsperdmp,nsamps,indexing,plot,indexnow;
int ifchan[16],frchan[4096],ifnum,chnum,ns,sample,ntotal;
float time_of_pulse, width_of_pulse, time, time_start, time_end;
float series_amp[100000],series_time[100000],ampmin,ampmax;
char message[80],outfile[80],filename[80],timestring[80],pgdev[80];
unsigned char c;
unsigned short s;
float f[8];
if (argc<2) {
puts("");
puts("getpulse - make and/or plot a time series from dedispersed file\n");
puts("usage: getpulse {filename} -{options}\n");
puts("filename is the dedispersed data file\n");
puts("options:\n");
puts("-t time - time (in seconds) on which to center time series (REQUIRED)\n");
puts("-w width - width (in seconds) of time series to plot (def=1)\n");
puts("-c fchan - to only output frequency channel fchan (def=all)\n");
puts("-i ifchan - to only output IF channel ifchan (def=all)\n");
puts("-p pgdev - pgplot device (def=/xs)\n");
puts("-numerate - to precede each dump with sample number (def=time)\n");
puts("-noindex - do not precede each dump with time/number\n");
puts("-plot - PGPLOT the results\n");
puts("");
exit(0);
}
/* zero IF and frequency channel arrays */
for (i=0;i<16;i++) ifchan[i]=0;
for (i=0;i<4096;i++) frchan[i]=0;
/* default case is to read from standard input */
input=stdin;
numerate=0;
ampmin = 1.e6;
ampmax = -1.e6;
plot=0;
indexnow=0;
indexing=1;
strcpy(pgdev,"/xs");
/* parse command line if arguments were given */
if (argc>1) {
i=1;
while (i<argc) {
if (strings_equal(argv[i],"-i")) {
i++;
ifchan[atoi(argv[i])-1]=1;
} else if (strings_equal(argv[i],"-c")) {
i++;
frchan[atoi(argv[i])-1]=1;
} else if (strings_equal(argv[i],"-t")) {
i++;
time_of_pulse = atof(argv[i]);
strcpy(timestring,argv[i]);
fprintf(stderr,"centering on time %f s\n",time_of_pulse);
} else if (strings_equal(argv[i],"-w")) {
i++;
width_of_pulse = atof(argv[i]);
fprintf(stderr,"with width %f s\n",width_of_pulse);
} else if (strings_equal(argv[i],"-p")) {
i++;
strcpy(pgdev,argv[i]);
} else if (strings_equal(argv[i],"-numerate")) {
numerate=1;
} else if (strings_equal(argv[i],"-noindex")) {
indexing=0;
} else if (strings_equal(argv[i],"-plot")) {
plot=1;
} else if (file_exists(argv[i])) {
input=open_file(argv[i],"rb");
strcpy(filename,argv[i]);
} else {
sprintf(message,"unknown argument (%s) passed to getpulse",argv[i]);
error_message(message);
}
i++;
}
}
strcat(filename,".pulse.");
strcat(filename,timestring);
strcpy(outfile,filename);
output=fopen(outfile,"w");
time_start = time_of_pulse - width_of_pulse/2.;
time_end = time_of_pulse + width_of_pulse/2.;
sample = 0;
/* try to read the header */
if (!read_header(input)) error_message("error reading header\n");
/* check what IF and frequency channels (if any the user has selected) */
j=0;
for (i=0; i<nifs; i++) if (ifchan[i]) j++;
if (j==0) for (i=0; i<nifs; i++) ifchan[i]=1;
j=0;
for (i=0; i<nchans; i++) if (frchan[i]) j++;
if (j==0) for (i=0; i<nchans; i++) frchan[i]=1;
/* number of samples to read per dump */
nsperdmp=nifs*nchans;
/* initialize loop counters and flags */
ifnum=chnum=nsamps=l=0;
while (!feof(input)) {
/* unpack the sample(s) if necessary */
switch (nbits) {
case 1:
fread(&c,1,1,input);
for (i=0;i<8;i++) {
f[i]=c&1;
c>>=1;
}
ns=8;
break;
case 4:
fread(&c,1,1,input);
char2ints(c,&j,&k);
f[0]=(float) j;
f[1]=(float) k;
ns=2;
break;
case 8:
fread(&c,nbits/8,1,input);
f[0]=(float) c;
ns=1;
break;
case 16:
fread(&s,nbits/8,1,input);
f[0]=(float) s;
ns=1;
break;
case 32:
fread(&f[0],nbits/8,1,input);
ns=1;
break;
default:
sprintf(message,"cannot read %d bits per sample...\n",nbits);
error_message(message);
break;
}
if (plot) {
ntotal = (time_end-time_start)/tsamp;
if (ntotal > 100000) {
fprintf(stderr,"Too many samples to plot!\n");
plot=0;
}
}
for (i=0; i<ns; i++) {
/* time stamp or index the data */
time = (double) tsamp * (double) l;
if (time > time_end) {
if (plot) {
indexnow=indexnow-1;
cpgbeg(0,pgdev,1,1);
cpgsvp(0.1,0.9,0.1,0.9);
cpgswin(series_time[0],series_time[indexnow],ampmin-0.1*ampmax,ampmax+0.1*ampmax);
cpgbox("bcnst",0.0,0,"bcnst",0,0.0);
cpgline(indexnow,series_time,series_amp);
cpgscf(2);
cpgmtxt("B",2.5,0.5,0.5,"Time (s)");
cpgmtxt("L",1.8,0.5,0.5,"Amplitude");
cpgend();}
exit(0);
}
/* print sample if it is one of the ones selected */
if (ifchan[ifnum] && frchan[chnum] && time >= time_start && time <= time_end) {
if (indexing) {
if (numerate) fprintf(output,"%d %f\n",l,f[i]);
else fprintf(output,"%f %f\n",time,f[i]);
}
else {
fprintf(output,"%f\n",f[i]);
}
if (plot) {
series_amp[indexnow]=f[i];
series_time[indexnow]=time;
if (f[i] < ampmin) ampmin = f[i];
if (f[i] > ampmax) ampmax = f[i];
indexnow++;
}
}
nsamps++;
chnum++;
if (chnum==nchans) {
chnum=0;
ifnum++;
if (ifnum==nifs) ifnum=0;
}
if ((nsamps%nsperdmp)==0) {
nsamps=0;
l++;
}
}
}
fclose(output);
}
int read_block(FILE *input, int nbits, float *block, int nread) /*includefile*/
{
int i,j,k,s1,s2,s3,s4,iread;
unsigned char *charblock;
unsigned short *shortblock;
long seed=0;
/* decide how to read the data based on the number of bits per sample */
switch(nbits) {
case 1:
/* read n/8 bytes into character block containing n 1-bit pairs */
charblock=(unsigned char *) malloc(nread/8);
iread=fread(charblock,1,nread/8,input);
k=0;
/* unpack 1-bit pairs into the datablock */
for (i=0; i<iread; i++) {
for (j=0;j<8;j++) {
block[k++]=charblock[i]&1;
charblock[i]>>=1;
}
}
iread=k; /* this is the number of samples read in */
free(charblock);
break;
case 2:
/* read n/4 bytes into character block containing n 2-bit pairs */
charblock=(unsigned char *) malloc(nread/4);
iread=fread(charblock,1,nread/4,input);
j=0;
/* unpack 2-bit pairs into the datablock */
for (i=0; i<iread; i++) {
char2fourints(charblock[i],&s1,&s2,&s3,&s4);
block[j++]=(float) s1;
block[j++]=(float) s2;
block[j++]=(float) s3;
block[j++]=(float) s4;
}
iread*=4; /* this is the number of samples read in */
free(charblock);
break;
case 4:
/* read n/2 bytes into character block containing n 4-bit pairs */
charblock=(unsigned char *) malloc(nread/2);
iread=fread(charblock,1,nread/2,input);
j=0;
/* unpack 4-bit pairs into the datablock */
for (i=0; i<iread; i++) {
char2ints(charblock[i],&s1,&s2);
block[j++]=(float) s1;
block[j++]=(float) s2;
}
iread*=2; /* this is the number of samples read in */
free(charblock);
break;
case 8:
/* read n bytes into character block containing n 1-byte numbers */
charblock=(unsigned char *) malloc(nread);
iread=fread(charblock,1,nread,input);
/* copy numbers into datablock */
for (i=0; i<iread; i++) {
block[i]=(float) charblock[i];
}
free(charblock);
break;
case 16:
/* read 2*n bytes into short block containing n 2-byte numbers */
shortblock=(unsigned short *) malloc(2*nread);
iread=fread(shortblock,2,nread,input);
/* copy numbers into datablock */
for (i=0; i<iread; i++) {
block[i]=(float) shortblock[i];
}
free(shortblock);
break;
case 32:
/* read 4*n bytes into floating block containing n 4-byte numbers */
iread=fread(block,4,nread,input);
break;
default:
error_message("read_block - nbits can only be 4,8,16 or 32!");
}
/* return number of samples read */
return iread;
}