SpectralKurtosis.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2011 by Andrew Jameson
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Extensions/Pulsar/SpectralKurtosis.h
 
#ifndef __Pulsar_SpectralKurtosis_h
#define __Pulsar_SpectralKurtosis_h
 
#include "Pulsar/IntegrationExtension.h"
#include "TextInterface.h"
 
namespace Pulsar {
  
  class SpectralKurtosis : public Pulsar::Integration::Extension {
    
  public:
    
    SpectralKurtosis ();
 
    SpectralKurtosis (const SpectralKurtosis& extension);
 
    const SpectralKurtosis& operator= (const SpectralKurtosis& extension);
    
    ~SpectralKurtosis ();
 
    SpectralKurtosis* clone () const { return new SpectralKurtosis( *this ); }
    
    TextInterface::Parser* get_interface();
    
    // Text interface to a SpectralKurtosis instance
    class Interface : public TextInterface::To<SpectralKurtosis>
    {
      public:
          Interface( SpectralKurtosis *s_instance = NULL );
    };
 
    // Abstract loader for SpectralKurtosis extension
    class Loader : public Reference::Able 
    {
      public:
        virtual void load (SpectralKurtosis * s) = 0;
    };
 
    std::string get_short_name () const { return "skz"; }
 
    const SpectralKurtosis& operator += (const SpectralKurtosis& extension);
 
    void set_loader (SpectralKurtosis::Loader *);
 
    void resize (unsigned npol, unsigned nchan);
 
    void integrate (const Integration* subint);
 
    void update (const Integration* subint);
 
    void set_npol (unsigned n) { npol = n; }
    unsigned get_npol() const { get_data(); return npol; }
 
    void set_nchan (unsigned n) { nchan = n; }
    unsigned get_nchan() const { get_data(); return nchan; }
 
    void set_M (unsigned _M);
    unsigned get_M() const;
 
    void set_excision_threshold (unsigned nsigma);
    unsigned get_excision_threshold () const;
 
    float get_filtered_sum (unsigned ichan, unsigned ipol) const;
    void set_filtered_sum (unsigned ichan, unsigned ipol, float sum);
 
    uint64_t get_filtered_hits (unsigned ichan) const;
    void set_filtered_hits (unsigned ichan, uint64_t hits);
 
    float get_unfiltered_sum (unsigned ichan, unsigned ipol) const;
    void set_unfiltered_sum (unsigned ichan, unsigned ipol, float sum);
 
    // Get the unfiltered hits, common to all channels and polarizations
    uint64_t get_unfiltered_hits () const;
    // Set the unfiltered hits, common to all channels and polarizations
    void set_unfiltered_hits (uint64_t hits);
 
    void set_ipol_mean (unsigned ipol) { ipol_mean = ipol; }
    unsigned get_ipol_mean () const { return ipol_mean; }
 
    float get_unfiltered_mean (unsigned ichan) const;
    float get_filtered_mean (unsigned ichan) const;
 
  protected:
 
    Reference::To<SpectralKurtosis::Loader> loader;
 
    unsigned npol = 0;
 
    unsigned nchan = 0;
 
    unsigned M = 0;
    
    unsigned nsigma = 0;
 
    std::vector<float> filtered_sum;
 
    std::vector<uint64_t> filtered_hits;
 
    std::vector<float> unfiltered_sum;
 
    uint64_t unfiltered_hits = 0;
 
    void get_data () const;
    void load ();
 
    void range_check (unsigned ichan, unsigned ipol, const char* method) const;
 
    unsigned ipol_mean = 0;
  };
  
}
 
#endif