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	EndcapSide { EndcapSide::A, EndcapSide::C, EndcapSide::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. More...

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. More...
template<typename T >
std::pair< std::vector< staticNodePtr >, std::vector< surfacePtr > >	getSensitiveElements (const ActsGeometryContext &gctx, const T &element, const Acts::GeometryIdentifier &chId, Acts::VolumeBoundFactory &boundsFactory) const
	Get the chamber's sensitive elements. More...
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. More...
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. More...

Private Attributes
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
Gaudi::Property< bool >	m_dumpVolumes {this, "dumpVolumes", true}
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 ActsTrk::MuonBlueprintNodeBuilder::EndcapSide

strong

Enumerator
A
C
Both

Definition at line 54 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 298 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 = Acts::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 49 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.insert(element);
    } else if (isElementInTheStation(*element, {StIdx::EO}, EndcapSide::A)) {
      endcapA.insert(element);
    } else if (isElementInTheStation(*element, {StIdx::EO}, EndcapSide::C)) {
      endcapC.insert(element);
    } else if (isElementInTheStation(*element, {StIdx::EM}, EndcapSide::A)) {
      endcapMiddleA.insert(element);
    } else if (isElementInTheStation(*element, {StIdx::EM}, EndcapSide::C)) {
      endcapMiddleC.insert(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 122 of file MuonBlueprintNodeBuilder.cxx.

                                                 {
 
    const ActsGeometryContext* context = gctx.get<const ActsGeometryContext* >();
    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->localToGlobalTrans(*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());
        }
      }
      if(m_dumpVolumes){
        //for visualizing each chamber volume individually
        Acts::ObjVisualization3D helper;
        vol->visualize(helper, gctx, {.visible = true},
                                {.visible = true}, {.visible = true});
        helper.write(volName + ".obj");
        helper.clear();
      }
 
      auto node = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(vol));
      for(auto& childNode : innerStructure.first){
        node->addChild(std::move(childNode));
        
      }
 
 
      
      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 ActsGeometryContext &  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 223 of file MuonBlueprintNodeBuilder.cxx.

                                                 {
 
  std::vector<staticNodePtr> readoutVolumes;
  std::vector<surfacePtr> readoutSurfaces;
  Acts::GeometryIdentifier::Value mdtId{1};
 
  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.globalToLocalTrans(gctx)*mdtReadoutEle->center(gctx);
          const Acts::Transform3 mdtTransform = element.localToGlobalTrans(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;
 
          auto mdtBounds = boundsFactory.makeBounds<Acts::TrapezoidVolumeBounds>(parameters.shortHalfX, 
          parameters.longHalfX, parameters.halfY, parameters.halfHeight);
 
          mwCfg.bounds = mdtBounds;
          using BoundsV = Acts::TrapezoidVolumeBounds::BoundValues;
          mwCfg.binning = {{{Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,
                            -mdtBounds->get(BoundsV::eHalfLengthY),
                            mdtBounds->get(BoundsV::eHalfLengthY),
                            static_cast<std::size_t>(std::lround(2 * mdtBounds->get(BoundsV::eHalfLengthY) / parameters.tubePitch))}, 2u},
                            {{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,
                              -mdtBounds->get(BoundsV::eHalfLengthZ),
                              mdtBounds->get(BoundsV::eHalfLengthZ),
                              static_cast<std::size_t>(std::lround(2 * mdtBounds->get(BoundsV::eHalfLengthZ) / 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 43 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 320 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 72 of file MuonBlueprintNodeBuilder.h.

m_dumpVolumes

Gaudi::Property<bool> ActsTrk::MuonBlueprintNodeBuilder::m_dumpVolumes {this, "dumpVolumes", true}

private

Definition at line 74 of file MuonBlueprintNodeBuilder.h.

m_useSectors

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

private

Definition at line 76 of file MuonBlueprintNodeBuilder.h.

---

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

• MuonBlueprintNodeBuilder.h
• MuonBlueprintNodeBuilder.cxx