int main(int argc, char *argv[])
{
FILE *infile, *outfile;
int ii, numread;
long long N = 0;
float offset = 0.0, fbuffer[sizeof(float) * BUFFLEN];
short sbuffer[sizeof(short) * BUFFLEN];
char *outname;
if (argc != 2 && argc != 3) {
printf("\nUsage: sdat2dat sdatfilename [offset to add]\n\n");
exit(1);
}
printf("\n Shorts to Floats Data Conversion Program\n\n");
/* Get the root of the input filename and */
/* generate the output filenames from it. */
{
char *rootnm, *suffix;
split_root_suffix(argv[1], &rootnm, &suffix);
outname = (char *) calloc(strlen(rootnm) + 5, sizeof(char));
sprintf(outname, "%s.dat", rootnm);
free(rootnm);
free(suffix);
}
if (argc == 3) {
offset = strtod(argv[2], NULL);
printf(" Converting, adding %g, and writing to '%s'...", offset, outname);
} else {
printf(" Converting the data and writing to '%s'...", outname);
}
fflush(NULL);
infile = chkfopen(argv[1], "rb");
outfile = chkfopen(outname, "wb");
while ((numread = chkfread(sbuffer, sizeof(short), BUFFLEN, infile))) {
N += numread;
for (ii = 0; ii < numread; ii++)
fbuffer[ii] = (float) (sbuffer[ii]) + offset;
fwrite(fbuffer, sizeof(float), numread, outfile);
}
printf("done.\n Wrote %lld points.\n\n", N);
fclose(infile);
fclose(outfile);
free(outname);
exit(0);
}
void read_dftvector(dftvector * data, char *filename)
/* Read a dftvector data structure from a binary file */
{
FILE *infile;
int ii;
double dtmp;
infile = chkfopen(filename, "rb");
chkfread(&dtmp, sizeof(double), 1, infile);
data->n = (int) dtmp;
chkfread(&dtmp, sizeof(double), 1, infile);
data->numvect = (int) dtmp;
chkfread(&data->dt, sizeof(double), 1, infile);
chkfread(&data->r, sizeof(double), 1, infile);
chkfread(&data->norm, sizeof(double), 1, infile);
chkfread(&data->T, sizeof(double), 1, infile);
data->vector = gen_cvect(data->n);
for (ii = 0; ii < data->numvect; ii++) {
chkfread(&dtmp, sizeof(double), 1, infile);
data->vector[ii].r = (float) dtmp;
chkfread(&dtmp, sizeof(double), 1, infile);
data->vector[ii].i = (float) dtmp;
}
fclose(infile);
}
void write_mask(char *maskfilenm, mask * obsmask)
/* Write the contents of an mask structure to a file */
{
FILE *outfile;
int ii;
outfile = chkfopen(maskfilenm, "wb");
chkfwrite(&(obsmask->timesigma), sizeof(double), 1, outfile);
chkfwrite(&(obsmask->freqsigma), sizeof(double), 1, outfile);
chkfwrite(&(obsmask->mjd), sizeof(double), 1, outfile);
chkfwrite(&(obsmask->dtint), sizeof(double), 1, outfile);
chkfwrite(&(obsmask->lofreq), sizeof(double), 1, outfile);
chkfwrite(&(obsmask->dfreq), sizeof(double), 1, outfile);
chkfwrite(&(obsmask->numchan), sizeof(int), 1, outfile);
chkfwrite(&(obsmask->numint), sizeof(int), 1, outfile);
chkfwrite(&(obsmask->ptsperint), sizeof(int), 1, outfile);
chkfwrite(&(obsmask->num_zap_chans), sizeof(int), 1, outfile);
if (obsmask->num_zap_chans)
chkfwrite(obsmask->zap_chans, sizeof(int), obsmask->num_zap_chans, outfile);
chkfwrite(&(obsmask->num_zap_ints), sizeof(int), 1, outfile);
if (obsmask->num_zap_ints)
chkfwrite(obsmask->zap_ints, sizeof(int), obsmask->num_zap_ints, outfile);
chkfwrite(obsmask->num_chans_per_int, sizeof(int), obsmask->numint, outfile);
for (ii = 0; ii < obsmask->numint; ii++) {
if (obsmask->num_chans_per_int[ii] > 0 &&
obsmask->num_chans_per_int[ii] < obsmask->numchan) {
chkfwrite(obsmask->chans[ii], sizeof(int),
obsmask->num_chans_per_int[ii], outfile);
}
}
fclose(outfile);
}
int read_database(void)
/* Reads the full pulsar database into the static array psrdata */
{
FILE *database;
char databasenm[200];
psrdata pdata;
binpsrdata bpdata;
/* Open the binary data file */
sprintf(databasenm, "%s/lib/pulsars.cat", getenv("PRESTO"));
database = chkfopen(databasenm, "rb");
while (chkfread(&pdata, sizeof(psrdata), 1, database)) {
if (np >= NP) {
printf("NP value set to small (%d) in $PRESTO/include/database.h\n", NP);
printf("Please increase it and recompile\n");
exit(-1);
}
strncpy(pulsardata[np].jname, pdata.jname, 13);
strncpy(pulsardata[np].bname, pdata.bname, 9);
strncpy(pulsardata[np].alias, pdata.alias, 10);
pulsardata[np].ra2000 = pdata.ra2000;
pulsardata[np].dec2000 = pdata.dec2000;
pulsardata[np].dm = pdata.dm;
pulsardata[np].timepoch = pdata.timepoch;
pulsardata[np].p = pdata.p;
pulsardata[np].pd = pdata.pd;
pulsardata[np].pdd = 0.0;
pulsardata[np].f = 1.0 / pdata.p;
pulsardata[np].fd = -pdata.pd / (pdata.p * pdata.p);
pulsardata[np].fdd = 0.0;
if (pdata.binary == 1.0) {
chkfread(&bpdata, sizeof(binpsrdata), 1, database);
pulsardata[np].orb.p = bpdata.pb;
pulsardata[np].orb.e = bpdata.e;
pulsardata[np].orb.x = bpdata.x;
pulsardata[np].orb.w = bpdata.w;
pulsardata[np].orb.t = bpdata.To;
} else {
pulsardata[np].orb.p = 0.0;
pulsardata[np].orb.e = 0.0;
pulsardata[np].orb.x = 0.0;
pulsardata[np].orb.w = 0.0;
pulsardata[np].orb.t = 0.0;
}
pulsardata[np].orb.pd = 0.0;
pulsardata[np].orb.wd = 0.0;
np++;
};
/* Close the database */
fclose(database);
have_database = 1;
return np;
}
int determine_padvals(char *maskfilenm, mask * obsmask, float *padvals[])
/* Determine reasonable padding values from the rfifind produced */
/* *.stats file if it is available. Return the allocated vector */
/* (of length numchan) in padvals. Return a '1' if the routine */
/* used the stats file, return 0 if the padding was set to aeros. */
{
FILE *statsfile;
int ii, numchan, numint, ptsperint, lobin, numbetween;
float **dataavg, tmp1, tmp2;
char *statsfilenm, *root, *suffix;
if (split_root_suffix(maskfilenm, &root, &suffix) == 0) {
printf("\nThe mask filename (%s) must have a suffix!\n\n", maskfilenm);
exit(1);
} else {
/* Determine the stats file name */
statsfilenm = calloc(strlen(maskfilenm) + 2, sizeof(char));
sprintf(statsfilenm, "%s.stats", root);
free(root);
free(suffix);
*padvals = gen_fvect(obsmask->numchan);
/* Check to see if the file exists */
printf("Attempting to read the data statistics from '%s'...\n", statsfilenm);
statsfile = chkfopen(statsfilenm, "rb");
free(statsfilenm);
if (statsfile) { /* Read the stats */
chkfread(&numchan, sizeof(int), 1, statsfile);
chkfread(&numint, sizeof(int), 1, statsfile);
chkfread(&ptsperint, sizeof(int), 1, statsfile);
chkfread(&lobin, sizeof(int), 1, statsfile);
chkfread(&numbetween, sizeof(int), 1, statsfile);
dataavg = gen_fmatrix(numint, numchan);
/* These are the powers */
chkfread(dataavg[0], sizeof(float), numchan * numint, statsfile);
/* These are the averages */
chkfread(dataavg[0], sizeof(float), numchan * numint, statsfile);
/* Set the padding values equal to the mid-80% channel averages */
for (ii = 0; ii < numchan; ii++)
calc_avgmedstd(dataavg[0] + ii, numint, 0.8, numchan,
*padvals + ii, &tmp1, &tmp2);
printf
("...succeded. Set the padding values equal to the mid-80%% channel averages.\n");
vect_free(dataavg[0]);
vect_free(dataavg);
fclose(statsfile);
return 1;
} else {
/* This is a temporary solution */
for (ii = 0; ii < obsmask->numchan; ii++)
(*padvals)[ii] = 0.0;
printf("...failed.\n Set the padding values to 0.\n");
return 0;
}
}
}
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);
}
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 write_mak_file(makedata * mdata)
/* Write the data for makedata to the makefile. */
{
FILE *makefile;
char makefilenm[200];
int i;
sprintf(makefilenm, "%s.mak", mdata->basefilenm);
makefile = chkfopen(makefilenm, "w");
fprintf(makefile, "%s\n", mdata->description);
fprintf(makefile, "Num data pts = %ld\n", mdata->N);
fprintf(makefile, "dt per bin (s) = %25.15g\n", mdata->dt);
fprintf(makefile, "Pulse shape = %s", mdata->ptype);
if (mdata->pnum > 2) {
fprintf(makefile, " (FWHM = %g)", mdata->fwhm);
}
fprintf(makefile, "\nRounding format = %s\n", mdata->round);
fprintf(makefile, "Pulse freq (hz) = %25.15g\n", mdata->f);
fprintf(makefile, "fdot (s-2) = %25.15g\n", mdata->fd);
fprintf(makefile, "fdotdot (s-3) = %25.15g\n", mdata->fdd);
fprintf(makefile, "Pulse amp = %25.15g\n", mdata->amp);
fprintf(makefile, "Pulse phs (deg) = %25.15g\n", mdata->phs);
fprintf(makefile, "DC backgrnd level = %25.15g\n", mdata->dc);
fprintf(makefile, "Binary period (s) = %25.15g\n",
((mdata->binary) ? mdata->orb.p : 0.0));
fprintf(makefile, "Bin asini/c (s) = %25.15g\n",
((mdata->binary) ? mdata->orb.x : 0.0));
fprintf(makefile, "Bin eccentricity = %25.15g\n",
((mdata->binary) ? mdata->orb.e : 0.0));
fprintf(makefile, "Ang of Peri (deg) = %25.15g\n",
((mdata->binary) ? mdata->orb.w : 0.0));
fprintf(makefile, "Tm since peri (s) = %25.15g\n",
((mdata->binary) ? mdata->orb.t : 0.0));
fprintf(makefile, "Amp Mod amplitude = %25.15g\n",
((mdata->ampmod) ? mdata->ampmoda : 0.0));
fprintf(makefile, "Amp Mod phs (deg) = %25.15g\n",
((mdata->ampmod) ? mdata->ampmodp : 0.0));
fprintf(makefile, "Amp Mod freq (hz) = %25.15g\n",
((mdata->ampmod) ? mdata->ampmodf : 0.0));
fprintf(makefile, "Noise type = %s\n", mdata->noisetype);
fprintf(makefile, "Noise sigma = %25.15g\n", mdata->noisesig);
i = 0;
do {
fprintf(makefile, "On/Off Pair %2d = %g %g\n",
i + 1, mdata->onoff[2 * i], mdata->onoff[2 * i + 1]);
i++;
}
while (mdata->onoff[2 * i - 1] != 1.0);
fclose(makefile);
}
void read_offsets(float **loptr, float **optr, int numpts, int numchan)
{
static int firsttime = 1, useoffsets = 0;
static float *offsets1, *offsets2, *tempzz;
static FILE *offsetfile=NULL; //, *bandpassfile;
int ii;
if (firsttime) {
char *envval = getenv("OFFSETFILE");
if (envval != NULL) {
offsetfile = chkfopen(envval, "r");
if (offsetfile) {
printf("\nUsing offsets from the file '%s'.\n", envval);
useoffsets = 1;
}
}
/* Read the bandpass file */
//*bandpass = gen_fvect(numchan);
//printf("Reading 'bandpass.dat'\n");
//bandpassfile = chkfopen("bandpass.dat", "r");
//chkfread(*bandpass, sizeof(float), numchan, bandpassfile);
//fclose(bandpassfile);
offsets1 = gen_fvect(numpts);
offsets2 = gen_fvect(numpts);
*loptr = offsets2; // Start "backwards" since we'll switch them below
*optr = offsets1;
if (useoffsets) { // Read the data into offsets1
chkfread(*optr, sizeof(float), numpts, offsetfile);
for (ii = 0 ; ii < numpts ; ii++)
offsets1[ii] *= 1.0/(float)numchan;
} else { // Just fill the arrays with zeros
for (ii = 0 ; ii < numpts ; ii++) {
offsets1[ii] = 0.0;
offsets2[ii] = 0.0;
}
}
firsttime = 0;
return;
}
if (useoffsets) {
SWAP(*loptr, *optr); // Swap the buffer pointers
// Read the offsets and scale by the number of channels
chkfread(*optr, sizeof(float), numpts, offsetfile);
for (ii = 0 ; ii < numpts ; ii++)
(*optr)[ii] *= 1.0/(float)numchan;
}
}
static void write_statsfile(char *statsfilenm, float *datapow,
float *dataavg, float *datastd,
int numchan, int numint, int ptsperint,
int lobin, int numbetween)
{
FILE *outfile;
outfile = chkfopen(statsfilenm, "wb");
chkfwrite(&numchan, sizeof(int), 1, outfile);
chkfwrite(&numint, sizeof(int), 1, outfile);
chkfwrite(&ptsperint, sizeof(int), 1, outfile);
chkfwrite(&lobin, sizeof(int), 1, outfile);
chkfwrite(&numbetween, sizeof(int), 1, outfile);
chkfwrite(datapow, sizeof(float), numchan * numint, outfile);
chkfwrite(dataavg, sizeof(float), numchan * numint, outfile);
chkfwrite(datastd, sizeof(float), numchan * numint, outfile);
fclose(outfile);
}
void read_mask(char *maskfilenm, mask * obsmask)
/* Read the contents of a mask structure from a file */
{
FILE *infile;
int ii;
infile = chkfopen(maskfilenm, "rb");
chkfread(&(obsmask->timesigma), sizeof(double), 1, infile);
chkfread(&(obsmask->freqsigma), sizeof(double), 1, infile);
chkfread(&(obsmask->mjd), sizeof(double), 1, infile);
chkfread(&(obsmask->dtint), sizeof(double), 1, infile);
chkfread(&(obsmask->lofreq), sizeof(double), 1, infile);
chkfread(&(obsmask->dfreq), sizeof(double), 1, infile);
chkfread(&(obsmask->numchan), sizeof(int), 1, infile);
chkfread(&(obsmask->numint), sizeof(int), 1, infile);
chkfread(&(obsmask->ptsperint), sizeof(int), 1, infile);
chkfread(&(obsmask->num_zap_chans), sizeof(int), 1, infile);
if (obsmask->num_zap_chans) {
obsmask->zap_chans = gen_ivect(obsmask->num_zap_chans);
chkfread(obsmask->zap_chans, sizeof(int), obsmask->num_zap_chans, infile);
}
chkfread(&(obsmask->num_zap_ints), sizeof(int), 1, infile);
if (obsmask->num_zap_ints) {
obsmask->zap_ints = gen_ivect(obsmask->num_zap_ints);
chkfread(obsmask->zap_ints, sizeof(int), obsmask->num_zap_ints, infile);
}
obsmask->num_chans_per_int = gen_ivect(obsmask->numint);
chkfread(obsmask->num_chans_per_int, sizeof(int), obsmask->numint, infile);
obsmask->chans = (int **) malloc(obsmask->numint * sizeof(int *));
for (ii = 0; ii < obsmask->numint; ii++) {
if (obsmask->num_chans_per_int[ii] > 0 &&
obsmask->num_chans_per_int[ii] < obsmask->numchan) {
obsmask->chans[ii] = gen_ivect(obsmask->num_chans_per_int[ii]);
chkfread(obsmask->chans[ii], sizeof(int),
obsmask->num_chans_per_int[ii], infile);
} else if (obsmask->num_chans_per_int[ii] == obsmask->numchan) {
int jj;
obsmask->chans[ii] = gen_ivect(obsmask->num_chans_per_int[ii]);
for (jj = 0; jj < obsmask->numchan; jj++)
obsmask->chans[ii][jj] = jj;
}
}
fclose(infile);
}
static void read_statsfile(char *statsfilenm, float ***datapow,
float ***dataavg, float ***datastd,
int *numchan, int *numint, int *ptsperint,
int *lobin, int *numbetween)
{
FILE *outfile;
outfile = chkfopen(statsfilenm, "rb");
chkfread(numchan, sizeof(int), 1, outfile);
chkfread(numint, sizeof(int), 1, outfile);
chkfread(ptsperint, sizeof(int), 1, outfile);
chkfread(lobin, sizeof(int), 1, outfile);
chkfread(numbetween, sizeof(int), 1, outfile);
*dataavg = gen_fmatrix(*numint, *numchan);
*datastd = gen_fmatrix(*numint, *numchan);
*datapow = gen_fmatrix(*numint, *numchan);
chkfread(*(datapow[0]), sizeof(float), *numchan * *numint, outfile);
chkfread(*(dataavg[0]), sizeof(float), *numchan * *numint, outfile);
chkfread(*(datastd[0]), sizeof(float), *numchan * *numint, outfile);
fclose(outfile);
}
static void write_rfifile(char *rfifilenm, rfi * rfivect, int numrfi,
int numchan, int numint, int ptsperint,
int lobin, int numbetween, int harmsum,
float fracterror, float freqsigma)
{
FILE *outfile;
int ii;
outfile = chkfopen(rfifilenm, "wb");
chkfwrite(&numchan, sizeof(int), 1, outfile);
chkfwrite(&numint, sizeof(int), 1, outfile);
chkfwrite(&ptsperint, sizeof(int), 1, outfile);
chkfwrite(&lobin, sizeof(int), 1, outfile);
chkfwrite(&numbetween, sizeof(int), 1, outfile);
chkfwrite(&harmsum, sizeof(int), 1, outfile);
chkfwrite(&numrfi, sizeof(int), 1, outfile);
chkfwrite(&fracterror, sizeof(float), 1, outfile);
chkfwrite(&freqsigma, sizeof(float), 1, outfile);
for (ii = 0; ii < numrfi; ii++)
write_rfi(outfile, rfivect + ii, numchan, numint);
fclose(outfile);
}
void read_wgts_and_offs(char *filenm, int *numchan,
float **weights, float **offsets)
{
FILE *infile;
int N, chan;
float wgt, offs;
char line[80];
infile = chkfopen(filenm, "r");
// Read the input file once to count the lines
N = 0;
while (!feof(infile)){
fgets(line, 80, infile);
if (line[0]!='#') {
sscanf(line, "%d %f %f\n", &chan, &wgt, &offs);
N++;
}
}
N--;
*numchan = N;
// Allocate the output arrays
*weights = (float *)malloc(N * sizeof(float));
*offsets = (float *)malloc(N * sizeof(float));
// Rewind and read the EVENTs for real
rewind(infile);
N = 0;
while (!feof(infile)){
fgets(line, 80, infile);
if (line[0]!='#') {
sscanf(line, "%d %f %f\n", &chan, *weights+N, *offsets+N);
N++;
}
}
fclose(infile);
}
static void read_rfifile(char *rfifilenm, rfi ** rfivect, int *numrfi,
int *numchan, int *numint, int *ptsperint,
int *lobin, int *numbetween, int *harmsum,
float *fracterror, float *freqsigma)
{
FILE *outfile;
int ii;
outfile = chkfopen(rfifilenm, "rb");
chkfread(numchan, sizeof(int), 1, outfile);
chkfread(numint, sizeof(int), 1, outfile);
chkfread(ptsperint, sizeof(int), 1, outfile);
chkfread(lobin, sizeof(int), 1, outfile);
chkfread(numbetween, sizeof(int), 1, outfile);
chkfread(harmsum, sizeof(int), 1, outfile);
chkfread(numrfi, sizeof(int), 1, outfile);
chkfread(fracterror, sizeof(float), 1, outfile);
chkfread(freqsigma, sizeof(float), 1, outfile);
*rfivect = rfi_vector(*rfivect, *numchan, *numint, 0, *numrfi);
for (ii = 0; ii < *numrfi; ii++)
read_rfi(outfile, *rfivect + ii, *numchan, *numint);
fclose(outfile);
}
void write_dftvector(dftvector * data, char *filename)
/* Write a dftvector data structure to a binary file */
{
FILE *outfile;
int ii;
double dtmp;
outfile = chkfopen(filename, "wb");
dtmp = (double) data->n;
chkfwrite(&dtmp, sizeof(double), 1, outfile);
dtmp = (double) data->numvect;
chkfwrite(&dtmp, sizeof(double), 1, outfile);
chkfwrite(&data->dt, sizeof(double), 1, outfile);
chkfwrite(&data->r, sizeof(double), 1, outfile);
chkfwrite(&data->norm, sizeof(double), 1, outfile);
chkfwrite(&data->T, sizeof(double), 1, outfile);
for (ii = 0; ii < data->numvect; ii++) {
dtmp = (double) data->vector[ii].r;
chkfwrite(&dtmp, sizeof(double), 1, outfile);
dtmp = (double) data->vector[ii].i;
chkfwrite(&dtmp, sizeof(double), 1, outfile);
}
fclose(outfile);
}
void output_fundamentals(fourierprops * props, GSList * list,
accelobs * obs, infodata * idata)
{
double accel = 0.0, accelerr = 0.0, coherent_pow;
int ii, jj, numcols = 12, numcands, *width, *error;
int widths[12] = { 4, 5, 6, 8, 4, 16, 15, 15, 15, 11, 15, 20 };
int errors[12] = { 0, 0, 0, 0, 0, 1, 1, 2, 1, 2, 2, 0 };
char tmpstr[30], ctrstr[30], *notes;
accelcand *cand;
GSList *listptr;
rzwerrs errs;
static char **title;
static char *titles1[] = { "", "", "Summed", "Coherent", "Num", "Period",
"Frequency", "FFT 'r'", "Freq Deriv", "FFT 'z'",
"Accel", ""
};
static char *titles2[] = { "Cand", "Sigma", "Power", "Power", "Harm", "(ms)",
"(Hz)", "(bin)", "(Hz/s)", "(bins)",
"(m/s^2)", "Notes"
};
numcands = g_slist_length(list);
listptr = list;
/* Close the old work file and open the cand file */
if (!obs->dat_input)
fclose(obs->workfile); /* Why is this here? -A */
obs->workfile = chkfopen(obs->accelnm, "w");
/* Set our candidate notes to all spaces */
notes = (char *) malloc(numcands * widths[numcols - 1]);
memset(notes, ' ', numcands * widths[numcols - 1]);
/* Compare the candidates with the pulsar database */
if (dms2rad(idata->ra_h, idata->ra_m, idata->ra_s) != 0.0 &&
hms2rad(idata->dec_d, idata->dec_m, idata->dec_s) != 0.0) {
for (ii = 0; ii < numcands; ii++) {
comp_psr_to_cand(props + ii, idata, notes + ii * 20, 0);
}
}
/* Compare the candidates with themselves */
compare_rzw_cands(props, numcands, notes);
/* Print the header */
width = widths;
title = titles1;
for (ii = 0; ii < numcols - 1; ii++) {
center_string(ctrstr, *title++, *width++);
fprintf(obs->workfile, "%s ", ctrstr);
}
center_string(ctrstr, *title++, *width++);
fprintf(obs->workfile, "%s\n", ctrstr);
width = widths;
title = titles2;
for (ii = 0; ii < numcols - 1; ii++) {
center_string(ctrstr, *title++, *width++);
fprintf(obs->workfile, "%s ", ctrstr);
}
center_string(ctrstr, *title++, *width++);
fprintf(obs->workfile, "%s\n", ctrstr);
width = widths;
for (ii = 0; ii < numcols - 1; ii++) {
memset(tmpstr, '-', *width);
tmpstr[*width++] = '\0';
fprintf(obs->workfile, "%s--", tmpstr);
}
memset(tmpstr, '-', *width++);
tmpstr[widths[ii]] = '\0';
fprintf(obs->workfile, "%s\n", tmpstr);
/* Print the fundamentals */
for (ii = 0; ii < numcands; ii++) {
width = widths;
error = errors;
cand = (accelcand *) (listptr->data);
calc_rzwerrs(props + ii, obs->T, &errs);
{ /* Calculate the coherently summed power */
double coherent_r = 0.0, coherent_i = 0.0;
double phs0, phscorr, amp;
rderivs harm;
/* These phase calculations assume the fundamental is best */
/* Better to irfft them and check the amplitude */
phs0 = cand->derivs[0].phs;
for (jj = 0; jj < cand->numharm; jj++) {
harm = cand->derivs[jj];
if (obs->nph > 0.0)
amp = sqrt(harm.pow / obs->nph);
else
amp = sqrt(harm.pow / harm.locpow);
phscorr = phs0 - fmod((jj + 1.0) * phs0, TWOPI);
coherent_r += amp * cos(harm.phs + phscorr);
coherent_i += amp * sin(harm.phs + phscorr);
}
coherent_pow = coherent_r * coherent_r + coherent_i * coherent_i;
}
sprintf(tmpstr, "%-4d", ii + 1);
center_string(ctrstr, tmpstr, *width++);
error++;
fprintf(obs->workfile, "%s ", ctrstr);
sprintf(tmpstr, "%.2f", cand->sigma);
center_string(ctrstr, tmpstr, *width++);
error++;
fprintf(obs->workfile, "%s ", ctrstr);
sprintf(tmpstr, "%.2f", cand->power);
center_string(ctrstr, tmpstr, *width++);
error++;
fprintf(obs->workfile, "%s ", ctrstr);
sprintf(tmpstr, "%.2f", coherent_pow);
center_string(ctrstr, tmpstr, *width++);
error++;
fprintf(obs->workfile, "%s ", ctrstr);
sprintf(tmpstr, "%d", cand->numharm);
center_string(ctrstr, tmpstr, *width++);
error++;
fprintf(obs->workfile, "%s ", ctrstr);
write_val_with_err(obs->workfile, errs.p * 1000.0, errs.perr * 1000.0,
*error++, *width++);
write_val_with_err(obs->workfile, errs.f, errs.ferr, *error++, *width++);
write_val_with_err(obs->workfile, props[ii].r, props[ii].rerr,
*error++, *width++);
write_val_with_err(obs->workfile, errs.fd, errs.fderr, *error++, *width++);
write_val_with_err(obs->workfile, props[ii].z, props[ii].zerr,
*error++, *width++);
accel = props[ii].z * SOL / (obs->T * obs->T * errs.f);
accelerr = props[ii].zerr * SOL / (obs->T * obs->T * errs.f);
write_val_with_err(obs->workfile, accel, accelerr, *error++, *width++);
fprintf(obs->workfile, " %.20s\n", notes + ii * 20);
fflush(obs->workfile);
listptr = listptr->next;
}
fprintf(obs->workfile, "\n\n");
free(notes);
}
void create_accelobs(accelobs * obs, infodata * idata, Cmdline * cmd, int usemmap)
{
int ii, rootlen, input_shorts = 0;
{
int hassuffix = 0;
char *suffix;
hassuffix = split_root_suffix(cmd->argv[0], &(obs->rootfilenm), &suffix);
if (hassuffix) {
if (strcmp(suffix, "fft") != 0 &&
strcmp(suffix, "dat") != 0 && strcmp(suffix, "sdat") != 0) {
printf("\nInput file ('%s') must be an '.fft' or '.[s]dat' file!\n\n",
cmd->argv[0]);
free(suffix);
exit(0);
}
/* If the input file is a time series */
if (strcmp(suffix, "dat") == 0 || strcmp(suffix, "sdat") == 0) {
obs->dat_input = 1;
obs->mmap_file = 0;
if (strcmp(suffix, "sdat") == 0)
input_shorts = 1;
} else {
obs->dat_input = 0;
}
free(suffix);
} else {
printf("\nInput file ('%s') must be an '.fft' or '.[s]dat' file!\n\n",
cmd->argv[0]);
exit(0);
}
}
if (cmd->noharmpolishP)
obs->use_harmonic_polishing = 0;
else
obs->use_harmonic_polishing = 1; // now default
/* Read the info file */
readinf(idata, obs->rootfilenm);
if (idata->object) {
printf("Analyzing %s data from '%s'.\n\n",
remove_whitespace(idata->object), cmd->argv[0]);
} else {
printf("Analyzing data from '%s'.\n\n", cmd->argv[0]);
}
/* Prepare the input time series if required */
if (obs->dat_input) {
FILE *datfile;
long long filelen;
float *ftmp;
printf("Reading and FFTing the time series...");
fflush(NULL);
datfile = chkfopen(cmd->argv[0], "rb");
/* Check the length of the file to see if we can handle it */
filelen = chkfilelen(datfile, sizeof(float));
if (input_shorts)
filelen *= 2;
if (filelen > 67108864) { /* Small since we need memory for the templates */
printf("\nThe input time series is too large. Use 'realfft' first.\n\n");
exit(0);
}
/* Read the time series into a temporary buffer */
/* Note: The padding allows us to search very short time series */
/* using correlations without having to worry about */
/* accessing data before or after the valid FFT freqs. */
if (input_shorts) {
short *stmp = gen_svect(filelen);
ftmp = gen_fvect(filelen+2*ACCEL_PADDING);
for (ii = 0; ii < ACCEL_PADDING; ii++) {
ftmp[ii] = 0.0;
ftmp[ii+filelen+ACCEL_PADDING] = 0.0;
}
chkfread(stmp, sizeof(short), filelen, datfile);
for (ii = 0; ii < filelen; ii++)
ftmp[ii+ACCEL_PADDING] = (float) stmp[ii];
free(stmp);
} else {
ftmp = read_float_file(datfile, -ACCEL_PADDING, filelen+2*ACCEL_PADDING);
}
/* Now, offset the pointer so that we are pointing at the first */
/* bits of valid data. */
ftmp += ACCEL_PADDING;
fclose(datfile);
/* FFT it */
realfft(ftmp, filelen, -1);
obs->fftfile = NULL;
obs->fft = (fcomplex *) ftmp;
obs->numbins = filelen / 2;
printf("done.\n");
/* De-redden it */
printf("Removing red-noise...");
deredden(obs->fft, obs->numbins);
printf("done.\n\n");
}
/* Determine the output filenames */
rootlen = strlen(obs->rootfilenm) + 25;
obs->candnm = (char *) calloc(rootlen, 1);
obs->accelnm = (char *) calloc(rootlen, 1);
obs->workfilenm = (char *) calloc(rootlen, 1);
sprintf(obs->candnm, "%s_ACCEL_%d.cand", obs->rootfilenm, cmd->zmax);
sprintf(obs->accelnm, "%s_ACCEL_%d", obs->rootfilenm, cmd->zmax);
sprintf(obs->workfilenm, "%s_ACCEL_%d.txtcand", obs->rootfilenm, cmd->zmax);
/* Open the FFT file if it exists appropriately */
if (!obs->dat_input) {
obs->fftfile = chkfopen(cmd->argv[0], "rb");
obs->numbins = chkfilelen(obs->fftfile, sizeof(fcomplex));
if (usemmap) {
fclose(obs->fftfile);
obs->fftfile = NULL;
printf("Memory mapping the input FFT. This may take a while...\n");
obs->mmap_file = open(cmd->argv[0], O_RDONLY);
if (obs->mmap_file == -1) {
perror("\nError in open() in accel_utils.c");
printf("\n");
exit(-1);
}
obs->fft = (fcomplex *) mmap(0, sizeof(fcomplex) * obs->numbins, PROT_READ,
MAP_SHARED, obs->mmap_file, 0);
if (obs->fft == MAP_FAILED) {
perror("\nError in mmap() in accel_utils.c");
printf("Falling back to a non-mmaped approach\n");
obs->fftfile = chkfopen(cmd->argv[0], "rb");
obs->mmap_file = 0;
}
} else {
obs->mmap_file = 0;
}
}
/* Determine the other parameters */
if (cmd->zmax % ACCEL_DZ)
cmd->zmax = (cmd->zmax / ACCEL_DZ + 1) * ACCEL_DZ;
if (!obs->dat_input)
obs->workfile = chkfopen(obs->workfilenm, "w");
obs->N = (long long) idata->N;
if (cmd->photonP) {
if (obs->mmap_file || obs->dat_input) {
obs->nph = obs->fft[0].r;
} else {
obs->nph = get_numphotons(obs->fftfile);
}
printf("Normalizing powers using %.0f photons.\n\n", obs->nph);
} else {
obs->nph = 0.0;
/* For short FFTs insure that we don't pick up the DC */
/* or Nyquist component as part of the interpolation */
/* for higher frequencies. */
if (cmd->locpowP) {
obs->norm_type = 1;
printf("Normalizing powers using local-power determination.\n\n");
} else if (cmd->medianP) {
obs->norm_type = 0;
printf("Normalizing powers using median-blocks.\n\n");
} else {
obs->norm_type = 0;
printf("Normalizing powers using median-blocks (default).\n\n");
}
if (obs->dat_input) {
obs->fft[0].r = 1.0;
obs->fft[0].i = 1.0;
}
}
obs->lobin = cmd->lobin;
if (obs->lobin > 0) {
obs->nph = 0.0;
if (cmd->lobin > obs->numbins - 1) {
printf("\n'lobin' is greater than the total number of\n");
printf(" frequencies in the data set. Exiting.\n\n");
exit(1);
}
}
if (cmd->numharm != 1 &&
cmd->numharm != 2 &&
cmd->numharm != 4 && cmd->numharm != 8 && cmd->numharm != 16) {
printf("\n'numharm' = %d must be a power-of-two! Exiting\n\n", cmd->numharm);
exit(1);
}
obs->numharmstages = twon_to_index(cmd->numharm) + 1;
obs->dz = ACCEL_DZ;
obs->numz = cmd->zmax * 2 + 1;
obs->numbetween = ACCEL_NUMBETWEEN;
obs->dt = idata->dt;
obs->T = idata->dt * idata->N;
if (cmd->floP) {
obs->rlo = floor(cmd->flo * obs->T);
if (obs->rlo < obs->lobin)
obs->rlo = obs->lobin;
if (obs->rlo > obs->numbins - 1) {
printf("\nLow frequency to search 'flo' is greater than\n");
printf(" the highest available frequency. Exiting.\n\n");
exit(1);
}
} else {
if (cmd->rloP)
obs->rlo = cmd->rlo;
else
obs->rlo = 1.0;
if (obs->rlo < obs->lobin)
obs->rlo = obs->lobin;
if (obs->rlo > obs->numbins - 1) {
printf("\nLow frequency to search 'rlo' is greater than\n");
printf(" the available number of points. Exiting.\n\n");
exit(1);
}
}
obs->highestbin = obs->numbins - 1;
if (cmd->fhiP) {
obs->highestbin = ceil(cmd->fhi * obs->T);
if (obs->highestbin > obs->numbins - 1)
obs->highestbin = obs->numbins - 1;
obs->rhi = obs->highestbin;
if (obs->highestbin < obs->rlo) {
printf("\nHigh frequency to search 'fhi' is less than\n");
printf(" the lowest frequency to search 'flo'. Exiting.\n\n");
exit(1);
}
} else if (cmd->rhiP) {
obs->highestbin = cmd->rhi;
if (obs->highestbin > obs->numbins - 1)
obs->highestbin = obs->numbins - 1;
obs->rhi = obs->highestbin;
if (obs->highestbin < obs->rlo) {
printf("\nHigh frequency to search 'rhi' is less than\n");
printf(" the lowest frequency to search 'rlo'. Exiting.\n\n");
exit(1);
}
}
obs->dr = ACCEL_DR;
obs->zhi = cmd->zmax;
obs->zlo = -cmd->zmax;
obs->sigma = cmd->sigma;
obs->powcut = (float *) malloc(obs->numharmstages * sizeof(float));
obs->numindep = (long long *) malloc(obs->numharmstages * sizeof(long long));
for (ii = 0; ii < obs->numharmstages; ii++) {
if (obs->numz == 1)
obs->numindep[ii] = (obs->rhi - obs->rlo) / index_to_twon(ii);
else
/* The numz+1 takes care of the small amount of */
/* search we get above zmax and below zmin. */
obs->numindep[ii] = (obs->rhi - obs->rlo) * (obs->numz + 1) *
(obs->dz / 6.95) / index_to_twon(ii);
obs->powcut[ii] = power_for_sigma(obs->sigma,
index_to_twon(ii), obs->numindep[ii]);
}
obs->numzap = 0;
/*
if (zapfile!=NULL)
obs->numzap = get_birdies(cmd->zapfile, obs->T, obs->baryv,
&(obs->lobins), &(obs->hibins));
else
obs->numzap = 0;
*/
}
int main(int argc, char *argv[])
{
/* Any variable that begins with 't' means topocentric */
/* Any variable that begins with 'b' means barycentric */
FILE **outfiles = NULL;
float **outdata;
double dtmp, *dms, avgdm = 0.0, dsdt = 0, maxdm;
double *dispdt, tlotoa = 0.0, blotoa = 0.0, BW_ddelay = 0.0;
double max = -9.9E30, min = 9.9E30, var = 0.0, avg = 0.0;
double *btoa = NULL, *ttoa = NULL, avgvoverc = 0.0;
char obs[3], ephem[10], rastring[50], decstring[50];
long totnumtowrite, totwrote = 0, padwrote = 0, datawrote = 0;
int *idispdt, **offsets;
int ii, jj, numadded = 0, numremoved = 0, padding = 0, good_inputs = 1;
int numbarypts = 0, numread = 0, numtowrite = 0;
int padtowrite = 0, statnum = 0;
int numdiffbins = 0, *diffbins = NULL, *diffbinptr = NULL, good_padvals = 0;
double local_lodm;
char *datafilenm, *outpath, *outfilenm, *hostname;
struct spectra_info s;
infodata idata;
mask obsmask;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
#ifdef _OPENMP
omp_set_num_threads(1); // Explicitly turn off OpenMP
#endif
set_using_MPI();
{
FILE *hostfile;
char tmpname[100];
int retval;
hostfile = chkfopen("/etc/hostname", "r");
retval = fscanf(hostfile, "%s\n", tmpname);
if (retval==0) {
printf("Warning: error reading /etc/hostname on proc %d\n", myid);
}
hostname = (char *) calloc(strlen(tmpname) + 1, 1);
memcpy(hostname, tmpname, strlen(tmpname));
fclose(hostfile);
}
/* Call usage() if we have no command line arguments */
if (argc == 1) {
if (myid == 0) {
Program = argv[0];
usage();
}
MPI_Finalize();
exit(1);
}
make_maskbase_struct();
make_spectra_info_struct();
/* Parse the command line using the excellent program Clig */
cmd = parseCmdline(argc, argv);
spectra_info_set_defaults(&s);
// If we are zeroDMing, make sure that clipping is off.
if (cmd->zerodmP) cmd->noclipP = 1;
s.clip_sigma = cmd->clip;
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->numoutP)
cmd->numout = LONG_MAX;
#ifdef DEBUG
showOptionValues();
#endif
if (myid == 0) { /* Master node only */
printf("\n\n");
printf(" Parallel Pulsar Subband De-dispersion Routine\n");
printf(" by Scott M. Ransom\n\n");
s.filenames = cmd->argv;
s.num_files = cmd->argc;
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 (RAWDATA) {
if (cmd->filterbankP) s.datatype = SIGPROCFB;
else if (cmd->psrfitsP) s.datatype = PSRFITS;
else if (cmd->pkmbP) s.datatype = SCAMP;
else if (cmd->bcpmP) s.datatype = BPP;
else if (cmd->wappP) s.datatype = WAPP;
else if (cmd->spigotP) s.datatype = SPIGOT;
} 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==SCAMP) cmd->pkmbP = 1;
else if (s.datatype==BPP) cmd->bcpmP = 1;
else if (s.datatype==WAPP) cmd->wappP = 1;
else if (s.datatype==SPIGOT) cmd->spigotP = 1;
else if (s.datatype==SUBBAND) insubs = 1;
else {
printf("\nError: Unable to identify input data files. Please specify type.\n\n");
good_inputs = 0;
}
}
// So far we can only handle PSRFITS, filterbank, and subbands
if (s.datatype!=PSRFITS &&
s.datatype!=SIGPROCFB &&
s.datatype!=SUBBAND) good_inputs = 0;
// For subbanded data
if (!RAWDATA) s.files = (FILE **)malloc(sizeof(FILE *) * s.num_files);
if (good_inputs && (RAWDATA || insubs)) {
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]);
if (insubs) s.files[ii] = chkfopen(s.filenames[ii], "rb");
}
printf("\n");
if (RAWDATA) {
read_rawdata_files(&s);
print_spectra_info_summary(&s);
spectra_info_to_inf(&s, &idata);
} else { // insubs
char *root, *suffix;
cmd->nsub = s.num_files;
s.N = chkfilelen(s.files[0], sizeof(short));
s.start_subint = gen_ivect(1);
s.num_subint = gen_ivect(1);
s.start_MJD = (long double *)malloc(sizeof(long double));
s.start_spec = (long long *)malloc(sizeof(long long));
s.num_spec = (long long *)malloc(sizeof(long long));
s.num_pad = (long long *)malloc(sizeof(long long));
s.start_spec[0] = 0L;
s.start_subint[0] = 0;
s.num_spec[0] = s.N;
s.num_subint[0] = s.N / SUBSBLOCKLEN;
s.num_pad[0] = 0L;
s.padvals = gen_fvect(s.num_files);
for (ii = 0 ; ii < ii ; ii++)
s.padvals[ii] = 0.0;
if (split_root_suffix(s.filenames[0], &root, &suffix) == 0) {
printf("\nError: The input filename (%s) must have a suffix!\n\n", s.filenames[0]);
exit(1);
}
if (strncmp(suffix, "sub", 3) == 0) {
char *tmpname;
tmpname = calloc(strlen(root) + 10, 1);
sprintf(tmpname, "%s.sub", root);
readinf(&idata, tmpname);
free(tmpname);
strncpy(s.telescope, idata.telescope, 40);
strncpy(s.backend, idata.instrument, 40);
strncpy(s.observer, idata.observer, 40);
strncpy(s.source, idata.object, 40);
s.ra2000 = hms2rad(idata.ra_h, idata.ra_m,
idata.ra_s) * RADTODEG;
s.dec2000 = dms2rad(idata.dec_d, idata.dec_m,
idata.dec_s) * RADTODEG;
ra_dec_to_string(s.ra_str,
idata.ra_h, idata.ra_m, idata.ra_s);
ra_dec_to_string(s.dec_str,
idata.dec_d, idata.dec_m, idata.dec_s);
s.num_channels = idata.num_chan;
s.start_MJD[0] = idata.mjd_i + idata.mjd_f;
s.dt = idata.dt;
s.T = s.N * s.dt;
s.lo_freq = idata.freq;
s.df = idata.chan_wid;
s.hi_freq = s.lo_freq + (s.num_channels - 1.0) * s.df;
s.BW = s.num_channels * s.df;
s.fctr = s.lo_freq - 0.5 * s.df + 0.5 * s.BW;
s.beam_FWHM = idata.fov / 3600.0;
s.spectra_per_subint = SUBSBLOCKLEN;
print_spectra_info_summary(&s);
} else {
printf("\nThe input files (%s) must be subbands! (i.e. *.sub##)\n\n",
cmd->argv[0]);
MPI_Finalize();
exit(1);
}
free(root);
free(suffix);
}
}
}
// If we don't have good input data, exit
MPI_Bcast(&good_inputs, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (!good_inputs) {
MPI_Finalize();
exit(1);
}
MPI_Bcast(&insubs, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (insubs)
cmd->nsub = cmd->argc;
/* Determine the output file names and open them */
local_numdms = cmd->numdms / (numprocs - 1);
dms = gen_dvect(local_numdms);
if (cmd->numdms % (numprocs - 1)) {
if (myid == 0)
printf
("\nThe number of DMs must be divisible by (the number of processors - 1).\n\n");
MPI_Finalize();
exit(1);
}
local_lodm = cmd->lodm + (myid - 1) * local_numdms * cmd->dmstep;
split_path_file(cmd->outfile, &outpath, &outfilenm);
datafilenm = (char *) calloc(strlen(outfilenm) + 20, 1);
if (myid > 0) {
if (chdir(outpath) == -1) {
printf("\nProcess %d on %s cannot chdir() to '%s'. Exiting.\n\n",
myid, hostname, outpath);
MPI_Finalize();
exit(1);
}
outfiles = (FILE **) malloc(local_numdms * sizeof(FILE *));
for (ii = 0; ii < local_numdms; ii++) {
dms[ii] = local_lodm + ii * cmd->dmstep;
avgdm += dms[ii];
sprintf(datafilenm, "%s_DM%.2f.dat", outfilenm, dms[ii]);
outfiles[ii] = chkfopen(datafilenm, "wb");
}
avgdm /= local_numdms;
}
// Broadcast the raw data information
broadcast_spectra_info(&s, myid);
if (myid > 0) {
spectra_info_to_inf(&s, &idata);
if (s.datatype==SIGPROCFB) cmd->filterbankP = 1;
else if (s.datatype==PSRFITS) cmd->psrfitsP = 1;
else if (s.datatype==SCAMP) cmd->pkmbP = 1;
else if (s.datatype==BPP) cmd->bcpmP = 1;
else if (s.datatype==WAPP) cmd->wappP = 1;
else if (s.datatype==SPIGOT) cmd->spigotP = 1;
else if (s.datatype==SUBBAND) insubs = 1;
}
s.filenames = cmd->argv;
/* Read an input mask if wanted */
if (myid > 0) {
int numpad = s.num_channels;
if (insubs)
numpad = s.num_files;
s.padvals = gen_fvect(numpad);
for (ii = 0 ; ii < numpad ; ii++)
s.padvals[ii] = 0.0;
}
if (cmd->maskfileP) {
if (myid == 0) {
read_mask(cmd->maskfile, &obsmask);
printf("Read mask information from '%s'\n\n", cmd->maskfile);
good_padvals = determine_padvals(cmd->maskfile, &obsmask, s.padvals);
}
broadcast_mask(&obsmask, myid);
MPI_Bcast(&good_padvals, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(s.padvals, obsmask.numchan, MPI_FLOAT, 0, MPI_COMM_WORLD);
} else {
obsmask.numchan = obsmask.numint = 0;
MPI_Bcast(&good_padvals, 1, MPI_INT, 0, MPI_COMM_WORLD);
}
// The number of topo to bary time points to generate with TEMPO
numbarypts = (int) (s.T * 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);
}
// Broadcast or calculate a few extra important values
if (insubs) avgdm = idata.dm;
idata.dm = avgdm;
dsdt = cmd->downsamp * idata.dt;
maxdm = cmd->lodm + cmd->numdms * cmd->dmstep;
BW_ddelay = delay_from_dm(maxdm, idata.freq) -
delay_from_dm(maxdm, idata.freq + (idata.num_chan-1) * idata.chan_wid);
blocksperread = ((int) (BW_ddelay / idata.dt) / s.spectra_per_subint + 1);
worklen = s.spectra_per_subint * blocksperread;
if (cmd->nsub > s.num_channels) {
printf
("Warning: The number of requested subbands (%d) is larger than the number of channels (%d).\n",
cmd->nsub, s.num_channels);
printf(" Re-setting the number of subbands to %d.\n\n", s.num_channels);
cmd->nsub = s.num_channels;
}
if (s.spectra_per_subint % cmd->downsamp) {
if (myid == 0) {
printf
("\nError: The downsample factor (%d) must be a factor of the\n",
cmd->downsamp);
printf(" blocklength (%d). Exiting.\n\n", s.spectra_per_subint);
}
MPI_Finalize();
exit(1);
}
tlotoa = idata.mjd_i + idata.mjd_f; /* Topocentric epoch */
if (cmd->numoutP)
totnumtowrite = cmd->numout;
else
totnumtowrite = (long) idata.N / cmd->downsamp;
if (cmd->nobaryP) { /* Main loop if we are not barycentering... */
/* Dispersion delays (in bins). The high freq gets no delay */
/* All other delays are positive fractions of bin length (dt) */
dispdt = subband_search_delays(s.num_channels, cmd->nsub, avgdm,
idata.freq, idata.chan_wid, 0.0);
idispdt = gen_ivect(s.num_channels);
for (ii = 0; ii < s.num_channels; ii++)
idispdt[ii] = NEAREST_LONG(dispdt[ii] / idata.dt);
vect_free(dispdt);
/* The subband dispersion delays (see note above) */
offsets = gen_imatrix(local_numdms, cmd->nsub);
for (ii = 0; ii < local_numdms; ii++) {
double *subdispdt;
subdispdt = subband_delays(s.num_channels, cmd->nsub, dms[ii],
idata.freq, idata.chan_wid, 0.0);
dtmp = subdispdt[cmd->nsub - 1];
for (jj = 0; jj < cmd->nsub; jj++)
offsets[ii][jj] = NEAREST_LONG((subdispdt[jj] - dtmp) / dsdt);
vect_free(subdispdt);
}
/* Allocate our data array and start getting data */
if (myid == 0) {
printf("De-dispersing using %d subbands.\n", cmd->nsub);
if (cmd->downsamp > 1)
printf("Downsampling by a factor of %d (new dt = %.10g)\n",
cmd->downsamp, dsdt);
printf("\n");
}
/* Print the nodes and the DMs they are handling */
print_dms(hostname, myid, numprocs, local_numdms, dms);
outdata = gen_fmatrix(local_numdms, worklen / cmd->downsamp);
numread = get_data(outdata, blocksperread, &s,
&obsmask, idispdt, offsets, &padding);
while (numread == worklen) {
numread /= cmd->downsamp;
if (myid == 0)
print_percent_complete(totwrote, totnumtowrite);
/* Write the latest chunk of data, but don't */
/* write more than cmd->numout points. */
numtowrite = numread;
if (cmd->numoutP && (totwrote + numtowrite) > cmd->numout)
numtowrite = cmd->numout - totwrote;
if (myid > 0) {
write_data(outfiles, local_numdms, outdata, 0, numtowrite);
/* Update the statistics */
if (!padding) {
for (ii = 0; ii < numtowrite; ii++)
update_stats(statnum + ii, outdata[0][ii], &min, &max, &avg, &var);
statnum += numtowrite;
}
}
totwrote += numtowrite;
/* Stop if we have written out all the data we need to */
if (cmd->numoutP && (totwrote == cmd->numout))
break;
numread = get_data(outdata, blocksperread, &s,
&obsmask, idispdt, offsets, &padding);
}
datawrote = totwrote;
} else { /* Main loop if we are barycentering... */
/* 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 */
btoa = gen_dvect(numbarypts);
ttoa = gen_dvect(numbarypts);
for (ii = 0; ii < numbarypts; ii++)
ttoa[ii] = tlotoa + TDT * ii / SECPERDAY;
/* Call TEMPO for the barycentering */
if (myid == 0) {
double maxvoverc = -1.0, minvoverc = 1.0, *voverc = NULL;
printf("\nGenerating barycentric corrections...\n");
voverc = gen_dvect(numbarypts);
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);
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("De-dispersing using %d subbands.\n", cmd->nsub);
if (cmd->downsamp > 1) {
printf(" Downsample = %d\n", cmd->downsamp);
printf(" New sample dt = %.10g\n", dsdt);
}
printf("\n");
}
/* Print the nodes and the DMs they are handling */
print_dms(hostname, myid, numprocs, local_numdms, dms);
MPI_Bcast(btoa, numbarypts, MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(&avgvoverc, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
blotoa = btoa[0];
/* Dispersion delays (in bins). The high freq gets no delay */
/* All other delays are positive fractions of bin length (dt) */
dispdt = subband_search_delays(s.num_channels, cmd->nsub, avgdm,
idata.freq, idata.chan_wid, avgvoverc);
idispdt = gen_ivect(s.num_channels);
for (ii = 0; ii < s.num_channels; ii++)
idispdt[ii] = NEAREST_LONG(dispdt[ii] / idata.dt);
vect_free(dispdt);
/* The subband dispersion delays (see note above) */
offsets = gen_imatrix(local_numdms, cmd->nsub);
for (ii = 0; ii < local_numdms; ii++) {
double *subdispdt;
subdispdt = subband_delays(s.num_channels, cmd->nsub, dms[ii],
idata.freq, idata.chan_wid, avgvoverc);
dtmp = subdispdt[cmd->nsub - 1];
for (jj = 0; jj < cmd->nsub; jj++)
offsets[ii][jj] = NEAREST_LONG((subdispdt[jj] - dtmp) / dsdt);
vect_free(subdispdt);
}
/* Convert the bary TOAs to differences from the topo TOAs in */
/* units of bin length (dt) 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 */
outdata = gen_fmatrix(local_numdms, worklen / cmd->downsamp);
numread = get_data(outdata, blocksperread, &s,
&obsmask, idispdt, offsets, &padding);
while (numread == worklen) { /* Loop to read and write the data */
int numwritten = 0;
double block_avg, block_var;
numread /= cmd->downsamp;
/* Determine the approximate local average */
avg_var(outdata[0], numread, &block_avg, &block_var);
if (myid == 0)
print_percent_complete(totwrote, totnumtowrite);
/* 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;
if (cmd->numoutP && (totwrote + numtowrite) > cmd->numout)
numtowrite = cmd->numout - totwrote;
if (numtowrite > numread)
numtowrite = numread;
if (myid > 0) {
write_data(outfiles, local_numdms, outdata, 0, numtowrite);
/* Update the statistics */
if (!padding) {
for (ii = 0; ii < numtowrite; ii++)
update_stats(statnum + ii, outdata[0][ii], &min, &max, &avg, &var);
statnum += numtowrite;
}
}
datawrote += numtowrite;
totwrote += numtowrite;
numwritten += numtowrite;
if ((datawrote == abs(*diffbinptr)) &&
(numwritten != numread) &&
(totwrote < cmd->numout)) { /* Add/remove a bin */
int skip, nextdiffbin;
skip = numtowrite;
/* Write the rest of the data after adding/removing a bin */
do {
if (*diffbinptr > 0) {
/* Add a bin */
if (myid > 0)
write_padding(outfiles, local_numdms, block_avg, 1);
numadded++;
totwrote++;
} else {
/* Remove a bin */
numremoved++;
datawrote++;
numwritten++;
skip++;
}
diffbinptr++;
/* Write the part after the diffbin */
numtowrite = numread - numwritten;
if (cmd->numoutP && (totwrote + numtowrite) > cmd->numout)
numtowrite = cmd->numout - totwrote;
nextdiffbin = abs(*diffbinptr) - datawrote;
if (numtowrite > nextdiffbin)
numtowrite = nextdiffbin;
if (myid > 0) {
write_data(outfiles, local_numdms, outdata, skip, numtowrite);
/* Update the statistics and counters */
if (!padding) {
for (ii = 0; ii < numtowrite; ii++)
update_stats(statnum + ii,
outdata[0][skip + ii], &min, &max, &avg, &var);
statnum += numtowrite;
}
}
numwritten += numtowrite;
datawrote += numtowrite;
totwrote += numtowrite;
skip += numtowrite;
/* Stop if we have written out all the data we need to */
if (cmd->numoutP && (totwrote == cmd->numout))
break;
} while (numwritten < numread);
}
/* Stop if we have written out all the data we need to */
if (cmd->numoutP && (totwrote == cmd->numout))
break;
numread = get_data(outdata, blocksperread, &s,
&obsmask, idispdt, offsets, &padding);
}
}
if (myid > 0) {
/* Calculate the amount of padding we need */
if (cmd->numoutP && (cmd->numout > totwrote))
padwrote = padtowrite = cmd->numout - totwrote;
/* Write the new info file for the output data */
idata.dt = dsdt;
update_infodata(&idata, totwrote, padtowrite, diffbins,
numdiffbins, cmd->downsamp);
for (ii = 0; ii < local_numdms; ii++) {
idata.dm = dms[ii];
if (!cmd->nobaryP) {
double baryepoch, barydispdt, baryhifreq;
baryhifreq = idata.freq + (s.num_channels - 1) * idata.chan_wid;
barydispdt = delay_from_dm(dms[ii], doppler(baryhifreq, avgvoverc));
baryepoch = blotoa - (barydispdt / SECPERDAY);
idata.bary = 1;
idata.mjd_i = (int) floor(baryepoch);
idata.mjd_f = baryepoch - idata.mjd_i;
}
sprintf(idata.name, "%s_DM%.2f", outfilenm, dms[ii]);
writeinf(&idata);
}
/* Set the padded points equal to the average data point */
if (idata.numonoff >= 1) {
int index, startpad, endpad;
for (ii = 0; ii < local_numdms; ii++) {
fclose(outfiles[ii]);
sprintf(datafilenm, "%s_DM%.2f.dat", outfilenm, dms[ii]);
outfiles[ii] = 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];
for (jj = 0; jj < local_numdms; jj++)
chkfseek(outfiles[jj], (startpad + 1) * sizeof(float), SEEK_SET);
padtowrite = endpad - startpad;
write_padding(outfiles, local_numdms, avg, padtowrite);
}
}
}
/* Print simple stats and results */
var /= (datawrote - 1);
if (myid == 0)
print_percent_complete(1, 1);
if (myid == 1) {
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));
printf("\n");
}
/* Close the files and cleanup */
if (cmd->maskfileP)
free_mask(obsmask);
if (myid > 0) {
for (ii = 0; ii < local_numdms; ii++)
fclose(outfiles[ii]);
free(outfiles);
}
vect_free(outdata[0]);
vect_free(outdata);
vect_free(dms);
free(hostname);
vect_free(idispdt);
vect_free(offsets[0]);
vect_free(offsets);
free(datafilenm);
free(outfilenm);
free(outpath);
if (!cmd->nobaryP) {
vect_free(btoa);
vect_free(ttoa);
vect_free(diffbins);
}
MPI_Finalize();
return (0);
}
void barycenter(double *topotimes, double *barytimes,
double *voverc, long N, char *ra, char *dec, char *obs, char *ephem)
/* This routine uses TEMPO to correct a vector of */
/* topocentric times (in *topotimes) to barycentric times */
/* (in *barytimes) assuming an infinite observation */
/* frequency. The routine also returns values for the */
/* radial velocity of the observation site (in units of */
/* v/c) at the barycentric times. All three vectors must */
/* be initialized prior to calling. The vector length for */
/* all the vectors is 'N' points. The RA and DEC (J2000) */
/* of the observed object are passed as strings in the */
/* following format: "hh:mm:ss.ssss" for RA and */
/* "dd:mm:ss.ssss" for DEC. The observatory site is passed */
/* as a 2 letter ITOA code. This observatory code must be */
/* found in obsys.dat (in the TEMPO paths). The ephemeris */
/* is either "DE200" or "DE405". */
{
FILE *outfile;
long i;
double fobs = 1000.0, femit, dtmp;
char command[100], temporaryfile[100];
/* Write the free format TEMPO file to begin barycentering */
strcpy(temporaryfile, "bary.tmp");
outfile = chkfopen(temporaryfile, "w");
fprintf(outfile, "C Header Section\n"
" HEAD \n"
" PSR bary\n"
" NPRNT 2\n"
" P0 1.0 1\n"
" P1 0.0\n"
" CLK UTC(NIST)\n"
" PEPOCH %19.13f\n"
" COORD J2000\n"
" RA %s\n"
" DEC %s\n"
" DM 0.0\n"
" EPHEM %s\n"
"C TOA Section (uses ITAO Format)\n"
"C First 8 columns must have + or -!\n"
" TOA\n", topotimes[0], ra, dec, ephem);
/* Write the TOAs for infinite frequencies */
for (i = 0; i < N; i++) {
fprintf(outfile, "topocen+ %19.13f 0.00 0.0000 0.000000 %s\n",
topotimes[i], obs);
}
fprintf(outfile, "topocen+ %19.13f 0.00 0.0000 0.000000 %s\n",
topotimes[N - 1] + 10.0 / SECPERDAY, obs);
fprintf(outfile, "topocen+ %19.13f 0.00 0.0000 0.000000 %s\n",
topotimes[N - 1] + 20.0 / SECPERDAY, obs);
fclose(outfile);
/* Call TEMPO */
/* Check the TEMPO *.tmp and *.lis files for errors when done. */
sprintf(command, "tempo bary.tmp > tempoout_times.tmp");
if (system(command)==-1) {
fprintf(stderr, "\nError calling TEMPO in barycenter.c!\n");
exit(1);
}
/* Now read the TEMPO results */
strcpy(temporaryfile, "resid2.tmp");
outfile = chkfopen(temporaryfile, "rb");
/* Read the barycentric TOAs for infinite frequencies */
for (i = 0; i < N; i++) {
read_resid_rec(outfile, &barytimes[i], &dtmp);
}
fclose(outfile);
/* rename("itoa.out", "itoa1.out"); */
/* rename("bary.tmp", "bary1.tmp"); */
/* rename("bary.par", "bary1.par"); */
/* Write the free format TEMPO file to begin barycentering */
strcpy(temporaryfile, "bary.tmp");
outfile = chkfopen(temporaryfile, "w");
fprintf(outfile, "C Header Section\n"
" HEAD \n"
" PSR bary\n"
" NPRNT 2\n"
" P0 1.0 1\n"
" P1 0.0\n"
" CLK UTC(NIST)\n"
" PEPOCH %19.13f\n"
" COORD J2000\n"
" RA %s\n"
" DEC %s\n"
" DM 0.0\n"
" EPHEM %s\n"
"C TOA Section (uses ITAO Format)\n"
"C First 8 columns must have + or -!\n"
" TOA\n", topotimes[0], ra, dec, ephem);
/* Write the TOAs for finite frequencies */
for (i = 0; i < N; i++) {
fprintf(outfile, "topocen+ %19.13f 0.00 %9.4f 0.000000 %s\n",
topotimes[i], fobs, obs);
}
fprintf(outfile, "topocen+ %19.13f 0.00 %9.4f 0.000000 %s\n",
topotimes[N - 1] + 10.0 / SECPERDAY, fobs, obs);
fprintf(outfile, "topocen+ %19.13f 0.00 %9.4f 0.000000 %s\n",
topotimes[N - 1] + 20.0 / SECPERDAY, fobs, obs);
fclose(outfile);
/* Call TEMPO */
/* Insure you check the file tempoout.tmp for */
/* errors from TEMPO when complete. */
sprintf(command, "tempo bary.tmp > tempoout_vels.tmp");
if (system(command)==-1) {
fprintf(stderr, "\nError calling TEMPO in barycenter.c!\n");
exit(1);
}
/* Now read the TEMPO results */
strcpy(temporaryfile, "resid2.tmp");
outfile = chkfopen(temporaryfile, "rb");
/* Determine the radial velocities using the emitted freq */
for (i = 0; i < N; i++) {
read_resid_rec(outfile, &dtmp, &femit);
voverc[i] = femit / fobs - 1.0;
}
fclose(outfile);
/* Cleanup the temp files */
/* rename("itoa.out", "itoa2.out"); */
/* rename("bary.tmp", "bary2.tmp"); */
/* rename("bary.par", "bary2.par"); */
remove("tempo.lis");
remove("tempoout_times.tmp");
remove("tempoout_vels.tmp");
remove("resid2.tmp");
remove("bary.tmp");
remove("matrix.tmp");
remove("bary.par");
}
int main(int argc, char *argv[])
{
FILE *infile, *outfile;
int ii, jj, bufflen = 10000, numread;
long long N = 0;
float *inbuffer = NULL, *outbuffer = NULL;
short useshorts = 0, *sinbuffer = NULL, *soutbuffer = NULL;
char *rootfilenm, *outname;
infodata idata;
Cmdline *cmd;
/* Call usage() if we have no command line arguments */
if (argc == 1) {
Program = argv[0];
printf("\n");
usage();
exit(1);
}
/* Parse the command line using the excellent program Clig */
cmd = parseCmdline(argc, argv);
#ifdef DEBUG
showOptionValues();
#endif
printf("\n\n");
printf(" Time Series Downsampling Routine\n");
printf(" Sept, 2002\n\n");
{
int hassuffix = 0;
char *suffix;
hassuffix = split_root_suffix(cmd->argv[0], &rootfilenm, &suffix);
if (hassuffix) {
if (strcmp(suffix, "sdat") == 0)
useshorts = 1;
if (strcmp(suffix, "dat") != 0 && strcmp(suffix, "sdat") != 0) {
printf
("\nInput file ('%s') must be a time series ('.dat' or '.sdat')!\n\n",
cmd->argv[0]);
free(suffix);
exit(0);
}
free(suffix);
} else {
printf("\nInput file ('%s') must be a time series ('.dat' or '.sdat')!\n\n",
cmd->argv[0]);
exit(0);
}
if (cmd->outfileP) {
outname = cmd->outfile;
} else {
outname = (char *) calloc(strlen(rootfilenm) + 11, sizeof(char));
if (useshorts)
sprintf(outname, "%s_D%d.sdat", rootfilenm, cmd->factor);
else
sprintf(outname, "%s_D%d.dat", rootfilenm, cmd->factor);
}
}
/* Read the info file */
readinf(&idata, rootfilenm);
if (idata.object) {
printf("Downsampling %s data from '%s'.\n\n",
remove_whitespace(idata.object), cmd->argv[0]);
} else {
printf("Downsampling data from '%s'.\n\n", cmd->argv[0]);
}
/* Open files and create arrays */
infile = chkfopen(argv[1], "rb");
outfile = chkfopen(outname, "wb");
/* Read and downsample */
if (useshorts) {
sinbuffer = gen_svect(bufflen * cmd->factor);
soutbuffer = gen_svect(bufflen);
while ((numread =
chkfread(sinbuffer, sizeof(short), bufflen * cmd->factor, infile))) {
for (ii = 0; ii < numread / cmd->factor; ii++) {
soutbuffer[ii] = 0;
for (jj = 0; jj < cmd->factor; jj++)
soutbuffer[ii] += sinbuffer[cmd->factor * ii + jj];
}
chkfwrite(soutbuffer, sizeof(short), numread / cmd->factor, outfile);
N += numread / cmd->factor;
}
vect_free(sinbuffer);
vect_free(soutbuffer);
} else {
inbuffer = gen_fvect(bufflen * cmd->factor);
outbuffer = gen_fvect(bufflen);
while ((numread =
chkfread(inbuffer, sizeof(float), bufflen * cmd->factor, infile))) {
for (ii = 0; ii < numread / cmd->factor; ii++) {
outbuffer[ii] = 0;
for (jj = 0; jj < cmd->factor; jj++)
outbuffer[ii] += inbuffer[cmd->factor * ii + jj];
}
chkfwrite(outbuffer, sizeof(float), numread / cmd->factor, outfile);
N += numread / cmd->factor;
}
vect_free(inbuffer);
vect_free(outbuffer);
}
printf("Done. Wrote %lld points.\n\n", N);
/* Write the new info file */
idata.dt = idata.dt * cmd->factor;
idata.numonoff = 0;
idata.N = (double) N;
strncpy(idata.name, outname, strlen(outname) - 4);
if (useshorts)
idata.name[strlen(outname) - 5] = '\0';
else
idata.name[strlen(outname) - 4] = '\0';
writeinf(&idata);
fclose(infile);
fclose(outfile);
free(rootfilenm);
if (!cmd->outfileP)
free(outname);
exit(0);
}
void read_mak_file(char basefilenm[], makedata * mdata)
/* Read the data for makedata from the makefile. */
{
FILE *makefile;
char makefilenm[200], tmp[50];
double tmponoff[40];
int i;
sprintf(makefilenm, "%s.mak", basefilenm);
printf("Reading make information from \"%s\".\n", makefilenm);
makefile = chkfopen(makefilenm, "r");
strcpy(mdata->basefilenm, basefilenm);
fscanf(makefile, "%[^\n]", mdata->description);
fscanf(makefile, "%*[^=]= %ld", &mdata->N);
if (mdata->N <= 0) {
printf("\nmdata->N must be > 0 in read_mak_file()\n");
exit(1);
}
mdata->next2_to_n = 1;
while (mdata->next2_to_n < mdata->N) {
mdata->next2_to_n <<= 1;
}
fscanf(makefile, "%*[^=]= %lf", &mdata->dt);
if (mdata->dt <= 0) {
printf("\nmdata->dt must be > 0 in read_mak_file()\n");
exit(1);
}
mdata->T = mdata->N * mdata->dt;
i = fscanf(makefile, "%*[^=]= %s%[^\n]", mdata->ptype, tmp);
if (strcmp(mdata->ptype, "Sine") == 0)
mdata->pnum = 1;
else if (strcmp(mdata->ptype, "Crab-like") == 0)
mdata->pnum = 2;
else {
if (strcmp(mdata->ptype, "Spike") == 0) {
mdata->pnum = 3;
} else {
mdata->pnum = 4;
}
/* Default value for fwhm */
if (i == 2)
sscanf(tmp, "%*[^=]= %lf", &mdata->fwhm);
else
mdata->fwhm = 0.1;
if (mdata->fwhm <= 0.0 || mdata->fwhm > 0.5) {
printf("\nmdata->fwhm must be between 0 and 0.5 in ");
printf("read_mak_file()\n");
exit(1);
}
}
fscanf(makefile, "%*[^=]= %s", mdata->round);
if (strcmp(mdata->round, "Fractional") == 0)
mdata->roundnum = 0;
else
mdata->roundnum = 1;
fscanf(makefile, "%*[^=]= %lf", &mdata->f);
if (mdata->f <= 0.0) {
printf("\nmdata->f must be > 0.0 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->fd);
fscanf(makefile, "%*[^=]= %lf", &mdata->fdd);
mdata->p = 1.0 / mdata->f;
mdata->pd = -mdata->fd / (mdata->f * mdata->f);
if (mdata->fdd == 0.0)
mdata->pdd = 0.0;
else
mdata->pdd = (2 * mdata->fd * mdata->fd / mdata->f -
mdata->fdd) / mdata->f * mdata->f;
mdata->r = mdata->f * mdata->T;
mdata->z = mdata->fd * mdata->T * mdata->T;
mdata->w = mdata->fdd * mdata->T * mdata->T * mdata->T;
fscanf(makefile, "%*[^=]= %lf", &mdata->amp);
if (mdata->amp < 0.0) {
printf("\nmdata->amp must be >= 0.0 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->phs);
if (mdata->phs < 0.0 || mdata->phs >= 360) {
printf("\nmdata->phs must be 0 <= phs < 360 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->dc);
fscanf(makefile, "%*[^=]= %lf", &mdata->orb.p);
if (mdata->orb.p < 0.0) {
printf("\nmdata->orb.p must be >= 0.0 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->orb.x);
if (mdata->orb.x < 0.0) {
printf("\nmdata->orb.x must be >= 0.0 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->orb.e);
if (mdata->orb.e < 0.0 || mdata->orb.e >= 1.0) {
printf("\nmdata->e must be 0 <= e < 1.0 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->orb.w);
if (mdata->orb.w < 0.0 || mdata->orb.w >= 360) {
printf("\nmdata->orb.w must be 0 <= w < 360 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->orb.t);
if (mdata->orb.p == 0.0 || mdata->orb.x == 0.0)
mdata->binary = 0;
else
mdata->binary = 1;
fscanf(makefile, "%*[^=]= %lf", &mdata->ampmoda);
if (mdata->ampmoda < 0.0) {
printf("\nmdata->ampmoda must be >= 0.0 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->ampmodp);
if (mdata->ampmodp < 0.0 || mdata->ampmodp >= 360) {
printf("\nmdata->ampmodp must be 0 <= phs < 360 in read_mak_file()\n");
exit(1);
}
fscanf(makefile, "%*[^=]= %lf", &mdata->ampmodf);
if (mdata->ampmodf < 0.0) {
printf("\nmdata->ampmodf must be >= 0.0 in read_mak_file()\n");
exit(1);
}
if (mdata->ampmoda == 0.0 || mdata->ampmodf == 0.0)
mdata->ampmod = 0;
else
mdata->ampmod = 1;
fscanf(makefile, "%*[^=]= %s", mdata->noisetype);
if (strcmp(mdata->noisetype, "Standard") == 0)
mdata->noise = 1;
else
mdata->noise = 2;
fscanf(makefile, "%*[^=]= %lf", &mdata->noisesig);
i = 0;
do {
fscanf(makefile, "%*[^=]= %lf %lf", &tmponoff[i], &tmponoff[i + 1]);
i += 2;
} while (tmponoff[i - 1] < 1.0 && i < 40);
if (tmponoff[i - 1] > 1.0)
tmponoff[i - 1] = 1.0;
mdata->numonoff = i / 2;
mdata->onoff = (double *) malloc(mdata->numonoff * 2 * sizeof(double));
for (i = 0; i < mdata->numonoff; i++) {
mdata->onoff[2 * i] = tmponoff[2 * i];
mdata->onoff[2 * i + 1] = tmponoff[2 * i + 1];
}
fclose(makefile);
}
/* NEW Clipping Routine (uses channel running averages) */
int clip_times(float *rawdata, int ptsperblk, int numchan, float clip_sigma,
float *good_chan_levels)
// Perform time-domain clipping of rawdata. This is a 2D array with
// ptsperblk*numchan points, each of which is a float. The clipping
// is done at clip_sigma sigma above/below the running mean. The
// up-to-date running averages of the channels are returned in
// good_chan_levels (which must be pre-allocated).
{
static float *chan_running_avg;
static float running_avg = 0.0, running_std = 0.0;
static int blocksread = 0, firsttime = 1;
static long long current_point = 0;
static int numonoff = 0, onoffindex = 0;
static long long *onbins = NULL, *offbins = NULL;
float *zero_dm_block, *ftmp, *powptr;
double *chan_avg_temp;
float current_med, trigger;
double current_avg = 0.0, current_std = 0.0;
int ii, jj, clipit = 0, clipped = 0;
if (firsttime) {
chan_running_avg = gen_fvect(numchan);
firsttime = 0;
{ // This is experimental code to zap radar-filled data
char *envval = getenv("CLIPBINSFILE");
if (envval != NULL) {
FILE *onofffile = chkfopen(envval, "r");
numonoff = read_onoff_paris(onofffile, &onbins, &offbins);
fclose(onofffile);
printf("\nRead %d bin clipping pairs from '%s'.\n", numonoff,
envval);
//for (ii=0;ii<numonoff;ii++) printf("%lld %lld\n", onbins[ii], offbins[ii]);
}
}
}
chan_avg_temp = gen_dvect(numchan);
zero_dm_block = gen_fvect(ptsperblk);
ftmp = gen_fvect(ptsperblk);
/* Calculate the zero DM time series */
for (ii = 0; ii < ptsperblk; ii++) {
zero_dm_block[ii] = 0.0;
powptr = rawdata + ii * numchan;
for (jj = 0; jj < numchan; jj++)
zero_dm_block[ii] += *powptr++;
ftmp[ii] = zero_dm_block[ii];
}
avg_var(ftmp, ptsperblk, ¤t_avg, ¤t_std);
current_std = sqrt(current_std);
current_med = median(ftmp, ptsperblk);
/* Calculate the current standard deviation and mean */
/* but only for data points that are within a certain */
/* fraction of the median value. This removes the */
/* really strong RFI from the calculation. */
{
float lo_cutoff, hi_cutoff;
int numgoodpts = 0;
lo_cutoff = current_med - 3.0 * current_std;
hi_cutoff = current_med + 3.0 * current_std;;
for (jj = 0; jj < numchan; jj++)
chan_avg_temp[jj] = 0.0;
/* Find the "good" points */
for (ii = 0; ii < ptsperblk; ii++) {
if (zero_dm_block[ii] > lo_cutoff && zero_dm_block[ii] < hi_cutoff) {
ftmp[numgoodpts] = zero_dm_block[ii];
powptr = rawdata + ii * numchan;
for (jj = 0; jj < numchan; jj++)
chan_avg_temp[jj] += *powptr++;
numgoodpts++;
}
}
//printf("avg = %f med = %f std = %f numgoodpts = %d\n",
// current_avg, current_med, current_std, numgoodpts);
/* Calculate the current average and stddev */
if (numgoodpts < 1) {
current_avg = running_avg;
current_std = running_std;
for (jj = 0; jj < numchan; jj++)
chan_avg_temp[jj] = chan_running_avg[jj];
} else {
avg_var(ftmp, numgoodpts, ¤t_avg, ¤t_std);
current_std = sqrt(current_std);
for (jj = 0; jj < numchan; jj++)
chan_avg_temp[jj] /= numgoodpts;
}
}
/* Update a pseudo running average and stdev */
if (blocksread) {
running_avg = 0.9 * running_avg + 0.1 * current_avg;
running_std = 0.9 * running_std + 0.1 * current_std;
for (ii = 0; ii < numchan; ii++)
chan_running_avg[ii] =
0.9 * chan_running_avg[ii] + 0.1 * chan_avg_temp[ii];
} else {
running_avg = current_avg;
running_std = current_std;
for (ii = 0; ii < numchan; ii++)
chan_running_avg[ii] = chan_avg_temp[ii];
if (current_avg == 0.0)
printf("Warning: problem with clipping in first block!!!\n\n");
}
/* See if any points need clipping */
trigger = clip_sigma * running_std;
for (ii = 0; ii < ptsperblk; ii++) {
if (fabs(zero_dm_block[ii] - running_avg) > trigger) {
clipit = 1;
break;
}
}
/* or alternatively from the CLIPBINSFILE */
if (numonoff && ((current_point > onbins[onoffindex]
&& current_point <= offbins[onoffindex])
|| (current_point + ptsperblk > onbins[onoffindex]
&& current_point + ptsperblk <= offbins[onoffindex])
|| (current_point < onbins[onoffindex]
&& current_point + ptsperblk > offbins[onoffindex])))
clipit = 1;
/* Update the good channel levels */
for (ii = 0; ii < numchan; ii++)
good_chan_levels[ii] = chan_running_avg[ii];
/* Replace the bad channel data with channel median values */
/* that are scaled to equal the running_avg. */
if (clipit) {
for (ii = 0; ii < ptsperblk; ii++) {
if ((fabs(zero_dm_block[ii] - running_avg) > trigger) ||
(numonoff && (current_point > onbins[onoffindex]
&& current_point <= offbins[onoffindex]))) {
powptr = rawdata + ii * numchan;
for (jj = 0; jj < numchan; jj++)
*powptr++ = good_chan_levels[jj];
clipped++;
//fprintf(stderr, "zapping %lld\n", current_point);
}
current_point++;
if (numonoff && current_point > offbins[onoffindex]
&& onoffindex < numonoff - 1) {
while (current_point > offbins[onoffindex]
&& onoffindex < numonoff - 1)
onoffindex++;
//printf("updating index to %d\n", onoffindex);
}
}
} else {
current_point += ptsperblk;
if (numonoff && current_point > offbins[onoffindex]
&& onoffindex < numonoff - 1) {
while (current_point > offbins[onoffindex]
&& onoffindex < numonoff - 1)
onoffindex++;
//printf("updating index to %d\n", onoffindex);
}
}
blocksread++;
vect_free(chan_avg_temp);
vect_free(zero_dm_block);
vect_free(ftmp);
return clipped;
}
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);
}
char *make_polycos(char *parfilenm, infodata * idata)
{
FILE *tmpfile;
int tracklen;
double T, fmid = 0.0, epoch;
char command[100], *psrname, scopechar;
psrparams psr;
/* Read the parfile */
epoch = idata->mjd_i + idata->mjd_f;
T = (idata->dt * idata->N) / SECPERDAY;
if (!get_psr_from_parfile(parfilenm, epoch, &psr)) {
printf("\nError: Cannot read parfile '%s'\n\n", parfilenm);
exit(0);
}
/* Write tz.in */
if (strcmp(idata->telescope, "GBT") == 0) {
scopechar = '1';
tracklen = 12;
} else if (strcmp(idata->telescope, "Arecibo") == 0) {
scopechar = '3';
tracklen = 3;
} else if (strcmp(idata->telescope, "VLA") == 0) {
scopechar = '6';
tracklen = 6;
} else if (strcmp(idata->telescope, "Parkes") == 0) {
scopechar = '7';
tracklen = 12;
} else if (strcmp(idata->telescope, "Jodrell") == 0) {
scopechar = '8';
tracklen = 12;
} else if ((strcmp(idata->telescope, "GB43m") == 0) ||
(strcmp(idata->telescope, "GB 140FT") == 0)){
scopechar = 'a';
tracklen = 12;
} else if (strcmp(idata->telescope, "Nancay") == 0) {
scopechar = 'f';
tracklen = 4;
} else if (strcmp(idata->telescope, "Effelsberg") == 0) {
scopechar = 'g';
tracklen = 12;
} else if (strcmp(idata->telescope, "LOFAR") == 0) {
scopechar = 't';
tracklen = 12;
} else if (strcmp(idata->telescope, "FR606") == 0) {
scopechar = 'u';
tracklen = 12;
} else if (strcmp(idata->telescope, "UTR-2") == 0) {
scopechar = 'w';
tracklen = 12;
} else if (strcmp(idata->telescope, "DE601") == 0) {
scopechar = 'x';
tracklen = 12;
} else if (strcmp(idata->telescope, "UK608") == 0) {
scopechar = 'y';
tracklen = 12;
} else if (strcmp(idata->telescope, "WSRT") == 0) {
scopechar = 'i';
tracklen = 12;
} else if (strcmp(idata->telescope, "GMRT") == 0) {
scopechar = 'r';
tracklen = 12;
} else if (strcmp(idata->telescope, "Geocenter") == 0) {
scopechar = 'o';
tracklen = 12;
} else { /* Barycenter */
printf("Defaulting to barycenter for polyco generation...\n");
scopechar = '@';
tracklen = 12;
}
/* For optical, X-ray, or gamma-ray data */
if (scopechar != '@' && scopechar != 'o') {
fmid = idata->freq + (idata->num_chan / 2 - 0.5) * idata->chan_wid;
} else {
fmid = 0.0;
}
printf("Generating polycos for PSR %s.\n", psr.jname);
tmpfile = chkfopen("tz.in", "w");
fprintf(tmpfile, "%c %d 60 12 430\n\n\n%s 60 12 %d %.5f\n",
scopechar, tracklen, psr.jname, tracklen, fmid);
fclose(tmpfile);
sprintf(command, "echo %d %d | tempo -z -f %s > /dev/null",
idata->mjd_i-1, (int) ceil(epoch + T), parfilenm);
// printf("making polycos: '%s'\n", command);
system(command);
remove("tz.in");
psrname = (char *) calloc(strlen(psr.jname) + 1, sizeof(char));
strcpy(psrname, psr.jname);
return psrname;
}
char *make_polycos(char *parfilenm, infodata * idata, char *polycofilenm)
{
FILE *tmpfile;
int tracklen;
double T, fmid = 0.0, epoch;
char *command, *psrname, scopechar;
char *pcpathnm, *pcfilenm;
psrparams psr;
/* Get the path and name of the output polycofilenm */
split_path_file(polycofilenm, &pcpathnm, &pcfilenm);
/* Read the parfile */
epoch = idata->mjd_i + idata->mjd_f;
T = (idata->dt * idata->N) / SECPERDAY;
if (!get_psr_from_parfile(parfilenm, epoch, &psr)) {
fprintf(stderr,
"\nError: Cannot read parfile '%s' in make_polycos()\n\n",
parfilenm);
exit(-1);
}
/* Generate temp directory */
char tmpdir[] = "/tmp/polycoXXXXXX";
if (mkdtemp(tmpdir) == NULL) {
fprintf(stderr,
"\nError: Cannot generate temp dir '%s' in make_polycos()\n\n",
tmpdir);
exit(-1);
}
/* Copy the parfile to the temp directory */
command = (char *) calloc(strlen(parfilenm) + strlen(tmpdir) +
strlen(pcfilenm) + strlen(pcpathnm) + 200, 1);
sprintf(command, "cp %s %s/pulsar.par", parfilenm, tmpdir);
if (system(command) != 0) {
fprintf(stderr,
"\nError: Cannot copy parfile '%s' to tmpdir '%s' in make_polycos()\n\n",
parfilenm, tmpdir);
exit(-1);
}
/* change to temp dir */
char *origdir = getcwd(NULL, 0);
chdir(tmpdir);
/* Write tz.in */
if (strcmp(idata->telescope, "GBT") == 0) {
scopechar = '1';
tracklen = 12;
} else if (strcmp(idata->telescope, "Arecibo") == 0) {
scopechar = '3';
tracklen = 3;
} else if (strcmp(idata->telescope, "VLA") == 0) {
scopechar = '6';
tracklen = 6;
} else if (strcmp(idata->telescope, "Parkes") == 0) {
scopechar = '7';
tracklen = 12;
} else if (strcmp(idata->telescope, "Jodrell") == 0) {
scopechar = '8';
tracklen = 12;
} else if ((strcmp(idata->telescope, "GB43m") == 0) ||
(strcmp(idata->telescope, "GB 140FT") == 0) ||
(strcmp(idata->telescope, "NRAO20") == 0)) {
scopechar = 'a';
tracklen = 12;
} else if (strcmp(idata->telescope, "Nancay") == 0) {
scopechar = 'f';
tracklen = 4;
} else if (strcmp(idata->telescope, "Effelsberg") == 0) {
scopechar = 'g';
tracklen = 12;
} else if (strcmp(idata->telescope, "LOFAR") == 0) {
scopechar = 't';
tracklen = 12;
} else if (strcmp(idata->telescope, "WSRT") == 0) {
scopechar = 'i';
tracklen = 12;
} else if (strcmp(idata->telescope, "GMRT") == 0) {
scopechar = 'r';
tracklen = 12;
} else if (strcmp(idata->telescope, "LWA") == 0) {
scopechar = 'x';
tracklen = 12;
} else if (strcmp(idata->telescope, "SRT") == 0) {
scopechar = 'z';
tracklen = 12;
} else if (strcmp(idata->telescope, "Geocenter") == 0) {
scopechar = 'o';
tracklen = 12;
} else { /* Barycenter */
printf("Defaulting to barycenter for polyco generation...\n");
scopechar = '@';
tracklen = 12;
}
/* For optical, X-ray, or gamma-ray data */
if (scopechar != '@' && scopechar != 'o') {
fmid = idata->freq + (idata->num_chan / 2 - 0.5) * idata->chan_wid;
} else {
fmid = 0.0;
}
printf("Generating polycos for PSR %s.\n", psr.jname);
tmpfile = chkfopen("tz.in", "w");
fprintf(tmpfile, "%c %d 60 12 430\n\n\n%s 60 12 %d %.5f\n",
scopechar, tracklen, psr.jname, tracklen, fmid);
fclose(tmpfile);
//sprintf(command, "echo %d %d | tempo -z -f %s > /dev/null",
sprintf(command, "echo %d %d | tempo -z -f pulsar.par > /dev/null",
idata->mjd_i - 1, (int) ceil(epoch + T));
if (system(command) != 0) {
fprintf(stderr,
"\nError: Problem running TEMPO in '%s' for make_polycos()\n\n",
tmpdir);
exit(-1);
} else {
sprintf(command, "cp polyco.dat %s/%s", pcpathnm, pcfilenm);
if (system(command) != 0) {
fprintf(stderr,
"\nError: Cannot copy polyco.dat in '%s' to '%s' make_polycos()\n\n",
tmpdir, polycofilenm);
exit(-1);
}
remove("polyco.dat");
remove("pulsar.par");
remove("tempo.lis");
remove("tz.in");
remove("tz.tmp");
}
chdir(origdir);
free(origdir);
free(pcpathnm);
free(pcfilenm);
free(command);
remove(tmpdir);
psrname = (char *) calloc(strlen(psr.jname) + 1, sizeof(char));
strcpy(psrname, psr.jname);
return psrname;
}
int main(int argc, char *argv[])
{
float minval = SMALLNUM, maxval = LARGENUM, inx = 0, iny = 0;
int centern, offsetn;
int zoomlevel, maxzoom = 0, minzoom, xid, psid;
char *rootfilenm, inchar;
datapart *lodp;
dataview *dv;
basicstats *statvals;
if (argc == 1) {
printf("\nusage: exploredat datafilename\n\n");
exit(0);
}
printf("\n\n");
printf(" Interactive Data Explorer\n");
printf(" by Scott M. Ransom\n");
printf(" November, 2001\n");
print_help();
{
int hassuffix = 0;
char *suffix;
hassuffix = split_root_suffix(argv[1], &rootfilenm, &suffix);
if (hassuffix) {
if (strcmp(suffix, "dat") != 0) {
printf
("\nInput file ('%s') must be a single PRESTO data file ('.dat')!\n\n",
argv[1]);
free(suffix);
exit(0);
}
free(suffix);
} else {
printf("\nInput file ('%s') must be a PRESTO data file ('.dat')!\n\n",
argv[1]);
exit(0);
}
}
/* Read the info file */
readinf(&idata, rootfilenm);
if (idata.object) {
printf("Examining %s data from '%s'.\n\n",
remove_whitespace(idata.object), argv[1]);
} else {
printf("Examining data from '%s'.\n\n", argv[1]);
}
#ifdef USEMMAP
mmap_file = open(argv[1], O_RDONLY);
{
int rt;
struct stat buf;
rt = fstat(mmap_file, &buf);
if (rt == -1) {
perror("\nError in fstat() in exploredat.c");
printf("\n");
exit(-1);
}
Ndat = buf.st_size / sizeof(float);
}
lodp = get_datapart(0, Ndat);
#else
{
int numsamp;
datfile = chkfopen(argv[1], "rb");
Ndat = chkfilelen(datfile, sizeof(float));
numsamp = (Ndat > MAXPTS) ? (int) MAXPTS : (int) Ndat;
lodp = get_datapart(0, numsamp);
}
#endif
/* Plot the initial data */
centern = 0.5 * INITIALNUMPTS;
if (centern > lodp->nn)
centern = lodp->nn / 2;
zoomlevel = LOGMAXDISPNUM - LOGINITIALNUMPTS;
minzoom = LOGMAXDISPNUM - LOGMAXPTS;
maxzoom = LOGMAXDISPNUM - LOGMINDISPNUM;
dv = get_dataview(centern, zoomlevel, lodp);
/* Prep the XWIN device for PGPLOT */
xid = cpgopen("/XWIN");
if (xid <= 0) {
free_datapart(lodp);
#ifdef USEMMAP
close(mmap_file);
#else
fclose(datfile);
#endif
free(dv);
exit(EXIT_FAILURE);
}
cpgask(0);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
do {
cpgcurs(&inx, &iny, &inchar);
if (DEBUGOUT)
printf("You pressed '%c'\n", inchar);
switch (inchar) {
case ' ': /* Toggle stats and sample plotting on/off */
/* 0 = both, 1 = stats only, 2 = data only */
plotstats++;
plotstats = plotstats % 3;
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case 'M': /* Toggle between median and average */
case 'm':
usemedian = (usemedian) ? 0 : 1;
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case 'A': /* Zoom in */
case 'a':
centern = inx + offsetn;
case 'I':
case 'i':
if (DEBUGOUT)
printf(" Zooming in (zoomlevel = %d)...\n", zoomlevel);
if (zoomlevel < maxzoom) {
zoomlevel++;
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
} else
printf(" Already at maximum zoom level (%d).\n", zoomlevel);
break;
case 'X': /* Zoom out */
case 'x':
case 'O':
case 'o':
if (DEBUGOUT)
printf(" Zooming out (zoomlevel = %d)...\n", zoomlevel);
if (zoomlevel > minzoom) {
zoomlevel--;
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
} else
printf(" Already at minimum zoom level (%d).\n", zoomlevel);
break;
case '<': /* Shift left 1 full screen */
centern -= dv->numsamps + dv->numsamps / 8;
case ',': /* Shift left 1/8 screen */
if (DEBUGOUT)
printf(" Shifting left...\n");
centern -= dv->numsamps / 8;
{ /* Should probably get the previous chunk from the datfile... */
double lowestr;
lowestr = 0.5 * dv->numsamps;
if (centern < lowestr)
centern = lowestr;
}
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case '>': /* Shift right 1 full screen */
centern += dv->numsamps - dv->numsamps / 8;
case '.': /* Shift right 1/8 screen */
centern += dv->numsamps / 8;
if (DEBUGOUT)
printf(" Shifting right...\n");
{ /* Should probably get the next chunk from the datfile... */
double highestr;
highestr = lodp->nlo + lodp->nn - 0.5 * dv->numsamps;
if (centern > highestr)
centern = highestr;
}
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case '+': /* Increase height of top edge */
{
float dy;
if (maxval > 0.5 * LARGENUM) {
printf(" Auto-scaling of top edge is off.\n");
if (minval < 0.5 * SMALLNUM)
dy = dv->maxval - dv->minval;
else
dy = dv->maxval - minval;
maxval = dv->maxval + 0.1 * dy;
} else {
if (minval < 0.5 * SMALLNUM)
dy = maxval - dv->minval;
else
dy = maxval - minval;
maxval += 0.1 * dy;
}
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
}
case '_': /* Decrease height of top edge */
{
float dy;
if (maxval > 0.5 * LARGENUM) {
printf(" Auto-scaling of top edge is off.\n");
if (minval < 0.5 * SMALLNUM)
dy = dv->maxval - dv->minval;
else
dy = dv->maxval - minval;
maxval = dv->maxval - 0.1 * dy;
} else {
if (minval < 0.5 * SMALLNUM)
dy = maxval - dv->minval;
else
dy = maxval - minval;
maxval -= 0.1 * dy;
}
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
}
case '=': /* Increase height of bottom edge */
{
float dy;
if (minval < 0.5 * SMALLNUM) {
printf(" Auto-scaling of bottom edge is off.\n");
if (maxval > 0.5 * LARGENUM)
dy = dv->maxval - dv->minval;
else
dy = maxval - dv->minval;
minval = dv->minval + 0.1 * dy;
} else {
if (maxval > 0.5 * LARGENUM)
dy = dv->maxval - minval;
else
dy = maxval - minval;
minval += 0.1 * dy;
}
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
}
case '-': /* Decrease height of bottom edge */
{
float dy;
if (minval < 0.5 * SMALLNUM) {
printf(" Auto-scaling of bottom edge is off.\n");
if (maxval > 0.5 * LARGENUM)
dy = dv->maxval - dv->minval;
else
dy = maxval - dv->minval;
minval = dv->minval - 0.1 * dy;
} else {
if (maxval > 0.5 * LARGENUM)
dy = dv->maxval - minval;
else
dy = maxval - minval;
minval -= 0.1 * dy;
}
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
}
case 'S': /* Auto-scale */
case 's':
printf(" Auto-scaling is on.\n");
minval = SMALLNUM;
maxval = LARGENUM;
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
break;
case 'G': /* Goto a time */
case 'g':
{
char timestr[50];
double time = -1.0;
while (time < 0.0) {
printf
(" Enter the time (s) from the beginning of the file to go to:\n");
fgets(timestr, 50, stdin);
timestr[strlen(timestr) - 1] = '\0';
time = atof(timestr);
}
offsetn = 0.0;
centern = (int) (time / idata.dt + 0.5);
printf(" Moving to time %.15g (data point %d).\n", time, centern);
free(dv);
dv = get_dataview(centern, zoomlevel, lodp);
cpgpage();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
}
break;
case '?': /* Print help screen */
print_help();
break;
case 'P': /* Print the current plot */
case 'p':
{
int len;
char filename[200];
printf(" Enter the filename to save the plot as:\n");
fgets(filename, 195, stdin);
len = strlen(filename) - 1;
filename[len + 0] = '/';
filename[len + 1] = 'C';
filename[len + 2] = 'P';
filename[len + 3] = 'S';
filename[len + 4] = '\0';
psid = cpgopen(filename);
cpgslct(psid);
cpgpap(10.25, 8.5 / 11.0);
cpgiden();
offsetn = plot_dataview(dv, minval, maxval, 1.0);
cpgclos();
cpgslct(xid);
filename[len] = '\0';
printf(" Wrote the plot to the file '%s'.\n", filename);
}
break;
case 'V': /* Show the basic statistics for the current dataview */
case 'v':
statvals = calc_stats(dv, lodp);
printf("\n Statistics:\n"
" Low sample %d\n"
" Number of samples %d\n"
" Low time (s) %.7g\n"
" Duration of samples (s) %.7g\n"
" Maximum value %.7g\n"
" Minimum value %.7g\n"
" Average value %.7g\n"
" Median value %.7g\n"
" Standard Deviation %.7g\n"
" Skewness %.7g\n"
" Kurtosis %.7g\n\n",
dv->lon, dv->numsamps, dv->lon * idata.dt, dv->numsamps * idata.dt,
statvals->max, statvals->min, statvals->average,
statvals->median, statvals->stdev,
statvals->skewness, statvals->kurtosis);
free(statvals);
break;
case 'Q': /* Quit */
case 'q':
printf(" Quitting...\n");
free(dv);
cpgclos();
break;
default:
printf(" Unrecognized option '%c'.\n", inchar);
break;
}
} while (inchar != 'Q' && inchar != 'q');
free_datapart(lodp);
#ifdef USEMMAP
close(mmap_file);
#else
fclose(datfile);
#endif
printf("Done\n\n");
return 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 *bytemaskfile;
float **dataavg = NULL, **datastd = NULL, **datapow = NULL;
float *chandata = NULL, powavg, powstd, powmax;
float inttime, norm, fracterror = RFI_FRACTERROR;
float *rawdata = NULL;
unsigned char **bytemask = NULL;
short *srawdata = NULL;
char *outfilenm, *statsfilenm, *maskfilenm;
char *bytemaskfilenm, *rfifilenm;
int numchan = 0, numint = 0, newper = 0, oldper = 0, good_padvals = 0;
int blocksperint, ptsperint = 0, ptsperblock = 0, padding = 0;
int numcands, candnum, numrfi = 0, numrfivect = NUM_RFI_VECT;
int ii, jj, kk, slen, numread = 0, insubs = 0;
int harmsum = RFI_NUMHARMSUM, lobin = RFI_LOBIN, numbetween = RFI_NUMBETWEEN;
double davg, dvar, freq;
struct spectra_info s;
presto_interptype interptype;
rfi *rfivect = NULL;
mask oldmask, newmask;
fftcand *cands;
infodata idata;
Cmdline *cmd;
/* 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;
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;
}
slen = strlen(cmd->outfile) + 20;
#ifdef DEBUG
showOptionValues();
#endif
printf("\n\n");
printf(" Pulsar Data RFI Finder\n");
printf(" by Scott M. Ransom\n\n");
/* The following is the root of all the output files */
outfilenm = (char *) calloc(slen, sizeof(char));
sprintf(outfilenm, "%s_rfifind", cmd->outfile);
/* And here are the output file names */
maskfilenm = (char *) calloc(slen, sizeof(char));
sprintf(maskfilenm, "%s.mask", outfilenm);
bytemaskfilenm = (char *) calloc(slen, sizeof(char));
sprintf(bytemaskfilenm, "%s.bytemask", outfilenm);
rfifilenm = (char *) calloc(slen, sizeof(char));
sprintf(rfifilenm, "%s.rfi", outfilenm);
statsfilenm = (char *) calloc(slen, sizeof(char));
sprintf(statsfilenm, "%s.stats", outfilenm);
sprintf(idata.name, "%s", outfilenm);
if (RAWDATA) {
if (cmd->filterbankP) s.datatype = SIGPROCFB;
else if (cmd->psrfitsP) s.datatype = PSRFITS;
else if (cmd->pkmbP) s.datatype = SCAMP;
else if (cmd->bcpmP) s.datatype = BPP;
else if (cmd->wappP) s.datatype = WAPP;
else if (cmd->spigotP) s.datatype = SPIGOT;
} 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==SCAMP) cmd->pkmbP = 1;
else if (s.datatype==BPP) cmd->bcpmP = 1;
else if (s.datatype==WAPP) cmd->wappP = 1;
else if (s.datatype==SPIGOT) cmd->spigotP = 1;
else if (s.datatype==SUBBAND) insubs = 1;
else {
printf("Error: Unable to identify input data files. Please specify type.\n\n");
exit(1);
}
}
if (!cmd->nocomputeP) {
if (RAWDATA || insubs) {
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);
if (insubs) s.files = (FILE **)malloc(sizeof(FILE *) * s.num_files);
for (ii = 0; ii < s.num_files; ii++) {
printf(" '%s'\n", cmd->argv[ii]);
if (insubs) s.files[ii] = chkfopen(cmd->argv[ii], "rb");
}
printf("\n");
}
if (RAWDATA) {
read_rawdata_files(&s);
print_spectra_info_summary(&s);
spectra_info_to_inf(&s, &idata);
ptsperblock = s.spectra_per_subint;
numchan = s.num_channels;
idata.dm = 0.0;
}
if (insubs) {
/* Set-up values if we are using subbands */
char *tmpname, *root, *suffix;
if (split_root_suffix(s.filenames[0], &root, &suffix) == 0) {
printf("Error: The input filename (%s) must have a suffix!\n\n", s.filenames[0]);
exit(1);
}
if (strncmp(suffix, "sub", 3) == 0) {
tmpname = calloc(strlen(root) + 6, 1);
sprintf(tmpname, "%s.sub", root);
readinf(&idata, tmpname);
free(tmpname);
} else {
printf("\nThe input files (%s) must be subbands! (i.e. *.sub##)\n\n",
s.filenames[0]);
exit(1);
}
free(root);
free(suffix);
ptsperblock = 1;
/* Compensate for the fact that we have subbands and not channels */
idata.freq = idata.freq - 0.5 * idata.chan_wid +
0.5 * idata.chan_wid * (idata.num_chan / s.num_files);
idata.chan_wid = idata.num_chan / s.num_files * idata.chan_wid;
idata.num_chan = numchan = s.num_files;
idata.dm = 0.0;
sprintf(idata.name, "%s", outfilenm);
writeinf(&idata);
s.padvals = gen_fvect(s.num_files);
for (ii = 0 ; ii < s.num_files ; ii++)
s.padvals[ii] = 0.0;
}
/* Read an input mask if wanted */
if (cmd->maskfileP) {
read_mask(cmd->maskfile, &oldmask);
printf("Read old mask information from '%s'\n\n", cmd->maskfile);
good_padvals = determine_padvals(cmd->maskfile, &oldmask, s.padvals);
} else {
oldmask.numchan = oldmask.numint = 0;
}
/* The number of data points and blocks to work with at a time */
if (cmd->blocksP) {
blocksperint = cmd->blocks;
cmd->time = blocksperint * ptsperblock * idata.dt;
} else {
blocksperint = (int) (cmd->time / (ptsperblock * idata.dt) + 0.5);
}
ptsperint = blocksperint * ptsperblock;
numint = (long long) idata.N / ptsperint;
if ((long long) idata.N % ptsperint)
numint++;
inttime = ptsperint * idata.dt;
printf("Analyzing data sections of length %d points (%.6g sec).\n",
ptsperint, inttime);
{
int *factors, numfactors;
factors = get_prime_factors(ptsperint, &numfactors);
printf(" Prime factors are: ");
for (ii = 0; ii < numfactors; ii++)
printf("%d ", factors[ii]);
printf("\n");
if (factors[numfactors - 1] > 13) {
printf(" WARNING: The largest prime factor is pretty big! This will\n"
" cause the FFTs to take a long time to compute. I\n"
" recommend choosing a different -time value.\n");
}
printf("\n");
free(factors);
}
/* Allocate our workarrays */
if (RAWDATA)
rawdata = gen_fvect(idata.num_chan * ptsperblock * blocksperint);
else if (insubs)
srawdata = gen_svect(idata.num_chan * ptsperblock * blocksperint);
dataavg = gen_fmatrix(numint, numchan);
datastd = gen_fmatrix(numint, numchan);
datapow = gen_fmatrix(numint, numchan);
chandata = gen_fvect(ptsperint);
bytemask = gen_bmatrix(numint, numchan);
for (ii = 0; ii < numint; ii++)
for (jj = 0; jj < numchan; jj++)
bytemask[ii][jj] = GOODDATA;
rfivect = rfi_vector(rfivect, numchan, numint, 0, numrfivect);
if (numbetween == 2)
interptype = INTERBIN;
else
interptype = INTERPOLATE;
/* Main loop */
printf("Writing mask data to '%s'.\n", maskfilenm);
printf("Writing RFI data to '%s'.\n", rfifilenm);
printf("Writing statistics to '%s'.\n\n", statsfilenm);
printf("Massaging the data ...\n\n");
printf("Amount Complete = %3d%%", oldper);
fflush(stdout);
for (ii = 0; ii < numint; ii++) { /* Loop over the intervals */
newper = (int) ((float) ii / numint * 100.0 + 0.5);
if (newper > oldper) {
printf("\rAmount Complete = %3d%%", newper);
fflush(stdout);
oldper = newper;
}
/* Read a chunk of data */
if (RAWDATA)
numread = read_rawblocks(rawdata, blocksperint, &s, &padding);
else if (insubs)
numread = read_subband_rawblocks(s.files, s.num_files,
srawdata, blocksperint, &padding);
if (padding)
for (jj = 0; jj < numchan; jj++)
bytemask[ii][jj] |= PADDING;
for (jj = 0; jj < numchan; jj++) { /* Loop over the channels */
if (RAWDATA)
get_channel(chandata, jj, blocksperint, rawdata, &s);
else if (insubs)
get_subband(jj, chandata, srawdata, blocksperint);
/* Calculate the averages and standard deviations */
/* for each point in time. */
if (padding) {
dataavg[ii][jj] = 0.0;
datastd[ii][jj] = 0.0;
datapow[ii][jj] = 1.0;
} else {
avg_var(chandata, ptsperint, &davg, &dvar);
dataavg[ii][jj] = davg;
datastd[ii][jj] = sqrt(dvar);
realfft(chandata, ptsperint, -1);
numcands = 0;
norm = datastd[ii][jj] * datastd[ii][jj] * ptsperint;
if (norm == 0.0)
norm = (chandata[0] == 0.0) ? 1.0 : chandata[0];
cands = search_fft((fcomplex *) chandata, ptsperint / 2,
lobin, ptsperint / 2, harmsum,
numbetween, interptype, norm, cmd->freqsigma,
&numcands, &powavg, &powstd, &powmax);
datapow[ii][jj] = powmax;
/* Record the birdies */
if (numcands) {
for (kk = 0; kk < numcands; kk++) {
freq = cands[kk].r / inttime;
candnum = find_rfi(rfivect, numrfi, freq, RFI_FRACTERROR);
if (candnum >= 0) {
update_rfi(rfivect + candnum, freq, cands[kk].sig, jj, ii);
} else {
update_rfi(rfivect + numrfi, freq, cands[kk].sig, jj, ii);
numrfi++;
if (numrfi == numrfivect) {
numrfivect *= 2;
rfivect = rfi_vector(rfivect, numchan, numint,
numrfivect / 2, numrfivect);
}
}
}
free(cands);
}
}
}
}
printf("\rAmount Complete = 100%%\n");
/* Write the data to the output files */
write_rfifile(rfifilenm, rfivect, numrfi, numchan, numint,
ptsperint, lobin, numbetween, harmsum,
fracterror, cmd->freqsigma);
write_statsfile(statsfilenm, datapow[0], dataavg[0], datastd[0],
numchan, numint, ptsperint, lobin, numbetween);
} else { /* If "-nocompute" */
float freqsigma;
/* Read the data from the output files */
printf("Reading RFI data from '%s'.\n", rfifilenm);
printf("Reading statistics from '%s'.\n", statsfilenm);
readinf(&idata, outfilenm);
read_rfifile(rfifilenm, &rfivect, &numrfi, &numchan, &numint,
&ptsperint, &lobin, &numbetween, &harmsum,
&fracterror, &freqsigma);
numrfivect = numrfi;
read_statsfile(statsfilenm, &datapow, &dataavg, &datastd,
&numchan, &numint, &ptsperint, &lobin, &numbetween);
bytemask = gen_bmatrix(numint, numchan);
printf("Reading bytemask from '%s'.\n\n", bytemaskfilenm);
bytemaskfile = chkfopen(bytemaskfilenm, "rb");
chkfread(bytemask[0], numint * numchan, 1, bytemaskfile);
fclose(bytemaskfile);
for (ii = 0; ii < numint; ii++)
for (jj = 0; jj < numchan; jj++)
bytemask[ii][jj] &= PADDING; /* Clear all but the PADDING bits */
inttime = ptsperint * idata.dt;
}
/* Make the plots and set the mask */
{
int *zapints, *zapchan;
int numzapints = 0, numzapchan = 0;
if (cmd->zapintsstrP) {
zapints = ranges_to_ivect(cmd->zapintsstr, 0, numint - 1, &numzapints);
zapints = (int *) realloc(zapints, (size_t) (sizeof(int) * numint));
} else {
zapints = gen_ivect(numint);
}
if (cmd->zapchanstrP) {
zapchan = ranges_to_ivect(cmd->zapchanstr, 0, numchan - 1, &numzapchan);
zapchan = (int *) realloc(zapchan, (size_t) (sizeof(int) * numchan));
} else {
zapchan = gen_ivect(numchan);
}
rfifind_plot(numchan, numint, ptsperint, cmd->timesigma, cmd->freqsigma,
cmd->inttrigfrac, cmd->chantrigfrac,
dataavg, datastd, datapow, zapchan, numzapchan,
zapints, numzapints, &idata, bytemask,
&oldmask, &newmask, rfivect, numrfi,
cmd->rfixwinP, cmd->rfipsP, cmd->xwinP);
vect_free(zapints);
vect_free(zapchan);
}
/* Write the new mask and bytemask to the file */
write_mask(maskfilenm, &newmask);
bytemaskfile = chkfopen(bytemaskfilenm, "wb");
chkfwrite(bytemask[0], numint * numchan, 1, bytemaskfile);
fclose(bytemaskfile);
/* Determine the percent of good and bad data */
{
int numpad = 0, numbad = 0, numgood = 0;
for (ii = 0; ii < numint; ii++) {
for (jj = 0; jj < numchan; jj++) {
if (bytemask[ii][jj] == GOODDATA) {
numgood++;
} else {
if (bytemask[ii][jj] & PADDING)
numpad++;
else
numbad++;
}
}
}
printf("\nTotal number of intervals in the data: %d\n\n", numint * numchan);
printf(" Number of padded intervals: %7d (%6.3f%%)\n",
numpad, (float) numpad / (float) (numint * numchan) * 100.0);
printf(" Number of good intervals: %7d (%6.3f%%)\n",
numgood, (float) numgood / (float) (numint * numchan) * 100.0);
printf(" Number of bad intervals: %7d (%6.3f%%)\n\n",
numbad, (float) numbad / (float) (numint * numchan) * 100.0);
qsort(rfivect, numrfi, sizeof(rfi), compare_rfi_sigma);
printf(" Ten most significant birdies:\n");
printf("# Sigma Period(ms) Freq(Hz) Number \n");
printf("----------------------------------------------------\n");
for (ii = 0; ii < 10; ii++) {
double pperr;
char temp1[40], temp2[40];
if (rfivect[ii].freq_var == 0.0) {
pperr = 0.0;
sprintf(temp1, " %-14g", rfivect[ii].freq_avg);
sprintf(temp2, " %-14g", 1000.0 / rfivect[ii].freq_avg);
} else {
pperr = 1000.0 * sqrt(rfivect[ii].freq_var) /
(rfivect[ii].freq_avg * rfivect[ii].freq_avg);
nice_output_2(temp1, rfivect[ii].freq_avg, sqrt(rfivect[ii].freq_var),
-15);
nice_output_2(temp2, 1000.0 / rfivect[ii].freq_avg, pperr, -15);
}
printf("%-2d %-8.2f %13s %13s %-8d\n", ii + 1, rfivect[ii].sigma_avg,
temp2, temp1, rfivect[ii].numobs);
}
qsort(rfivect, numrfi, sizeof(rfi), compare_rfi_numobs);
printf("\n Ten most numerous birdies:\n");
printf("# Number Period(ms) Freq(Hz) Sigma \n");
printf("----------------------------------------------------\n");
for (ii = 0; ii < 10; ii++) {
double pperr;
char temp1[40], temp2[40];
if (rfivect[ii].freq_var == 0.0) {
pperr = 0.0;
sprintf(temp1, " %-14g", rfivect[ii].freq_avg);
sprintf(temp2, " %-14g", 1000.0 / rfivect[ii].freq_avg);
} else {
pperr = 1000.0 * sqrt(rfivect[ii].freq_var) /
(rfivect[ii].freq_avg * rfivect[ii].freq_avg);
nice_output_2(temp1, rfivect[ii].freq_avg, sqrt(rfivect[ii].freq_var),
-15);
nice_output_2(temp2, 1000.0 / rfivect[ii].freq_avg, pperr, -15);
}
printf("%-2d %-8d %13s %13s %-8.2f\n", ii + 1, rfivect[ii].numobs,
temp2, temp1, rfivect[ii].sigma_avg);
}
printf("\nDone.\n\n");
}
/* Close the files and cleanup */
free_rfi_vector(rfivect, numrfivect);
free_mask(newmask);
if (cmd->maskfileP)
free_mask(oldmask);
free(outfilenm);
free(statsfilenm);
free(bytemaskfilenm);
free(maskfilenm);
free(rfifilenm);
vect_free(dataavg[0]);
vect_free(dataavg);
vect_free(datastd[0]);
vect_free(datastd);
vect_free(datapow[0]);
vect_free(datapow);
vect_free(bytemask[0]);
vect_free(bytemask);
if (!cmd->nocomputeP) {
// Close all the raw files and free their vectors
close_rawfiles(&s);
vect_free(chandata);
if (insubs)
vect_free(srawdata);
else
vect_free(rawdata);
}
return (0);
}
int main(int argc, char *argv[])
/* dftfold: Does complex plane vector addition of a DFT freq */
/* Written by Scott Ransom on 31 Aug 00 based on Ransom and */
/* Eikenberry paper I (to be completed sometime...). */
{
FILE *infile;
char infilenm[200], outfilenm[200];
int dataperread;
unsigned long N;
double T, rr = 0.0, norm = 1.0;
dftvector dftvec;
infodata idata;
Cmdline *cmd;
/* Call usage() if we have no command line arguments */
if (argc == 1) {
Program = argv[0];
usage();
exit(1);
}
/* Parse the command line using the excellent program Clig */
cmd = parseCmdline(argc, argv);
#ifdef DEBUG
showOptionValues();
#endif
printf("\n\n");
printf(" DFT Vector Folding Routine\n");
printf(" by Scott M. Ransom\n");
printf(" 31 August, 2000\n\n");
/* Open the datafile and read the info file */
sprintf(infilenm, "%s.dat", cmd->argv[0]);
infile = chkfopen(infilenm, "rb");
readinf(&idata, cmd->argv[0]);
/* The number of points in datafile */
N = chkfilelen(infile, sizeof(float));
dataperread = N / cmd->numvect;
/* N = cmd->numvect * dataperread; */
T = N * idata.dt;
/* Calculate the Fourier frequency */
if (!cmd->rrP) {
if (cmd->ffP)
rr = cmd->ff;
else if (cmd->ppP)
rr = T / cmd->pp;
else {
printf("\n You must specify a frequency to fold! Exiting.\n\n");
}
} else
rr = cmd->rr;
/* Calculate the amplitude normalization if required */
if (cmd->normP)
norm = 1.0 / sqrt(cmd->norm);
else if (cmd->fftnormP) {
FILE *fftfile;
int kern_half_width, fftdatalen, startbin;
double rrfrac, rrint;
char fftfilenm[200];
fcomplex *fftdata;
sprintf(fftfilenm, "%s.fft", cmd->argv[0]);
fftfile = chkfopen(fftfilenm, "rb");
kern_half_width = r_resp_halfwidth(HIGHACC);
fftdatalen = 2 * kern_half_width + 10;
rrfrac = modf(rr, &rrint);
startbin = (int) rrint - fftdatalen / 2;
fftdata = read_fcomplex_file(fftfile, startbin, fftdatalen);
norm = 1.0 / sqrt(get_localpower3d(fftdata, fftdatalen,
rrfrac + fftdatalen / 2, 0.0, 0.0));
vect_free(fftdata);
fclose(fftfile);
}
/* Initialize the dftvector */
init_dftvector(&dftvec, dataperread, cmd->numvect, idata.dt, rr, norm, T);
/* Show our folding values */
printf("\nFolding data from '%s':\n", infilenm);
printf(" Folding Fourier Freq = %.5f\n", rr);
printf(" Folding Freq (Hz) = %-.11f\n", rr / T);
printf(" Folding Period (s) = %-.14f\n", T / rr);
printf(" Points per sub-vector = %d\n", dftvec.n);
printf(" Number of sub-vectors = %d\n", dftvec.numvect);
printf(" Normalization constant = %g\n", norm * norm);
/* Perform the actual vector addition */
{
int ii, jj;
float *data;
double real, imag, sumreal = 0.0, sumimag = 0.0;
double theta, aa, bb, cc, ss, dtmp;
double powargr, powargi, phsargr, phsargi, phstmp;
data = gen_fvect(dftvec.n);
theta = -TWOPI * rr / (double) N;
dtmp = sin(0.5 * theta);
aa = -2.0 * dtmp * dtmp;
bb = sin(theta);
cc = 1.0;
ss = 0.0;
for (ii = 0; ii < dftvec.numvect; ii++) {
chkfread(data, sizeof(float), dftvec.n, infile);
real = 0.0;
imag = 0.0;
for (jj = 0; jj < dftvec.n; jj++) {
real += data[jj] * cc;
imag += data[jj] * ss;
cc = aa * (dtmp = cc) - bb * ss + cc;
ss = aa * ss + bb * dtmp + ss;
}
dftvec.vector[ii].r = norm * real;
dftvec.vector[ii].i = norm * imag;
sumreal += dftvec.vector[ii].r;
sumimag += dftvec.vector[ii].i;
}
vect_free(data);
printf("\nDone:\n");
printf(" Vector sum = %.3f + %.3fi\n", sumreal, sumimag);
printf(" Total phase (deg) = %.2f\n", PHASE(sumreal, sumimag));
printf(" Total power = %.2f\n", POWER(sumreal, sumimag));
printf("\n");
}
fclose(infile);
/* Write the output structure */
sprintf(outfilenm, "%s_%.3f.dftvec", cmd->argv[0], rr);
write_dftvector(&dftvec, outfilenm);
/* Free our vector and return */
free_dftvector(&dftvec);
return (0);
}