SDetector/PMT.h

Go to the documentation of this file.

#ifndef _sdet_PMT_h_
#define _sdet_PMT_h_

#include <vector>
#include <string>
#include <utl/TabulatedFunction.h>
#include <utl/Point.h>
#include <utl/AugerException.h>
#include <det/VManager.h>
#include <det/Detector.h>
#include <sdet/PMTConstants.h>


namespace sdet {

  class PMT {

  public:
    int GetId() const { return fPMTId; }

    // return PMT type (e.g. eWaterCherenkovLarge)
    sdet::PMTConstants::PMTType GetType() const { return fType; }

    const utl::Point& GetPosition() const;

    double GetWorkingGain() const;

    double GetCollectionEfficiency() const;

    const utl::TabulatedFunction& GetQuantumEfficiency() const;

    const utl::TabulatedFunction& GetFaceRefractionIndex() const;

    const utl::TabulatedFunction& GetRTVRefractionIndex() const;

    const utl::TabulatedFunction& GetDomeRefractionIndex() const;

    const std::vector<double>& GetChargeProbabilityDistribution() const;

    const utl::TabulatedFunction& GetPulseShape() const;

    double GetMinCharge() const;

    double GetMaxCharge() const;

    double GetEffectiveArea() const;

    // --------------------
    // Sim calibration info
    // --------------------


    double GetVEMPeak(const std::string& simulationIdentifier) const;

    double GetCompatibilityVEMPeak(const std::string& simulationIdentifier) const;

    double GetNominalVEMPeak() const;

    double GetVEMCharge(const std::string& simulationIdentifier) const;

    double GetNominalVEMCharge() const;

    double GetBaseline(const sdet::PMTConstants::PMTGain gain) const;

    double GetBaselineRMS(const sdet::PMTConstants::PMTGain gain) const;

    double GetGainRatio() const;

    //* This is not actually used at present, but it's included here to mimic CDAS. *//
    double GetGainRatioRMS() const;

    double GetMultiplier(const sdet::PMTConstants::PMTGain gain) const;

    double GetCurrent2VoltageMultiplier() const;

    double GetVoltage2FADCMultiplier() const;

    double GetHighGainDelay() const;

    double GetTimeOffset() const;


  private:
    PMT(const int PMTId, const int stationId, const int isUUB,
        const PMTConstants::PMTType ptype = PMTConstants::eWaterCherenkovLarge);
    ~PMT();

    PMT(const PMT&);
    PMT& operator=(const PMT&);

    void Update() const;

    int fPMTId = 0;
    int fStationId = 0;
    bool fIsUUB = false;
    const PMTConstants::PMTType fType = PMTConstants::eWaterCherenkovLarge;

    // Static quantities pertaining to the PMT (use lazy evaluation)
    mutable double* fWorkingGain = nullptr;
    mutable double* fCollectionEfficiency = nullptr;
    mutable utl::TabulatedFunction* fQuantumEfficiency = nullptr;
    mutable utl::Point* fPosition = nullptr;
    mutable utl::TabulatedFunction* fFaceRefractionIndex = nullptr;
    mutable utl::TabulatedFunction* fRTVRefractionIndex = nullptr;
    mutable utl::TabulatedFunction* fDomeRefractionIndex = nullptr;
    mutable std::vector<double>* fChargeProbabilityDistribution = nullptr;
    mutable utl::TabulatedFunction* fPulseShape = nullptr;
    mutable double* fMinCharge = nullptr;
    mutable double* fMaxCharge = nullptr;
    mutable double* fEffectiveArea = nullptr;

    mutable double* fVEMPeak = nullptr;
    mutable double* fVEMCharge = nullptr;

    mutable double* fBaselineLG = nullptr;
    mutable double* fBaselineHG = nullptr;
    mutable double* fBaselineLGRMS = nullptr;
    mutable double* fBaselineHGRMS = nullptr;
    mutable double* fGainRatio = nullptr;
    mutable double* fGainRatioRMS = nullptr;
    mutable double* fMultiplierLG = nullptr;
    mutable double* fMultiplierHG = nullptr;
    mutable double* fCurrent2VoltageMultiplier = nullptr;
    mutable double* fVoltage2FADCMultiplier = nullptr;
    mutable double* fHighGainDelay = nullptr;
    mutable double* fTimeOffset = nullptr;

    friend class Station;

    mutable det::VManager::IndexMap fIndexMap;

    // Helper method to do the redundant work of preparing requests for PMT data,
    // sending it to the manager and reporting any errors.
    template<typename T>
    inline
    const T&
    GetPMTData(T*& data,
               const std::string& property,
               const std::string& component,
               const std::string& errorMsg)
      const
    {
      if (!data) {
        data = new T;
        const auto& m = det::Detector::GetInstance().GetSManagerRegister();
        const auto status = m.GetData(*data, property, component, fIndexMap);
        if (status == det::VManager::eNotFound)
          NotFoundAndThrow(errorMsg);
      }
      return *data;
    }

    void NotFoundAndThrow(const std::string& msg) const;

  };

}


#endif