Belle II Software  release-05-02-19
GeometryPar.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2010 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 /* Own header. */
12 #include <klm/bklm/geometry/GeometryPar.h>
13 
14 /* KLM headers. */
15 #include <klm/dataobjects/bklm/BKLMElementNumbers.h>
16 #include <klm/dataobjects/KLMChannelIndex.h>
17 #include <klm/dbobjects/bklm/BKLMAlignment.h>
18 
19 /* Belle 2 headers. */
20 #include <framework/gearbox/GearDir.h>
21 #include <framework/logging/Logger.h>
22 #include <framework/database/DBObjPtr.h>
23 #include <simulation/background/BkgSensitiveDetector.h>
24 
25 using namespace std;
26 using namespace Belle2::bklm;
27 
28 GeometryPar* GeometryPar::m_Instance = nullptr;
29 
30 GeometryPar* GeometryPar::instance(void)
31 {
32  if (m_Instance) return m_Instance;
33  B2FATAL("instance() called without initialization");
34  return nullptr; // never reached
35 }
36 
37 GeometryPar* GeometryPar::instance(const GearDir& content)
38 {
39  if (!m_Instance) m_Instance = new GeometryPar(content);
40  return m_Instance;
41 }
42 
43 GeometryPar* GeometryPar::instance(const BKLMGeometryPar& element)
44 {
45  if (!m_Instance) m_Instance = new GeometryPar(element);
46  return m_Instance;
47 }
48 
49 GeometryPar::GeometryPar(const GearDir& content) :
50  m_DoBeamBackgroundStudy(false),
51  m_BkgSensitiveDetector(nullptr),
52  m_NSector(BKLMElementNumbers::getMaximalSectorNumber()),
53  m_NLayer(BKLMElementNumbers::getMaximalLayerNumber())
54 {
55  clear();
56  read(content);
57  calculate();
58 }
59 
60 GeometryPar::GeometryPar(const BKLMGeometryPar& element) :
61  m_DoBeamBackgroundStudy(false),
62  m_BkgSensitiveDetector(nullptr),
63  m_NSector(BKLMElementNumbers::getMaximalSectorNumber()),
64  m_NLayer(BKLMElementNumbers::getMaximalLayerNumber())
65 {
66  clear();
67  readFromDB(element);
68  calculate();
69 }
70 
71 GeometryPar::~GeometryPar()
72 {
73  clear();
74 }
75 
76 void GeometryPar::clear()
77 {
78  for (std::map<int, Module*>::iterator m = m_Modules.begin(); m != m_Modules.end(); ++m) { delete m->second; }
79  m_Modules.clear();
80 
81  m_Alignments.clear();
82  m_Displacements.clear();
83 }
84 
85 // Get BKLM geometry parameters from Gearbox (no calculations here)
86 void GeometryPar::read(const GearDir& content)
87 {
88 
89  char name[80] = "";
90  m_DoBeamBackgroundStudy = content.getBool("BeamBackgroundStudy");
91  m_Rotation = content.getAngle("Rotation");
92  m_OffsetZ = content.getLength("OffsetZ");
93  m_Phi = content.getLength("Phi");
94  m_NSector = content.getNumberNodes("Sectors/Forward/Sector");
95  if (m_NSector > BKLMElementNumbers::getMaximalSectorNumber()) { // array-bounds check
96  B2FATAL("BKLM GeometryPar::read(): sector array size exceeded:"
97  << LogVar("# of sectors", m_NSector)
98  << LogVar("array size", BKLMElementNumbers::getMaximalSectorNumber()));
99  }
100  m_SolenoidOuterRadius = content.getLength("SolenoidOuterRadius");
101  m_OuterRadius = content.getLength("OuterRadius");
102  m_HalfLength = content.getLength("HalfLength");
103  m_NLayer = content.getNumberNodes("Layers/Layer");
104  if (m_NLayer > BKLMElementNumbers::getMaximalLayerNumber()) { // array-bounds check
105  B2FATAL("BKLM GeometryPar::read(): layer array size exceeded:"
106  << LogVar("# of layers", m_NLayer)
107  << LogVar("array size", BKLMElementNumbers::getMaximalLayerNumber()));
108  }
109 
110  m_IronNominalHeight = content.getLength("Layers/IronNominalHeight");
111  m_IronActualHeight = content.getLength("Layers/IronActualHeight");
112  m_Gap1NominalHeight = content.getLength("Layers/Layer[@layer=\"1\"]/GapNominalHeight");
113  m_GapNominalHeight = content.getLength("Layers/GapNominalHeight");
114  m_Gap1InnerRadius = content.getLength("Layers/InnerRadius");
115  m_Gap1IronWidth = content.getLength("Layers/Layer[@layer=\"1\"]/GapIronWidth");
116  m_GapIronWidth = content.getLength("Layers/GapIronWidth");
117  m_GapLength = content.getLength("Layers/GapLength");
118 
119  m_NZStrips = content.getInt("Layers/NZStrips");
120  m_NZStripsChimney = content.getInt("Layers/NZStripsChimney");
121  m_NZScints = content.getInt("Layers/NZScintillators");
122  m_NZScintsChimney = content.getInt("Layers/NZScintillatorsChimney");
123  if (m_NZScints > NZSCINT) { // array-bounds check
124  B2FATAL("BKLM GeometryPar::read(): z-scint array size exceeded:"
125  << LogVar("# of z scintillators", m_NZScints)
126  << LogVar("array size", NZSCINT));
127  }
128  if (m_NZScintsChimney > NZSCINT) { // array-bounds check
129  B2FATAL("BKLM GeometryPar::read(): chimney sector z-scint array size exceeded:"
130  << LogVar("# of z scintillators", m_NZScintsChimney)
131  << LogVar("array size", NZSCINT));
132  }
133 
134  m_ModuleLength = content.getLength("Module/Length");
135  m_ModuleLengthChimney = content.getLength("Module/LengthChimney");
136  m_ModuleCoverHeight = content.getLength("Module/CoverHeight");
137  m_ModuleCopperHeight = content.getLength("Module/CopperHeight");
138  m_ModuleFoamHeight = content.getLength("Module/FoamHeight");
139  m_ModuleMylarHeight = content.getLength("Module/MylarHeight");
140  m_ModuleGlassHeight = content.getLength("Module/GlassHeight");
141  m_ModuleGasHeight = content.getLength("Module/GasHeight");
142  m_ModuleFrameWidth = content.getLength("Module/FrameWidth");
143  m_ModuleFrameThickness = content.getLength("Module/FrameThickness");
144  m_ModuleGasSpacerWidth = content.getLength("Module/SpacerWidth");
145  m_ModulePolystyreneInnerHeight = content.getLength("Module/PolystyreneInnerHeight");
146  m_ModulePolystyreneOuterHeight = content.getLength("Module/PolystyreneOuterHeight");
147  m_ScintWidth = content.getLength("Module/Scintillator/Width");
148  m_ScintHeight = content.getLength("Module/Scintillator/Height");
149  m_ScintBoreRadius = content.getLength("Module/Scintillator/BoreRadius");
150  m_ScintFiberRadius = content.getLength("Module/Scintillator/FiberRadius");
151  m_ScintTiO2ThicknessTop = content.getLength("Module/Scintillator/TiO2ThicknessTop");
152  m_ScintTiO2ThicknessSide = content.getLength("Module/Scintillator/TiO2ThicknessSide");
153 
154  m_ChimneyLength = content.getLength("Chimney/Length");
155  m_ChimneyWidth = content.getLength("Chimney/Width");
156  m_ChimneyCoverThickness = content.getLength("Chimney/CoverThickness");
157  m_ChimneyHousingInnerRadius = content.getLength("Chimney/HousingInnerRadius");
158  m_ChimneyHousingOuterRadius = content.getLength("Chimney/HousingOuterRadius");
159  m_ChimneyShieldInnerRadius = content.getLength("Chimney/ShieldInnerRadius");
160  m_ChimneyShieldOuterRadius = content.getLength("Chimney/ShieldOuterRadius");
161  m_ChimneyPipeInnerRadius = content.getLength("Chimney/PipeInnerRadius");
162  m_ChimneyPipeOuterRadius = content.getLength("Chimney/PipeOuterRadius");
163 
164  m_RibThickness = content.getLength("RibThickness");
165  m_CablesWidth = content.getLength("CablesWidth");
166  m_BraceWidth = content.getLength("BraceWidth");
167  m_BraceWidthChimney = content.getLength("BraceWidthChimney");
168 
169  m_SupportPlateWidth = content.getLength("SupportPlateWidth");
170  m_SupportPlateHeight = content.getLength("SupportPlateHeight");
171  m_SupportPlateLength = content.getLength("SupportPlateLength");
172  m_SupportPlateLengthChimney = content.getLength("SupportPlateLengthChimney");
173 
174  m_BracketWidth = content.getLength("BracketWidth");
175  m_BracketThickness = content.getLength("BracketThickness");
176  m_BracketLength = content.getLength("BracketLength");
177  m_BracketRibWidth = content.getLength("BracketRibWidth");
178  m_BracketRibThickness = content.getLength("BracketRibThickness");
179  m_BracketInnerRadius = content.getLength("BracketInnerRadius");
180  m_BracketInset = content.getLength("BracketInset");
181  m_BracketCutoutDphi = content.getAngle("BracketCutoutDphi");
182 
183  m_NReadoutStation = content.getNumberNodes("Readout/Stations/Station");
184  if (m_NReadoutStation > NSTATION) { // array-bounds check
185  B2FATAL("BKLM GeometryPar::read(): readout stations array size exceeded:"
186  << LogVar("# of readout stations", m_NReadoutStation)
187  << LogVar("array size", NSTATION));
188  }
189  for (int station = 1; station <= m_NReadoutStation; ++station) {
190  sprintf(name, "/Readout/Stations/Station[@station=\"%d\"]", station);
191  GearDir stationContent = content;
192  stationContent.append(name);
193  m_ReadoutStationIsPhi[station - 1] = stationContent.getBool("IsPhi");
194  m_ReadoutStationPosition[station - 1] = stationContent.getLength("Position");
195  }
196  m_ReadoutContainerLength = content.getLength("Readout/Container/Length");
197  m_ReadoutContainerWidth = content.getLength("Readout/Container/Width");
198  m_ReadoutContainerHeight = content.getLength("Readout/Container/Height");
199  m_ReadoutCarrierLength = content.getLength("Readout/Carrier/Length");
200  m_ReadoutCarrierWidth = content.getLength("Readout/Carrier/Width");
201  m_ReadoutCarrierHeight = content.getLength("Readout/Carrier/Height");
202  m_ReadoutPreamplifierLength = content.getLength("Readout/Preamplifier/Length");
203  m_ReadoutPreamplifierWidth = content.getLength("Readout/Preamplifier/Width");
204  m_ReadoutPreamplifierHeight = content.getLength("Readout/Preamplifier/Height");
205  m_ReadoutPreamplifierPosition = content.getArray("Readout/Preamplifier/Position");
206  m_ReadoutConnectorsLength = content.getLength("Readout/Connectors/Length");
207  m_ReadoutConnectorsWidth = content.getLength("Readout/Connectors/Width");
208  m_ReadoutConnectorsHeight = content.getLength("Readout/Connectors/Height");
209  m_ReadoutConnectorsPosition = content.getLength("Readout/Connectors/Position");
210  m_MPPCHousingRadius = content.getLength("Readout/MPPC/Housing/Radius");
211  m_MPPCHousingLength = content.getLength("Readout/MPPC/Housing/Length");
212  m_MPPCLength = content.getLength("Readout/MPPC/Sensor/Length");
213  m_MPPCWidth = content.getLength("Readout/MPPC/Sensor/Width");
214  m_MPPCHeight = content.getLength("Readout/MPPC/Sensor/Height");
215  // by-layer values that are common for all sectors and forward/backward
216  for (int layer = 1; layer <= m_NLayer; ++layer) {
217  sprintf(name, "/Layers/Layer[@layer=\"%d\"]", layer);
218  GearDir layerContent = content;
219  layerContent.append(name);
220  m_HasRPCs[layer - 1] = layerContent.getBool("HasRPCs");
221  m_NPhiStrips[layer - 1] = layerContent.getInt("PhiStrips/NStrips");
222  m_PhiStripWidth[layer - 1] = layerContent.getLength("PhiStrips/Width");
223  m_ZStripWidth[layer - 1] = layerContent.getLength("ZStrips/Width");
224  m_ScintEnvelopeOffsetSign[layer - 1] = layerContent.getInt("ScintEnvelopeOffsetSign");
225  m_NPhiScints[layer - 1] = layerContent.getInt("PhiScintillators/NScints", 0);
226  if (m_NPhiScints[layer - 1] > NPHISCINT) { // array-bounds check
227  B2FATAL("BKLM GeometryPar::read(): phi-scint array size exceeded:"
228  << LogVar("in zero-based layer", layer - 1)
229  << LogVar("# phi scintillators", m_NPhiScints[layer - 1])
230  << LogVar("array size", NPHISCINT));
231  }
232  for (int scint = 1; scint <= m_NZScints; ++scint) {
233  sprintf(name, "/ZScintillators/Scint[@scint=\"%d\"]", scint);
234  GearDir scintContent(layerContent);
235  scintContent.append(name);
236  m_ZScintDLength[layer - 1][scint - 1] = scintContent.getLength("DLength", 0.0);
237  }
238  }
239  // values that depend on fb/sector/layer
240  for (int section = 0; section <= BKLMElementNumbers::getMaximalSectionNumber(); ++section) {
241  bool isForward = (section == BKLMElementNumbers::c_ForwardSection);
242  for (int sector = 1; sector <= m_NSector; ++sector) {
243  sprintf(name, "/Sectors/%s/Sector[@sector=\"%d\"]", (isForward ? "Forward" : "Backward"), sector);
244  GearDir sectorContent(content);
245  sectorContent.append(name);
246  m_SectorRotation[section][sector - 1] = sectorContent.getAngle("Phi");
247  for (int layer = 1; layer <= m_NLayer; ++layer) {
248  GearDir layerContent(sectorContent);
249  sprintf(name, "/Layer[@layer=\"%d\"]", layer);
250  layerContent.append(name);
251  m_LocalReconstructionShiftX[section][sector - 1][layer - 1] = layerContent.getLength("ReconstructionShift/X");
252  m_LocalReconstructionShiftY[section][sector - 1][layer - 1] = layerContent.getLength("ReconstructionShift/Y");
253  m_LocalReconstructionShiftZ[section][sector - 1][layer - 1] = layerContent.getLength("ReconstructionShift/Z");
254  m_IsFlipped[section][sector - 1][layer - 1] = layerContent.getBool("Flip", false);
255  }
256  }
257  }
258 }
259 
260 // Get BKLM geometry parameters from dbobject (no calculations here)
261 void GeometryPar::readFromDB(const BKLMGeometryPar& element)
262 {
263 
264  m_DoBeamBackgroundStudy = element.doBeamBackgroundStudy();
265  m_Rotation = element.getRotation();
266  m_OffsetZ = element.getOffsetZ();
267  m_Phi = element.getPhi();
268  m_NSector = element.getNSector(); // array-bounds check has already been done
269  m_SolenoidOuterRadius = element.getSolenoidOuterRadius();
270  m_OuterRadius = element.getOuterRadius();
271  m_HalfLength = element.getHalfLength();
272  m_NLayer = element.getNLayer(); // array-bounds check has already been done
273 
274  m_IronNominalHeight = element.getIronNominalHeight();
275  m_IronActualHeight = element.getIronActualHeight();
276  m_Gap1NominalHeight = element.getGap1NominalHeight();
277  m_GapNominalHeight = element.getGapNominalHeight();
278  m_Gap1InnerRadius = element.getGap1InnerRadius();
279  m_Gap1IronWidth = element.getGap1IronWidth();
280  m_GapIronWidth = element.getGapIronWidth();
281  m_GapLength = element.getGapLength();
282 
283  m_NZStrips = element.getNZStrips();
284  m_NZStripsChimney = element.getNZStripsChimney();
285  m_NZScints = element.getNZScints(); // array-bounds check has already been done
286  m_NZScintsChimney = element.getNZScintsChimney(); // array-bounds check has already been done
287 
288  m_ModuleLength = element.getModuleLength();
289  m_ModuleLengthChimney = element.getModuleLengthChimney();
290  m_ModuleCoverHeight = element.getModuleCoverHeight();
291  m_ModuleCopperHeight = element.getModuleCopperHeight();
292  m_ModuleFoamHeight = element.getModuleFoamHeight();
293  m_ModuleMylarHeight = element.getModuleMylarHeight();
294  m_ModuleGlassHeight = element.getModuleGlassHeight();
295  m_ModuleGasHeight = element.getModuleGasHeight();
296  m_ModuleFrameWidth = element.getModuleFrameWidth();
297  m_ModuleFrameThickness = element.getModuleFrameThickness();
298  m_ModuleGasSpacerWidth = element.getModuleGasSpacerWidth();
299  m_ModulePolystyreneInnerHeight = element.getModulePolystyreneInnerHeight();
300  m_ModulePolystyreneOuterHeight = element.getModulePolystyreneOuterHeight();
301  m_ScintWidth = element.getScintWidth();
302  m_ScintHeight = element.getScintHeight();
303  m_ScintBoreRadius = element.getScintBoreRadius();
304  m_ScintFiberRadius = element.getScintFiberRadius();
305  m_ScintTiO2ThicknessTop = element.getScintTiO2ThicknessTop();
306  m_ScintTiO2ThicknessSide = element.getScintTiO2ThicknessSide();
307 
308  m_ChimneyLength = element.getChimneyLength();
309  m_ChimneyWidth = element.getChimneyWidth();
310  m_ChimneyCoverThickness = element.getChimneyCoverThickness();
311  m_ChimneyHousingInnerRadius = element.getChimneyHousingInnerRadius();
312  m_ChimneyHousingOuterRadius = element.getChimneyHousingOuterRadius();
313  m_ChimneyShieldInnerRadius = element.getChimneyShieldInnerRadius();
314  m_ChimneyShieldOuterRadius = element.getChimneyShieldOuterRadius();
315  m_ChimneyPipeInnerRadius = element.getChimneyPipeInnerRadius();
316  m_ChimneyPipeOuterRadius = element.getChimneyPipeOuterRadius();
317 
318  m_RibThickness = element.getRibThickness();
319  m_CablesWidth = element.getCablesWidth();
320  m_BraceWidth = element.getBraceWidth();
321  m_BraceWidthChimney = element.getBraceWidthChimney();
322 
323  m_SupportPlateWidth = element.getSupportPlateWidth();
324  m_SupportPlateHeight = element.getSupportPlateHeight();
325  m_SupportPlateLength = element.getSupportPlateLength();
326  m_SupportPlateLengthChimney = element.getSupportPlateLengthChimney();
327 
328  m_BracketWidth = element.getBracketWidth();
329  m_BracketThickness = element.getBracketThickness();
330  m_BracketLength = element.getBracketLength();
331  m_BracketRibWidth = element.getBracketRibWidth();
332  m_BracketRibThickness = element.getBracketRibThickness();
333  m_BracketInnerRadius = element.getBracketInnerRadius();
334  m_BracketInset = element.getBracketInset();
335  m_BracketCutoutDphi = element.getBracketCutoutDphi();
336 
337  m_NReadoutStation = element.getNReadoutStation(); // array-bounds check has already been done
338  for (int station = 1; station <= m_NReadoutStation; ++station) {
339  m_ReadoutStationIsPhi[station - 1] = element.getReadoutStationIsPhi(station);
340  m_ReadoutStationPosition[station - 1] = element.getReadoutStationPosition(station);
341  }
342  m_ReadoutContainerLength = element.getReadoutContainerLength();
343  m_ReadoutContainerWidth = element.getReadoutContainerWidth();
344  m_ReadoutContainerHeight = element.getReadoutContainerHeight();
345  m_ReadoutCarrierLength = element.getReadoutCarrierLength();
346  m_ReadoutCarrierWidth = element.getReadoutCarrierWidth();
347  m_ReadoutCarrierHeight = element.getReadoutCarrierHeight();
348  m_ReadoutPreamplifierLength = element.getReadoutPreamplifierLength();
349  m_ReadoutPreamplifierWidth = element.getReadoutPreamplifierWidth();
350  m_ReadoutPreamplifierHeight = element.getReadoutPreamplifierHeight();
351  for (int preamp = 1; preamp <= element.getNReadoutPreamplifierPosition(); ++preamp) {
352  m_ReadoutPreamplifierPosition.push_back(element.getReadoutPreamplifierPosition(preamp));
353  }
354  m_ReadoutConnectorsLength = element.getReadoutConnectorsLength();
355  m_ReadoutConnectorsWidth = element.getReadoutConnectorsWidth();
356  m_ReadoutConnectorsHeight = element.getReadoutConnectorsHeight();
357  m_ReadoutConnectorsPosition = element.getReadoutConnectorsPosition();
358  m_MPPCHousingRadius = element.getMPPCHousingRadius();
359  m_MPPCHousingLength = element.getMPPCHousingLength();
360  m_MPPCLength = element.getMPPCLength();
361  m_MPPCWidth = element.getMPPCWidth();
362  m_MPPCHeight = element.getMPPCHeight();
363 
364  // by-layer values that are common for all sectors and forward/backward
365  for (int layer = 1; layer <= m_NLayer; ++layer) {
366  m_HasRPCs[layer - 1] = element.hasRPCs(layer);
367  m_NPhiStrips[layer - 1] = element.getNPhiStrips(layer);
368  m_PhiStripWidth[layer - 1] = element.getPhiStripWidth(layer);
369  m_ZStripWidth[layer - 1] = element.getZStripWidth(layer);
370  m_NPhiScints[layer - 1] = (m_HasRPCs[layer - 1] ? 0 : element.getNPhiScints(layer)); // array-bounds check has already been done
371  m_ScintEnvelopeOffsetSign[layer - 1] = (m_HasRPCs[layer - 1] ? 0 : element.getScintEnvelopeOffsetSign(layer));
372  for (int scint = 1; scint <= m_NZScints; ++scint) {
373  m_ZScintDLength[layer - 1][scint - 1] = (m_HasRPCs[layer - 1] ? 0.0 : element.getZScintDLength(layer, scint));
374  }
375  }
376  // values that depend on fb/sector/layer
377  for (int section = 0; section <= BKLMElementNumbers::getMaximalSectionNumber(); ++section) {
378  for (int sector = 1; sector <= m_NSector; ++sector) {
379  m_SectorRotation[section][sector - 1] = element.getSectorRotation(section, sector);
380  for (int layer = 1; layer <= m_NLayer; ++layer) {
381  m_LocalReconstructionShiftX[section][sector - 1][layer - 1] = element.getLocalReconstructionShiftX(section, sector, layer);
382  m_LocalReconstructionShiftY[section][sector - 1][layer - 1] = element.getLocalReconstructionShiftY(section, sector, layer);
383  m_LocalReconstructionShiftZ[section][sector - 1][layer - 1] = element.getLocalReconstructionShiftZ(section, sector, layer);
384  m_IsFlipped[section][sector - 1][layer - 1] = false;
385  if (layer <= NSCINTLAYER) {
386  m_IsFlipped[section][sector - 1][layer - 1] = element.isFlipped(section, sector, layer);
387  }
388  }
389  }
390  }
391 
392 
393 }
394 
395 // Calculate derived quantities from the database-defined values
396 void GeometryPar::calculate(void)
397 {
398  if (m_DoBeamBackgroundStudy) {
399  B2INFO("BKLM::GeometryPar: DoBeamBackgroundStudy is enabled");
400  m_BkgSensitiveDetector = new BkgSensitiveDetector("BKLM");
401  } else {
402  B2DEBUG(20, "BKLM::GeometryPar: DoBeamBackgroundStudy is disabled");
403  }
404  m_Gap1ActualHeight = m_Gap1NominalHeight + (m_IronNominalHeight - m_IronActualHeight) / 2.0;
405  m_GapActualHeight = m_GapNominalHeight + (m_IronNominalHeight - m_IronActualHeight);
406  m_Layer1Height = m_IronNominalHeight + m_Gap1NominalHeight;
407  m_LayerHeight = m_IronNominalHeight + m_GapNominalHeight;
408  m_GapInnerRadius = m_Gap1InnerRadius + m_Layer1Height - m_LayerHeight;
409  m_ModuleReadoutHeight = m_ModuleFoamHeight + (m_ModuleCopperHeight + m_ModuleMylarHeight) * 2.0;
410  m_ModuleHeight = (m_ModuleCoverHeight + m_ModuleReadoutHeight + m_ModuleGasHeight + m_ModuleGlassHeight * 2.0) * 2.0;
411 
412  // set up displaced geometry
413  readDisplacedGeoFromDB();
414  // set up ReconstructionAlignment, so that those information can pass to Modules
415  readAlignmentFromDB();
416 
417  for (int section = 0; section <= BKLMElementNumbers::getMaximalSectionNumber(); ++section) {
418  bool isForward = (section == BKLMElementNumbers::c_ForwardSection);
419  for (int sector = 1; sector <= m_NSector; ++sector) {
420  bool hasChimney = (!isForward) && (sector == BKLMElementNumbers::c_ChimneySector);
421  int nZStrips = (hasChimney ? m_NZStripsChimney : m_NZStrips);
422  int nZScints = (hasChimney ? m_NZScintsChimney : m_NZScints);
423  CLHEP::HepRotation rotation;
424  if (!isForward) rotation.rotateX(M_PI);
425  rotation.rotateZ(m_SectorRotation[section][sector - 1]);
426  for (int layer = 1; layer <= m_NLayer; ++layer) {
427  bool isFlipped = m_IsFlipped[section][sector - 1][layer - 1];
428  CLHEP::Hep3Vector localReconstructionShift(m_LocalReconstructionShiftX[section][sector - 1][layer - 1],
429  m_LocalReconstructionShiftY[section][sector - 1][layer - 1],
430  m_LocalReconstructionShiftZ[section][sector - 1][layer - 1]);
431  double dx = getActiveMiddleRadius(section, sector, layer);
432  double dz = getModuleHalfSize(layer, hasChimney).z() - getModuleInteriorHalfSize2(layer, hasChimney).z();
433  CLHEP::Hep3Vector localOrigin(dx, 0.0, dz);
434  int moduleID = BKLMElementNumbers::moduleNumber(
435  section, sector, layer);
436  if (m_HasRPCs[layer - 1]) {
437  localOrigin.setZ(localOrigin.z() + getModuleInteriorHalfSize1(layer, hasChimney).z() - getGasHalfSize(layer, hasChimney).z());
438  Module* pModule = new Module(m_PhiStripWidth[layer - 1],
439  (layer == 1 ? 2 : 1),
440  m_NPhiStrips[layer - 1] - (layer == 1 ? 1 : 0),
441  m_ZStripWidth[layer - 1],
442  nZStrips,
443  CLHEP::Hep3Vector(0.0, 0.0, m_OffsetZ) + rotation(localOrigin),
444  localReconstructionShift,
445  rotation
446  );
447  pModule->setDisplacedGeo(getModuleDisplacedGeo(section, sector, layer));
448  pModule->setAlignment(getModuleAlignment(section, sector, layer));
449  m_Modules.insert(std::pair<int, Module*>(moduleID, pModule));
450  } else {
451  double dy = getScintEnvelopeOffset(layer, hasChimney).y() * getScintEnvelopeOffsetSign(layer) * (isFlipped ? -1.0 : 1.0);
452  localOrigin.setY(dy);
453  Module* pModule = new Module(m_ScintWidth,
454  m_NPhiScints[layer - 1],
455  getScintEnvelopeOffsetSign(layer),
456  nZScints,
457  CLHEP::Hep3Vector(0.0, 0.0, m_OffsetZ) + rotation(localOrigin),
458  localReconstructionShift,
459  rotation,
460  isFlipped
461  );
462  pModule->setDisplacedGeo(getModuleDisplacedGeo(section, sector, layer));
463  pModule->setAlignment(getModuleAlignment(section, sector, layer));
464  m_Modules.insert(std::pair<int, Module*>(moduleID, pModule));
465  double base = -0.5 * (m_NPhiScints[layer - 1] + 1) * m_ScintWidth;
466  for (int scint = 1; scint <= m_NPhiScints[layer - 1]; ++scint) {
467  pModule->addPhiScint(scint,
468  nZScints * m_ScintWidth,
469  0.0,
470  base + scint * m_ScintWidth
471  );
472  }
473  base = -0.5 * (nZScints + 1) * m_ScintWidth;
474  for (int scint = 1; scint <= nZScints; ++scint) {
475  int scint0 = m_NZScints - getNZScints(hasChimney);
476  double dLength = m_ZScintDLength[layer - 1][scint0 + scint - 1];
477  pModule->addZScint(scint,
478  m_NPhiScints[layer - 1] * m_ScintWidth + dLength,
479  -0.5 * dLength,
480  base + scint * m_ScintWidth
481  );
482  }
483  }
484  }
485  }
486  }
487 
488 }
489 
490 double GeometryPar::getLayerInnerRadius(int layer) const
491 {
492  if (layer == 1) {
493  return m_Gap1InnerRadius;
494  }
495  if (layer > m_NLayer) {
496  return m_OuterRadius;
497  }
498  return m_GapInnerRadius - (m_IronNominalHeight - m_IronActualHeight) / 2.0 + m_LayerHeight * (layer - 1);
499 }
500 
501 double GeometryPar::getLayerOuterRadius(int layer) const
502 {
503  return getLayerInnerRadius(layer + 1);
504 }
505 
506 const CLHEP::Hep3Vector GeometryPar::getGapHalfSize(int layer, bool hasChimney) const
507 {
508  double r, ds, dx;
509  if (layer == 1) {
510  r = m_Gap1InnerRadius + m_Gap1NominalHeight;
511  ds = m_Gap1IronWidth;
512  dx = 0.5 * m_Gap1ActualHeight;
513  } else {
514  r = m_GapInnerRadius + m_GapNominalHeight + m_LayerHeight * (layer - 1);
515  ds = m_GapIronWidth;
516  dx = 0.5 * m_GapActualHeight;
517  }
518  double dz = 0.5 * (hasChimney ? m_GapLength - m_ChimneyLength : m_GapLength);
519  return CLHEP::Hep3Vector(dx, r * tan(M_PI / m_NSector) - ds, dz);
520 
521 }
522 
523 const CLHEP::Hep3Vector GeometryPar::getModuleHalfSize(int layer, bool hasChimney) const
524 {
525  CLHEP::Hep3Vector size = getGapHalfSize(layer, hasChimney);
526  size.setX(0.5 * m_ModuleHeight);
527  size.setZ(0.5 * (hasChimney ? m_ModuleLengthChimney : m_ModuleLength));
528  return size;
529 }
530 
531 const CLHEP::Hep3Vector GeometryPar::getModuleInteriorHalfSize1(int layer, bool hasChimney) const
532 {
533  CLHEP::Hep3Vector size = getModuleHalfSize(layer, hasChimney);
534  size.setX(size.x() - m_ModuleCoverHeight);
535  size.setY(size.y() - m_ModuleFrameWidth);
536  size.setZ(size.z() - m_ModuleFrameWidth);
537  return size;
538 }
539 
540 const CLHEP::Hep3Vector GeometryPar::getModuleInteriorHalfSize2(int layer, bool hasChimney) const
541 {
542  CLHEP::Hep3Vector size = getModuleHalfSize(layer, hasChimney);
543  size.setX(size.x() - m_ModuleFrameThickness - m_ModuleCoverHeight);
544  size.setY(size.y() - m_ModuleFrameThickness);
545  size.setZ(size.z() - m_ModuleFrameThickness);
546  return size;
547 }
548 
549 const CLHEP::Hep3Vector GeometryPar::getElectrodeHalfSize(int layer, bool hasChimney) const
550 {
551  CLHEP::Hep3Vector size = getModuleInteriorHalfSize1(layer, hasChimney);
552  size.setX(2.0 * m_ModuleGlassHeight + m_ModuleGasHeight);
553  return size;
554 }
555 
556 const CLHEP::Hep3Vector GeometryPar::getGasHalfSize(int layer, bool hasChimney) const
557 {
558  CLHEP::Hep3Vector size = getElectrodeHalfSize(layer, hasChimney);
559  size.setX(0.5 * m_ModuleGasHeight);
560  size.setY(size.y() - m_ModuleGasSpacerWidth);
561  size.setZ(size.z() - m_ModuleGasSpacerWidth);
562  return size;
563 }
564 
565 const CLHEP::Hep3Vector GeometryPar::getAirHalfSize(int layer, bool hasChimney) const
566 {
567  CLHEP::Hep3Vector size = getModuleInteriorHalfSize2(layer, hasChimney);
568  size.setX(m_ScintHeight);
569  return size;
570 }
571 
572 const CLHEP::Hep3Vector GeometryPar::getScintEnvelopeHalfSize(int layer, bool hasChimney) const
573 {
574  return CLHEP::Hep3Vector(0.5 * m_ScintHeight,
575  0.5 * m_ScintWidth * getNPhiScints(layer),
576  0.5 * m_ScintWidth * getNZScints(hasChimney)
577  );
578 }
579 
580 int GeometryPar::getNPhiScints(int layer) const
581 {
582  if ((layer <= 0) || (layer > m_NLayer)) return 0;
583  return m_NPhiScints[layer - 1];
584 }
585 
586 double GeometryPar::getPolystyreneOffsetX(void) const
587 {
588  return 0.5 * (m_ModulePolystyreneInnerHeight - m_ModulePolystyreneOuterHeight);
589 }
590 
591 double GeometryPar::getGapMiddleRadius(int layer) const
592 {
593  if (layer == 1) {
594  return m_Gap1InnerRadius + 0.5 * m_Gap1ActualHeight;
595  }
596  return m_GapInnerRadius + 0.5 * m_GapActualHeight + m_LayerHeight * (layer - 1);
597 }
598 
599 double GeometryPar::getModuleMiddleRadius(int layer) const
600 {
601  if (layer == 1) {
602  return m_Gap1InnerRadius + 0.5 * m_Gap1NominalHeight;
603  }
604  return m_GapInnerRadius + 0.5 * m_GapNominalHeight + m_LayerHeight * (layer - 1);
605 }
606 
607 double GeometryPar::getActiveMiddleRadius(int section, int sector, int layer) const
608 {
609  // place the active radius midway between the two readout planes
610  // (same as positioning in GeoBKLMCreator.cc)
611  double dx = getModuleMiddleRadius(layer) - getGapMiddleRadius(layer);
612  int s1 = sector - 1;
613  int s2 = m_NSector / 2;
614  if (s1 % s2 == 0) {
615  dx = 0.0;
616  } else if (s1 > s2) {
617  dx = -dx;
618  }
619  double r = getGapMiddleRadius(layer) + dx;
620  if (!hasRPCs(layer)) {
621  if (m_IsFlipped[section][sector - 1][layer - 1]) {
622  r -= getPolystyreneOffsetX();
623  } else {
624  r += getPolystyreneOffsetX();
625  }
626  }
627  return r;
628 }
629 
630 const CLHEP::Hep3Vector GeometryPar::getScintEnvelopeOffset(int layer, bool hasChimney) const
631 {
632  CLHEP::Hep3Vector airHalfSize = getAirHalfSize(layer, hasChimney);
633  CLHEP::Hep3Vector envelopeHalfSize = getScintEnvelopeHalfSize(layer, hasChimney);
634  CLHEP::Hep3Vector offset((airHalfSize.x() - envelopeHalfSize.x()),
635  (airHalfSize.y() - envelopeHalfSize.y()),
636  -(airHalfSize.z() - envelopeHalfSize.z()));
637  return offset;
638 }
639 
640 const CLHEP::Hep3Vector GeometryPar::getChimneyHalfSize(int layer) const
641 {
642  return CLHEP::Hep3Vector(0.5 * (getLayerOuterRadius(layer) - getLayerInnerRadius(layer)),
643  0.5 * m_ChimneyWidth,
644  0.5 * (m_ChimneyLength - m_ChimneyCoverThickness));
645 }
646 
647 const CLHEP::Hep3Vector GeometryPar::getChimneyPosition(int layer) const
648 {
649  return CLHEP::Hep3Vector(0.5 * (getLayerOuterRadius(layer) + getLayerInnerRadius(layer)),
650  0.0,
651  0.5 * (m_GapLength - m_ChimneyLength - m_ChimneyCoverThickness));
652 }
653 
654 const CLHEP::Hep3Vector GeometryPar::getSupportPlateHalfSize(bool hasChimney) const
655 {
656  CLHEP::Hep3Vector size;
657  size.setX(0.5 * m_SupportPlateHeight);
658  size.setY(0.5 * m_SupportPlateWidth);
659  if (hasChimney) {
660  size.setZ(0.5 * m_SupportPlateLengthChimney);
661  } else {
662  size.setZ(0.5 * m_SupportPlateLength);
663  }
664  return size;
665 }
666 
667 double GeometryPar::getBracketZPosition(int bracket, bool hasChimney) const
668 {
669  double z = m_BracketInset - 0.5 * m_GapLength;
670  if (bracket == 0) return z;
671  if (hasChimney) {
672  return m_SupportPlateLengthChimney - m_GapLength - z;
673  } else {
674  return (bracket == 1 ? 0.0 : -z);
675  }
676 }
677 
678 const CLHEP::Hep3Vector GeometryPar::getReadoutContainerHalfSize(void) const
679 {
680  return CLHEP::Hep3Vector(0.5 * m_ReadoutContainerWidth,
681  0.5 * m_ReadoutContainerLength,
682  0.5 * m_ReadoutContainerHeight
683  );
684 }
685 
686 const CLHEP::Hep3Vector GeometryPar::getReadoutCarrierHalfSize(void) const
687 {
688  return CLHEP::Hep3Vector(0.5 * m_ReadoutCarrierWidth,
689  0.5 * m_ReadoutCarrierLength,
690  0.5 * m_ReadoutCarrierHeight
691  );
692 }
693 
694 const CLHEP::Hep3Vector GeometryPar::getReadoutPreamplifierHalfSize(void) const
695 {
696  return CLHEP::Hep3Vector(0.5 * m_ReadoutPreamplifierWidth,
697  0.5 * m_ReadoutPreamplifierLength,
698  0.5 * m_ReadoutPreamplifierHeight
699  );
700 }
701 
702 const CLHEP::Hep3Vector GeometryPar::getReadoutConnectorsHalfSize(void) const
703 {
704  return CLHEP::Hep3Vector(0.5 * m_ReadoutConnectorsWidth,
705  0.5 * m_ReadoutConnectorsLength,
706  0.5 * m_ReadoutConnectorsHeight
707  );
708 }
709 
710 bool GeometryPar::hasRPCs(int layer) const
711 {
712  if ((layer <= 0) || (layer > m_NLayer)) return false;
713  return m_HasRPCs[layer - 1];
714 }
715 
716 const Module* GeometryPar::findModule(int section, int sector, int layer) const
717 {
718  int moduleID = BKLMElementNumbers::moduleNumber(section, sector, layer);
719  map<int, Module*>::const_iterator iM = m_Modules.find(moduleID);
720  return (iM == m_Modules.end() ? nullptr : iM->second);
721 }
722 
723 const HepGeom::Transform3D GeometryPar::getModuleAlignment(int section, int sector, int layer) const
724 {
725  int moduleID = BKLMElementNumbers::moduleNumber(section, sector, layer);
726  map<int, HepGeom::Transform3D>::const_iterator iA = m_Alignments.find(moduleID);
727  return (iA == m_Alignments.end() ? HepGeom::Transform3D() : iA->second);
728 }
729 
730 const HepGeom::Transform3D GeometryPar::getModuleDisplacedGeo(int section, int sector, int layer) const
731 {
732  int moduleID = BKLMElementNumbers::moduleNumber(section, sector, layer);
733  map<int, HepGeom::Transform3D>::const_iterator iDis = m_Displacements.find(moduleID);
734  return (iDis == m_Displacements.end() ? HepGeom::Transform3D() : iDis->second);
735 }
736 
737 void GeometryPar::readAlignmentFromDB()
738 {
739  DBObjPtr<BKLMAlignment> bklmAlignment;
740  if (!bklmAlignment.isValid())
741  B2FATAL("No BKLM alignment data.");
742  KLMChannelIndex bklmModules(KLMChannelIndex::c_IndexLevelLayer);
743  for (KLMChannelIndex bklmModule = bklmModules.beginBKLM();
744  bklmModule != bklmModules.endBKLM(); ++bklmModule) {
745  uint16_t module = bklmModule.getKLMModuleNumber();
746  const KLMAlignmentData* alignmentData =
747  bklmAlignment->getModuleAlignment(module);
748  if (alignmentData == nullptr)
749  B2FATAL("Incomplete BKLM alignment data.");
750  HepGeom::Transform3D alignment;
751  alignment = getTransformFromRigidBodyParams(
752  alignmentData->getDeltaU(),
753  alignmentData->getDeltaV(),
754  alignmentData->getDeltaW(),
755  alignmentData->getDeltaAlpha(),
756  alignmentData->getDeltaBeta(),
757  alignmentData->getDeltaGamma());
758  int moduleID = BKLMElementNumbers::moduleNumber(
759  bklmModule.getSection(), bklmModule.getSector(),
760  bklmModule.getLayer());
761  m_Alignments.insert(std::pair<int, HepGeom::Transform3D>(moduleID, alignment));
762  }
763  // Add callback to itself.
764  bklmAlignment.addCallback(this, &bklm::GeometryPar::readAlignmentFromDB);
765 }
766 
767 void GeometryPar::readDisplacedGeoFromDB()
768 {
769  DBObjPtr<BKLMAlignment> bklmDisplacement("BKLMDisplacement");
770  if (!bklmDisplacement.isValid())
771  B2FATAL("No BKLM displaced geometry data in database!");
772  KLMChannelIndex bklmModules(KLMChannelIndex::c_IndexLevelLayer);
773  for (KLMChannelIndex bklmModule = bklmModules.beginBKLM();
774  bklmModule != bklmModules.endBKLM(); ++bklmModule) {
775  uint16_t module = bklmModule.getKLMModuleNumber();
776  const KLMAlignmentData* displacementData =
777  bklmDisplacement->getModuleAlignment(module);
778  if (displacementData == nullptr)
779  B2FATAL("Incomplete BKLM displacement data.");
780  HepGeom::Transform3D displacement;
781  displacement = getTransformFromRigidBodyParams(
782  displacementData->getDeltaU(),
783  displacementData->getDeltaV(),
784  displacementData->getDeltaW(),
785  displacementData->getDeltaAlpha(),
786  displacementData->getDeltaBeta(),
787  displacementData->getDeltaGamma());
788  int moduleID = BKLMElementNumbers::moduleNumber(
789  bklmModule.getSection(), bklmModule.getSector(),
790  bklmModule.getLayer());
791  m_Displacements.insert(std::pair<int, HepGeom::Transform3D>(moduleID, displacement));
792  }
793  // Add callback to itself.
794  bklmDisplacement.addCallback(this, &bklm::GeometryPar::readDisplacedGeoFromDB);
795 }
796 
797 HepGeom::Transform3D GeometryPar::getTransformFromRigidBodyParams(double dU, double dV, double dW, double dAlpha, double dBeta,
798  double dGamma)
799 {
800 
801  CLHEP::HepRotation dy = CLHEP::HepRotationY(-dAlpha);
802  CLHEP::HepRotation dz = CLHEP::HepRotationZ(-dBeta);
803  CLHEP::HepRotation dx = CLHEP::HepRotationX(-dGamma);
804  CLHEP::Hep3Vector shift(dW, dU, dV);
805 
806  //we do dx-->dz-->dy ( local w-->v-->u), because angles are definded as intrinsic rotations u-->v'-->w''
807  //the equivalent one is extrinsic rotation with the order w (gamma)--> v(beta) --> u (alpha)
808  //and then we map it to global rotation x -> z -> y axis
809  return HepGeom::Transform3D(dy * dz * dx, shift);
810 }
Belle2::bklm::GeometryPar::m_NZScintsChimney
int m_NZScintsChimney
number of z-measuring scintillators in a chimney-sector scintillator module
Definition: GeometryPar.h:719
Belle2::bklm::GeometryPar::getGapHalfSize
const CLHEP::Hep3Vector getGapHalfSize(int layer, bool hasChimney) const
Get the size (dx,dy,dz) of the gap [=slot] of specified layer.
Definition: GeometryPar.cc:506
Belle2::bklm::GeometryPar::hasRPCs
bool hasRPCs(int layer) const
Determine if the sensitive detectors in a given layer are RPCs (=true) or scintillators (=false)
Definition: GeometryPar.cc:710
Belle2::bklm::GeometryPar::m_ReadoutCarrierWidth
double m_ReadoutCarrierWidth
Width of the readout carrier card.
Definition: GeometryPar.h:897
Belle2::bklm::GeometryPar::m_ReadoutStationIsPhi
bool m_ReadoutStationIsPhi[NSTATION]
Selector for phi (true) or z (false) readout station.
Definition: GeometryPar.h:879
Belle2::bklm::GeometryPar::m_DoBeamBackgroundStudy
bool m_DoBeamBackgroundStudy
Flag for enabling beam background study (=use bkg sensitive-detector function too)
Definition: GeometryPar.h:632
Belle2::bklm::GeometryPar::m_GapInnerRadius
double m_GapInnerRadius
Radius of the inner tangent circle of virtual gap 0 (assuming equal-height layers)
Definition: GeometryPar.h:701
Belle2::bklm::GeometryPar::m_MPPCHousingLength
double m_MPPCHousingLength
MPPC housing length.
Definition: GeometryPar.h:930
Belle2::bklm::GeometryPar::m_ReadoutConnectorsPosition
double m_ReadoutConnectorsPosition
Position of the readout connectors pair along the length of the carrier card.
Definition: GeometryPar.h:924
Belle2::bklm::GeometryPar::m_ReadoutConnectorsWidth
double m_ReadoutConnectorsWidth
Width of the readout connectors pair.
Definition: GeometryPar.h:918
Belle2::bklm::Module::addZScint
void addZScint(int scint, double length, double offset, double position)
Add one z-measuring scintillator strip to the module.
Definition: Module.cc:241
Belle2::bklm::GeometryPar::m_NZScints
int m_NZScints
number of z-measuring scintillators in a standard scintillator module
Definition: GeometryPar.h:716
Belle2::KLMChannelIndex::endBKLM
KLMChannelIndex & endBKLM()
Last channel for BKLM.
Definition: KLMChannelIndex.cc:195
Belle2::bklm::GeometryPar::m_ScintHeight
double m_ScintHeight
height of one scintillator strip (cm), including the TiO2 coating
Definition: GeometryPar.h:786
Belle2::bklm::GeometryPar::m_OuterRadius
double m_OuterRadius
Radius of the circle tangent to the sides of the outer polygon.
Definition: GeometryPar.h:656
Belle2::bklm::GeometryPar::m_ScintTiO2ThicknessTop
double m_ScintTiO2ThicknessTop
thickness (cm) of the TiO2 coating on the top (and bottom) of the scintillator strip
Definition: GeometryPar.h:795
Belle2::bklm::GeometryPar::m_Gap1IronWidth
double m_Gap1IronWidth
Width (at the outer radius) of the adjacent structural iron on either side of innermost gap.
Definition: GeometryPar.h:686
Belle2::bklm::GeometryPar::clear
void clear()
Clear all geometry parameters.
Definition: GeometryPar.cc:76
Belle2::bklm::GeometryPar::readDisplacedGeoFromDB
void readDisplacedGeoFromDB()
Initialize and Updates displacements parameters from DB for geometry constructor, registers itself fo...
Definition: GeometryPar.cc:767
Belle2::bklm::GeometryPar::getBracketZPosition
double getBracketZPosition(int, bool) const
Get the position of a layer-0 support plate's bracket.
Definition: GeometryPar.cc:667
Belle2::bklm::GeometryPar::m_BracketCutoutDphi
double m_BracketCutoutDphi
angular width of the innermost-module support plate's bracket's cutout
Definition: GeometryPar.h:873
Belle2::bklm::GeometryPar::m_ModulePolystyreneOuterHeight
double m_ModulePolystyreneOuterHeight
height of the outer polystyrene-filler sheet
Definition: GeometryPar.h:780
Belle2::bklm::GeometryPar::getNPhiScints
int getNPhiScints(int layer) const
Get the number of phi-measuring scintillators in a scintillator module.
Definition: GeometryPar.cc:580
Belle2::bklm::GeometryPar::m_SupportPlateLengthChimney
double m_SupportPlateLengthChimney
length of the innermost-module support plate in the chimney sector
Definition: GeometryPar.h:849
Belle2::bklm::GeometryPar::m_ScintTiO2ThicknessSide
double m_ScintTiO2ThicknessSide
thickness (cm) of the TiO2 coating on the left (and right) side of the scintillator strip
Definition: GeometryPar.h:798
Belle2::bklm::GeometryPar::getChimneyPosition
const CLHEP::Hep3Vector getChimneyPosition(int layer) const
Get the position of the chimney hole in the specified layer.
Definition: GeometryPar.cc:647
Belle2::bklm::GeometryPar::m_SolenoidOuterRadius
double m_SolenoidOuterRadius
Outer radius of the solenoid.
Definition: GeometryPar.h:653
Belle2::gearbox::Interface::getAngle
double getAngle(const std::string &path="") const noexcept(false)
Get the parameter path as a double converted to the standard angle unit.
Definition: Interface.h:301
Belle2::bklm::GeometryPar::GeometryPar
GeometryPar(const GearDir &)
Hidden constructor.
Definition: GeometryPar.cc:49
Belle2::bklm::GeometryPar::getReadoutContainerHalfSize
const CLHEP::Hep3Vector getReadoutContainerHalfSize(void) const
Get the size (dx,dy,dz) of the readout container.
Definition: GeometryPar.cc:678
Belle2::bklm::GeometryPar::m_Gap1NominalHeight
double m_Gap1NominalHeight
Nominal height of the innermost gap.
Definition: GeometryPar.h:674
Belle2::KLMChannelIndex::c_IndexLevelLayer
@ c_IndexLevelLayer
Layer.
Definition: KLMChannelIndex.h:52
Belle2::bklm::GeometryPar::m_Modules
std::map< int, Module * > m_Modules
map of <volumeIDs, pointers to defined modules>
Definition: GeometryPar.h:957
Belle2::gearbox::Interface::getInt
int getInt(const std::string &path="") const noexcept(false)
Get the parameter path as a int.
Definition: Interface.cc:70
Belle2::bklm::GeometryPar::m_ModuleFrameThickness
double m_ModuleFrameThickness
thickness of a detector module's frame ("C" shape - thickness of vertical leg)
Definition: GeometryPar.h:768
Belle2::bklm::GeometryPar::getModuleHalfSize
const CLHEP::Hep3Vector getModuleHalfSize(int layer, bool hasChimney) const
Get the size (dx,dy,dz) of the detector module of specified layer.
Definition: GeometryPar.cc:523
Belle2::bklm::GeometryPar::getReadoutPreamplifierHalfSize
const CLHEP::Hep3Vector getReadoutPreamplifierHalfSize(void) const
Get the size (dx,dy,dz) of the preamplifier card.
Definition: GeometryPar.cc:694
Belle2::bklm::GeometryPar::m_BraceWidthChimney
double m_BraceWidthChimney
width of the central brace in the middle of the cable-services channel in the chimney sector
Definition: GeometryPar.h:837
Belle2::bklm::GeometryPar::m_ReadoutConnectorsHeight
double m_ReadoutConnectorsHeight
Height of the readout connectors pair.
Definition: GeometryPar.h:921
Belle2::bklm::GeometryPar::m_ChimneyLength
double m_ChimneyLength
length along z of the chimney hole
Definition: GeometryPar.h:801
Belle2::bklm::GeometryPar::m_ScintFiberRadius
double m_ScintFiberRadius
radius (cm) of the central WLS fiber in the scintillator strip
Definition: GeometryPar.h:792
Belle2::bklm::GeometryPar::m_ModuleReadoutHeight
double m_ModuleReadoutHeight
height of a detector module's readout
Definition: GeometryPar.h:753
Belle2::bklm::GeometryPar::m_SupportPlateLength
double m_SupportPlateLength
length of the innermost-module support plate
Definition: GeometryPar.h:846
Belle2::bklm::GeometryPar::~GeometryPar
~GeometryPar()
Hidden destructor.
Definition: GeometryPar.cc:71
Belle2::bklm::GeometryPar::m_ReadoutCarrierLength
double m_ReadoutCarrierLength
Length of the readout carrier card.
Definition: GeometryPar.h:894
Belle2::KLMAlignmentData::getDeltaV
float getDeltaV() const
Get shift in V.
Definition: KLMAlignmentData.h:104
Belle2::bklm::GeometryPar::m_ModuleFoamHeight
double m_ModuleFoamHeight
height of a detector module's transmission-line foam
Definition: GeometryPar.h:747
Belle2::bklm::GeometryPar::m_Phi
double m_Phi
Starting angle of the polygon shape.
Definition: GeometryPar.h:647
Belle2::bklm::GeometryPar::getChimneyHalfSize
const CLHEP::Hep3Vector getChimneyHalfSize(int layer) const
Get the size of the chimney hole in the specified layer.
Definition: GeometryPar.cc:640
Belle2::bklm::GeometryPar::m_ChimneyShieldInnerRadius
double m_ChimneyShieldInnerRadius
inner radius of the chimney shield
Definition: GeometryPar.h:816
Belle2::bklm::GeometryPar::m_BracketLength
double m_BracketLength
length of the innermost-module support plate's bracket
Definition: GeometryPar.h:858
Belle2::bklm::GeometryPar::m_ReadoutContainerWidth
double m_ReadoutContainerWidth
Width of the readout station's container.
Definition: GeometryPar.h:888
Belle2::bklm::GeometryPar::m_IsFlipped
bool m_IsFlipped[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()]
Flag to indicate whether a module is flipped (true) or not (false) by 180 degrees about the z axis.
Definition: GeometryPar.h:954
Belle2::bklm::Module::addPhiScint
void addPhiScint(int scint, double length, double offset, double position)
Add one phi-measuring scintillator strip to the module.
Definition: Module.cc:229
Belle2::BKLMElementNumbers::c_ForwardSection
@ c_ForwardSection
Forward.
Definition: BKLMElementNumbers.h:47
Belle2::BkgSensitiveDetector
The Class for BeamBackground Sensitive Detector.
Definition: BkgSensitiveDetector.h:34
Belle2::bklm::GeometryPar::m_NReadoutStation
int m_NReadoutStation
Number of preamplifier readout stations.
Definition: GeometryPar.h:876
Belle2::bklm::GeometryPar::m_BracketRibThickness
double m_BracketRibThickness
thickness of the innermost-module support plate's bracket's rib
Definition: GeometryPar.h:864
Belle2::bklm::GeometryPar::m_ChimneyPipeOuterRadius
double m_ChimneyPipeOuterRadius
outer radius of the chimney pipe
Definition: GeometryPar.h:825
Belle2::BKLMElementNumbers::c_ChimneySector
@ c_ChimneySector
Chimney sector: BB3 in 1-based notation; BB2 in 0-based notation.
Definition: BKLMElementNumbers.h:61
Belle2::bklm::GeometryPar::m_ModuleGasHeight
double m_ModuleGasHeight
height of a detector module's gas gap
Definition: GeometryPar.h:759
Belle2::bklm::GeometryPar::m_LayerHeight
double m_LayerHeight
Height of a layer: internal use only.
Definition: GeometryPar.h:683
Belle2::bklm::GeometryPar::m_Gap1InnerRadius
double m_Gap1InnerRadius
Radius of the inner tangent circle of the innermost gap.
Definition: GeometryPar.h:671
Belle2::bklm::GeometryPar::getAirHalfSize
const CLHEP::Hep3Vector getAirHalfSize(int layer, bool hasChimney) const
Get the size (dx,dy,dz) of the scintillator detector module's air filler.
Definition: GeometryPar.cc:565
Belle2::bklm::GeometryPar::m_GapNominalHeight
double m_GapNominalHeight
Nominal height of outer gaps.
Definition: GeometryPar.h:692
Belle2::bklm::GeometryPar::getPolystyreneOffsetX
double getPolystyreneOffsetX(void) const
Get the radial offset of the scintillator detector module's active envelope due to difference in poly...
Definition: GeometryPar.cc:586
Belle2::bklm::Module
Define the geometry of a BKLM module Each sector [octant] contains Modules.
Definition: Module.h:86
Belle2::KLMAlignmentData::getDeltaAlpha
float getDeltaAlpha() const
Get rotation in alpha.
Definition: KLMAlignmentData.h:138
Belle2::BKLMElementNumbers::getMaximalSectorNumber
static constexpr int getMaximalSectorNumber()
Get maximal sector number (1-based).
Definition: BKLMElementNumbers.h:243
Belle2::bklm::GeometryPar
Provides BKLM geometry parameters for simulation, reconstruction etc (from Gearbox or DataBase)
Definition: GeometryPar.h:48
Belle2::KLMChannelIndex::beginBKLM
KLMChannelIndex beginBKLM()
First channel for BKLM.
Definition: KLMChannelIndex.cc:189
Belle2::bklm::GeometryPar::getModuleMiddleRadius
double getModuleMiddleRadius(int layer) const
Get the radial midpoint of the detector module of specified layer.
Definition: GeometryPar.cc:599
Belle2::bklm::GeometryPar::m_GapActualHeight
double m_GapActualHeight
Actual height of outer gaps.
Definition: GeometryPar.h:695
Belle2::bklm::GeometryPar::m_CablesWidth
double m_CablesWidth
width of the cable-services channel at each end
Definition: GeometryPar.h:831
Belle2::bklm::GeometryPar::m_Gap1ActualHeight
double m_Gap1ActualHeight
Actual height of the innermost gap.
Definition: GeometryPar.h:677
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:31
Belle2::bklm::GeometryPar::m_BracketRibWidth
double m_BracketRibWidth
width of the innermost-module support plate's bracket's rib
Definition: GeometryPar.h:861
Belle2::KLMAlignmentData::getDeltaU
float getDeltaU() const
Get shift in U.
Definition: KLMAlignmentData.h:87
Belle2::bklm::GeometryPar::getReadoutCarrierHalfSize
const CLHEP::Hep3Vector getReadoutCarrierHalfSize(void) const
Get the size (dx,dy,dz) of the carrier card.
Definition: GeometryPar.cc:686
Belle2::bklm::GeometryPar::m_ModuleLength
double m_ModuleLength
length along z of the module
Definition: GeometryPar.h:735
Belle2::bklm::GeometryPar::m_ModuleLengthChimney
double m_ModuleLengthChimney
length along z of the module in the chimney sector
Definition: GeometryPar.h:738
Belle2::bklm::GeometryPar::m_RibThickness
double m_RibThickness
thickness of the radial rib that supports the solenoid / inner detectors
Definition: GeometryPar.h:828
Belle2::bklm::GeometryPar::getGapMiddleRadius
double getGapMiddleRadius(int layer) const
Get the radial midpoint of the gap of specified layer.
Definition: GeometryPar.cc:591
Belle2::bklm::GeometryPar::m_ModuleMylarHeight
double m_ModuleMylarHeight
height of a detector module's mylar insulation
Definition: GeometryPar.h:750
Belle2::bklm::GeometryPar::m_GapLength
double m_GapLength
Length along z of each gap.
Definition: GeometryPar.h:689
Belle2::bklm::GeometryPar::getModuleDisplacedGeo
const HepGeom::Transform3D getModuleDisplacedGeo(int section, int sector, int layer) const
Get the displacement transformation of a module.
Definition: GeometryPar.cc:730
Belle2::bklm::GeometryPar::m_ChimneyHousingOuterRadius
double m_ChimneyHousingOuterRadius
outer radius of the chimney housing
Definition: GeometryPar.h:813
Belle2::bklm::GeometryPar::m_MPPCLength
double m_MPPCLength
MPPC length.
Definition: GeometryPar.h:933
Belle2::BKLMElementNumbers::getMaximalLayerNumber
static constexpr int getMaximalLayerNumber()
Get maximal layer number (1-based).
Definition: BKLMElementNumbers.h:251
Belle2::bklm::GeometryPar::getLayerOuterRadius
double getLayerOuterRadius(int layer) const
Get the outer radius of specified layer.
Definition: GeometryPar.cc:501
Belle2::KLMAlignmentData::getDeltaBeta
float getDeltaBeta() const
Get rotation in alpha.
Definition: KLMAlignmentData.h:155
Belle2::bklm::GeometryPar::m_ReadoutPreamplifierWidth
double m_ReadoutPreamplifierWidth
Width of the preamplifier card.
Definition: GeometryPar.h:906
Belle2::bklm::GeometryPar::m_ZStripWidth
double m_ZStripWidth[BKLMElementNumbers::getMaximalLayerNumber()]
Width of the z strips on each layer.
Definition: GeometryPar.h:729
Belle2::bklm::GeometryPar::m_ModuleHeight
double m_ModuleHeight
height of a detector module
Definition: GeometryPar.h:762
Belle2::bklm::GeometryPar::m_HasRPCs
bool m_HasRPCs[BKLMElementNumbers::getMaximalLayerNumber()]
Flag to indicate whether layer contains RPCs (true) or scintillators (false)
Definition: GeometryPar.h:942
Belle2::bklm::GeometryPar::getModuleAlignment
const HepGeom::Transform3D getModuleAlignment(int section, int sector, int layer) const
Get the alignment transformation of a module.
Definition: GeometryPar.cc:723
Belle2::bklm::GeometryPar::m_ReadoutContainerHeight
double m_ReadoutContainerHeight
Height of the readout station's container.
Definition: GeometryPar.h:891
Belle2::bklm::GeometryPar::getElectrodeHalfSize
const CLHEP::Hep3Vector getElectrodeHalfSize(int layer, bool hasChimney) const
Get the size (dx,dy,dz) of the detector module's electrode of specified layer.
Definition: GeometryPar.cc:549
Belle2::bklm::GeometryPar::getTransformFromRigidBodyParams
HepGeom::Transform3D getTransformFromRigidBodyParams(double dU, double dV, double dW, double dAlpha, double dBeta, double dGamma)
Convert 6 rigid body params (alignment/displacement) to corresponding Transform3D Angles in radians,...
Definition: GeometryPar.cc:797
Belle2::bklm::GeometryPar::getSupportPlateHalfSize
const CLHEP::Hep3Vector getSupportPlateHalfSize(bool) const
Get the size of the layer-0 support plate.
Definition: GeometryPar.cc:654
Belle2::GearDir
GearDir is the basic class used for accessing the parameter store.
Definition: GearDir.h:41
Belle2::GearDir::append
void append(const std::string &path)
Append something to the current path, modifying the GearDir in place.
Definition: GearDir.h:62
Belle2::bklm::GeometryPar::m_Displacements
std::map< int, HepGeom::Transform3D > m_Displacements
map of <volumeIDs, displacement Transform3D>
Definition: GeometryPar.h:963
LogVar
Class to store variables with their name which were sent to the logging service.
Definition: LogVariableStream.h:24
Belle2::bklm::GeometryPar::getReadoutConnectorsHalfSize
const CLHEP::Hep3Vector getReadoutConnectorsHalfSize(void) const
Get the size (dx,dy,dz) of the readout connectors pair.
Definition: GeometryPar.cc:702
Belle2::bklm::GeometryPar::m_BracketThickness
double m_BracketThickness
thickness of the innermost-module support plate's bracket
Definition: GeometryPar.h:855
Belle2::bklm::GeometryPar::m_MPPCWidth
double m_MPPCWidth
MPPC width.
Definition: GeometryPar.h:936
Belle2::bklm::GeometryPar::m_ReadoutCarrierHeight
double m_ReadoutCarrierHeight
Height of the readout carrier card.
Definition: GeometryPar.h:900
Belle2::bklm::GeometryPar::m_NZStripsChimney
int m_NZStripsChimney
number of z-measuring cathode strips in a chimney-sector RPC module
Definition: GeometryPar.h:713
Belle2::bklm::GeometryPar::m_ReadoutPreamplifierLength
double m_ReadoutPreamplifierLength
Length of the preamplifier card.
Definition: GeometryPar.h:903
Belle2::BKLMGeometryPar
The Class for BKLM geometry.
Definition: BKLMGeometryPar.h:42
Belle2::bklm::GeometryPar::getScintEnvelopeOffset
const CLHEP::Hep3Vector getScintEnvelopeOffset(int layer, bool hasChimney) const
Get the shift (dx,dy,dz) of the scintillator detector module's scintillator envelope within its enclo...
Definition: GeometryPar.cc:630
Belle2::bklm::GeometryPar::m_ReadoutStationPosition
double m_ReadoutStationPosition[NSTATION]
Position of each readout station along its relevant axis.
Definition: GeometryPar.h:882
Belle2::KLMAlignmentData::getDeltaGamma
float getDeltaGamma() const
Get rotation in alpha.
Definition: KLMAlignmentData.h:172
Belle2::bklm::GeometryPar::m_Alignments
std::map< int, HepGeom::Transform3D > m_Alignments
map of <volumeIDs, alignment Transform3D>
Definition: GeometryPar.h:960
Belle2::bklm::GeometryPar::m_Rotation
double m_Rotation
Global rotation about z of the BKLM.
Definition: GeometryPar.h:638
Belle2::bklm::GeometryPar::m_HalfLength
double m_HalfLength
Half-length along z of the BKLM.
Definition: GeometryPar.h:659
Belle2::bklm::GeometryPar::getScintEnvelopeHalfSize
const CLHEP::Hep3Vector getScintEnvelopeHalfSize(int layer, bool hasChimney) const
Get the size (dx,dy,dz) of the scintillator detector module's scintillator envelope.
Definition: GeometryPar.cc:572
Belle2::bklm::GeometryPar::m_BraceWidth
double m_BraceWidth
width of the central brace in the middle of the cable-services channel
Definition: GeometryPar.h:834
Belle2::bklm::GeometryPar::read
void read(const GearDir &)
Get geometry parameters from Gearbox.
Definition: GeometryPar.cc:86
Belle2::bklm::GeometryPar::m_BkgSensitiveDetector
BkgSensitiveDetector * m_BkgSensitiveDetector
Pointer to object that creates BeamBkgHits for BKLM.
Definition: GeometryPar.h:635
Belle2::bklm::Module::setDisplacedGeo
void setDisplacedGeo(const HepGeom::Transform3D &moduleDisplacedGeo)
Set the displaced geometry Transformation.
Definition: Module.cc:355
Belle2::bklm::GeometryPar::m_MPPCHousingRadius
double m_MPPCHousingRadius
MPPC housing radius.
Definition: GeometryPar.h:927
Belle2::bklm::GeometryPar::m_ChimneyShieldOuterRadius
double m_ChimneyShieldOuterRadius
outer radius of the chimney shield
Definition: GeometryPar.h:819
Belle2::bklm::GeometryPar::m_NPhiStrips
int m_NPhiStrips[BKLMElementNumbers::getMaximalLayerNumber()]
Number of phi-readout RPC strips in each layer.
Definition: GeometryPar.h:704
Belle2::BKLMElementNumbers
BKLM element numbers.
Definition: BKLMElementNumbers.h:34
Belle2::bklm::GeometryPar::m_LocalReconstructionShiftX
double m_LocalReconstructionShiftX[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()]
Reconstruction dx in local system. displacement, not alignment.
Definition: GeometryPar.h:945
Belle2::bklm::GeometryPar::getModuleInteriorHalfSize2
const CLHEP::Hep3Vector getModuleInteriorHalfSize2(int layer, bool hasChimney) const
Get the size (dx,dy,dz) of the scintillator detector module's polystyrene filler.
Definition: GeometryPar.cc:540
Belle2::bklm::GeometryPar::getScintEnvelopeOffsetSign
int getScintEnvelopeOffsetSign(int layer) const
Get the sign (+/-1) of scintillator-envelope's shift along y axis within its enclosing module for MPP...
Definition: GeometryPar.h:108
Belle2::gearbox::Interface::getLength
double getLength(const std::string &path="") const noexcept(false)
Get the parameter path as a double converted to the standard length unit.
Definition: Interface.h:261
Belle2::bklm::GeometryPar::m_BracketInnerRadius
double m_BracketInnerRadius
inner radius of the innermost-module support plate's bracket
Definition: GeometryPar.h:870
Belle2::bklm::GeometryPar::m_NZStrips
int m_NZStrips
number of z-measuring cathode strips in a standard RPC module
Definition: GeometryPar.h:710
Belle2::bklm::GeometryPar::m_ChimneyHousingInnerRadius
double m_ChimneyHousingInnerRadius
inner radius of the chimney housing
Definition: GeometryPar.h:810
Belle2::bklm::GeometryPar::m_LocalReconstructionShiftY
double m_LocalReconstructionShiftY[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()]
Reconstruction dy in local system. displacement, not alignment.
Definition: GeometryPar.h:948
Belle2::DBAccessorBase::isValid
bool isValid() const
Check whether a valid object was obtained from the database.
Definition: DBAccessorBase.h:75
Belle2::KLMChannelIndex
KLM channel index.
Definition: KLMChannelIndex.h:33
Belle2::bklm::GeometryPar::m_ScintBoreRadius
double m_ScintBoreRadius
radius (cm) of the central bore in the scintillator strip
Definition: GeometryPar.h:789
Belle2::BKLMElementNumbers::getMaximalSectionNumber
static constexpr int getMaximalSectionNumber()
Get maximal section number (0-based).
Definition: BKLMElementNumbers.h:235
Belle2::bklm::GeometryPar::readAlignmentFromDB
void readAlignmentFromDB()
Initialize and Updates alignment parameters from DB for reconstruction, that is for Module constructi...
Definition: GeometryPar.cc:737
Belle2::bklm::GeometryPar::readFromDB
void readFromDB(const BKLMGeometryPar &)
Get geometry parameters from Conditions Database.
Definition: GeometryPar.cc:261
Belle2::bklm::GeometryPar::m_SupportPlateWidth
double m_SupportPlateWidth
width of the innermost-module support plate
Definition: GeometryPar.h:840
Belle2::bklm::GeometryPar::m_PhiStripWidth
double m_PhiStripWidth[BKLMElementNumbers::getMaximalLayerNumber()]
Width of the phi strips on each layer.
Definition: GeometryPar.h:726
Belle2::bklm::GeometryPar::m_SupportPlateHeight
double m_SupportPlateHeight
height of the innermost-module support plate
Definition: GeometryPar.h:843
Belle2::bklm::GeometryPar::m_LocalReconstructionShiftZ
double m_LocalReconstructionShiftZ[2][BKLMElementNumbers::getMaximalSectorNumber()][BKLMElementNumbers::getMaximalLayerNumber()]
Reconstruction dz in local system. displacement, not alignment.
Definition: GeometryPar.h:951
Belle2::bklm::GeometryPar::m_ReadoutPreamplifierHeight
double m_ReadoutPreamplifierHeight
Height of the preamplifier card.
Definition: GeometryPar.h:909
Belle2::KLMAlignmentData
KLM Alignment data.
Definition: KLMAlignmentData.h:33
Belle2::bklm::GeometryPar::getModuleInteriorHalfSize1
const CLHEP::Hep3Vector getModuleInteriorHalfSize1(int layer, bool hasChimney) const
Get the size (dx,dy,dz) of the detector module's interior volume 1.
Definition: GeometryPar.cc:531
Belle2::bklm::GeometryPar::m_Layer1Height
double m_Layer1Height
Height of layer 0: internal use only.
Definition: GeometryPar.h:680
Belle2::bklm::GeometryPar::m_ModulePolystyreneInnerHeight
double m_ModulePolystyreneInnerHeight
height of the inner polystyrene-filler sheet
Definition: GeometryPar.h:777
Belle2::bklm::GeometryPar::m_ReadoutConnectorsLength
double m_ReadoutConnectorsLength
Length of the readout connectors pair.
Definition: GeometryPar.h:915
Belle2::bklm::GeometryPar::m_ChimneyWidth
double m_ChimneyWidth
width of the chimney hole
Definition: GeometryPar.h:804
Belle2::bklm::GeometryPar::getNZScints
int getNZScints(bool isChimney) const
Get the number of z-measuring scintillators in a scintillator module.
Definition: GeometryPar.h:291
Belle2::bklm::GeometryPar::m_ChimneyPipeInnerRadius
double m_ChimneyPipeInnerRadius
inner radius of the chimney pipe
Definition: GeometryPar.h:822
Belle2::bklm::GeometryPar::m_ModuleCopperHeight
double m_ModuleCopperHeight
height of a detector module's copper readout or ground plane
Definition: GeometryPar.h:744
Belle2::bklm::GeometryPar::m_ModuleFrameWidth
double m_ModuleFrameWidth
width of a detector module's frame ("C" shape - width of horizontal leg)
Definition: GeometryPar.h:765
Belle2::bklm::GeometryPar::m_OffsetZ
double m_OffsetZ
Global offset along z of the BKLM.
Definition: GeometryPar.h:644
Belle2::bklm::GeometryPar::m_BracketWidth
double m_BracketWidth
width of the innermost-module support plate's bracket
Definition: GeometryPar.h:852
Belle2::bklm::GeometryPar::m_SectorRotation
double m_SectorRotation[2][BKLMElementNumbers::getMaximalSectorNumber()]
Global rotation angle of a sector.
Definition: GeometryPar.h:641
Belle2::bklm::GeometryPar::calculate
void calculate()
Calculate additional geometry parameters.
Definition: GeometryPar.cc:396
Belle2::bklm::GeometryPar::m_ReadoutContainerLength
double m_ReadoutContainerLength
Length of the readout station's container.
Definition: GeometryPar.h:885
Belle2::bklm::GeometryPar::m_NPhiScints
int m_NPhiScints[BKLMElementNumbers::getMaximalLayerNumber()]
Number of phi-readout scintillators in each layer.
Definition: GeometryPar.h:707
Belle2::KLMAlignmentData::getDeltaW
float getDeltaW() const
Get shift in W.
Definition: KLMAlignmentData.h:121
Belle2::bklm::GeometryPar::m_ScintWidth
double m_ScintWidth
width of one scintillator strip (cm), including the TiO2 coating
Definition: GeometryPar.h:783
Belle2::gearbox::Interface::getBool
bool getBool(const std::string &path="") const noexcept(false)
Get the parameter path as a bool.
Definition: Interface.cc:90
Belle2::bklm::GeometryPar::m_BracketInset
double m_BracketInset
distance from support plate's end of bracket
Definition: GeometryPar.h:867
Belle2::bklm::GeometryPar::findModule
const Module * findModule(int section, int sector, int layer) const
Get the pointer to the definition of a module.
Definition: GeometryPar.cc:716
Belle2::bklm::GeometryPar::m_ZScintDLength
double m_ZScintDLength[BKLMElementNumbers::getMaximalLayerNumber()][NZSCINT]
Shortening of the nominal length of the z scintillators.
Definition: GeometryPar.h:732
Belle2::bklm::GeometryPar::m_ScintEnvelopeOffsetSign
int m_ScintEnvelopeOffsetSign[BKLMElementNumbers::getMaximalLayerNumber()]
Sign (+/-1) of scintillator-envelope's shift along y axis within its enclosing module for MPPC placem...
Definition: GeometryPar.h:723
Belle2::bklm::GeometryPar::m_ModuleGlassHeight
double m_ModuleGlassHeight
height of a detector module's glass electrode
Definition: GeometryPar.h:756
Belle2::bklm::GeometryPar::getGasHalfSize
const CLHEP::Hep3Vector getGasHalfSize(int layer, bool hasChimney) const
Get the size (dx,dy,dz) of the detector module's gas gaps of specified layer.
Definition: GeometryPar.cc:556
Belle2::bklm::GeometryPar::m_ChimneyCoverThickness
double m_ChimneyCoverThickness
thickness of the chimney's iron cover plate
Definition: GeometryPar.h:807
Belle2::bklm::GeometryPar::m_NLayer
int m_NLayer
Number of layers in one sector.
Definition: GeometryPar.h:662
Belle2::DBAccessorBase::addCallback
void addCallback(std::function< void(const std::string &)> callback, bool onDestruction=false)
Add a callback method.
Definition: DBAccessorBase.h:108
Belle2::bklm::GeometryPar::m_IronActualHeight
double m_IronActualHeight
Actual height of a layer's stuctural iron.
Definition: GeometryPar.h:668
Belle2::bklm::GeometryPar::m_ModuleGasSpacerWidth
double m_ModuleGasSpacerWidth
width of a detector module's spacer
Definition: GeometryPar.h:771
Belle2::bklm::GeometryPar::getActiveMiddleRadius
double getActiveMiddleRadius(int section, int sector, int layer) const
Get the radial midpoint of the detector module's active volume of specified layer.
Definition: GeometryPar.cc:607
Belle2::bklm::GeometryPar::m_MPPCHeight
double m_MPPCHeight
MPPC height.
Definition: GeometryPar.h:939
Belle2::bklm::Module::setAlignment
void setAlignment(const HepGeom::Transform3D &moduleAlignment)
Set the alignment Transformation.
Definition: Module.cc:346
Belle2::BKLMElementNumbers::moduleNumber
static uint16_t moduleNumber(int section, int sector, int layer, bool fatalError=true)
Get module number.
Definition: BKLMElementNumbers.cc:71
Belle2::bklm::GeometryPar::m_ModuleCoverHeight
double m_ModuleCoverHeight
height of a detector module's aluminum cover
Definition: GeometryPar.h:741
Belle2::bklm::GeometryPar::m_IronNominalHeight
double m_IronNominalHeight
Nominal height of a layer's structural iron.
Definition: GeometryPar.h:665
Belle2::bklm::GeometryPar::m_GapIronWidth
double m_GapIronWidth
Width (at the outer radius) of the adjacent structural iron on either side of a gap.
Definition: GeometryPar.h:698
Belle2::bklm::GeometryPar::m_ReadoutPreamplifierPosition
std::vector< double > m_ReadoutPreamplifierPosition
Positions of the preamplifiers along the length of the carrier card.
Definition: GeometryPar.h:912
Belle2::bklm::GeometryPar::getLayerInnerRadius
double getLayerInnerRadius(int layer) const
Get the inner radius of specified layer.
Definition: GeometryPar.cc:490
Belle2::bklm::GeometryPar::m_NSector
int m_NSector
Number of sectors (=8 : octagonal)
Definition: GeometryPar.h:650