MuonGMR4::ChamberAssembleTool Class Reference

#include <ChamberAssembleTool.h>

Inheritance diagram for MuonGMR4::ChamberAssembleTool:

Collaboration diagram for MuonGMR4::ChamberAssembleTool:

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

Private Types
using	TrapVolBound_t = Acts::TrapezoidVolumeBounds
using	SurfBoundPtr_t = std::shared_ptr< const Acts::PlanarBounds >
using	VolBoundPtr_t = std::shared_ptr< Acts::TrapezoidVolumeBounds >
using	TrfWithBounds = std::tuple< Amg::Transform3D, VolBoundPtr_t, SurfBoundPtr_t >
	Abrivation of the volume transform together with a set of volume & surface bounds. More...

Private Member Functions
TrfWithBounds	boundingBox (const ActsGeometryContext &gctx, const std::vector< const MuonReadoutElement * > &readoutEles, const Amg::Transform3D &globToLoc, Acts::VolumeBoundFactory &volBoundSet, Acts::SurfaceBoundFactory &surfBoundSet, const double margin=1.*Gaudi::Units::cm) 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 More...

Static Private Member Functions
static VolBoundPtr_t	boundingBox (const MuonReadoutElement *reEle, Acts::VolumeBoundFactory &boundSet)
	Builds the trapezoidal bounding box enclosing a single readout element. More...
static std::array< Amg::Vector3D, 4 >	cornerPointsPlane (const Amg::Transform3D &localToGlob, const TrapVolBound_t &bounds)
	Returns the 4 corners of the trapezoid in the x-y plane. More...
static std::array< Amg::Vector3D, 8 >	cornerPoints (const Amg::Transform3D &localToGlob, const TrapVolBound_t &bounds)
	Returns the 8 corners marking the trapezoid. More...
static Amg::Transform3D	centerTrapezoid (const std::array< Amg::Vector3D, 8 > &cornerPoints)
	Returns the translation transform centering the 8 corner points of the trapezoid. More...
static double	trapezoidEdgeDist (const Amg::Vector3D &linePos, const Amg::Vector3D &lineDir, const Amg::Vector3D &testMe, bool leftEdge)
	Returns the signed distances of an external point to the trapezoidal edge. More...

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
PublicToolHandle< IMuonGeoUtilityTool >	m_geoUtilTool {this,"GeoUtilTool", "" }

Detailed Description

Definition at line 31 of file ChamberAssembleTool.h.

Member Typedef Documentation

SurfBoundPtr_t

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

private

Definition at line 40 of file ChamberAssembleTool.h.

TrapVolBound_t

using MuonGMR4::ChamberAssembleTool::TrapVolBound_t = Acts::TrapezoidVolumeBounds

private

Definition at line 39 of file ChamberAssembleTool.h.

TrfWithBounds

using MuonGMR4::ChamberAssembleTool::TrfWithBounds = std::tuple<Amg::Transform3D, VolBoundPtr_t, SurfBoundPtr_t>

private

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

Definition at line 44 of file ChamberAssembleTool.h.

VolBoundPtr_t

using MuonGMR4::ChamberAssembleTool::VolBoundPtr_t = std::shared_ptr<Acts::TrapezoidVolumeBounds>

private

Definition at line 41 of file ChamberAssembleTool.h.

Member Function Documentation

boundingBox() [1/2]

ChamberAssembleTool::TrfWithBounds MuonGMR4::ChamberAssembleTool::boundingBox ( const ActsGeometryContext &  gctx, const std::vector< const MuonReadoutElement * > &  readoutEles, const Amg::Transform3D &  globToLoc, Acts::VolumeBoundFactory &  volBoundSet, Acts::SurfaceBoundFactory &  surfBoundSet, const double  margin = 1.*Gaudi::Units::cm  ) 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
readoutEles	List of readout elements around which the bounding box shall be built
globToLoc	Transformation to go from the global -> local chamber's frame
boundSet	Cache of create bounds to share the same bounds across multiple volumes

Hack to cope with the RPCs which may be rotated by 180 degrees around the x or z-axis in cases, they're upside down.

Check whether the bounds are already embedded in the trapezoid

Everything is contained in the volume

Fetch the edges of the best known trapezoid to extend the dimensions

Reserve space for the new envelope trapezoid

The first 4 indices in the trpezoidal array are the bottom corners

Check the angles of the bounding trapzeoids

On the left edge the trapezoid opening angle needs to be larger while on the right side it's smaller

Calculate the distance to the trapezoidal edge. If it's less than 0, it's not embedded by the trapezoid and the smaller the number the farer it's from the trapezoid

Choose as reference point the one which is farest away from the edge

Extend the trapezoid in the x-y plane

Edge points of the best-known trapezoid

Finally re-center the trapezoid

Definition at line 161 of file ChamberAssembleTool.cxx.

                                                                  {
 
      VolBoundPtr_t envelopeBounds{};
     
      Amg::Transform3D newCentreTrf{Amg::Transform3D::Identity()};
      for (const MuonReadoutElement* chambEle :  readoutEles) {
            Amg::Transform3D trf = newCentreTrf * toCenter * 
                                   chambEle->localToGlobalTrans(gctx) * 
                                   axisRotation(chambEle->detectorType()).inverse();
            VolBoundPtr_t bounds = boundingBox(chambEle, volBoundSet);
            if (!envelopeBounds) {
               envelopeBounds = bounds;
               newCentreTrf = centerTrapezoid(cornerPoints(trf, *bounds)) * newCentreTrf;
               ATH_MSG_VERBOSE("Envelope "<<(*envelopeBounds)<<", transform: "<<Amg::toString(newCentreTrf));
               continue;
            }
            GeoTrf::CoordEulerAngles rotAngles = GeoTrf::getCoordRotationAngles(trf);
            if (std::abs(rotAngles.gamma - 180.*Gaudi::Units::deg)< std::numeric_limits<float>::epsilon()){
               trf = trf *Amg::getRotateZ3D(180.*Gaudi::Units::deg);
            }
            if (std::abs(rotAngles.alpha - 180.*Gaudi::Units::deg)< std::numeric_limits<float>::epsilon()){
               trf = trf *Amg::getRotateX3D(180.*Gaudi::Units::deg);
            }
            const std::array<Amg::Vector3D, 8> corners = cornerPoints(trf, *bounds);
 
            Acts::Volume volume{Amg::Transform3D::Identity(), envelopeBounds};
            if (std::ranges::find_if(corners, [&volume](const Amg::Vector3D& v) {
                              return !volume.inside(v);}) == corners.end()) {
               ATH_MSG_VERBOSE("Readout element "<<m_idHelperSvc->toStringDetEl(chambEle->identify())<<" "
                           <<(*boundingBox(chambEle, volBoundSet))<<" fully contained. ");
               continue;
            }
            if (msgLvl(MSG::VERBOSE)) {
               std::stringstream debugStr{};
               for (const Amg::Vector3D& corner : corners) {
                  debugStr<<"   ***** "<<Amg::toString(corner)<<std::endl;
               }
               ATH_MSG_VERBOSE(m_idHelperSvc->toString(chambEle->identify())<<" corner points "
                              <<GeoTrf::toString(trf, true)<<std::endl<<debugStr.str());   
            }
            const std::array<Amg::Vector3D, 8> refCorners{cornerPoints(Amg::Transform3D::Identity(), *envelopeBounds)};
            std::array<Amg::Vector3D, 8> newTrapBounds{make_array<Amg::Vector3D, 8>(Amg::Vector3D::Zero())};
 
            for (unsigned  lowZ : {0, 4}) {
               for (bool isLeft : {false, true}) {
 
                  const size_t iHigh = 1 + (!isLeft)*2 + lowZ;
                  const size_t iLow  = 0 + (!isLeft)*2 + lowZ;
                  const Amg::Vector3D dirRef{projectIntoXY(refCorners[iHigh] - refCorners[iLow]).unit()};
                  const Amg::Vector3D dirCan{projectIntoXY(corners[iHigh] - corners[iLow]).unit()};
            
                  
                  ATH_MSG_VERBOSE((isLeft ? "Left" : "Right")<<" edge "<<Amg::toString(dirRef)
                                    <<" "<<dirRef.phi() / Gaudi::Units::deg <<" --- "
                                    <<m_idHelperSvc->toStringDetEl(chambEle->identify())<<" "
                                    <<Amg::toString(dirCan)<<", phi: "<<dirCan.phi() / Gaudi::Units::deg);
 
                  const Amg::Vector3D& pickDir{(dirRef.phi() > dirCan.phi()) == isLeft ? dirRef : dirCan};
                  const double cornerLowD = trapezoidEdgeDist(refCorners[iLow], pickDir, corners[iLow], isLeft);
                  const double cornerHighD = trapezoidEdgeDist(refCorners[iLow], pickDir, corners[iHigh], isLeft);
                  ATH_MSG_VERBOSE("Distance "<<cornerLowD<<"/ "<<cornerHighD);
                  const Amg::Vector3D& pickPos{cornerLowD < 0 || cornerHighD < 0  ? 
                                               cornerLowD < cornerHighD ? corners[iLow] : corners[iHigh]: refCorners[iLow]};
               
                  ATH_MSG_VERBOSE("Low points "<<Amg::toString(corners[iLow])<<" - "<<Amg::toString(refCorners[iLow]));
                  ATH_MSG_VERBOSE("High points "<<Amg::toString(corners[iHigh])<<" - "<<Amg::toString(refCorners[iHigh]));
 
                  newTrapBounds[iHigh] = pickPos + Amg::intersect<3>(pickPos, pickDir, Amg::Vector3D::UnitY(),
                                                      std::max(corners[iHigh].y(), refCorners[iHigh].y())).value_or(0.) * pickDir;
 
                  newTrapBounds[iHigh].z() = lowZ ? std::max(corners[iHigh].z(),refCorners[iHigh].z())
                                                   : std::min(corners[iHigh].z(), refCorners[iHigh].z());
                  newTrapBounds[iLow] = pickPos + Amg::intersect<3>(pickPos, pickDir, Amg::Vector3D::UnitY(),
                                                                     std::min(corners[iLow].y(), refCorners[iLow].y())).value_or(0.) * pickDir;
                  newTrapBounds[iLow].z() = lowZ ? std::max(corners[iLow].z(), refCorners[iLow].z())
                                                 : std::min(corners[iLow].z(), refCorners[iLow].z());
 
                  ATH_MSG_VERBOSE("New end points "<<Amg::toString(newTrapBounds[iLow])<<" - "<<Amg::toString(newTrapBounds[iHigh]));
               }  
            }
            if (msgLvl(MSG::VERBOSE)) {
               std::stringstream debugStr{};
               for (const Amg::Vector3D& edge : newTrapBounds) {
                  debugStr<<"***** "<<Amg::toString(edge)<<std::endl;
               }
               ATH_MSG_VERBOSE("#############################################################"<<std::endl<<
                     debugStr.str()<<"#############################################################");
            }
            const double halfY  = 0.5*std::max(newTrapBounds[1].y() - newTrapBounds[0].y(),
                                               newTrapBounds[3].y() - newTrapBounds[2].y());
            const double lHalfX = 0.5*(newTrapBounds[3].x() - newTrapBounds[1].x());
            const double sHalfX = 0.5*(newTrapBounds[2].x() - newTrapBounds[0].x());
            const double halfZ  = 0.5*(newTrapBounds[4].z() - newTrapBounds[0].z());
            envelopeBounds = volBoundSet.makeBounds<Acts::TrapezoidVolumeBounds>(sHalfX, lHalfX, halfY, halfZ);
            ATH_MSG_VERBOSE(m_idHelperSvc->toStringDetEl(chambEle->identify())<<" "<<(*envelopeBounds));
         
            const Amg::Transform3D centerShift = centerTrapezoid(newTrapBounds);
            newCentreTrf = centerShift * newCentreTrf;
            ATH_MSG_VERBOSE("New trapezoid centering "<<Amg::toString(centerShift)<<" combined: "
                           <<Amg::toString(newCentreTrf));
      }
      
      VolBoundPtr_t volToReturn = 
            volBoundSet.makeBounds<Acts::TrapezoidVolumeBounds>(envelopeBounds->get(BoundEnum::eHalfLengthXnegY)+margin,
                                                                envelopeBounds->get(BoundEnum::eHalfLengthXposY)+margin,
                                                                envelopeBounds->get(BoundEnum::eHalfLengthY)+margin,
                                                                envelopeBounds->get(BoundEnum::eHalfLengthZ)+margin);
      SurfBoundPtr_t surfToReturn{};
      if (std::abs(envelopeBounds->get(BoundEnum::eHalfLengthXnegY) - 
                  envelopeBounds->get(BoundEnum::eHalfLengthXposY)) > margin) {
         surfToReturn = surfBoundSet.makeBounds<Acts::TrapezoidBounds>(envelopeBounds->get(BoundEnum::eHalfLengthXposY),
                                                                       envelopeBounds->get(BoundEnum::eHalfLengthXnegY),
                                                                       envelopeBounds->get(BoundEnum::eHalfLengthY)); 
      } else {
         const double maxX = std::max(envelopeBounds->get(BoundEnum::eHalfLengthXnegY), 
                                      envelopeBounds->get(BoundEnum::eHalfLengthXposY));
         surfToReturn = surfBoundSet.makeBounds<Acts::RectangleBounds>(maxX, envelopeBounds->get(BoundEnum::eHalfLengthY)); 
      }
      return std::make_tuple(newCentreTrf.inverse(), volToReturn, surfToReturn);               
}

boundingBox() [2/2]

ChamberAssembleTool::VolBoundPtr_t MuonGMR4::ChamberAssembleTool::boundingBox ( const MuonReadoutElement *  reEle, Acts::VolumeBoundFactory &  boundSet  )

staticprivate

Builds the trapezoidal bounding box enclosing a single readout element.

Parameters

reEle	Pointer to the readout element to fetch the bounds from
boundSet	Cache of create bounds to share the same bounds across multiple volumes

Definition at line 80 of file ChamberAssembleTool.cxx.

                                                                            {
 
   switch(chambEle->detectorType()) {
      case ActsTrk::DetectorType::Mdt: {
         const auto* techEle = static_cast<const MdtReadoutElement*>(chambEle);
         const auto& pars = techEle->getParameters();
         return volBoundSet.makeBounds<Acts::TrapezoidVolumeBounds>(pars.shortHalfX, pars.longHalfX, 
                                                                 pars.halfY, pars.halfHeight );
         break;
      } case ActsTrk::DetectorType::Rpc: {
         const auto* techEle = static_cast<const RpcReadoutElement*>(chambEle);
         const auto& pars = techEle->getParameters();
         return volBoundSet.makeBounds<Acts::TrapezoidVolumeBounds>(pars.halfWidth, pars.halfWidth, 
                                                                 pars.halfLength, pars.halfThickness);
         break;
      } case ActsTrk::DetectorType::Tgc: {
         const auto* techEle = static_cast<const TgcReadoutElement*>(chambEle);
         const auto& pars = techEle->getParameters();
         return volBoundSet.makeBounds<Acts::TrapezoidVolumeBounds>(pars.halfWidthShort, pars.halfWidthLong, 
                                                                 pars.halfHeight, pars.halfThickness );
         break;
      } case ActsTrk::DetectorType::sTgc: {
         const auto* techEle = static_cast<const sTgcReadoutElement*>(chambEle);
         const auto& pars = techEle->getParameters();
         return volBoundSet.makeBounds<Acts::TrapezoidVolumeBounds>(pars.sHalfChamberLength, pars.lHalfChamberLength, 
                                                                 pars.halfChamberHeight, pars.halfChamberTck );
         break;
      } case ActsTrk::DetectorType::Mm: {
         const auto* techEle = static_cast<const MmReadoutElement*>(chambEle);
         const auto& pars = techEle->getParameters();
         return volBoundSet.makeBounds<Acts::TrapezoidVolumeBounds>(pars.halfShortWidth, pars.halfLongWidth, 
                                                                 pars.halfHeight, pars.halfThickness );
         break;
      } default:
         THROW_EXCEPTION("Unsupported detector type "<<to_string(chambEle->detectorType()));
   }
   return nullptr;
}

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

Separate out the BOE chambers

Summarize all readout element in the same sector & layer into a single chamber

sTgcs && Micromegas should belong to the same chamber

EM readout element shall be grouped together too

Finally the EIL chambers should belong to the same 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

Create the enclosing chamber volume

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

Definition at line 302 of file ChamberAssembleTool.cxx.

                                                                             {
   ATH_CHECK(m_idHelperSvc.retrieve());
   ATH_CHECK(m_geoUtilTool.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> stIndicesEIL{mdtStationIndex("EIL"), mdtStationIndex("T4E")};
   const std::unordered_set<int> stIndicesEM{mdtStationIndex("EML"), mdtStationIndex("EMS"),
                                             tgcStationIndex("T1E"), tgcStationIndex("T1F"),
                                             tgcStationIndex("T2E"), tgcStationIndex("T2F"),
                                             tgcStationIndex("T3E"), tgcStationIndex("T3F")};
   
   const std::set<Identifier> BOE_ids{m_idHelperSvc->hasMDT() ? m_idHelperSvc->mdtIdHelper().elementID("BOL", 7,7): Identifier{},
                                      m_idHelperSvc->hasMDT() ? m_idHelperSvc->mdtIdHelper().elementID("BOL", -7,7): Identifier{},
                                      m_idHelperSvc->hasRPC() ? m_idHelperSvc->rpcIdHelper().elementID("BOL", -8, 7, 1) : Identifier{},
                                      m_idHelperSvc->hasRPC() ? m_idHelperSvc->rpcIdHelper().elementID("BOL", 8, 7, 1) : Identifier{}};
 
   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, &stIndicesEIL, &stIndicesEM, &BOE_ids](const chamberArgs& args){
                            const MuonReadoutElement* refEle = args.detEles.front();
                            const Identifier refId = refEle->identify();
                            const Identifier testId = readOutEle->identify();
                            if (sign(refEle->stationEta()) * sign(readOutEle->stationEta()) <0) {
                                 return false;
                            }
                            if (m_idHelperSvc->sector(testId) != m_idHelperSvc->sector(refId)) {
                                 return false;
                            }
                            if (BOE_ids.count(m_idHelperSvc->chamberId(refId)) !=
                                BOE_ids.count(m_idHelperSvc->chamberId(testId))){
                                    return false;
                            }
                            if (readOutEle->chamberIndex() == refEle->chamberIndex()) {
                                 return true;
                            }
                            if (isNsw(readOutEle) && isNsw(refEle)) return true;
                            if (stIndicesEM.count(readOutEle->stationName()) && 
                                stIndicesEM.count(refEle->stationName())) {
                                 return true;
                            }
                            if (stIndicesEIL.count(readOutEle->stationName()) &&
                                stIndicesEIL.count(refEle->stationName())) {
                                 return true;    
                            }
                            return false;
                         });
      if (exist == envelopeCandidates.end()) {
         chamberArgs newChamb{};
         newChamb.detEles.push_back(readOutEle);
         envelopeCandidates.push_back(std::move(newChamb));
      } else {
         exist->detEles.push_back(readOutEle);
      }
    }
    ActsGeometryContext gctx{};    
 
 
   Acts::VolumeBoundFactory volBoundSet{};
   Acts::SurfaceBoundFactory surfBoundSet{};    
   for (chamberArgs& candidate : envelopeCandidates) {
         std::unordered_set<Identifier> reIds{};
         const MuonReadoutElement* refEle = candidate.detEles.front();
         const Amg::Transform3D toCenter = axisRotation(refEle->detectorType()) * refEle->globalToLocalTrans(gctx);
         ATH_MSG_VERBOSE("New envelope candidate ");
         const auto [envelopeCentre, envelopeBox, envelopePlane] = boundingBox(gctx, candidate.detEles, toCenter, 
                                                                               volBoundSet, surfBoundSet);
       
         SpectrometerSector::defineArgs sectorArgs{};
         sectorArgs.bounds = envelopeBox;
         sectorArgs.surface = Acts::Surface::makeShared<Acts::PlaneSurface>(toCenter.inverse() * envelopeCentre, envelopePlane);
         
         if (!isNsw(candidate.detEles.front())) {
            std::map<PVConstLink, std::vector<const MuonReadoutElement*>> stationMap{};
            for (const MuonReadoutElement* re : candidate.detEles) {
               stationMap[re->getMaterialGeom()->getParent()].push_back(re);
            }
            for (auto& [parent, detEles]: stationMap) {
               const MuonReadoutElement* refEle = detEles.front();
               const Amg::Transform3D toChambCentre = axisRotation(refEle->detectorType()) * refEle->globalToLocalTrans(gctx);
               ATH_MSG_VERBOSE("New chambre 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.surface = Acts::Surface::makeShared<Acts::PlaneSurface>(toChambCentre.inverse() * chamberCentre, planeBounds);
               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);
               }
            }
         } else {
            const MuonReadoutElement* refEle = candidate.detEles.front();
            const Amg::Transform3D toChambCentre = axisRotation(refEle->detectorType()) * refEle->globalToLocalTrans(gctx);
            ATH_MSG_VERBOSE("New chambre candidate "<<m_idHelperSvc->toStringChamber(refEle->identify()));
            const auto[chamberCentre, chamberBox, planeBounds] = boundingBox(gctx, candidate.detEles, toChambCentre, 
                                                                             volBoundSet, surfBoundSet, 0.1*Gaudi::Units::cm);
            chamberArgs chambArgs{};
            chambArgs.detEles = candidate.detEles;
            chambArgs.bounds = chamberBox;
            chambArgs.surface = Acts::Surface::makeShared<Acts::PlaneSurface>(toChambCentre.inverse() * chamberCentre, planeBounds);
            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);
            }
         }
         std::ranges::sort(sectorArgs.chambers, [](const SpectrometerSector::ChamberPtr& a,
                                                   const SpectrometerSector::ChamberPtr& b) {
                                                      return (*a) < (*b);
                                                   });
         const Amg::Transform3D globalToSector = sectorArgs.surface->transform(gctx.context()).inverse();
 
         for (auto & chamber : sectorArgs.chambers){
            // split by readout elements - MDT multilayers and trigger chambers 
            for (auto & RE : chamber->readoutEles()){
               // get the center of the element in the sector frame 
               const Amg::Transform3D& chamberToGlobal{RE->localToGlobalTrans(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, boundingBox(RE, volBoundSet));
            }
         }
         auto newSector = std::make_unique<SpectrometerSector>(std::move(sectorArgs));
         
         for (const Identifier& chId : reIds) {
            mgr.getReadoutElement(chId)->setSectorLink(newSector.get());
         }
         ATH_MSG_VERBOSE("Add new sector "<<(*newSector));
         mgr.addSpectrometerSector(std::move(newSector));
    }
    return StatusCode::SUCCESS;
}

centerTrapezoid()

Amg::Transform3D MuonGMR4::ChamberAssembleTool::centerTrapezoid ( const std::array< Amg::Vector3D, 8 > &  cornerPoints )

staticprivate

Returns the translation transform centering the 8 corner points of the trapezoid.

The centre is defined as the centre point of the surrounding box

Parameters

cornerPoints

Array to all 8 corner points of the trapezoid

Definition at line 144 of file ChamberAssembleTool.cxx.

                                                                                           {
   
   static constexpr double maxSize = 200.*Gaudi::Units::km;
   double minX{maxSize}, maxX{-maxSize}, minY{maxSize}, maxY{-maxSize}, minZ{maxSize}, maxZ{-maxSize};
   for (const Amg::Vector3D& corner : corners) {
      minX = std::min(corner.x(), minX);
      maxX = std::max(corner.x(), maxX);
      minY = std::min(corner.y(), minY);
      maxY = std::max(corner.y(), maxY);
      minZ = std::min(corner.z(), minZ);
      maxZ = std::max(corner.z(), maxZ);
   }
   return Amg::getTranslate3D(-0.5*(minX + maxX), -0.5*(minY + maxY), -0.5*(minZ + maxZ));
}

cornerPoints()

std::array< Amg::Vector3D, 8 > MuonGMR4::ChamberAssembleTool::cornerPoints ( const Amg::Transform3D &  localToGlob, const TrapVolBound_t &  bounds  )

staticprivate

Returns the 8 corners marking the trapezoid.

Parameters

localToGlob	Transform from the trapezoid restframe -> chambers frame
bounds	Reference to the trapezoidal bounds defining the volume

Definition at line 131 of file ChamberAssembleTool.cxx.

                                                                                             {
   std::array<Amg::Vector3D, 8> toRet{make_array<Amg::Vector3D,8>(Amg::Vector3D::Zero())};
   std::array<Amg::Vector3D, 4> plane = cornerPointsPlane(localToGlob, bounds);
   for (unsigned int z : {0, 1}){
      const double sign {z ? 1. : -1.};
      const Amg::Vector3D stretch = (sign * bounds.get(BoundEnum::eHalfLengthZ)) * Amg::Vector3D::UnitZ();
      for (unsigned int b = 0; b < plane.size(); ++b){
         toRet[b + z * plane.size()] = plane[b] + stretch;
      }
   }
   return toRet;
}

cornerPointsPlane()

std::array< Amg::Vector3D, 4 > MuonGMR4::ChamberAssembleTool::cornerPointsPlane ( const Amg::Transform3D &  localToGlob, const TrapVolBound_t &  bounds  )

staticprivate

Returns the 4 corners of the trapezoid in the x-y plane.

Parameters

localToGlob	Transform from the trapezoid restframe -> chambers frame
bounds	Reference to the trapezoidal bounds defining the volume

Definition at line 121 of file ChamberAssembleTool.cxx.

                                                                                                  {
   std::array<Amg::Vector3D,4> planePoints{
            localToGlob * Amg::Vector3D(-bounds.get(BoundEnum::eHalfLengthXnegY), -bounds.get(BoundEnum::eHalfLengthY), 0. ),
            localToGlob * Amg::Vector3D(-bounds.get(BoundEnum::eHalfLengthXposY), bounds.get(BoundEnum::eHalfLengthY), 0. ),
            localToGlob * Amg::Vector3D(bounds.get(BoundEnum::eHalfLengthXnegY), -bounds.get(BoundEnum::eHalfLengthY), 0. ),
            localToGlob * Amg::Vector3D(bounds.get(BoundEnum::eHalfLengthXposY), bounds.get(BoundEnum::eHalfLengthY), 0. ),
   };
   return planePoints;
}

trapezoidEdgeDist()

double MuonGMR4::ChamberAssembleTool::trapezoidEdgeDist ( const Amg::Vector3D &  linePos, const Amg::Vector3D &  lineDir, const Amg::Vector3D &  testMe, bool  leftEdge  )

staticprivate

Returns the signed distances of an external point to the trapezoidal edge.

Distances > 0 indicate that the point is inside the boundaries and outside otherwise

Parameters

linePos	Arbitrary point on the trapezoidal edge
lineDir	Direction of the trapezoidal edge
testMe	External point to measure the distance
leftEdge	Switch indicating whether the edge is on the left & right side

Construct the normal pointing inwards

Definition at line 69 of file ChamberAssembleTool.cxx.

                                                             {
   const Amg::Vector3D normal = lineDir.cross((leftEdge ? 1. : -1.) *Amg::Vector3D::UnitZ());
   const Amg::Vector3D closest = linePos + lineDir.dot(testMe - linePos) * lineDir;
   return normal.dot(testMe - closest);  
}

Member Data Documentation

m_geoUtilTool

PublicToolHandle<IMuonGeoUtilityTool> MuonGMR4::ChamberAssembleTool::m_geoUtilTool {this,"GeoUtilTool", "" }

private

Definition at line 92 of file ChamberAssembleTool.h.

m_idHelperSvc

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

private

Definition at line 91 of file ChamberAssembleTool.h.

---

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

• ChamberAssembleTool.h
• ChamberAssembleTool.cxx