SKDetector.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2010 by Andrew Jameson
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __SKDetector_h
#define __SKDetector_h
 
#include "dsp/Transformation.h"
#include "dsp/TimeSeries.h"
#include "dsp/BitSeries.h"
#include "Reference.h"
#include "MJD.h"
 
namespace dsp {
 
  class IOManager;
  class TimeSeries;
 
  class SKDetector: public Transformation<TimeSeries,BitSeries> {
 
  public:
 
    SKDetector ();
 
    ~SKDetector ();
 
    void set_thresholds (unsigned _M, float _n_std_devs);
 
    void set_channel_range (unsigned start, unsigned end);
 
    void set_options (bool disable_fscr, bool disable_tscr, bool disable_ft);
 
    void set_input_tscr (TimeSeries * _input_tscr);
 
    unsigned get_M () const { return M; }
 
    float get_excision_threshold () const { return n_std_devs; }
 
    void get_filtered_sum (std::vector<float>& sum) const
    {  sum = filtered_sum; }
 
    void get_filtered_hits (std::vector<uint64_t>& hits) const
    { hits = filtered_hits; }
 
    void get_unfiltered_sum (std::vector<float>& sum) const
    { sum = unfiltered_sum; }
 
    uint64_t get_unfiltered_hits () const { return unfiltered_hits; }
 
    void reset_count () { unfiltered_hits = 0; }
 
    class Engine;
 
    void set_engine (Engine*);
 
  protected:
 
    void reserve();
 
    void transformation ();
 
    Reference::To<Engine> engine;
 
    void reset_mask ();
 
    void detect_tscr ();
 
    void detect_skfb ();
 
    void detect_fscr();
 
    void count_zapped ();
 
    std::vector<float> filtered_sum;
 
    std::vector<uint64_t> filtered_hits;
 
    std::vector<float> unfiltered_sum;
 
    uint64_t unfiltered_hits;
 
    Reference::To<TimeSeries> input_tscr;
 
    unsigned tscr_M;
 
    float tscr_upper;
    float tscr_lower;
 
    unsigned M;
 
    float one_sigma;
 
    float n_std_devs;
 
    float upper_thresh;
 
    float lower_thresh;
 
    float mega_upper_thresh;
 
    float mega_lower_thresh;
 
    unsigned s_chan;
 
    unsigned e_chan;
 
    uint64_t ndat_zapped;
 
    uint64_t ndat_zapped_skfb;
 
    uint64_t ndat_zapped_mega;
 
    uint64_t ndat_zapped_fscr;
 
    uint64_t ndat_zapped_tscr;
 
    uint64_t ndat_total;
 
    bool disable_fscr;
 
    bool disable_tscr;
 
    bool disable_ft;
 
    unsigned debugd;
 
  private:
 
  };
 
  class SKDetector::Engine : public Reference::Able
  {
  public:
 
    virtual void setup () = 0;
 
    virtual void reset_mask (dsp::BitSeries* output) = 0;
 
    virtual void detect_ft (const dsp::TimeSeries* input, dsp::BitSeries* output,
                            float upper_thresh, float lower_thresh) = 0;
 
    virtual void detect_fscr (const dsp::TimeSeries* input, dsp::BitSeries* output,
                              const float mu2, const float std_devs,
                              unsigned s_chan, unsigned e_chan) = 0;
 
    virtual void detect_tscr (const dsp::TimeSeries* input,
                              const dsp::TimeSeries * input_tscr,
                              dsp::BitSeries* output,
                              float upper_thresh, float lower_thresh) = 0;
 
    virtual int count_mask (const dsp::BitSeries* output) = 0;
 
    virtual float * get_estimates (const TimeSeries* input) = 0;
 
    virtual unsigned char * get_zapmask (const BitSeries* input) = 0;
 
  };
 
 
}
 
#endif