ShowerFRecData.h

Go to the documentation of this file.

#ifndef _evt_ShowerFRecData_h_
#define _evt_ShowerFRecData_h_

#include <utl/ShadowPtr.h>
#include <utl/LameShadowPtr_fwd.h>
#include <utl/Vector.h>
#include <utl/Point.h>
#include <utl/TimeStamp.h>
#include <utl/TimeInterval.h>
#include <utl/TabulatedFunction.h>
#include <utl/TabulatedFunctionErrors.h>
#include <evt/VGaisserHillasParameter.h>
#include <evt/MultipleGaisserHillasParameters.h>

#include <vector>
#include <map>


namespace fevt {
  class EyeRecData;
}

namespace evt {

  class ShowerRecData;


  class ShowerFRecData {

  public:
    enum EUncertaintyType {
      eTotal = 0,
      eStatistical,
      eAtmospheric
    };

    typedef std::map<EUncertaintyType, double> UncertaintyMap;
    typedef UncertaintyMap::const_iterator UncertaintyMapConstIterator;

  public:
    bool HasLongitudinalProfile() const { return bool(fLongitudinalProfile); }
    utl::TabulatedFunctionErrors& GetLongitudinalProfile()
    { return *fLongitudinalProfile; }
    const utl::TabulatedFunctionErrors& GetLongitudinalProfile() const
    { return *fLongitudinalProfile; }
    void MakeLongitudinalProfile();

    bool HasFluorescencePhotons() const { return bool(fFluorescencePhotons); }
    utl::TabulatedFunctionErrors& GetFluorescencePhotons()
    { return *fFluorescencePhotons; }
    const utl::TabulatedFunctionErrors& GetFluorescencePhotons() const
    { return *fFluorescencePhotons; }
    void MakeFluorescencePhotons();

    bool HasCherenkovPhotons() const { return bool(fCherenkovPhotons); }
    utl::TabulatedFunction& GetCherenkovPhotons()
    { return *fCherenkovPhotons; }
    const utl::TabulatedFunction& GetCherenkovPhotons() const
    { return *fCherenkovPhotons; }
    void MakeCherenkovPhotons();
 
    template<class T>
    bool HasGHParameters() const { return (bool(fGHParameters) && dynamic_cast<const T*>(fGHParameters.Get())); }
    template<class T>
    T& GetGHParameters() { return *dynamic_cast<T*>(fGHParameters.Get()); }
    template<class T>
    const T& GetGHParameters() const { return *dynamic_cast<const T*>(fGHParameters.Get()); }
    
    bool HasGHParameters() const { return bool(fGHParameters); }
    evt::VGaisserHillasParameter& GetGHParameters()
    { return *fGHParameters; }
    const evt::VGaisserHillasParameter& GetGHParameters() const
    { return *fGHParameters; }
    void MakeGHParameters(const VGaisserHillasParameter& gh);

    bool HasMultipleGHParameters() const { return fMultipleGHParameters.GetVirtualParameters().size(); }
    evt::MultipleGaisserHillasParameters&
    GetMultipleGHParameters() { return fMultipleGHParameters; }
    const evt::MultipleGaisserHillasParameters&
    GetMultipleGHParameters() const { return fMultipleGHParameters; }
    void MakeMultipleGHParameters(const std::vector<double>& dgh);

    bool HasEnergyDeposit() const { return bool(fEnergyDeposit); }
    utl::TabulatedFunctionErrors& GetEnergyDeposit()
    { return *fEnergyDeposit; }
    const utl::TabulatedFunctionErrors& GetEnergyDeposit() const
    { return *fEnergyDeposit; }
    void MakeEnergyDeposit();

    void SetEmEnergy(const double energy, const double energyError,
                     const EUncertaintyType type = eTotal )
    { fEmEnergy = energy; fEmEnergyError[type] = energyError; }
    void SetEmEnergyError(const double energyError, const EUncertaintyType type )
    { fEmEnergyError[type] = energyError; }

    void SetTotalEnergy(const double energy, const double energyError,
                        const EUncertaintyType type = eTotal )
    { fTotalEnergy = energy; fTotalEnergyError[type] = energyError; }
    void SetTotalEnergyError(const double energyError, const EUncertaintyType type)
    { fTotalEnergyError[type] = energyError; }

    void SetXmaxError(const double xmaxError, const EUncertaintyType type)
    { fXmaxError[type] = xmaxError; }

    void SetEnergyCutoff(const double energy) { fEnergyCutoff = energy; }

    void AddStationId(const unsigned short int id) { fStationIds.push_back(id); }

    double GetEmEnergy() const { return fEmEnergy; }
    double GetEmEnergyError(const EUncertaintyType type = eTotal) const;
    UncertaintyMapConstIterator GetEmEnergyErrorsBegin() const
    { return fEmEnergyError.begin(); }
    UncertaintyMapConstIterator GetEmEnergyErrorsEnd() const
    { return fEmEnergyError.end(); }
    bool HasEmEnergyError(const EUncertaintyType type = eTotal) const;

    double GetTotalEnergy() const { return fTotalEnergy; }
    double GetTotalEnergyError(const EUncertaintyType type = eTotal) const;
    UncertaintyMapConstIterator GetTotalEnergyErrorsBegin() const
    { return fTotalEnergyError.begin(); }
    UncertaintyMapConstIterator GetTotalEnergyErrorsEnd() const
    { return fTotalEnergyError.end(); }
    bool  HasTotalEnergyError(const EUncertaintyType type = eTotal) const;

    double GetXmaxError(const EUncertaintyType type = eTotal) const;
    UncertaintyMapConstIterator GetXmaxErrorsBegin() const
    { return fXmaxError.begin(); }
    UncertaintyMapConstIterator GetXmaxErrorsEnd() const
    { return fXmaxError.end(); }
    bool HasXmaxError(const EUncertaintyType type = eTotal) const;

    double GetEnergyCutoff() const { return fEnergyCutoff; }

    std::vector<unsigned short int>& GetStationIds() { return fStationIds; }
    const std::vector<unsigned short int>& GetStationIds() const { return fStationIds; }

    void SetSDTimeResidual(const double time) { fSDTimeResidual = time; }
    double GetSDTimeResidual() const { return fSDTimeResidual; }

    const utl::Vector& GetAxis() const { return fAxis; }

    const utl::Vector& GetAxisError() const { return fAxisError; }

    const utl::Point& GetCorePosition() const { return fCore; }

    const utl::Vector& GetCoreError() const { return fCoreError; }

    const utl::TimeStamp& GetCoreTime() const { return fCoreTime; }
    const utl::TimeInterval& GetCoreTimeError() const { return fCoreTimeError; }

    double GetCorrelationXY() const { return fCorrelationXY; }

    double GetCorrelationThetaPhi() const { return fCorrelationThetaPhi; }

    utl::Point CalculatePointOnShower(const utl::TimeStamp& timeAtTelescope,
                                      const utl::Point& telescopePosition) const;

    void SetCoreTime(const utl::TimeStamp& coreTime,
                     const utl::TimeInterval& coreTimeErr)
    { fCoreTime = coreTime; fCoreTimeError = coreTimeErr; }
    void SetCoreTime(const utl::TimeStamp& eyeTriggerTime,
                     const double rp, const double chi0, const double t0);
    void SetAxis(const utl::Vector& axis) { fAxis = axis; }
    void SetAxisError(const utl::Vector& axis_er) { fAxisError = axis_er; }
    void SetCorePosition(const utl::Point& core) { fCore = core; }
    void SetCoreError(const utl::Vector& core_er) { fCoreError = core_er; }
    void SetCorrelationXY(const double corr) { fCorrelationXY = corr; }
    void SetCorrelationThetaPhi(const double corr) { fCorrelationThetaPhi = corr; }
    
  private:
    ShowerFRecData();
    ~ShowerFRecData() { }

    utl::ShadowPtr<utl::TabulatedFunctionErrors> fEnergyDeposit;
    utl::ShadowPtr<utl::TabulatedFunctionErrors> fLongitudinalProfile;
    utl::ShadowPtr<utl::TabulatedFunctionErrors> fFluorescencePhotons;
    utl::ShadowPtr<utl::TabulatedFunction> fCherenkovPhotons;
    utl::ShadowPtr<evt::VGaisserHillasParameter> fGHParameters;

    double fEmEnergy;
    double fTotalEnergy;
    UncertaintyMap fEmEnergyError;
    UncertaintyMap fTotalEnergyError;
    UncertaintyMap fXmaxError;

    double fEnergyCutoff;

    utl::Vector fAxis;
    utl::Vector fAxisError;
    utl::Point fCore;
    utl::Vector fCoreError;
    double fCorrelationXY;

    utl::TimeStamp fCoreTime;
    utl::TimeInterval fCoreTimeError;

    double fCorrelationThetaPhi;
    double fSDTimeResidual;

    std::vector<unsigned short int> fStationIds;

    evt::MultipleGaisserHillasParameters fMultipleGHParameters;

    friend class evt::ShowerRecData;
    friend class fevt::EyeRecData;
    friend class utl::LameShadowPtr<ShowerFRecData>;

  };

}


#endif