ProfileStats.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2005 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/General/Pulsar/ProfileStats.h
 
#ifndef __Pulsar_ProfileStats_h
#define __Pulsar_ProfileStats_h
 
#include "Pulsar/PhaseWeight.h"
#include "Pulsar/Algorithm.h"
#include "Pulsar/HasBaselineEstimator.h"
 
#include "PhaseRange.h"
#include "TextInterface.h"
#include "Estimate.h"
 
namespace Pulsar
{
  class Profile;
  class ProfileWeightFunction;
  class SNRatioEstimator;
  class WidthEstimator;
  class Integration;

  class ProfileStats : public Algorithm, public HasBaselineEstimator
  {   
  public:

    static unsigned get_instance_count ();

    ProfileStats (const Profile* profile = 0);

    ProfileStats (const ProfileStats&);

    ~ProfileStats();

    ProfileStats* clone () const;

    void set_include_estimator (ProfileWeightFunction*);
    ProfileWeightFunction* get_include_estimator () const;

    void set_exclude_estimator (ProfileWeightFunction*);
    ProfileWeightFunction* get_exclude_estimator () const;

    void set_profile (const Profile*);
    void set_Profile (const Profile* profile) { set_profile(profile); }

    void set_integration (const Integration*);
    void set_Integration (const Integration* subint) { set_integration(subint); }
    Integration* get_Integration() const;

    void select_profile (const Profile*);

    void deselect_onpulse (const Profile* profile, float threshold);

    void set_onpulse_estimator (ProfileWeightFunction*);
    ProfileWeightFunction* get_onpulse_estimator () const;

    void set_baseline_estimator (ProfileWeightFunction*);

    void set_regions (const PhaseWeight& pulse, const PhaseWeight& baseline);

    void get_regions (PhaseWeight& pulse, PhaseWeight& base) const;

    unsigned get_onpulse_nbin () const;

    bool get_onpulse (unsigned ibin) const;

    void set_onpulse (unsigned ibin, bool);

    unsigned get_baseline_nbin () const;

    bool get_baseline (unsigned ibin) const;

    Estimate<double> get_total (bool subtract_baseline = true) const;

    Estimate<double> get_baseline_variance () const;

    PhaseWeight* get_onpulse ();

    PhaseWeight* get_baseline ();

    PhaseWeight* get_all ();

    void set_snratio_estimator (SNRatioEstimator*);
    SNRatioEstimator* get_snratio_estimator () const;

    void set_snr_estimator (const std::string& name);

    double get_snr () const;

    TextInterface::Parser* get_snr_interface ();

    void set_width_estimator (WidthEstimator*);
    WidthEstimator* get_width_estimator () const;

    void set_pulse_width_estimator (const std::string& name);

    ::Phase::Value get_pulse_width () const;

    TextInterface::Parser* get_pulse_width_interface ();

    TextInterface::Parser* get_interface ();

    class Interface;
 
  protected:

    Reference::To<const Profile, false> profile;

    Reference::To<const Integration, false> integration;

    Reference::To<ProfileWeightFunction> onpulse_estimator;

    Reference::To<SNRatioEstimator> snratio_estimator;

    Reference::To<WidthEstimator> width_estimator;

    bool regions_set = false;

    mutable Reference::To<PhaseWeight> onpulse = new PhaseWeight;

    mutable Reference::To<PhaseWeight> baseline = new PhaseWeight;

    mutable Reference::To<PhaseWeight> all = new PhaseWeight;

    mutable Estimate<double> baseline_variance;

    mutable Reference::To<ProfileWeightFunction> include_estimator;

    mutable Reference::To<PhaseWeight> include;

    mutable Reference::To<ProfileWeightFunction> exclude_estimator;

    mutable Reference::To<PhaseWeight> exclude;

    void build () const;
 
  private:

    mutable bool built = false;
  };
 
}
 
 
#endif