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