FluxCalibrator.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2003 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
// psrchive/More/Polarimetry/Pulsar/FluxCalibrator.h
 
#ifndef __Pulsar_FluxCalibrator_H
#define __Pulsar_FluxCalibrator_H
 
#include "Pulsar/Calibrator.h"
 
namespace Pulsar {
 
  class Integration;
  class StandardCandles;
  class CalibratorStokes;
  class FluxCalibratorExtension;
  
  class FluxCalibrator : public Calibrator {
    
  public:

    FluxCalibrator (const Archive* archive = 0);

    ~FluxCalibrator ();

    class Policy;

    class VariableGain;

    class ConstantGain;

    void set_policy (Policy*);
                     
    class Info;

    Calibrator::Info* get_Info () const;
    
    CalibratorExtension* new_Extension () const;

    std::string get_standard_candle_info () const;

    double meanTsys () const;
    
    double Tsys (unsigned ichan) const;

    const CalibratorStokes* get_CalibratorStokes () const;
    
    void add_observation (const Archive* archive);

    void set_database (const StandardCandles* database);

    void set_outlier_threshold (float f) { outlier_threshold = f; }

    float get_outlier_threshold () const { return outlier_threshold; }

    void calibrate (Archive* archive);

    unsigned get_nchan () const;

    unsigned get_nreceptor () const;

    bool get_valid (unsigned ch) const;

    float get_weight (unsigned ichan) const;

    void set_invalid (unsigned ch);

    void print(std::ostream& os=std::cout) const;

    bool complete () const { return (have_on && have_off); }

    void calibration_setup (const Archive* archive);
 
  protected:
 
    friend class FluxCalibratorExtension;
    friend class ConstantGainInfo;
    friend class Info;

    Reference::To<const StandardCandles> database;

    Reference::To<const FluxCalibratorExtension> flux_extension;
    
    void create (unsigned nchan = 0);

    void calibrate (Integration* subint);

    std::vector< Reference::To<Policy> > data;

    void data_range_check (unsigned ichan, const char* method) const;

    void resize (unsigned nchan, unsigned nreceptor);

    std::vector< float > gain;

    void resize (unsigned required_nchan);

    Reference::To<Policy> policy;
    
  private:

    mutable Reference::To<CalibratorStokes> calibrator_stokes;
    
    bool calculated = false;

    bool have_on = false;

    bool have_off = false;

    std::string standard_candle_info;

    double outlier_threshold = 0.0;

    bool constant_scale = false;

    void init ();

    void setup ();
 
  };
 
}
 
#endif