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 : std::uint8_t { A , C , Both }
using	blueprintNodePtr = std::shared_ptr<Acts::Experimental::BlueprintNode>
	Abrivation of the blueprint node ptr base class.
using	staticNodePtr = std::shared_ptr<Acts::Experimental::StaticBlueprintNode>
	Abrivation of the blue print node pointer.
using	materialNodePtr = std::shared_ptr<Acts::Experimental::MaterialDesignatorBlueprintNode>
	Abrivation of the material node pointer.
using	surfacePtr = std::shared_ptr<Acts::Surface>
	Abrivation of the surface pointer.
using	BluePrintSurfPairs_t = std::pair<std::vector<blueprintNodePtr>, std::vector<surfacePtr>>
	Abrivate the vector pair of blue print nodes and associated active surfaces.
using	MuonChamberSet = MuonGMR4::MuonDetectorManager::MuonChamberSet
	Abrivation of the container holding all chambers.
using	MuonSectorSet = MuonGMR4::MuonDetectorManager::MuonSectorSet
	Abrivation of the container holding all ms sectors.
using	StIdx = Muon::MuonStationIndex::StIndex
	Abrivation of the station index.
using	DetIdx = Muon::MuonStationIndex::DetectorRegionIndex
	Abrivatin for the detector region index.
using	LayIdx = Muon::MuonStationIndex::LayerIndex
	Abrivation for the layer index.
using	ChIdx = Muon::MuonStationIndex::ChIndex
	Abrivation for the chamber index.
using	DetLayIdx_t = std::pair<DetIdx, LayIdx>
	Abrivation for the stations indices.
using	EnvelopeSet_t = std::variant<MuonChamberSet, MuonSectorSet>
	Hide the flexibility to build the tracking geometry from sectors or chambers behind a variant.
using	EnvelopesPerStIdx_t = std::unordered_map<StIdx, EnvelopeSet_t>

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.
template<typename ElementSet_t>
std::vector< std::shared_ptr< Acts::Surface > >	getPassiveMaterialSurfaces (const Acts::GeometryContext &gctx, const std::unordered_map< unsigned int, ElementSet_t > &elementsPerStation) const

Private Member Functions
std::shared_ptr< Acts::ISurfaceMaterial >	preparePassiveMaterial (const Acts::SurfaceBounds &bounds, const std::size_t nBins1, const std::size_t nBins2) const
	Prepare a binned material which is associated to the surface.
std::pair< std::size_t, std::size_t >	getMaterialBins (const Muon::MuonStationIndex::ChIndex chIdx) const
template<typename T> requires (std::is_same_v<T, MuonGMR4::Chamber> \|\| std::is_same_v<T, MuonGMR4::SpectrometerSector>)
BluePrintSurfPairs_t	getSensitiveElements (const ActsTrk::GeometryContext &gctx, const T &element, const Acts::GeometryIdentifier &chId, Acts::VolumeBoundFactory &boundsFactory) const
	Get the chamber's sensitive elements.
template<typename ElementSet_t>
std::vector< surfacePtr >	getPassiveMaterialSurfaces (const Acts::GeometryContext &gctx, const std::unordered_map< unsigned int, ElementSet_t > &elementsPerStation) const
	Construct and return the surfaces for the passive material description (e.g cylinders for barrel/ discs for endcaps).
template<typename T> requires (std::is_same_v<T, MuonGMR4::Chamber> \|\| std::is_same_v<T, MuonGMR4::SpectrometerSector>)
std::shared_ptr< const Acts::ISurfaceMaterial >	getActiveMaterial (const T &element) const
	Get the active material for a given element representing the chamber/sector.
template<typename T> requires (std::is_same_v<T, MuonGMR4::Chamber> \|\| std::is_same_v<T, MuonGMR4::SpectrometerSector>)
bool	isElementInTheStation (const T &element, const std::vector< StIdx > &stationNames, const EndcapSide side) const
	Check if the chamber is in this node.
staticNodePtr	buildMuonNode (const Acts::GeometryContext &gctx, const EnvelopeSet_t &elements, const std::string &name, const Acts::GeometryIdentifier &id, Acts::VolumeBoundFactory &boundsFactory, const std::vector< ChIdx > &passiveStationIds={}) const
	Build subnodes for the muon system node.
std::variant< staticNodePtr, materialNodePtr >	buildChamberNode (const blueprintNodePtr &chamberNode) const
	Build a static or a material node for a chamber that corresponds to a single blueprint node (e.g for a single MDT multilayer).
template<typename T>
std::variant< staticNodePtr, materialNodePtr >	buildChamberNode (const T &element, std::unique_ptr< Acts::TrackingVolume > &vol, const std::vector< blueprintNodePtr > &innerStructure) const
	Build a static or a material node for a chamber that corresponds to a single blueprint node (e.g for a single MDT multilayer).
bool	isBIS78 (const MuonGMR4::MuonReadoutElement *element) const
	Helper function determining whether a readout element is BIS78.

Private Attributes
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
	the Detector manager
Gaudi::Property< bool >	m_useSectors {this, "UseSectors", false}
	Flag to control if we want to build the muon node from sectors or chambers.
Gaudi::Property< bool >	m_alignableVolumes {this, "AlignableVolumes", true}
	Flag to control if the volumes should be alignable or not.
Gaudi::Property< bool >	m_assignActiveMaterial {this, "AssignActiveMaterial", false}
	Flag to assign active material on the chambers.
Gaudi::Property< bool >	m_buildPassiveVolumes {this, "BuildPassiveVolumes", true}
	Flag to construct the passive material surfaces.
Gaudi::Property< std::size_t >	m_nPhiBinsBI {this, "nPhiBinsBI", 16}
	Number of bins in phi direction on the BI cylinder surface.
Gaudi::Property< std::size_t >	m_nZBinsBI {this, "nZBinsBI", 12}
	Number of bins in Z direction on the BI cylinder surface.
Gaudi::Property< std::size_t >	m_nPhiBinsBM {this, "nPhiBinsBM", 16}
	Number of bins in phi direction on the BM cylinder surface.
Gaudi::Property< std::size_t >	m_nZBinsBM {this, "nZBinsBM", 12}
	Number of bins in Z direction on the BM cylinder surface.
Gaudi::Property< std::size_t >	m_nPhiBinsBO {this, "nPhiBinsBO", 16}
	Number of bins in phi direction on the BM cylinder surface.
Gaudi::Property< std::size_t >	m_nZBinsBO {this, "nZBinsBO", 12}
	Number of bins in Z direction on the BM cylinder surface.
Gaudi::Property< std::size_t >	m_nRBinsEI1 {this, "nRBinsEIbNSW", 4}
	Number of bins in R direction on the disc before the NSW.
Gaudi::Property< std::size_t >	m_nPhiBinsEI1 {this, "nPhiBinsEIbNSW", 16}
	Number of bins in phi direction on the disc before the NSW.
Gaudi::Property< std::size_t >	m_nRBinsEI2 {this, "nRBinsEIaNSW", 4}
	Number of bins in R direction on the disc after the NSW.
Gaudi::Property< std::size_t >	m_nPhiBinsEI2 {this, "nPhiBinsEIaNSW", 16}
	Number of bins in phi direction on the disc after the NSW.
Gaudi::Property< std::size_t >	m_nRBinsEM1 {this, "nRBinsEMbBW", 16}
	Number of bins in R direction on the disc before the middle big wheel.
Gaudi::Property< std::size_t >	m_nPhiBinsEM1 {this, "nPhiBinsEMbBW", 16}
	Number of bins in phi direction on the disc before the middle big wheel.
Gaudi::Property< std::size_t >	m_nRBinsEM2 {this, "nRBinsEMaBW", 5}
	Number of bins in R direction on the disc after the middle big wheel.
Gaudi::Property< std::size_t >	m_nPhiBinsEM2 {this, "nPhiBinsEMaBW", 16}
	Number of bins in phi direction on the disc after the NSW.

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 42 of file MuonBlueprintNodeBuilder.h.

Member Typedef Documentation

◆ blueprintNodePtr

using ActsTrk::MuonBlueprintNodeBuilder::blueprintNodePtr = std::shared_ptr<Acts::Experimental::BlueprintNode>

Abrivation of the blueprint node ptr base class.

Definition at line 45 of file MuonBlueprintNodeBuilder.h.

◆ BluePrintSurfPairs_t

using ActsTrk::MuonBlueprintNodeBuilder::BluePrintSurfPairs_t = std::pair<std::vector<blueprintNodePtr>, std::vector<surfacePtr>>

Abrivate the vector pair of blue print nodes and associated active surfaces.

Definition at line 53 of file MuonBlueprintNodeBuilder.h.

◆ ChIdx

using ActsTrk::MuonBlueprintNodeBuilder::ChIdx = Muon::MuonStationIndex::ChIndex

Abrivation for the chamber index.

Definition at line 65 of file MuonBlueprintNodeBuilder.h.

◆ DetIdx

using ActsTrk::MuonBlueprintNodeBuilder::DetIdx = Muon::MuonStationIndex::DetectorRegionIndex

Abrivatin for the detector region index.

Definition at line 61 of file MuonBlueprintNodeBuilder.h.

◆ DetLayIdx_t

using ActsTrk::MuonBlueprintNodeBuilder::DetLayIdx_t = std::pair<DetIdx, LayIdx>

Abrivation for the stations indices.

Definition at line 67 of file MuonBlueprintNodeBuilder.h.

◆ EnvelopeSet_t

using ActsTrk::MuonBlueprintNodeBuilder::EnvelopeSet_t = std::variant<MuonChamberSet, MuonSectorSet>

Hide the flexibility to build the tracking geometry from sectors or chambers behind a variant.

Definition at line 70 of file MuonBlueprintNodeBuilder.h.

◆ EnvelopesPerStIdx_t

using ActsTrk::MuonBlueprintNodeBuilder::EnvelopesPerStIdx_t = std::unordered_map<StIdx, EnvelopeSet_t>

Definition at line 72 of file MuonBlueprintNodeBuilder.h.

◆ LayIdx

using ActsTrk::MuonBlueprintNodeBuilder::LayIdx = Muon::MuonStationIndex::LayerIndex

Abrivation for the layer index.

Definition at line 63 of file MuonBlueprintNodeBuilder.h.

◆ materialNodePtr

using ActsTrk::MuonBlueprintNodeBuilder::materialNodePtr = std::shared_ptr<Acts::Experimental::MaterialDesignatorBlueprintNode>

Abrivation of the material node pointer.

Definition at line 49 of file MuonBlueprintNodeBuilder.h.

◆ MuonChamberSet

using ActsTrk::MuonBlueprintNodeBuilder::MuonChamberSet = MuonGMR4::MuonDetectorManager::MuonChamberSet

Abrivation of the container holding all chambers.

Definition at line 55 of file MuonBlueprintNodeBuilder.h.

◆ MuonSectorSet

using ActsTrk::MuonBlueprintNodeBuilder::MuonSectorSet = MuonGMR4::MuonDetectorManager::MuonSectorSet

Abrivation of the container holding all ms sectors.

Definition at line 57 of file MuonBlueprintNodeBuilder.h.

◆ staticNodePtr

using ActsTrk::MuonBlueprintNodeBuilder::staticNodePtr = std::shared_ptr<Acts::Experimental::StaticBlueprintNode>

Abrivation of the blue print node pointer.

Definition at line 47 of file MuonBlueprintNodeBuilder.h.

◆ StIdx

using ActsTrk::MuonBlueprintNodeBuilder::StIdx = Muon::MuonStationIndex::StIndex

Abrivation of the station index.

Definition at line 59 of file MuonBlueprintNodeBuilder.h.

◆ surfacePtr

using ActsTrk::MuonBlueprintNodeBuilder::surfacePtr = std::shared_ptr<Acts::Surface>

Abrivation of the surface pointer.

Definition at line 51 of file MuonBlueprintNodeBuilder.h.

Member Enumeration Documentation

◆ EndcapSide

enum class ActsTrk::MuonBlueprintNodeBuilder::EndcapSide : std::uint8_t

strong

Enumerator
A
C
Both

Definition at line 74 of file MuonBlueprintNodeBuilder.h.

                       : std::uint8_t {
      A,
      C,
      Both
  };

Member Function Documentation

◆ 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 103 of file MuonBlueprintNodeBuilder.cxx.

                                                                                                                                                                                   {
 
EnvelopeSet_t elements;
EnvelopeSet_t barrelStations, endcapOuterAStations, endcapOuterCStations, 
              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);
  endcapOuterAStations = std::move(endcapA);
  endcapOuterCStations = 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, {ChIdx::BIS, ChIdx::BML, ChIdx::BOL, 
                                                                                                                                               ChIdx::EIS, ChIdx::EIL});
auto endcapANode = buildMuonNode(gctx, endcapOuterAStations, "EO_A", Acts::GeometryIdentifier().withVolume(s_muonEndcapAId), boundsFactory);
auto endcapCNode = buildMuonNode(gctx, endcapOuterCStations, "EO_C", Acts::GeometryIdentifier().withVolume(s_muonEndcapCId), boundsFactory);
auto endcapMiddleANode = buildMuonNode(gctx, endcapMiddleAStations, "EM_A", Acts::GeometryIdentifier().withVolume(s_muonEndcapMiddleAId), boundsFactory, {ChIdx::EML, ChIdx::EMS});
auto endcapMiddleCNode = buildMuonNode(gctx, endcapMiddleCStations, "EM_C", Acts::GeometryIdentifier().withVolume(s_muonEndcapMiddleCId), boundsFactory, {ChIdx::EML, ChIdx::EMS});
 
//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;
 
}

◆ buildChamberNode() [1/2]

std::variant< MuonBlueprintNodeBuilder::staticNodePtr, MuonBlueprintNodeBuilder::materialNodePtr > ActsTrk::MuonBlueprintNodeBuilder::buildChamberNode ( const blueprintNodePtr & chamberNode ) const

private

Build a static or a material node for a chamber that corresponds to a single blueprint node (e.g for a single MDT multilayer).

Parameters

chamberNode The blueprint node out of which the variant node will be built

Returns: A variant holding either a static node or material node depending on wether the assignment of active material is enabled

Definition at line 296 of file MuonBlueprintNodeBuilder.cxx.

                                                                                         {
    if (m_assignActiveMaterial) {
        auto materialNode = std::dynamic_pointer_cast<Acts::Experimental::MaterialDesignatorBlueprintNode>(chamberVolumeNode);  
        return materialNode;
    }
    auto staticNode = std::dynamic_pointer_cast<Acts::Experimental::StaticBlueprintNode>(chamberVolumeNode);
    return staticNode;   
}

◆ buildChamberNode() [2/2]

template<typename T>

std::variant< MuonBlueprintNodeBuilder::staticNodePtr, MuonBlueprintNodeBuilder::materialNodePtr > ActsTrk::MuonBlueprintNodeBuilder::buildChamberNode	(	const T &	element,
		std::unique_ptr< Acts::TrackingVolume > &	vol,
		const std::vector< blueprintNodePtr > &	innerStructure ) const

private

Build a static or a material node for a chamber that corresponds to a single blueprint node (e.g for a single MDT multilayer).

Parameters

innerStructure	The inner structure of the chamber that corresponds to the children nodes
element	The element representing the chamber/sector for which the node is built
vol	The tracking volume associated to the chamber/sector

Returns: A variant holding either a static node or material node depending on wether the assignment of active material is enabled

Definition at line 307 of file MuonBlueprintNodeBuilder.cxx.

                                                                                                  {
  //copy of the volume bounds
  const Acts::VolumeBounds& bounds = vol->volumeBounds();
  staticNodePtr staticNode = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(vol));
  for (auto& childNode : innerStructure) {
      auto node = std::dynamic_pointer_cast<Acts::Experimental::StaticBlueprintNode>(childNode);
      if (node) {
          staticNode->addChild(std::move(node));
      } 
  }
  if(!m_assignActiveMaterial){
    return staticNode;
  }
  auto materialNode = std::make_shared<Acts::Experimental::MaterialDesignatorBlueprintNode>(element->identString() + "_MaterialNode");
  configureMaterialFaces(*materialNode, bounds, getActiveMaterial(*element));
  materialNode->addChild(staticNode);
  return materialNode;
}

◆ buildMuonNode()

std::shared_ptr< Acts::Experimental::StaticBlueprintNode > ActsTrk::MuonBlueprintNodeBuilder::buildMuonNode	(	const Acts::GeometryContext &	gctx,
		const EnvelopeSet_t &	elements,
		const std::string &	name,
		const Acts::GeometryIdentifier &	id,
		Acts::VolumeBoundFactory &	boundsFactory,
		const std::vector< ChIdx > &	passiveStationIds = {} ) 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
passiveStationIds	The ids with the chamber indices we want to put passive material surfaces on

Definition at line 174 of file MuonBlueprintNodeBuilder.cxx.

                                                                                         {
 
    const ActsTrk::GeometryContext* context = gctx.get<const ActsTrk::GeometryContext* >();
    std::vector<std::string> stationNames;
 
    //build the material nodes that will have as children the static nodes bult from the tracking volumes of the chambers   
    std::vector<std::variant<staticNodePtr, materialNodePtr>> 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::vector<std::shared_ptr<Acts::Surface>> passiveSurfaces;
 
    std::visit([&](const auto& elems){
    
    using SetType = std::decay_t<decltype(elems)>;
    std::unordered_map<unsigned int, SetType> elementsPerStation;
  
    for(const auto& element : elems){
      std::unique_ptr<Acts::TrackingVolume> vol{};
      if (m_alignableVolumes) {
          vol = std::make_unique<Acts::TrackingVolume>(*element->boundingVolume(*context),
                                                       element->identString());
      } else {
          vol = std::make_unique<Acts::TrackingVolume>(element->localToGlobalTransform(*context),
                                                      element->bounds(),
                                                      element->identString());
      }
      // //the chamber geometry id
      Acts::GeometryIdentifier chId = id.withLayer(chamberId++);
      vol->assignGeometryId(chId);
      //build the inner structure of the chamber this will return inner sensitive surfaces 
      //or volumes that have already constructed as blueptint nodes and will nbe assigned as children to the element node
      std::pair<std::vector<blueprintNodePtr>,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->volumeBounds().orientedSurfaces(vol->localToGlobalTransform(gctx))) {
        const auto& surfaceRepr = (*surface.surface);
        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::variant<staticNodePtr, materialNodePtr> chamberNode;      
      const bool isSingleMdt =
          (element->readoutEles().size() == 1 &&
          element->readoutEles().front()->detectorType() == DetectorType::Mdt);
      //for the single MDT elements we build the material node during the volume construction 
      //and the node returned is the material node already
      if (isSingleMdt) {
          // Take ownership of the single existing node where we have already included the static node as child
          // if we allow active material assignment the node is the material node, otherwise it is the static node
        chamberNode = buildChamberNode(innerStructure.first.front());
      } else {
        //for the non single MDT elements we build the material node that has as child the static node representing the chamber volume if we build with material
        // or it is a static node with the other static nodes as children if not active material is assigned 
        chamberNode = buildChamberNode(element, vol, innerStructure.first);
        innerStructure.first.clear();
      }
      if (isNullVariant(chamberNode)) {
        THROW_EXCEPTION("No blueprint node constructed");
      }     
      nodes.push_back(std::move(chamberNode));
  
      //keep the elements of the stations we want to assign passive material surfaces     
      if(!Acts::rangeContainsValue(passiveStationIds, element->chamberIndex())){
        continue;
      }
 
      DetIdx detIdx = toDetectorRegionIndex(element->chamberIndex(), element->side());    
      elementsPerStation[regionChamberHash(detIdx, element->chamberIndex())].push_back(element);
    }
    //construct the surfaces we want to map passive material on using the elements' geometrical parameters
    passiveSurfaces = getPassiveMaterialSurfaces(gctx, std::move(elementsPerStation));
 
    }, elements);
 
    double halfLengthZ = 0.5 * std::abs(maxZ - minZ);
    ATH_MSG_DEBUG("Inner radius: " << innerRadius<<", outer radius: " << outerRadius
                 <<", max Z: " << maxZ<<", min Z: " << minZ<<", 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);
    
    //put the passive material surfaces into the volume
    std::ranges::for_each(passiveSurfaces, [&volume](auto& surf){
      volume->addSurface(surf);
    });
 
    auto muonNode = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(volume));
    ATH_MSG_DEBUG("There are " << nodes.size() << " nodes");
    //loop through the nodes-material pairs to add the nodes to the muon node and assign the material to the faces 
    std::ranges::for_each(nodes, [&muonNode](auto& nodeVariant){
      std::visit([&](auto&& ptr) {
        muonNode->addChild(ptr);
      }, nodeVariant);     
    });
    return muonNode;
  }

◆ getActiveMaterial()

template<typename T>
requires (std::is_same_v<T, MuonGMR4::Chamber> || std::is_same_v<T, MuonGMR4::SpectrometerSector>)

std::shared_ptr< const Acts::ISurfaceMaterial > ActsTrk::MuonBlueprintNodeBuilder::getActiveMaterial ( const T & element ) const

private

Get the active material for a given element representing the chamber/sector.

Parameters

element The element for which to get the active material

Returns: The active surface material

Definition at line 612 of file MuonBlueprintNodeBuilder.cxx.

                                                        {
  
  const float thickness = element.halfZ();
  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);
  Acts::MaterialSlab slab{aMat, thickness};
  std::shared_ptr<Acts::HomogeneousSurfaceMaterial> material = std::make_shared<Acts::HomogeneousSurfaceMaterial>(slab);
  material->scale(0.5); // we want to split the active material in two and put it on the two faces of the chamber bounds
 
  return material;
  
}

◆ getMaterialBins()

std::pair< std::size_t, std::size_t > ActsTrk::MuonBlueprintNodeBuilder::getMaterialBins ( const Muon::MuonStationIndex::ChIndex chIdx ) const

private

Definition at line 677 of file MuonBlueprintNodeBuilder.cxx.

                                                                       {
    switch(chIdx) {
      using enum ChIndex;
      case BIS:
      case BIL:
        return std::make_pair(1ul * m_nZBinsBI, 1ul * m_nPhiBinsBI);
      case BML:
      case BMS:
        return std::make_pair(1ul * m_nZBinsBM, 1ul * m_nPhiBinsBM);
      case BOL:
      case BOS:
        return std::make_pair(1ul * m_nZBinsBO, 1ul * m_nPhiBinsBO);
      case EIS:
        return std::make_pair(1ul*  m_nRBinsEI1, 1ul* m_nPhiBinsEI1);
      case EIL:
        return std::make_pair(1ul*  m_nRBinsEI2, 1ul* m_nPhiBinsEI2);
      case EMS:
        return std::make_pair(1ul*  m_nRBinsEM1, 1ul* m_nPhiBinsEM1);
      case EML:
        return std::make_pair(1ul*  m_nRBinsEM2, 1ul* m_nPhiBinsEM2);
      default:
        THROW_EXCEPTION("getMaterialBins() - "<<chName(chIdx)<<" is not yet implemented");
    }
    return std::make_pair(0ul, 0ul);
}

◆ getPassiveMaterialSurfaces() [1/2]

template<typename ElementSet_t>

std::vector< std::shared_ptr< Acts::Surface > > ActsTrk::MuonBlueprintNodeBuilder::getPassiveMaterialSurfaces	(	const Acts::GeometryContext &	gctx,
		const std::unordered_map< unsigned int, ElementSet_t > &	elementsPerStation ) const

Definition at line 472 of file MuonBlueprintNodeBuilder.cxx.

                                                                                {
 
  if (!m_buildPassiveVolumes) {
      return {};
  }
  //this is a margin to put the surfaces along Z 
  //(a margin distance from the corresponding chamber's boundary surface)
  constexpr double margin{4._mm};
 
  std::vector<std::shared_ptr<Acts::Surface>> surfaces;
  surfaces.reserve(elementsPerStation.size());
  LayIdx layIdx = LayIdx::LayerIndexMax;
  DetIdx detIdx = DetIdx::DetectorRegionIndexMax;
  
  const ActsTrk::GeometryContext* context = gctx.get<const ActsTrk::GeometryContext* >();
 
  //lamda function to reject BIS78 chambers from the extension of the passive surface
  //otherwise they create overlap with the NSW sectors - stop a little bit before the cylinder of the passive surface
  const auto rejectBIS78 = [&](const MuonGMR4::MuonReadoutElement* readoutEle) {
    bool reject{false};
    switch (readoutEle->detectorType()) {
      case DetectorType::Mdt: {
        const auto* techEle =
          static_cast<const MuonGMR4::MdtReadoutElement*>(readoutEle);
        if (techEle->multilayer() == 2) {
          reject = true;
        }
        break;
      }
      case DetectorType::Rpc: {
        const auto* techEle =
          static_cast<const MuonGMR4::RpcReadoutElement*>(readoutEle);
        if (techEle->doubletZ() == 2) {
          reject = true;
        }
        break;
      }
      default:
        break;
    }
    return isBIS78(readoutEle) && reject;
  };
 
  for(const auto& [hash, elements] : elementsPerStation){
 
    //decompose the layer hash to the detector region idx and layer index
    const auto& [detIdxVal, chIdx] = decomposeRegionChamberHash(hash);
    layIdx = toLayerIndex(chIdx);
    detIdx = detIdxVal;
 
    double maxZ{std::numeric_limits<double>::lowest()};
    double minZ{std::numeric_limits<double>::max()};
    double rMin{std::numeric_limits<double>::max()};
    double rMax{std::numeric_limits<double>::lowest()};
       //loop through the elements of every station to construct the cylinder/disc  surfaces
    for(const auto& el : elements){  
 
      if(rejectBIS78(el->readoutEles().front())){
        continue;
      }
      const Amg::Transform3D& locToGlobal = el->localToGlobalTransform(*context);
      const auto& bounds = el->bounds();
      for(const auto& surface : bounds->orientedSurfaces(locToGlobal)){
        const auto& surfaceRepr = (*surface.surface);
        const Amg::Vector3D& center = surfaceRepr.center(gctx);
        rMin = std::min(rMin, center.perp());
        minZ = std::min(minZ, center.z());
        maxZ = std::max(maxZ, center.z());
        rMax = std::max(rMax, center.perp());
      }
 
    }
    double halfZ = 0.5*std::abs(maxZ-minZ);  
    Amg::Transform3D trf = Amg::Transform3D::Identity();
    double zShift{0.};
    // the chambers are groupd per chamber index and detector region(side) - 
    // we can use the first one for the distinction
    const auto& testCh = elements.front();
    int8_t side = testCh->side();
    switch (testCh->chamberIndex()) {      
      //small NSW sectors (disc passive surface in front of NSW and one in front of EMS)
      case ChIdx::EIS : 
      case ChIdx::EMS :{
        side > 0 ? zShift = minZ - margin : zShift = maxZ + margin;
        trf = Amg::getTranslateZ3D(zShift);
        auto surface = Acts::Surface::makeShared<Acts::DiscSurface>(trf, std::make_shared<Acts::RadialBounds>(rMin, rMax));
        const auto [nBins1, nBins2] = getMaterialBins(testCh->chamberIndex());
        surface->assignSurfaceMaterial(preparePassiveMaterial(surface->bounds(), nBins1, nBins2));
        surfaces.push_back(surface);
        break;
        //large sectors (disc passive surface after NSW/EIL and after EML)
    } case ChIdx::EIL :
      case ChIdx::EML : {
        // HARDCODED!! (maybe think a better solution in the future) 
        // But for the EIL that we put after the EIS/EIL chambers we extend the radius of the disc surface 
        // in order to have a better coverage for the projections from EE
        if(testCh->chamberIndex() == ChIdx::EIL){
          rMax += 60*margin;
        }
        side > 0 ? zShift = maxZ + margin : zShift = minZ - margin;
        trf = Amg::getTranslateZ3D(zShift);
        auto surface = Acts::Surface::makeShared<Acts::DiscSurface>(trf, 
                             std::make_shared<Acts::RadialBounds>(rMin, rMax));
        const auto [nBins1, nBins2] = getMaterialBins(testCh->chamberIndex());
        surface->assignSurfaceMaterial(preparePassiveMaterial(surface->bounds(), nBins1, nBins2));
        surfaces.push_back(surface);
        break;
      } case ChIdx::BIS :
        case ChIdx::BML :
        case ChIdx::BOL : {
        trf = Amg::getTranslateZ3D(halfZ + minZ);
        auto surface = Acts::Surface::makeShared<Acts::CylinderSurface>(trf, 
                             std::make_shared<Acts::CylinderBounds>(rMin - margin, halfZ));
        const auto [nBins1, nBins2] = getMaterialBins(testCh->chamberIndex());
        surface->assignSurfaceMaterial(preparePassiveMaterial(surface->bounds(), nBins1, nBins2));
        surfaces.push_back(surface);
        break;
    } default :
        THROW_EXCEPTION("No implementation of passive material surface for this station!!!! - sorry :) ");
    }    
    ATH_MSG_VERBOSE("Putting passive material surface for station " << layerName(layIdx) << "/ "<< regionName(detIdx) << ": minZ = " << minZ << ", maxZ = " << maxZ<< "and radius "<< rMax);
  }
 
  if(msgLvl(MSG::VERBOSE)){
    std::stringstream stream{};
    for(const auto& surf : surfaces){
      stream<< " at position  : "<< Amg::toString(surf->center(gctx))
             << "with bounds "<< surf->bounds()<<std::endl;
    }
    ATH_MSG_VERBOSE("Constructed "<< surfaces.size()
        << " surfaces for passive material description : "<<std::endl<<stream.str());
  }
 
  return surfaces;
}

◆ getPassiveMaterialSurfaces() [2/2]

template<typename ElementSet_t>

std::vector< surfacePtr > ActsTrk::MuonBlueprintNodeBuilder::getPassiveMaterialSurfaces	(	const Acts::GeometryContext &	gctx,
		const std::unordered_map< unsigned int, ElementSet_t > &	elementsPerStation ) const

private

Construct and return the surfaces for the passive material description (e.g cylinders for barrel/ discs for endcaps).

Parameters

gctx	The geometry context
elementsPerStation	The elements (chambers or sectors) grouped per station to which we want to assign passive material This function uses the elements of the station to construct the surfaces and define their bounds

◆ getSensitiveElements()

template<typename T>
requires (std::is_same_v<T, MuonGMR4::Chamber> || std::is_same_v<T, MuonGMR4::SpectrometerSector>)

MuonBlueprintNodeBuilder::BluePrintSurfPairs_t 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	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 331 of file MuonBlueprintNodeBuilder.cxx.

                                                                                               {
  
  std::vector<blueprintNodePtr> 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()};
 
          std::unique_ptr<ActsTrk::VolumePlacement> placement{};
 
          // 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 = readoutEle->localToGlobalTransform(gctx);
 
          //initialize a nullptr material node which will be filled in the case of single MDT readout elements 
          //and used to assign the material to the volume and add the static node as child of the material node
          std::shared_ptr<Acts::Experimental::MaterialDesignatorBlueprintNode> mdtMaterialNode;
 
          //special treatment of BIS78 MDT multilayer
          //use different shape because of clashes with EIL chambers 
          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);
              const auto& surface = mdtReadoutEle->surface(tubeHash);
              const auto& lBounds = static_cast<const Acts::LineBounds&>(surface.bounds());
              using BoundEnum = Acts::LineBounds::BoundValues;
              const double tubeLength = 2.*lBounds.get(BoundEnum::eHalfLengthZ);
              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
            constexpr double extraMargin = 1._cm;
            double y2 = (nSmallTubes+1.)*parameters.tubePitch;
            double y1 = 2.*parameters.halfY + extraMargin - y2;
            if (m_alignableVolumes) {         
                placement = std::make_unique<ActsTrk::VolumePlacement>(*readoutEle, 
                                                                       Amg::getTranslateY3D(parameters.halfY + extraMargin -y2));   
            }
            mwCfg.transform = mwCfg.transform * Amg::getTranslateY3D(parameters.halfY + extraMargin - y2);
            mwCfg.bounds = boundsFactory.makeBounds<Acts::DiamondVolumeBounds>(0.5*(*maxX), 0.5*(*maxX), 0.5*(*minX), 
                                                                               y1, y2, parameters.halfHeight);                                                                     
                    
          } else {
            if (m_alignableVolumes){
                placement = std::make_unique<ActsTrk::VolumePlacement>(*readoutEle);
            }
            //check for rectangular or trapezoidal shape bounds
            if(std::abs(parameters.shortHalfX - parameters.longHalfX) < Acts::s_epsilon){
              mwCfg.bounds = boundsFactory.makeBounds<Acts::CuboidVolumeBounds>(parameters.shortHalfX, 
                                                                                parameters.halfY, 
                                                                                parameters.halfHeight);
            } else { 
              mwCfg.bounds = boundsFactory.makeBounds<Acts::TrapezoidVolumeBounds>(parameters.shortHalfX,
                                                                                   parameters.longHalfX,
                                                                                   parameters.halfY,
                                                                                   parameters.halfHeight);
            }
          }
          mwCfg.alignablePlacement = placement.get();
          if (m_alignableVolumes){
              element.addPlacement(std::move(placement));
          }
          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
          // check if this is a single mdt (single multilayer) chamber so we assign the material directly to the multilayer
          if(element.readoutEles().size() == 1 && m_assignActiveMaterial){
 
            mdtMaterialNode = std::make_shared<Acts::Experimental::MaterialDesignatorBlueprintNode>(element.identString() + "_MaterialNode");
            configureMaterialFaces(*mdtMaterialNode, mdtVolume->volumeBounds(), getActiveMaterial(element));
            auto staticNode = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(mdtVolume));
            mdtMaterialNode->addChild(std::move(staticNode));
            readoutVolumes.push_back(std::move(mdtMaterialNode));
            break;
          }
          auto 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 97 of file MuonBlueprintNodeBuilder.cxx.

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

◆ isBIS78()

bool ActsTrk::MuonBlueprintNodeBuilder::isBIS78 ( const MuonGMR4::MuonReadoutElement * element ) const

private

Helper function determining whether a readout element is BIS78.

Definition at line 464 of file MuonBlueprintNodeBuilder.cxx.

                                                                                      {    
      return element->detectorType() == ActsTrk::DetectorType::Mdt && 
             element->chamberIndex() == ChIndex::BIS && 
             element->stationEta()>=7;
  }

◆ isElementInTheStation()

template<typename T>
requires (std::is_same_v<T, MuonGMR4::Chamber> || std::is_same_v<T, MuonGMR4::SpectrometerSector>)

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 631 of file MuonBlueprintNodeBuilder.cxx.

                                                        {
  bool etaSignCorrect = (side == EndcapSide::Both) ||
                        (side == EndcapSide::A && element.side() > 0) || 
                        (side == EndcapSide::C && element.side() < 0);
  return etaSignCorrect && 
         Acts::rangeContainsValue(stationIndex, toStationIndex(element.chamberIndex()));
}

◆ preparePassiveMaterial()

std::shared_ptr< Acts::ISurfaceMaterial > ActsTrk::MuonBlueprintNodeBuilder::preparePassiveMaterial	(	const Acts::SurfaceBounds &	bounds,
		const std::size_t	nBins1,
		const std::size_t	nBins2 ) const

private

Prepare a binned material which is associated to the surface.

Parameters

type	The surface type on which the material is mapped (Plane, Disc, Cylinder)
nBins1	Number of bins in the local0 direction
nBins2	Number of bins in the complementary direction

Definition at line 645 of file MuonBlueprintNodeBuilder.cxx.

                                                                                   {
    if (nBins1 == 0 || nBins2 == 0) {
      ATH_MSG_ERROR("Cannot create material for "<<bounds
        <<" as one of the bin dimensions is zero. nBins1: "<<nBins1<<", nBins2: "<<nBins2);
      return nullptr;
    }
    if (nBins1 == 1 && nBins1 == nBins2) {
      return std::make_shared<Acts::HomogeneousSurfaceMaterial>();
    }
 
    std::vector<Acts::DirectedProtoAxis> pmBinning = {};
 
    switch (bounds.type()) {
       using enum Acts::SurfaceBounds::BoundsType;
      case eCylinder: {
          pmBinning = {{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound, nBins1},
                       {Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Bound, nBins2}};        
          break;
      } case eDisc: {
          pmBinning = {{Acts::AxisDirection::AxisR, Acts::AxisBoundaryType::Bound, nBins1},
                       {Acts::AxisDirection::AxisPhi, Acts::AxisBoundaryType::Bound, nBins2}};
      
          break;
      } default:
        ATH_MSG_ERROR("Unsupoorted type "<<bounds<<".");
        return nullptr;
    }
    return std::make_shared<Acts::ProtoGridSurfaceMaterial>(pmBinning);
}

Member Data Documentation

◆ m_alignableVolumes

Gaudi::Property<bool> ActsTrk::MuonBlueprintNodeBuilder::m_alignableVolumes {this, "AlignableVolumes", true}

private

Flag to control if the volumes should be alignable or not.

Definition at line 94 of file MuonBlueprintNodeBuilder.h.

94{this, "AlignableVolumes", true};

◆ m_assignActiveMaterial

Gaudi::Property<bool> ActsTrk::MuonBlueprintNodeBuilder::m_assignActiveMaterial {this, "AssignActiveMaterial", false}

private

Flag to assign active material on the chambers.

Definition at line 96 of file MuonBlueprintNodeBuilder.h.

96{this, "AssignActiveMaterial", false};

◆ m_buildPassiveVolumes

Gaudi::Property<bool> ActsTrk::MuonBlueprintNodeBuilder::m_buildPassiveVolumes {this, "BuildPassiveVolumes", true}

private

Flag to construct the passive material surfaces.

Definition at line 98 of file MuonBlueprintNodeBuilder.h.

98{this, "BuildPassiveVolumes", true};

◆ m_detMgr

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

private

the Detector manager

Definition at line 90 of file MuonBlueprintNodeBuilder.h.

90{nullptr};

◆ m_nPhiBinsBI

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nPhiBinsBI {this, "nPhiBinsBI", 16}

private

Number of bins in phi direction on the BI cylinder surface.

Definition at line 100 of file MuonBlueprintNodeBuilder.h.

100{this, "nPhiBinsBI", 16};

◆ m_nPhiBinsBM

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nPhiBinsBM {this, "nPhiBinsBM", 16}

private

Number of bins in phi direction on the BM cylinder surface.

Definition at line 104 of file MuonBlueprintNodeBuilder.h.

104{this, "nPhiBinsBM", 16};

◆ m_nPhiBinsBO

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nPhiBinsBO {this, "nPhiBinsBO", 16}

private

Number of bins in phi direction on the BM cylinder surface.

Definition at line 108 of file MuonBlueprintNodeBuilder.h.

108{this, "nPhiBinsBO", 16};

◆ m_nPhiBinsEI1

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nPhiBinsEI1 {this, "nPhiBinsEIbNSW", 16}

private

Number of bins in phi direction on the disc before the NSW.

Definition at line 114 of file MuonBlueprintNodeBuilder.h.

114{this, "nPhiBinsEIbNSW", 16};

◆ m_nPhiBinsEI2

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nPhiBinsEI2 {this, "nPhiBinsEIaNSW", 16}

private

Number of bins in phi direction on the disc after the NSW.

Definition at line 118 of file MuonBlueprintNodeBuilder.h.

118{this, "nPhiBinsEIaNSW", 16};

◆ m_nPhiBinsEM1

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nPhiBinsEM1 {this, "nPhiBinsEMbBW", 16}

private

Number of bins in phi direction on the disc before the middle big wheel.

Definition at line 123 of file MuonBlueprintNodeBuilder.h.

123{this, "nPhiBinsEMbBW", 16};

◆ m_nPhiBinsEM2

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nPhiBinsEM2 {this, "nPhiBinsEMaBW", 16}

private

Number of bins in phi direction on the disc after the NSW.

Definition at line 127 of file MuonBlueprintNodeBuilder.h.

127{this, "nPhiBinsEMaBW", 16};

◆ m_nRBinsEI1

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nRBinsEI1 {this, "nRBinsEIbNSW", 4}

private

Number of bins in R direction on the disc before the NSW.

Definition at line 112 of file MuonBlueprintNodeBuilder.h.

112{this, "nRBinsEIbNSW", 4};

◆ m_nRBinsEI2

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nRBinsEI2 {this, "nRBinsEIaNSW", 4}

private

Number of bins in R direction on the disc after the NSW.

Definition at line 116 of file MuonBlueprintNodeBuilder.h.

116{this, "nRBinsEIaNSW", 4};

◆ m_nRBinsEM1

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nRBinsEM1 {this, "nRBinsEMbBW", 16}

private

Number of bins in R direction on the disc before the middle big wheel.

Definition at line 121 of file MuonBlueprintNodeBuilder.h.

121{this, "nRBinsEMbBW", 16};

◆ m_nRBinsEM2

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nRBinsEM2 {this, "nRBinsEMaBW", 5}

private

Number of bins in R direction on the disc after the middle big wheel.

Definition at line 125 of file MuonBlueprintNodeBuilder.h.

125{this, "nRBinsEMaBW", 5};

◆ m_nZBinsBI

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nZBinsBI {this, "nZBinsBI", 12}

private

Number of bins in Z direction on the BI cylinder surface.

Definition at line 102 of file MuonBlueprintNodeBuilder.h.

102{this, "nZBinsBI", 12};

◆ m_nZBinsBM

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nZBinsBM {this, "nZBinsBM", 12}

private

Number of bins in Z direction on the BM cylinder surface.

Definition at line 106 of file MuonBlueprintNodeBuilder.h.

106{this, "nZBinsBM", 12};

◆ m_nZBinsBO

Gaudi::Property<std::size_t> ActsTrk::MuonBlueprintNodeBuilder::m_nZBinsBO {this, "nZBinsBO", 12}

private

Number of bins in Z direction on the BM cylinder surface.

Definition at line 110 of file MuonBlueprintNodeBuilder.h.

110{this, "nZBinsBO", 12};

◆ m_useSectors

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

private

Flag to control if we want to build the muon node from sectors or chambers.

Definition at line 92 of file MuonBlueprintNodeBuilder.h.

92{this, "UseSectors", false};

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

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ blueprintNodePtr

◆ BluePrintSurfPairs_t

◆ ChIdx

◆ DetIdx

◆ DetLayIdx_t

◆ EnvelopeSet_t

◆ EnvelopesPerStIdx_t

◆ LayIdx

◆ materialNodePtr

◆ MuonChamberSet

◆ MuonSectorSet

◆ staticNodePtr

◆ StIdx

◆ surfacePtr

Member Enumeration Documentation

◆ EndcapSide

Member Function Documentation

◆ buildBlueprintNode()

◆ buildChamberNode() [1/2]

◆ buildChamberNode() [2/2]

◆ buildMuonNode()

◆ getActiveMaterial()

◆ getMaterialBins()

◆ getPassiveMaterialSurfaces() [1/2]

◆ getPassiveMaterialSurfaces() [2/2]

◆ getSensitiveElements()

◆ initialize()

◆ isBIS78()

◆ isElementInTheStation()

◆ preparePassiveMaterial()

Member Data Documentation

◆ m_alignableVolumes

◆ m_assignActiveMaterial

◆ m_buildPassiveVolumes

◆ m_detMgr

◆ m_nPhiBinsBI

◆ m_nPhiBinsBM

◆ m_nPhiBinsBO

◆ m_nPhiBinsEI1

◆ m_nPhiBinsEI2

◆ m_nPhiBinsEM1

◆ m_nPhiBinsEM2

◆ m_nRBinsEI1

◆ m_nRBinsEI2

◆ m_nRBinsEM1

◆ m_nRBinsEM2

◆ m_nZBinsBI

◆ m_nZBinsBM

◆ m_nZBinsBO

◆ m_useSectors