SDetector/Station.h

Go to the documentation of this file.

#ifndef _sdet_Station_h_
#define _sdet_Station_h_

#include <sdet/PMT.h>
#include <sdet/Scintillator.h>
#include <sdet/PMTConstants.h>
#include <sdet/SDetectorConstants.h>
#include <det/VManager.h>
#include <det/Detector.h>
#include <utl/AugerException.h>
#include <utl/CoordinateSystemPtr.h>
#include <utl/ReferenceEllipsoid.h>
#include <utl/Validated.h>
#include <utl/Point.h>
#include <utl/Vector.h>
#include <utl/TimeStamp.h>
#include <utl/TimeRange.h>
#include <utl/TabulatedFunction.h>
#include <utl/ShadowPtr.h>
#include <utl/IteratorRange.h>

#include <boost/iterator/indirect_iterator.hpp>
#include <boost/iterator/transform_iterator.hpp>

#include <vector>
#include <map>
#include <string>
#include <bitset>


namespace sevt {
  class PMT;
}

namespace sdet {

  class PMT;
  class Unlock;


  class Station {

  private:
    typedef std::vector<const PMT*> InternalPMTVector;
    typedef InternalPMTVector::const_iterator InternalPMTIterator;

    struct InternalPartnerStationFunctor {
      const Station& operator()(const int stationId) const;
    };

    /* These constants are to be read from external file ....
       all code that uses them must be changed accordingly */
    static const unsigned int kFirstWaterCherenkovLargePMTId = 1;
    static const unsigned int kLastWaterCherenkovLargePMTId  = 3;
    static const unsigned int kWaterCherenkovSmallPMTId      = 4;
    static const unsigned int kScintillatorPMTId             = 5;

  public:
    static unsigned int GetFirstPMTId() { return kFirstWaterCherenkovLargePMTId; }

    unsigned int GetLastPMTId() const { return fPMTVector.size(); }

    unsigned int GetNPMTs(const PMTConstants::PMTType type = PMTConstants::eAnyType) const;

    template<typename T>
    const std::vector<T>&
    GetMuonPeakHistogramBinning(const PMTConstants::PMTType pmtType, const int calibrationVersion)
      const
    {
      const short int normalBins = 100;
      const short int stridedBins = 50;

      if (!IsUUB()) {  // UB
        static std::vector<T> muonPeakBinningUb;
        return InitializeIfNeeded(muonPeakBinningUb, normalBins, 1, stridedBins, 3);
      }

      if (calibrationVersion < 262) {  // old version of UUB
        static std::vector<T> muonPeakBinningUubOld;
        return InitializeIfNeeded(muonPeakBinningUubOld, normalBins, 4, stridedBins, 4);
      }

      switch (pmtType) {
      case PMTConstants::eWaterCherenkovLarge:
        static std::vector<T> muonPeakBinningUubWcd;
        return InitializeIfNeeded(muonPeakBinningUubWcd, normalBins, 4, stridedBins, 4);
      case PMTConstants::eScintillator:
        static std::vector<T> muonPeakBinningUubSsd;
        return InitializeIfNeeded(muonPeakBinningUubSsd, normalBins, 2, stridedBins, 4);
      default:
        throw utl::DoesNotComputeException("unhandled PMT type");
      }

      static std::vector<T> emptyVector;
      return emptyVector;
    }

    template<typename T>
    const std::vector<T>&
    GetMuonChargeHistogramBinning(const PMTConstants::PMTType pmtType, const int calibrationVersion)
      const
    {
      const short int normalBins = 400;
      const short int stridedBins = 200;

      if (!IsUUB()) {  // UB
        static std::vector<T> muonChargeBinningUb;
        return InitializeIfNeeded(muonChargeBinningUb, normalBins, 1, stridedBins, 3);
      }

      if (calibrationVersion < 262) {  // old version of UUB
        static std::vector<T> muonChargeBinningUubOld;
        return InitializeIfNeeded(muonChargeBinningUubOld, normalBins, 8, stridedBins, 4);
      }

      switch (pmtType) {
      case PMTConstants::eWaterCherenkovLarge:
        static std::vector<T> muonChargeBinningUubWcd;
        return InitializeIfNeeded(muonChargeBinningUubWcd, normalBins, 8, stridedBins, 4);
      case PMTConstants::eScintillator:
        static std::vector<T> muonChargeBinningUubSsd;
        return InitializeIfNeeded(muonChargeBinningUubSsd, normalBins, 2, stridedBins, 4);
      default:
        throw utl::DoesNotComputeException("unhandled PMT type");
      }

      static std::vector<T> emptyVector;
      return emptyVector;
    }

    template<typename T>
    const std::vector<T>&
    GetBaselineHistogramBinning()
      const
    {
      static std::vector<T> baseHisto;
      if (baseHisto.empty()) {
        baseHisto.resize(20 + 1);
        std::iota(baseHisto.begin(), baseHisto.end(), T(0));
      }
      return baseHisto;
    }

    const std::vector<double>&
    GetMuonShapeHistogramBinning(const int calibrationVersion) const;

    const std::string& GetName() const;

    int GetId() const { return fId; }

    /* First implementation of IsUUB, HasSmallPMTData, and HasScintillator
       just returns hardware version, cast as a boolean
       since a hardware version of 0 corresponds to
       a UB and all other values correspond to a UUB. The plan is to
       largely replace the concept of hardware version by updating the
       values returned by IsUUB()/HasScintillator()/HasSmallPMTData() and
       constructing/deconstructing the relevant classes during
       read-in of CDAS events or from information stored in the station
       list for simulations. */
    bool IsUUB() const { return fIsUUB; }

    bool HasSmallPMT() const;

    bool HasScintillator() const { return bool(fScintillator); }

    unsigned int GetFADCTraceLength() const;

    double GetFADCBinSize() const;

    double GetTimingUncertainty() const;

    unsigned int GetSaturationValue() const;

    int GetLatchBin() const;

    const utl::TabulatedFunction& GetElectronicsImpulseResponse() const;

    typedef boost::indirect_iterator<InternalPMTIterator, const PMT&> PMTIterator;

    PMTIterator PMTsBegin() const
    { return PMTIterator(fPMTVector.begin()); }
    PMTIterator PMTsEnd() const
    { return PMTIterator(fPMTVector.end()); }
    OFFLINE_MAKE_CONST_ITERATOR_RANGE(PMTIterator, PMTs)

    
    typedef boost::transform_iterator<InternalPartnerStationFunctor,
                                      std::vector<int>::const_iterator,
                                      const Station&> PartnerIterator;

    PartnerIterator PartnersBegin() const
    { return PartnerIterator(SetPartnerIds().begin()); }
    PartnerIterator PartnersEnd() const
    { return PartnerIterator(SetPartnerIds().end()); }
    OFFLINE_MAKE_CONST_ITERATOR_RANGE(PartnerIterator, Partners)

    
    int GetNumberOfPartners() const;

    const std::vector<int>& GetPartnerIds() const
    { return SetPartnerIds(); }

    int GetGroupId() const;

    const utl::TimeStamp& GetCommissionTime() const
    { return GetCommissionTimeRange().GetStartTime(); }

    const utl::TimeStamp& GetDecommissionTime() const
    { return GetCommissionTimeRange().GetStopTime(); }

    const utl::TimeRange& GetCommissionTimeRange() const;

    const utl::TimeStamp& GetUUBCommissionTime() const;

    typedef std::vector<int> StationIdCollection;
    const StationIdCollection& GetCrown(const int level) const;


    double GetRadius() const;


    double GetHeight() const;

    double GetThickness() const;

    const Scintillator& GetScintillator() const { return *fScintillator; }

    // temporary solution for detector creeping (bug #307) is to *not* to return reference
    utl::Point GetPosition() const;

    utl::CoordinateSystemPtr GetLocalCoordinateSystem() const;

    const utl::TabulatedFunction& GetWaterAbsorptionLength() const;

    const utl::TabulatedFunction& GetWaterRefractionIndex() const;

    const utl::TabulatedFunction& GetLinerReflectivity() const;


    double GetLinerSigmaAlpha() const;

    const utl::TabulatedFunction& GetLinerSpecularLobe() const;

    const utl::TabulatedFunction& GetLinerSpecularSpike() const;

    bool IsInGrid(const SDetectorConstants::GridIndex index = SDetectorConstants::eStandard) const;


    bool IsDense() const { return fDense; }

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

    bool IsHit(const utl::Point& from, const utl::Vector& direction, utl::Point& where) const;

    bool IsHit(const utl::Point& from, const utl::Vector& direction) const
    { utl::Point p; return IsHit(from, direction, p); }

    bool IsInsideStation(const utl::Point& pos) const;

    bool IsInAcquisition() const;

    bool ExistsAssociatedCounter() const;

    int GetAssociatedCounterId() const;

    const PMT& GetPMT(const int id) const;

    const PMT& GetPMT(const sevt::PMT& pmt) const;

    const PMT& GetSmallPMT() const;

    const PMT& GetScintillatorPMT() const;

  private:
    typedef std::map<int, StationIdCollection> InternalCrownCollection;

    Station(const int id);
    ~Station();

    Station(const Station&);
    Station operator=(const Station&);

    void Update() const;

    void UpdateElectronics(const bool isuub) const;

    void MakeScintillator() const;

    void RemoveScintillator() const;

    void MakeSmallPMT() const;

    void RemoveSmallPMT() const;

    const std::vector<int>& SetPartnerIds() const;

    template<typename T>
    det::VManager::Status
    GetStationData(T& requestedData,
                   const std::string& property,
                   const std::string& component,
                   const std::string& errorMsg, const bool throwOnFailure = true)
      const
    {
      const auto& manager = det::Detector::GetInstance().GetSManagerRegister();
      const auto status = manager.GetData(requestedData, property, component, fStationIndexMap);
      if (throwOnFailure && status == det::VManager::eNotFound)
        NotFoundAndThrow(errorMsg);
      return status;
    }

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

    template<typename T>
    static
    const std::vector<T>&
    InitializeIfNeeded(std::vector<T>& histox,
                       const short int normalBins, const short int step,
                       const short int stridedBins, const short int stride)
    {
      if (histox.empty()) {
        histox.reserve(normalBins + stridedBins + 1);
        for (short i = 0; i < normalBins; ++i)
          histox.push_back(step*i);
        for (short i = 0; i <= stridedBins; ++i)
          histox.push_back(step*(normalBins + stride*i));
      }
      return histox;
    }

    static void InitializeShape(std::vector<double>& histox, const int nBins, const double dt);

    //

    int fId = 0;
    mutable bool fIsUUB = false;
    /* Station id and hardware version held also as strings in fStationIndexMap
       with keys "stationId" and "isUUB", respectively. Don't forget to update
       "isUUB" accordingly to changes in fIsUUB. */
    mutable det::VManager::IndexMap fStationIndexMap;
    mutable utl::Validated<unsigned int> fFADCTraceLength;
    mutable utl::Validated<double> fFADCBinSize;
    mutable utl::Validated<double> fTimingUncertainty;
    mutable utl::Validated<int> fLatchBin;
    mutable utl::Validated<unsigned int> fSaturationValue;
    mutable utl::ShadowPtr<utl::TabulatedFunction> fElectronicsImpulseResponse;

    mutable InternalPMTVector fPMTVector;

    mutable utl::Validated<std::vector<int>> fPartnerIds;

    mutable utl::Validated<std::vector<double>> fAxes;

    // Quantities filled by lazy evaluation
    mutable utl::Validated<std::string> fName;
    typedef std::bitset<SDetectorConstants::kGridIndexSize> InGridType;
    mutable utl::Validated<InGridType> fInGrid;
    mutable utl::Validated<double> fRadius;
    mutable utl::Validated<double> fHeight;
    mutable utl::Validated<double> fThickness;

    mutable utl::ShadowPtr<Scintillator> fScintillator;

    mutable InternalCrownCollection fCrowns;

  private:
    // used in UTM conversions
    mutable utl::ReferenceEllipsoid::EllipsoidID fEllipsoid;

    mutable utl::ShadowPtr<utl::TabulatedFunction> fWaterAbsLength;
    mutable utl::ShadowPtr<utl::TabulatedFunction> fWaterRefractionIndex;

    mutable utl::ShadowPtr<utl::TabulatedFunction> fLinerReflectivity;
    mutable utl::Validated<double> fLinerSigmaAlpha;
    mutable utl::ShadowPtr<utl::TabulatedFunction> fLinerSpecularLobe;
    mutable utl::ShadowPtr<utl::TabulatedFunction> fLinerSpecularSpike;

    mutable utl::Validated<int> fIsInAcquisition;

    mutable utl::Validated<int> fGroupId;

    mutable utl::Validated<utl::TimeRange> fCommissionTimeRange;

    mutable utl::Validated<utl::TimeStamp> fUUBCommissionTime;

    bool fDense = false;

  protected:
    mutable utl::CoordinateSystemPtr fReferenceSystem;
    mutable utl::Validated<utl::Point> fPosition;

    friend class SDetector;
    friend class Unlock;

  };

}


#endif