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 <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;
 
      unsigned getPMTType(int moduleID, int pmtID) const;
 
      const TOPNominalTTS& getTTS(int moduleID, int pmtID) const;
 
      double getPhaseIndex(double energy) const;
 
      double getGroupIndex(double energy) const;
 
      double getPhaseIndexDerivative(double energy) const;
 
      double getGroupIndexDerivative(double energy) const;
 
      double getAbsorptionLength(double energy) const;
 
      static const double c_hc; 
    private:
 
      TOPGeometryPar()
      {}
 
      void finalizeInitialization();
 
      TOPGeometry* createConfiguration(const GearDir& content);
 
      TOPGeoBarSegment createBarSegment(const GearDir& content,
                                        const std::string& serialNumber);
 
      TOPGeoMirrorSegment createMirrorSegment(const GearDir& content,
                                              const std::string& serialNumber);
 
      TOPGeoPrism createPrism(const GearDir& content,
                              const std::string& serialNumber);
 
      std::string addNumber(const std::string& str, unsigned number);
 
      void clearCache();
 
      void setEnvelopeQE() const;
 
      void mapPmtQEToPositions() const;
 
      void mapPmtTypeToPositions() const;
 
      void prepareRelEfficiencies() const;
 
      int getUniquePmtID(int moduleID, int pmtID) const
      {
        return (moduleID << 16) + pmtID;
      }
 
      int getUniquePixelID(int moduleID, int pixelID) const
      {
        return (moduleID << 16) + pixelID;
      }
 
      double integralOfQE(const std::vector<float>& qe, double ce,
                          double lambdaFirst, double lambdaStep) const;
 
 
      double refractiveIndex(double lambda) const;
 
      // Geometry
 
      TOPGeometry* m_geo = 0;             
      DBObjPtr<TOPGeometry>* m_geoDB = 0; 
      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; 
      // cache
      mutable TOPNominalQE m_envelopeQE;  
      mutable std::map<int, const TOPPmtQE*> m_pmts; 
      mutable std::map<int, double> m_relEfficiencies; 
      mutable std::map<int, unsigned> m_pmtTypes; 
      // Other
 
      static TOPGeometryPar* s_instance;  
    };
 
    inline double TOPGeometryPar::getPhaseIndexDerivative(double energy) const
    {
      double dE = 0.01; // [eV]
      return (getPhaseIndex(energy + dE / 2) - getPhaseIndex(energy - dE / 2)) / dE;
    }
 
    inline double TOPGeometryPar::getGroupIndexDerivative(double energy) const
    {
      double dE = 0.01; // [eV]
      return (getGroupIndex(energy + dE / 2) - getGroupIndex(energy - dE / 2)) / dE;
    }
 
    inline double TOPGeometryPar::getAbsorptionLength(double energy) const
    {
      double lambda = c_hc / energy;
      return 15100 * pow(lambda / 405, 4); // Alan Schwartz, 2013 (private comunication)
    }
 
  } // end of namespace TOP
} // end of namespace Belle2