void get_rawbin_cand(char *filenm, int candnum, rawbincand * cand)
/* Read the rawbin candidate file 'filenm' and return a */
/* pointer to the rawbincand that describe it. */
{
FILE *candfile;
candfile = chkfopen(filenm, "rb");
chkfileseek(candfile, candnum - 1, sizeof(rawbincand), SEEK_SET);
chkfread(cand, sizeof(rawbincand), 1, candfile);
fclose(candfile);
}
void get_rzw_cand(char *filenm, int candnum, fourierprops * cand)
/* Read the rzw candidate file 'filenm' and return a */
/* pointer to the fourierprops that describes it. */
{
FILE *candfile;
candfile = chkfopen(filenm, "rb");
chkfileseek(candfile, candnum - 1, sizeof(fourierprops), SEEK_SET);
chkfread(cand, sizeof(fourierprops), 1, candfile);
fclose(candfile);
}
float get_numphotons(FILE * file)
/* Return the total number of photons in the FFT file */
/* i.e. it returns the value of the 0th frequency bin. */
/* Arguments: */
/* 'file' is a pointer to the file you want to access. */
{
float nph;
chkfileseek(file, 0, sizeof(fcomplex), SEEK_SET);
chkfread(&nph, sizeof(float), 1, file);
/* The following protects against pre-normalized time-series */
if (nph <= 0)
nph = 1.0;
return nph;
}
int main(int argc, char *argv[])
{
float *data;
int status, isign;
unsigned long numdata;
/* unsigned long next2ton; */
FILE *datafile, *scratchfile;
char datafilenm[100], scratchfilenm[100], resultfilenm[100];
char command[80];
struct tms runtimes;
double ttim, stim, utim, tott;
tott = times(&runtimes) / (double) CLK_TCK;
printf("\n\n");
printf(" Real-Valued Data FFT Program v2.0\n");
printf(" by Scott M. Ransom\n");
printf(" 8 June, 1997\n\n");
if ((argc > 1) && (argc < 7)) {
/* Open and check data file. */
if (argc == 3) {
sprintf(datafilenm, "%s.", argv[2]);
sprintf(scratchfilenm, "%s.tmp", argv[2]);
sprintf(resultfilenm, "%s.", argv[2]);
}
if (argc == 4) {
sprintf(datafilenm, "%s/%s.", argv[3], argv[2]);
sprintf(scratchfilenm, "%s/%s.tmp", argv[3], argv[2]);
sprintf(resultfilenm, "%s/%s.", argv[3], argv[2]);
}
if (argc == 5) {
sprintf(datafilenm, "%s/%s.", argv[3], argv[2]);
sprintf(scratchfilenm, "%s/%s.tmp", argv[4], argv[2]);
sprintf(resultfilenm, "%s/%s.", argv[3], argv[2]);
}
isign = atoi(argv[1]);
/* Add the appropriate suffix to the filenames. */
if (isign == 1) {
strcat(datafilenm, "fft");
strcat(resultfilenm, "dat");
} else {
strcat(datafilenm, "dat");
strcat(resultfilenm, "fft");
}
/* Check the input data set... */
printf("Checking data in \"%s\".\n", datafilenm);
datafile = chkfopen(datafilenm, "rb");
/* # of real data points */
numdata = chkfilelen(datafile, sizeof(float));
/* next2ton = next2_to_n(numdata); */
/* if (numdata != next2ton) { */
/* printf("\nNumber of data pts must be an integer power of two,\n"); */
/* printf(" or data must be single precision floats.\n"); */
/* printf("Exiting.\n\n"); */
/* fclose(datafile); */
/* exit(1); */
/* } */
printf("Data OK. There are %ld points.\n\n", numdata);
fclose(datafile);
} else {
printf("\nUsage: realfft sign datafilename [ data path] ");
printf("[scratch path]\n\n");
printf(" This program calculates the FFT of a file containing\n");
printf(" a power-of-two number of floats representing\n");
printf(" real numbers. (i.e. a normal time series)\n\n");
printf(" THE INPUT FILE WILL BE OVERWRITTEN.\n\n");
printf(" \"sign\" is the sign of the exponential during the FFT. \n");
printf(" (i.e. -1 is the standard forward transform, 1 is the\n");
printf(" inverse transform times N (the number of floats))\n");
printf(" If both paths are omitted, the data is assumed to be\n");
printf(" located in the working directory, and the scratch space\n");
printf(" if needed will be located there. If only one path is\n");
printf(" given, both input and scratch files will reside there.\n\n");
printf(" Notes:\n");
printf(" - datafilename must not include \".dat\" or \".fft\"\n");
printf(" suffix. It will be added by the program.\n");
printf(" - Do not end paths in \"/\".\n");
printf(" - The scratch file is the same size as the input file.\n");
printf(" - If \"sign\"=1, the file to be transformed should end\n");
printf(" with \".fft\". Otherwise, it should end with\n");
printf(" \".dat\".\n\n");
exit(0);
}
/* Start the transform sequence */
if (numdata > MAXREALFFT) {
/* Perform Two-Pass, Out-of-Core, FFT */
printf("Performing Out-of-Core Two-Pass FFT on data.\n\n");
printf("Result will be stored in the file \"%s\".\n", resultfilenm);
/* Initialize files. */
datafile = chkfopen(datafilenm, "rb+");
scratchfile = chkfopen(scratchfilenm, "wb+");
printf("\nTransforming...\n");
/* Call Two-Pass routine */
if (isign == 1) {
realfft_scratch_inv(datafile, scratchfile, numdata);
} else {
realfft_scratch_fwd(datafile, scratchfile, numdata);
}
fclose(scratchfile);
sprintf(command, "rm -f %s\n", scratchfilenm);
if ((status = (system(command))) == -1 || status == 127) {
perror("\nSystem call (rm) failed");
printf("\n");
exit(1);
}
printf("Finished.\n\n");
printf("Timing summary:\n");
tott = times(&runtimes) / (double) CLK_TCK - tott;
utim = runtimes.tms_utime / (double) CLK_TCK;
stim = runtimes.tms_stime / (double) CLK_TCK;
ttim = utim + stim;
printf("CPU usage: %.3f sec total (%.3f sec user, %.3f sec system)\n",
ttim, utim, stim);
printf("Total time elapsed: %.3f sec.\n\n", tott);
} else {
/* Perform standard FFT for real functions */
printf("Performing in-core FFT for real functions on data.\n\n");
printf("FFT will be stored in the file \"%s\".\n\n", resultfilenm);
/* Open the data and fft results files. */
datafile = chkfopen(datafilenm, "rb+");
/* Read data from file to data array */
printf("Reading data.\n\n");
data = gen_fvect(numdata);
chkfread(data, sizeof(float), (unsigned long) numdata, datafile);
chkfileseek(datafile, 0L, sizeof(char), SEEK_SET);
/* Start and time the transform */
printf("Transforming...\n");
realfft(data, numdata, isign);
printf("Finished.\n\n");
/* Write data from FFT array to file */
printf("Writing FFT data.\n\n");
chkfwrite(data, sizeof(float), (unsigned long) numdata, datafile);
vect_free(data);
/* Output the timing information */
printf("Timing summary:\n");
tott = times(&runtimes) / (double) CLK_TCK - tott;
utim = runtimes.tms_utime / (double) CLK_TCK;
stim = runtimes.tms_stime / (double) CLK_TCK;
ttim = utim + stim;
printf("CPU usage: %.3f sec total (%.3f sec user, %.3f sec system)\n",
ttim, utim, stim);
printf("Total time elapsed: %.3f sec.\n\n", tott);
}
sprintf(command, "mv %s %s\n", datafilenm, resultfilenm);
if ((status = (system(command))) == -1 || status == 127) {
perror("\nSystem call (mv) failed");
printf("\n");
exit(1);
}
fclose(datafile);
/*
fftw_print_max_memory_usage();
fftw_check_memory_leaks();
*/
exit(0);
}
multifile *fopen_multifile(int numfiles, char **filenames, char *mode,
long long maxlen)
/* Open a multifile for use and return the multifile structure. */
/* 'numfiles' is the number of files in the multifile. */
/* 'filenames' is an array of the names of the component files */
/* 'mode' is the method of opening the file (binary is assumed) */
/* "r" : read only, do not create (truncate) the files */
/* "r+": read+write, do not create (truncate) the files */
/* "w" : read+write, create (truncate) the files */
/* "a" : read+write, create files or open at end of files */
/* 'maxlen' is the maximum length in bytes of each file. This */
/* number is only used if a file is opened fo writing. The */
/* default value is DEFAULT_MAXLEN. If you want to use */
/* the default, simply set 'maxlen' to 0. */
{
multifile *mfile;
int ii, append = 0;
mfile = (multifile *) malloc(sizeof(multifile));
mfile->numfiles = numfiles;
mfile->currentfile = 0;
mfile->currentpos = 0;
mfile->length = 0;
mfile->position = 0;
if (maxlen > 0)
mfile->maxfilelen = maxlen;
else
mfile->maxfilelen = DEFAULT_MAXLEN;
mfile->filelens = (long long *) malloc(numfiles * sizeof(long long));
mfile->filenames = (char **) malloc(numfiles * sizeof(char *));
mfile->fileptrs = (FILE **) malloc(numfiles * sizeof(FILE *));
if (strncmp(mode, "r", 1) == 0) {
if (strncmp(mode, "r+", 2) == 0) {
strcpy(mfile->mode, "rb+");
} else {
strcpy(mfile->mode, "rb");
}
} else if (strncmp(mode, "w", 1) == 0) {
if (strncmp(mode, "w+", 2) == 0) {
strcpy(mfile->mode, "wb+");
} else {
strcpy(mfile->mode, "wb");
}
} else if (strncmp(mode, "a", 1) == 0) {
if (strncmp(mode, "a+", 2) == 0) {
strcpy(mfile->mode, "ab+");
} else {
strcpy(mfile->mode, "ab");
}
append = 1;
} else {
printf("\n'mode' = '%s' in open_multifile() is not valid.\n\n", mode);
return NULL;
}
for (ii = 0; ii < numfiles; ii++) {
mfile->filenames[ii] = (char *) calloc(strlen(filenames[ii]) + 1, 1);
strcpy(mfile->filenames[ii], filenames[ii]);
mfile->fileptrs[ii] = chkfopen(filenames[ii], mfile->mode);
mfile->filelens[ii] = chkfilelen(mfile->fileptrs[ii], 1);
mfile->length += mfile->filelens[ii];
}
if (append) {
mfile->currentfile = numfiles - 1;
chkfileseek(mfile->fileptrs[mfile->currentfile], 0, 1, SEEK_END);
}
return mfile;
}
int main(int argc, char *argv[])
{
FILE *fftfile, *candfile = NULL, *psfile = NULL;
char filenm[100], candnm[100], psfilenm[120];
float locpow, norm, powargr, powargi;
float *powr, *spreadpow, *minizoompow, *freqs;
fcomplex *data, *minifft, *minizoom, *spread;
fcomplex *resp, *kernel;
double T, dr, ftobinp;
int ii, nbins, ncands, candnum, lofreq = 0, nzoom, numsumpow = 1;
int numbetween, numkern, kern_half_width;
binaryprops binprops;
infodata idata;
if (argc < 3 || argc > 6) {
usage();
exit(1);
}
printf("\n\n");
printf(" Binary Candidate Display Routine\n");
printf(" by Scott M. Ransom\n\n");
/* Initialize the filenames: */
sprintf(filenm, "%s.fft", argv[1]);
sprintf(candnm, "%s_bin.cand", argv[1]);
/* Read the info file */
readinf(&idata, argv[1]);
if (idata.object) {
printf("Plotting a %s candidate from '%s'.\n", idata.object, filenm);
} else {
printf("Plotting a candidate from '%s'.\n", filenm);
}
T = idata.N * idata.dt;
/* Open the FFT file and get its length */
fftfile = chkfopen(filenm, "rb");
nbins = chkfilelen(fftfile, sizeof(fcomplex));
/* Open the candidate file and get its length */
candfile = chkfopen(candnm, "rb");
ncands = chkfilelen(candfile, sizeof(binaryprops));
/* The candidate number to examine */
candnum = atoi(argv[2]);
/* Check that candnum is in range */
if ((candnum < 1) || (candnum > ncands)) {
printf("\nThe candidate number is out of range.\n\n");
exit(1);
}
/* The lowest freq present in the FFT file */
if (argc >= 4) {
lofreq = atoi(argv[3]);
if ((lofreq < 0) || (lofreq > nbins - 1)) {
printf("\n'lofreq' is out of range.\n\n");
exit(1);
}
}
/* Is the original FFT a sum of other FFTs with the amplitudes added */
/* in quadrature? (i.e. an incoherent sum) */
if (argc >= 5) {
numsumpow = atoi(argv[4]);
if (numsumpow < 1) {
printf("\nNumber of summed powers must be at least one.\n\n");
exit(1);
}
}
/* Initialize PGPLOT using Postscript if requested */
if ((argc == 6) && (!strcmp(argv[5], "ps"))) {
sprintf(psfilenm, "%s_bin_cand_%d.ps", argv[1], candnum);
cpgstart_ps(psfilenm, "landscape");
} else {
cpgstart_x("landscape");
}
/* Read the binary candidate */
chkfileseek(candfile, (long) (candnum - 1), sizeof(binaryprops), SEEK_SET);
chkfread(&binprops, sizeof(binaryprops), 1, candfile);
fclose(candfile);
/* Output the binary candidate */
print_bin_candidate(&binprops, 2);
/* Allocate some memory */
powr = gen_fvect(binprops.nfftbins);
minifft = gen_cvect(binprops.nfftbins / 2);
spread = gen_cvect(binprops.nfftbins);
spreadpow = gen_fvect(binprops.nfftbins);
nzoom = 2 * ZOOMFACT * ZOOMNEIGHBORS;
minizoom = gen_cvect(nzoom);
minizoompow = gen_fvect(nzoom);
/* Allocate and initialize our interpolation kernel */
numbetween = 2;
kern_half_width = r_resp_halfwidth(LOWACC);
numkern = 2 * numbetween * kern_half_width;
resp = gen_r_response(0.0, numbetween, numkern);
kernel = gen_cvect(binprops.nfftbins);
place_complex_kernel(resp, numkern, kernel, binprops.nfftbins);
COMPLEXFFT(kernel, binprops.nfftbins, -1);
/* Read the data from the FFT file */
data = read_fcomplex_file(fftfile, binprops.lowbin - lofreq, binprops.nfftbins);
/* Turn the Fourier amplitudes into powers */
for (ii = 0; ii < binprops.nfftbins; ii++)
powr[ii] = POWER(data[ii].r, data[ii].i);
/* Chop the powers that are way above the median level */
prune_powers(powr, binprops.nfftbins, numsumpow);
/* Perform the minifft */
memcpy((float *) minifft, powr, sizeof(float) * binprops.nfftbins);
realfft((float *) minifft, binprops.nfftbins, -1);
/* Calculate the normalization constant */
norm = sqrt((double) binprops.nfftbins * (double) numsumpow) / minifft[0].r;
locpow = minifft[0].r / binprops.nfftbins;
/* Divide the original power spectrum by the local power level */
for (ii = 0; ii < binprops.nfftbins; ii++)
powr[ii] /= locpow;
/* Now normalize the miniFFT */
minifft[0].r = 1.0;
minifft[0].i = 1.0;
for (ii = 1; ii < binprops.nfftbins / 2; ii++) {
minifft[ii].r *= norm;
minifft[ii].i *= norm;
}
/* Interpolate the minifft and convert to power spectrum */
corr_complex(minifft, binprops.nfftbins / 2, RAW,
kernel, binprops.nfftbins, FFT,
spread, binprops.nfftbins, kern_half_width,
numbetween, kern_half_width, CORR);
for (ii = 0; ii < binprops.nfftbins; ii++)
spreadpow[ii] = POWER(spread[ii].r, spread[ii].i);
/* Plot the initial data set */
freqs = gen_freqs(binprops.nfftbins, binprops.lowbin / T, 1.0 / T);
xyline(binprops.nfftbins, freqs, powr, "Pulsar Frequency (hz)",
"Power / Local Power", 1);
vect_free(freqs);
printf("The initial data set (with high power outliers removed):\n\n");
/* Plot the miniFFT */
freqs = gen_freqs(binprops.nfftbins, 0.0, T / (2 * binprops.nfftbins));
xyline(binprops.nfftbins, freqs, spreadpow, "Binary Period (sec)",
"Normalized Power", 1);
vect_free(freqs);
printf("The miniFFT:\n\n");
/* Interpolate and plot the actual candidate peak */
ftobinp = T / binprops.nfftbins;
freqs = gen_freqs(nzoom, (binprops.rdetect - ZOOMNEIGHBORS) *
ftobinp, ftobinp / (double) ZOOMFACT);
for (ii = 0; ii < nzoom; ii++) {
dr = -ZOOMNEIGHBORS + (double) ii / ZOOMFACT;
rz_interp(minifft, binprops.nfftbins / 2, binprops.rdetect + dr,
0.0, kern_half_width, &minizoom[ii]);
minizoompow[ii] = POWER(minizoom[ii].r, minizoom[ii].i);
}
xyline(nzoom, freqs, minizoompow, "Binary Period (sec)", "Normalized Power", 1);
vect_free(freqs);
printf("The candidate itself:\n\n");
printf("Done.\n\n");
/* Cleanup */
cpgend();
vect_free(data);
vect_free(powr);
vect_free(resp);
vect_free(kernel);
vect_free(minifft);
vect_free(spread);
vect_free(spreadpow);
vect_free(minizoom);
vect_free(minizoompow);
fclose(fftfile);
if ((argc == 6) && (!strcmp(argv[5], "ps"))) {
fclose(psfile);
}
return (0);
}
int main(int argc, char **argv)
{
int index = -1, need_type = 0;
int objs_read, objs_to_read, has_suffix;
long i, j, ct;
char *cptr, *data, *short_filenm, *extension, key = '\n';
FILE *infile;
Cmdline *cmd;
infodata inf;
/* Call usage() if we have no command line arguments */
if (argc == 1) {
Program = argv[0];
usage();
exit(0);
}
/* Parse the command line using the excellent program Clig */
cmd = parseCmdline(argc, argv);
#ifdef DEBUG
showOptionValues();
#endif
//fprintf(stdout, "\n\n PRESTO Binary File Reader\n");
//fprintf(stdout, " by Scott M. Ransom\n\n");
/* Set our index value */
if (cmd->bytP || cmd->sbytP)
index = BYTE;
else if (cmd->fltP || cmd->sfltP)
index = FLOAT;
else if (cmd->dblP || cmd->sdblP)
index = DOUBLE;
else if (cmd->fcxP || cmd->sfcxP)
index = FCPLEX;
else if (cmd->dcxP || cmd->sdcxP)
index = DCPLEX;
else if (cmd->shtP || cmd->sshtP)
index = SHORT;
else if (cmd->igrP || cmd->sigrP)
index = INT;
else if (cmd->lngP || cmd->slngP)
index = LONG;
else if (cmd->rzwP || cmd->srzwP)
index = RZWCAND;
else if (cmd->binP || cmd->sbinP)
index = BINCAND;
else if (cmd->posP || cmd->sposP)
index = POSITION;
else if (cmd->pkmbP)
index = PKMBHDR;
else if (cmd->bcpmP)
index = BCPMHDR;
else if (cmd->wappP)
index = WAPPHDR;
else if (cmd->spigotP)
index = SPIGOTHDR;
else if (cmd->filterbankP)
index = SPECTRAINFO;
#ifdef USELOFAR
else if (cmd->lofarhdf5P)
index = SPECTRAINFO;
#endif
else if (cmd->psrfitsP)
index = SPECTRAINFO;
/* Try to determine the data type from the file name */
if (index == -1) {
has_suffix = split_root_suffix(cmd->argv[0], &short_filenm, &extension);
if (!has_suffix) {
need_type = 1;
} else {
if (strlen(extension) < 2) {
need_type = 1;
} else {
if (0 == strcmp(extension, "dat")) {
index = FLOAT;
fprintf(stdout, "Assuming the data is floating point.\n\n");
} else if (0 == strcmp(extension, "sdat")) {
index = SHORT;
fprintf(stdout, "Assuming the data is short integers.\n\n");
} else if (0 == strcmp(extension, "fft")) {
index = FCPLEX;
fprintf(stdout, "Assuming the data is single precision complex.\n\n");
} else if ((0 == strcmp(extension, "fits")) ||
(0 == strcmp(extension, "sf"))) {
if (strstr(short_filenm, "spigot_5") != NULL) {
cmd->spigotP = 1;
index = SPIGOTHDR;
fprintf(stdout,
"Assuming the data is from the Caltech/NRAO Spigot.\n\n");
} else if (is_PSRFITS(cmd->argv[0])) {
cmd->psrfitsP = 1;
index = SPECTRAINFO;
fprintf(stdout,
"Assuming the data is in PSRFITS format.\n\n");
}
} else if (0 == strcmp(extension, "bcpm1") ||
0 == strcmp(extension, "bcpm2")) {
cmd->bcpmP = 1;
index = BCPMHDR;
fprintf(stdout, "Assuming the data is from a BCPM machine.\n\n");
} else if (0 == strcmp(extension, "pkmb")) {
cmd->pkmbP = 1;
index = PKMBHDR;
fprintf(stdout,
"Assuming the data is from the Parkes Multibeam machine.\n\n");
} else if (0 == strcmp(extension, "fil") || 0 == strcmp(extension, "fb")) {
cmd->filterbankP = 1;
index = SPECTRAINFO;
fprintf(stdout,
"Assuming the data is a SIGPROC filterbank file.\n\n");
} else if (0 == strcmp(extension, "h5")) {
cmd->lofarhdf5P = 1;
index = SPECTRAINFO;
fprintf(stdout,
"Assuming the data is a LOFAR HDF5 file.\n\n");
} else if (isdigit(extension[0]) &&
isdigit(extension[1]) && isdigit(extension[2])) {
cmd->wappP = 1;
index = WAPPHDR;
fprintf(stdout, "Assuming the data is from a WAPP machine.\n\n");
} else if (0 == strcmp(extension, "pos")) {
index = POSITION;
fprintf(stdout,
"Assuming the data contains 'position' structures.\n\n");
} else if (0 == strcmp(extension, "cand")) {
/* A binary or RZW search file? */
if (NULL != (cptr = strstr(cmd->argv[0], "_bin"))) {
index = BINCAND;
fprintf(stdout,
"Assuming the file contains binary candidates.\n\n");
} else if (NULL != (cptr = strstr(cmd->argv[0], "_rzw"))) {
index = RZWCAND;
ct = (long) (cptr - cmd->argv[0]);
fprintf(stdout, "Assuming the file contains 'RZW' candidates.\n");
free(short_filenm);
short_filenm = (char *) malloc(ct + 1);
short_filenm[ct] = '\0';
strncpy(short_filenm, cmd->argv[0], ct);
fprintf(stdout, "\nAttempting to read '%s.inf'. ", short_filenm);
readinf(&inf, short_filenm);
fprintf(stdout, "Successful.\n");
N = (long) (inf.N + DBLCORRECT);
dt = inf.dt;
if (cmd->nphP)
nph = cmd->nph;
else
nph = 1.0;
fprintf(stdout,
"\nUsing N = %ld, dt = %g, and DC Power = %f\n\n",
N, dt, nph);
} else if (NULL != (cptr = strstr(cmd->argv[0], "_ACCEL"))) {
index = RZWCAND;
ct = (long) (cptr - cmd->argv[0]);
fprintf(stdout, "Assuming the file contains 'RZW' candidates.\n");
free(short_filenm);
short_filenm = (char *) malloc(ct + 1);
short_filenm[ct] = '\0';
strncpy(short_filenm, cmd->argv[0], ct);
fprintf(stdout, "\nAttempting to read '%s.inf'. ", short_filenm);
readinf(&inf, short_filenm);
fprintf(stdout, "Successful.\n");
N = (long) (inf.N + DBLCORRECT);
dt = inf.dt;
if (cmd->nphP)
nph = cmd->nph;
else
nph = 1.0;
fprintf(stdout,
"\nUsing N = %ld, dt = %g, and DC Power = %f\n\n",
N, dt, nph);
} else
need_type = 1;
} else
need_type = 1;
}
}
/* If no file extension or if we don't understand the extension, exit */
if (need_type) {
fprintf(stdout, "You must specify a data type for this file.\n\n");
free(short_filenm);
exit(-1);
}
free(short_filenm);
if (has_suffix)
free(extension);
}
if (cmd->index[1] == -1 || cmd->index[1] == 0)
cmd->index[1] = INT_MAX;
if (cmd->index[1] < cmd->index[0]) {
fprintf(stdout, "\nThe high index must be >= the low index.");
fprintf(stdout, " Exiting.\n\n");
exit(-1);
}
// Use new-style backend reading stuff
if (cmd->psrfitsP || cmd->filterbankP || cmd->lofarhdf5P) {
struct spectra_info s;
// Eventually we should use this...
// identify_psrdatatype(struct spectra_info *s, int output);
spectra_info_set_defaults(&s);
if (cmd->psrfitsP) s.datatype=PSRFITS;
if (cmd->filterbankP) s.datatype=SIGPROCFB;
if (cmd->lofarhdf5P) s.datatype=LOFARHDF5;
s.filenames = cmd->argv;
s.num_files = cmd->argc;
s.clip_sigma = 0.0;
s.apply_flipband = s.apply_weight = s.apply_scale = s.apply_offset = -1;
s.remove_zerodm = 0;
read_rawdata_files(&s);
SPECTRAINFO_print(0, (char *)(&s));
printf("\n");
exit(0);
}
if (cmd->spigotP) {
SPIGOT_INFO spigot;
if (read_SPIGOT_header(cmd->argv[0], &spigot)) {
print_SPIGOT_header(&spigot);
printf("\n");
} else {
printf("\n Error reading spigot file!\n\n");
}
exit(0);
}
if (cmd->wappP) {
struct HEADERP *hdr = NULL;
infile = chkfopen(cmd->argv[0], "rb");
hdr = head_parse(infile);
set_WAPP_HEADER_version(hdr);
if (hdr) {
print_WAPP_hdr(hdr);
printf("\n");
} else {
printf("\n Error reading WAPP file!\n\n");
}
exit(0);
}
/* Open the file */
infile = chkfopen(cmd->argv[0], "rb");
if (cmd->fortranP) {
chkfileseek(infile, 1, sizeof(long), SEEK_SET);
}
/* Skip to the correct first object */
if (cmd->index[0] > 0) {
chkfileseek(infile, (long) (cmd->index[0]), type_sizes[index], SEEK_CUR);
}
/* Read the file */
objs_to_read = objs_at_a_time[index];
data = (char *) malloc(type_sizes[index] * objs_at_a_time[index]);
i = cmd->index[0];
do {
if (objs_to_read > cmd->index[1] - i)
objs_to_read = cmd->index[1] - i;
objs_read = chkfread(data, type_sizes[index], objs_to_read, infile);
for (j = 0; j < objs_read; j++)
print_funct_ptrs[index] (i + j, data + j * type_sizes[index]);
/* Just print 1 header for BCPM and WAPP files */
if (index == BCPMHDR || index == WAPPHDR || index == SPIGOTHDR)
break;
i += objs_read;
if (cmd->pageP) {
fflush(NULL);
fprintf(stdout, "\nPress ENTER for next page, or any other key and ");
fprintf(stdout, "then ENTER to exit.\n\n");
key = getchar();
}
} while (!feof(infile) && i < cmd->index[1] && key == '\n');
fflush(NULL);
if (feof(infile)) {
fprintf(stdout, "\nEnd of file.\n\n");
}
free(data);
fclose(infile);
exit(0);
}
int main(int argc, char *argv[])
{
/* Any variable that begins with 't' means topocentric */
/* Any variable that begins with 'b' means barycentric */
FILE *outfile;
float *outdata = NULL;
double tdf = 0.0, dtmp = 0.0, barydispdt = 0.0, dsdt = 0.0;
double *dispdt, *tobsf = NULL, tlotoa = 0.0, blotoa = 0.0;
double max = -9.9E30, min = 9.9E30, var = 0.0, avg = 0.0;
char obs[3], ephem[10], *datafilenm, *outinfonm;
char rastring[50], decstring[50];
int numchan = 1, newper = 0, oldper = 0, nummasked = 0, useshorts = 0;
int numadded = 0, numremoved = 0, padding = 0, *maskchans = NULL, offset = 0;
long slen, ii, numbarypts = 0, worklen = 65536;
long numread = 0, numtowrite = 0, totwrote = 0, datawrote = 0;
long padwrote = 0, padtowrite = 0, statnum = 0;
int numdiffbins = 0, *diffbins = NULL, *diffbinptr = NULL, good_padvals = 0;
int *idispdt;
struct spectra_info s;
infodata idata;
Cmdline *cmd;
mask obsmask;
/* Call usage() if we have no command line arguments */
if (argc == 1) {
Program = argv[0];
printf("\n");
usage();
exit(0);
}
/* Parse the command line using the excellent program Clig */
cmd = parseCmdline(argc, argv);
spectra_info_set_defaults(&s);
s.filenames = cmd->argv;
s.num_files = cmd->argc;
// If we are zeroDMing, make sure that clipping is off.
if (cmd->zerodmP)
cmd->noclipP = 1;
s.clip_sigma = cmd->clip;
// -1 causes the data to determine if we use weights, scales, &
// offsets for PSRFITS or flip the band for any data type where
// we can figure that out with the data
s.apply_flipband = (cmd->invertP) ? 1 : -1;
s.apply_weight = (cmd->noweightsP) ? 0 : -1;
s.apply_scale = (cmd->noscalesP) ? 0 : -1;
s.apply_offset = (cmd->nooffsetsP) ? 0 : -1;
s.remove_zerodm = (cmd->zerodmP) ? 1 : 0;
if (cmd->noclipP) {
cmd->clip = 0.0;
s.clip_sigma = 0.0;
}
if (cmd->ifsP) {
// 0 = default or summed, 1-4 are possible also
s.use_poln = cmd->ifs + 1;
}
if (cmd->ncpus > 1) {
#ifdef _OPENMP
int maxcpus = omp_get_num_procs();
int openmp_numthreads = (cmd->ncpus <= maxcpus) ? cmd->ncpus : maxcpus;
// Make sure we are not dynamically setting the number of threads
omp_set_dynamic(0);
omp_set_num_threads(openmp_numthreads);
printf("Using %d threads with OpenMP\n\n", openmp_numthreads);
#endif
} else {
#ifdef _OPENMP
omp_set_num_threads(1); // Explicitly turn off OpenMP
#endif
}
#ifdef DEBUG
showOptionValues();
#endif
printf("\n\n");
printf(" Pulsar Data Preparation Routine\n");
printf(" Type conversion, de-dispersion, barycentering.\n");
printf(" by Scott M. Ransom\n\n");
if (RAWDATA) {
if (cmd->filterbankP)
s.datatype = SIGPROCFB;
else if (cmd->psrfitsP)
s.datatype = PSRFITS;
} else { // Attempt to auto-identify the data
identify_psrdatatype(&s, 1);
if (s.datatype == SIGPROCFB)
cmd->filterbankP = 1;
else if (s.datatype == PSRFITS)
cmd->psrfitsP = 1;
else if (s.datatype == SDAT)
useshorts = 1;
else if (s.datatype != DAT) {
printf
("Error: Unable to identify input data files. Please specify type.\n\n");
exit(1);
}
}
if (!RAWDATA) {
char *root, *suffix;
/* Split the filename into a rootname and a suffix */
if (split_root_suffix(s.filenames[0], &root, &suffix) == 0) {
printf("\nThe input filename (%s) must have a suffix!\n\n",
s.filenames[0]);
exit(1);
}
printf("Reading input data from '%s'.\n", s.filenames[0]);
printf("Reading information from '%s.inf'.\n\n", root);
/* Read the info file if available */
readinf(&idata, root);
free(root);
free(suffix);
s.files = (FILE **) malloc(sizeof(FILE *));
s.files[0] = chkfopen(s.filenames[0], "rb");
} else {
char description[40];
psrdatatype_description(description, s.datatype);
if (s.num_files > 1)
printf("Reading %s data from %d files:\n", description, s.num_files);
else
printf("Reading %s data from 1 file:\n", description);
for (ii = 0; ii < s.num_files; ii++) {
printf(" '%s'\n", cmd->argv[ii]);
}
printf("\n");
}
/* Determine the other file names and open the output data file */
slen = strlen(cmd->outfile) + 8;
datafilenm = (char *) calloc(slen, 1);
sprintf(datafilenm, "%s.dat", cmd->outfile);
outfile = chkfopen(datafilenm, "wb");
sprintf(idata.name, "%s", cmd->outfile);
outinfonm = (char *) calloc(slen, 1);
sprintf(outinfonm, "%s.inf", cmd->outfile);
if (RAWDATA) {
read_rawdata_files(&s);
if (cmd->ignorechanstrP) {
s.ignorechans = get_ignorechans(cmd->ignorechanstr, 0, s.num_channels-1,
&s.num_ignorechans, &s.ignorechans_str);
if (s.ignorechans_str==NULL) {
s.ignorechans_str = (char *)malloc(strlen(cmd->ignorechanstr)+1);
strcpy(s.ignorechans_str, cmd->ignorechanstr);
}
}
print_spectra_info_summary(&s);
spectra_info_to_inf(&s, &idata);
/* Finish setting up stuff common to all raw formats */
idata.dm = cmd->dm;
worklen = s.spectra_per_subint;
/* If we are offsetting into the file, change inf file start time */
if (cmd->start > 0.0 || cmd->offset > 0) {
if (cmd->start > 0.0) /* Offset in units of worklen */
cmd->offset = (long) (cmd->start *
idata.N / worklen) * worklen;
add_to_inf_epoch(&idata, cmd->offset * idata.dt);
offset_to_spectra(cmd->offset, &s);
printf("Offsetting into the input files by %ld spectra (%.6g sec)\n",
cmd->offset, cmd->offset * idata.dt);
}
if (cmd->maskfileP)
maskchans = gen_ivect(idata.num_chan);
/* Compare the size of the data to the size of output we request */
if (cmd->numoutP) {
dtmp = idata.N;
idata.N = cmd->numout;
writeinf(&idata);
idata.N = dtmp;
} else {
/* Set the output length to a good number if it wasn't requested */
cmd->numoutP = 1;
cmd->numout = choose_good_N((long long)(idata.N/cmd->downsamp));
writeinf(&idata);
printf("Setting a 'good' output length of %ld samples\n", cmd->numout);
}
/* The number of topo to bary time points to generate with TEMPO */
numbarypts = (long) (idata.dt * idata.N * 1.1 / TDT + 5.5) + 1;
// Identify the TEMPO observatory code
{
char *outscope = (char *) calloc(40, sizeof(char));
telescope_to_tempocode(idata.telescope, outscope, obs);
free(outscope);
}
}
/* Read an input mask if wanted */
if (cmd->maskfileP) {
read_mask(cmd->maskfile, &obsmask);
printf("Read mask information from '%s'\n\n", cmd->maskfile);
good_padvals = determine_padvals(cmd->maskfile, &obsmask, s.padvals);
} else {
obsmask.numchan = obsmask.numint = 0;
}
/* Determine our initialization data if we do _not_ have Parkes, */
/* Green Bank BCPM, or Arecibo WAPP data sets. */
if (!RAWDATA) {
/* If we will be barycentering... */
if (!cmd->nobaryP) {
/* The number of topo to bary time points to generate with TEMPO */
numbarypts = (long) (idata.dt * idata.N * 1.1 / TDT + 5.5) + 1;
// Identify the TEMPO observatory code
{
char *outscope = (char *) calloc(40, sizeof(char));
telescope_to_tempocode(idata.telescope, outscope, obs);
free(outscope);
}
}
/* The number of data points to work with at a time */
if (worklen > idata.N)
worklen = idata.N;
worklen = (long) (worklen / 1024) * 1024;
/* If we are offsetting into the file, change inf file start time */
if (cmd->start > 0.0 || cmd->offset > 0) {
if (cmd->start > 0.0) /* Offset in units of worklen */
cmd->offset = (long) (cmd->start *
idata.N / worklen) * worklen;
add_to_inf_epoch(&idata, cmd->offset * idata.dt);
printf("Offsetting into the input files by %ld samples (%.6g sec)\n",
cmd->offset, cmd->offset * idata.dt);
if (useshorts) {
chkfileseek(s.files[0], cmd->offset, sizeof(short), SEEK_SET);
} else {
chkfileseek(s.files[0], cmd->offset, sizeof(float), SEEK_SET);
}
}
/* Set the output length to a good number if it wasn't requested */
if (!cmd->numoutP) {
cmd->numoutP = 1;
cmd->numout = choose_good_N((long long)(idata.N/cmd->downsamp));
printf("Setting a 'good' output length of %ld samples\n", cmd->numout);
}
}
/* Check if we are downsampling */
dsdt = idata.dt * cmd->downsamp;
if (cmd->downsamp > 1) {
printf("Downsampling by a factor of %d\n", cmd->downsamp);
printf("New sample dt = %.10g\n\n", dsdt);
if (worklen % cmd->downsamp) {
printf("Error: The downsample factor (%d) must be a factor of the\n",
cmd->downsamp);
printf(" worklength (%ld). Exiting.\n\n", worklen);
exit(1);
}
}
printf("Writing output data to '%s'.\n", datafilenm);
printf("Writing information to '%s'.\n\n", outinfonm);
/* The topocentric epoch of the start of the data */
tlotoa = (double) idata.mjd_i + idata.mjd_f;
if (!strcmp(idata.band, "Radio") && RAWDATA) {
/* The topocentric spacing between channels */
tdf = idata.chan_wid;
numchan = idata.num_chan;
/* The topocentric observation frequencies */
tobsf = gen_dvect(numchan);
tobsf[0] = idata.freq;
for (ii = 0; ii < numchan; ii++)
tobsf[ii] = tobsf[0] + ii * tdf;
/* The dispersion delays (in time bins) */
dispdt = gen_dvect(numchan); // full float bins
idispdt = gen_ivect(numchan); // nearest integer bins
if (cmd->nobaryP) {
/* Determine our dispersion time delays for each channel */
for (ii = 0; ii < numchan; ii++)
dispdt[ii] = delay_from_dm(cmd->dm, tobsf[ii]);
/* The highest frequency channel gets no delay */
/* All other delays are positive fractions of bin length (dt) */
dtmp = dispdt[numchan - 1];
for (ii = 0; ii < numchan; ii++) {
dispdt[ii] = (dispdt[ii] - dtmp) / idata.dt;
idispdt[ii] = (int) (dispdt[ii] + 0.5);
}
worklen *= ((int) (fabs(dispdt[0])) / worklen) + 1;
}
} else { /* For unknown radio raw data (Why is this here?) */
tobsf = gen_dvect(numchan);
dispdt = gen_dvect(numchan);
idispdt = gen_ivect(numchan);
dispdt[0] = 0.0;
idispdt[0] = 0;
if (!strcmp(idata.band, "Radio")) {
tobsf[0] = idata.freq + (idata.num_chan - 1) * idata.chan_wid;
cmd->dm = idata.dm;
} else {
tobsf[0] = 0.0;
cmd->dm = 0.0;
}
}
if (cmd->nobaryP) { /* Main loop if we are not barycentering... */
/* Allocate our data array */
outdata = gen_fvect(worklen);
printf("Massaging the data ...\n\n");
printf("Amount Complete = 0%%");
do {
if (RAWDATA)
numread = read_psrdata(outdata, worklen, &s, idispdt, &padding,
maskchans, &nummasked, &obsmask);
else if (useshorts)
numread = read_shorts(s.files[0], outdata, worklen, numchan);
else
numread = read_floats(s.files[0], outdata, worklen, numchan);
if (numread == 0)
break;
/* Downsample if requested */
if (cmd->downsamp > 1)
numread = downsample(outdata, numread, cmd->downsamp);
/* Print percent complete */
newper = (int) ((float) totwrote / cmd->numout * 100.0) + 1;
if (newper > oldper) {
printf("\rAmount Complete = %3d%%", newper);
fflush(stdout);
oldper = newper;
}
/* Write the latest chunk of data, but don't */
/* write more than cmd->numout points. */
numtowrite = numread;
if ((totwrote + numtowrite) > cmd->numout)
numtowrite = cmd->numout - totwrote;
chkfwrite(outdata, sizeof(float), numtowrite, outfile);
totwrote += numtowrite;
/* Update the statistics */
if (!padding) {
for (ii = 0; ii < numtowrite; ii++)
update_stats(statnum + ii, outdata[ii], &min, &max, &avg, &var);
statnum += numtowrite;
}
/* Stop if we have written out all the data we need to */
if (totwrote == cmd->numout)
break;
} while (numread);
datawrote = totwrote;
} else { /* Main loop if we are barycentering... */
double avgvoverc = 0.0, maxvoverc = -1.0, minvoverc = 1.0, *voverc = NULL;
double *bobsf = NULL, *btoa = NULL, *ttoa = NULL;
/* What ephemeris will we use? (Default is DE405) */
strcpy(ephem, "DE405");
/* Define the RA and DEC of the observation */
ra_dec_to_string(rastring, idata.ra_h, idata.ra_m, idata.ra_s);
ra_dec_to_string(decstring, idata.dec_d, idata.dec_m, idata.dec_s);
/* Allocate some arrays */
bobsf = gen_dvect(numchan);
btoa = gen_dvect(numbarypts);
ttoa = gen_dvect(numbarypts);
voverc = gen_dvect(numbarypts);
for (ii = 0; ii < numbarypts; ii++)
ttoa[ii] = tlotoa + TDT * ii / SECPERDAY;
/* Call TEMPO for the barycentering */
printf("Generating barycentric corrections...\n");
barycenter(ttoa, btoa, voverc, numbarypts, rastring, decstring, obs, ephem);
for (ii = 0; ii < numbarypts; ii++) {
if (voverc[ii] > maxvoverc)
maxvoverc = voverc[ii];
if (voverc[ii] < minvoverc)
minvoverc = voverc[ii];
avgvoverc += voverc[ii];
}
avgvoverc /= numbarypts;
vect_free(voverc);
blotoa = btoa[0];
printf(" Average topocentric velocity (c) = %.7g\n", avgvoverc);
printf(" Maximum topocentric velocity (c) = %.7g\n", maxvoverc);
printf(" Minimum topocentric velocity (c) = %.7g\n\n", minvoverc);
printf("Collecting and barycentering %s...\n\n", cmd->argv[0]);
/* Determine the initial dispersion time delays for each channel */
for (ii = 0; ii < numchan; ii++) {
bobsf[ii] = doppler(tobsf[ii], avgvoverc);
dispdt[ii] = delay_from_dm(cmd->dm, bobsf[ii]);
}
/* The highest frequency channel gets no delay */
/* All other delays are positive fractions of bin length (dt) */
barydispdt = dispdt[numchan - 1];
for (ii = 0; ii < numchan; ii++) {
dispdt[ii] = (dispdt[ii] - barydispdt) / idata.dt;
idispdt[ii] = (int) (dispdt[ii] + 0.5);
}
if (RAWDATA)
worklen *= ((int) (dispdt[0]) / worklen) + 1;
/* If the data is de-dispersed radio data... */
if (!strcmp(idata.band, "Radio")) {
printf("The DM of %.2f at the barycentric observing freq of %.3f MHz\n",
idata.dm, bobsf[numchan - 1]);
printf(" causes a delay of %f seconds compared to infinite freq.\n",
barydispdt);
printf(" This delay is removed from the barycented times.\n\n");
}
printf("Topocentric epoch (at data start) is:\n");
printf(" %17.11f\n\n", tlotoa);
printf("Barycentric epoch (infinite obs freq at data start) is:\n");
printf(" %17.11f\n\n", blotoa - (barydispdt / SECPERDAY));
/* Convert the bary TOAs to differences from the topo TOAs in */
/* units of bin length (dsdt) rounded to the nearest integer. */
dtmp = (btoa[0] - ttoa[0]);
for (ii = 0; ii < numbarypts; ii++)
btoa[ii] = ((btoa[ii] - ttoa[ii]) - dtmp) * SECPERDAY / dsdt;
{ /* Find the points where we need to add or remove bins */
int oldbin = 0, currentbin;
double lobin, hibin, calcpt;
numdiffbins = abs(NEAREST_LONG(btoa[numbarypts - 1])) + 1;
diffbins = gen_ivect(numdiffbins);
diffbinptr = diffbins;
for (ii = 1; ii < numbarypts; ii++) {
currentbin = NEAREST_LONG(btoa[ii]);
if (currentbin != oldbin) {
if (currentbin > 0) {
calcpt = oldbin + 0.5;
lobin = (ii - 1) * TDT / dsdt;
hibin = ii * TDT / dsdt;
} else {
calcpt = oldbin - 0.5;
lobin = -((ii - 1) * TDT / dsdt);
hibin = -(ii * TDT / dsdt);
}
while (fabs(calcpt) < fabs(btoa[ii])) {
/* Negative bin number means remove that bin */
/* Positive bin number means add a bin there */
*diffbinptr = NEAREST_LONG(LININTERP(calcpt, btoa[ii - 1],
btoa[ii], lobin,
hibin));
diffbinptr++;
calcpt = (currentbin > 0) ? calcpt + 1.0 : calcpt - 1.0;
}
oldbin = currentbin;
}
}
*diffbinptr = cmd->numout; /* Used as a marker */
}
diffbinptr = diffbins;
/* Now perform the barycentering */
printf("Massaging the data...\n\n");
printf("Amount Complete = 0%%");
/* Allocate our data array */
outdata = gen_fvect(worklen);
do { /* Loop to read and write the data */
int numwritten = 0;
double block_avg, block_var;
if (RAWDATA)
numread = read_psrdata(outdata, worklen, &s, idispdt, &padding,
maskchans, &nummasked, &obsmask);
else if (useshorts)
numread = read_shorts(s.files[0], outdata, worklen, numchan);
else
numread = read_floats(s.files[0], outdata, worklen, numchan);
if (numread == 0)
break;
/* Downsample if requested */
if (cmd->downsamp > 1)
numread = downsample(outdata, numread, cmd->downsamp);
/* Determine the approximate local average */
avg_var(outdata, numread, &block_avg, &block_var);
/* Print percent complete */
newper = (int) ((float) totwrote / cmd->numout * 100.0) + 1;
if (newper > oldper) {
printf("\rAmount Complete = %3d%%", newper);
fflush(stdout);
oldper = newper;
}
/* Simply write the data if we don't have to add or */
/* remove any bins from this batch. */
/* OR write the amount of data up to cmd->numout or */
/* the next bin that will be added or removed. */
numtowrite = abs(*diffbinptr) - datawrote;
/* FIXME: numtowrite+totwrote can wrap! */
if ((totwrote + numtowrite) > cmd->numout)
numtowrite = cmd->numout - totwrote;
if (numtowrite > numread)
numtowrite = numread;
chkfwrite(outdata, sizeof(float), numtowrite, outfile);
datawrote += numtowrite;
totwrote += numtowrite;
numwritten += numtowrite;
/* Update the statistics */
if (!padding) {
for (ii = 0; ii < numtowrite; ii++)
update_stats(statnum + ii, outdata[ii], &min, &max, &avg, &var);
statnum += numtowrite;
}
if ((datawrote == abs(*diffbinptr)) && (numwritten != numread) && (totwrote < cmd->numout)) { /* Add/remove a bin */
float favg;
int skip, nextdiffbin;
skip = numtowrite;
do { /* Write the rest of the data after adding/removing a bin */
if (*diffbinptr > 0) {
/* Add a bin */
favg = (float) block_avg;
chkfwrite(&favg, sizeof(float), 1, outfile);
numadded++;
totwrote++;
} else {
/* Remove a bin */
numremoved++;
datawrote++;
numwritten++;
skip++;
}
diffbinptr++;
/* Write the part after the diffbin */
numtowrite = numread - numwritten;
if ((totwrote + numtowrite) > cmd->numout)
numtowrite = cmd->numout - totwrote;
nextdiffbin = abs(*diffbinptr) - datawrote;
if (numtowrite > nextdiffbin)
numtowrite = nextdiffbin;
chkfwrite(outdata + skip, sizeof(float), numtowrite, outfile);
numwritten += numtowrite;
datawrote += numtowrite;
totwrote += numtowrite;
/* Update the statistics and counters */
if (!padding) {
for (ii = 0; ii < numtowrite; ii++)
update_stats(statnum + ii, outdata[skip + ii],
&min, &max, &avg, &var);
statnum += numtowrite;
}
skip += numtowrite;
/* Stop if we have written out all the data we need to */
if (totwrote == cmd->numout)
break;
} while (numwritten < numread);
}
/* Stop if we have written out all the data we need to */
if (totwrote == cmd->numout)
break;
} while (numread);
/* Free the arrays used in barycentering */
vect_free(bobsf);
vect_free(btoa);
vect_free(ttoa);
}
/* Calculate what the amount of padding we need */
if (cmd->numout > totwrote)
padwrote = padtowrite = cmd->numout - totwrote;
/* Write the new info file for the output data */
if (!cmd->nobaryP) {
idata.bary = 1;
idata.mjd_i = (int) floor(blotoa - (barydispdt / SECPERDAY));
idata.mjd_f = blotoa - (barydispdt / SECPERDAY) - idata.mjd_i;
}
if (cmd->downsamp > 1)
idata.dt = dsdt;
update_infodata(&idata, totwrote, padtowrite, diffbins, numdiffbins);
writeinf(&idata);
/* Set the padded points equal to the average data point */
if (idata.numonoff >= 1) {
int jj, index, startpad, endpad;
for (ii = 0; ii < worklen; ii++)
outdata[ii] = avg;
fclose(outfile);
outfile = chkfopen(datafilenm, "rb+");
for (ii = 0; ii < idata.numonoff; ii++) {
index = 2 * ii;
startpad = idata.onoff[index + 1];
if (ii == idata.numonoff - 1)
endpad = idata.N - 1;
else
endpad = idata.onoff[index + 2];
chkfseek(outfile, (startpad + 1) * sizeof(float), SEEK_SET);
padtowrite = endpad - startpad;
for (jj = 0; jj < padtowrite / worklen; jj++)
chkfwrite(outdata, sizeof(float), worklen, outfile);
chkfwrite(outdata, sizeof(float), padtowrite % worklen, outfile);
}
}
vect_free(outdata);
// Close all the raw files and free their vectors
close_rawfiles(&s);
/* Print simple stats and results */
var /= (datawrote - 1);
/* Conver the '.dat' file to '.sdat' if requested */
if (cmd->shortsP) {
FILE *infile;
int safe_convert = 1, bufflen = 65536;
char *sdatafilenm;
float *fbuffer;
short *sbuffer;
offset = (int) (floor(avg));
if ((max - min) > (SHRT_MAX - SHRT_MIN)) {
if ((max - min) < 1.5 * (SHRT_MAX - SHRT_MIN)) {
printf("Warning: There is more dynamic range in the data\n"
" than can be handled perfectly:\n"
" max - min = %.2f - %.2f = %.2f\n"
" Clipping the low values...\n\n", max, min,
max - min);
offset = max - SHRT_MAX;
} else {
printf("Error: There is way too much dynamic range in the data:\n"
" max - min = %.2f - %.2f = %.2f\n"
" Not converting to shorts.\n\n", max, min, max - min);
safe_convert = 0;
}
}
if (safe_convert) {
fbuffer = gen_fvect(bufflen);
sbuffer = gen_svect(bufflen);
sdatafilenm = (char *) calloc(slen, 1);
sprintf(sdatafilenm, "%s.sdat", cmd->outfile);
printf("\n\nConverting floats in '%s' to shorts in '%s'.",
datafilenm, sdatafilenm);
fflush(NULL);
infile = chkfopen(datafilenm, "rb");
outfile = chkfopen(sdatafilenm, "wb");
while ((numread = chkfread(fbuffer, sizeof(float), bufflen, infile))) {
for (ii = 0; ii < numread; ii++)
sbuffer[ii] = (short) (fbuffer[ii] + 1e-20 - offset);
chkfwrite(sbuffer, sizeof(short), numread, outfile);
}
fclose(infile);
fclose(outfile);
remove(datafilenm);
vect_free(fbuffer);
vect_free(sbuffer);
}
}
printf("\n\nDone.\n\nSimple statistics of the output data:\n");
printf(" Data points written: %ld\n", totwrote);
if (padwrote)
printf(" Padding points written: %ld\n", padwrote);
if (!cmd->nobaryP) {
if (numadded)
printf(" Bins added for barycentering: %d\n", numadded);
if (numremoved)
printf(" Bins removed for barycentering: %d\n", numremoved);
}
printf(" Maximum value of data: %.2f\n", max);
printf(" Minimum value of data: %.2f\n", min);
printf(" Data average value: %.2f\n", avg);
printf(" Data standard deviation: %.2f\n", sqrt(var));
if (cmd->shortsP && offset != 0)
printf(" Offset applied to data: %d\n", -offset);
printf("\n");
/* Cleanup */
if (cmd->maskfileP) {
free_mask(obsmask);
vect_free(maskchans);
}
vect_free(tobsf);
vect_free(dispdt);
vect_free(idispdt);
free(outinfonm);
free(datafilenm);
if (!cmd->nobaryP)
vect_free(diffbins);
return (0);
}