BKLMGeometryPar.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
 
/* KLM headers. */
#include <klm/dataobjects/bklm/BKLMElementNumbers.h>
 
/* ROOT headers. */
#include <TObject.h>
 
/* C++ headers. */
#include <string>
#include <vector>
 
static const int NSCINTLAYER = 2;
static const int NPHISCINT = 48;
static const int NZSCINT = 54;
static const int NSTATION = 7;
static const int BKLM_INNER = 1;
static const int BKLM_OUTER = 2;
 
namespace Belle2 {
  class GearDir;
 
  class BKLMGeometryPar: public TObject {
 
  public:
 
    BKLMGeometryPar()
    {
    }
 
    explicit BKLMGeometryPar(const GearDir&);
 
    ~BKLMGeometryPar();
 
    void read(const GearDir&);
 
    bool doBeamBackgroundStudy(void) const
    {
      return m_DoBeamBackgroundStudy;
    }
 
    void doBeamBackgroundStudy(bool flag)
    {
      m_DoBeamBackgroundStudy = flag;
    }
 
    bool hasRPCs(int layer) const
    {
      return m_HasRPCs[layer - 1];
    }
 
    void hasRPCs(int layer, bool flag)
    {
      m_HasRPCs[layer] = flag;
    }
 
    double getScintTiO2ThicknessTop(void) const
    {
      return m_ScintTiO2ThicknessTop;
    }
 
    void setScintTiO2ThicknessTop(double x)
    {
      m_ScintTiO2ThicknessTop = x;
    }
 
    double getScintTiO2ThicknessSide(void) const
    {
      return m_ScintTiO2ThicknessSide;
    }
 
    void setScintTiO2ThicknessSide(double x)
    {
      m_ScintTiO2ThicknessSide = x;
    }
 
    double getChimneyLength(void) const
    {
      return m_ChimneyLength;
    }
 
    void setChimneyLength(double x)
    {
      m_ChimneyLength = x;
    }
 
    double getChimneyWidth(void) const
    {
      return m_ChimneyWidth;
    }
 
    void setChimneyWidth(double x)
    {
      m_ChimneyWidth = x;
    }
 
    double getScintHeight(void) const
    {
      return  m_ScintHeight;
    }
 
    void setScintHeight(double x)
    {
      m_ScintHeight = x;
    }
 
    double getScintWidth(void) const
    {
      return m_ScintWidth;
    }
 
    void setScintWidth(double x)
    {
      m_ScintWidth = x;
    }
 
    double getScintBoreRadius(void) const
    {
      return m_ScintBoreRadius;
    }
 
    void setScintBoreRadius(double x)
    {
      m_ScintBoreRadius = x;
    }
 
    double getScintFiberRadius(void) const
    {
      return m_ScintFiberRadius;
    }
 
    void setScintFiberRadius(double x)
    {
      m_ScintFiberRadius = x;
    }
 
    double getRotation(void) const
    {
      return m_Rotation;
    }
 
    void setRotation(double x)
    {
      m_Rotation = x;
    }
 
    double getSectorRotation(int section, int sector) const
    {
      return m_SectorRotation[section][sector - 1];
    }
 
    void setSectorRotation(int section, int sector, double x)
    {
      m_SectorRotation[section][sector - 1] = x;
    }
 
    double getOffsetZ(void) const
    {
      return m_OffsetZ;
    }
 
    void setOffsetZ(double x)
    {
      m_OffsetZ = x;
    }
 
    double getPhi(void) const
    {
      return m_Phi;
    }
 
    void setPhi(double x)
    {
      m_Phi = x;
    }
 
    double getSolenoidOuterRadius(void) const
    {
      return m_SolenoidOuterRadius;
    }
 
    void setSolenoidOuterRadius(double x)
    {
      m_SolenoidOuterRadius = x;
    }
 
    int getNSector(void) const
    {
      return m_NSector;
    }
 
    void setNSector(int n)
    {
      m_NSector = n;
    }
 
    double getHalfLength(void) const
    {
      return m_HalfLength;
    }
 
    void setHalfLength(double x)
    {
      m_HalfLength = x;
    }
 
    double getOuterRadius(void) const
    {
      return m_OuterRadius;
    }
 
    void setOuterRadius(double x)
    {
      m_OuterRadius = x;
    }
 
    int getNLayer(void) const
    {
      return m_NLayer;
    }
 
    void setNLayer(double n)
    {
      m_NLayer = n;
    }
 
    double getIronNominalHeight(void) const
    {
      return m_IronNominalHeight;
    }
 
    void setIronNominalHeight(double x)
    {
      m_IronNominalHeight = x;
    }
 
    double getIronActualHeight(void) const
    {
      return m_IronActualHeight;
    }
 
    void setIronActualHeight(double x)
    {
      m_IronActualHeight = x;
    }
 
    double getGap1InnerRadius(void) const
    {
      return m_Gap1InnerRadius;
    }
 
    void setGap1InnerRadius(double x)
    {
      m_Gap1InnerRadius = x;
    }
 
    double getGap1NominalHeight(void) const
    {
      return m_Gap1NominalHeight;
    }
 
    void setGap1NominalHeight(double x)
    {
      m_Gap1NominalHeight = x;
    }
 
    double getGap1IronWidth(void) const
    {
      return m_Gap1IronWidth;
    }
 
    void setGap1IronWidth(double x)
    {
      m_Gap1IronWidth = x;
    }
 
    double getGapLength(void) const
    {
      return m_GapLength;
    }
 
    void setGapLength(double x)
    {
      m_GapLength = x;
    }
 
    double getGapNominalHeight(void) const
    {
      return m_GapNominalHeight;
    }
 
    void setGapNominalHeight(double x)
    {
      m_GapNominalHeight = x;
    }
 
    double getGapIronWidth(void) const
    {
      return m_GapIronWidth;
    }
 
    void setGapIronWidth(double x)
    {
      m_GapIronWidth = x;
    }
 
    int getNZStrips(void) const
    {
      return m_NZStrips;
    }
 
    void setNZStrips(int n)
    {
      m_NZStrips = n;
    }
 
    int getNZStripsChimney(void) const
    {
      return m_NZStripsChimney;
    }
 
    void setNZStripsChimney(int n)
    {
      m_NZStripsChimney = n;
    }
 
    int getNPhiStrips(int layer) const
    {
      return m_NPhiStrips[layer - 1];
    }
 
    void setNPhiStrips(int layer, int n)
    {
      m_NPhiStrips[layer - 1] = n;
    }
 
    int getNZScints(void) const
    {
      return m_NZScints;
    }
 
    void setNZScints(int n)
    {
      m_NZScints = n;
    }
 
    int getNZScintsChimney(void) const
    {
      return m_NZScintsChimney;
    }
 
    void setNZScintsChimney(int n)
    {
      m_NZScintsChimney = n;
    }
 
    int getNPhiScints(int layer) const
    {
      return m_NPhiScints[layer - 1];
    }
 
    void setNPhiScints(int layer, int n)
    {
      m_NPhiScints[layer - 1] = n;
    }
 
    double getScintEnvelopeOffsetSign(int layer) const
    {
      return m_ScintEnvelopeOffsetSign[layer - 1];
    }
 
    void setScintEnvelopeOffsetSign(int layer, int n)
    {
      m_ScintEnvelopeOffsetSign[layer - 1] = n;
    }
 
    double getPhiStripWidth(int layer) const
    {
      return m_PhiStripWidth[layer - 1];
    }
 
    void setPhiStripWidth(int layer, double x)
    {
      m_PhiStripWidth[layer - 1] = x;
    }
 
    double getZStripWidth(int layer) const
    {
      return m_ZStripWidth[layer - 1];
    }
 
    void setZStripWidth(int layer, double x)
    {
      m_ZStripWidth[layer - 1] = x;
    }
 
    double getZScintDLength(int layer, int scint) const
    {
      return m_ZScintDLength[layer - 1][scint - 1];
    }
 
    void setZScintDLength(int layer, int scint, double x)
    {
      m_ZScintDLength[layer - 1][scint - 1] = x;
    }
 
    double getModuleLength(void) const
    {
      return m_ModuleLength;
    }
 
    void setModuleLength(double x)
    {
      m_ModuleLength = x;
    }
 
    double getModuleLengthChimney(void) const
    {
      return m_ModuleLengthChimney;
    }
 
    void setModuleLengthChimney(double x)
    {
      m_ModuleLengthChimney = x;
    }
 
    double getModuleCoverHeight(void) const
    {
      return m_ModuleCoverHeight;
    }
 
    void setModuleCoverHeight(double x)
    {
      m_ModuleCoverHeight = x;
    }
 
    double getModuleCopperHeight(void) const
    {
      return m_ModuleCopperHeight;
    }
 
    void setModuleCopperHeight(double x)
    {
      m_ModuleCopperHeight = x;
    }
 
    double getModuleFoamHeight(void) const
    {
      return m_ModuleFoamHeight;
    }
 
    void setModuleFoamHeight(double x)
    {
      m_ModuleFoamHeight = x;
    }
 
    double getModuleMylarHeight(void) const
    {
      return m_ModuleMylarHeight;
    }
 
    void setModuleMylarHeight(double x)
    {
      m_ModuleMylarHeight = x;
    }
 
    double getModuleGlassHeight(void) const
    {
      return m_ModuleGlassHeight;
    }
 
    void setModuleGlassHeight(double moduleGlassHeight)
    {
      m_ModuleGlassHeight = moduleGlassHeight;
    }
 
    double getModuleGasHeight(void) const
    {
      return m_ModuleGasHeight;
    }
 
    void setModuleGasHeight(double x)
    {
      m_ModuleGasHeight = x;
    }
 
    double getModuleFrameWidth(void) const
    {
      return m_ModuleFrameWidth;
    }
 
    void setModuleFrameWidth(double x)
    {
      m_ModuleFrameWidth = x;
    }
 
    double getModuleFrameThickness(void) const
    {
      return m_ModuleFrameThickness;
    }
 
    void setModuleFrameThickness(double x)
    {
      m_ModuleFrameThickness = x;
    }
 
    double getModuleGasSpacerWidth(void) const
    {
      return m_ModuleGasSpacerWidth;
    }
 
    void setModuleGasSpacerWidth(double x)
    {
      m_ModuleGasSpacerWidth = x;
    }
 
    double getModulePolystyreneInnerHeight(void) const
    {
      return m_ModulePolystyreneInnerHeight;
    }
 
    void setModulePolystyreneInnerHeight(double x)
    {
      m_ModulePolystyreneInnerHeight = x;
    }
 
    double getModulePolystyreneOuterHeight(void) const
    {
      return m_ModulePolystyreneOuterHeight;
    }
 
    void setModulePolystyreneOuterHeight(double x)
    {
      m_ModulePolystyreneOuterHeight = x;
    }
 
    double getChimneyCoverThickness(void) const
    {
      return m_ChimneyCoverThickness;
    }
 
    void setChimneyCoverThickness(double x)
    {
      m_ChimneyCoverThickness = x;
    }
 
    double getChimneyHousingInnerRadius(void) const
    {
      return m_ChimneyHousingInnerRadius;
    }
 
    void setChimneyHousingInnerRadius(double x)
    {
      m_ChimneyHousingInnerRadius = x;
    }
 
    double getChimneyHousingOuterRadius(void) const
    {
      return m_ChimneyHousingOuterRadius;
    }
 
    void setChimneyHousingOuterRadius(double x)
    {
      m_ChimneyHousingOuterRadius = x;
    }
 
    double getChimneyShieldInnerRadius(void) const
    {
      return m_ChimneyShieldInnerRadius;
    }
 
    void setChimneyShieldInnerRadius(double x)
    {
      m_ChimneyShieldInnerRadius = x;
    }
 
    double getChimneyShieldOuterRadius(void) const
    {
      return m_ChimneyShieldOuterRadius;
    }
 
    void setChimneyShieldOuterRadius(double x)
    {
      m_ChimneyShieldOuterRadius = x;
    }
 
    double getChimneyPipeInnerRadius(void) const
    {
      return m_ChimneyPipeInnerRadius;
    }
 
    void setChimneyPipeInnerRadius(double x)
    {
      m_ChimneyPipeInnerRadius = x;
    }
 
    double getChimneyPipeOuterRadius(void) const
    {
      return m_ChimneyPipeOuterRadius;
    }
 
    void setChimneyPipeOuterRadius(double x)
    {
      m_ChimneyPipeOuterRadius = x;
    }
 
    double getRibThickness(void) const
    {
      return m_RibThickness;
    }
 
    void setRibThickness(double x)
    {
      m_RibThickness = x;
    }
 
    double getCablesWidth(void) const
    {
      return m_CablesWidth;
    }
 
    void setCablesWidth(double x)
    {
      m_CablesWidth = x;
    }
 
    double getBraceWidth(void) const
    {
      return m_BraceWidth;
    }
 
    void setBraceWidth(double x)
    {
      m_BraceWidth = x;
    }
 
    double getBraceWidthChimney(void) const
    {
      return m_BraceWidthChimney;
    }
 
    void setBraceWidthChimney(double x)
    {
      m_BraceWidthChimney = x;
    }
 
    double getSupportPlateWidth(void) const
    {
      return m_SupportPlateWidth;
    }
 
    void setSupportPlateWidth(double x)
    {
      m_SupportPlateWidth = x;
    }
 
    double getSupportPlateHeight(void) const
    {
      return m_SupportPlateHeight;
    }
 
    void setSupportPlateHeight(double x)
    {
      m_SupportPlateHeight = x;
    }
 
    double getSupportPlateLength(void) const
    {
      return m_SupportPlateLength;
    }
 
    void setSupportPlateLength(double x)
    {
      m_SupportPlateLength = x;
    }
 
    double getSupportPlateLengthChimney(void) const
    {
      return m_SupportPlateLengthChimney;
    }
 
    void setSupportPlateLengthChimney(double x)
    {
      m_SupportPlateLengthChimney = x;
    }
 
    double getBracketWidth(void) const
    {
      return m_BracketWidth;
    }
 
    void setBracketWidth(double x)
    {
      m_BracketWidth = x;
    }
 
    double getBracketThickness(void) const
    {
      return m_BracketThickness;
    }
 
    void setBracketThickness(double x)
    {
      m_BracketThickness = x;
    }
 
    double getBracketLength(void) const
    {
      return m_BracketLength;
    }
 
    void setBracketLength(double x)
    {
      m_BracketLength = x;
    }
 
    double getBracketRibWidth(void) const
    {
      return m_BracketRibWidth;
    }
 
    void setBracketRibWidth(double x)
    {
      m_BracketRibWidth = x;
    }
 
    double getBracketRibThickness(void) const
    {
      return m_BracketRibThickness;
    }
 
    void setBracketRibThickness(double x)
    {
      m_BracketRibThickness = x;
    }
 
    double getBracketInset(void)const
    {
      return m_BracketInset;
    }
 
    void setBracketInset(double x)
    {
      m_BracketInset = x;
    }
 
    double getBracketInnerRadius(void) const
    {
      return m_BracketInnerRadius;
    }
 
    void setBracketInnerRadius(double x)
    {
      m_BracketInnerRadius = x;
    }
 
    double getBracketCutoutDphi(void) const
    {
      return m_BracketCutoutDphi;
    }
 
    void setBracketCutoutDphi(double x)
    {
      m_BracketCutoutDphi = x;
    }
 
    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];
    }
 
    double getReadoutContainerLength(void) const
    {
      return m_ReadoutContainerLength;
    }
 
    double getReadoutContainerWidth(void) const
    {
      return m_ReadoutContainerWidth;
    }
 
    double getReadoutContainerHeight(void) const
    {
      return m_ReadoutContainerHeight;
    }
 
    double getReadoutCarrierLength(void) const
    {
      return m_ReadoutCarrierLength;
    }
 
    double getReadoutCarrierWidth(void) const
    {
      return m_ReadoutCarrierWidth;
    }
 
    double getReadoutCarrierHeight(void) const
    {
      return m_ReadoutCarrierHeight;
    }
 
    double getReadoutPreamplifierLength(void) const
    {
      return m_ReadoutPreamplifierLength;
    }
 
    double getReadoutPreamplifierWidth(void) const
    {
      return m_ReadoutPreamplifierWidth;
    }
 
    double getReadoutPreamplifierHeight(void) const
    {
      return m_ReadoutPreamplifierHeight;
    }
 
    int getNReadoutPreamplifierPosition(void) const
    {
      return m_ReadoutPreamplifierPosition.size();
    }
 
    double getReadoutPreamplifierPosition(int preamp) const
    {
      return m_ReadoutPreamplifierPosition[preamp - 1];
    }
 
    double getReadoutConnectorsLength(void) const
    {
      return m_ReadoutConnectorsLength;
    }
 
    double getReadoutConnectorsWidth(void) const
    {
      return m_ReadoutConnectorsWidth;
    }
 
    double getReadoutConnectorsHeight(void) const
    {
      return m_ReadoutConnectorsHeight;
    }
 
    double getReadoutConnectorsPosition(void) const
    {
      return m_ReadoutConnectorsPosition;
    }
 
    double getMPPCHousingRadius(void) const
    {
      return m_MPPCHousingRadius;
    }
 
    double getMPPCHousingLength(void) const
    {
      return m_MPPCHousingLength;
    }
 
    double getMPPCLength(void) const
    {
      return m_MPPCLength;
    }
 
    double getMPPCWidth(void) const
    {
      return m_MPPCWidth;
    }
 
    double getMPPCHeight(void) const
    {
      return m_MPPCHeight;
    }
 
    double getLocalReconstructionShiftX(int section, int sector, int layer) const
    {
      return m_LocalReconstructionShiftX[section][sector - 1][layer - 1];
    }
 
    void setLocalReconstructionShiftX(int section, int sector, int layer, double x)
    {
      m_LocalReconstructionShiftX[section][sector - 1][layer - 1] = x;
    }
 
    double getLocalReconstructionShiftY(int section, int sector, int layer) const
    {
      return m_LocalReconstructionShiftY[section][sector - 1][layer - 1];
    }
 
    void setLocalReconstructionShiftY(int section, int sector, int layer, double x)
    {
      m_LocalReconstructionShiftY[section][sector - 1][layer - 1] = x;
    }
 
    double getLocalReconstructionShiftZ(int section, int sector, int layer) const
    {
      return m_LocalReconstructionShiftZ[section][sector - 1][layer - 1];
    }
 
    void setLocalReconstructionShiftZ(int section, int sector, int layer, double x)
    {
      m_LocalReconstructionShiftZ[section][sector - 1][layer - 1] = x;
    }
 
    bool isFlipped(int section, int sector, int layer) const
    {
      return m_IsFlipped[section][sector - 1][layer - 1];
    }
 
    void isFlipped(int section, int sector, int layer, bool flag)
    {
      m_IsFlipped[section][sector - 1][layer - 1] = flag;
    }
 
    std::string getBKLMGeometryParComment() const
    {
      return m_comment;
    }
 
    void setBKLMGeometryParComment(const std::string& s)
    {
      m_comment = s;
    }
 
  private:
 
    bool m_DoBeamBackgroundStudy;
 
    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_Gap1NominalHeight;
 
    double m_GapNominalHeight;
 
    double m_Gap1InnerRadius;
 
    double m_Gap1IronWidth;
 
    double m_GapIronWidth;
 
    double m_GapLength;
 
    int m_NZStrips;
 
    int m_NZStripsChimney;
 
    int m_NZScints;
 
    int m_NZScintsChimney;
 
    bool m_HasRPCs[BKLMElementNumbers::getMaximalLayerNumber()];
 
    int m_NPhiStrips[BKLMElementNumbers::getMaximalLayerNumber()];
 
    double m_PhiStripWidth[BKLMElementNumbers::getMaximalLayerNumber()];
 
    double m_ZStripWidth[BKLMElementNumbers::getMaximalLayerNumber()];
 
    int m_ScintEnvelopeOffsetSign[NSCINTLAYER];
 
    int m_NPhiScints[NSCINTLAYER];
 
    double m_ZScintDLength[NSCINTLAYER][NZSCINT];
 
    double m_ModuleLength;
 
    double m_ModuleLengthChimney;
 
    double m_ModuleCoverHeight;
 
    double m_ModuleCopperHeight;
 
    double m_ModuleFoamHeight;
 
    double m_ModuleMylarHeight;
 
    double m_ModuleGlassHeight;
 
    double m_ModuleGasHeight;
 
    double m_ModuleFrameWidth;
 
    double m_ModuleFrameThickness;
 
    double m_ModuleGasSpacerWidth;
 
    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_BracketInnerRadius;
 
    double m_BracketInset;
 
    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;
 
    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()][NSCINTLAYER];
 
    std::string m_comment;
 
    ClassDef(BKLMGeometryPar, 6);
 
  };
} // end of namespace Belle2