TOPGeometryPar.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <top/dbobjects/TOPGeometry.h>
#include <top/geometry/FrontEndMapper.h>
#include <top/geometry/ChannelMapper.h>
#include <framework/database/DBObjPtr.h>
#include <framework/database/DBArray.h>
#include <top/dbobjects/TOPPmtInstallation.h>
#include <top/dbobjects/TOPPmtQE.h>
#include <top/dbobjects/TOPNominalQE.h>
#include <top/dbobjects/TOPCalChannelRQE.h>
#include <top/dbobjects/TOPCalChannelThresholdEff.h>
#include <top/dbobjects/TOPCalChannelPulseHeight.h>
#include <string>
#include <map>
 
namespace Belle2 {
  namespace TOP {

 
    class TOPGeometryPar {
 
    public:

      virtual ~TOPGeometryPar();

      static TOPGeometryPar* Instance();

      void Initialize(const GearDir& content);

      void Initialize();

      bool isValid() const {return m_valid;}

      const TOPGeometry* getGeometry() const;

      const FrontEndMapper& getFrontEndMapper() const {return m_frontEndMapper;}

      const ChannelMapper& getChannelMapper() const {return m_channelMapperIRSX;}

      const ChannelMapper& getChannelMapper(ChannelMapper::EType type) const
      {
        switch (type) {
          case ChannelMapper::c_IRS3B: return m_channelMapperIRS3B;
          case ChannelMapper::c_IRSX:  return m_channelMapperIRSX;
          default: return m_channelMapperIRSX;
        }
      }

      double getPMTEfficiencyEnvelope(double energy) const;

      double getPMTEfficiency(double energy,
                              int moduleID, int pmtID, double x, double y) const;

      double getRelativePixelEfficiency(int moduleID, int pixelID) const;

      double getRelativePDEonMC(int moduleID, int pixelID) const;

      unsigned getPMTType(int moduleID, int pmtID) const;

      const TOPNominalTTS& getTTS(int moduleID, int pmtID) const;

      static double getPhaseIndex(double energy);

      static double getGroupIndex(double energy);

      static double getPhaseIndexDerivative(double energy);

      static double getGroupIndexDerivative(double energy);

      static double getAbsorptionLength(double energy);
 
      static const double c_hc; 
 
    private:

      TOPGeometryPar()
      {}

      TOPGeometryPar(const TOPGeometryPar&) = delete;

      TOPGeometryPar& operator=(const TOPGeometryPar&) = delete;

      void finalizeInitialization();

      static TOPGeometry* createConfiguration(const GearDir& content);

      static TOPGeoBarSegment createBarSegment(const GearDir& content,
                                               const std::string& serialNumber);

      static TOPGeoMirrorSegment createMirrorSegment(const GearDir& content,
                                                     const std::string& serialNumber);

      static TOPGeoPrism createPrism(const GearDir& content,
                                     const std::string& serialNumber);

      static std::string addNumber(const std::string& str, unsigned number);

      void clearCache();

      void setEnvelopeQE() const;

      void mapPmtQEToPositions() const;

      void mapPmtTypeToPositions() const;

      void prepareRelEfficiencies() const;

      void prepareRelPDEonMC() const;

      static int getUniquePmtID(int moduleID, int pmtID)
      {
        return (moduleID << 16) + pmtID;
      }

      static int getUniquePixelID(int moduleID, int pixelID)
      {
        return (moduleID << 16) + pixelID;
      }

      double integralOfQE(const std::vector<float>& qe, double ce,
                          double lambdaFirst, double lambdaStep) const;
 

      static double refractiveIndex(double lambda);
 
      // Geometry
 
      TOPGeometry* m_geo = 0;             
      DBObjPtr<TOPGeometry> m_geoDB;      
      bool m_fromDB = false;              
      bool m_valid = false;               
      bool m_oldPayload = false;          
      bool m_BfieldOn =  true;            
 
      // Mappings
 
      FrontEndMapper m_frontEndMapper; 
      ChannelMapper m_channelMapperIRS3B; 
      ChannelMapper m_channelMapperIRSX;  
 
      // PMT database
 
      OptionalDBArray<TOPPmtInstallation> m_pmtInstalled; 
      OptionalDBArray<TOPPmtQE> m_pmtQEData; 
      DBObjPtr<TOPCalChannelRQE> m_channelRQE; 
      DBObjPtr<TOPCalChannelThresholdEff> m_thresholdEff; 
      DBObjPtr<TOPCalChannelPulseHeight> m_pulseHeights; 
 
      // cache
      mutable TOPNominalQE m_envelopeQE;  
      mutable std::map<int, const TOPPmtQE*> m_pmts; 
      mutable std::map<int, double> m_relEfficiencies; 
      mutable std::map<int, double> m_relPDEonMC; 
      mutable std::map<int, unsigned> m_pmtTypes; 
 
      // Other
 
      static TOPGeometryPar* s_instance;  
 
    };
 
    inline double TOPGeometryPar::getPhaseIndexDerivative(double energy)
    {
      double dE = 0.01; // [eV]
      return (getPhaseIndex(energy + dE / 2) - getPhaseIndex(energy - dE / 2)) / dE;
    }
 
    inline double TOPGeometryPar::getGroupIndexDerivative(double energy)
    {
      double dE = 0.01; // [eV]
      return (getGroupIndex(energy + dE / 2) - getGroupIndex(energy - dE / 2)) / dE;
    }
 
    inline double TOPGeometryPar::getAbsorptionLength(double energy)
    {
      double lambda = c_hc / energy;
      return 15100 * pow(lambda / 405, 4); // Alan Schwartz, 2013 (private communication)
    }
 
  } // end of namespace TOP
} // end of namespace Belle2