Belle II Software  release-05-01-25
Module.cc
1 /*************************************************************************
2 * BASF2 (Belle Analysis Framework 2) *
3 * Copyright(C) 2010 - Belle II Collaboration *
4 * *
5 * Author: The Belle II Collaboration *
6 * Contributors: Leo Piilonen *
7 * *
8 * This software is provided "as is" without any warranty. *
9 *************************************************************************/
10 
11 /* Own header. */
12 #include <klm/bklm/geometry/Module.h>
13 
14 /* Belle 2 headers. */
15 #include <framework/gearbox/Const.h>
16 
17 /* C++ headers. */
18 #include <iostream>
19 
20 using namespace std;
21 using namespace Belle2::bklm;
22 
23 Module::Module() :
24  m_HasRPCs(false),
25  m_IsFlipped(false),
26  m_PhiStripWidth(0.0),
27  m_PhiStripMin(0),
28  m_PhiStripMax(0),
29  m_PhiPositionBase(0.0),
30  m_ZStripWidth(0.0),
31  m_ZStripMin(0),
32  m_ZStripMax(0),
33  m_ZPositionBase(0.0),
34  m_PhiSensorSide(0),
35  m_SignalSpeed(0.0),
36  m_GlobalOrigin(CLHEP::Hep3Vector()),
37  m_LocalReconstructionShift(CLHEP::Hep3Vector()),
38  m_Rotation(CLHEP::HepRotation()),
39  m_Alignment(HepGeom::Transform3D()),
40  m_AlignmentRotation(CLHEP::HepRotation()),
41  m_AlignmentTranslation(CLHEP::Hep3Vector()),
42  m_AlignmentInverse(HepGeom::Transform3D()),
43  m_AlignmentRotationInverse(CLHEP::HepRotation()),
44  m_DisplacedGeo(HepGeom::Transform3D()),
45  m_DisplacedGeoRotation(CLHEP::HepRotation()),
46  m_DisplacedGeoTranslation(CLHEP::Hep3Vector()),
47  m_DisplacedGeoInverse(HepGeom::Transform3D()),
48  m_DisplacedGeoRotationInverse(CLHEP::HepRotation())
49 {
50  m_RotationInverse = m_Rotation.inverse();
51  m_PhiScintPositions.clear();
52  m_PhiScintLengths.clear();
53  m_PhiScintOffsets.clear();
54  m_ZScintPositions.clear();
55  m_ZScintLengths.clear();
56  m_ZScintOffsets.clear();
57 }
58 
59 // constructor for RPC module
60 Module::Module(double phiStripWidth,
61  int phiStripMin,
62  int phiStripMax,
63  double zStripWidth,
64  int zStripNumber,
65  const CLHEP::Hep3Vector& globalOrigin,
66  const CLHEP::Hep3Vector& localReconstructionShift,
67  const CLHEP::HepRotation& rotation) :
68  m_HasRPCs(true),
69  m_IsFlipped(false),
70  m_PhiStripWidth(phiStripWidth),
71  m_PhiStripMin(phiStripMin),
72  m_PhiStripMax(phiStripMax),
73  m_PhiPositionBase(0.5 * (phiStripMin + phiStripMax - 1) + 1.0), // start at #1
74  m_ZStripWidth(zStripWidth),
75  m_ZStripMin(1),
76  m_ZStripMax(zStripNumber),
77  m_ZPositionBase(1.0), // start at #1
78  m_PhiSensorSide(1),
79  m_SignalSpeed(0.5 * Const::speedOfLight),
80  m_GlobalOrigin(globalOrigin),
81  m_LocalReconstructionShift(localReconstructionShift),
82  m_Rotation(rotation),
83  m_Alignment(HepGeom::Transform3D()),
84  m_AlignmentRotation(CLHEP::HepRotation()),
85  m_AlignmentTranslation(CLHEP::Hep3Vector()),
86  m_AlignmentInverse(HepGeom::Transform3D()),
87  m_AlignmentRotationInverse(CLHEP::HepRotation()),
88  m_DisplacedGeo(HepGeom::Transform3D()),
89  m_DisplacedGeoRotation(CLHEP::HepRotation()),
90  m_DisplacedGeoTranslation(CLHEP::Hep3Vector()),
91  m_DisplacedGeoInverse(HepGeom::Transform3D()),
92  m_DisplacedGeoRotationInverse(CLHEP::HepRotation())
93 {
94  m_RotationInverse = m_Rotation.inverse();
95  m_PhiScintLengths.clear();
96  m_PhiScintPositions.clear();
97  m_PhiScintOffsets.clear();
98  m_ZScintLengths.clear();
99  m_ZScintPositions.clear();
100  m_ZScintOffsets.clear();
101 }
102 
103 // constructor for scint module
104 Module::Module(double stripWidth,
105  int phiStripNumber,
106  int phiSensorSide,
107  int zStripNumber,
108  const CLHEP::Hep3Vector& globalOrigin,
109  const CLHEP::Hep3Vector& localReconstructionShift,
110  const CLHEP::HepRotation& rotation,
111  bool isFlipped) :
112  m_HasRPCs(false),
113  m_IsFlipped(isFlipped),
114  m_PhiStripWidth(stripWidth),
115  m_PhiStripMin(1),
116  m_PhiStripMax(phiStripNumber),
117  m_PhiPositionBase(0.5 * phiStripNumber + 1.0), // start at #1
118  m_ZStripWidth(stripWidth),
119  m_ZStripMin(1),
120  m_ZStripMax(zStripNumber),
121  m_ZPositionBase(1.0), // start at #1
122  m_PhiSensorSide(phiSensorSide),
123  m_SignalSpeed(0.5671 * Const::speedOfLight), // m_firstPhotonlightSpeed, from EKLM
124  m_GlobalOrigin(globalOrigin),
125  m_LocalReconstructionShift(localReconstructionShift),
126  m_Rotation(rotation),
127  m_Alignment(HepGeom::Transform3D()),
128  m_AlignmentRotation(CLHEP::HepRotation()),
129  m_AlignmentTranslation(CLHEP::Hep3Vector()),
130  m_AlignmentInverse(HepGeom::Transform3D()),
131  m_AlignmentRotationInverse(CLHEP::HepRotation()),
132  m_DisplacedGeo(HepGeom::Transform3D()),
133  m_DisplacedGeoRotation(CLHEP::HepRotation()),
134  m_DisplacedGeoTranslation(CLHEP::Hep3Vector()),
135  m_DisplacedGeoInverse(HepGeom::Transform3D()),
136  m_DisplacedGeoRotationInverse(CLHEP::HepRotation())
137 {
138  if (isFlipped) m_Rotation.rotateZ(M_PI);
139  m_RotationInverse = m_Rotation.inverse();
140  m_PhiScintLengths.clear();
141  m_PhiScintPositions.clear();
142  m_PhiScintOffsets.clear();
143  m_ZScintLengths.clear();
144  m_ZScintPositions.clear();
145  m_ZScintOffsets.clear();
146 }
147 
148 // copy constructor
149 Module::Module(const Module& m) :
150  m_HasRPCs(m.m_HasRPCs),
151  m_IsFlipped(m.m_IsFlipped),
152  m_PhiStripWidth(m.m_PhiStripWidth),
153  m_PhiStripMin(m.m_PhiStripMin),
154  m_PhiStripMax(m.m_PhiStripMax),
155  m_PhiPositionBase(m.m_PhiPositionBase),
156  m_ZStripWidth(m.m_ZStripWidth),
157  m_ZStripMin(m.m_ZStripMin),
158  m_ZStripMax(m.m_ZStripMax),
159  m_ZPositionBase(m.m_ZPositionBase),
160  m_PhiSensorSide(m.m_PhiSensorSide),
161  m_SignalSpeed(m.m_SignalSpeed),
162  m_GlobalOrigin(m.m_GlobalOrigin),
163  m_LocalReconstructionShift(m.m_LocalReconstructionShift),
164  m_Rotation(m.m_Rotation),
165  m_RotationInverse(m.m_RotationInverse),
166  m_Alignment(m.m_Alignment),
167  m_AlignmentRotation(m.m_AlignmentRotation),
168  m_AlignmentTranslation(m.m_AlignmentTranslation),
169  m_AlignmentInverse(m.m_AlignmentInverse),
170  m_AlignmentRotationInverse(m.m_AlignmentRotationInverse),
171  m_DisplacedGeo(m.m_DisplacedGeo),
172  m_DisplacedGeoRotation(m.m_DisplacedGeoRotation),
173  m_DisplacedGeoTranslation(m.m_DisplacedGeoTranslation),
174  m_DisplacedGeoInverse(m.m_DisplacedGeoInverse),
175  m_DisplacedGeoRotationInverse(m.m_DisplacedGeoRotationInverse),
176  m_PhiScintLengths(m.m_PhiScintLengths),
177  m_PhiScintPositions(m.m_PhiScintPositions),
178  m_PhiScintOffsets(m.m_PhiScintOffsets),
179  m_ZScintLengths(m.m_ZScintLengths),
180  m_ZScintPositions(m.m_ZScintPositions),
181  m_ZScintOffsets(m.m_ZScintOffsets)
182 {
183 }
184 
185 // Assignment operator
186 Module& Module::operator=(const Module& m)
187 {
188  if (this != &m) {
189  m_HasRPCs = m.m_HasRPCs;
190  m_IsFlipped = m.m_IsFlipped;
191  m_PhiStripWidth = m.m_PhiStripWidth;
192  m_PhiStripMin = m.m_PhiStripMin;
193  m_PhiStripMax = m.m_PhiStripMax;
194  m_PhiPositionBase = m.m_PhiPositionBase;
195  m_ZStripWidth = m.m_ZStripWidth;
196  m_ZStripMin = m.m_ZStripMin;
197  m_ZStripMax = m.m_ZStripMax;
198  m_ZPositionBase = m.m_ZPositionBase;
199  m_PhiSensorSide = m.m_PhiSensorSide;
200  m_SignalSpeed = m.m_SignalSpeed;
201  m_GlobalOrigin = m.m_GlobalOrigin;
202  m_LocalReconstructionShift = m.m_LocalReconstructionShift;
203  m_Rotation = m.m_Rotation;
204  m_RotationInverse = m.m_RotationInverse;
205  m_Alignment = m.m_Alignment;
206  m_AlignmentRotation = m.m_AlignmentRotation;
207  m_AlignmentTranslation = m.m_AlignmentTranslation;
208  m_AlignmentInverse = m.m_AlignmentInverse;
209  m_AlignmentRotationInverse = m.m_AlignmentRotationInverse;
210  m_DisplacedGeo = m.m_DisplacedGeo;
211  m_DisplacedGeoRotation = m.m_DisplacedGeoRotation;
212  m_DisplacedGeoTranslation = m.m_DisplacedGeoTranslation;
213  m_DisplacedGeoInverse = m.m_DisplacedGeoInverse;
214  m_DisplacedGeoRotationInverse = m.m_DisplacedGeoRotationInverse;
215  m_PhiScintLengths = m.m_PhiScintLengths;
216  m_PhiScintPositions = m.m_PhiScintPositions;
217  m_PhiScintOffsets = m.m_PhiScintOffsets;
218  m_ZScintLengths = m.m_ZScintLengths;
219  m_ZScintPositions = m.m_ZScintPositions;
220  m_ZScintOffsets = m.m_ZScintOffsets;
221  }
222  return *this;
223 }
224 
225 Module::~Module()
226 {
227 }
228 
229 void Module::addPhiScint(int scint, double length, double offset, double position)
230 {
231  while (m_PhiScintLengths.size() <= (unsigned int)scint) {
232  m_PhiScintLengths.push_back(0.0);
233  m_PhiScintOffsets.push_back(0.0);
234  m_PhiScintPositions.push_back(0.0);
235  }
236  m_PhiScintLengths[scint] = length;
237  m_PhiScintOffsets[scint] = offset;
238  m_PhiScintPositions[scint] = position;
239 }
240 
241 void Module::addZScint(int scint, double length, double offset, double position)
242 {
243  while (m_ZScintLengths.size() <= (unsigned int)scint) {
244  m_ZScintLengths.push_back(0.0);
245  m_ZScintOffsets.push_back(0.0);
246  m_ZScintPositions.push_back(0.0);
247  }
248  m_ZScintLengths[scint] = length;
249  m_ZScintOffsets[scint] = offset;
250  m_ZScintPositions[scint] = position;
251 }
252 
253 const CLHEP::Hep3Vector Module::getLocalPosition(double phiStripAve, double zStripAve) const
254 {
255  // "+0.5" assures that the local position is in the middle of the strip
256  return CLHEP::Hep3Vector(0.0,
257  (phiStripAve - m_PhiPositionBase + 0.5) * m_PhiStripWidth,
258  (zStripAve - m_ZPositionBase + 0.5) * m_ZStripWidth);
259 }
260 
261 double Module::getPropagationDistance(const CLHEP::Hep3Vector& local,
262  int strip, bool phiReadout) const
263 {
264  double distance;
265  if (phiReadout) {
266  distance = m_ZStripMax * m_ZStripWidth - local.z();
267  } else {
272  distance = fabs(m_ZScintOffsets[strip] -
273  0.5 * m_PhiSensorSide * m_ZScintLengths[strip] - local.y());
274  }
275  return distance;
276 }
277 
278 const CLHEP::Hep3Vector Module::getPropagationDistance(const CLHEP::Hep3Vector& local) const
279 {
280  double dy = m_PhiPositionBase * m_PhiStripWidth - m_PhiSensorSide * local.y();
281  double dz = m_ZStripMax * m_ZStripWidth - local.z();
282  return CLHEP::Hep3Vector(0.0, dz, dy);
283 }
284 
285 const CLHEP::Hep3Vector Module::getPropagationTimes(const CLHEP::Hep3Vector& local) const
286 {
287  const CLHEP::Hep3Vector proDist = getPropagationDistance(local);
288  return CLHEP::Hep3Vector(0.0, proDist[1] / m_SignalSpeed, proDist[2] / m_SignalSpeed);
289 }
290 
291 double Module::getPropagationTime(const CLHEP::Hep3Vector& local, int strip,
292  bool phiReadout) const
293 {
294  double distance = getPropagationDistance(local, strip, phiReadout);
295  return distance / m_SignalSpeed;
296 }
297 
298 const CLHEP::Hep3Vector Module::getPropagationTimes(
299  const CLHEP::Hep3Vector& local, int stripZ, int stripPhi) const
300 {
301  double distanceZ = getPropagationDistance(local, stripZ, false);
302  double distancePhi = getPropagationDistance(local, stripPhi, true);
303  return CLHEP::Hep3Vector(0.0, distancePhi / m_SignalSpeed, distanceZ / m_SignalSpeed);
304 }
305 
306 const CLHEP::Hep3Vector Module::localToGlobal(const CLHEP::Hep3Vector& v, bool m_reco) const
307 {
308  CLHEP::Hep3Vector vlocal(v.x(), v.y(), v.z());
309  if (m_reco) {
310  vlocal = m_AlignmentRotation * vlocal + m_AlignmentTranslation; // to nominal + displaced local
311  vlocal = m_DisplacedGeoRotation * vlocal + m_DisplacedGeoTranslation; //to nominal local
312  return m_Rotation * vlocal + m_GlobalOrigin; //to global
313  } else {
314  vlocal = m_DisplacedGeoRotation * vlocal + m_DisplacedGeoTranslation; // to nominal local
315  return m_Rotation * vlocal + m_GlobalOrigin; //to global
316  }
317 
318 }
319 
320 const CLHEP::Hep3Vector Module::globalToLocal(const CLHEP::Hep3Vector& v, bool reco) const
321 {
322  CLHEP::Hep3Vector vlocal = m_RotationInverse * (v - m_GlobalOrigin); //now in nominal local
323  vlocal = m_DisplacedGeoRotationInverse * (vlocal - m_DisplacedGeoTranslation); //now in displaced local
324  if (reco) {
325  vlocal = m_AlignmentRotationInverse * (vlocal - m_AlignmentTranslation); //now in real local
326  }
327  return vlocal;
328 }
329 
330 int Module::getPhiStripNumber(const CLHEP::Hep3Vector& p) const
331 {
332  int strip = std::floor(getPhiStrip(p));
333  if (strip < m_PhiStripMin || strip > m_PhiStripMax)
334  return -1;
335  return strip;
336 }
337 
338 int Module::getZStripNumber(const CLHEP::Hep3Vector& p) const
339 {
340  int strip = std::floor(getZStrip(p));
341  if (strip < m_ZStripMin || strip > m_ZStripMax)
342  return -1;
343  return strip;
344 }
345 
346 void Module::setAlignment(const HepGeom::Transform3D& moduleAlignment)
347 {
348  m_Alignment = moduleAlignment;
349  m_AlignmentRotation = getRotationFromTransform3D(moduleAlignment);
350  m_AlignmentTranslation = getTranslationFromTransform3D(moduleAlignment);
351  m_AlignmentInverse = moduleAlignment.inverse();
352  m_AlignmentRotationInverse = getRotationFromTransform3D(m_AlignmentInverse);
353 }
354 
355 void Module::setDisplacedGeo(const HepGeom::Transform3D& moduleDisplacedGeo)
356 {
357  m_DisplacedGeo = moduleDisplacedGeo;
358  m_DisplacedGeoRotation = getRotationFromTransform3D(moduleDisplacedGeo);
359  m_DisplacedGeoTranslation = getTranslationFromTransform3D(moduleDisplacedGeo);
360  m_DisplacedGeoInverse = moduleDisplacedGeo.inverse();
361  m_DisplacedGeoRotationInverse = getRotationFromTransform3D(m_DisplacedGeoInverse);
362 }
363 
364 const CLHEP::Hep3Vector Module::getTranslationFromTransform3D(const HepGeom::Transform3D& trans) const
365 {
366  HepGeom::Scale3D scale;
367  HepGeom::Rotate3D rotation;
368  HepGeom::Translate3D translation;
369  trans.getDecomposition(scale, rotation, translation);
370  CLHEP::Hep3Vector t(translation.dx(), translation.dy(), translation.dz());
371  return t;
372 }
373 
374 const CLHEP::HepRotation Module::getRotationFromTransform3D(const HepGeom::Transform3D& trans) const
375 {
376  HepGeom::Scale3D scale;
377  HepGeom::Rotate3D rotation;
378  HepGeom::Translate3D translation;
379  trans.getDecomposition(scale, rotation, translation);
380  CLHEP::HepRep3x3 rRep(rotation.xx(), rotation.xy(), rotation.xz(),
381  rotation.yx(), rotation.yy(), rotation.yz(),
382  rotation.zx(), rotation.zy(), rotation.zz()
383  );
384  CLHEP::HepRotation r;
385  r.set(rRep);
386  return r;
387 }
Belle2::bklm::Module::m_SignalSpeed
double m_SignalSpeed
to store the signal-propagation speed (cm/ns) along the strip
Definition: Module.h:352
Belle2::bklm::Module::m_PhiStripWidth
double m_PhiStripWidth
to store the width (in cm) of each phi strip this module
Definition: Module.h:325
Belle2::bklm::Module::m_PhiStripMin
int m_PhiStripMin
to store the minimum phi strip number in this module
Definition: Module.h:328
Belle2::bklm::Module::m_DisplacedGeo
HepGeom::Transform3D m_DisplacedGeo
displaced geometry w.r.t the nominal geometry, as transformation (rotation + shift)
Definition: Module.h:382
Belle2::bklm::Module::~Module
~Module()
Destructor.
Definition: Module.cc:225
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::Module::getPropagationDistance
const CLHEP::Hep3Vector getPropagationDistance(const CLHEP::Hep3Vector &) const
Convert local coordinates to signal-propagation distance (cm).
Definition: Module.cc:278
Belle2::bklm::Module::m_PhiPositionBase
double m_PhiPositionBase
to store the base position (in strip
Definition: Module.h:334
Belle2::bklm::Module::m_PhiStripMax
int m_PhiStripMax
to store the maximum phi strip number in this module
Definition: Module.h:331
Belle2::bklm::Module::m_HasRPCs
bool m_HasRPCs
flag to indicate whether this module contains RPCs (true) or scintillators (false)
Definition: Module.h:319
Belle2::bklm::Module::m_ZPositionBase
double m_ZPositionBase
to store the base position (in strip
Definition: Module.h:346
Belle2::bklm::Module::getRotationFromTransform3D
const CLHEP::HepRotation getRotationFromTransform3D(const HepGeom::Transform3D &trans) const
Get the rotation from Transform3D.
Definition: Module.cc:374
Belle2::bklm::Module::Module
Module(void)
Empty constructor does nothing.
Definition: Module.cc:23
Belle2::bklm::Module::getPropagationTimes
const CLHEP::Hep3Vector getPropagationTimes(const CLHEP::Hep3Vector &) const
Convert local coordinates to signal-propagation time (ns) Version for RPCs.
Definition: Module.cc:285
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::bklm::Module::getPhiStripNumber
int getPhiStripNumber(const CLHEP::Hep3Vector &p) const
Get phi strip corresponding to local phi coordinate.
Definition: Module.cc:330
Belle2::bklm::Module::m_AlignmentRotation
CLHEP::HepRotation m_AlignmentRotation
rotation of the alignment transformation
Definition: Module.h:370
Belle2::bklm::Module::m_PhiSensorSide
int m_PhiSensorSide
to store the sensor side for phi scintillators
Definition: Module.h:349
Belle2::bklm::Module
Define the geometry of a BKLM module Each sector [octant] contains Modules.
Definition: Module.h:86
Belle2::bklm::Module::getPhiStrip
double getPhiStrip(const CLHEP::Hep3Vector &p) const
Return phi strip (including fractional part) corresponding to local phi coordinate.
Definition: Module.h:239
Belle2::bklm::Module::getZStrip
double getZStrip(const CLHEP::Hep3Vector &p) const
Return z strip (including fractional part) corresponding to local z coordinate.
Definition: Module.h:245
Belle2::bklm::Module::m_DisplacedGeoInverse
HepGeom::Transform3D m_DisplacedGeoInverse
inverse of displaced geometry transformation
Definition: Module.h:391
Belle2::bklm::Module::getTranslationFromTransform3D
const CLHEP::Hep3Vector getTranslationFromTransform3D(const HepGeom::Transform3D &trans) const
Get the translation from Transform3D.
Definition: Module.cc:364
Belle2::bklm::Module::m_DisplacedGeoRotation
CLHEP::HepRotation m_DisplacedGeoRotation
rotation of the displaced geometry transformation
Definition: Module.h:385
Belle2::bklm::Module::m_ZScintLengths
std::vector< double > m_ZScintLengths
to store the length of each z-measuring scintillator
Definition: Module.h:406
Belle2::bklm::Module::m_AlignmentTranslation
CLHEP::Hep3Vector m_AlignmentTranslation
translation of the alignment transformation
Definition: Module.h:373
Belle2::bklm::Module::m_AlignmentInverse
HepGeom::Transform3D m_AlignmentInverse
inverse of alignment transformation
Definition: Module.h:376
Belle2::bklm::Module::m_RotationInverse
CLHEP::HepRotation m_RotationInverse
to store the inverse of the rotation matrix (in global coordinates) of this module's sector
Definition: Module.h:364
Belle2::bklm::Module::m_Rotation
CLHEP::HepRotation m_Rotation
to store the rotation matrix (in global coordinates) of this module's sector
Definition: Module.h:361
Belle2::bklm::Module::globalToLocal
const CLHEP::Hep3Vector globalToLocal(const CLHEP::Hep3Vector &v, bool reco=false) const
Transform space-point within this module from global to local coordinates.
Definition: Module.cc:320
Belle2::bklm::Module::m_ZStripWidth
double m_ZStripWidth
to store the width (in cm) of each z strip in this module
Definition: Module.h:337
Belle2::bklm::Module::operator=
Module & operator=(const Module &m)
Assignment operator: utilizes copy constructor.
Definition: Module.cc:186
Belle2::bklm::Module::m_ZStripMin
int m_ZStripMin
to store the minimum z strip number in this module
Definition: Module.h:340
Belle2::bklm::Module::m_ZStripMax
int m_ZStripMax
to store the maximum z strip number in this module
Definition: Module.h:343
Belle2::bklm::Module::getLocalPosition
const CLHEP::Hep3Vector getLocalPosition(double phiStripAve, double zStripAve) const
Convert 2D strip position (0..nStrips along each axis) to local coordinates.
Definition: Module.cc:253
Belle2::bklm::Module::getZStripNumber
int getZStripNumber(const CLHEP::Hep3Vector &p) const
Get z strip corresponding to local z coordinate.
Definition: Module.cc:338
Belle2::bklm::Module::m_Alignment
HepGeom::Transform3D m_Alignment
alignment transformation (rotation + shift)
Definition: Module.h:367
Belle2::bklm::Module::m_AlignmentRotationInverse
CLHEP::HepRotation m_AlignmentRotationInverse
inverse of the rotation of the alignment transformation
Definition: Module.h:379
Belle2::bklm::Module::setDisplacedGeo
void setDisplacedGeo(const HepGeom::Transform3D &moduleDisplacedGeo)
Set the displaced geometry Transformation.
Definition: Module.cc:355
Belle2::bklm::Module::m_PhiScintPositions
std::vector< double > m_PhiScintPositions
to store the transverse position (within scintillator envelope) of each phi-measuring scintillator
Definition: Module.h:400
Belle2::bklm::Module::m_LocalReconstructionShift
CLHEP::Hep3Vector m_LocalReconstructionShift
to store the local-coordinate real-vs-ideal translation of this module's sensitive volume
Definition: Module.h:358
Belle2::bklm::Module::getPropagationTime
double getPropagationTime(const CLHEP::Hep3Vector &local, int strip, bool phiReadout) const
Convert local coordinates to signal-propagation time (ns) Version for scintillators.
Definition: Module.cc:291
Belle2::bklm::Module::m_ZScintOffsets
std::vector< double > m_ZScintOffsets
to store the longitudinal offset (within scintillator envelope) of each z-measuring scintillator
Definition: Module.h:412
Belle2::bklm::Module::localToGlobal
const CLHEP::Hep3Vector localToGlobal(const CLHEP::Hep3Vector &v, bool reco=false) const
Transform space-point within this module from local to global coordinates.
Definition: Module.cc:306
Belle2::bklm::Module::m_DisplacedGeoTranslation
CLHEP::Hep3Vector m_DisplacedGeoTranslation
translation of the displaced geometry transformation
Definition: Module.h:388
Belle2::bklm::Module::m_DisplacedGeoRotationInverse
CLHEP::HepRotation m_DisplacedGeoRotationInverse
inverse of the rotation of displaced geometry transformation
Definition: Module.h:394
Belle2::bklm::Module::isFlipped
bool isFlipped() const
Determine if this module is flipped by 180 degrees about z axis within its air gap.
Definition: Module.h:123
Belle2::bklm::Module::m_PhiScintOffsets
std::vector< double > m_PhiScintOffsets
to store the longitudinal offset (within scintillator envelope) of each phi-measuring scintillator
Definition: Module.h:403
Belle2::bklm::Module::m_IsFlipped
bool m_IsFlipped
flag to indicate if this module is flipped by 180 degrees about z axis within its air gap
Definition: Module.h:322
Belle2::Const
This class provides a set of constants for the framework.
Definition: Const.h:36
Belle2::bklm::Module::m_GlobalOrigin
CLHEP::Hep3Vector m_GlobalOrigin
to store the position (in global coordinates) of this module's sensitive-volume origin
Definition: Module.h:355
Belle2::bklm::Module::m_PhiScintLengths
std::vector< double > m_PhiScintLengths
to store the length of each phi-measuring scintillator
Definition: Module.h:397
Belle2::bklm::Module::setAlignment
void setAlignment(const HepGeom::Transform3D &moduleAlignment)
Set the alignment Transformation.
Definition: Module.cc:346
Belle2::bklm::Module::m_ZScintPositions
std::vector< double > m_ZScintPositions
to store the transverse position (within scintillator envelope) of each z-measuring scintillator
Definition: Module.h:409