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