Esempio n. 1
0
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;
}
Esempio n. 2
0
// 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)]);
}
Esempio n. 3
0
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);
}