ActsTrk::MuonBlueprintNodeBuilder Class Reference

Helper class to build a Blueprint node of the muon system. More...

#include <MuonBlueprintNodeBuilder.h>

Inheritance diagram for ActsTrk::MuonBlueprintNodeBuilder:

Collaboration diagram for ActsTrk::MuonBlueprintNodeBuilder:

Public Types
enum class	EndcapSide { A , C , Both }

Public Member Functions
StatusCode	initialize () override
std::shared_ptr< Acts::Experimental::BlueprintNode >	buildBlueprintNode (const Acts::GeometryContext &gctx, std::shared_ptr< Acts::Experimental::BlueprintNode > &&childNode) override
	Build the Muon Blueprint Node.

Private Member Functions
template<typename T>
std::shared_ptr< Acts::Surface >	blendMaterial (const T &element) const
	Blend the sector's/chamber's material as plane surface.
template<typename T>
std::pair< std::vector< staticNodePtr >, std::vector< surfacePtr > >	getSensitiveElements (const ActsTrk::GeometryContext &gctx, const T &element, const Acts::GeometryIdentifier &chId, Acts::VolumeBoundFactory &boundsFactory) const
	Get the chamber's sensitive elements.
template<typename T>
bool	isElementInTheStation (const T &element, const std::vector< StIdx > &stationNames, const EndcapSide &side) const
	Check if the chamber is in this node.
template<typename MuonElementsSet>
std::shared_ptr< Acts::Experimental::StaticBlueprintNode >	buildMuonNode (const Acts::GeometryContext &gctx, const MuonElementsSet &elements, const std::string &name, const Acts::GeometryIdentifier &id, Acts::VolumeBoundFactory &boundsFactory) const
	Build subnodes for the muon system node.

Private Attributes
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
Gaudi::Property< bool >	m_useSectors {this, "UseSectors", false}

Detailed Description

Helper class to build a Blueprint node of the muon system.

It builds the whole muon system for PhaseII adding it to the Blueprint as a node.

Definition at line 49 of file MuonBlueprintNodeBuilder.h.

Member Enumeration Documentation

EndcapSide

enum class ActsTrk::MuonBlueprintNodeBuilder::EndcapSide

strong

Enumerator
A
C
Both

Definition at line 53 of file MuonBlueprintNodeBuilder.h.

                        {
      A,
      C,
      Both
  };

Member Function Documentation

blendMaterial()

template<typename T>

std::shared_ptr< Acts::Surface > ActsTrk::MuonBlueprintNodeBuilder::blendMaterial ( const T & element ) const

private

Blend the sector's/chamber's material as plane surface.

Parameters

element

The element for which to blend the material for This function returns a plane surface with the element's (chamber or sector) material assigned to be placed at the center of the element.

Definition at line 343 of file MuonBlueprintNodeBuilder.cxx.

                            {
 
  const float thickness = element.halfZ() * 2;
  PVConstLink parentVolume = element.readoutEles().front()->getMaterialGeom()->getParent();
  GeoModelTools::GeoMaterialHelper geoMaterialHelper;
  std::pair<GeoModelTools::GeoMaterialPtr, double> geoMaterials = geoMaterialHelper.collectMaterial(parentVolume);
 
  const Acts::Material aMat = ActsPlugins::GeoModel::geoMaterialConverter(*geoMaterials.first);
  //rotate about the z axis
  auto constPtr = element.surface().getSharedPtr();
  //to assign the material shouldnt be const
  auto ptr = std::const_pointer_cast<Acts::Surface>(constPtr);
 
  Acts::MaterialSlab slab{aMat, thickness};
  std::shared_ptr<Acts::HomogeneousSurfaceMaterial> material = std::make_shared<Acts::HomogeneousSurfaceMaterial>(slab);
  ptr->assignSurfaceMaterial(material);
  return ptr;
 
}

buildBlueprintNode()

std::shared_ptr< Acts::Experimental::BlueprintNode > ActsTrk::MuonBlueprintNodeBuilder::buildBlueprintNode ( const Acts::GeometryContext & gctx, std::shared_ptr< Acts::Experimental::BlueprintNode > && childNode )

override

Build the Muon Blueprint Node.

Parameters

gctx	Geometry context
childNode	The blueprint node as child of this node (for Muon System it should be Calo or Itk).

Definition at line 52 of file MuonBlueprintNodeBuilder.cxx.

                                                                                                                                                                                   {
 
std::variant<MuonChamberSet, MuonSectorSet> elements;
std::variant<MuonChamberSet, MuonSectorSet> barrelStations, endcapAStations, endcapCStations, endcapMiddleAStations, endcapMiddleCStations;
 
if (m_useSectors) {
  elements = m_detMgr->getAllSectors();
} else {
  elements = m_detMgr->getAllChambers();
}
 
std::visit([&](auto& elems) {
  using SetType = std::decay_t<decltype(elems)>;
 
  // Initialize station containers of the same type
  SetType barrel, endcapA, endcapC, endcapMiddleA, endcapMiddleC;
 
  for (const auto& element : elems) {
    if (isElementInTheStation(*element,
          {StIdx::BI, StIdx::BM, StIdx::BO, StIdx::BE, StIdx::EE, StIdx::EI},
          EndcapSide::Both)) {
      barrel.push_back(element);
    } else if (isElementInTheStation(*element, {StIdx::EO}, EndcapSide::A)) {
      endcapA.push_back(element);
    } else if (isElementInTheStation(*element, {StIdx::EO}, EndcapSide::C)) {
      endcapC.push_back(element);
    } else if (isElementInTheStation(*element, {StIdx::EM}, EndcapSide::A)) {
      endcapMiddleA.push_back(element);
    } else if (isElementInTheStation(*element, {StIdx::EM}, EndcapSide::C)) {
      endcapMiddleC.push_back(element);
    } else {
      ATH_MSG_WARNING("Element " << element->identString()
                      << " not assigned to any station!");
    }
  }
 
  // Assign back into the outer variants
  barrelStations       = std::move(barrel);
  endcapAStations      = std::move(endcapA);
  endcapCStations      = std::move(endcapC);
  endcapMiddleAStations= std::move(endcapMiddleA);
  endcapMiddleCStations= std::move(endcapMiddleC);
 
}, elements);
 
  // Top level node for the Muon system
auto muonNode = std::make_shared<Acts::Experimental::CylinderContainerBlueprintNode>("MuonNode", Acts::AxisDirection::AxisZ);
 
Acts::VolumeBoundFactory boundsFactory{};
auto barrelNode = buildMuonNode(gctx, barrelStations, "BI_BM_BO_EE_EI",Acts::GeometryIdentifier().withVolume(s_muonBarrelId), boundsFactory);
auto endcapANode = buildMuonNode(gctx, endcapAStations, "EO_A", Acts::GeometryIdentifier().withVolume(s_muonEndcapAId), boundsFactory);
auto endcapCNode = buildMuonNode(gctx, endcapCStations, "EO_C", Acts::GeometryIdentifier().withVolume(s_muonEndcapCId), boundsFactory);
auto endcapMiddleANode = buildMuonNode(gctx, endcapMiddleAStations, "EM_A", Acts::GeometryIdentifier().withVolume(s_muonEndcapMiddleAId), boundsFactory);
auto endcapMiddleCNode = buildMuonNode(gctx, endcapMiddleCStations, "EM_C", Acts::GeometryIdentifier().withVolume(s_muonEndcapMiddleCId), boundsFactory);
 
//Add to the muon barrel child node (e.g calo or Itk) - if existed
if(childNode){
  barrelNode->addChild(std::move(childNode));
}
muonNode->addChild(std::move(barrelNode));
muonNode->addChild(std::move(endcapANode));
muonNode->addChild(std::move(endcapCNode));
muonNode->addChild(std::move(endcapMiddleANode));
muonNode->addChild(std::move(endcapMiddleCNode));
 
return muonNode;
 
}

buildMuonNode()

template<typename MuonElementsSet>

std::shared_ptr< Acts::Experimental::StaticBlueprintNode > ActsTrk::MuonBlueprintNodeBuilder::buildMuonNode ( const Acts::GeometryContext & gctx, const MuonElementsSet & elements, const std::string & name, const Acts::GeometryIdentifier & id, Acts::VolumeBoundFactory & boundsFactory ) const

private

Build subnodes for the muon system node.

Parameters

gctx	The geometry context
elements	The name of the stations to include
side	The side (A, C or Both)
id	The geometry identifier of this node
boundsFactory	The factory for volume bounds

Definition at line 123 of file MuonBlueprintNodeBuilder.cxx.

                                                 {
 
    const ActsTrk::GeometryContext* context = gctx.get<const ActsTrk::GeometryContext* >();
    std::vector<std::string> stationNames;
  
    std::vector<std::shared_ptr<Acts::Experimental::StaticBlueprintNode>> nodes;
  
    double innerRadius = 0.0;
    double outerRadius = std::numeric_limits<double>::lowest();
    double maxZ = std::numeric_limits<double>::lowest();
    double minZ = std::numeric_limits<double>::max();
    int chamberId = 1;    
    std::visit([&](const auto& elems){
  
    for(const auto& element : elems){
      const Amg::Transform3D& transform = element->localToGlobalTransform(*context);
      std::string volName = element->identString();
 
      auto vol = std::make_unique<Acts::TrackingVolume>(
                                            transform,
                                            element->bounds(),
                                            volName);
 
      // Get material per chamber, blend it and place it in the center of the volume
      auto material = blendMaterial(*element);
      vol->addSurface(std::move(material));
      // //the chamber geometry id
      Acts::GeometryIdentifier chId = id.withLayer(chamberId++);
      vol->assignGeometryId(chId);
      std::pair<std::vector<staticNodePtr>,std::vector<surfacePtr>> innerStructure = getSensitiveElements(*context, *element, chId, boundsFactory);
      for(auto& surface: innerStructure.second){
        vol->addSurface(surface);
      }
      //calculate the bounds of the cylinder container
      for(const auto& surface: vol->boundarySurfaces()){
        const auto& surfaceRepr = surface->surfaceRepresentation();
        const Acts::Polyhedron& polyhedron = surfaceRepr.polyhedronRepresentation(gctx);
        const Amg::Vector3D& center = surfaceRepr.center(gctx);
 
        maxZ = std::max(maxZ, center.z());
        minZ = std::min(minZ, center.z());
 
        // Outer radius needs to be treated differently due to curvature of cylindrical surface
        for(const Amg::Vector3D& vertex: polyhedron.vertices){
          outerRadius = std::max(outerRadius, vertex.perp());
        }
      }
     
      std::shared_ptr<Acts::Experimental::StaticBlueprintNode> node;
      const bool isSingleMdt =
          (element->readoutEles().size() == 1 &&
          element->readoutEles().front()->detectorType() == DetectorType::Mdt);
 
      if (isSingleMdt) {
          // Take ownership of the single existing node
          node = std::move(innerStructure.first.front());
      } else {
          node = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(vol));
          for (auto& childNode : innerStructure.first) {
              node->addChild(std::move(childNode));
          }
          innerStructure.first.clear();
      }
      if (!node) {
          THROW_EXCEPTION("No blueprint node constructed");
      }
      nodes.emplace_back(std::move(node));
      }
 
    }, elements);
 
    double halfLengthZ = 0.5 * std::abs(maxZ - minZ);
    ATH_MSG_DEBUG("Inner radius: " << innerRadius);
    ATH_MSG_DEBUG("Outer radius: " << outerRadius);
    ATH_MSG_DEBUG("Max Z: " << maxZ);
    ATH_MSG_DEBUG("Min Z: " << minZ);
    ATH_MSG_DEBUG("Half length Z: " << halfLengthZ);
 
    Amg::Transform3D trf = Amg::getTranslateZ3D(halfLengthZ + minZ);
 
    auto bounds = boundsFactory.makeBounds<Acts::CylinderVolumeBounds>(innerRadius, outerRadius, halfLengthZ);
    auto volume = std::make_unique<Acts::TrackingVolume>(trf, bounds, name);
    volume->assignGeometryId(id);
    auto muonNode = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(volume));
 
    ATH_MSG_DEBUG("There are " << nodes.size() << " nodes");
    std::ranges::for_each(nodes, [&muonNode](auto& node) {
      muonNode->addChild(std::move(node));
    });
    return muonNode;
  }

getSensitiveElements()

template<typename T>

std::pair< std::vector< staticNodePtr >, std::vector< surfacePtr > > ActsTrk::MuonBlueprintNodeBuilder::getSensitiveElements ( const ActsTrk::GeometryContext & gctx, const T & element, const Acts::GeometryIdentifier & chId, Acts::VolumeBoundFactory & boundsFactory ) const

private

Get the chamber's sensitive elements.

Parameters

gctx	The geometry context
element	The element for which to get the sensitive elements (chamber or sector)
chId	The geometry identifier of the chamber
boundsFactory	The factory for volume bounds This function constructs and returns the sensitive elements (volumes and surfaces) of the sector.

Definition at line 222 of file MuonBlueprintNodeBuilder.cxx.

                                                 {
 
  std::vector<staticNodePtr> readoutVolumes;
  std::vector<surfacePtr> readoutSurfaces;
  Acts::GeometryIdentifier::Value mdtId{1};
 
  //lamda function for BIS78 MDT case
  auto isBIS78 = [this](const MuonGMR4::MuonReadoutElement* rElem) {
 
    if(rElem->detectorType() != DetectorType::Mdt){
      return false;
    }
    
    auto& mdtIdHelper = m_detMgr->idHelperSvc()->mdtIdHelper();
    const int BIS = mdtIdHelper.stationNameIndex("BIS");
    int stEta = rElem->stationEta();
 
    return rElem->stationName() == BIS && std::abs(stEta) >= 7;
 
  };
 
  for (const MuonGMR4::MuonReadoutElement* readoutEle : element.readoutEles()) {
 
    std::vector<surfacePtr> detSurfaces = readoutEle->getSurfaces();
    switch(readoutEle->detectorType()){
      case DetectorType::Mdt: {    
        const auto* mdtReadoutEle = static_cast<const MuonGMR4::MdtReadoutElement*>(readoutEle);
        const MuonGMR4::MdtReadoutElement::parameterBook& parameters{mdtReadoutEle->getParameters()};
 
          // get the transform to the sector's frame
          const Amg::Vector3D toChamber = element.globalToLocalTransform(gctx)*mdtReadoutEle->center(gctx);
          Acts::Transform3 mdtTransform = element.localToGlobalTransform(gctx) * Amg::getTranslate3D(toChamber);
 
          // create the MDT multilayer volume with the dedicated builder
          Acts::Experimental::MultiWireVolumeBuilder::Config mwCfg;
          mwCfg.name = m_detMgr->idHelperSvc()->toStringDetEl(mdtReadoutEle->identify());
          mwCfg.mlSurfaces = detSurfaces;
          mwCfg.transform = mdtTransform;
 
          //special treatment of BIS78 MDT multilayer
          //use different shape because of clashes with EIL chambers 
          std::shared_ptr<Acts::VolumeBounds> mdtBounds{nullptr};
          if(isBIS78(readoutEle) && mdtReadoutEle->multilayer() == 2){
            
            //find the minimum and the maximum tube length (x dimension of the diamond bounds)
            std::vector<double> tubeLengths;
            tubeLengths.reserve(mdtReadoutEle->numTubesInLay());
            for(std::size_t tube = 1; tube < mdtReadoutEle->numTubesInLay(); ++tube){
              const IdentifierHash tubeHash = MuonGMR4::MdtReadoutElement::measurementHash(1,tube);
              double tubeLength = mdtReadoutEle->tubeLength(tubeHash);
              tubeLengths.push_back(tubeLength);
            }
            auto [minX,maxX] = std::ranges::minmax_element(tubeLengths);
            int nSmallTubes = std::count_if(tubeLengths.begin(), tubeLengths.end(), [minX](double length){
              return std::abs(*minX-length) < Acts::s_epsilon;
            });
 
            //create the diamond bounds for the volume
            double y2 = (nSmallTubes+1)*parameters.tubePitch ;
            double y1 = 2*parameters.halfY - y2;           
            mdtTransform = mdtTransform*Amg::getTranslateY3D(parameters.halfY-y2);    
            mdtBounds = boundsFactory.makeBounds<Acts::DiamondVolumeBounds>(0.5*(*maxX), 0.5*(*maxX), 0.5*(*minX), 
                                                                            y1, y2, parameters.halfHeight);            
          }else{
          //check for rectangular or trapezoidal shape bounds       
          if(std::abs(parameters.shortHalfX - parameters.longHalfX) < Acts::s_epsilon){
            mdtBounds = boundsFactory.makeBounds<Acts::CuboidVolumeBounds>(parameters.shortHalfX, parameters.halfY, parameters.halfHeight);           
          } else {            
            mdtBounds = boundsFactory.makeBounds<Acts::TrapezoidVolumeBounds>(parameters.shortHalfX, 
              parameters.longHalfX, parameters.halfY, parameters.halfHeight);
          }
          }          
          mwCfg.bounds = mdtBounds;
          mwCfg.transform = mdtTransform;
          using BoundsV = Acts::TrapezoidVolumeBounds::BoundValues;
          mwCfg.binning = {{{Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,
                            -parameters.halfY,
                            parameters.halfY,
                            static_cast<std::size_t>(std::lround(2 * parameters.halfY / parameters.tubePitch))}, 2u},
                            {{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,
                              -parameters.halfHeight,
                              parameters.halfHeight,
                              static_cast<std::size_t>(std::lround(2 * parameters.halfHeight / parameters.tubePitch))}, 1u}};
          Acts::Experimental::MultiWireVolumeBuilder mdtBuilder{mwCfg};
          std::unique_ptr<Acts::TrackingVolume> mdtVolume = mdtBuilder.buildVolume();
 
          mdtVolume->assignGeometryId(chId.withExtra(mdtId++));
          //create the blueprint node for the mdt multilayers
          std::shared_ptr<Acts::Experimental::StaticBlueprintNode> mdtNode = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(mdtVolume));
          mdtNode->setNavigationPolicyFactory(mdtBuilder.createNavigationPolicyFactory());
          readoutVolumes.push_back(std::move(mdtNode));
 
          break;
 
        } case DetectorType::Rpc: 
          case DetectorType::Tgc:
          case DetectorType::sTgc:
          case DetectorType::Mm: {              
             
          readoutSurfaces.insert(readoutSurfaces.end(), std::make_move_iterator(detSurfaces.begin()),
                                 std::make_move_iterator(detSurfaces.end()));
 
          break;
 
        } default: 
              THROW_EXCEPTION("Unknown detector type for readout element: " << ActsTrk::to_string(readoutEle->detectorType()));
              break;
     
    }
  }
 
  return std::make_pair(std::move(readoutVolumes), std::move(readoutSurfaces));
}

initialize()

StatusCode ActsTrk::MuonBlueprintNodeBuilder::initialize ( )

override

Definition at line 46 of file MuonBlueprintNodeBuilder.cxx.

                                                 {
        ATH_CHECK(detStore()->retrieve(m_detMgr));
        return StatusCode::SUCCESS;
  }

isElementInTheStation()

template<typename T>

bool ActsTrk::MuonBlueprintNodeBuilder::isElementInTheStation ( const T & element, const std::vector< StIdx > & stationNames, const EndcapSide & side ) const

private

Check if the chamber is in this node.

Parameters

element	The element to check (chamber or sector)
stationNames	The names of the stations to check against
side	The side of the endcap (A, C or Both) This function checks if the chamber is part of the configured chambers in this node. It is used to filter out chambers that are not part of this muon node.

Definition at line 365 of file MuonBlueprintNodeBuilder.cxx.

                                                                                                                                         {
  StIdx stationIdx = toStationIndex(element.chamberIndex());
  auto stationSide = element.side(); 
  bool matchesName = std::ranges::any_of(stationIndex.begin(), stationIndex.end(), [&](const auto& n){
        return stationIdx == n;
      });
 
  bool etaSignCorrect = ((stationSide > 0 && side == EndcapSide::A) || (stationSide < 0 && side == EndcapSide::C) || (side == EndcapSide::Both));
  return matchesName && etaSignCorrect;
}

Member Data Documentation

m_detMgr

const MuonGMR4::MuonDetectorManager* ActsTrk::MuonBlueprintNodeBuilder::m_detMgr {nullptr}

private

Definition at line 69 of file MuonBlueprintNodeBuilder.h.

{nullptr};

m_useSectors

Gaudi::Property<bool> ActsTrk::MuonBlueprintNodeBuilder::m_useSectors {this, "UseSectors", false}

private

Definition at line 71 of file MuonBlueprintNodeBuilder.h.

{this, "UseSectors", false}; // Flag to control if we want to build the muon node from sectors or chambers

---

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

• MuonBlueprintNodeBuilder.h
• MuonBlueprintNodeBuilder.cxx