ComponentModel.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2006 by Russell Edwards
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Timing/Pulsar/ComponentModel.h
 
#ifndef __Pulsar_ComponentModel_h
#define __Pulsar_ComponentModel_h
 
#include "Pulsar/ProfileShiftEstimator.h"
#include "MEAL/Univariate.h"
 
#include <map>
 
namespace MEAL 
{
  class Scalar;
  class ScalarParameter;
  class ScaledVonMises;
  class ScaledVonMisesDeriv;
}
 
namespace Pulsar
{
  class Profile;
  class Archive;
 
 
  class ComponentModel : public ProfileShiftEstimator
  {
  public:
 
    ComponentModel ();
 
    ComponentModel (const std::string& filename);
 
    double get_gate_duty_cycle() const { return gate; }
    
    virtual void set_gate_duty_cycle (double turns) { gate = turns; }
 
    Estimate<double> get_shift () const;
 
    std::string get_name () const { return filename; }
    
    TextInterface::Parser* get_interface ();
 
    ComponentModel* clone () const { return new ComponentModel(*this); }
 
    MEAL::Univariate<MEAL::Scalar>* get_model ();
    
    double get_reduced_chisq () const { return chisq / nfree; }
 
    double get_absolute_phase () const;
    
    // I/O
    void load (const char *fname);
    void unload (const char *fname) const;
 
    void set_log_height (bool flag=true);
    bool get_log_height () const { return log_height; }
 
    void set_retain_memory (bool flag=true);
    bool get_retain_memory () const { return retain_memory; }
 
    void set_fix_widths (bool flag=true);
    bool get_fix_widths () const { return fix_widths; }
 
    void set_fit_primary_first (bool flag=true);
    bool get_fit_primary_first () const { return fit_primary_first; }
 
    void set_report_absolute_phases (bool flag=true);
    bool get_report_absolute_phases () const { return report_absolute_phases; }
 
    void set_report_widths (bool flag=true) { report_widths = flag; }
    bool get_report_widths () const { return report_widths; }
 
    // Manipulation
    void add_component (double centre, double concentration, double height,
                        const char *name);
 
    void remove_component (unsigned icomp);
 
    MEAL::ScaledVonMises *get_component(unsigned icomp);
 
    unsigned get_ncomponents() const;
 
    void align (const Profile *profile);
 
    void align_to_model (Profile* profile);
 
    void get_best_alignment (const Profile* profile, double& phase, double& scale);
 
    void fix_relative_phases ();
 
    void set_zap_height_ratio (float r) { zap_height_ratio = r; }
    float get_zap_height_ratio () const { return zap_height_ratio; }
 
    void set_zap_concentration_ratio (float r) { zap_concentration_ratio = r; }
    float get_zap_concentration_ratio () const { return zap_concentration_ratio; }
 
    // Fitting
 
    void set_fit_derivative (bool flag) { fit_derivative = flag; }
    void set_threshold (float t) { threshold = t; }
 
    void set_infit (unsigned icomponent, unsigned iparam, bool infit);
    void set_infit (const char *fitstring);
 
    void fit (const Profile *profile);
 
    float get_chisq () const { return chisq; }
    unsigned get_nfree () const { return nfree; }
    
    // Evaluating
    void evaluate (float *vals, unsigned nvals, int icomp=-1) ;
 
  protected:
 
    std::vector< Reference::To<MEAL::ScaledVonMises> > components;
 
    mutable std::vector< Reference::To<MEAL::ScaledVonMises> > backup;
 
    // set all infit flags of the specified component to false
    void freeze (unsigned icomponent) const;
 
    // restore all infit flags of the specified component from backup
    void unfreeze (unsigned icomponent) const;
 
    std::vector<std::string> component_names;
 
    mutable std::vector< Reference::To<MEAL::ScaledVonMisesDeriv> > derivative;
 
    std::map<unsigned, std::string> comments;
    
    mutable Reference::To< MEAL::ScalarParameter > phase;
    mutable Reference::To< MEAL::Univariate<MEAL::Scalar> > model;
 
    double gate;
    
    bool fit_derivative;
    float threshold;
 
    bool log_height;
    bool retain_memory;
    bool fix_widths;
    bool fit_primary_first;
    bool report_absolute_phases;
    bool report_widths;
    
    float zap_height_ratio;
    float zap_concentration_ratio;
 
    void build () const;
    void check (const char* method, unsigned icomponent) const;
 
    void clear ();
    void init ();
 
  private:
 
    float chisq;
    unsigned nfree;
    std::string filename;
  };
}
 
#endif