SDetector/PMT.cc

Go to the documentation of this file.

#include <iostream>
#include <sstream>
#include <boost/lexical_cast.hpp>
#include <sdet/Station.h>
#include <sdet/PMT.h>
#include <sdet/SDetector.h>
#include <det/Detector.h>
#include <utl/ErrorLogger.h>
#include <utl/MustFind.h>

using namespace det;
using namespace std;
using namespace utl;


namespace sdet {

  PMT::PMT(const int pid, const int sid,
           const int isUUB,
           const PMTConstants::PMTType ptype) :
    fPMTId(pid),
    fStationId(sid),
    fIsUUB(isUUB),
    fType(ptype),
    fIndexMap({
      { "PMTId", boost::lexical_cast<string>(pid) },
      { "stationId", boost::lexical_cast<string>(sid) },
      { "isUUB", boost::lexical_cast<string>(isUUB) }
    })
  { }


  PMT::~PMT()
  {
    delete fCollectionEfficiency;
    delete fWorkingGain;
    delete fQuantumEfficiency;
    delete fPosition;
    delete fFaceRefractionIndex;
    delete fRTVRefractionIndex;
    delete fDomeRefractionIndex;
    delete fChargeProbabilityDistribution;
    delete fPulseShape;
    delete fMinCharge;
    delete fMaxCharge;
    delete fEffectiveArea;
    delete fVEMPeak;
    delete fVEMCharge;
    delete fBaselineLG;
    delete fBaselineHG;
    delete fBaselineLGRMS;
    delete fBaselineHGRMS;
    delete fGainRatio;
    delete fGainRatioRMS;
    delete fMultiplierLG;
    delete fMultiplierHG;
    delete fCurrent2VoltageMultiplier;
    delete fVoltage2FADCMultiplier;
    delete fHighGainDelay;
    delete fTimeOffset;
  }


  double
  PMT::GetWorkingGain()
    const
  {
    return GetPMTData(fWorkingGain, "workingGain", "PMT", "PMT working gain");
  }


  double
  PMT::GetCollectionEfficiency()
    const
  {
    return GetPMTData(fCollectionEfficiency, "collectionEfficiency", "PMT", "collection efficiency");
  }


  const TabulatedFunction&
  PMT::GetQuantumEfficiency()
    const
  {
    return GetPMTData(fQuantumEfficiency, "quantumEfficiency", "PMT", "quantum efficiency");
  }


  double
  PMT::GetEffectiveArea()
    const
  {
    return GetPMTData(fEffectiveArea, "effectiveArea", "PMT", "effective area");
  }


  const Point&
  PMT::GetPosition()
    const
  {
    if (!fPosition) {
      // Note that the PMT position is a property of the tank (not the PMT).
      // This seems reasonable, because the PMT position is determined by
      // where holes are drilled in the tank.  Also, the detector description
      // currently has one PMT description that applies to all 3 PMT's in a
      // tank, so the position cannot be a PMT property.

      vector<double>* coords = nullptr;
      GetPMTData(coords, "PMTPosition", "tankPMTConfig", "PMT coordinates");

      // Return the PMT position in a coordinate system whose origin is at
      // the intersection of the ground and the central axis of the tank

      const auto& cs = Detector::GetInstance().GetSDetector().GetStation(fStationId).GetLocalCoordinateSystem();
      const auto& xyz = *coords;
      fPosition = new Point(xyz[0], xyz[1], xyz[2], cs);

      delete coords;
    }
    return *fPosition;
  }


  const TabulatedFunction&
  PMT::GetFaceRefractionIndex()
    const
  {
    return GetPMTData(fFaceRefractionIndex, "faceRefractionIndex", "PMT", "index of refraction for PMT face");
  }


  const TabulatedFunction&
  PMT::GetRTVRefractionIndex()
    const
  {
    return GetPMTData(fRTVRefractionIndex, "RTVRefractionIndex", "PMT", "index of refraction for RTV");
  }


  const TabulatedFunction&
  PMT::GetDomeRefractionIndex()
    const
  {
    return GetPMTData(fDomeRefractionIndex, "domeRefractionIndex", "PMT", "index of refraction for PMT dome");
  }


  const vector<double>&
  PMT::GetChargeProbabilityDistribution()
    const
  {
    return GetPMTData(fChargeProbabilityDistribution, "chargeProbabilityDistribution", "PMT",
      "probability distribution for charge at PMT base from SPEs");
  }


  const TabulatedFunction&
  PMT::GetPulseShape()
    const
  {
    return GetPMTData(fPulseShape, "anodePulseShape", "PMT", "pulse shape at PMT base for SPE");
  }


  double
  PMT::GetMinCharge()
    const
  {
    return GetPMTData(fMinCharge, "minCharge", "PMT", "minimum charge at PMT base from SPE");
  }


  double
  PMT::GetMaxCharge()
    const
  {
    return GetPMTData(fMaxCharge, "maxCharge", "PMT", "maximum charge at PMT base from SPE");
  }


  void
  PMT::NotFoundAndThrow(const string& msg)
    const
  {
    ostringstream err;
    err << "Did not find requested component: '" << msg << "', "
           "requested station = " << fIndexMap["stationId"] << ", "
           "requested PMT = " << fIndexMap["PMTId"];
    throw NonExistentComponentException(err.str());
  }


  double
  PMT::GetVEMPeak(const std::string& simId)
    const
  {
    return GetPMTData(fVEMPeak, "peak", simId, "VEM peak for simulated calibration");
  }


  double
  PMT::GetCompatibilityVEMPeak(const std::string& simId)
    const
  {
    return GetPMTData(fVEMPeak, "compatibilityPeak", simId, "VEM peak for simulated UUB calibration");
  }


  double
  PMT::GetNominalVEMPeak()
    const
  {
    switch (fType) {
    case PMTConstants::eWaterCherenkovLarge: return fIsUUB ? 150 : 50;
    case PMTConstants::eScintillator: return fIsUUB ? 25 : 17;
    default: return 0;
    }
  }


  double
  PMT::GetVEMCharge(const std::string& simId)
    const
  {
    return GetPMTData(fVEMCharge, "charge", simId, "VEM charge for simulated calibration");
  }


  double
  PMT::GetNominalVEMCharge()
    const
  {
    switch (fType) {
    case PMTConstants::eWaterCherenkovLarge: return fIsUUB ? 1450 : 130;
    case PMTConstants::eScintillator: return fIsUUB ? 157 : 30;
    default: return 0;
    }
  }


  double
  PMT::GetGainRatio()
    const
  {
    return GetPMTData(fGainRatio, "DA", "pmtElectronics", "D/A for simulations");
  }


  double
  PMT::GetGainRatioRMS()
    const
  {
    return GetPMTData(fGainRatioRMS, "DARMS", "pmtElectronics", "RMS of D/A for simulated calibration");
  }


  double
  PMT::GetMultiplier(const PMTConstants::PMTGain channel)
    const
  {
    if (channel == PMTConstants::eHighGain)
      return GetPMTData(fMultiplierHG, "dynodeMultiplier", "pmtElectronics", "dynode multiplier");
    else if (channel == PMTConstants::eLowGain)
      return GetPMTData(fMultiplierLG, "anodeMultiplier", "pmtElectronics", "anode multiplier");
    return 0;
  }


  double
  PMT::GetCurrent2VoltageMultiplier()
    const
  {
    return GetPMTData(fCurrent2VoltageMultiplier, "current2VoltageMultiplier", "pmtElectronics", "current to voltage multiplier");
  }


  double
  PMT::GetVoltage2FADCMultiplier()
    const
  {
    return GetPMTData(fVoltage2FADCMultiplier, "voltage2FADCMultiplier", "pmtElectronics", "voltage to FADC multiplier");
  }


  double
  PMT::GetHighGainDelay()
    const
  {
    return GetPMTData(fHighGainDelay, "dynode2AnodeDelay", "pmtElectronics", "dynode to anode delay time");
  }


  double
  PMT::GetTimeOffset()
    const
  {
    return GetPMTData(fTimeOffset, "timeOffset", "pmtElectronics", "time offset relative to UB large WCD PMT HG");
  }


  double
  PMT::GetBaseline(const sdet::PMTConstants::PMTGain channel)
    const
  {
    if (channel == PMTConstants::eHighGain)
      return GetPMTData(fBaselineHG, "HGBaseline", "pmtElectronics", "HG baseline for simulated calibration");
    else if (channel == PMTConstants::eLowGain)
      return GetPMTData(fBaselineLG, "LGBaseline", "pmtElectronics", "LG baseline for simulated calibration");
    return 0;
  }


  double
  PMT::GetBaselineRMS(const sdet::PMTConstants::PMTGain channel)
    const
  {
    if (channel == PMTConstants::eHighGain)
      return GetPMTData(fBaselineHGRMS, "HGBaselineRMS", "pmtElectronics", "HG baseline RMS for simulated calibration");
    else if (channel == PMTConstants::eLowGain)
      return GetPMTData(fBaselineLGRMS, "LGBaselineRMS", "pmtElectronics", "LG baseline RMS for simulated calibration");
    return 0;
  }


  void
  PMT::Update()
    const
  {
    // Clearing variables that may change in time
    delete fVEMPeak;
    fVEMPeak = nullptr;

    delete fVEMCharge;
    fVEMCharge = nullptr;
  }

}