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