TimeFrequencyZap.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2018 by Paul Demorest
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __Pulsar_TimeFrequencyZap_h
#define __Pulsar_TimeFrequencyZap_h
 
#include "Pulsar/Transformation.h"
#include "Pulsar/Archive.h"
#include "Pulsar/TimeFrequencySmooth.h"
#include "Pulsar/TimeFrequencyMask.h"
#include "Pulsar/ScrunchFactor.h"
 
namespace Pulsar {
 
  class ArchiveStatistic;
 
 
  class TimeFrequencyZap : public Transformation<Archive>
  {
 
    public:
 
      TimeFrequencyZap();
 
      void transform (Archive*);
 
      TextInterface::Parser* get_interface ();
    
      // Text interface to the TimeFrequencyZap class
      class Interface : public TextInterface::To<TimeFrequencyZap> {
      public:
        Interface (TimeFrequencyZap* = 0);
      };
 
      void set_expression (const std::string&);
 
      std::string get_expression () const { return expression; }
    
      void set_statistic (ArchiveStatistic*);
 
      ArchiveStatistic* get_statistic () const;
 
      void set_logarithmic (bool flag = true) { logarithmic = flag; }
 
      bool get_logarithmic () const { return logarithmic; }
 
      void set_smoother (TimeFrequencySmooth*);
 
      TimeFrequencySmooth* get_smoother () const;
 
      void set_masker (TimeFrequencyMask*);
 
      TimeFrequencyMask* get_masker () const;
 
      void set_cutoff_threshold (float t) { masker->set_threshold(t); }
 
      float get_cutoff_threshold () const { return masker->get_threshold(); }
 
      void set_fscrunch (const ScrunchFactor& f) { fscrunch_factor = f; }
 
      const ScrunchFactor get_fscrunch () const { return fscrunch_factor; }
 
      void set_bscrunch (const ScrunchFactor& f) { bscrunch_factor = f; }
    
      const ScrunchFactor get_bscrunch () const { return bscrunch_factor; }
 
      void set_max_iterations (unsigned n) { max_iterations = n; }
 
      unsigned get_max_iterations () const { return max_iterations; }
 
      void set_jobs (const std::string& p) { jobs = p; }
 
      std::string get_jobs () const { return jobs; }
 
      void set_polarizations (const std::string& p) { polns = p; }
 
      std::string get_polarizations () const { return polns; }
 
      void set_recompute (bool flag = true) { recompute = flag; }
 
      bool get_recompute () const { return recompute; }
 
      void set_report (bool flag = true) { report = flag; }
 
      bool get_report () const { return report; }
 
      void set_filename (const std::string& name) { filename = name; }
 
      const std::string& get_filename () const { return filename; }
 
      void set_aux_filename (const std::string& name) { aux_filename = name; }
 
      const std::string& get_aux_filename () const { return aux_filename; }
 
  protected:
 
      void compute_mask (Archive* data);
 
      virtual void compute_stat (Archive* data);
 
      virtual void update_mask();
 
      void apply_mask (Archive* archive,
                       const ScrunchFactor& fscrunch = ScrunchFactor::none,
                       unsigned chan_offset = 0);
 
      std::string expression;
 
      Reference::To<ArchiveStatistic> statistic;
 
      bool logarithmic;
 
      bool regions_from_total;
 
      bool pscrunch;
 
      ScrunchFactor fscrunch_factor;
 
      ScrunchFactor bscrunch_factor;
 
      std::string jobs;
 
      std::string polns;
 
      Reference::To<TimeFrequencySmooth> smoother;
 
      Reference::To<TimeFrequencyMask> masker;
 
      unsigned nchan;
 
      unsigned nsubint;
 
      unsigned npol;
 
      std::vector<unsigned> pol_i;
 
      std::vector<float> freq;
 
      std::vector<float> time;
 
      std::vector<float> stat;
 
      std::vector<float> mask;
 
      unsigned idx(unsigned isubint, unsigned ichan) const { 
        return nchan*isubint + ichan;
      }
 
      unsigned idx(unsigned isubint, unsigned ichan, unsigned ipol) const { 
        return nchan*npol*isubint + npol*ichan + ipol;
      }
 
    void iteration (Archive* archive);
 
    unsigned max_iterations;
 
    bool recompute;
 
    bool recompute_original;
    
    bool report;
 
    std::string filename;
 
    std::string aux_filename;
 
  private:
    
    unsigned nmasked;
 
    unsigned nmasked_original;
 
    unsigned nmasked_during_iterations;
 
 
    std::vector<bool> compute_subint;
 
 
    std::vector<bool> compute_chan;
    
    Reference::To<Archive> last_dedispersed;
    
    Reference::To<Archive> dedispersed_clone;
  };
 
}
 
#endif