FluxCalibratorPolicy.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003 - 2018 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/FluxCalibratorPolicy.h
 
#ifndef __Pulsar_FluxCalibratorPolicy_H
#define __Pulsar_FluxCalibratorPolicy_H
 
#include "Pulsar/FluxCalibrator.h"
#include "MEAL/ScalarMath.h"
#include "MEAL/ScalarParameter.h"
#include "MEAL/ScalarConstant.h"
#include "Types.h"
 
namespace Pulsar {

  class FluxCalibrator::Policy : public Reference::Able
  {
 
  public:

    Policy ();

    virtual Policy* clone () const = 0;

    virtual void integrate (Signal::Source source, unsigned ireceptor,
                            const Estimate<double>& cal_hi,
                            const Estimate<double>& cal_lo) = 0;
        
    void get ( std::vector< Estimate<double> >& S_sys,
               std::vector< Estimate<double> >& S_cal ) const;

    void set ( const std::vector< Estimate<double> >& S_sys,
               const std::vector< Estimate<double> >& S_cal );

    virtual void set_nreceptor (unsigned);
    
    unsigned get_nreceptor () const;

    void set_S_std (double S_std);
    
    double get_S_std () const;
    
    void set_valid (bool f = true) { valid = f; }
    
    bool get_valid () const { return valid; }

    bool get_solution_available () const;

    Estimate<double> get_S_sys () const;
    
    Estimate<double> get_S_cal () const;
    
    Estimate<double> get_S_sys (unsigned receptor) const;
    
    Estimate<double> get_S_cal (unsigned receptor) const;
    
  protected:
    
    mutable bool valid;
    
    double S_std;
    
    mutable std::vector< Estimate<double> > S_cal;
    
    mutable std::vector< Estimate<double> > S_sys;

    mutable bool calculated;
    
    void calculate () const;
    
    virtual void compute (unsigned ireceptor,
                          Estimate<double>& S_cal,
                          Estimate<double>& S_sys) = 0;
    
  };

  class FluxCalibrator::VariableGain : public FluxCalibrator::Policy
  {
 
  public:

    VariableGain ();
 
    VariableGain* clone () const;
    
    void integrate (Signal::Source source, unsigned ireceptor,
                    const Estimate<double>& cal_hi,
                    const Estimate<double>& cal_lo);
    
  protected:
    
    std::vector< MeanEstimate<double> > mean_ratio_on;
    
    std::vector< MeanEstimate<double> > mean_ratio_off;

    void add_ratio_on (unsigned receptor, Estimate<double>& ratio_on);
    
    void add_ratio_off (unsigned receptor, Estimate<double>& ratio_on);
    
    void compute (unsigned ireceptor,
                  Estimate<double>& S_cal,
                  Estimate<double>& S_sys);
 
  private:
    
    /* 
       Use the ScalarMath class to calculate the variances.
       These are static because they cost a bit during construction.
    */
    MEAL::ScalarParameter ratio_on;
    MEAL::ScalarParameter ratio_off;
    MEAL::ScalarConstant unity;
    
    MEAL::ScalarMath flux_cal;
    MEAL::ScalarMath flux_sys;
  };

  class FluxCalibrator::ConstantGain : public FluxCalibrator::Policy
  {
 
  public:

    ConstantGain ();
 
    ConstantGain* clone () const;

    void set_nreceptor (unsigned);
    
    void integrate (Signal::Source source, unsigned ireceptor,
                    const Estimate<double>& cal_hi,
                    const Estimate<double>& cal_lo);

    Estimate<double> get_scale (unsigned ireceptor) const;
    void get_scale ( std::vector< Estimate<double> >& );

    void set_scale (unsigned ireceptor, const Estimate<double>&);
    void set_scale ( const std::vector< Estimate<double> >& );

    Estimate<double> get_gain (unsigned ireceptor) const;

    Estimate<double> get_gain_ratio (unsigned ireceptor) const;
    void get_gain_ratio ( std::vector< Estimate<double> >& );

    void set_gain_ratio (unsigned ireceptor, const Estimate<double>&);
    void set_gain_ratio ( const std::vector< Estimate<double> >& );
 
    Estimate<double> get_scale () const;
    Estimate<double> get_gain () const;
 
  protected:
    
    std::vector< MeanEstimate<double> > mean_hi_on;
    std::vector< MeanEstimate<double> > mean_lo_on;
    
    std::vector< MeanEstimate<double> > mean_hi_off;
    std::vector< MeanEstimate<double> > mean_lo_off;
    
    void compute (unsigned ireceptor,
                  Estimate<double>& S_cal,
                  Estimate<double>& S_sys);
 
    void invalidate (unsigned ireceptor);
 
    std::vector< Estimate<double> > scale;
    std::vector< Estimate<double> > gain_ratio;
    
  private:
    
    /* 
       Use the ScalarMath class to calculate the variances.
    */
    MEAL::ScalarParameter ratio_hi;
    MEAL::ScalarParameter ratio_lo;
    MEAL::ScalarConstant unity;
    
    MEAL::ScalarMath flux_cal;
    MEAL::ScalarMath flux_sys;
 
  };
}
 
#endif