Assembly tool to produce the Acts envolpe volumes around the muon stations & also to construct the spectrometer envelope volumes. More...

#include <ChamberAssembleTool.h>

Inheritance diagram for MuonGMR4::ChamberAssembleTool:

Collaboration diagram for MuonGMR4::ChamberAssembleTool:

Public Types
using	VolBounds_t = Acts::VolumeBounds
	Abrivation of the volume bounds.
using	VolBoundPtr_t = std::shared_ptr<VolBounds_t>
	Abrivation of the Volume bound ptr.
using	SurfBoundPtr_t = std::shared_ptr<const Acts::PlanarBounds>
	Abrivation of the surface bounds.
using	TrfWithBounds = std::tuple<Acts::Transform3, VolBoundPtr_t, SurfBoundPtr_t>
	Abrivation of the volume transform together with a set of volume & surface bounds.

Public Member Functions
virtual StatusCode	buildReadOutElements (MuonDetectorManager &mgr) override final

Private Types
using	ChamberPtr = SpectrometerSector::ChamberPtr

Private Member Functions
template<typename ReObjType> requires (Acts::PointerConcept<ReObjType>)
TrfWithBounds	boundingBox (const ActsTrk::GeometryContext &gctx, const std::vector< ReObjType > &constituents, const Acts::Transform3 &globToLoc, Acts::VolumeBoundFactory &volBoundSet, Acts::SurfaceBoundFactory &surfBoundSet, const double margin) const
	builds the bounding box trapezoidal volume bounds from the set of readout elements Returns a pair of the volume bounds & the transformation to center the volume

Static Private Member Functions
static SurfBoundPtr_t	surfaceBounds (const VolBounds_t &volBounds, Acts::SurfaceBoundFactory &surfBoundSet)
	Construct surface bounds which measure equal sizes in halfXlow/halfXhigh & halfY as the parsed volume bounds.

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
Gaudi::Property< bool >	m_isRun4 {this, "run4Layout", false}
	Toggling whether the layout is a R3 or R4 layout.

Detailed Description

Assembly tool to produce the Acts envolpe volumes around the muon stations & also to construct the spectrometer envelope volumes.

Definition at line 27 of file ChamberAssembleTool.h.

Member Typedef Documentation

◆ ChamberPtr

using MuonGMR4::ChamberAssembleTool::ChamberPtr = SpectrometerSector::ChamberPtr

private

Definition at line 61 of file ChamberAssembleTool.h.

◆ SurfBoundPtr_t

using MuonGMR4::ChamberAssembleTool::SurfBoundPtr_t = std::shared_ptr<const Acts::PlanarBounds>

Abrivation of the surface bounds.

Definition at line 39 of file ChamberAssembleTool.h.

◆ TrfWithBounds

using MuonGMR4::ChamberAssembleTool::TrfWithBounds = std::tuple<Acts::Transform3, VolBoundPtr_t, SurfBoundPtr_t>

Abrivation of the volume transform together with a set of volume & surface bounds.

Definition at line 41 of file ChamberAssembleTool.h.

◆ VolBoundPtr_t

using MuonGMR4::ChamberAssembleTool::VolBoundPtr_t = std::shared_ptr<VolBounds_t>

Abrivation of the Volume bound ptr.

Definition at line 37 of file ChamberAssembleTool.h.

◆ VolBounds_t

using MuonGMR4::ChamberAssembleTool::VolBounds_t = Acts::VolumeBounds

Abrivation of the volume bounds.

Definition at line 35 of file ChamberAssembleTool.h.

Member Function Documentation

◆ boundingBox()

template<typename ReObjType>
requires (Acts::PointerConcept<ReObjType>)

ChamberAssembleTool::TrfWithBounds MuonGMR4::ChamberAssembleTool::boundingBox	(	const ActsTrk::GeometryContext &	gctx,
		const std::vector< ReObjType > &	constituents,
		const Acts::Transform3 &	globToLoc,
		Acts::VolumeBoundFactory &	volBoundSet,
		Acts::SurfaceBoundFactory &	surfBoundSet,
		const double	margin ) const

private

builds the bounding box trapezoidal volume bounds from the set of readout elements Returns a pair of the volume bounds & the transformation to center the volume

Parameters

gctx	Geometry context holding the alignment & global transformations
constituents	List of readout elements around which the bounding box shall be built
globToLoc	Transformation to go from the global -> local chamber's frame
volBoundSet	Factory to create the volume bounds & share them across equivalent volumes
surfBoundSet	Factory to create the surface bounds representing the material surfaces & share them across mutliple surfaces
margin	Extra margin by which the returned volume bounds are enlarged

Definition at line 56 of file ChamberAssembleTool.cxx.

                                                 {
      const Acts::GeometryContext tgContext{gctx.context()};
      TrapezoidBoundsExpander expandBounds{toCenter};
      expandBounds.setMargin(margin);
      ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Construct a new bounding box from "<<typeid(ReObjType).name()
                  <<" spanning over "<<constituents.size()<<" elements, align trf: "
                  <<Amg::toString(toCenter));
      for (const auto& element : constituents) {
         ATH_MSG_VERBOSE(__func__<<"() "<<__LINE__<<" - Append new element "<<toString(element));
         if constexpr(std::is_base_of_v<MuonReadoutElement, Acts::RemovePointer_t<ReObjType>>) {
            expandBounds.expand(tgContext, *element, volBoundSet);
         } else {
            expandBounds.expand(tgContext, *element);
         }
      }
      auto volBounds = expandBounds.makeBounds(volBoundSet);
      ATH_MSG_DEBUG(__func__<<"() "<<__LINE__<<" - Box centered "
         <<Amg::toString(expandBounds.boxMidPoint())<<" "<<(*volBounds));
      return std::make_tuple(expandBounds.boxMidPoint(), volBounds, 
                             surfaceBounds(*volBounds, surfBoundSet));
}

◆ buildReadOutElements()

StatusCode MuonGMR4::ChamberAssembleTool::buildReadOutElements ( MuonDetectorManager & mgr )

finaloverridevirtual

TGC T4E chambers & Mdt EIL chambers are glued together

Group chambers by sectors && station layer.

Check that the two readout elements are on the same side. Exception BOG eta 0 -> attributes to positive sectors

The two readout elements shall be located in the same sector

into a single chamber

If no chamber has been found, then create a new one

Find the chamber middle and create the geometry from that

Define the spectrometer sector

Define the chamber envelopes

Sort the readout elements by common parent volume

The BIS 7/8 chamber needs to be comparted into 4 subvolumes, each containing a single readout element to minimize the impact from the overlap between BIS78 & EIL-4 (TGC)

We need to ensure that the EIL 4/5 are split into a separate volume w.r.t. the New Small Wheel

Temporarily use the CSC to avoid reporting issues with the alignment algorithms

now, build simplified 2D representations of the sorted chambers we collected.

Now construct the sector volume from the chamber envelopes

Definition at line 84 of file ChamberAssembleTool.cxx.

                                                                             {
   ATH_CHECK(m_idHelperSvc.retrieve());
   auto mdtStationIndex = [this] (const std::string& stName) {
      return m_idHelperSvc->hasMDT() ? m_idHelperSvc->mdtIdHelper().stationNameIndex(stName) : -1;
   };
   auto tgcStationIndex = [this] (const std::string& stName) {
      return m_idHelperSvc->hasTGC() ? m_idHelperSvc->tgcIdHelper().stationNameIndex(stName) : -1;   
   };
   
   const std::unordered_set<int> stIndicesEM{mdtStationIndex("EML"), mdtStationIndex("EMS"),
                                             tgcStationIndex("T1E"), tgcStationIndex("T1F"),
                                             tgcStationIndex("T2E"), tgcStationIndex("T2F"),
                                             tgcStationIndex("T3E"), tgcStationIndex("T3F")};
 
 
   std::unordered_set<Identifier> BIS78_ids{};
   auto fillBIS78 = [&BIS78_ids, this](const MuonIdHelper& idHelper) {
      const int BIS = idHelper.stationNameIndex("BIS");
      std::copy_if(idHelper.detectorElement_begin(), idHelper.detectorElement_end(), std::inserter(BIS78_ids, BIS78_ids.end()), 
                  [&](const Identifier& detId){
                     int stEta = idHelper.stationEta(detId);
                     if (m_isRun4) {
                        stEta = std::abs(stEta);
                     }
                     return stEta >= 7 && idHelper.stationName(detId) == BIS;
                  });
   };
   if (m_idHelperSvc->hasMDT()) {
      fillBIS78(m_idHelperSvc->mdtIdHelper());
   }
   if (m_idHelperSvc->hasRPC()) {
      fillBIS78(m_idHelperSvc->rpcIdHelper());
   }
   
   std::vector<MuonReadoutElement*> allReadOutEles = mgr.getAllReadoutElements();
 
   std::vector<chamberArgs> envelopeCandidates{};
   for (const MuonReadoutElement* readOutEle : allReadOutEles) {
      std::vector<chamberArgs>::iterator exist = std::ranges::find_if(envelopeCandidates, 
                         [this, readOutEle, &stIndicesEM](const chamberArgs& args){
                           const MuonReadoutElement* refEle = args.detEles.front();
                           const Identifier refId = refEle->identify();
                           const Identifier testId = readOutEle->identify();
                           if (Acts::copySign(1, refEle->stationEta()) * 
                               Acts::copySign(1, readOutEle->stationEta()) < 0) {
                                 return false;
                           }
                           if (m_idHelperSvc->sector(testId) != m_idHelperSvc->sector(refId)) {
                              return false;
                           }
                           if (stIndicesEM.count(readOutEle->stationName()) &&
                               stIndicesEM.count(refEle->stationName())) {
                              return true;
                           }
                           // /// Summarize all readout element in the same sector & layer
                           return readOutEle->chamberIndex() == refEle->chamberIndex();
                         });
      if (exist == envelopeCandidates.end()) {
         ATH_MSG_VERBOSE(__func__<<" () "<<__LINE__<<" - Open envelope "<<(envelopeCandidates.size()+1)
               <<" for "<<m_idHelperSvc->toStringDetEl(readOutEle->identify())
               <<", sector: "<<m_idHelperSvc->sector(readOutEle->identify())
               <<", chIdx: "<<Muon::MuonStationIndex::chName(readOutEle->chamberIndex()));
         envelopeCandidates.emplace_back().detEles.push_back(readOutEle);
      } else {
         ATH_MSG_VERBOSE(__func__<<" () "<<__LINE__<<" - Attach "<<m_idHelperSvc->toStringDetEl(readOutEle->identify())
               <<", sector: "<<m_idHelperSvc->sector(readOutEle->identify())
               <<", chIdx: "<<Muon::MuonStationIndex::chName(readOutEle->chamberIndex())<<" to envelope "
            <<(std::distance(envelopeCandidates.begin(), exist) + 1)<<". ");
         exist->detEles.push_back(readOutEle);
      }
    }
    ActsTrk::GeometryContext gctx{};    
 
 
   Acts::VolumeBoundFactory volBoundSet{};
   Acts::SurfaceBoundFactory surfBoundSet{};  
   unsigned candId{0}; 
   for (chamberArgs& candidate : envelopeCandidates) {
         std::unordered_set<Identifier> reIds{};
 
         ATH_MSG_DEBUG(__func__<<" () "<<__LINE__<<" - New envelope candidate ");
         SpectrometerSector::defineArgs sectorArgs{};
         sectorArgs.id = (++candId);
         using namespace Muon::MuonStationIndex;
         std::vector<std::vector<const MuonReadoutElement*>> chamberElements{};
         if (toStationIndex(candidate.detEles.front()->chamberIndex()) != StIndex::EI) {
            std::map<PVConstLink, std::vector<const MuonReadoutElement*>> stationMap{};
            for (const MuonReadoutElement* re : candidate.detEles) {
               if (BIS78_ids.count(re->identify())) {
                  stationMap[re->getMaterialGeom()].push_back(re);
               } else {
                  stationMap[re->getMaterialGeom()->getParent()].push_back(re);
               }
            }
            for (auto& [parent, stationEles ]: stationMap){
               chamberElements.push_back(std::move(stationEles));
           }
         } else {
            std::vector<std::vector<const MuonReadoutElement*>> endcapEles(2);
 
            for (const MuonReadoutElement* sortMe : candidate.detEles){
               if (sortMe->detectorType() == ActsTrk::DetectorType::Tgc) {
                  endcapEles.emplace_back(1, sortMe);
               } else {
                  endcapEles[sortMe->detectorType() == ActsTrk::DetectorType::sTgc ||
                             sortMe->detectorType() == ActsTrk::DetectorType::Mm].push_back(sortMe);
               }
            }
            for (auto& stationEles : endcapEles) {
               if (!stationEles.empty()) {
                  chamberElements.push_back(std::move(stationEles));
               }
            }
         }
 
         for (auto& detEles: chamberElements) {
            const MuonReadoutElement* refEle = detEles.front();
            const Acts::Transform3 toChambCentre = refEle->globalToLocalTransform(gctx);
            ATH_MSG_DEBUG(__func__<<" () "<<__LINE__<<" - New chamber candidate "<<m_idHelperSvc->toStringChamber(refEle->identify()));
            const auto[chamberCentre, chamberBox, planeBounds] = boundingBox(gctx, detEles, toChambCentre, volBoundSet, 
                                                                              surfBoundSet, 0.1*Gaudi::Units::cm);
            chamberArgs chambArgs{};
            chambArgs.detEles = std::move(detEles);
            chambArgs.bounds = chamberBox;
            chambArgs.placement = std::make_unique<ActsTrk::VolumePlacement>(*refEle, chamberCentre);
            auto surface = Acts::Surface::makeShared<Acts::PlaneSurface>(Acts::Transform3::Identity(), planeBounds);
            chambArgs.placement->connectCenterSurface(surface);
            chambArgs.surface = surface;
            const Chamber* newChamber {sectorArgs.chambers.emplace_back(std::make_unique<Chamber>(std::move(chambArgs))).get()};
            for (const MuonReadoutElement* re : newChamber->readoutEles()) {
               reIds.insert(re->identify());
               mgr.getReadoutElement(re->identify())->setChamberLink(newChamber);
               ATH_MSG_VERBOSE(__func__<<" () "<<__LINE__<<" - Chamber element: "<<m_idHelperSvc->toStringDetEl(re->identify()));
                  
            }
            ATH_MSG_DEBUG(__func__<<" () "<<__LINE__<<" - Created new chamber: "<<(*newChamber));
         }
         if (sectorArgs.chambers.empty()) {
            continue;
         }
         std::ranges::sort(sectorArgs.chambers, [](const SpectrometerSector::ChamberPtr& a,
                                                   const SpectrometerSector::ChamberPtr& b) {
                                                      return (*a) < (*b);
                                                   });
 
         const Acts::Transform3 toCenter = sectorArgs.chambers.front()->globalToLocalTransform(gctx);
         const auto [envelopeCentre, envelopeBox, envelopePlane] = boundingBox(gctx, sectorArgs.chambers, toCenter, 
                                                                               volBoundSet, surfBoundSet, 2.* Gaudi::Units::cm);
 
         sectorArgs.bounds = envelopeBox;
         sectorArgs.localToGlobalTrf = make_intrusive<GeoAlignableTransform>(toCenter.inverse() * envelopeCentre);
         sectorArgs.placement = std::make_unique<ActsTrk::VolumePlacement>(ActsTrk::DetectorType::Csc,
                                                                           sectorArgs.localToGlobalTrf);
 
         auto surface = Acts::Surface::makeShared<Acts::PlaneSurface>(Acts::Transform3::Identity(), envelopePlane);
         sectorArgs.placement->connectCenterSurface(surface);
         sectorArgs.surface = surface ;
         const Acts::Transform3 globalToSector = sectorArgs.placement->globalToLocalTransform(gctx.context());
         for (auto & chamber : sectorArgs.chambers){
            // split by readout elements - MDT multilayers and trigger chambers for the sector
            for (auto & RE : chamber->readoutEles()){
               // get the center of the element in the sector frame 
               const Acts::Transform3& chamberToGlobal{RE->localToGlobalTransform(gctx)}; 
               const Amg::Vector3D origin = (globalToSector * chamberToGlobal).translation();
               // and then add the bounds of the element - this is technology dependent 
               sectorArgs.detectorLocs.emplace_back(origin, RE, BoundsExpander::makeBounds(*RE, volBoundSet));
            }
         }
         auto newSector = std::make_unique<SpectrometerSector>(std::move(sectorArgs));
         
         for (const Identifier& chId : reIds) {
            mgr.getReadoutElement(chId)->setSectorLink(newSector.get());
         }
         mgr.addSpectrometerSector(std::move(newSector));
    }
    return StatusCode::SUCCESS;
}

◆ surfaceBounds()

ChamberAssembleTool::SurfBoundPtr_t MuonGMR4::ChamberAssembleTool::surfaceBounds	(	const VolBounds_t &	volBounds,
		Acts::SurfaceBoundFactory &	surfBoundSet )

staticprivate

Construct surface bounds which measure equal sizes in halfXlow/halfXhigh & halfY as the parsed volume bounds.

Parameters

volBounds	Bounds which are mapped to surface bounds
surfBoundSet	Bound factory to assign equivalent bounds to multiple surfaces

Definition at line 45 of file ChamberAssembleTool.cxx.

                                                                            {
   if (volBounds.type() == Acts::VolumeBounds::BoundsType::eCuboid) {
      return surfBoundSet.makeBounds<Acts::RectangleBounds>(halfXlowY(volBounds),  halfY(volBounds));    
   } else if (volBounds.type()  == Acts::VolumeBounds::BoundsType::eTrapezoid) {
      return surfBoundSet.makeBounds<Acts::TrapezoidBounds>(halfXlowY(volBounds) , halfXhighY(volBounds) , halfY(volBounds));
   }
   return nullptr;
}

Member Data Documentation

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonGMR4::ChamberAssembleTool::m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 69 of file ChamberAssembleTool.h.

69{this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_isRun4

Gaudi::Property<bool> MuonGMR4::ChamberAssembleTool::m_isRun4 {this, "run4Layout", false}

private

Toggling whether the layout is a R3 or R4 layout.

If true, the BIS eta: -7 chambers are split into the individual readout elements.

Definition at line 72 of file ChamberAssembleTool.h.

72{this, "run4Layout", false};

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ChamberPtr

◆ SurfBoundPtr_t

◆ TrfWithBounds

◆ VolBoundPtr_t

◆ VolBounds_t

Member Function Documentation

◆ boundingBox()

◆ buildReadOutElements()

◆ surfaceBounds()

Member Data Documentation

◆ m_idHelperSvc

◆ m_isRun4