static double find_peak(float inf, fftview * fv, fftpart * fp)
{
int ii, lobin, hibin, maxbin = 0;
float maxpow = 0.0;
double inr, viewfrac = 0.05, newmaxr, newmaxz;
rderivs derivs;
fourierprops props;
inr = inf * T;
lobin = inr - (fv->numbins * 0.5 * viewfrac);
hibin = inr + (fv->numbins * 0.5 * viewfrac);
for (ii = lobin - fp->rlo; ii < hibin - fp->rlo + 1; ii++) {
if (fp->rawpowers[ii] > maxpow) {
maxpow = fp->rawpowers[ii];
maxbin = ii + fp->rlo;
}
}
maxpow = max_rz_arr(fp->amps, fp->numamps, maxbin, 0.0,
&newmaxr, &newmaxz, &derivs);
newmaxr += fp->rlo;
calc_props(derivs, newmaxr, newmaxz, 0.0, &props);
print_candidate(&props, idata.dt, N, r0, 2);
return newmaxr;
}
// FIXME: this shouldn't be a #define, or it shouldn't be here
void optimize_accelcand(accelcand * cand, accelobs * obs)
{
int ii;
int *r_offset;
fcomplex **data;
double r, z;
cand->pows = gen_dvect(cand->numharm);
cand->hirs = gen_dvect(cand->numharm);
cand->hizs = gen_dvect(cand->numharm);
r_offset = (int*) malloc(sizeof(int)*cand->numharm);
data = (fcomplex**) malloc(sizeof(fcomplex*)*cand->numharm);
cand->derivs = (rderivs *) malloc(sizeof(rderivs) * cand->numharm);
if (obs->use_harmonic_polishing) {
if (obs->mmap_file || obs->dat_input) {
for(ii=0;ii<cand->numharm;ii++) {
r_offset[ii]=obs->lobin;
data[ii] = obs->fft;
}
max_rz_arr_harmonics(data,
cand->numharm,
r_offset,
obs->numbins,
cand->r-obs->lobin,
cand->z,
&r,
&z,
cand->derivs,
cand->pows);
} else {
max_rz_file_harmonics(obs->fftfile,
cand->numharm,
obs->lobin,
cand->r-obs->lobin,
cand->z,
&r,
&z,
cand->derivs,
cand->pows);
}
for(ii=0;ii<cand->numharm;ii++) {
cand->hirs[ii]=(r+obs->lobin)*(ii+1);
cand->hizs[ii]=z*(ii+1);
}
} else {
for (ii = 0; ii < cand->numharm; ii++) {
if (obs->mmap_file || obs->dat_input)
cand->pows[ii] = max_rz_arr(obs->fft,
obs->numbins,
cand->r * (ii + 1) - obs->lobin,
cand->z * (ii + 1),
&(cand->hirs[ii]),
&(cand->hizs[ii]), &(cand->derivs[ii]));
else
cand->pows[ii] = max_rz_file(obs->fftfile,
cand->r * (ii + 1) - obs->lobin,
cand->z * (ii + 1),
&(cand->hirs[ii]),
&(cand->hizs[ii]), &(cand->derivs[ii]));
cand->hirs[ii] += obs->lobin;
}
}
free(r_offset);
free(data);
cand->sigma = candidate_sigma(cand->power, cand->numharm,
obs->numindep[twon_to_index(cand->numharm)]);
}
int main(int argc, char *argv[])
{
FILE *fftfile;
double flook, dt, nph, t, maxz, pwr, hipow = 0.0;
double zlo = -30.0, zhi = 30.0, dr, dz = 2.0;
double hir = 0.0, hiz = 0.0, newhir, newhiz;
fcomplex **ffdotplane, *data;
float powargr, powargi;
int startbin, numdata, nextbin, nr, nz, numkern;
int i, j, realpsr, kernel_half_width, numbetween = 4;
int n, corrsize = 1024;
char filenm[80], compare[200];
rderivs derivs;
fourierprops props;
infodata idata;
struct tms runtimes;
double ttim, utim, stim, tott;
tott = times(&runtimes) / (double) CLK_TCK;
if (argc != 3) {
printf("\nUsage: 'quicklook filename fftfreq dt'\n\n");
printf(" 'filename' = a string containing the FFT file's name.\n");
printf(" (do not include the '.fft' suffix)\n");
printf(" 'fftfreq' = the central fourier frequency to examine.\n");
printf(" Quicklook will search a region of the f-fdot plane\n");
printf(" of a file containing a long, single precision FFT\n");
printf(" using the Correlation method (i.e. Ransom and \n");
printf(" Eikenberry, 1997, unpublished as of yet).\n");
printf(" The search uses a spacing of 0.5 frequency bins in\n");
printf(" the fourier frequency (r) direction, and 2 'bins' in\n");
printf(" the fdot (z) direction. The routine will output\n");
printf(" statistics for the best candidate in the region.\n\n");
printf(" The routine was written as a quick but useful hack\n");
printf(" to show the power of the Correlation method, and the\n");
printf(" forthcoming power of Scott Ransom's Pulsar Finder\n");
printf(" Software.\n");
printf(" 2 March 2001\n\n");
exit(0);
}
printf("\n\n");
printf(" Quick-Look Pulsation Search\n");
printf(" With database lookup.\n");
printf(" by Scott M. Ransom\n");
printf(" 2 March, 2001\n\n");
/* Initialize our data: */
sprintf(filenm, "%s.fft", argv[1]);
readinf(&idata, argv[1]);
flook = atof(argv[2]);
dt = idata.dt;
dr = 1.0 / (double) numbetween;
fftfile = chkfopen(filenm, "r");
nph = get_numphotons(fftfile);
n = chkfilelen(fftfile, sizeof(float));
t = n * dt;
nz = (int) ((zhi - zlo) / dz) + 1;
/* Determine our starting frequency and get the data */
maxz = (fabs(zlo) < fabs(zhi)) ? zhi : zlo;
kernel_half_width = z_resp_halfwidth(maxz, HIGHACC);
numkern = 2 * numbetween * kernel_half_width;
while (numkern > 2 * corrsize)
corrsize *= 2;
startbin = (int) (flook) - corrsize / (2 * numbetween);
numdata = corrsize / numbetween;
data = read_fcomplex_file(fftfile, startbin, numdata);
/* Do the f-fdot plane correlations: */
ffdotplane = corr_rz_plane(data, numdata, numbetween, kernel_half_width,
zlo, zhi, nz, corrsize, LOWACC, &nextbin);
nr = corrsize - 2 * kernel_half_width * numbetween;
/* Search the resulting data set: */
for (i = 0; i < nz; i++) {
for (j = 0; j < nr; j++) {
pwr = POWER(ffdotplane[i][j].r, ffdotplane[i][j].i);
if (pwr > hipow) {
hir = j * dr + kernel_half_width;
hiz = i * dz + zlo;
hipow = pwr;
}
}
}
/* Maximize the best candidate: */
hipow = max_rz_arr(data, numdata, hir, hiz, &newhir, &newhiz, &derivs);
newhir += startbin;
calc_props(derivs, newhir, newhiz, 0.0, &props);
printf("Searched %d pts ", nz * nr);
printf("(r: %.1f to %.1f, ", (double) startbin + kernel_half_width,
(double) startbin + kernel_half_width + dr * (nr - 1));
printf("z: %.1f to %.1f)\n\n", zlo, zhi);
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 time: %.3f sec (User: %.3f sec, System: %.3f sec)\n",
ttim, utim, stim);
printf(" Total time: %.3f sec\n\n", tott);
printf("The best candidate is:\n");
print_candidate(&props, dt, n, nph, 2);
realpsr = comp_psr_to_cand(&props, &idata, compare, 1);
printf("%s\n", compare);
fclose(fftfile);
/* Cleanup and exit */
free(ffdotplane[0]);
free(ffdotplane);
free(data);
exit(0);
}