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