GeometryPar.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Leo Piilonen                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
/* KLM headers. */
#include <klm/bklm/geometry/Module.h>
#include <klm/dbobjects/bklm/BKLMGeometryPar.h>
 
/* CLHEP headers. */
#include <CLHEP/Vector/ThreeVector.h>
 
/* C++ headers. */
#include <map>
#include <vector>
 
namespace Belle2 {
  class GearDir;
  class BkgSensitiveDetector;
 
  namespace bklm {
 
 
    class GeometryPar {
 
    public:
 
      static GeometryPar* instance(void);
 
      static GeometryPar* instance(const GearDir&);
 
      static GeometryPar* instance(const BKLMGeometryPar&);
 
      bool doBeamBackgroundStudy(void) const
      {
        return m_DoBeamBackgroundStudy;
      }
 
      BkgSensitiveDetector* getBkgSensitiveDetector(void) const
      {
        return m_BkgSensitiveDetector;
      }
 
      double getLayerInnerRadius(int layer) const;
 
      double getLayerOuterRadius(int layer) const;
 
      const CLHEP::Hep3Vector getGapHalfSize(int layer, bool hasChimney) const;
 
      const CLHEP::Hep3Vector getModuleHalfSize(int layer, bool hasChimney) const;
 
      const CLHEP::Hep3Vector getModuleInteriorHalfSize1(int layer, bool hasChimney) const;
 
      const CLHEP::Hep3Vector getModuleInteriorHalfSize2(int layer, bool hasChimney) const;
 
      const CLHEP::Hep3Vector getElectrodeHalfSize(int layer, bool hasChimney) const;
 
      const CLHEP::Hep3Vector getGasHalfSize(int layer, bool hasChimney) const;
 
      const CLHEP::Hep3Vector getAirHalfSize(int layer, bool hasChimney) const;
 
      const CLHEP::Hep3Vector getScintEnvelopeHalfSize(int layer, bool hasChimney) const;
 
      const CLHEP::Hep3Vector getScintEnvelopeOffset(int layer, bool hasChimney) const;
 
      int getScintEnvelopeOffsetSign(int layer) const
      {
        return m_ScintEnvelopeOffsetSign[layer - 1];
      }
 
      double getPolystyreneOffsetX(void) const;
 
      double getScintTiO2ThicknessTop(void) const
      {
        return m_ScintTiO2ThicknessTop;
      }
 
      double getScintTiO2ThicknessSide(void) const
      {
        return m_ScintTiO2ThicknessSide;
      }
 
      double getScintHalfHeight(void) const
      {
        return 0.5 * m_ScintHeight;
      }
 
      double getScintHalfWidth(void) const
      {
        return 0.5 * m_ScintWidth;
      }
 
      double getScintBoreRadius(void) const
      {
        return m_ScintBoreRadius;
      }
 
      double getScintFiberRadius(void) const
      {
        return m_ScintFiberRadius;
      }
 
      double getGapMiddleRadius(int layer) const;
 
      double getModuleMiddleRadius(int layer) const;
 
      double getActiveMiddleRadius(int section, int sector, int layer) const;
 
      bool getModuleFlip(int section, int sector, int layer) const
      {
        return m_IsFlipped[section][sector - 1][layer - 1];
      }
 
      double getRotation(void) const
      {
        return m_Rotation;
      }
 
      double getOffsetZ(void) const
      {
        return m_OffsetZ;
      }
 
      double getPhi(void) const
      {
        return m_Phi;
      }
 
      double getSolenoidOuterRadius(void) const
      {
        return m_SolenoidOuterRadius;
      }
 
      int getNSector(void) const
      {
        return m_NSector;
      }
 
      double getHalfLength(void) const
      {
        return m_HalfLength;
      }
 
      double getOuterRadius(void) const
      {
        return m_OuterRadius;
      }
 
      int getNLayer(void) const
      {
        return m_NLayer;
      }
 
      double getIronNominalHeight(void) const
      {
        return m_IronNominalHeight;
      }
 
      double getIronActualHeight(void) const
      {
        return m_IronActualHeight;
      }
 
      double getGap1InnerRadius(void) const
      {
        return m_Gap1InnerRadius;
      }
 
      double getGap1NominalHeight(void) const
      {
        return m_Gap1NominalHeight;
      }
 
      double getGap1ActualHeight(void) const
      {
        return m_Gap1ActualHeight;
      }
 
      double getGap1IronWidth(void) const
      {
        return m_Gap1IronWidth;
      }
 
      double getGapLength(void) const
      {
        return m_GapLength;
      }
 
      double getGapNominalHeight(void) const
      {
        return m_GapNominalHeight;
      }
 
      double getGapActualHeight(void) const
      {
        return m_GapActualHeight;
      }
 
      double getGapIronWidth(void) const
      {
        return m_GapIronWidth;
      }
 
      double getGapInnerRadius(void) const
      {
        return m_GapInnerRadius;
      }
 
      int getNZStrips(bool isChimney) const
      {
        return (isChimney ? m_NZStripsChimney : m_NZStrips);
      }
 
      int getNPhiStrips(int layer) const;
 
      int getNZScints(bool isChimney) const
      {
        return (isChimney ? m_NZScintsChimney : m_NZScints);
      }
 
      int getNPhiScints(int layer) const;
 
      double getModuleLength(void) const
      {
        return m_ModuleLength;
      }
 
      double getModuleLengthChimney(void) const
      {
        return m_ModuleLengthChimney;
      }
 
      double getModuleCoverHeight(void) const
      {
        return m_ModuleCoverHeight;
      }
 
      double getModuleCopperHeight(void) const
      {
        return m_ModuleCopperHeight;
      }
 
      double getModuleFoamHeight(void) const
      {
        return m_ModuleFoamHeight;
      }
 
      double getModuleMylarHeight(void) const
      {
        return m_ModuleMylarHeight;
      }
 
      double getModuleGlassHeight(void) const
      {
        return m_ModuleGlassHeight;
      }
 
      double getModuleGasHeight(void) const
      {
        return m_ModuleGasHeight;
      }
 
      double getModuleHeight(void) const
      {
        return m_ModuleHeight;
      }
 
      double getModuleFrameWidth(void) const
      {
        return m_ModuleFrameWidth;
      }
 
      double getModuleFrameThickness(void) const
      {
        return m_ModuleFrameThickness;
      }
 
      double getModuleGasSpacerWidth(void) const
      {
        return m_ModuleGasSpacerWidth;
      }
 
      double getModuleElectrodeBorder(void) const
      {
        return m_ModuleElectrodeBorder;
      }
 
      const CLHEP::Hep3Vector getChimneyHalfSize(int layer) const;
 
      const CLHEP::Hep3Vector getChimneyPosition(int layer) const;
 
      double getChimneyCoverThickness(void) const
      {
        return m_ChimneyCoverThickness;
      }
 
      double getChimneyHousingInnerRadius(void) const
      {
        return m_ChimneyHousingInnerRadius;
      }
 
      double getChimneyHousingOuterRadius(void) const
      {
        return m_ChimneyHousingOuterRadius;
      }
 
      double getChimneyShieldInnerRadius(void) const
      {
        return m_ChimneyShieldInnerRadius;
      }
 
      double getChimneyShieldOuterRadius(void) const
      {
        return m_ChimneyShieldOuterRadius;
      }
 
      double getChimneyPipeInnerRadius(void) const
      {
        return m_ChimneyPipeInnerRadius;
      }
 
      double getChimneyPipeOuterRadius(void) const
      {
        return m_ChimneyPipeOuterRadius;
      }
 
      double getRibThickness(void) const
      {
        return m_RibThickness;
      }
 
      double getCablesWidth(void) const
      {
        return m_CablesWidth;
      }
 
      double getBraceWidth(void) const
      {
        return m_BraceWidth;
      }
 
      double getBraceWidthChimney(void) const
      {
        return m_BraceWidthChimney;
      }
 
      const CLHEP::Hep3Vector getSupportPlateHalfSize(bool) const;
 
      double getBracketWidth(void) const
      {
        return m_BracketWidth;
      }
 
      double getBracketThickness(void) const
      {
        return m_BracketThickness;
      }
 
      double getBracketLength(void) const
      {
        return m_BracketLength;
      }
 
      double getBracketRibWidth(void) const
      {
        return m_BracketRibWidth;
      }
 
      double getBracketRibThickness(void) const
      {
        return m_BracketRibThickness;
      }
 
      double getBracketInnerRadius(void) const
      {
        return m_BracketInnerRadius;
      }
 
      double getBracketZPosition(int, bool) const;
 
      double getBracketCutoutDphi(void) const
      {
        return m_BracketCutoutDphi;
      }
 
      int getNReadoutStation(void) const
      {
        return m_NReadoutStation;
      }
 
      bool getReadoutStationIsPhi(int station) const
      {
        return m_ReadoutStationIsPhi[station - 1];
      }
 
      double getReadoutStationPosition(int station) const
      {
        return m_ReadoutStationPosition[station - 1];
      }
 
      const CLHEP::Hep3Vector getReadoutContainerHalfSize(void) const;
 
      const CLHEP::Hep3Vector getReadoutCarrierHalfSize(void) const;
 
      const CLHEP::Hep3Vector getReadoutPreamplifierHalfSize(void) const;
 
      int getNReadoutPreamplifierPosition(void) const
      {
        return m_ReadoutPreamplifierPosition.size();
      }
 
      double getReadoutPreamplifierPosition(int preamp) const
      {
        return m_ReadoutPreamplifierPosition[preamp - 1];
      }
 
      const CLHEP::Hep3Vector getReadoutConnectorsHalfSize(void) const;
 
      double getReadoutConnectorsPosition(void) const
      {
        return m_ReadoutConnectorsPosition;
      }
 
      double getMPPCHousingRadius(void) const
      {
        return m_MPPCHousingRadius;
      }
 
      double getMPPCHousingHalfLength(void) const
      {
        return 0.5 * m_MPPCHousingLength;
      }
 
      double getMPPCHalfLength(void) const
      {
        return 0.5 * m_MPPCLength;
      }
 
      double getMPPCHalfWidth(void) const
      {
        return 0.5 * m_MPPCWidth;
      }
 
      double getMPPCHalfHeight(void) const
      {
        return 0.5 * m_MPPCHeight;
      }
 
      bool hasRPCs(int layer) const;
 
      const Module* findModule(int section, int sector, int layer) const;
 
      const HepGeom::Transform3D getModuleAlignment(int section, int sector, int layer) const;
 
      const HepGeom::Transform3D getModuleDisplacedGeo(int section, int sector, int layer) const;
 
    private:
 
      explicit GeometryPar(const GearDir&);
 
      explicit GeometryPar(const Belle2::BKLMGeometryPar&);
 
      GeometryPar(GeometryPar&);
 
      GeometryPar& operator=(const GeometryPar&);
 
      ~GeometryPar();
 
      void clear();
 
      void read(const GearDir&);
 
      void readFromDB(const BKLMGeometryPar&);
 
      void calculate();
 
      void readAlignmentFromDB();
 
      void readDisplacedGeoFromDB();
 
      HepGeom::Transform3D getTransformFromRigidBodyParams(double dU, double dV, double dW, double dAlpha, double dBeta, double dGamma);
 
      bool m_DoBeamBackgroundStudy;
 
      BkgSensitiveDetector* m_BkgSensitiveDetector;
 
      double m_Rotation;
 
      double m_SectorRotation[2][BKLMElementNumbers::getMaximalSectorNumber()];
 
      double m_OffsetZ;
 
      double m_Phi;
 
      int m_NSector;
 
      double m_SolenoidOuterRadius;
 
      double m_OuterRadius;
 
      double m_HalfLength;
 
      int m_NLayer;
 
      double m_IronNominalHeight;
 
      double m_IronActualHeight;
 
      double m_Gap1InnerRadius;
 
      double m_Gap1NominalHeight;
 
      double m_Gap1ActualHeight;
 
      double m_Layer1Height;
 
      double m_LayerHeight;
 
      double m_Gap1IronWidth;
 
      double m_GapLength;
 
      double m_GapNominalHeight;
 
      double m_GapActualHeight;
 
      double m_GapIronWidth;
 
      double m_GapInnerRadius;
 
      int m_NPhiStrips[BKLMElementNumbers::getMaximalLayerNumber()];
 
      int m_NPhiScints[BKLMElementNumbers::getMaximalLayerNumber()];
 
      int m_NZStrips;
 
      int m_NZStripsChimney;
 
      int m_NZScints;
 
      int m_NZScintsChimney;
 
      int m_ScintEnvelopeOffsetSign[BKLMElementNumbers::getMaximalLayerNumber()];
 
      double m_PhiStripWidth[BKLMElementNumbers::getMaximalLayerNumber()];
 
      double m_ZStripWidth[BKLMElementNumbers::getMaximalLayerNumber()];
 
      double m_ZScintDLength[BKLMElementNumbers::getMaximalLayerNumber()][NZSCINT];
 
      double m_ModuleLength;
 
      double m_ModuleLengthChimney;
 
      double m_ModuleCoverHeight;
 
      double m_ModuleCopperHeight;
 
      double m_ModuleFoamHeight;
 
      double m_ModuleMylarHeight;
 
      double m_ModuleReadoutHeight;
 
      double m_ModuleGlassHeight;
 
      double m_ModuleGasHeight;
 
      double m_ModuleHeight;
 
      double m_ModuleFrameWidth;
 
      double m_ModuleFrameThickness;
 
      double m_ModuleGasSpacerWidth;
 
      double m_ModuleElectrodeBorder;
 
      double m_ModulePolystyreneInnerHeight;
 
      double m_ModulePolystyreneOuterHeight;
 
      double m_ScintWidth;
 
      double m_ScintHeight;
 
      double m_ScintBoreRadius;
 
      double m_ScintFiberRadius;
 
      double m_ScintTiO2ThicknessTop;
 
      double m_ScintTiO2ThicknessSide;
 
      double m_ChimneyLength;
 
      double m_ChimneyWidth;
 
      double m_ChimneyCoverThickness;
 
      double m_ChimneyHousingInnerRadius;
 
      double m_ChimneyHousingOuterRadius;
 
      double m_ChimneyShieldInnerRadius;
 
      double m_ChimneyShieldOuterRadius;
 
      double m_ChimneyPipeInnerRadius;
 
      double m_ChimneyPipeOuterRadius;
 
      double m_RibThickness;
 
      double m_CablesWidth;
 
      double m_BraceWidth;
 
      double m_BraceWidthChimney;
 
      double m_SupportPlateWidth;
 
      double m_SupportPlateHeight;
 
      double m_SupportPlateLength;
 
      double m_SupportPlateLengthChimney;
 
      double m_BracketWidth;
 
      double m_BracketThickness;
 
      double m_BracketLength;
 
      double m_BracketRibWidth;
 
      double m_BracketRibThickness;
 
      double m_BracketInset;
 
      double m_BracketInnerRadius;
 
      double m_BracketCutoutDphi;
 
      int m_NReadoutStation;
 
      bool m_ReadoutStationIsPhi[NSTATION];
 
      double m_ReadoutStationPosition[NSTATION];
 
      double m_ReadoutContainerLength;
 
      double m_ReadoutContainerWidth;
 
      double m_ReadoutContainerHeight;
 
      double m_ReadoutCarrierLength;
 
      double m_ReadoutCarrierWidth;
 
      double m_ReadoutCarrierHeight;
 
      double m_ReadoutPreamplifierLength;
 
      double m_ReadoutPreamplifierWidth;
 
      double m_ReadoutPreamplifierHeight;
 
      std::vector<double> m_ReadoutPreamplifierPosition;
 
      double m_ReadoutConnectorsLength;
 
      double m_ReadoutConnectorsWidth;
 
      double m_ReadoutConnectorsHeight;
 
      double m_ReadoutConnectorsPosition;
 
      double m_MPPCHousingRadius;
 
      double m_MPPCHousingLength;
 
      double m_MPPCLength;
 
      double m_MPPCWidth;
 
      double m_MPPCHeight;
 
      bool m_HasRPCs[BKLMElementNumbers::getMaximalLayerNumber()];
 
      double m_LocalReconstructionShiftX[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];
 
      double m_LocalReconstructionShiftY[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];
 
      double m_LocalReconstructionShiftZ[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];
 
      bool m_IsFlipped[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()];
 
      std::map<int, Module*> m_Modules;
 
      std::map<int, HepGeom::Transform3D> m_Alignments;
 
      std::map<int, HepGeom::Transform3D> m_Displacements;
 
      static GeometryPar* m_Instance;
 
    };
 
  } // end of namespace bklm
 
} // end of namespace Belle2