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 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