Profile.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 - 2023 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/Base/Classes/Pulsar/Profile.h
 
#ifndef __Pulsar_Profile_h
#define __Pulsar_Profile_h
 
#include "Pulsar/ProfileAmps.h"
#include "Pulsar/Config.h"
 
#include "Types.h"
#include "Functor.h"
#include "Estimate.h"
 
namespace Pulsar {
 
  class PhaseWeight;
  class ProfileWeightFunction;
  class SNRatioEstimator;


  class Profile : public ProfileAmps {
 
  public:

    friend class Integration;

    static bool verbose;

    static bool rotate_phase_enabled;

    static Option<bool> rotate_in_phase_domain;

    static Option<float> transition_duty_cycle;

    static Option<float> default_duty_cycle;

    Profile (unsigned nbin = 0);

    Profile (const Profile& profile);

    Profile (const Profile* profile);

    ~Profile ();

    static unsigned get_instance_count ();

    virtual Profile* clone () const;

    virtual void resize (unsigned nbin);

    const Profile& operator = (const Profile& profile);

    void copy (const Profile*, bool clone_strategy = true);

    void average (const Profile* that);

    void sum (const Profile* profile);

    void diff (const Profile* profile);

    const Profile& operator += (float offset);

    const Profile& operator -= (float offset);

    const Profile& operator *= (float scale);

    void scale (double scale);

    void offset (double offset);

    void rotate_phase (double phase);

    void derivative ();

    void zero ();
  
    void square_root ();

    void absolute ();

    void logarithm (double base = 10.0, double threshold = 0.0);

    float max  (int bin_start=0, int bin_end=0) const;
    float min  (int bin_start=0, int bin_end=0) const;

    double sum (int bin_start=0, int bin_end=0) const;
    double sumsq (int bin_start=0, int bin_end=0) const;
    double sumfabs (int bin_start=0, int bin_end=0) const;

    void stats (double* mean, double* variance = 0, double* varmean = 0,
                int bin_start=0, int bin_end=0) const;

    void stats (float phase, 
                double* mean, double* variance = 0, double* varmean = 0,
                float duty_cycle = default_duty_cycle) const;

    double mean (float phase, float duty_cycle = default_duty_cycle) const;

    float find_max_phase (float duty_cycle = default_duty_cycle) const;
    float find_min_phase (float duty_cycle = default_duty_cycle) const;

    void find_transitions (int& highlow, int& lowhigh, int& width) const;

    int find_max_bin (int bin_start=0, int bin_end=0) const;
    int find_min_bin (int bin_start=0, int bin_end=0) const;
 
    typedef Functor< std::pair<int,int> (const Profile*) > Edges;
    static Option<Edges> peak_edges_strategy;

    void find_peak_edges (int& rise, int& fall) const;
 
    class Strategies;

    Strategies* get_strategy() const;

    void set_strategy (Strategies*);
    
    PhaseWeight* baseline () const;

    float snr () const;
    
    void dedisperse (double dm, double ref_freq, double pfold);
    
    Estimate<double> shift (const Profile& std) const;

    std::vector<float> get_weighted_amps () const;
    
    double get_centre_frequency () const { return centrefreq; }
    virtual void set_centre_frequency (double cfreq) { centrefreq = cfreq; }

    float get_weight () const { return fabs(weight); }
    virtual void set_weight (float);

    void fft_convolve (const Profile* profile); 

    void convolve (const Profile* profile); 

    void correlate (const Profile* profile); 

    void correlate_normalized (const Profile* profile); 

    void pscrunch ();

    void bscrunch (unsigned nscrunch);

    void bscrunch_to_nbin (unsigned nbin);

    void fold (unsigned nfold);
 
    // //////////////////////////////////////////////////////////////////
    //
    // Extension access
    //
    // //////////////////////////////////////////////////////////////////

    
    class Extension;
    
    virtual unsigned get_nextension () const;

    virtual const Extension* get_extension (unsigned iextension) const;

    virtual Extension* get_extension (unsigned iextension);

    template<class ExtensionType>
    const ExtensionType* get () const;

    template<class ExtensionType>
    ExtensionType* get ();


    virtual void add_extension (Extension* extension);
 
  protected:
 
    friend class PolnProfile;
    friend class StandardSNR;

    void convolve (const Profile* profile, int direction);

    void init ();

    double centrefreq;

    float weight;

    mutable std::vector< Reference::To<Extension> > extension;

    mutable Reference::To<Strategies> strategy;
  };
 
}
 
 
 
 
#endif // !defined __Pulsar_Profile_h