Belle II Software prerelease-10-00-00a
CDCSimpleSimulation.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <tracking/trackFindingCDC/sim/CDCSimpleSimulation.h>
10
11#include <tracking/trackFindingCDC/eventdata/tracks/CDCTrack.h>
12
13#include <tracking/trackFindingCDC/eventdata/hits/CDCRecoHit3D.h>
14#include <tracking/trackFindingCDC/eventdata/hits/CDCRLWireHit.h>
15#include <tracking/trackFindingCDC/eventdata/hits/CDCWireHit.h>
16
17#include <tracking/trackFindingCDC/topology/CDCWire.h>
18#include <tracking/trackFindingCDC/topology/CDCWireLayer.h>
19#include <tracking/trackFindingCDC/topology/CDCWireTopology.h>
20
21#include <tracking/trackFindingCDC/utilities/VectorRange.h>
22
23#include <framework/gearbox/Const.h>
24#include <framework/logging/Logger.h>
25
26#include <TRandom.h>
27
28#include <algorithm>
29
30using namespace Belle2;
31using namespace TrackFindingCDC;
32
33ConstVectorRange<CDCWireHit> CDCSimpleSimulation::getWireHits() const
34{
35 if (m_sharedWireHits) {
36 return {m_sharedWireHits->begin(), m_sharedWireHits->end()};
37 } else {
38 return ConstVectorRange<CDCWireHit>();
39 }
40}
41
42CDCTrack CDCSimpleSimulation::simulate(const CDCTrajectory3D& trajectory3D)
43{
44 return std::move(simulate(std::vector<CDCTrajectory3D>(1, trajectory3D)).front());
45}
46
47
48std::vector<CDCTrack> CDCSimpleSimulation::simulate(const std::vector<CDCTrajectory3D>& trajectories3D)
49{
50 std::vector<SimpleSimHit> simpleSimHits;
51 const size_t nMCTracks = trajectories3D.size();
52
53 for (size_t iMCTrack = 0; iMCTrack < nMCTracks; ++iMCTrack) {
54 const CDCTrajectory3D& trajectory3D = trajectories3D[iMCTrack];
55
56 const UncertainHelix& localHelix = trajectory3D.getLocalHelix();
57 const Vector3D& localOrigin = trajectory3D.getLocalOrigin();
58
59 Helix globalHelix = localHelix;
60 const double arcLength2DOffset = globalHelix.passiveMoveBy(-localOrigin);
61 std::vector<SimpleSimHit> simpleSimHitsForTrajectory = createHits(globalHelix, arcLength2DOffset);
62
63 for (SimpleSimHit& simpleSimHit : simpleSimHitsForTrajectory) {
64 simpleSimHit.m_iMCTrack = iMCTrack;
65 simpleSimHits.push_back(simpleSimHit);
66 }
67 }
68
69 std::vector<CDCTrack> mcTracks = constructMCTracks(nMCTracks, std::move(simpleSimHits));
70
72 for (size_t iMCTrack = 0; iMCTrack < nMCTracks; ++iMCTrack) {
73 CDCTrack& mcTrack = mcTracks[iMCTrack];
74 CDCTrajectory3D mcTrajectory = trajectories3D[iMCTrack];
75 if (not mcTrack.empty()) {
76 mcTrajectory.setLocalOrigin(mcTrack.front().getRecoPos3D());
77 mcTrack.setStartTrajectory3D(mcTrajectory);
78 mcTrajectory.setLocalOrigin(mcTrack.back().getRecoPos3D());
79 mcTrack.setEndTrajectory3D(mcTrajectory);
80 } else {
81 mcTrack.setStartTrajectory3D(mcTrajectory);
82 mcTrack.setEndTrajectory3D(mcTrajectory);
83 }
84 }
85 return mcTracks;
86}
87
88std::vector<CDCTrack>
89CDCSimpleSimulation::constructMCTracks(int nMCTracks, std::vector<SimpleSimHit> simpleSimHits)
90{
91
92 // Sort the hits along side their wire hits
93 std::stable_sort(simpleSimHits.begin(), simpleSimHits.end(),
94 [](const SimpleSimHit & lhs, const SimpleSimHit & rhs) -> bool {
95 return lhs.m_wireHit < rhs.m_wireHit;
96 });
97
98 // Discard multiple hits on the same wire up to the maximal exceeding the maximal desired number
99 if (m_maxNHitOnWire > 0) {
100 const CDCWire* lastWire = nullptr;
101 size_t nSameWire = 0;
102 const size_t maxNHitOnWire = m_maxNHitOnWire;
103
104 auto exceedsMaxNHitOnWire =
105 [&lastWire, &nSameWire, maxNHitOnWire](const SimpleSimHit & simpleSimHit) -> bool {
106
107 if (&(simpleSimHit.m_wireHit.getWire()) == lastWire)
108 {
109 ++nSameWire;
110 } else
111 {
112 nSameWire = 1;
113 lastWire = &(simpleSimHit.m_wireHit.getWire());
114 }
115 return nSameWire > maxNHitOnWire ? true : false;
116 };
117
118 auto itLast = std::remove_if(simpleSimHits.begin(), simpleSimHits.end(), exceedsMaxNHitOnWire);
119 simpleSimHits.erase(itLast, simpleSimHits.end());
120 }
121
122 // Write the created hits and move them to the their storage place.
123 {
124 std::vector<CDCWireHit> wireHits;
125 wireHits.reserve(simpleSimHits.size());
126 for (SimpleSimHit& simpleSimHit : simpleSimHits) {
127 wireHits.push_back(simpleSimHit.m_wireHit);
128 }
129
130 B2ASSERT("WireHits should be sorted as a result from sorting the SimpleSimHits. "
131 "Algorithms may relay on the sorting o the WireHits",
132 std::is_sorted(wireHits.begin(), wireHits.end()));
133
134 m_sharedWireHits.reset(new const std::vector<CDCWireHit>(std::move(wireHits)));
135 }
136
137 // TODO: Decide if the EventMeta should be incremented after write.
138
139 // Now construct the tracks.
140 std::vector<CDCTrack> mcTracks;
141 mcTracks.resize(nMCTracks);
142 ConstVectorRange<CDCWireHit> wireHits = getWireHits();
143 const size_t nWireHits = wireHits.size();
144
145 for (size_t iWireHit = 0; iWireHit < nWireHits; ++iWireHit) {
146 const CDCWireHit& wireHit = wireHits[iWireHit];
147 const SimpleSimHit& simpleSimHit = simpleSimHits[iWireHit];
148
149 CDCTrack& mcTrack = mcTracks[simpleSimHit.m_iMCTrack];
150
151 CDCRLWireHit rlWireHit(&wireHit, simpleSimHit.m_rlInfo);
152 CDCRecoHit3D recoHit3D(rlWireHit, simpleSimHit.m_pos3D, simpleSimHit.m_arcLength2D);
153 mcTrack.push_back(recoHit3D);
154 }
155
157 for (CDCTrack& mcTrack : mcTracks) {
158 mcTrack.sortByArcLength2D();
159 }
160
161 return mcTracks;
162}
163
164
165
166std::vector<CDCSimpleSimulation::SimpleSimHit>
167CDCSimpleSimulation::createHits(const Helix& globalHelix,
168 double arcLength2DOffset) const
169{
170
171 std::vector<SimpleSimHit> simpleSimHits;
172
173 CDCWireTopology& wireTopology = CDCWireTopology::getInstance();
174 const double outerWallCylinderR = wireTopology.getOuterCylindricalR();
175
176 const double minR = globalHelix.minimalCylindricalR();
177 const double maxR = globalHelix.maximalCylindricalR();
178
179 const double globalArcLength2DToOuterWall = globalHelix.arcLength2DToCylindricalR(outerWallCylinderR);
180 const double localArcLength2DToOuterWall = arcLength2DOffset + globalArcLength2DToOuterWall;
181
182 if (localArcLength2DToOuterWall < 0) {
183 // Trajectory starts outside the CDC and initially flys away from it
184 // Do not try to createHit hits for it
185 B2WARNING("Simple simulation got trajectory outside CDC that moves away from the detector.");
186 return simpleSimHits;
187 }
188
189 // Two dimensional arc length where the trajectory
190 // * leaves the outer wall of the CDC or
191 // * made a full circle (cut off for curlers)
192 const bool isCurler = std::isnan(localArcLength2DToOuterWall);
193 const double perimeterXY = globalHelix.perimeterXY();
194 const double maxArcLength2D = isCurler ? fabs(perimeterXY) : localArcLength2DToOuterWall;
195
196 if (isCurler) {
197 B2INFO("Simulating curler");
198 }
199
200 for (const CDCWireLayer& wireLayer : wireTopology.getWireLayers()) {
201 double outerR = wireLayer.getOuterCylindricalR();
202 double innerR = wireLayer.getInnerCylindricalR();
203
204 if ((maxR < innerR) or (outerR < minR)) {
205 // Trajectory does not reaching the layer
206 continue;
207 }
208
209 double centerR = (std::min(outerR, maxR) + std::max(innerR, minR)) / 2;
210
211 double globalArcLength2D = globalHelix.arcLength2DToCylindricalR(centerR);
212 double localArcLength2D = arcLength2DOffset + globalArcLength2D;
213
214
215 std::vector<SimpleSimHit> simpleSimHitsInLayer;
216 if (localArcLength2D > 0 and localArcLength2D < maxArcLength2D) {
217
218 Vector3D pos3DAtLayer = globalHelix.atArcLength2D(globalArcLength2D);
219 const CDCWire& closestWire = wireLayer.getClosestWire(pos3DAtLayer);
220
221 simpleSimHitsInLayer = createHitsForLayer(closestWire, globalHelix, arcLength2DOffset);
222
223 for (SimpleSimHit& simpleSimHit : simpleSimHitsInLayer) {
224 if (simpleSimHit.m_arcLength2D < maxArcLength2D) {
225 simpleSimHits.push_back(simpleSimHit);
226 }
227 }
228 } else {
229 B2INFO("Arc length to long");
230 }
231
232 bool oneSegment = outerR > maxR or innerR < minR;
233 if (not oneSegment) {
234
235 // Check the second branch for more hits
236 double secondGlobalArcLength2D = -globalArcLength2D;
237 double secondArcLength2DOffset = arcLength2DOffset;
238 double secondLocalArcLength2D = secondArcLength2DOffset + secondGlobalArcLength2D;
239
240 if (isCurler and secondLocalArcLength2D < 0) {
241 secondLocalArcLength2D += perimeterXY;
242 secondArcLength2DOffset += perimeterXY;
243 secondGlobalArcLength2D += perimeterXY;
244 }
245
246 if (secondLocalArcLength2D > 0 and secondLocalArcLength2D < maxArcLength2D) {
247 Vector3D pos3DAtLayer = globalHelix.atArcLength2D(secondGlobalArcLength2D);
248 const CDCWire& closestWire = wireLayer.getClosestWire(pos3DAtLayer);
249
250 // Check again if the wire has been hit before
251 bool wireAlreadyHit = false;
252 for (const SimpleSimHit& simpleSimHit : simpleSimHits) {
253 if (simpleSimHit.m_wireHit.isOnWire(closestWire)) {
254 wireAlreadyHit = true;
255 }
256 }
257 if (not wireAlreadyHit) {
258 std::vector<SimpleSimHit> secondSimpleSimHitsInLayer =
259 createHitsForLayer(closestWire, globalHelix, secondArcLength2DOffset);
260
261 for (SimpleSimHit& simpleSimHit : secondSimpleSimHitsInLayer) {
262 if (simpleSimHit.m_arcLength2D < maxArcLength2D) {
263 simpleSimHits.push_back(simpleSimHit);
264 }
265 }
266 }
267 }
268 }
269 }
270
271 return simpleSimHits;
272}
273
274std::vector<CDCSimpleSimulation::SimpleSimHit>
275CDCSimpleSimulation::createHitsForLayer(const CDCWire& nearWire,
276 const Helix& globalHelix,
277 double arcLength2DOffset) const
278{
279 std::vector<SimpleSimHit> result;
280
281 SimpleSimHit simpleSimHit = createHitForCell(nearWire, globalHelix, arcLength2DOffset);
282 if (not std::isnan(simpleSimHit.m_wireHit.getRefDriftLength())) {
283 result.push_back(simpleSimHit);
284 }
285
287 const CDCWire* ccwWire = nearWire.getNeighborCCW();
288 while (true) {
289 SimpleSimHit simpleSimHitForWire = createHitForCell(*ccwWire, globalHelix, arcLength2DOffset);
290 if (std::isnan(simpleSimHitForWire.m_arcLength2D) or
291 std::isnan(simpleSimHitForWire.m_trueDriftLength)) {
292 break;
293 }
294 result.push_back(simpleSimHitForWire);
295 ccwWire = ccwWire->getNeighborCCW();
296 }
297
299 const CDCWire* cwWire = nearWire.getNeighborCW();
300 while (true) {
301 SimpleSimHit simpleSimHitForWire = createHitForCell(*cwWire, globalHelix, arcLength2DOffset);
302 if (std::isnan(simpleSimHitForWire.m_arcLength2D) or
303 std::isnan(simpleSimHitForWire.m_trueDriftLength)) {
304 break;
305 }
306 result.push_back(simpleSimHitForWire);
307 cwWire = cwWire->getNeighborCW();
308 }
309
310 return result;
311}
312
313
314CDCSimpleSimulation::SimpleSimHit
315CDCSimpleSimulation::createHitForCell(const CDCWire& wire,
316 const Helix& globalHelix,
317 double arcLength2DOffset) const
318{
319 double arcLength2D = globalHelix.arcLength2DToXY(wire.getRefPos2D());
320 if ((arcLength2D + arcLength2DOffset) < 0) {
321 arcLength2D += globalHelix.perimeterXY();
322 }
323
324 Vector3D pos3D = globalHelix.atArcLength2D(arcLength2D);
325
326 Vector3D correctedPos3D = pos3D;
327 Vector2D correctedWirePos(wire.getWirePos2DAtZ(correctedPos3D.z()));
328 double correctedArcLength2D = arcLength2D;
329
330 for (int c_Iter = 0; c_Iter < 2; c_Iter++) {
331 // Iterate the extrapolation to the stereo shifted position.
332 correctedWirePos = wire.getWirePos2DAtZ(correctedPos3D.z());
333 correctedArcLength2D = globalHelix.arcLength2DToXY(correctedWirePos);
334
335 if ((correctedArcLength2D + arcLength2DOffset) < 0) {
336 correctedArcLength2D += globalHelix.perimeterXY();
337 }
338 correctedPos3D = globalHelix.atArcLength2D(correctedArcLength2D);
339 }
340
341 const double trueDriftLength = wire.getDriftLength(correctedPos3D);
342 const double smearedDriftLength = trueDriftLength + gRandom->Gaus(0, m_driftLengthSigma);
343
344 double delayTime = getEventTime();
345 if (m_addTOFDelay) {
346 double arcLength3D = hypot2(1, globalHelix.tanLambda()) * (correctedArcLength2D + arcLength2DOffset);
347 delayTime += arcLength3D / Const::speedOfLight;
348 }
349
350 if (m_addInWireSignalDelay) {
351 double backwardZ = wire.getBackwardZ();
352 // Position where wire has been hit
353 Vector3D wirePos = wire.getClosest(correctedPos3D);
354 double distanceToBack = (wirePos.z() - backwardZ) * hypot2(1, wire.getTanStereoAngle());
355
356 delayTime += distanceToBack / m_propSpeed;
357 }
358
359 double measuredDriftLength = smearedDriftLength + delayTime * m_driftSpeed;
360
361 ERightLeft rlInfo = globalHelix.circleXY().isRightOrLeft(correctedWirePos);
362
363 // if (not std::isnan(trueDriftLength)){
364 // B2INFO("Delay time " << delayTime);
365 // B2INFO("True dirft length " << trueDriftLength);
366 // B2INFO("Measured drift length " << measuredDriftLength);
367 // B2INFO("Absolute deviation " << measuredDriftLength - trueDriftLength);
368 // B2INFO("Relative deviation " << (measuredDriftLength / trueDriftLength - 1) * 100 << "%");
369 // }
370
371 return SimpleSimHit{
372 CDCWireHit(wire.getWireID(), measuredDriftLength, m_driftLengthVariance),
373 0,
374 rlInfo,
375 correctedPos3D,
376 correctedArcLength2D,
377 trueDriftLength
378 };
379}
380
381
382std::vector<CDCTrack>
383CDCSimpleSimulation::loadPreparedEvent()
384{
385 const size_t nMCTracks = 2;
386 std::vector<SimpleSimHit> simpleSimHits;
387 simpleSimHits.reserve(128 + 64); // First plus second mc track
388
389 // First MC track
391 size_t iMCTrack = 0;
392
393 // SL 6
394 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 4, 251), 0.104), iMCTrack, ERightLeft::c_Left});
395 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 4, 250), 0.272), iMCTrack, ERightLeft::c_Left});
396 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 4, 249), 0.488), iMCTrack, ERightLeft::c_Left});
397 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 4, 248), 0.764), iMCTrack, ERightLeft::c_Left});
398 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 3, 247), 0.9), iMCTrack, ERightLeft::c_Right});
399 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 4, 247), 1.024), iMCTrack, ERightLeft::c_Left});
400 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 3, 246), 0.64), iMCTrack, ERightLeft::c_Right});
401 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 3, 245), 0.304), iMCTrack, ERightLeft::c_Right});
402 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 3, 244), 0.012), iMCTrack, ERightLeft::c_Right});
403 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 3, 243), 0.352), iMCTrack, ERightLeft::c_Left});
404 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 3, 242), 0.74), iMCTrack, ERightLeft::c_Left});
405 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 2, 241), 0.46), iMCTrack, ERightLeft::c_Right});
406 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 2, 240), 0.02), iMCTrack, ERightLeft::c_Right});
407 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 2, 239), 0.46), iMCTrack, ERightLeft::c_Left});
408 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 2, 238), 0.884), iMCTrack, ERightLeft::c_Left});
409 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 1, 238), 1.104), iMCTrack, ERightLeft::c_Right});
410 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 1, 237), 0.612), iMCTrack, ERightLeft::c_Right});
411 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 1, 236), 0.12), iMCTrack, ERightLeft::c_Right});
412 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 1, 235), 0.356), iMCTrack, ERightLeft::c_Left});
413 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 1, 234), 0.884), iMCTrack, ERightLeft::c_Left});
414 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 0, 235), 1.032), iMCTrack, ERightLeft::c_Right});
415 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 0, 234), 0.52), iMCTrack, ERightLeft::c_Right});
416 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 0, 233), 0.06), iMCTrack, ERightLeft::c_Left});
417 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 0, 232), 0.62), iMCTrack, ERightLeft::c_Left});
418
419 // SL 5
420 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 5, 206), 1.116), iMCTrack, ERightLeft::c_Right});
421 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 5, 205), 0.464), iMCTrack, ERightLeft::c_Right});
422 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 5, 204), 0.168), iMCTrack, ERightLeft::c_Right});
423 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 4, 204), 1.08), iMCTrack, ERightLeft::c_Right});
424 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 4, 203), 0.392), iMCTrack, ERightLeft::c_Right});
425 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 4, 202), 0.304), iMCTrack, ERightLeft::c_Left});
426 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 3, 201), 0.968), iMCTrack, ERightLeft::c_Right});
427 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 3, 200), 0.252), iMCTrack, ERightLeft::c_Right});
428 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 3, 199), 0.476), iMCTrack, ERightLeft::c_Left});
429 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 2, 199), 0.736), iMCTrack, ERightLeft::c_Right});
430 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 2, 198), 0.008), iMCTrack, ERightLeft::c_Left});
431 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 2, 197), 0.788), iMCTrack, ERightLeft::c_Left});
432 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 1, 197), 1.188), iMCTrack, ERightLeft::c_Right});
433 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 1, 196), 0.404), iMCTrack, ERightLeft::c_Right});
434 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 1, 195), 0.356), iMCTrack, ERightLeft::c_Left});
435 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 0, 195), 0.74), iMCTrack, ERightLeft::c_Right});
436 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 0, 194), 0.04), iMCTrack, ERightLeft::c_Left});
437 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 0, 193), 0.832), iMCTrack, ERightLeft::c_Left});
438
439 // SL 4
440 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 5, 173), 0.692), iMCTrack, ERightLeft::c_Right});
441 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 5, 172), 0.22), iMCTrack, ERightLeft::c_Left});
442 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 5, 171), 1.132), iMCTrack, ERightLeft::c_Left});
443 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 4, 172), 0.816), iMCTrack, ERightLeft::c_Right});
444 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 4, 171), 0.136), iMCTrack, ERightLeft::c_Left});
445 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 4, 170), 1.048), iMCTrack, ERightLeft::c_Left});
446 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 3, 170), 0.884), iMCTrack, ERightLeft::c_Right});
447 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 3, 169), 0.032), iMCTrack, ERightLeft::c_Left});
448 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 3, 168), 0.96), iMCTrack, ERightLeft::c_Left});
449 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 2, 169), 0.972), iMCTrack, ERightLeft::c_Right});
450 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 2, 168), 0.044), iMCTrack, ERightLeft::c_Right});
451 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 2, 167), 0.872), iMCTrack, ERightLeft::c_Left});
452 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 1, 167), 1.004), iMCTrack, ERightLeft::c_Right});
453 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 1, 166), 0.1), iMCTrack, ERightLeft::c_Right});
454 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 1, 165), 0.828), iMCTrack, ERightLeft::c_Left});
455 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 0, 166), 1.004), iMCTrack, ERightLeft::c_Right});
456 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 0, 165), 0.084), iMCTrack, ERightLeft::c_Right});
457 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 0, 164), 0.82), iMCTrack, ERightLeft::c_Left});
458
459 // SL 3
460 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 5, 145), 0.508), iMCTrack, ERightLeft::c_Right});
461 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 5, 144), 0.5), iMCTrack, ERightLeft::c_Left});
462 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 4, 145), 1.348), iMCTrack, ERightLeft::c_Right});
463 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 4, 144), 0.292), iMCTrack, ERightLeft::c_Right});
464 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 4, 143), 0.68), iMCTrack, ERightLeft::c_Left});
465 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 3, 143), 1.136), iMCTrack, ERightLeft::c_Right});
466 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 3, 142), 0.12), iMCTrack, ERightLeft::c_Right});
467 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 3, 141), 0.872), iMCTrack, ERightLeft::c_Left});
468 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 2, 142), 0.96), iMCTrack, ERightLeft::c_Right});
469 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 2, 141), 0.036), iMCTrack, ERightLeft::c_Left});
470 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 1, 140), 0.756), iMCTrack, ERightLeft::c_Right});
471 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 1, 139), 0.204), iMCTrack, ERightLeft::c_Left});
472 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 0, 139), 0.588), iMCTrack, ERightLeft::c_Right});
473 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 0, 138), 0.332), iMCTrack, ERightLeft::c_Left});
474
475 // SL 2
476 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 5, 116), 1.1), iMCTrack, ERightLeft::c_Right});
477 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 5, 115), 0.008), iMCTrack, ERightLeft::c_Left});
478 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 5, 114), 1.048), iMCTrack, ERightLeft::c_Left});
479 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 4, 115), 0.712), iMCTrack, ERightLeft::c_Right});
480 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 4, 114), 0.316), iMCTrack, ERightLeft::c_Left});
481 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 3, 113), 0.428), iMCTrack, ERightLeft::c_Right});
482 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 3, 112), 0.572), iMCTrack, ERightLeft::c_Left});
483 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 2, 112), 0.188), iMCTrack, ERightLeft::c_Right});
484 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 2, 111), 0.776), iMCTrack, ERightLeft::c_Left});
485 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 1, 111), 0.92), iMCTrack, ERightLeft::c_Right});
486 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 1, 110), 0.024), iMCTrack, ERightLeft::c_Left});
487 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 1, 109), 0.928), iMCTrack, ERightLeft::c_Left});
488 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 0, 110), 0.776), iMCTrack, ERightLeft::c_Right});
489 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 0, 109), 0.116), iMCTrack, ERightLeft::c_Left});
490 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 0, 108), 0.992), iMCTrack, ERightLeft::c_Left});
491
492 // SL 1
493 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 5, 87), 0.664), iMCTrack, ERightLeft::c_Right});
494 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 5, 86), 0.3), iMCTrack, ERightLeft::c_Left});
495 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 4, 86), 0.504), iMCTrack, ERightLeft::c_Right});
496 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 4, 85), 0.424), iMCTrack, ERightLeft::c_Left});
497 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 3, 85), 1.256), iMCTrack, ERightLeft::c_Right});
498 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 3, 84), 0.388), iMCTrack, ERightLeft::c_Right});
499 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 3, 83), 0.5), iMCTrack, ERightLeft::c_Left});
500 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 2, 84), 1.128), iMCTrack, ERightLeft::c_Right});
501 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 2, 83), 0.28), iMCTrack, ERightLeft::c_Right});
502 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 2, 82), 0.532), iMCTrack, ERightLeft::c_Left});
503 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 1, 82), 1.084), iMCTrack, ERightLeft::c_Right});
504 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 1, 81), 0.3), iMCTrack, ERightLeft::c_Right});
505 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 1, 80), 0.472), iMCTrack, ERightLeft::c_Left});
506 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 0, 81), 1.124), iMCTrack, ERightLeft::c_Right});
507 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 0, 80), 0.428), iMCTrack, ERightLeft::c_Right});
508 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 0, 79), 0.296), iMCTrack, ERightLeft::c_Left});
509 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 0, 78), 0.972), iMCTrack, ERightLeft::c_Left});
510
511 // SL 0
512 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 7, 81), 0.192), iMCTrack, ERightLeft::c_Right});
513 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 7, 80), 0.452), iMCTrack, ERightLeft::c_Left});
514 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 6, 80), 0.596), iMCTrack, ERightLeft::c_Right});
515 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 6, 79), 0.024), iMCTrack, ERightLeft::c_Left});
516 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 6, 78), 0.66), iMCTrack, ERightLeft::c_Left});
517 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 5, 79), 0.388), iMCTrack, ERightLeft::c_Right});
518 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 5, 78), 0.184), iMCTrack, ERightLeft::c_Left});
519 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 4, 77), 0.296), iMCTrack, ERightLeft::c_Right});
520 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 4, 76), 0.244), iMCTrack, ERightLeft::c_Left});
521 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 3, 76), 0.268), iMCTrack, ERightLeft::c_Right});
522 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 3, 75), 0.212), iMCTrack, ERightLeft::c_Left});
523 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 2, 74), 0.316), iMCTrack, ERightLeft::c_Right});
524 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 2, 73), 0.112), iMCTrack, ERightLeft::c_Right});
525 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 2, 72), 0.588), iMCTrack, ERightLeft::c_Left});
526 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 1, 73), 0.464), iMCTrack, ERightLeft::c_Right});
527 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 1, 72), 0.028), iMCTrack, ERightLeft::c_Left});
528 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 0, 70), 0.284), iMCTrack, ERightLeft::c_Right});
529 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 0, 69), 0.088), iMCTrack, ERightLeft::c_Left});
530 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 0, 68), 0.416), iMCTrack, ERightLeft::c_Left});
531
532 // Second MC track
534 iMCTrack = 1;
535
536 // SL 0
537 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 1, 140), 0.308), iMCTrack, ERightLeft::c_Left});
538 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 2, 139), 0.08), iMCTrack, ERightLeft::c_Left});
539 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 3, 139), 0.16), iMCTrack, ERightLeft::c_Right});
540 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 4, 139), 0.404), iMCTrack, ERightLeft::c_Left});
541 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 4, 138), 0.38), iMCTrack, ERightLeft::c_Right});
542 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 5, 139), 0.132), iMCTrack, ERightLeft::c_Left});
543 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 6, 138), 0.108), iMCTrack, ERightLeft::c_Right});
544 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 7, 139), 0.48), iMCTrack, ERightLeft::c_Left});
545 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(0, 7, 138), 0.424), iMCTrack, ERightLeft::c_Right});
546
547 // SL 1
548 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 0, 136), 0.532), iMCTrack, ERightLeft::c_Left});
549 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 0, 135), 0.452), iMCTrack, ERightLeft::c_Right});
550 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 1, 135), 0.396), iMCTrack, ERightLeft::c_Left});
551 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 2, 135), 0.26), iMCTrack, ERightLeft::c_Left});
552 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 1, 134), 0.64), iMCTrack, ERightLeft::c_Right});
553 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 3, 134), 0.092), iMCTrack, ERightLeft::c_Left});
554 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 4, 134), 0.16), iMCTrack, ERightLeft::c_Right});
555 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(1, 5, 133), 0.524), iMCTrack, ERightLeft::c_Right});
556
557 // SL 2
558 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 0, 163), 0.228), iMCTrack, ERightLeft::c_Right});
559 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 1, 162), 0.356), iMCTrack, ERightLeft::c_Right});
560 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 2, 163), 0.776), iMCTrack, ERightLeft::c_Left});
561 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 2, 162), 0.46), iMCTrack, ERightLeft::c_Right});
562 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 3, 162), 0.744), iMCTrack, ERightLeft::c_Left});
563 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 3, 161), 0.58), iMCTrack, ERightLeft::c_Right});
564 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 4, 162), 0.656), iMCTrack, ERightLeft::c_Left});
565 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 4, 161), 0.68), iMCTrack, ERightLeft::c_Right});
566 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 5, 161), 0.568), iMCTrack, ERightLeft::c_Left});
567 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(2, 5, 160), 0.812), iMCTrack, ERightLeft::c_Right});
568
569 // SL 3
570 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 0, 190), 0.54), iMCTrack, ERightLeft::c_Left});
571 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 1, 188), 0.688), iMCTrack, ERightLeft::c_Right});
572 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 2, 188), 0.656), iMCTrack, ERightLeft::c_Right});
573 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 3, 188), 0.664), iMCTrack, ERightLeft::c_Left});
574 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 3, 187), 0.68), iMCTrack, ERightLeft::c_Right});
575 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 4, 188), 0.724), iMCTrack, ERightLeft::c_Left});
576 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 4, 187), 0.656), iMCTrack, ERightLeft::c_Right});
577 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(3, 5, 186), 0.676), iMCTrack, ERightLeft::c_Right});
578
579 // SL 4
580 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 0, 211), 0.42), iMCTrack, ERightLeft::c_Left});
581 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 0, 210), 0.872), iMCTrack, ERightLeft::c_Right});
582 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 1, 210), 0.548), iMCTrack, ERightLeft::c_Left});
583 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 1, 209), 0.796), iMCTrack, ERightLeft::c_Right});
584 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 2, 210), 0.716), iMCTrack, ERightLeft::c_Left});
585 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 2, 209), 0.656), iMCTrack, ERightLeft::c_Right});
586 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 3, 209), 0.856), iMCTrack, ERightLeft::c_Left});
587 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 4, 209), 1.056), iMCTrack, ERightLeft::c_Left});
588 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 4, 208), 0.36), iMCTrack, ERightLeft::c_Right});
589 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(4, 5, 207), 0.232), iMCTrack, ERightLeft::c_Right});
590
591 // SL 5
592 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 0, 231), 0.224), iMCTrack, ERightLeft::c_Left});
593 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 0, 230), 1.088), iMCTrack, ERightLeft::c_Right});
594 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 1, 230), 0.452), iMCTrack, ERightLeft::c_Left});
595 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 1, 229), 0.912), iMCTrack, ERightLeft::c_Right});
596 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 2, 230), 0.72), iMCTrack, ERightLeft::c_Left});
597 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 2, 229), 0.632), iMCTrack, ERightLeft::c_Right});
598 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 3, 229), 1.016), iMCTrack, ERightLeft::c_Left});
599 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 3, 228), 0.34), iMCTrack, ERightLeft::c_Right});
600 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 4, 228), 0.04), iMCTrack, ERightLeft::c_Right});
601 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 5, 227), 0.22), iMCTrack, ERightLeft::c_Left});
602 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(5, 5, 226), 1.196), iMCTrack, ERightLeft::c_Right});
603
604 // SL 6
605 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 0, 254), 0.104), iMCTrack, ERightLeft::c_Left});
606 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 1, 253), 0.504), iMCTrack, ERightLeft::c_Left});
607 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 1, 252), 0.78), iMCTrack, ERightLeft::c_Right});
608 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 2, 253), 0.968), iMCTrack, ERightLeft::c_Left});
609 simpleSimHits.push_back(SimpleSimHit{CDCWireHit(WireID(6, 2, 252), 0.332), iMCTrack, ERightLeft::c_Right});
610
611 std::vector<CDCTrack> mcTracks = constructMCTracks(nMCTracks, std::move(simpleSimHits));
612 return mcTracks;
613}
Belle2::Const::speedOfLight
static const double speedOfLight
[cm/ns]
Definition Const.h:695
Belle2::TrackFindingCDC::CDCRLWireHit
Class representing an oriented hit wire including a hypotheses whether the causing track passes left ...
Definition CDCRLWireHit.h:41
Belle2::TrackFindingCDC::CDCRecoHit3D
Class representing a three dimensional reconstructed hit.
Definition CDCRecoHit3D.h:52
Belle2::TrackFindingCDC::CDCSimpleSimulation::getWireHits
ConstVectorRange< CDCWireHit > getWireHits() const
Getter for the wire hits created in the simulation.
Definition CDCSimpleSimulation.cc:33
Belle2::TrackFindingCDC::CDCSimpleSimulation::constructMCTracks
std::vector< CDCTrack > constructMCTracks(int nMCTracks, std::vector< SimpleSimHit > simpleSimHits)
Creates CDCWireHits and uses them to construct the true CDCTracks.
Definition CDCSimpleSimulation.cc:89
Belle2::TrackFindingCDC::CDCSimpleSimulation::simulate
std::vector< CDCTrack > simulate(const std::vector< CDCTrajectory3D > &trajectories3D)
Propagates the trajectories through the CDC as without energy loss until they first leave the CDC.
Definition CDCSimpleSimulation.cc:48
Belle2::TrackFindingCDC::CDCSimpleSimulation::m_addInWireSignalDelay
bool m_addInWireSignalDelay
Switch to activate the in wire signal delay.
Definition CDCSimpleSimulation.h:184
Belle2::TrackFindingCDC::CDCSimpleSimulation::m_propSpeed
double m_propSpeed
Electrical current propagation speed in the wires.
Definition CDCSimpleSimulation.h:194
Belle2::TrackFindingCDC::CDCSimpleSimulation::m_sharedWireHits
std::shared_ptr< const std::vector< CDCWireHit > > m_sharedWireHits
Space for the memory of the generated wire hits.
Definition CDCSimpleSimulation.h:163
Belle2::TrackFindingCDC::CDCSimpleSimulation::getEventTime
double getEventTime() const
Getter for a global event time offset.
Definition CDCSimpleSimulation.h:138
Belle2::TrackFindingCDC::CDCSimpleSimulation::m_driftLengthVariance
double m_driftLengthVariance
Variance by which the drift length should be smeared.
Definition CDCSimpleSimulation.h:188
Belle2::TrackFindingCDC::CDCSimpleSimulation::createHitsForLayer
std::vector< SimpleSimHit > createHitsForLayer(const CDCWire &nearWire, const Helix &globalHelix, double arcLength2DOffset) const
Generate connected hits for wires in the same layer close to the given wire.
Definition CDCSimpleSimulation.cc:275
Belle2::TrackFindingCDC::CDCSimpleSimulation::m_addTOFDelay
bool m_addTOFDelay
Switch to activate the addition of the time of flight.
Definition CDCSimpleSimulation.h:181
Belle2::TrackFindingCDC::CDCSimpleSimulation::createHitForCell
SimpleSimHit createHitForCell(const CDCWire &wire, const Helix &globalHelix, double arcLength2DOffset) const
Generate a hit for the given wire.
Definition CDCSimpleSimulation.cc:315
Belle2::TrackFindingCDC::CDCSimpleSimulation::m_maxNHitOnWire
int m_maxNHitOnWire
Maximal number of hits allowed on each wire (0 means all).
Definition CDCSimpleSimulation.h:175
Belle2::TrackFindingCDC::CDCSimpleSimulation::m_driftLengthSigma
double m_driftLengthSigma
Standard deviation by which the drift length should be smeared.
Definition CDCSimpleSimulation.h:191
Belle2::TrackFindingCDC::CDCSimpleSimulation::loadPreparedEvent
std::vector< CDCTrack > loadPreparedEvent()
Fills the wire hits with a hard coded event from the real simulation.
Definition CDCSimpleSimulation.cc:383
Belle2::TrackFindingCDC::CDCSimpleSimulation::m_driftSpeed
double m_driftSpeed
Electron drift speed in the cdc gas.
Definition CDCSimpleSimulation.h:197
Belle2::TrackFindingCDC::CDCSimpleSimulation::createHits
std::vector< SimpleSimHit > createHits(const Helix &globalHelix, double arcLength2DOffset) const
Generate hits for the given helix in starting from the two dimensional arc length.
Definition CDCSimpleSimulation.cc:167
Belle2::TrackFindingCDC::CDCTrack
Class representing a sequence of three dimensional reconstructed hits.
Definition CDCTrack.h:41
Belle2::TrackFindingCDC::CDCTrack::setStartTrajectory3D
void setStartTrajectory3D(const CDCTrajectory3D &startTrajectory3D)
Setter for the two dimensional trajectory.
Definition CDCTrack.h:98
Belle2::TrackFindingCDC::CDCTrack::setEndTrajectory3D
void setEndTrajectory3D(const CDCTrajectory3D &endTrajectory3D)
Setter for the three dimensional trajectory.
Definition CDCTrack.h:105
Belle2::TrackFindingCDC::CDCTrajectory3D
Particle full three dimensional trajectory.
Definition CDCTrajectory3D.h:45
Belle2::TrackFindingCDC::CDCTrajectory3D::getLocalHelix
const UncertainHelix & getLocalHelix() const
Getter for the helix in local coordinates.
Definition CDCTrajectory3D.h:339
Belle2::TrackFindingCDC::CDCTrajectory3D::setLocalOrigin
double setLocalOrigin(const Vector3D &localOrigin)
Setter for the origin of the local coordinate system.
Definition CDCTrajectory3D.cc:366
Belle2::TrackFindingCDC::CDCTrajectory3D::getLocalOrigin
const Vector3D & getLocalOrigin() const
Getter for the origin of the local coordinate system.
Definition CDCTrajectory3D.h:351
Belle2::TrackFindingCDC::CDCWireHit
Class representing a hit wire in the central drift chamber.
Definition CDCWireHit.h:55
Belle2::TrackFindingCDC::CDCWireHit::getRefDriftLength
double getRefDriftLength() const
Getter for the drift length at the reference position of the wire.
Definition CDCWireHit.h:224
Belle2::TrackFindingCDC::CDCWireLayer
Class representing a sense wire layer in the central drift chamber.
Definition CDCWireLayer.h:42
Belle2::TrackFindingCDC::CDCWireTopology
Class representing the sense wire arrangement in the whole of the central drift chamber.
Definition CDCWireTopology.h:44
Belle2::TrackFindingCDC::CDCWireTopology::getWireLayers
const std::vector< Belle2::TrackFindingCDC::CDCWireLayer > & getWireLayers() const
Getter for the underlying storing layer vector.
Definition CDCWireTopology.h:149
Belle2::TrackFindingCDC::CDCWireTopology::getInstance
static CDCWireTopology & getInstance()
Getter for the singleton instance of the wire topology.
Definition CDCWireTopology.cc:20
Belle2::TrackFindingCDC::CDCWireTopology::getOuterCylindricalR
double getOuterCylindricalR() const
Getter for the outer radius of the outer most wire layer.
Definition CDCWireTopology.h:471
Belle2::TrackFindingCDC::CDCWire
Class representing a sense wire in the central drift chamber.
Definition CDCWire.h:58
Belle2::TrackFindingCDC::CDCWire::getDriftLength
double getDriftLength(const Vector3D &pos3D) const
Calculates the straight drift length from the position to the wire This is essentially the same as th...
Definition CDCWire.h:214
Belle2::TrackFindingCDC::CDCWire::getWireID
const WireID & getWireID() const
Getter for the wire id.
Definition CDCWire.h:122
Belle2::TrackFindingCDC::CDCWire::getWirePos2DAtZ
Vector2D getWirePos2DAtZ(const double z) const
Gives the xy projected position of the wire at the given z coordinate.
Definition CDCWire.h:192
Belle2::TrackFindingCDC::CDCWire::getClosest
Vector3D getClosest(const Vector3D &pos3D) const
Calculates the closest approach in the wire to the position.
Definition CDCWire.h:204
Belle2::TrackFindingCDC::CDCWire::getNeighborCCW
MayBePtr< const CDCWire > getNeighborCCW() const
Gives the closest neighbor in the counterclockwise direction - always exists.
Definition CDCWire.cc:159
Belle2::TrackFindingCDC::CDCWire::getNeighborCW
MayBePtr< const CDCWire > getNeighborCW() const
Gives the closest neighbor in the clockwise direction - always exists.
Definition CDCWire.cc:164
Belle2::TrackFindingCDC::CDCWire::getRefPos2D
const Vector2D & getRefPos2D() const
Getter for the wire reference position for 2D tracking Gives the wire's reference position projected ...
Definition CDCWire.h:229
Belle2::TrackFindingCDC::CDCWire::getTanStereoAngle
double getTanStereoAngle() const
Getter for the tangents of the stereo angle of the wire.
Definition CDCWire.h:240
Belle2::TrackFindingCDC::CDCWire::getBackwardZ
double getBackwardZ() const
Getter for the z coordinate at the backward joint points of the wires.
Definition CDCWire.h:280
Belle2::TrackFindingCDC::Helix
Extension of the generalized circle also caching the perigee coordinates.
Definition Helix.h:28
Belle2::TrackFindingCDC::Helix::minimalCylindricalR
double minimalCylindricalR() const
Gives the minimal cylindrical radius the circle reaches (unsigned)
Definition Helix.h:192
Belle2::TrackFindingCDC::Helix::perimeterXY
double perimeterXY() const
Getter for the perimeter of the circle in the xy projection.
Definition Helix.h:271
Belle2::TrackFindingCDC::Helix::arcLength2DToXY
double arcLength2DToXY(const Vector2D &point) const
Calculates the two dimensional arc length that is closest to two dimensional point in the xy projecti...
Definition Helix.h:102
Belle2::TrackFindingCDC::Helix::tanLambda
double tanLambda() const
Getter for the proportinality factor from arc length in xy space to z.
Definition Helix.h:240
Belle2::TrackFindingCDC::Helix::maximalCylindricalR
double maximalCylindricalR() const
Gives the maximal cylindrical radius the circle reaches.
Definition Helix.h:198
Belle2::TrackFindingCDC::Helix::arcLength2DToCylindricalR
double arcLength2DToCylindricalR(double cylindricalR) const
Calculates the two dimensional arc length that first reaches a cylindrical radius on the helix Return...
Definition Helix.h:112
Belle2::TrackFindingCDC::Helix::circleXY
const PerigeeCircle & circleXY() const
Getter for the projection into xy space.
Definition Helix.h:320
Belle2::TrackFindingCDC::Helix::atArcLength2D
Vector3D atArcLength2D(double s) const
Calculates the point, which lies at the give perpendicular travel distance (counted from the perigee)
Definition Helix.h:174
Belle2::TrackFindingCDC::Helix::passiveMoveBy
double passiveMoveBy(const Vector3D &by)
Moves the coordinates system by the given vector.
Definition Helix.h:147
Belle2::TrackFindingCDC::PerigeeCircle::isRightOrLeft
ERightLeft isRightOrLeft(const Vector2D &point) const
Indicates if the point is on the right or left side of the circle.
Definition PerigeeCircle.h:244
Belle2::TrackFindingCDC::Range::size
std::size_t size() const
Returns the total number of objects in this range.
Definition Range.h:76
Belle2::TrackFindingCDC::UncertainHelix
A general helix class including a covariance matrix.
Definition UncertainHelix.h:34
Belle2::TrackFindingCDC::Vector2D
A two dimensional vector which is equipped with functions for correct handling of orientation relate...
Definition Vector2D.h:32
Belle2::TrackFindingCDC::Vector3D
A three dimensional vector.
Definition Vector3D.h:33
Belle2::TrackFindingCDC::Vector3D::z
double z() const
Getter for the z coordinate.
Definition Vector3D.h:496
Belle2::WireID
Class to identify a wire inside the CDC.
Definition WireID.h:34
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17
Belle2::TrackFindingCDC::CDCSimpleSimulation::SimpleSimHit
Structure to accommodate information about the individual hits during the simulation.
Definition CDCSimpleSimulation.h:49
Belle2::TrackFindingCDC::CDCSimpleSimulation::SimpleSimHit::m_pos3D
Vector3D m_pos3D
Memory for the true position on the track closest to the wire.
Definition CDCSimpleSimulation.h:91
Belle2::TrackFindingCDC::CDCSimpleSimulation::SimpleSimHit::m_arcLength2D
double m_arcLength2D
Memory for the true two dimensional arc length on the helix to this hit.
Definition CDCSimpleSimulation.h:94
Belle2::TrackFindingCDC::CDCSimpleSimulation::SimpleSimHit::m_wireHit
CDCWireHit m_wireHit
Memory for the wire hit instance that will be given to the reconstruction.
Definition CDCSimpleSimulation.h:82
Belle2::TrackFindingCDC::CDCSimpleSimulation::SimpleSimHit::m_rlInfo
ERightLeft m_rlInfo
Memory for the true right left passage information.
Definition CDCSimpleSimulation.h:88
Belle2::TrackFindingCDC::CDCSimpleSimulation::SimpleSimHit::m_trueDriftLength
double m_trueDriftLength
Memory for the true drift length from the true position to the wire.
Definition CDCSimpleSimulation.h:97
Belle2::TrackFindingCDC::CDCSimpleSimulation::SimpleSimHit::m_iMCTrack
size_t m_iMCTrack
Memory for the true index of the track this hit is contained in.
Definition CDCSimpleSimulation.h:85