TrackingGeometry Interface method.
87 double enclosedInnerSectorHalflength = 0.;
88 double enclosedInnerSectorRadius = 0.;
98 if (!innerDetectorBounds)
101 enclosedInnerSectorHalflength = innerDetectorBounds->
halflengthZ();
102 enclosedInnerSectorRadius = innerDetectorBounds->
outerRadius();
104 keyDim.emplace_back(enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
112 for (
unsigned int i = 0;
i < envelopeDefsIn.size();
i++) {
115 else if (envelopeDefsIn[
i].
second == envelopeDefsIn[ii].
second &&
116 envelopeDefsIn[
i].
first > envelopeDefsIn[ii].
first)
122 unsigned int inext = ii + 1;
123 if (inext == envelopeDefsIn.size())
125 if (envelopeDefsIn[inext].
second != envelopeDefsIn[ii].
second) {
127 inext = ii > 0 ? ii - 1 : envelopeDefsIn.size() - 1;
133 for (
unsigned int i = inext;
i < envelopeDefsIn.size();
i++)
134 envelopeDefs.push_back(envelopeDefsIn[
i]);
136 for (
unsigned int i = 0;
i <= inext - 1;
i++)
137 envelopeDefs.push_back(envelopeDefsIn[
i]);
141 envelopeDefs.push_back(envelopeDefsIn[
i]);
144 inext = envelopeDefsIn.size() - 1;
145 while (inext >= ii) {
146 envelopeDefs.push_back(envelopeDefsIn[inext]);
155 for (
unsigned int i = 0;
i < envelopeDefs.size();
i++) {
158 if (std::abs(envelopeDefs[
i].
second) < envEnclosingVolumeHalfZ)
159 envEnclosingVolumeHalfZ = std::abs(envelopeDefs[
i].
second);
161 if (envelopeDefs[
i].
first > 1100. && envelopeDefs[
i].
first < 1200. &&
164 if (enclosedInnerSectorRadius != envelopeDefs[
i].
first)
166 "Enclosed ID volume radius does not match ID envelope, adjusting "
168 envEnclosingVolumeHalfZ = envelopeDefs[
i].second;
170 enclosedInnerSectorRadius = envelopeDefs[
i].first;
171 enclosedInnerSectorHalflength = envelopeDefs[
i].second;
177 if (envelopeDefs[
i].
second > 0. && envelopeDefs[
i].
second < 6785. &&
178 (envelopeDefs[
i].
first > 1200. ||
179 envelopeDefs[
i].
second > envEnclosingVolumeHalfZ)) {
180 if (msCutouts.empty())
181 msCutouts.push_back(envelopeDefs[
i]);
184 while (envIter != msCutouts.end() &&
185 (*envIter).second < envelopeDefs[
i].second)
187 while (envIter != msCutouts.end() &&
188 (*envIter).second == envelopeDefs[
i].second &&
189 (*envIter).first > envelopeDefs[
i].first)
191 msCutouts.insert(envIter, envelopeDefs[
i]);
197 for (
unsigned int i = 0;
i < msCutouts.size();
i++)
199 <<
i <<
":" << msCutouts[
i].
first <<
","
207 if (!msCutouts.empty()) {
208 caloDefaultRadius = msCutouts[0].first;
209 caloDefaultHalflengthZ = msCutouts[0].second;
211 " Calo central cylinder dimensions adjusted using EnvelopeSvc:"
218 auto idBounds = std::make_shared<Trk::CylinderVolumeBounds>(
219 enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
221 auto idTr = std::make_unique<Amg::Transform3D>(Trk::s_idTransform);
225 nullptr,
"Calo::GapVolumes::DummyID");
227 keyDim.emplace_back(enclosedInnerSectorRadius, enclosedInnerSectorHalflength);
235 for (
unsigned int i = 0;
i < bpDefs.size();
i++) {
241 bpDefs[
i].
second >= envEnclosingVolumeHalfZ &&
242 bpDefs[
i].
second <= msCutouts.back().second) {
243 bpCutouts.push_back(bpDefs[
i]);
246 keyDim.push_back(bpDefs[
i]);
253 if (bpCutouts.size() > 1 &&
254 bpCutouts.back().second == bpCutouts[bpCutouts.size() - 2].second)
255 bpCutouts.erase(bpCutouts.end() - 1);
257 for (
unsigned int i = 0;
i < bpCutouts.size();
i++)
259 <<
i <<
":" << bpCutouts[
i].
first <<
","
262 keyDim.emplace_back(caloDefaultRadius, caloDefaultHalflengthZ);
271 const std::vector<Trk::TrackingVolume*> lArVolumes =
301 std::vector<Trk::TrackingVolume*> tileVolumes =
308 "--------------- detailed output "
309 "---------------------------------------------------------- ");
310 auto tileVolIter = tileVolumes.begin();
311 auto tileVolIterEnd = tileVolumes.end();
312 for (; tileVolIter != tileVolIterEnd;
326 double rTileMin = ebBounds ? ebBounds->
innerRadius() : 2288.;
327 double zTileMin = ebBounds ? tilePositiveExtendedBarrel->
center().z() -
331 keyDim.emplace_back(rTileMin, zTileMin);
332 for (
unsigned int i = 0;
i < keyDim.size();
i++) {
341 if (!solenoidBounds){
347 if (!lArBarrelBounds){
353 if (!lArPositiveEndcapBounds){
359 if (!lArNegativeEndcapBounds){
365 if (!lArPositiveHecBounds){
371 if (!lArPositiveFcalBounds){
377 if (!lArNegativeFcalBounds){
383 if (!tileCombinedBounds){
403 double caloPositiveOuterBoundary = tileCombinedBounds->
halflengthZ();
405 double lArPositiveOuterBoundary = lArPositiveFcal->
center().z();
406 lArPositiveOuterBoundary += lArPositiveFcalBounds->
halflengthZ();
414 float caloVolsOuterRadius = tileCombinedBounds->
outerRadius();
415 float caloVolsExtendZ = caloPositiveOuterBoundary;
424 float rInnerGapBP = 0.;
425 std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> innerGapBP =
427 bpCutouts, keyDim[0].
second,
429 keyDim.back().second,
"InnerGap", rInnerGapBP);
431 double z = 0.5 * (keyDim.back().second + keyDim[0].second);
433 auto mbtsNegLayers = std::make_unique<std::vector<Trk::Layer*>>();
434 auto mbtsPosLayers = std::make_unique<std::vector<Trk::Layer*>>();
436 if (lArPositiveMBTS && lArNegativeMBTS) {
445 auto dibo = std::make_shared<Trk::DiscBounds>(rmin, rmax);
459 mbtsPosZpos, std::make_shared<Trk::DiscBounds>(*dibo),
465 mbtsNegLayers->push_back(mbtsNegLayer);
466 mbtsPosLayers->push_back(mbtsPosLayer);
471 auto lArG1Bounds = std::make_shared<Trk::CylinderVolumeBounds>(
474 keyDim[0].
first, 0.5 * (keyDim.back().second - keyDim[0].second));
479 std::move(lArG1P), std::make_shared<Trk::CylinderVolumeBounds>(*lArG1Bounds),
480 lArSectorInnerGapMaterial, std::move(mbtsPosLayers),
481 "Calo::GapVolumes::LAr::PositiveSectorInnerGap");
487 std::move(lArG1Bounds),
488 lArSectorInnerGapMaterial,
489 std::move(mbtsNegLayers),
"Calo::GapVolumes::LAr::NegativeSectorInnerGap");
493 if (innerGapBP.first) {
494 std::vector<Trk::TrackingVolume*> volsInnerGap;
495 volsInnerGap.push_back(innerGapBP.first);
496 volsInnerGap.push_back(lArPositiveSectorInnerGap);
498 volsInnerGap,
m_caloMaterial,
"Calo::Container::PositiveInnerGap");
500 positiveInnerGap = lArPositiveSectorInnerGap;
503 if (innerGapBP.second) {
504 std::vector<Trk::TrackingVolume*> volsInnerGap;
505 volsInnerGap.push_back(innerGapBP.second);
506 volsInnerGap.push_back(lArNegativeSectorInnerGap);
508 volsInnerGap,
m_caloMaterial,
"Calo::Container::NegativeInnerGap");
510 negativeInnerGap = lArNegativeSectorInnerGap;
513 std::vector<Trk::TrackingVolume*> inBufferVolumes;
514 inBufferVolumes.push_back(negativeInnerGap);
515 inBufferVolumes.push_back(innerVol);
516 inBufferVolumes.push_back(positiveInnerGap);
521 "Calo::Container::EnclosedInnerDetector");
528 float rEndcapBP = 0.;
529 std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> endcapBP =
531 lArPositiveEndcap->
center().z() +
533 "Endcap", rEndcapBP);
547 auto ecpPos = std::make_unique<Amg::Transform3D>(lArPosECPresampler->
transform());
548 auto ecpNeg = std::make_unique<Amg::Transform3D>(lArNegECPresampler->
transform());
550 auto ecpUpBounds = std::make_shared<Trk::CylinderVolumeBounds>(ecpRmax, keyDim.back().first, ecpHz);
551 auto ecpDownBounds = std::make_shared<Trk::CylinderVolumeBounds>(rEndcapBP, ecpRmin, ecpHz);
554 std::make_unique<Amg::Transform3D>(*ecpPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpUpBounds),
555 m_Al,
nullptr,
nullptr,
556 "Calo::GapVolumes::LAr::PositiveECPresamplerCover");
558 std::make_unique<Amg::Transform3D>(*ecpNeg),
559 std::move(ecpUpBounds),
m_Al,
nullptr,
nullptr,
560 "Calo::GapVolumes::LAr::NegativeECPresamplerCover");
562 std::move(ecpPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpDownBounds),
564 nullptr,
"Calo::GapVolumes::LAr::PositiveECPresamplerInner");
567 std::move(ecpDownBounds),
569 nullptr,
"Calo::GapVolumes::LAr::NegativeECPresamplerInner");
572 std::vector<Trk::TrackingVolume*> volsECP;
573 volsECP.push_back(ecPresamplerInnerPos);
574 volsECP.push_back(lArPosECPresampler);
575 volsECP.push_back(ecPresamplerCoverPos);
578 volsECP,
m_caloMaterial,
"Calo::Container::PositiveECPresamplerR");
579 std::vector<Trk::TrackingVolume*> volsECN;
580 volsECN.push_back(ecPresamplerInnerNeg);
581 volsECN.push_back(lArNegECPresampler);
582 volsECN.push_back(ecPresamplerCoverNeg);
585 volsECN,
m_caloMaterial,
"Calo::Container::NegativeECPresamplerR");
588 z = lArPosECPresampler->
center().z() - ecpHz;
589 float z1 = lArPosECPresampler->
center().z() + ecpHz;
599 auto ecpIBounds = std::make_shared<Trk::CylinderVolumeBounds>(
600 rEndcapBP, keyDim.back().first, 0.5 * (
z - keyDim.back().second));
602 auto ecOPos = std::make_unique<Amg::Transform3D>(
605 auto ecONeg = std::make_unique<Amg::Transform3D>(
608 auto ecpOBounds = std::make_shared<Trk::CylinderVolumeBounds>(
609 rEndcapBP, keyDim.back().first, 0.5 * (z2 - z1));
612 std::move(ecIPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpIBounds),
613 m_Ar,
nullptr,
nullptr,
614 "Calo::GapVolumes::LAr::PositiveECPresamplerIn");
616 std::move(ecINeg), std::move(ecpIBounds),
617 m_Ar,
nullptr,
nullptr,
618 "Calo::GapVolumes::LAr::NegativeECPresamplerIn");
620 std::move(ecOPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecpOBounds),
621 m_Ar,
nullptr,
nullptr,
622 "Calo::GapVolumes::LAr::PositiveECPresamplerOut");
624 std::move(ecONeg), std::move(ecpOBounds),
625 m_Ar,
nullptr,
nullptr,
626 "Calo::GapVolumes::LAr::NegativeECPresamplerOut");
629 std::vector<Trk::TrackingVolume*> volECP;
630 volECP.push_back(ecPresamplerInPos);
631 volECP.push_back(positiveECP);
632 volECP.push_back(ecPresamplerOutPos);
636 std::vector<Trk::TrackingVolume*> volECN;
637 volECN.push_back(ecPresamplerOutNeg);
638 volECN.push_back(negativeECP);
639 volECN.push_back(ecPresamplerInNeg);
650 std::make_unique<Amg::Transform3D>(lArPositiveEndcap->
transform());
652 std::make_unique<Amg::Transform3D>(lArNegativeEndcap->
transform());
655 std::make_shared<Trk::CylinderVolumeBounds>(ecpRmax, keyDim.back().first, ecpHz);
657 std::make_shared<Trk::CylinderVolumeBounds>(rEndcapBP, ecpRmin, ecpHz);
660 std::make_unique<Amg::Transform3D>(*ecPos),
661 std::make_shared<Trk::CylinderVolumeBounds>(*ecUpBounds),
662 m_Ar,
nullptr,
nullptr,
663 "Calo::GapVolumes::LAr::PositiveEndcapCover");
665 std::make_unique<Amg::Transform3D>(*ecNeg),
666 std::move(ecUpBounds),
667 m_Ar,
nullptr,
nullptr,
668 "Calo::GapVolumes::LAr::NegativeEndcapCover");
670 std::move(ecPos), std::make_shared<Trk::CylinderVolumeBounds>(*ecDownBounds),
672 nullptr,
"Calo::GapVolumes::LAr::PositiveEndcapInner");
675 std::move(ecDownBounds),
677 nullptr,
"Calo::GapVolumes::LAr::NegativeEndcapInner");
680 std::vector<Trk::TrackingVolume*> volsEC;
681 volsEC.push_back(ecInnerPos);
682 volsEC.push_back(lArPositiveEndcap);
683 volsEC.push_back(ecCoverPos);
687 std::vector<Trk::TrackingVolume*> volsEN;
688 volsEN.push_back(ecInnerNeg);
689 volsEN.push_back(lArNegativeEndcap);
690 volsEN.push_back(ecCoverNeg);
696 std::vector<Trk::TrackingVolume*> volEEP;
697 volEEP.push_back(positiveEP);
698 volEEP.push_back(positiveEC);
702 std::vector<Trk::TrackingVolume*> volEEN;
703 volEEN.push_back(negativeEC);
704 volEEN.push_back(negativeEP);
711 std::vector<Trk::TrackingVolume*> volsEndcapPos;
713 volsEndcapPos.push_back(endcapBP.first);
714 volsEndcapPos.push_back(positiveEEP);
716 std::unique_ptr<Trk::TrackingVolume> positiveEndcap(
718 volsEndcapPos,
m_caloMaterial,
"Calo::Container::PositiveEndcap"));
720 std::vector<Trk::TrackingVolume*> volsEndcapNeg;
722 volsEndcapNeg.push_back(endcapBP.second);
723 volsEndcapNeg.push_back(negativeEEP);
725 std::unique_ptr<Trk::TrackingVolume> negativeEndcap(
727 volsEndcapNeg,
m_caloMaterial,
"Calo::Container::NegativeEndcap"));
733 std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> hecBP =
744 auto lArHecInnerGapBounds =
745 std::make_shared<Trk::CylinderVolumeBounds>(rHecBP, lArPositiveHecBounds->
innerRadius(),
748 auto lArHecPos = std::make_unique<Amg::Transform3D>(
750 auto lArHecNeg = std::make_unique<Amg::Transform3D>(
754 std::make_unique<Amg::Transform3D>(*lArHecPos),
755 lArHecInnerGapBounds,
m_Al,
nullptr,
nullptr,
756 "Calo::GapVolumes::LAr::PositiveHecInnerGap");
759 std::make_unique<Amg::Transform3D>(*lArHecNeg),
760 std::make_shared<Trk::CylinderVolumeBounds>(*lArHecInnerGapBounds),
761 m_Al,
nullptr,
nullptr,
762 "Calo::GapVolumes::LAr::NegativeHecInnerGap");
764 auto lArHecOuterGapBounds =
765 std::make_shared<Trk::CylinderVolumeBounds>(lArPositiveHecBounds->
outerRadius(),
770 std::move(lArHecPos), std::make_shared<Trk::CylinderVolumeBounds>(*lArHecOuterGapBounds),
772 nullptr,
"Calo::GapVolumes::LAr::PositiveHecOuterGap");
775 std::move(lArHecNeg),
776 std::move(lArHecOuterGapBounds),
m_Ar,
777 nullptr,
nullptr,
"Calo::GapVolumes::LAr::NegativeHecOuterGap");
781 std::vector<Trk::TrackingVolume*> volsHecPos;
783 volsHecPos.push_back(hecBP.first);
784 volsHecPos.push_back(lArPositiveHecInnerGap);
785 volsHecPos.push_back(lArPositiveHec);
786 volsHecPos.push_back(lArPositiveHecOuterGap);
788 std::unique_ptr<Trk::TrackingVolume> positiveHec(
792 std::vector<Trk::TrackingVolume*> volsHecNeg;
794 volsHecNeg.push_back(hecBP.second);
796 volsHecNeg.push_back(lArNegativeHecInnerGap);
797 volsHecNeg.push_back(lArNegativeHec);
798 volsHecNeg.push_back(lArNegativeHecOuterGap);
800 std::unique_ptr<Trk::TrackingVolume> negativeHec(
809 std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> fcalBP =
819 if (rFcalBP > lArPositiveFcalBounds->
innerRadius()) {
821 << rFcalBP <<
">" << lArPositiveFcalBounds->
innerRadius()
827 auto lArFcalInnerGapBounds =
828 std::make_shared<Trk::CylinderVolumeBounds>(rFcalBP,
832 auto lArFcalPos = std::make_unique<Amg::Transform3D>(
834 auto lArFcalNeg = std::make_unique<Amg::Transform3D>(
838 std::make_unique<Amg::Transform3D>(*lArFcalPos),
839 std::make_shared<Trk::CylinderVolumeBounds>(*lArFcalInnerGapBounds),
840 m_Al,
nullptr,
nullptr,
841 "Calo::GapVolumes::LAr::PositiveFcalInnerGap");
844 std::make_unique<Amg::Transform3D>(*lArFcalNeg),
845 std::move(lArFcalInnerGapBounds),
m_Al,
nullptr,
846 nullptr,
"Calo::GapVolumes::LAr::NegativeFcalInnerGap");
849 auto lArFcalOuterGapBounds =
850 std::make_shared<Trk::CylinderVolumeBounds>(lArPositiveHecBounds->
outerRadius(),
855 std::move(lArFcalPos), std::make_shared<Trk::CylinderVolumeBounds>(*lArFcalOuterGapBounds),
856 m_Ar,
nullptr,
nullptr,
"Calo::GapVolumes::LAr::PositiveFcalOuterGap");
859 std::move(lArFcalNeg), std::move(lArFcalOuterGapBounds),
m_Ar,
860 nullptr,
nullptr,
"Calo::GapVolumes::LAr::NegativeFcalOuterGap");
864 std::vector<Trk::TrackingVolume*> volsFcalPos;
866 volsFcalPos.push_back(fcalBP.first);
868 volsFcalPos.push_back(lArPositiveFcalInnerGap);
869 volsFcalPos.push_back(lArPositiveFcal);
870 volsFcalPos.push_back(lArPositiveHecFcalCover);
871 volsFcalPos.push_back(lArPositiveFcalOuterGap);
873 std::unique_ptr<Trk::TrackingVolume> positiveFcal(
877 std::vector<Trk::TrackingVolume*> volsFcalNeg;
879 volsFcalNeg.push_back(fcalBP.second);
881 volsFcalNeg.push_back(lArNegativeFcalInnerGap);
882 volsFcalNeg.push_back(lArNegativeFcal);
883 volsFcalNeg.push_back(lArNegativeHecFcalCover);
884 volsFcalNeg.push_back(lArNegativeFcalOuterGap);
886 std::unique_ptr<Trk::TrackingVolume> negativeFcal(
895 std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> outBP =
897 caloPositiveOuterBoundary,
"Outer", rOutBP);
902 auto lArSectorOuterG0Bounds =
903 std::make_shared<Trk::CylinderVolumeBounds>(
906 0.5 * (caloPositiveOuterBoundary - lArPositiveOuterBoundary));
908 auto lArSectorOuterG1Bounds =
909 std::make_shared<Trk::CylinderVolumeBounds>(
910 430., keyDim.back().first,
912 0.5 * (caloPositiveOuterBoundary - lArPositiveOuterBoundary));
914 z = 0.5 * (caloPositiveOuterBoundary + lArPositiveOuterBoundary);
922 std::move(lArSecOutG0P), std::make_shared<Trk::CylinderVolumeBounds>(*lArSectorOuterG0Bounds),
923 lArSectorOuterGapMat,
nullptr,
924 nullptr,
"Calo::GapVolumes::LAr::PositiveSectorOuterGap0");
927 std::move(lArSecOutG1P), std::make_shared<Trk::CylinderVolumeBounds> (*lArSectorOuterG1Bounds),
928 m_Ar,
nullptr,
nullptr,
929 "Calo::GapVolumes::LAr::PositiveSectorOuterGap");
936 lArNegativeSectorOuterGap0 =
938 std::move(lArSectorOuterG0Bounds),
939 lArSectorOuterGapMat,
nullptr,
nullptr,
940 "Calo::GapVolumes::LAr::NegativeSectorOuterGap0");
943 std::move(lArSecOutG1N),
944 std::move(lArSectorOuterG1Bounds),
946 nullptr,
"Calo::GapVolumes::LAr::NegativeSectorOuterGap");
949 std::vector<Trk::TrackingVolume*> volsOuterGapP;
951 volsOuterGapP.push_back(outBP.first);
953 volsOuterGapP.push_back(lArPositiveSectorOuterGap0);
954 volsOuterGapP.push_back(lArPositiveSectorOuterGap);
955 std::unique_ptr<Trk::TrackingVolume> positiveOuterGap(
957 volsOuterGapP,
m_caloMaterial,
"Calo::Container::PositiveOuterGap"));
959 std::vector<Trk::TrackingVolume*> volsOuterGapN;
961 volsOuterGapN.push_back(outBP.second);
963 volsOuterGapN.push_back(lArNegativeSectorOuterGap0);
964 volsOuterGapN.push_back(lArNegativeSectorOuterGap);
965 std::unique_ptr<Trk::TrackingVolume> negativeOuterGap(
967 volsOuterGapN,
m_caloMaterial,
"Calo::Container::NegativeOuterGap"));
974 std::vector<Trk::TrackingVolume*> lArNegativeSectorVolumes;
976 lArNegativeSectorVolumes.push_back(negativeOuterGap.release());
978 lArNegativeSectorVolumes.push_back(negativeFcal.release());
980 lArNegativeSectorVolumes.push_back(negativeHec.release());
982 lArNegativeSectorVolumes.push_back(negativeEndcap.release());
986 "Calo::LAr::Container::NegativeSector");
991 std::vector<Trk::TrackingVolume*> lArPositiveSectorVolumes;
993 lArPositiveSectorVolumes.push_back(positiveEndcap.release());
995 lArPositiveSectorVolumes.push_back(positiveHec.release());
997 lArPositiveSectorVolumes.push_back(positiveFcal.release());
999 lArPositiveSectorVolumes.push_back(positiveOuterGap.release());
1003 "Calo::LAr::Container::PositiveSector");
1009 auto trtSolGapBounds = std::make_shared<Trk::CylinderVolumeBounds>(
1018 nullptr,
"Calo::GapVolumes::SolenoidGap");
1020 auto lArTileCentralG1Bounds =
1021 std::make_shared<Trk::CylinderVolumeBounds>(lArBarrelBounds->
outerRadius(),
1026 nullptr, std::move(lArTileCentralG1Bounds),
m_Ar,
nullptr,
nullptr,
1027 "Calo::GapVolumes::LArTileCentralSectorGap");
1031 std::vector<Trk::TrackingVolume*> lArCentralBarrelSectorVolumes;
1033 lArCentralBarrelSectorVolumes.push_back(trtSolenoidGap);
1035 lArCentralBarrelSectorVolumes.push_back(solenoid);
1037 lArCentralBarrelSectorVolumes.push_back(solenoidlArPresamplerGap);
1039 lArCentralBarrelSectorVolumes.push_back(lArBarrelPresampler);
1041 lArCentralBarrelSectorVolumes.push_back(lArBarrel);
1043 lArCentralBarrelSectorVolumes.push_back(lArTileCentralSectorGap);
1045 lArCentralBarrelSector =
1048 "Calo::Containers::LAr::CentralBarrelSector",
false,
true);
1054 std::vector<Trk::IdentifiedMaterial> matCrack;
1057 matCrack.emplace_back(std::make_shared<Trk::Material>(
m_Scint), baseID);
1058 matCrack.emplace_back(std::make_shared<Trk::Material>(
m_caloMaterial), -1);
1059 matCrack.emplace_back(std::make_shared<Trk::Material>(
m_Al), -1);
1068 std::vector<std::vector<size_t>> indexP;
1069 std::vector<std::vector<size_t>> indexN;
1071 std::vector<Trk::BinUtility> layDN(bun.bins());
1072 std::vector<Trk::BinUtility> layUP(bup.bins());
1073 double crackZ1 = 3532.;
1074 double crackZ2 = 3540.;
1076 std::vector<float>
steps;
1077 for (
unsigned int i = 0;
i < bup.bins();
i++) {
1079 std::vector<size_t> indx;
1081 steps.push_back(crackZ1);
1082 indx.push_back(
i < bup.bins() - 1 ? 0 : 1);
1083 steps.push_back(crackZ2);
1085 steps.push_back(keyDim.back().second);
1088 indexP.push_back(indx);
1094 auto crackBoundsPos = std::make_shared<Trk::CylinderVolumeBounds>(
1096 0.5 * (keyDim.back().second - crackZ1));
1097 z = 0.5 * (keyDim.back().second + crackZ1);
1098 auto crackPosTransform =
1102 std::move(crackPosTransform), crackBoundsPos, crackBinPos, 17,
1103 "Calo::Detectors::Tile::CrackPos");
1105 for (
unsigned int i = 0;
i < bun.bins();
i++) {
1107 std::vector<size_t> indx;
1109 steps.push_back(-keyDim.back().second);
1111 steps.push_back(-crackZ2);
1112 indx.push_back(
i > 0 ? 0 : 1);
1113 steps.push_back(-crackZ1);
1116 indexN.push_back(indx);
1121 auto crackNegTransform =
1125 std::move(crackNegTransform),
1126 std::make_shared<Trk::CylinderVolumeBounds>(*crackBoundsPos), crackBinNeg, 17,
1127 "Calo::Detectors::Tile::CrackNeg");
1130 auto lArCentralG1Bounds = std::make_shared<Trk::CylinderVolumeBounds>(
1132 0.5 * (crackZ1 - lArBarrelBounds->
halflengthZ()));
1135 auto lArCentralG1P =
1139 std::move(lArCentralG1P),
1140 std::make_shared<Trk::CylinderVolumeBounds>(*lArCentralG1Bounds),
m_Ar,
nullptr,
nullptr,
1141 "Calo::GapVolumes::LArCentralPositiveGap");
1143 auto lArCentralG1N =
1147 std::move(lArCentralG1N),
1148 std::move(lArCentralG1Bounds),
1150 nullptr,
"Calo::GapVolumes::LArCentralNegativeGap");
1155 std::vector<Trk::TrackingVolume*> lArCentralSectorVolumes;
1157 lArCentralSectorVolumes.push_back(crackNeg);
1159 lArCentralSectorVolumes.push_back(lArCentralNegativeGap);
1161 lArCentralSectorVolumes.push_back(lArCentralBarrelSector);
1163 lArCentralSectorVolumes.push_back(lArCentralPositiveGap);
1165 lArCentralSectorVolumes.push_back(crackPos);
1169 "Calo::Containers::LAr::CentralSector");
1174 std::vector<Trk::TrackingVolume*> caloCentralSectorVolumes;
1176 caloCentralSectorVolumes.push_back(inDetEnclosed);
1178 caloCentralSectorVolumes.push_back(lArCentralSector);
1182 "Calo::Containers::CaloCentralSector");
1189 std::vector<Trk::TrackingVolume*> lArCombinedVolumes;
1191 lArCombinedVolumes.push_back(lArNegativeSector);
1193 lArCombinedVolumes.push_back(caloCentralSector);
1195 lArCombinedVolumes.push_back(lArPositiveSector);
1198 lArCombinedVolumes,
m_caloMaterial,
"Calo::Containers::LAr::Combined");
1203 std::vector<Trk::TrackingVolume*> caloVolumes;
1205 caloVolumes.push_back(lArCombined);
1207 caloVolumes.push_back(tileCombined);
1220 if (caloVolsOuterRadius > caloDefaultRadius) {
1222 "Calo volumes exceeds envelope radius: adjusting envelope "
1223 "(de-synchronizing...)");
1224 caloDefaultRadius = caloVolsOuterRadius;
1227 if (caloVolsOuterRadius < caloDefaultRadius) {
1229 "Build radial buffer to synchronize the boundaries in between R "
1230 << caloVolsOuterRadius <<
" and " << caloDefaultRadius);
1232 auto centralSynBounds = std::make_shared<Trk::CylinderVolumeBounds>(
1233 caloVolsOuterRadius, caloDefaultRadius, caloVolsExtendZ);
1235 nullptr, std::move(centralSynBounds),
m_caloMaterial,
nullptr,
nullptr,
1236 "Calo::GapVolumes::EnvelopeBuffer");
1239 if (caloVolsExtendZ < caloDefaultHalflengthZ) {
1241 "Build longitudinal buffers to synchronize the boundaries in between Z "
1242 << caloVolsExtendZ <<
" and " << caloDefaultHalflengthZ);
1244 auto endcapSynBounds = std::make_shared<Trk::CylinderVolumeBounds>(
1245 0., caloDefaultRadius,
1246 0.5 * (caloDefaultHalflengthZ - caloVolsExtendZ));
1249 0.0053 *
pow(0.38, 3));
1251 float zPos = 0.5 * (caloDefaultHalflengthZ + caloVolsExtendZ);
1254 std::make_shared<Trk::CylinderVolumeBounds>(*endcapSynBounds),
1255 m_Ar,
nullptr,
nullptr,
1256 "Calo::GapVolumes::PosECBuffer");
1260 std::move(endcapSynBounds),
m_Ar,
nullptr,
nullptr,
1261 "Calo::GapVolumes::NegECBuffer");
1265 "All gap volumes for the Calorimeter created. Starting to build Volume "
1274 std::vector<float> zCutStep;
1275 std::vector<float> rCutStep;
1276 if (msCutouts.size() > 1) {
1277 zCutStep.push_back(msCutouts[0].
second);
1278 rCutStep.push_back(msCutouts[0].
first);
1279 for (
unsigned int i = 1;
i < msCutouts.size();
i++) {
1280 if (msCutouts[
i].
second == zCutStep.back())
1281 rCutStep.push_back(msCutouts[
i].
first);
1283 zCutStep.push_back(msCutouts[
i].
second);
1285 nCutVol = zCutStep.size() - 1;
1290 std::vector<Trk::TrackingVolume*> forwardCutoutVols;
1291 std::vector<Trk::TrackingVolume*> backwardCutoutVols;
1294 std::vector<Trk::Material> cutOutMat;
1295 cutOutMat.emplace_back(19.9, 213., 50., 23.,
1303 float rout = rCutStep[0];
1304 float zlow = zCutStep[0];
1305 for (
unsigned int i = 1;
i < zCutStep.size();
i++) {
1306 float zup = zCutStep[
i];
1307 float rcut = rCutStep[
i];
1308 std::stringstream
ss;
1311 float rCutOutBP = 0.;
1312 std::pair<Trk::TrackingVolume*, Trk::TrackingVolume*> cutOutBP =
1317 unsigned int mindex =
i > 1 ? 1 :
i;
1320 std::make_shared<Trk::CylinderVolumeBounds>(rCutOutBP, rcut, 0.5 * (zup - zlow));
1322 std::make_unique<Amg::Transform3D>(
1324 std::make_shared<Trk::CylinderVolumeBounds>(*cutInBounds),
1325 cutOutMat[mindex],
nullptr,
nullptr,
1326 "Calo::GapVolumes::CaloPositiveCutIn" +
ss.str());
1328 std::make_unique<Amg::Transform3D>(
1330 std::move(cutInBounds),
1331 cutOutMat[mindex],
nullptr,
nullptr,
1332 "Calo::GapVolumes::CaloNegativeCutIn" +
ss.str());
1335 auto cutOutBounds = std::make_shared<Trk::CylinderVolumeBounds>(rcut, rout, 0.5 * (zup - zlow));
1337 std::make_unique<Amg::Transform3D>(
1339 std::make_shared<Trk::CylinderVolumeBounds>(*cutOutBounds),
m_caloMaterial,
nullptr,
nullptr,
1340 "Muon::GapVolumes::CaloPositiveCutOut" +
ss.str());
1342 std::make_unique<Amg::Transform3D>(
1344 std::move(cutOutBounds),
1346 "Muon::GapVolumes::CaloNegativeCutOut" +
ss.str());
1353 std::vector<Trk::TrackingVolume*> cvPos;
1354 cvPos.push_back(cutOutBP.first);
1355 cvPos.push_back(caloInPos);
1356 cvPos.push_back(caloOutPos);
1360 "Calo::GapVolumes::CaloPositiveCutoutVolume" +
ss.str());
1361 forwardCutoutVols.push_back(cutOutPos);
1363 std::vector<Trk::TrackingVolume*> cvNeg;
1364 cvNeg.push_back(cutOutBP.second);
1365 cvNeg.push_back(caloInNeg);
1366 cvNeg.push_back(caloOutNeg);
1370 "Calo::GapVolumes::CaloNegativeCutoutVolume" +
ss.str());
1371 backwardCutoutVols.insert(backwardCutoutVols.begin(), cutOutNeg);
1379 if (!centralBuffer) {
1381 calorimeter = caloCombined;
1385 std::vector<Trk::TrackingVolume*> envRVols;
1386 envRVols.push_back(caloCombined);
1387 envRVols.push_back(centralBuffer);
1390 if (!forwardCutoutVols.empty() || ecNegBuffer) {
1395 std::vector<Trk::TrackingVolume*> envZVols;
1396 envZVols.reserve(backwardCutoutVols.size());
1397 for (
auto& backwardCutoutVol : backwardCutoutVols)
1398 envZVols.push_back(backwardCutoutVol);
1400 envZVols.push_back(ecNegBuffer);
1401 envZVols.push_back(caloRVolume);
1403 envZVols.push_back(ecPosBuffer);
1404 for (
auto& forwardCutoutVol : forwardCutoutVols)
1405 envZVols.push_back(forwardCutoutVol);
1418 "TrackingVolume 'Calorimeter' built successfully. Wrap it in "
1419 "TrackingGeometry.");
1421 auto caloTrackingGeometry = std::make_unique<Trk::TrackingGeometry>(calorimeter);
1428 caloTrackingGeometry->indexStaticLayers(
signature());
1431 return caloTrackingGeometry;