17 #include "GeoModelKernel/GeoFullPhysVol.h"
18 #include "GeoModelKernel/GeoLogVol.h"
19 #include "GeoModelKernel/GeoShape.h"
20 #include "GeoModelKernel/GeoTubs.h"
21 #include "GeoModelKernel/GeoTube.h"
22 #include "GeoModelKernel/GeoPcon.h"
23 #include "GeoModelKernel/GeoTrd.h"
24 #include "GeoModelKernel/GeoMaterial.h"
53 declareInterface<Trk::ICaloTrackingVolumeBuilder>(
this);
57 LAr::LArVolumeBuilder::~ LArVolumeBuilder() =
default;
65 ATH_CHECK(m_trackingVolumeCreator.retrieve());
66 ATH_MSG_DEBUG(
"Retrieved tool " << m_trackingVolumeCreator );
68 if(m_useCaloSurfBuilder){
74 return StatusCode::SUCCESS;
81 return StatusCode::SUCCESS;
92 ATH_MSG_FATAL(
"Could not get LArDetectorManager! Calo TrackingGeometry will not be built");
98 ATH_MSG_DEBUG(
"Retrieved " << numTreeTops <<
" tree tops from the LArDetDescrManager. " );
100 for (
unsigned int itreetop = 0; itreetop<numTreeTops; ++itreetop){
101 PVConstLink currentVPhysVolLink = lArMgr->
getTreeTop(itreetop);
102 const GeoLogVol* currentLogVol = currentVPhysVolLink->getLogVol();
104 unsigned int currentChilds = currentVPhysVolLink->getNChildVols();
106 ATH_MSG_DEBUG(
"Processing " << currentLogVol->getName() <<
"... has "
107 << currentChilds <<
" childs, position " << currentVPhysVolLink->getX(geoAlign).translation());
114 ATH_MSG_DEBUG(
"============ Barrel Section ======================" );
121 std::shared_ptr<Trk::CylinderVolumeBounds> solenoidBounds =
nullptr;
122 std::shared_ptr<Trk::CylinderVolumeBounds> solenoidLArBarrelGapBounds =
nullptr;
126 auto lArBarrelPresamplerMaterial = std::make_shared<Trk::Material>(130., 634.4, 33.7, 15.4, 0.0017);
127 auto lArBarrelMaterial = std::make_shared<Trk::Material>( 26.2, 436.3, 65.4, 27.8, 0.0035);
130 std::vector<std::pair<const Trk::Surface*, const Trk::Surface*>> entrySurf =
131 m_calosurf->entrySurfaces(&caloDDM);
132 std::vector<std::pair<const Trk::Surface*, const Trk::Surface*>> exitSurf =
133 m_calosurf->exitSurfaces(&caloDDM);
140 std::shared_ptr<Trk::CylinderVolumeBounds> lArBarrelPosBounds =
nullptr;
141 std::shared_ptr<Trk::CylinderVolumeBounds> lArBarrelNegBounds =
nullptr;
143 if (
detStore()->contains<StoredPhysVol>(
"EMB_POS")) {
149 GeoFullPhysVol* lArBarrelPosPhysVol =
154 if (
detStore()->contains<StoredPhysVol>(
"EMB_NEG")) {
160 GeoFullPhysVol* lArBarrelNegPhysVol =
163 const GeoLogVol* lArBarrelPosLogVol = lArBarrelPosPhysVol ? lArBarrelPosPhysVol->getLogVol() :
nullptr;
164 const GeoLogVol* lArBarrelNegLogVol = lArBarrelNegPhysVol ? lArBarrelNegPhysVol->getLogVol() :
nullptr;
168 double lArBarrelHalflength = 0.;
169 std::vector<double> zBoundaries;
172 if (lArBarrelPosLogVol && lArBarrelNegLogVol){
174 int poschilds = lArBarrelPosPhysVol->getNChildVols();
175 int negchilds = lArBarrelNegPhysVol->getNChildVols();
177 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArBarrelPosPhysVol->getAbsoluteName()
178 <<
" (" << poschilds <<
" childs) ." );
179 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArBarrelNegPhysVol->getAbsoluteName()
180 <<
" (" << negchilds <<
" childs) ." );
183 const GeoShape* lArBarrelPosShape = lArBarrelPosLogVol->getShape();
184 const GeoShape* lArBarrelNegShape = lArBarrelNegLogVol->getShape();
187 const GeoPcon* lArBarrelPosPcon =
dynamic_cast<const GeoPcon*
>(lArBarrelPosShape);
189 const GeoPcon* lArBarrelNegPcon =
dynamic_cast<const GeoPcon*
>(lArBarrelNegShape);
192 if (lArBarrelPosBounds)
193 ATH_MSG_VERBOSE(
" -> Positive Barrel Bounds: " << *lArBarrelPosBounds );
194 if (lArBarrelNegBounds)
195 ATH_MSG_VERBOSE(
" -> Negative Barrel Bounds: " << *lArBarrelNegBounds );
200 if (lArBarrelPosBounds && lArBarrelNegBounds){
203 double lArBarrelRmin = lArBarrelPosBounds->
innerRadius();
204 double lArBarrelRmax = lArBarrelPosBounds->
outerRadius();
205 lArBarrelHalflength = zBoundaries[1];
208 auto lArBarrelBoundsPos = std::make_shared<Trk::CylinderVolumeBounds>(
209 lArBarrelRmin, lArBarrelRmax, 0.5 * lArBarrelHalflength);
210 auto lArBarrelBoundsNeg =
211 std::make_shared<Trk::CylinderVolumeBounds>(*lArBarrelBoundsPos);
216 auto lArBPosTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArBPos));
217 auto lArBNegTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArBNeg));
222 std::vector<Trk::IdentifiedMaterial> matID;
225 matID.emplace_back(lArBarrelMaterial,0);
226 matID.emplace_back(lArBarrelMaterial,baseID+1);
227 matID.emplace_back(lArBarrelMaterial,baseID+2);
228 matID.emplace_back(lArBarrelMaterial,baseID+3);
230 matID.emplace_back(lArBarrelMaterial->scale(1.3),baseID+1);
231 matID.emplace_back(lArBarrelMaterial->scale(1.3),baseID+2);
232 matID.emplace_back(lArBarrelMaterial->scale(0.6),baseID+3);
233 matID.emplace_back(lArBarrelMaterial->scale(0.7),baseID+3);
234 matID.emplace_back(lArBarrelMaterial->scale(0.8),baseID+3);
235 matID.emplace_back(lArBarrelMaterial->scale(0.9),baseID+3);
236 matID.emplace_back(lArBarrelMaterial->scale(1.1),baseID+3);
242 std::vector<std::vector<size_t> > indexP(bubn.bins());
243 std::vector<std::vector<size_t> > indexN;
245 std::vector< Trk::BinUtility> layBUN(bubn.bins());
246 std::vector< Trk::BinUtility> layBUP(bubp.bins());
252 std::vector<float> offset2{};
254 if (scyl2) offset2 = scyl2->
offset();
255 std::vector<float> offset3{};
257 if (scyl3) offset3 = scyl3->
offset();
259 std::vector<float>
steps;
260 for (
unsigned int i=0;
i< bubn.bins();
i++) {
262 steps.push_back(lArBarrelBoundsNeg->innerRadius());
263 std::vector<size_t> indx; indx.clear();
266 indx.push_back(
i<14 ? 1:4 );
267 steps.push_back(r2 + offset2[
i] );
268 indx.push_back(
i<14 ? 2:5 );
269 steps.push_back(r3 + offset3[
i]);
271 if (
i>19) indx.push_back(7);
272 else if (
i>17) indx.push_back(8);
273 else if (
i>15) indx.push_back(9);
274 else if (
i>13) indx.push_back(3);
275 else if (
i>11) indx.push_back(6);
276 else if (
i>9) indx.push_back(7);
277 else if (
i>7) indx.push_back(8);
278 else if (
i>5) indx.push_back(8);
279 else if (
i>4) indx.push_back(9);
280 else indx.push_back(3);
282 steps.push_back(lArBarrelBoundsNeg->outerRadius());
285 layBUP[bubp.bins()-1-
i] = rBU;
286 indexN.push_back(indx);
287 indexP[bubp.bins()-1-
i] = std::vector<size_t>(indx);
290 const Trk::BinnedMaterial lArBarrelMaterialBinPos(*lArBarrelMaterial,bubp,layBUP,indexP,matID);
291 const Trk::BinnedMaterial lArBarrelMaterialBinNeg(*lArBarrelMaterial,bubn,layBUN,indexN,matID);
295 std::move(lArBPosTransform),
296 std::move(lArBarrelBoundsPos),
297 lArBarrelMaterialBinPos,
299 "Calo::Detectors::LAr::BarrelPos");
302 std::move(lArBNegTransform),
303 std::move(lArBarrelBoundsNeg),
304 lArBarrelMaterialBinNeg,
306 "Calo::Detectors::LAr::BarrelNeg");
309 std::vector<Trk::TrackingVolume*> volsB;
310 volsB.push_back(lArBarrelNeg);
311 volsB.push_back(lArBarrelPos);
313 lArBarrel = m_trackingVolumeCreator->createContainerTrackingVolume(volsB,
315 "Calo::Container::LAr::Barrel");
321 if(
detStore()->contains<StoredPhysVol>(
"SOLENOID"))
329 GeoFullPhysVol* solenoidPhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
332 const GeoLogVol* solenoidLogVol = solenoidPhysVol ? solenoidPhysVol->getLogVol() :
nullptr;
336 int childs = solenoidPhysVol->getNChildVols();
339 << solenoidPhysVol->getAbsoluteName() <<
" (" << childs <<
" childs) ." );
341 const GeoShape* solenoidShape = solenoidLogVol->getShape();
343 const GeoTubs* solenoidTubs =
dynamic_cast<const GeoTubs*
>(solenoidShape);
344 solenoidBounds = std::make_shared<Trk::CylinderVolumeBounds>(solenoidTubs->getRMin(),solenoidTubs->getRMax(),lArBarrelHalflength);
346 const GeoMaterial* solenoidMaterialGM = solenoidLogVol->getMaterial();
347 if (solenoidMaterialGM) {
353 if (solenoidBounds) {
369 std::shared_ptr<Trk::CylinderVolumeBounds> lArBarrelPresamplerPosBounds =
nullptr;
370 std::shared_ptr<Trk::CylinderVolumeBounds> lArBarrelPresamplerNegBounds =
nullptr;
372 if(
detStore()->contains<StoredPhysVol>(
"PRESAMPLER_B_POS"))
376 ATH_MSG_DEBUG(
"Unable to retrieve Stored PV PRESAMPLER_B_POS" );
380 GeoFullPhysVol* lArBarrelPresamplerPosPhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
384 if(
detStore()->contains<StoredPhysVol>(
"PRESAMPLER_B_NEG"))
388 ATH_MSG_DEBUG(
"Unable to retrieve Stored PV PRESAMPLER_B_NEG" );
392 GeoFullPhysVol* lArBarrelPresamplerNegPhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
395 const GeoLogVol* lArBarrelPresamplerPosLogVol = lArBarrelPresamplerPosPhysVol ? lArBarrelPresamplerPosPhysVol->getLogVol() :
nullptr;
396 const GeoLogVol* lArBarrelPresamplerNegLogVol = lArBarrelPresamplerNegPhysVol ? lArBarrelPresamplerNegPhysVol->getLogVol() :
nullptr;
399 if (lArBarrelPresamplerPosLogVol && lArBarrelPresamplerNegLogVol){
401 int poschilds = lArBarrelPresamplerPosPhysVol->getNChildVols();
402 int negchilds = lArBarrelPresamplerNegPhysVol->getNChildVols();
405 << lArBarrelPresamplerPosPhysVol->getAbsoluteName() <<
" (" << poschilds <<
" childs) ." );
407 << lArBarrelPresamplerNegPhysVol->getAbsoluteName() <<
" (" << negchilds <<
" childs) ." );
411 auto lArPBPosTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArBPos));
412 auto lArPBNegTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArBNeg));
415 const GeoShape* lArBarrelPresamplerPosShape = lArBarrelPresamplerPosLogVol->getShape();
418 const GeoTubs* lArBarrelPresamplerPosTubs =
dynamic_cast<const GeoTubs*
>(lArBarrelPresamplerPosShape);
419 lArBarrelPresamplerPosBounds = std::make_shared<Trk::CylinderVolumeBounds>(lArBarrelPresamplerPosTubs->getRMin(),
420 lArBarrelPresamplerPosTubs->getRMax(),
421 0.5*lArBarrelHalflength);
424 if (lArBarrelPresamplerPosBounds){
425 lArBarrelPresamplerNegBounds = std::make_shared<Trk::CylinderVolumeBounds>(*lArBarrelPresamplerPosBounds);
427 << *lArBarrelPresamplerPosBounds );
429 if (lArBarrelPresamplerNegBounds){
431 << *lArBarrelPresamplerNegBounds );
438 std::vector<float> bpsteps{
float(lArBarrelPresamplerPosBounds->
innerRadius()),
443 std::vector<size_t> dummylay (1,0);
445 std::vector<Trk::IdentifiedMaterial> matBP;
448 matBP.emplace_back(lArBarrelPresamplerMaterial,baseID);
450 const Trk::BinnedMaterial lArBarrelPresamplerMaterialBinPos(*lArBarrelPresamplerMaterial,rBU,dummylay,matBP);
451 const Trk::BinnedMaterial lArBarrelPresamplerMaterialBinNeg(*lArBarrelPresamplerMaterial,rBUc,dummylay,matBP);
454 std::move(lArPBPosTransform),
455 lArBarrelPresamplerPosBounds,
456 lArBarrelPresamplerMaterialBinPos,
458 "Calo::Detectors::LAr::BarrelPresamplerPos");
461 std::move(lArPBNegTransform),
462 std::move(lArBarrelPresamplerNegBounds),
463 lArBarrelPresamplerMaterialBinNeg,
465 "Calo::Detectors::LAr::BarrelPresamplerNeg");
468 std::vector<Trk::TrackingVolume*> volsBP;
469 volsBP.push_back(lArBarrelPresamplerNeg);
470 volsBP.push_back(lArBarrelPresamplerPos);
472 lArBarrelPresampler = m_trackingVolumeCreator->createContainerTrackingVolume(volsBP,
474 "Calo::Container::LAr::BarrelPresampler");
479 if (solenoidBounds && lArBarrelPresamplerPosBounds) {
480 solenoidLArBarrelGapBounds = std::make_shared<Trk::CylinderVolumeBounds>(solenoidBounds->
outerRadius(),
482 lArBarrelHalflength);
489 std::move(solenoidLArBarrelGapBounds),
492 "Calo::GapVolumes::LAr::SolenoidPresamplerGap");
497 ATH_MSG_DEBUG(
"============ Endcap Section ======================" );
523 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveHecBounds =
nullptr;
524 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveHecFcalCoverBounds =
nullptr;
525 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveFcalBounds =
nullptr;
527 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeHecBounds =
nullptr;
528 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeHecFcalCoverBounds =
nullptr;
529 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeFcalBounds =
nullptr;
532 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveEndcapBounds;
533 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeEndcapBounds;
535 if(
detStore()->contains<StoredPhysVol>(
"EMEC_POS"))
543 GeoFullPhysVol* lArPositiveEndcapPhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
545 const GeoLogVol* lArPositiveEndcapLogVol = lArPositiveEndcapPhysVol ? lArPositiveEndcapPhysVol->getLogVol() :
nullptr;
547 if(
detStore()->contains<StoredPhysVol>(
"EMEC_NEG"))
555 GeoFullPhysVol* lArNegativeEndcapPhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
557 const GeoLogVol* lArNegativeEndcapLogVol = lArNegativeEndcapPhysVol ? lArNegativeEndcapPhysVol->getLogVol() :
nullptr;
560 const GeoMaterial* lArPositiveEndcapMaterial =
nullptr;
563 std::vector<double> positiveEndcapZboundaries;
564 std::vector<double> negativeEndcapZboundaries;
566 double lArEndcapZpos = 0.;
569 if (lArPositiveEndcapLogVol && lArNegativeEndcapLogVol){
571 int poschilds = lArPositiveEndcapPhysVol->getNChildVols();
572 int negchilds = lArNegativeEndcapPhysVol->getNChildVols();
574 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArPositiveEndcapPhysVol->getAbsoluteName()
575 <<
" (" << poschilds <<
" childs)." );
576 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArNegativeEndcapPhysVol->getAbsoluteName()
577 <<
" (" << negchilds <<
" childs)." );
581 const GeoShape* lArPositiveEndcapShape = lArPositiveEndcapLogVol->getShape();
582 const GeoShape* lArNegativeEndcapShape = lArNegativeEndcapLogVol->getShape();
586 ? lArPositiveEndcapPhysVol->getCachedAbsoluteTransform(geoAlign)
587 : lArPositiveEndcapPhysVol->getAbsoluteTransform();
589 Amg::Vector3D lArPositiveEndcapNomPosition = lArPositiveEndcapTransform.translation();
593 const GeoPcon* lArPositiveEndcapPcon =
dynamic_cast<const GeoPcon*
>(lArPositiveEndcapShape);
594 if (lArPositiveEndcapPcon)
595 lArPositiveEndcapBounds = std::shared_ptr<Trk::CylinderVolumeBounds>
597 positiveEndcapZboundaries));
599 const GeoPcon* lArNegativeEndcapPcon =
dynamic_cast<const GeoPcon*
>(lArNegativeEndcapShape);
600 if (lArNegativeEndcapPcon)
601 lArNegativeEndcapBounds = std::shared_ptr<Trk::CylinderVolumeBounds>
603 negativeEndcapZboundaries));
605 if (lArPositiveEndcapBounds)
606 ATH_MSG_DEBUG(
" -> Positive Endcap Bounds: " << *lArPositiveEndcapBounds );
607 if (lArNegativeEndcapBounds)
608 ATH_MSG_DEBUG(
" -> Negative Endcap Bounds: " << *lArNegativeEndcapBounds );
610 double positiveEndcapZpos = 0.5 *(positiveEndcapZboundaries[1] + positiveEndcapZboundaries[0]);
612 lArEndcapZpos = positiveEndcapZpos+lArPositiveEndcapNomPosition.z();
614 ATH_MSG_DEBUG(
" located at z-positions " << lArEndcapZpos <<
" / " << -lArEndcapZpos );
617 lArPositiveEndcapMaterial = lArPositiveEndcapLogVol->getMaterial();
622 double lArEndcapHalfZ = 0.;
623 double lArEndcapZmin = 0.;
624 double lArEndcapZmax = 0.;
625 double lArEndcapInnerRadius = 0;
626 double lArEndcapOuterRadius = 0;
629 if (lArPositiveEndcapBounds && lArNegativeEndcapBounds && lArPositiveEndcapMaterial){
633 auto lArEndcapMaterial= std::make_shared<Trk::Material>(22.21, 402.2, 72.6, 30.5, 0.0039);
635 lArEndcapHalfZ = lArPositiveEndcapBounds->
halflengthZ();
636 lArEndcapZmin = lArEndcapZpos - lArPositiveEndcapBounds->
halflengthZ();
637 lArEndcapZmax = lArEndcapZpos + lArPositiveEndcapBounds->
halflengthZ();
638 lArEndcapInnerRadius = lArPositiveEndcapBounds->
innerRadius();
639 lArEndcapOuterRadius = lArPositiveEndcapBounds->
outerRadius();
643 auto lArPositiveEndcapTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArEndcapPositionPos));
644 auto lArNegativeEndcapTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArEndcapPositionNeg));
651 std::vector<Trk::IdentifiedMaterial> matEID;
654 matEID.emplace_back(lArEndcapMaterial,0);
655 matEID.emplace_back(lArEndcapMaterial,baseID+1);
656 matEID.emplace_back(lArEndcapMaterial,baseID+2);
657 matEID.emplace_back(lArEndcapMaterial,baseID+3);
659 matEID.emplace_back(lArEndcapMaterial->scale(1.05),baseID+1);
660 matEID.emplace_back(lArEndcapMaterial->scale(1.1),baseID+1);
661 matEID.emplace_back(lArEndcapMaterial->scale(1.15),baseID+1);
662 matEID.emplace_back(lArEndcapMaterial->scale(1.2),baseID+1);
663 matEID.emplace_back(lArEndcapMaterial->scale(1.25),baseID+1);
664 matEID.emplace_back(lArEndcapMaterial->scale(1.3),baseID+1);
665 matEID.emplace_back(lArEndcapMaterial->scale(1.35),baseID+1);
666 matEID.emplace_back(lArEndcapMaterial->scale(1.4),baseID+1);
667 matEID.emplace_back(lArEndcapMaterial->scale(1.05),baseID+2);
668 matEID.emplace_back(lArEndcapMaterial->scale(1.1),baseID+2);
669 matEID.emplace_back(lArEndcapMaterial->scale(1.15),baseID+2);
670 matEID.emplace_back(lArEndcapMaterial->scale(1.2),baseID+2);
671 matEID.emplace_back(lArEndcapMaterial->scale(1.25),baseID+2);
672 matEID.emplace_back(lArEndcapMaterial->scale(1.3),baseID+2);
673 matEID.emplace_back(lArEndcapMaterial->scale(1.35),baseID+2);
674 matEID.emplace_back(lArEndcapMaterial->scale(1.4),baseID+2);
675 matEID.emplace_back(lArEndcapMaterial->scale(1.45),baseID+2);
676 matEID.emplace_back(lArEndcapMaterial->scale(0.7),baseID+3);
677 matEID.emplace_back(lArEndcapMaterial->scale(0.75),baseID+3);
678 matEID.emplace_back(lArEndcapMaterial->scale(0.8),baseID+3);
679 matEID.emplace_back(lArEndcapMaterial->scale(0.85),baseID+3);
680 matEID.emplace_back(lArEndcapMaterial->scale(0.9),baseID+3);
681 matEID.emplace_back(lArEndcapMaterial->scale(0.95),baseID+3);
682 matEID.emplace_back(lArEndcapMaterial->scale(1.05),baseID+3);
683 matEID.emplace_back(lArEndcapMaterial->scale(1.1),baseID+3);
684 matEID.emplace_back(lArEndcapMaterial->scale(1.15),baseID+3);
685 matEID.emplace_back(lArEndcapMaterial->scale(1.2),baseID+3);
688 std::vector< Trk::BinUtility> layEUP(bup.bins());
690 std::vector<std::vector<size_t> > indexEP;
696 std::vector<float> offset2;
698 if (sd2) offset2 = sd2->
offset();
699 std::vector<float>offset3;
701 if (sd3) offset3 = sd3->
offset();
703 std::vector<float>
steps;
704 for (
unsigned int i=0;
i< bup.bins();
i++) {
706 std::vector<size_t> indx; indx.clear();
707 steps.push_back( lArEndcapZmin);
710 if (
i<4) indx.push_back(1);
711 else if (
i<6) indx.push_back(4);
712 else if (
i<8) indx.push_back(5);
713 else if (
i<10) indx.push_back(6);
714 else if (
i<12) indx.push_back(7);
715 else if (
i<14) indx.push_back(8);
716 else if (
i<16) indx.push_back(9);
717 else if (
i<18) indx.push_back(10);
718 else if (
i<23) indx.push_back(11);
719 else indx.push_back(1);
721 float z2c = z2 + offset2[
i];
722 if (z2c!=
steps.back()) {
steps.push_back(z2c); indx.push_back(2);}
723 else { indx.back()=2; }
725 else if (
i<6) indx.back()=12;
726 else if (
i<8) indx.back()=13;
727 else if (
i<10) indx.back()=14;
728 else if (
i<12) indx.back()=15;
729 else if (
i<14) indx.back()=16;
730 else if (
i<16) indx.back()=17;
731 else if (
i<18) indx.back()=18;
732 else if (
i<21) indx.back()=19;
733 else if (
i<23) indx.back()=20;
734 else if (
i<25) indx.back()=14;
735 else if (
i<27) indx.back()=15;
736 else if (
i<29) indx.back()=16;
737 else if (
i<31) indx.back()=17;
738 else if (
i<33) indx.back()=18;
739 else if (
i<35) indx.back()=19;
740 else if (
i<37) indx.back()=20;
742 steps.push_back(z3 + offset3[
i] );
743 if (
i<6) indx.push_back(21);
744 else if (
i<8) indx.push_back(22);
745 else if (
i<10) indx.push_back(23);
746 else if (
i<12) indx.push_back(24);
747 else if (
i<14) indx.push_back(25);
748 else if (
i<16) indx.push_back(26);
749 else if (
i<18) indx.push_back(3);
750 else if (
i<20) indx.push_back(28);
751 else if (
i<23) indx.push_back(29);
752 else if (
i<25) indx.push_back(22);
753 else if (
i<27) indx.push_back(23);
754 else if (
i<29) indx.push_back(24);
755 else if (
i<31) indx.push_back(26);
756 else if (
i<33) indx.push_back(3);
757 else if (
i<35) indx.push_back(27);
758 else indx.push_back(28);
759 steps.push_back(lArEndcapZmax);
762 indexEP.push_back(indx);
766 std::vector< Trk::BinUtility> layEUN(bun.bins());
767 std::vector<std::vector<size_t> > indexEN;
768 for (
int j=indexEP.size()-1; j>-1; j--) {
769 std::vector<size_t> indx; indx.clear();
770 for (
int jj=indexEP[j].
size()-1; jj>-1; jj--) {
771 indx.push_back(indexEP[j][jj]);
773 indexEN.push_back(indx);
782 if (sd2) offset2 = sd2->
offset();
785 if (sd3) offset3 = sd3->
offset();
787 for (
unsigned int i=0;
i< bun.bins();
i++) {
789 steps.push_back(-lArEndcapZmax);
790 steps.push_back(z3 + offset3[
i] );
791 steps.push_back(z2 + offset2[
i] );
792 if (z1!=
steps.back()) {
steps.push_back(z1); }
793 steps.push_back(-lArEndcapZmin);
798 const Trk::BinnedMaterial lArEndcapMaterialBinnedPos(*lArEndcapMaterial,bup,layEUP,indexEP,matEID);
799 const Trk::BinnedMaterial lArEndcapMaterialBinnedNeg(*lArEndcapMaterial,bun,layEUN,indexEN,matEID);
802 std::move(lArPositiveEndcapTransform),
803 std::move(lArPositiveEndcapBounds),
804 lArEndcapMaterialBinnedPos,
806 "Calo::Detectors::LAr::PositiveEndcap");
809 std::move(lArNegativeEndcapTransform),
810 std::move(lArNegativeEndcapBounds),
811 lArEndcapMaterialBinnedNeg,
813 "Calo::Detectors::LAr::NegativeEndcap");
819 std::shared_ptr<Trk::CylinderVolumeBounds> lArECPresamplerBounds =
nullptr;
821 if(
detStore()->contains<StoredPhysVol>(
"PRESAMPLER_EC_POS"))
825 ATH_MSG_DEBUG(
"Unable to retrieve Stored PV PRESAMPLER_EC_POS" );
829 GeoFullPhysVol* lArECPresamplerPhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
832 const GeoLogVol* lArECPresamplerLogVol = lArECPresamplerPhysVol ? lArECPresamplerPhysVol->getLogVol() :
nullptr;
835 std::vector<Trk::IdentifiedMaterial> matECP;
836 auto mAr = std::make_shared<Trk::Material>(140., 1170./1.4, 40., 18., 0.0014);
837 auto mAl = std::make_shared<Trk::Material>(88.93, 388.8, 27., 13., 0.0027);
841 matECP.emplace_back(mAl,0);
842 matECP.emplace_back(mAr,baseID);
844 if ( lArECPresamplerLogVol ) {
846 const GeoShape* lArECPresamplerShape = lArECPresamplerLogVol->getShape();
848 ? lArECPresamplerPhysVol->getCachedAbsoluteTransform(geoAlign)
849 : lArECPresamplerPhysVol->getAbsoluteTransform();
851 const GeoTubs* psTubs =
dynamic_cast<const GeoTubs*
>(lArECPresamplerShape);
853 float d = psTubs->getZHalfLength();
857 float zec = lArECPresamplerTransform.translation().z()-ecd+
d;
860 auto lArPosECPresamplerTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArECPresamplerPos));
861 auto lArNegECPresamplerTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArECPresamplerNeg));
863 lArECPresamplerBounds = std::make_shared<Trk::CylinderVolumeBounds>(psTubs->getRMin(),psTubs->getRMax(),ecd);
866 std::vector<float> ecp;
867 ecp.push_back( zec-ecd);
868 ecp.push_back( zec+ecd-2*
d);
869 ecp.push_back( zec+ecd);
873 std::vector<size_t> iep{0,1};
876 const Trk::BinnedMaterial lArECPresamplerMaterialBinPos(*lArBarrelPresamplerMaterial,hecp,iep,matECP);
880 std::move(lArPosECPresamplerTransform),
881 std::make_shared<Trk::CylinderVolumeBounds>(*lArECPresamplerBounds),
882 lArECPresamplerMaterialBinPos,
884 "Calo::Detectors::LAr::PositiveECPresampler");
887 std::vector<float> ecpn;
888 ecpn.push_back(-zec-ecd);
889 ecpn.push_back(-zec-ecd+2*
d);
890 ecpn.push_back(-zec+ecd);
894 std::vector<size_t> ien{1,0};
897 const Trk::BinnedMaterial lArECPresamplerMaterialBinNeg(*lArBarrelPresamplerMaterial,hecpn,ien,matECP);
900 std::move(lArNegECPresamplerTransform),
901 std::move(lArECPresamplerBounds),
902 lArECPresamplerMaterialBinNeg,
904 "Calo::Detectors::LAr::NegativeECPresampler");
910 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveHec1Bounds =
nullptr;
911 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveHec2Bounds =
nullptr;
912 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeHec1Bounds =
nullptr;
913 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeHec2Bounds =
nullptr;
916 if(
detStore()->contains<StoredPhysVol>(
"HEC1_POS")){
924 GeoFullPhysVol* lArPositiveHec1PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
926 if(
detStore()->contains<StoredPhysVol>(
"HEC2_POS")){
934 GeoFullPhysVol* lArPositiveHec2PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
936 if(
detStore()->contains<StoredPhysVol>(
"HEC1_NEG")){
944 GeoFullPhysVol* lArNegativeHec1PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
946 if(
detStore()->contains<StoredPhysVol>(
"HEC2_NEG")){
955 GeoFullPhysVol* lArNegativeHec2PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
957 const GeoLogVol* lArPositiveHec1LogVol = lArPositiveHec1PhysVol ? lArPositiveHec1PhysVol->getLogVol() :
nullptr;
958 const GeoLogVol* lArPositiveHec2LogVol = lArPositiveHec2PhysVol ? lArPositiveHec2PhysVol->getLogVol() :
nullptr;
959 const GeoLogVol* lArNegativeHec1LogVol = lArNegativeHec1PhysVol ? lArNegativeHec1PhysVol->getLogVol() :
nullptr;
960 const GeoLogVol* lArNegativeHec2LogVol = lArNegativeHec2PhysVol ? lArNegativeHec2PhysVol->getLogVol() :
nullptr;
962 std::vector<double> positiveEndcapZboundariesHec1;
963 std::vector<double> positiveEndcapZboundariesHec2;
964 std::vector<double> negativeEndcapZboundariesHec1;
965 std::vector<double> negativeEndcapZboundariesHec2;
969 if (lArPositiveHec1LogVol && lArPositiveHec2LogVol && lArNegativeHec1LogVol && lArNegativeHec2LogVol){
971 int poschildsHec1 = lArPositiveHec1PhysVol->getNChildVols();
972 int poschildsHec2 = lArPositiveHec2PhysVol->getNChildVols();
973 int negchildsHec1 = lArNegativeHec1PhysVol->getNChildVols();
974 int negchildsHec2 = lArNegativeHec2PhysVol->getNChildVols();
976 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArPositiveHec1PhysVol->getAbsoluteName()
977 <<
" (" << poschildsHec1 <<
" childs) ." );
978 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArNegativeHec2PhysVol->getAbsoluteName()
979 <<
" (" << poschildsHec2 <<
" childs) ." );
980 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArPositiveHec1PhysVol->getAbsoluteName()
981 <<
" (" << negchildsHec1 <<
" childs) ." );
982 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArNegativeHec2PhysVol->getAbsoluteName()
983 <<
" (" << negchildsHec2 <<
" childs) ." );
986 const GeoShape* lArPositiveHec1Shape = lArPositiveHec1LogVol->getShape();
987 const GeoShape* lArPositiveHec2Shape = lArPositiveHec2LogVol->getShape();
988 const GeoShape* lArNegativeHec1Shape = lArNegativeHec1LogVol->getShape();
989 const GeoShape* lArNegativeHec2Shape = lArNegativeHec2LogVol->getShape();
993 ? lArPositiveHec1PhysVol->getCachedAbsoluteTransform(geoAlign)
994 : lArPositiveHec1PhysVol->getAbsoluteTransform();
996 ? lArPositiveHec2PhysVol->getCachedAbsoluteTransform(geoAlign)
997 : lArPositiveHec2PhysVol->getAbsoluteTransform();
999 ? lArNegativeHec1PhysVol->getCachedAbsoluteTransform(geoAlign)
1000 : lArNegativeHec1PhysVol->getAbsoluteTransform();
1002 ? lArNegativeHec2PhysVol->getCachedAbsoluteTransform(geoAlign)
1003 : lArNegativeHec2PhysVol->getAbsoluteTransform();
1005 Amg::Vector3D lArPositiveHec1NomPosition = lArPositiveHec1Transform.translation();
1006 Amg::Vector3D lArPositiveHec2NomPosition = lArPositiveHec2Transform.translation();
1007 Amg::Vector3D lArNegativeHec1NomPosition = lArNegativeHec1Transform.translation();
1008 Amg::Vector3D lArNegativeHec2NomPosition = lArNegativeHec2Transform.translation();
1011 const GeoPcon* lArPositiveHec1Pcon =
dynamic_cast<const GeoPcon*
>(lArPositiveHec1Shape);
1013 positiveEndcapZboundariesHec1) :
nullptr;
1014 const GeoPcon* lArPositiveHec2Pcon =
dynamic_cast<const GeoPcon*
>(lArPositiveHec2Shape);
1016 positiveEndcapZboundariesHec2) :
nullptr;
1017 const GeoPcon* lArNegativeHec1Pcon =
dynamic_cast<const GeoPcon*
>(lArNegativeHec1Shape);
1019 negativeEndcapZboundariesHec1) :
nullptr;
1020 const GeoPcon* lArNegativeHec2Pcon =
dynamic_cast<const GeoPcon*
>(lArNegativeHec2Shape);
1022 negativeEndcapZboundariesHec2) :
nullptr;
1024 if (lArPositiveHec1Bounds)
1025 ATH_MSG_VERBOSE(
" -> Positive Hec1 Bounds: " << *lArPositiveHec1Bounds );
1026 if (lArPositiveHec2Bounds)
1027 ATH_MSG_VERBOSE(
" -> Positive Hec2 Bounds: " << *lArPositiveHec2Bounds );
1029 if (lArNegativeHec1Bounds)
1030 ATH_MSG_VERBOSE(
" -> Negative Hec1 Bounds: " << *lArNegativeHec1Bounds );
1031 if (lArNegativeHec2Bounds)
1032 ATH_MSG_VERBOSE(
" -> Negative Hec2 Bounds: " << *lArNegativeHec2Bounds );
1035 double positiveHec1Zpos = 0.5 *(positiveEndcapZboundariesHec1[1] + positiveEndcapZboundariesHec1[0]);
1036 double positiveHec2Zpos = 0.5 *(positiveEndcapZboundariesHec2[1] + positiveEndcapZboundariesHec2[0]);
1037 double negativeHec1Zpos = -fabs(0.5 *(negativeEndcapZboundariesHec1[1] + negativeEndcapZboundariesHec1[0]));
1038 double negativeHec2Zpos = -fabs(0.5 *(negativeEndcapZboundariesHec2[1] + negativeEndcapZboundariesHec2[0]));
1040 ATH_MSG_VERBOSE(
" Positive parts located at: " << positiveHec1Zpos + lArPositiveHec1NomPosition.z()
1041 <<
" / " << positiveHec2Zpos + lArPositiveHec2NomPosition.z() );
1043 ATH_MSG_VERBOSE(
" Negative parts located at: " << negativeHec1Zpos + lArNegativeHec1NomPosition.z()
1044 <<
" / " << negativeHec2Zpos + lArNegativeHec2NomPosition.z() );
1055 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveFcal1Bounds =
nullptr;
1056 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveFcal2Bounds =
nullptr;
1057 std::shared_ptr<Trk::CylinderVolumeBounds> lArPositiveFcal3Bounds =
nullptr;
1060 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeFcal1Bounds =
nullptr;
1061 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeFcal2Bounds =
nullptr;
1062 std::shared_ptr<Trk::CylinderVolumeBounds> lArNegativeFcal3Bounds =
nullptr;
1064 if(
detStore()->contains<StoredPhysVol>(
"FCAL1_POS"))
1072 GeoFullPhysVol* lArPositiveFcal1PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
1074 if(
detStore()->contains<StoredPhysVol>(
"FCAL2_POS"))
1082 GeoFullPhysVol* lArPositiveFcal2PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
1085 if(
detStore()->contains<StoredPhysVol>(
"FCAL3_POS"))
1093 GeoFullPhysVol* lArPositiveFcal3PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
1095 if(
detStore()->contains<StoredPhysVol>(
"FCAL1_NEG"))
1103 GeoFullPhysVol* lArNegativeFcal1PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
1105 if(
detStore()->contains<StoredPhysVol>(
"FCAL2_NEG"))
1113 GeoFullPhysVol* lArNegativeFcal2PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
1115 if(
detStore()->contains<StoredPhysVol>(
"FCAL3_NEG"))
1123 GeoFullPhysVol* lArNegativeFcal3PhysVol = storedPV ? storedPV->
getPhysVol() :
nullptr;
1125 const GeoLogVol* lArPositiveFcal1LogVol = lArPositiveFcal1PhysVol ? lArPositiveFcal1PhysVol->getLogVol() :
nullptr;
1126 const GeoLogVol* lArPositiveFcal2LogVol = lArPositiveFcal2PhysVol ? lArPositiveFcal2PhysVol->getLogVol() :
nullptr;
1127 const GeoLogVol* lArPositiveFcal3LogVol = lArPositiveFcal3PhysVol ? lArPositiveFcal3PhysVol->getLogVol() :
nullptr;
1129 const GeoLogVol* lArNegativeFcal1LogVol = lArNegativeFcal1PhysVol ? lArNegativeFcal1PhysVol->getLogVol() :
nullptr;
1130 const GeoLogVol* lArNegativeFcal2LogVol = lArNegativeFcal2PhysVol ? lArNegativeFcal2PhysVol->getLogVol() :
nullptr;
1131 const GeoLogVol* lArNegativeFcal3LogVol = lArNegativeFcal3PhysVol ? lArNegativeFcal3PhysVol->getLogVol() :
nullptr;
1134 double lArFcalHalflength = 0.;
1135 double lArFcalZposition = 0.;
1136 double lArFcalZmin = 0.;
1137 double lArFcalZmax = 0.;
1140 if (lArPositiveFcal1LogVol &&
1141 lArPositiveFcal2LogVol &&
1142 lArPositiveFcal3LogVol &&
1143 lArNegativeFcal1LogVol &&
1144 lArNegativeFcal2LogVol &&
1145 lArNegativeFcal3LogVol){
1147 int poschildsFcal1 = lArPositiveFcal1PhysVol->getNChildVols();
1148 int poschildsFcal2 = lArPositiveFcal2PhysVol->getNChildVols();
1149 int poschildsFcal3 = lArPositiveFcal3PhysVol->getNChildVols();
1151 int negchildsFcal1 = lArNegativeFcal1PhysVol->getNChildVols();
1152 int negchildsFcal2 = lArNegativeFcal2PhysVol->getNChildVols();
1153 int negchildsFcal3 = lArNegativeFcal3PhysVol->getNChildVols();
1156 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArPositiveFcal1PhysVol->getAbsoluteName()
1157 <<
" (" << poschildsFcal1 <<
" childs) ." );
1158 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArPositiveFcal2PhysVol->getAbsoluteName()
1159 <<
" (" << poschildsFcal2 <<
" childs) ." );
1160 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArPositiveFcal3PhysVol->getAbsoluteName()
1161 <<
" (" << poschildsFcal3 <<
" childs) ." );
1163 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArNegativeFcal1PhysVol->getAbsoluteName()
1164 <<
" (" << negchildsFcal1 <<
" childs) ." );
1165 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArNegativeFcal2PhysVol->getAbsoluteName()
1166 <<
" (" << negchildsFcal2 <<
" childs) ." );
1167 ATH_MSG_VERBOSE(
" -> Retrieved GeoModel Volume " << lArNegativeFcal3PhysVol->getAbsoluteName()
1168 <<
" (" << negchildsFcal3 <<
" childs) ." );
1171 const GeoShape* lArPositiveFcal1Shape = lArPositiveFcal1LogVol->getShape();
1172 const GeoShape* lArPositiveFcal2Shape = lArPositiveFcal2LogVol->getShape();
1173 const GeoShape* lArPositiveFcal3Shape = lArPositiveFcal3LogVol->getShape();
1175 const GeoShape* lArNegativeFcal1Shape = lArNegativeFcal1LogVol->getShape();
1176 const GeoShape* lArNegativeFcal2Shape = lArNegativeFcal2LogVol->getShape();
1177 const GeoShape* lArNegativeFcal3Shape = lArNegativeFcal3LogVol->getShape();
1182 ? lArPositiveFcal1PhysVol->getCachedAbsoluteTransform(geoAlign)
1183 : lArPositiveFcal1PhysVol->getAbsoluteTransform();
1185 ? lArPositiveFcal2PhysVol->getCachedAbsoluteTransform(geoAlign)
1186 : lArPositiveFcal2PhysVol->getAbsoluteTransform();
1188 ? lArPositiveFcal3PhysVol->getCachedAbsoluteTransform(geoAlign)
1189 : lArPositiveFcal3PhysVol->getAbsoluteTransform();
1192 ? lArNegativeFcal1PhysVol->getCachedAbsoluteTransform(geoAlign)
1193 : lArNegativeFcal1PhysVol->getAbsoluteTransform();
1195 ? lArNegativeFcal2PhysVol->getCachedAbsoluteTransform(geoAlign)
1196 : lArNegativeFcal2PhysVol->getAbsoluteTransform();
1198 ? lArNegativeFcal3PhysVol->getCachedAbsoluteTransform(geoAlign)
1199 : lArNegativeFcal3PhysVol->getAbsoluteTransform();
1201 Amg::Vector3D lArPositiveFcal1NomPosition = lArPositiveFcal1Transform.translation();
1202 Amg::Vector3D lArPositiveFcal2NomPosition = lArPositiveFcal2Transform.translation();
1203 Amg::Vector3D lArPositiveFcal3NomPosition = lArPositiveFcal3Transform.translation();
1205 Amg::Vector3D lArNegativeFcal1NomPosition = lArNegativeFcal1Transform.translation();
1206 Amg::Vector3D lArNegativeFcal2NomPosition = lArNegativeFcal2Transform.translation();
1207 Amg::Vector3D lArNegativeFcal3NomPosition = lArNegativeFcal3Transform.translation();
1210 const GeoTubs* lArPositiveFcal1Tubs =
dynamic_cast<const GeoTubs*
>(lArPositiveFcal1Shape);
1212 const GeoTubs* lArPositiveFcal2Tubs =
dynamic_cast<const GeoTubs*
>(lArPositiveFcal2Shape);
1214 const GeoTubs* lArPositiveFcal3Tubs =
dynamic_cast<const GeoTubs*
>(lArPositiveFcal3Shape);
1217 const GeoTubs* lArNegativeFcal1Tubs =
dynamic_cast<const GeoTubs*
>(lArNegativeFcal1Shape);
1219 const GeoTubs* lArNegativeFcal2Tubs =
dynamic_cast<const GeoTubs*
>(lArNegativeFcal2Shape);
1221 const GeoTubs* lArNegativeFcal3Tubs =
dynamic_cast<const GeoTubs*
>(lArNegativeFcal3Shape);
1224 if (lArPositiveFcal1Bounds)
1225 ATH_MSG_VERBOSE(
" -> Positive Fcal1 Bounds: " << *lArPositiveFcal1Bounds );
1226 if (lArPositiveFcal2Bounds)
1227 ATH_MSG_VERBOSE(
" -> Positive Fcal2 Bounds: " << *lArPositiveFcal2Bounds );
1228 if (lArPositiveFcal3Bounds)
1229 ATH_MSG_VERBOSE(
" -> Positive Fcal3 Bounds: " << *lArPositiveFcal3Bounds );
1232 if (lArNegativeFcal1Bounds)
1233 ATH_MSG_VERBOSE(
" -> Negative Fcal1 Bounds: " << *lArNegativeFcal1Bounds );
1234 if (lArNegativeFcal2Bounds)
1235 ATH_MSG_VERBOSE(
" -> Negative Fcal2 Bounds: " << *lArNegativeFcal2Bounds );
1236 if (lArNegativeFcal3Bounds)
1237 ATH_MSG_VERBOSE(
" -> Negative Fcal3 Bounds: " << *lArNegativeFcal3Bounds );
1240 ATH_MSG_VERBOSE(
" Positive parts located at: " << lArPositiveFcal1NomPosition.z()
1241 <<
" / " << lArPositiveFcal2NomPosition.z() <<
" / " << lArPositiveFcal3NomPosition.z() );
1243 ATH_MSG_VERBOSE(
" Negative parts located at: " << lArNegativeFcal1NomPosition.z()
1244 <<
" / " << lArNegativeFcal2NomPosition.z() <<
" / " << lArNegativeFcal3NomPosition.z() );
1249 lArFcalHalflength = lArPositiveFcal3NomPosition.z() + lArPositiveFcal3Bounds->
halflengthZ()
1250 - lArPositiveFcal1NomPosition.z() + lArNegativeFcal1Bounds->
halflengthZ();
1252 lArFcalHalflength *= 0.5;
1256 lArFcalZposition = lArPositiveFcal3NomPosition.z() + lArPositiveFcal3Bounds->
halflengthZ();
1257 lArFcalZposition += lArPositiveFcal1NomPosition.z() - lArNegativeFcal1Bounds->
halflengthZ();
1258 lArFcalZposition *= 0.5;
1266 double lArHecZmax = lArFcalZposition - lArFcalHalflength;
1267 double lArHecZmin = 0;
1268 if (lArPositiveEndcap && lArEndcapHalfZ != 0)
1269 lArHecZmin = lArPositiveEndcap->
center().z() + lArEndcapHalfZ;
1274 double caloSurfZOffset = 0;
1276 if(m_useCaloSurfBuilder){
1285 caloSurfZOffset = lArHecZmin -
z;
1286 lArHecZmax =
z +
depth + caloSurfZOffset;
1288 hecEnd =
z +
depth + caloSurfZOffset;
1292 double lArHecZpos = 0.5*(lArHecZmax + lArHecZmin);
1293 double lArHecHalflength = 0.5*(lArHecZmax - lArHecZmin);
1295 double hecFcalCoverHalflength = 0.5*(hecEnd - lArHecZmax);
1296 double hecFcalCoverZpos = 0.5*(lArHecZmax + hecEnd);
1298 lArFcalHalflength = hecFcalCoverHalflength;
1299 lArFcalZposition = hecFcalCoverZpos;
1302 std::vector<Trk::IdentifiedMaterial> matHEC;
1303 auto lArHecFcalCoverMaterial= std::make_shared<Trk::Material>(18.4, 201.9, 57.2, 26.1, 0.0071);
1304 auto lArHecMaterial = std::make_shared<Trk::Material>(19., 224.4, 56.7, 25.8, 0.007);
1308 matHEC.emplace_back(lArHecFcalCoverMaterial->scale(0.13*m_scale_HECmaterial),0);
1309 matHEC.emplace_back(lArHecMaterial->scale(m_scale_HECmaterial),baseID);
1310 matHEC.emplace_back(lArHecFcalCoverMaterial->scale(0.93*m_scale_HECmaterial),baseID+1);
1311 matHEC.emplace_back(lArHecFcalCoverMaterial->scale(1.09*m_scale_HECmaterial),baseID+2);
1312 matHEC.emplace_back(lArHecFcalCoverMaterial->scale(1.12*m_scale_HECmaterial),baseID+3);
1316 if (lArPositiveFcal1Bounds && lArNegativeFcal1Bounds){
1320 lArPositiveHecFcalCoverBounds = std::make_shared<Trk::CylinderVolumeBounds>(lArPositiveFcal1Bounds->
outerRadius(),
1321 lArEndcapOuterRadius,
1322 hecFcalCoverHalflength);
1324 lArNegativeHecFcalCoverBounds = std::make_shared<Trk::CylinderVolumeBounds>(*lArPositiveHecFcalCoverBounds);
1326 ATH_MSG_DEBUG(
"Smoothed LAr Hec (Fcal covering part) bounds : " << *lArPositiveHecFcalCoverBounds );
1327 ATH_MSG_DEBUG(
" -> at z-position: +/- " << hecFcalCoverZpos );
1330 Amg::Vector3D lArPositiveHecFcalCoverPos(0.,0.,hecFcalCoverZpos);
1331 Amg::Vector3D lArPositiveHecFcalCoverNeg(0.,0.,-hecFcalCoverZpos);
1332 auto lArPositiveHecFcalCoverTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArPositiveHecFcalCoverPos));
1333 auto lArNegativeHecFcalCoverTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArPositiveHecFcalCoverNeg));
1337 std::vector<float> spCover;
1338 spCover.push_back(hecFcalCoverZpos-hecFcalCoverHalflength);
1342 spCover.push_back(hecFcalCoverZpos+hecFcalCoverHalflength);
1346 std::vector<size_t> hfc{0,2,3,4};
1349 const Trk::BinnedMaterial lArHecFcalCoverMaterialBinPos(*lArHecFcalCoverMaterial,hfp,hfc,matHEC);
1352 std::move(lArPositiveHecFcalCoverTransform),
1353 std::move(lArPositiveHecFcalCoverBounds),
1354 lArHecFcalCoverMaterialBinPos,
1357 "Calo::Detectors::LAr::PositiveHecFcalCover");
1359 std::vector<float> snCover;
1360 snCover.push_back(-hecFcalCoverZpos-hecFcalCoverHalflength);
1364 snCover.push_back(-hecFcalCoverZpos+hecFcalCoverHalflength);
1368 std::vector<size_t> hfcn{4,3,2,0};
1374 std::move(lArNegativeHecFcalCoverTransform),
1375 std::move(lArNegativeHecFcalCoverBounds),
1376 lArHecFcalCoverMaterialBinNeg,
1379 "Calo::Detectors::LAr::NegativeHecFcalCover");
1384 if (lArPositiveFcal1Bounds && lArEndcapOuterRadius != 0){
1388 double lArHecRmin = 0.5*(lArPositiveFcal1Bounds->
outerRadius()+lArEndcapInnerRadius);
1389 double lArHecRmax = lArEndcapOuterRadius;
1392 lArPositiveHecBounds = std::make_shared<Trk::CylinderVolumeBounds>(lArHecRmin, lArHecRmax, lArHecHalflength);
1393 lArNegativeHecBounds = std::make_shared<Trk::CylinderVolumeBounds>(*lArPositiveHecBounds);
1395 ATH_MSG_DEBUG(
"Smoothed LAr Hec bounds : " << *lArPositiveHecBounds );
1401 auto lArPositiveHecTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArPositiveHecPos));
1402 auto lArNegativeHecTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArPositiveHecNeg));
1406 std::vector<float> sphec;
1407 sphec.push_back(lArHecZpos-lArHecHalflength);
1409 sphec.push_back(lArHecZpos+lArHecHalflength);
1413 std::vector<size_t> hf{0,1};
1419 std::move(lArPositiveHecTransform),
1420 std::move(lArPositiveHecBounds),
1421 lArHecMaterialBinPos,
1424 "Calo::Detectors::LAr::PositiveHec");
1427 std::vector<float> snhec;
1428 snhec.push_back(-lArHecZpos-lArHecHalflength);
1430 snhec.push_back(-lArHecZpos+lArHecHalflength);
1434 std::vector<size_t>
hfn{1,0};
1440 std::move(lArNegativeHecTransform),
1441 std::move(lArNegativeHecBounds),
1442 lArHecMaterialBinNeg,
1445 "Calo::Detectors::LAr::NegativeHec");
1450 std::vector<Trk::IdentifiedMaterial> matFCAL;
1452 auto lArFcalMaterial = std::make_shared<Trk::Material>(8.4, 175.5, 100.8, 42.1, 0.0097);
1453 auto lArFcalMaterial0 = std::make_shared<Trk::Material>(96., 560., 30.3, 14.3, 0.0025);
1457 matFCAL.emplace_back(lArFcalMaterial0,0);
1458 matFCAL.emplace_back(lArFcalMaterial->scale(0.5),baseID+1);
1459 matFCAL.emplace_back(lArFcalMaterial->scale(1.5),baseID+2);
1460 matFCAL.emplace_back(lArFcalMaterial->scale(1.4),baseID+3);
1463 if (lArPositiveFcal1Bounds && lArPositiveFcal2Bounds && lArPositiveFcal3Bounds &&
1464 lArNegativeFcal1Bounds && lArNegativeFcal2Bounds && lArNegativeFcal3Bounds){
1467 double lArFcalRmin = lArPositiveFcal1Bounds->
innerRadius();
1468 double lArFcalRmax = lArPositiveFcal1Bounds->
outerRadius();
1470 lArPositiveFcalBounds = std::make_shared<Trk::CylinderVolumeBounds>(lArFcalRmin, lArFcalRmax, lArFcalHalflength);
1471 lArNegativeFcalBounds = std::make_shared<Trk::CylinderVolumeBounds>(*lArPositiveFcalBounds);
1473 ATH_MSG_DEBUG(
"Smoothed LAr Fcal bounds : " << *lArPositiveFcalBounds );
1474 ATH_MSG_DEBUG(
" -> at z-position: +/- " << lArFcalZposition );
1477 lArFcalZmin = lArFcalZposition - lArFcalHalflength;
1478 lArFcalZmax = lArFcalZposition + lArFcalHalflength;
1481 std::vector<float> spfc;
1482 spfc.push_back(lArFcalZmin);
1486 spfc.push_back(lArFcalZmax);
1490 std::vector<size_t> hf{0,1,2,3};
1496 std::vector<float> snfc;
1497 snfc.push_back(-lArFcalZmax);
1501 snfc.push_back(-lArFcalZmin);
1505 std::vector<size_t>
hfn{3,2,1,0};
1513 auto lArPositiveFcalTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArPositiveFcalPos));
1514 auto lArNegativeFcalTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArPositiveFcalNeg));
1518 std::move(lArPositiveFcalTransform),
1519 std::move(lArPositiveFcalBounds),
1520 lArFcalMaterialBinPos,
1523 "Calo::Detectors::LAr::PositiveFcal");
1526 std::move(lArNegativeFcalTransform),
1527 std::move(lArNegativeFcalBounds),
1528 lArFcalMaterialBinNeg,
1531 "Calo::Detectors::LAr::NegativeFcal");
1538 const PVConstLink topEC = lArMgr->
getTreeTop(1U);
1541 const PVConstLink
mbts= getChild(topEC,
"MBTS_mother",trIn);
1549 const PVConstLink mbts1= getChild(
mbts,
"MBTS1",trIn);
1550 if (mbts1) mbtsZ=fabs(trIn.translation().z());
1554 const GeoLogVol* clv = mbts1->getLogVol();
1555 const GeoTrd* trd=
dynamic_cast<const GeoTrd*
> (clv->getShape());
1556 if (trd) mbts_rmin = trIn.translation().perp()-trd->getZHalfLength();
1559 const PVConstLink mbts2= getChild(
mbts,
"MBTS2",tr2);
1561 const GeoLogVol* clv = mbts2->getLogVol();
1562 const GeoTrd* trd=
dynamic_cast<const GeoTrd*
> (clv->getShape());
1563 if (trd) mbts_rmax = (tr2.translation().perp()+trd->getZHalfLength())/
cos(acos(-1.)/8);
1571 if (mbtsZ>0. && mbts_rmin>0. && mbts_rmax>0.){
1573 auto lArNegativeMBTSBounds = std::make_shared<Trk::CylinderVolumeBounds>(
1578 ATH_MSG_DEBUG(
"Filled in LAr MBTS bounds : " << *lArNegativeMBTSBounds );
1584 auto lArPositiveMBTSTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArEndcapInnerGapPos));
1585 auto lArNegativeMBTSTransform = std::make_unique<Amg::Transform3D>(
Amg::Translation3D(lArEndcapInnerGapNeg));
1589 std::move(lArPositiveMBTSTransform),
1590 std::make_shared<Trk::CylinderVolumeBounds>(*lArNegativeMBTSBounds),
1593 "Calo::Detectors::MBTS");
1596 std::move(lArNegativeMBTSTransform),
1597 std::move(lArNegativeMBTSBounds),
1600 "Calo::Detectors::MBTS");
1604 ATH_MSG_DEBUG(
"Checking the existence of all Tracking Volumes:" );
1607 ATH_MSG_DEBUG(
" -> Calo::GapVolumes::LAr::SolenoidPresamplerGap ");
1609 ATH_MSG_DEBUG(
" -> Calo::Detectors::LAr::BarrelPresampler ");
1613 if (lArPositiveEndcapInnerGap) {
1614 ATH_MSG_DEBUG(
" -> Calo::GapVolumes::LAr::PositiveEndcapInnerGap ");
1615 printCheckResult(
msg(
MSG::DEBUG), lArPositiveEndcapInnerGap);
1617 ATH_MSG_DEBUG(
" -> Calo::Detectors::LAr::PositiveEndcap ");
1623 ATH_MSG_DEBUG(
" -> Calo::Detectors::LAr::LArPositiveHecFcalCover ");
1625 if (lArNegativeEndcapInnerGap) {
1626 ATH_MSG_DEBUG(
" -> Calo::GapVolumes::LAr::NegativeEndcapInnerGap ");
1627 printCheckResult(
msg(
MSG::DEBUG), lArNegativeEndcapInnerGap);
1629 ATH_MSG_DEBUG(
" -> Calo::Detectors::LAr::NegativeEndcap ");
1635 ATH_MSG_DEBUG(
" -> Calo::Detectors::LAr::LArNegativeHecFcalCover ");
1637 ATH_MSG_DEBUG(
" -> Calo::Detectors::LAr::LArPositiveECPresampler ");
1639 ATH_MSG_DEBUG(
" -> Calo::Detectors::LAr::LArNegativeECPresampler ");
1644 auto lArTrackingVolumes = std::vector<Trk::TrackingVolume*>();
1647 if (solenoid && solenoidLArBarrelGap && lArBarrelPresampler && lArBarrel &&
1648 lArPositiveEndcap && lArPositiveHec && lArPositiveFcal && lArPositiveHecFcalCover &&
1649 lArNegativeEndcap && lArNegativeHec && lArNegativeFcal && lArNegativeHecFcalCover){
1654 lArTrackingVolumes.push_back(solenoid);
1656 lArTrackingVolumes.push_back(solenoidLArBarrelGap);
1658 lArTrackingVolumes.push_back(lArBarrelPresampler);
1660 lArTrackingVolumes.push_back(lArBarrel);
1663 lArTrackingVolumes.push_back(lArPositiveEndcapInnerGap);
1664 lArTrackingVolumes.push_back(lArPositiveEndcap);
1666 lArTrackingVolumes.push_back(lArPositiveHec);
1668 lArTrackingVolumes.push_back(lArPositiveFcal);
1670 lArTrackingVolumes.push_back(lArPositiveHecFcalCover);
1673 lArTrackingVolumes.push_back(lArNegativeEndcapInnerGap);
1674 lArTrackingVolumes.push_back(lArNegativeEndcap);
1676 lArTrackingVolumes.push_back(lArNegativeHec);
1678 lArTrackingVolumes.push_back(lArNegativeFcal);
1680 lArTrackingVolumes.push_back(lArNegativeHecFcalCover);
1682 lArTrackingVolumes.push_back(lArPosECPresampler);
1684 lArTrackingVolumes.push_back(lArNegECPresampler);
1688 return lArTrackingVolumes;
1699 const GeoLogVol* lv =
pv->getLogVol();
1701 << lv->getMaterial()->getName() <<
","
1702 << lv->getShape()->type());
1703 const GeoTrd* trd =
dynamic_cast<const GeoTrd*
>(lv->getShape());
1706 << trd->getXHalfLength1() <<
"," << trd->getXHalfLength2()
1707 <<
"," << trd->getYHalfLength1() <<
","
1708 << trd->getYHalfLength2() <<
"," << trd->getZHalfLength());
1709 const GeoTubs* tub =
dynamic_cast<const GeoTubs*
>(lv->getShape());
1711 ATH_MSG_VERBOSE(
"tubdim:" << tub->getRMin() <<
"," << tub->getRMax() <<
","
1712 << tub->getZHalfLength());
1713 const GeoTube*
tube =
dynamic_cast<const GeoTube*
>(lv->getShape());
1716 <<
"," <<
tube->getZHalfLength());
1717 const GeoPcon* con =
dynamic_cast<const GeoPcon*
>(lv->getShape());
1719 const unsigned int nPlanes = con->getNPlanes();
1720 for (
unsigned int i = 0;
i < nPlanes;
i++) {
1722 << con->getRMaxPlane(
i) <<
","
1723 << con->getZPlane(
i));
1728 <<
",phi:" << transf.translation().phi()
1729 <<
",x:" << transf.translation().x()
1730 <<
",y:" << transf.translation().y()
1731 <<
",z:" << transf.translation().z());
1733 printChildren(
pv,
gen, igen, transf);
1739 unsigned int nc =
pv->getNChildVols();
1741 if (
gen>-1 && igen>
gen)
return;
1743 for (
unsigned int ic=0;
ic<
nc;
ic++) {
1745 const PVConstLink cv =
pv->getChildVol(
ic);
1746 const GeoLogVol* clv = cv->getLogVol();
1749 << clv->getName() <<
", made of"
1750 << clv->getMaterial()->getName() <<
","
1751 << clv->getShape()->type());
1753 <<
",phi:" << transf.translation().phi()
1754 <<
",x:" << transf.translation().x()
1755 <<
",y:" << transf.translation().y()
1756 <<
",z:" << transf.translation().z());
1757 const GeoTrd* trd =
dynamic_cast<const GeoTrd*
>(clv->getShape());
1760 "trddim:" << trd->getXHalfLength1() <<
"," << trd->getXHalfLength2()
1761 <<
"," << trd->getYHalfLength1() <<
","
1762 << trd->getYHalfLength2() <<
"," << trd->getZHalfLength());
1763 const GeoTubs* tub =
dynamic_cast<const GeoTubs*
>(clv->getShape());
1766 <<
"," << tub->getZHalfLength());
1767 const GeoTube*
tube =
dynamic_cast<const GeoTube*
>(clv->getShape());
1770 <<
"," <<
tube->getZHalfLength());
1771 const GeoPcon* con =
dynamic_cast<const GeoPcon*
>(clv->getShape());
1773 const unsigned int nPlanes = con->getNPlanes();
1774 for (
unsigned int i = 0;
i < nPlanes;
i++) {
1776 << con->getRMaxPlane(
i) <<
","
1777 << con->getZPlane(
i));
1781 if (
ic == 0 || cname != clv->getName()) {
1782 printChildren(cv,
gen, igen, transf);
1783 cname = clv->getName();
1789 const std::string&
name,
1792 for (
const GeoVolumeVec_t::value_type&
p :
geoGetVolumes (&*mother))
1795 GeoPVConstLink cv =
p.first;
1796 const GeoLogVol* clv = cv->getLogVol();
1797 if (clv->getName().substr(0,
name.size())==
name) { trIn = transf;
return cv; }
1798 GeoPVConstLink
next=getChild(cv,
name,transf);
1799 if (
next) {trIn = transf;
return next; }