84 {
86 bool hasStations = !inertObjs.empty() || !stations.empty();
87
88
97
99 if (!aLVC.m_adjustStatic || !aLVC.m_static3d) {
100 ATH_MSG_INFO(
" diluted inert material hardcoded for 3D "
101 "volume frame, adjusting setup");
102 aLVC.m_adjustStatic = true;
103 aLVC.m_static3d = true;
104 }
105 }
106
107
110
112
113
114
115
116 aLVC.m_muonMaterial = Trk::Material(10e10, 10e10, 0., 0., 0.);
117
118
119
121
125
127
128
129 unsigned int ii = 0;
130 for (
unsigned int i = 0;
i < envelopeDefsIn.size();
i++) {
131 if (envelopeDefsIn[i].second > envelopeDefsIn[ii].second)
133 else if (envelopeDefsIn[i].second == envelopeDefsIn[ii].second &&
134 envelopeDefsIn[i].first > envelopeDefsIn[ii].first)
136 }
137
138
139 int irot = 1;
140 unsigned int inext = ii + 1;
141 if (inext == envelopeDefsIn.size())
142 inext = 0;
143 if (envelopeDefsIn[inext].second != envelopeDefsIn[ii].second) {
144 irot = -1;
145 inext = ii > 0 ? ii - 1 : envelopeDefsIn.size() - 1;
146 }
147
148
149 if (irot > 0) {
150 for (
unsigned int i = inext;
i < envelopeDefsIn.size();
i++)
151 envelopeDefs.push_back(envelopeDefsIn[i]);
152 if (inext > 0)
153 for (
unsigned int i = 0;
i <= inext - 1;
i++)
154 envelopeDefs.push_back(envelopeDefsIn[i]);
155 } else {
157 while (i >= 0) {
158 envelopeDefs.push_back(envelopeDefsIn[i]);
160 };
161 inext = envelopeDefsIn.size() - 1;
162 while (inext >= ii) {
163 envelopeDefs.push_back(envelopeDefsIn[inext]);
164 inext = inext - 1;
165 };
166 }
167
168
169 double maxR = 0.;
170 for (auto& envelopeDef : envelopeDefs) {
171 if (envelopeDef.first > maxR)
172 maxR = envelopeDef.first;
173 }
174
175 aLVC.m_outerBarrelRadius = maxR;
176 aLVC.m_outerEndcapZ = envelopeDefs[0].second;
177
179 << aLVC.m_outerBarrelRadius << ","
180 << aLVC.m_outerEndcapZ);
181
182
183
184 for (
unsigned int i = 0;
i < envelopeDefs.size();
i++) {
186 << "," << envelopeDefs[i].second);
187 }
188 }
189
191
193 auto globalBounds = std::make_shared<Trk::CylinderVolumeBounds>(aLVC.m_outerBarrelRadius, aLVC.m_outerEndcapZ);
194 auto topVolume = std::make_unique<Trk::TrackingVolume>(nullptr, std::move(globalBounds), aLVC.m_muonMaterial,
195 nullptr, nullptr, "GlobalVolume");
196 return std::make_unique<Trk::TrackingGeometry>(topVolume.release());
197 }
198
200
202
203
204
205 std::vector<TrackingVolumePtr> volumeGarbage{};
206
208 negativeMuonBigWheel{}, negativeMuonOuterBuffer{},
209 positiveMuonOuterWheel{}, negativeMuonSmallWheel{},
210 positiveMuonSmallWheel{}, negativeECT{}, positiveECT{},
211 positiveMuonBigWheel{}, positiveMuonOuterBuffer{};
212
213 TrackingVolumePtr negBeamPipe{}, posBeamPipe{}, negDiskShield{}, posDiskShield{},
214 negInnerShield{}, posInnerShield{}, negOuterShield{}, posOuterShield{};
215
216 std::shared_ptr<Trk::CylinderVolumeBounds> enclosedBounds{};
217
220 negativeMuonInnerEndcap{}, positiveMuonInnerEndcap{},
221 negNavOEndcap{}, posNavOEndcap{}, negativeMuonOuterEndcap{},
222 positiveMuonOuterEndcap{},
barrel{}, negOuterEndcap{},
223 posOuterEndcap{}, negInnerEndcap{}, posInnerEndcap{}, negNavEndcap{},
225
226
227
228 if (tvol) {
229 bool msEntryDefined = false;
231 msEntryDefined = true;
232
234 const auto *enclosedDetectorBounds =
dynamic_cast<const Trk::CylinderVolumeBounds*
>(&(tvol->
volumeBounds()));
235 if (!enclosedDetectorBounds) {
236 ATH_MSG_ERROR(
" dynamic cast of enclosed volume to the cylinder bounds failed, aborting MTG build-up ");
237 return nullptr;
238 }
239 double enclosedDetectorHalfZ = enclosedDetectorBounds->halflengthZ();
240 double enclosedDetectorOuterRadius =
241 enclosedDetectorBounds->outerRadius();
242
247 if (!enclosedCentralFaceVolumes.empty()) {
248 const auto *cylR = dynamic_cast<const Trk::CylinderVolumeBounds*>(&(enclosedCentralFaceVolumes[0]->volumeBounds()));
249 if (cylR && cylR->outerRadius() != enclosedDetectorOuterRadius) {
250 enclosedDetectorOuterRadius = cylR->outerRadius();
252 "correspond to radius of glue volumes : adjusted ");
253 }
254 }
255 if (!enclosedNegativeFaceVolumes.empty() &&
256 !enclosedPositiveFaceVolumes.empty()) {
257 double negZ = -enclosedDetectorHalfZ;
258 double posZ = enclosedDetectorHalfZ;
259 const auto *cylN = dynamic_cast<const Trk::CylinderVolumeBounds*>(&(enclosedNegativeFaceVolumes[0]->volumeBounds()));
260 if (cylN){
261 negZ = enclosedNegativeFaceVolumes[0]->center().z() - cylN->halflengthZ();
262 }
263 const auto *cylP =dynamic_cast<const Trk::CylinderVolumeBounds*>(&(enclosedPositiveFaceVolumes[0]->volumeBounds()));
264 if (cylP) {
265 posZ = enclosedPositiveFaceVolumes[0]->center().z() +
266 cylP->halflengthZ();
267 }
268 if (std::abs(negZ + enclosedDetectorHalfZ) > 0.001 ||
269 std::abs(posZ - enclosedDetectorHalfZ) > 0.001) {
270 ATH_MSG_WARNING(
" enclosed volume envelope z dimension does not correspond to that of glue volumes ");
271 if (std::abs(negZ + posZ) < 0.001) {
272 enclosedDetectorHalfZ =
posZ;
274 } else {
275 ATH_MSG_ERROR(
"assymetric Z dimensions - cannot recover " << negZ <<
"," << posZ);
276 return nullptr;
277 }
278 }
279 }
280
281
282
283 ATH_MSG_DEBUG(
" dimensions of enclosed detectors (halfZ,outerR):"
284 << enclosedDetectorHalfZ << ","<< enclosedDetectorOuterRadius);
285
286
287 if (enclosedDetectorOuterRadius > aLVC.m_innerBarrelRadius) {
289 "muon envelope, abandon :R:"
290 << enclosedDetectorOuterRadius);
291 return nullptr;
292 }
293 aLVC.m_innerBarrelRadius = enclosedDetectorOuterRadius;
294
295
298 <<"muon envelope, abandon :Z:"<< enclosedDetectorHalfZ);
299 return nullptr;
300 } else {
302 auto barrelZPBounds = std::make_shared<Trk::CylinderVolumeBounds>(aLVC.m_innerBarrelRadius,
303 0.5 * (
m_barrelZ - enclosedDetectorHalfZ));
304 auto barrelZMBounds = std::make_shared<Trk::CylinderVolumeBounds>(aLVC.m_innerBarrelRadius,
305 0.5 * (
m_barrelZ - enclosedDetectorHalfZ));
306 double zbShift = 0.5 * (
m_barrelZ + enclosedDetectorHalfZ);
307
309 std::move(barrelZPBounds), aLVC.m_muonMaterial, nullptr,
310 nullptr, "BarrelRZPosBuffer");
312 std::move(barrelZMBounds), aLVC.m_muonMaterial, nullptr,
313 nullptr, "BarrelRZNegBuffer");
314
318 std::move(barrelZPBuffer),
320
321 std::string nameEncl = msEntryDefined ?
"All::Gaps::Barrel" :
m_entryVolume.value();
325 std::move(barrelZMBuffer),
327 nameEncl);
328
329 } else{
332 }
333 }
334
335 } else {
338
339
341 << " m_enclosingEnvelopeSvc "
343 double rmax = 0.;
345 for (const auto& envelopeDef : envelopeDefs) {
346 rmax = std::max(envelopeDef.first, rmax);
347 zmax = std::max(std::abs(envelopeDef.second), zmax);
348 }
349 if (!envelopeDefs.empty()) {
350 if (rmax > 0. && rmax <= aLVC.m_innerBarrelRadius &&
352 enclosedBounds = std::make_unique<Trk::CylinderVolumeBounds>(rmax, zmax);
353 } else {
354 ATH_MSG_DEBUG(
" input MSEntrance size (R,Z:"<< rmax <<
"," << zmax
355 << ") clashes with MS material, switch to default values (R,Z:"
356 << aLVC.m_innerBarrelRadius <<
"," <<
m_barrelZ <<
")");
357 }
358 }
359 }
360
361 if (!enclosedBounds) {
362 enclosedBounds = std::make_shared<Trk::CylinderVolumeBounds>(aLVC.m_innerBarrelRadius,
m_barrelZ);
363 }
364 {
365 enclosed = std::make_unique<Trk::TrackingVolume>(
nullptr, std::move(enclosedBounds),
366 aLVC.m_muonMaterial, nullptr,
369 }
371 }
372
373
374
375 for (auto& envelopeDef : envelopeDefs) {
376
377
378 if (!aLVC.m_msCutoutsIn.empty() &&
379 aLVC.m_msCutoutsIn.back().second == -aLVC.m_outerEndcapZ)
380 break;
381 if (aLVC.m_msCutoutsIn.empty() ||
382 std::abs(aLVC.m_msCutoutsIn.back().second) >
m_barrelZ ||
383 std::abs(envelopeDef.second) >
m_barrelZ)
384 aLVC.m_msCutoutsIn.push_back(envelopeDef);
385 else if (!aLVC.m_msCutoutsIn.empty() &&
386 aLVC.m_msCutoutsIn.back().second ==
m_barrelZ &&
387 aLVC.m_msCutoutsIn.back().first != aLVC.m_innerBarrelRadius) {
388 aLVC.m_msCutoutsIn.emplace_back(aLVC.m_innerBarrelRadius,
390 aLVC.m_msCutoutsIn.emplace_back(aLVC.m_innerBarrelRadius,
392 aLVC.m_msCutoutsIn.emplace_back(
393 aLVC.m_msCutoutsIn[aLVC.m_msCutoutsIn.size() - 3].first,
395 }
396 }
397
399 while (envelopeDefs[il - 1].second != -aLVC.m_outerEndcapZ)
401 for (;
il < envelopeDefs.size();
il++)
402 aLVC.m_msCutoutsOut.push_back(envelopeDefs[il]);
403
404 for (
unsigned int i = 0;
i < aLVC.m_msCutoutsIn.size();
i++) {
406 << i << ":" << aLVC.m_msCutoutsIn[i].first << ","
407 << aLVC.m_msCutoutsIn[i].second);
408 }
409 for (
unsigned int i = 0;
i < aLVC.m_msCutoutsOut.size();
i++) {
411 << i << ":" << aLVC.m_msCutoutsOut[i].first << ","
412 << aLVC.m_msCutoutsOut[i].second);
413 }
414
415 if (aLVC.m_msCutoutsIn[5].second != aLVC.m_innerEndcapZ) {
416 aLVC.m_innerEndcapZ = aLVC.m_msCutoutsIn[5].second;
417 }
419
420
421
423
424 auto negDiskShieldBounds = std::make_shared<Trk::CylinderVolumeBounds>(aLVC.m_innerBarrelRadius,
427 std::move(negDiskShieldBounds));
428 negDiskShield =
processShield(negDiskVol, 2,
"Muons::Detectors::NegativeDiskShield",
429 aLVC, hasStations);
430
431 auto posDiskShieldBounds = std::make_shared<Trk::CylinderVolumeBounds>(aLVC.m_innerBarrelRadius,
434 std::move(posDiskShieldBounds));
435 posDiskShield =
processShield(posDiskVol, 2,
"Muons::Detectors::PositiveDiskShield",
436 aLVC, hasStations);
437
441 std::move(posDiskShield),
443 "Container::CentralP");
446 std::move(negDiskShield),
448 "Container::Central");
449
450 if (aLVC.m_adjustStatic) {
453 }
454
455
456 auto barrelBounds = std::make_shared<Trk::CylinderVolumeBounds>(aLVC.m_innerBarrelRadius,
457 aLVC.m_outerBarrelRadius,
459 Trk::Volume barrelVol(nullptr, std::move(barrelBounds));
460
461
462 if (aLVC.m_adjustStatic && aLVC.m_static3d)
463 muonBarrel =
processVolume(barrelVol, 0,
"Detectors::Barrel",
464 aLVC, hasStations);
465 else if (aLVC.m_adjustStatic)
466 muonBarrel =
processVolume(barrelVol, -1,
"Detectors::Barrel",
467 aLVC, hasStations);
468 else
470 "Detectors::Barrel", aLVC, hasStations);
471
472
473
475 auto negativeSmallWheelBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_innerShieldRadius,
476 aLVC.m_outerBarrelRadius,
477 smallWheelZHalfSize);
478
480 std::move(negativeSmallWheelBounds));
481 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
482 negativeMuonSmallWheel =
processVolume(negSWVol, 1,
"Detectors::NegativeSmallWheel",
483 aLVC, hasStations);
484 } else if (aLVC.m_adjustStatic) {
485 negativeMuonSmallWheel =
processVolume(negSWVol, -1,
"Detectors::NegativeSmallWheel",
486 aLVC, hasStations);
487 } else {
491 "Detectors::NegativeSmallWheel",
492 aLVC, hasStations);
493 }
494
496 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
497 positiveMuonSmallWheel =
processVolume(posSWVol, 1,
"Detectors::PositiveSmallWheel",
498 aLVC, hasStations);
499 } else if (aLVC.m_adjustStatic) {
500 positiveMuonSmallWheel =
processVolume(posSWVol, -1,
"Detectors::PositiveSmallWheel",
501 aLVC, hasStations);
502 } else {
505 aLVC, hasStations);
506 }
507
508
509 double ectZHalfSize = 0.5 * (aLVC.m_innerEndcapZ -
m_ectZ);
510
512 aLVC.m_outerBarrelRadius,
513 ectZHalfSize);
514
516 std::move(negativeECTBounds));
517 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
518 negativeECT =
processVolume(negECTVol, 2,
"Detectors::NegativeECT",
519 aLVC, hasStations);
520 } else if (aLVC.m_adjustStatic) {
521 negativeECT =
processVolume(negECTVol, -1,
"Detectors::NegativeECT",
522 aLVC, hasStations);
523 } else {
525 "Detectors::NegativeECT", aLVC, hasStations);
526 }
527
528
529 Trk::Volume posECTVol(negECTVol,
532 positiveECT =
processVolume(posECTVol, 2,
"Detectors::PositiveECT",
533 aLVC, hasStations);
534 } else if (aLVC.m_adjustStatic) {
535 positiveECT =
processVolume(posECTVol, -1,
"Detectors::PositiveECT",
536 aLVC, hasStations);
537 } else {
540 aLVC, hasStations);
541 }
542
543
546 std::move(negativeMuonSmallWheel),
548 "Container::NegInnerEndcap"));
549 positiveMuonInnerEndcap = (
m_trackingVolumeHelper->glueTrackingVolumeArrays(std::move(positiveMuonSmallWheel),
551 std::move(positiveECT),
553 "Container::PosInnerEndcap"));
554
555
556 double innerEndcapZHalfSize = 0.5 * (aLVC.m_innerEndcapZ -
m_diskShieldZ);
557 auto negInnerShieldBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_beamPipeRadius,
559 innerEndcapZHalfSize);
561 std::move(negInnerShieldBounds)};
562 negInnerShield =
processShield(negisVol, 1,
"Muons::Detectors::NegativeInnerShield",
563 aLVC, hasStations);
564
565 auto posInnerShieldBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_beamPipeRadius,
567 innerEndcapZHalfSize);
569 std::move(posInnerShieldBounds));
570 posInnerShield =
processShield(posisVol, 1,
"Muons::Detectors::PositiveInnerShield",
571 aLVC, hasStations);
572
573
574
575
576 double outerWheelZHalfSize = 0.5 * (aLVC.m_outerEndcapZ -
m_outerWheel);
577 auto negativeOuterWheelBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_outerShieldRadius,
578 aLVC.m_outerBarrelRadius,
579 outerWheelZHalfSize);
581 outerWheelZHalfSize)),
582 std::move(negativeOuterWheelBounds));
583 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
584 negativeMuonOuterWheel =
processVolume(negOWVol, 3,
"Detectors::NegativeOuterWheel",
585 aLVC, hasStations);
586 } else if (aLVC.m_adjustStatic) {
587 negativeMuonOuterWheel =
processVolume(negOWVol, -1,
"Detectors::NegativeOuterWheel",
588 aLVC, hasStations);
589 } else {
592 aLVC, hasStations);
593 }
594
595 Trk::Volume posOWVol(negOWVol,
597
598 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
599 positiveMuonOuterWheel =
processVolume(posOWVol, 3,
"Detectors::PositiveOuterWheel",
600 aLVC, hasStations);
601 } else if (aLVC.m_adjustStatic) {
602 positiveMuonOuterWheel =
processVolume(posOWVol, -1,
"Detectors::PositiveOuterWheel",
603 aLVC, hasStations);
604 } else {
607 aLVC, hasStations);
608 }
609
611 auto negativeOuterBufferBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_outerShieldRadius,
612 aLVC.m_outerBarrelRadius,
613 outerBufferZHalfSize);
614
616 outerBufferZHalfSize)),
617 std::move(negativeOuterBufferBounds));
618 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
619 negativeMuonOuterBuffer =
processVolume(negBuffVol, 3,
"Detectors::NegativeOuterBuffer",
620 aLVC, hasStations);
621 } else if (aLVC.m_adjustStatic) {
622 negativeMuonOuterBuffer =
processVolume(negBuffVol, -1,
"Detectors::NegativeOuterBuffer",
623 aLVC, hasStations);
624 } else {
627 aLVC, hasStations);
628 }
629
631 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
632 positiveMuonOuterBuffer =
processVolume(posBuffVol, 3,
"Detectors::PositiveOuterBuffer",
633 aLVC, hasStations);
634 } else if (aLVC.m_adjustStatic) {
635 positiveMuonOuterBuffer =
processVolume(posBuffVol, -1,
"Detectors::PositiveOuterBuffer",
636 aLVC, hasStations);
637 } else {
640 aLVC, hasStations);
641 }
642
643 double bigWheelZHalfSize = 0.5 * (
m_bigWheel - aLVC.m_innerEndcapZ);
644 auto negativeBigWheelBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_outerShieldRadius,
645 aLVC.m_outerBarrelRadius,
646 bigWheelZHalfSize);
647
649 bigWheelZHalfSize)),
650 std::move(negativeBigWheelBounds));
651 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
652 negativeMuonBigWheel =
processVolume(negBWVol, 3,
"Detectors::NegativeBigWheel",
653 aLVC, hasStations);
654 } else if (aLVC.m_adjustStatic) {
655 negativeMuonBigWheel =
processVolume(negBWVol, -1,
"Detectors::NegativeBigWheel",
656 aLVC, hasStations);
657 } else {
660 aLVC, hasStations);
661 }
662
663 Trk::Volume posBWVol(negBWVol,
665 if (aLVC.m_adjustStatic && aLVC.m_static3d) {
666 positiveMuonBigWheel =
processVolume(posBWVol, 3,
"Detectors::PositiveBigWheel",
667 aLVC, hasStations);
668 } else if (aLVC.m_adjustStatic) {
669 positiveMuonBigWheel =
processVolume(posBWVol, -1,
"Detectors::PositiveBigWheel",
670 aLVC, hasStations);
671 } else {
674 aLVC, hasStations);
675 }
676
679 std::move(negativeMuonOuterBuffer),
681 "Container::NegOEndcap");
682
685 std::move(positiveMuonOuterWheel),
687 "Container::PosOEndcap");
688
689
692 std::move(negativeMuonBigWheel),
694 "Container::NegOuterEndcap");
695
696 positiveMuonOuterEndcap =
m_trackingVolumeHelper->glueTrackingVolumeArrays(std::move(positiveMuonBigWheel),
698 std::move(posNavOEndcap),
700 "Container::PosOuterEndcap");
701
702
703 double outerEndcapZHalfSize = 0.5 * (aLVC.m_outerEndcapZ - aLVC.m_innerEndcapZ);
704 double outerEndcapPosition = 0.5 * (aLVC.m_outerEndcapZ + aLVC.m_innerEndcapZ);
705 auto negOuterShieldBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_beamPipeRadius,
707 outerEndcapZHalfSize);
709 std::move(negOuterShieldBounds));
710 negOuterShield =
processShield(negosVol, 0,
"Muons::Detectors::NegativeOuterShield",
711 aLVC, hasStations);
712
713 auto posOuterShieldBounds = std::make_shared<Trk::CylinderVolumeBounds>(
716 std::move(posOuterShieldBounds));
717 posOuterShield =
processShield(pososVol, 0,
"Muons::Detectors::PositiveOuterShield",
718 aLVC, hasStations);
719
720
721 auto negBeamPipeBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_beamPipeRadius,
722 outerEndcapZHalfSize + innerEndcapZHalfSize);
723 auto posBeamPipeBounds = std::make_shared<Trk::CylinderVolumeBounds>(
m_beamPipeRadius,
724 outerEndcapZHalfSize + innerEndcapZHalfSize);
726 std::move(negBeamPipeBounds));
727 negBeamPipe =
processVolume(negbpVol, 1, 1,
"Muons::Gaps::NegativeBeamPipe",
728 aLVC, hasStations);
730 std::move(posBeamPipeBounds));
731 posBeamPipe =
processVolume(posbpVol, 1, 1,
"Muons::Gaps::PositiveBeamPipe",
732 aLVC, hasStations);
733
734 negBeamPipe->registerColorCode(0);
735 posBeamPipe->registerColorCode(0);
736
738
739
740
741
745 std::move(central),
747 "All::Container::Barrel");
748
752 std::move(negOuterShield),
754 "Container::NegativeOuterEndcap");
755
758 std::move(posOuterShield),
760 "Container::PositiveOuterEndcap");
761
762
766 std::move(negInnerShield),
768 "Container::NegativeInnerEndcap");
769
772 std::move(posInnerShield),
774 "Container::PositiveInnerEndcap");
775
776
780 std::move(negInnerEndcap),
782 "Container::NegativeEndcap");
783
786 std::move(posOuterEndcap),
788 "Container::PositiveEndcap");
789
790
794 std::move(negBeamPipe),
796 "All::Container::NegativeEndcap"));
799 std::move(posBeamPipe),
801 "All::Container::PositiveEndcap"));
802
803
804
806
811 "All::Container::NegDet");
814 std::move(negDet),
817
820
821
823
824
825 trackingGeometry->addToGarbage(std::move(stations));
826 trackingGeometry->addToGarbage(std::move(inertObjs));
827
828 volumeGarbage.push_back(std::move(negativeMuonOuterWheel));
829 volumeGarbage.push_back(std::move(negativeMuonBigWheel));
830 volumeGarbage.push_back(std::move(negativeMuonOuterBuffer));
831 volumeGarbage.push_back(std::move(positiveMuonOuterWheel));
832
833 volumeGarbage.push_back(std::move(negativeMuonSmallWheel));
834 volumeGarbage.push_back(std::move(positiveMuonSmallWheel));
835 volumeGarbage.push_back(std::move(negativeECT));
836 volumeGarbage.push_back(std::move(positiveECT));
837 volumeGarbage.push_back(std::move(positiveMuonBigWheel));
838
839 volumeGarbage.push_back(std::move(positiveMuonOuterBuffer));
840 volumeGarbage.push_back(std::move(negDiskShield));
841 volumeGarbage.push_back(std::move(posDiskShield));
842
843 trackingGeometry->addToGarbage(std::move(volumeGarbage));
845 ATH_MSG_DEBUG(
" with " << aLVC.m_frameNum <<
" subvolumes at navigation level");
846 ATH_MSG_DEBUG(
"( mean number of enclosed detached volumes:" <<
float(aLVC.m_frameStat) / aLVC.m_frameNum <<
")");
847 return trackingGeometry;
848}
std::vector< RZPair > RZPairVector
Gaudi::Property< bool > m_static3d
VolumeSpanArray findVolumesSpan(const DetachedVolVec &objs, double zTol, double phiTol, const LocalVariablesContainer &aLVC) const
Private method to filter detached volumes in z span.
Gaudi::Property< std::string > m_exitVolume
Gaudi::Property< bool > m_adjustStatic
Gaudi::Property< double > m_outerEndcapZ
Gaudi::Property< std::string > m_entryVolume
void getHParts(LocalVariablesContainer &aLVC) const
Private method to retrieve h partition.
static void getShieldParts(LocalVariablesContainer &aLVC)
Private method to retrieve shield partition.
Gaudi::Property< bool > m_muonSimple
TrackingVolumePtr processVolume(const Trk::Volume &, int, int, const std::string &, LocalVariablesContainer &aLVC, bool hasStations) const
Private methods to define subvolumes and fill them with detached volumes.
Gaudi::Property< double > m_alignTolerance
Gaudi::Property< int > m_outerEndcapEtaPartition
Gaudi::Property< double > m_outerBarrelRadius
maximal extend in z of the muon barrel
Gaudi::Property< int > m_innerEndcapEtaPartition
Gaudi::Property< int > m_barrelEtaPartition
void blendMaterial(LocalVariablesContainer &aLVC) const
Private method to blend the inert material.
Gaudi::Property< double > m_innerEndcapZ
maximal extend in z of the outer part of muon endcap
void getZParts(LocalVariablesContainer &aLVC) const
Private method to retrieve z partition.
Gaudi::Property< double > m_innerBarrelRadius
< minimal extend in radial dimension of the muon barrel
TrackingVolumePtr processShield(const Trk::Volume &, int, const std::string &, LocalVariablesContainer &aLVC, bool hasStations) const
Gaudi::Property< bool > m_muonInert
const std::vector< TrackingVolume * > & glueVolumes(BoundarySurfaceFace)
retrieve them again
const std::string & volumeName() const
Returns the VolumeName - for debug reason, might be depreciated later.
GlueVolumesDescriptor & glueVolumesDescriptor()
Private struct to contain local variables we dont want to be global in this class.
double m_innerBarrelRadius
1.14.0