ATLAS Offline Software
MuonBlueprintNodeBuilder.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 
4 */
5 
7 
8 #include "Acts/Geometry/BlueprintNode.hpp"
9 #include "Acts/Geometry/StaticBlueprintNode.hpp"
10 #include "Acts/Geometry/CylinderVolumeBounds.hpp"
11 #include <Acts/Geometry/ContainerBlueprintNode.hpp>
12 #include "Acts/Geometry/MultiWireVolumeBuilder.hpp"
13 #include "Acts/Surfaces/TrapezoidBounds.hpp"
14 #include "Acts/Material/HomogeneousSurfaceMaterial.hpp"
15 #include <Acts/Geometry/MaterialDesignatorBlueprintNode.hpp>
16 #include <Acts/Geometry/GeometryIdentifierBlueprintNode.hpp>
17 #include <Acts/Geometry/VolumeAttachmentStrategy.hpp>
18 #include "Acts/Geometry/VolumeResizeStrategy.hpp"
19 #include <Acts/Geometry/TrackingVolume.hpp>
20 #include <Acts/Geometry/TrapezoidVolumeBounds.hpp>
21 #include <Acts/Surfaces/PlaneSurface.hpp>
22 #include <Acts/Plugins/GeoModel/GeoModelMaterialConverter.hpp>
23 #include <Acts/Visualization/ObjVisualization3D.hpp>
24 
25 
29 
30 #include "GeoModelValidation/GeoMaterialHelper.h"
31 
32 namespace {
33  //Muon System IDs
34 constexpr std::size_t s_muonBarrelId = 30;
35 constexpr std::size_t s_muonEndcapAId = 31;
36 constexpr std::size_t s_muonEndcapCId = 32;
37 constexpr std::size_t s_muonEndcapMiddleAId = 33;
38 constexpr std::size_t s_muonEndcapMiddleCId = 34;
39 }
40 
41 namespace ActsTrk {
42 
45  return StatusCode::SUCCESS;
46  }
47 
48 
49 std::shared_ptr<Acts::Experimental::BlueprintNode> MuonBlueprintNodeBuilder::buildBlueprintNode(const Acts::GeometryContext& gctx, std::shared_ptr<Acts::Experimental::BlueprintNode>&& childNode) {
50 
51 std::variant<MuonChamberSet, MuonSectorSet> elements;
52 std::variant<MuonChamberSet, MuonSectorSet> barrelStations, endcapAStations, endcapCStations, endcapMiddleAStations, endcapMiddleCStations;
53 
54 if (m_useSectors) {
55  elements = m_detMgr->getAllSectors();
56 } else {
57  elements = m_detMgr->getAllChambers();
58 }
59 
60 std::visit([&](auto& elems) {
61  using SetType = std::decay_t<decltype(elems)>;
62 
63  // Initialize station containers of the same type
64  SetType barrel, endcapA, endcapC, endcapMiddleA, endcapMiddleC;
65 
66  for (const auto& element : elems) {
67  if (isElementInTheStation(*element,
70  barrel.insert(element);
71  } else if (isElementInTheStation(*element, {StIdx::EO}, EndcapSide::A)) {
72  endcapA.insert(element);
73  } else if (isElementInTheStation(*element, {StIdx::EO}, EndcapSide::C)) {
74  endcapC.insert(element);
75  } else if (isElementInTheStation(*element, {StIdx::EM}, EndcapSide::A)) {
76  endcapMiddleA.insert(element);
77  } else if (isElementInTheStation(*element, {StIdx::EM}, EndcapSide::C)) {
78  endcapMiddleC.insert(element);
79  } else {
80  ATH_MSG_WARNING("Element " << element->identString()
81  << " not assigned to any station!");
82  }
83  }
84 
85  // Assign back into the outer variants
86  barrelStations = std::move(barrel);
87  endcapAStations = std::move(endcapA);
88  endcapCStations = std::move(endcapC);
89  endcapMiddleAStations= std::move(endcapMiddleA);
90  endcapMiddleCStations= std::move(endcapMiddleC);
91 
92 }, elements);
93 
94  // Top level node for the Muon system
95 auto muonNode = std::make_shared<Acts::Experimental::CylinderContainerBlueprintNode>("MuonNode", Acts::AxisDirection::AxisZ);
96 
97 Acts::VolumeBoundFactory boundsFactory{};
98 
99 auto barrelNode = buildMuonNode(gctx, barrelStations, "BI_BM_BO_EE_EI",Acts::GeometryIdentifier().withVolume(s_muonBarrelId), boundsFactory);
100 auto endcapANode = buildMuonNode(gctx, endcapAStations, "EO_A", Acts::GeometryIdentifier().withVolume(s_muonEndcapAId), boundsFactory);
101 auto endcapCNode = buildMuonNode(gctx, endcapCStations, "EO_C", Acts::GeometryIdentifier().withVolume(s_muonEndcapCId), boundsFactory);
102 auto endcapMiddleANode = buildMuonNode(gctx, endcapMiddleAStations, "EM_A", Acts::GeometryIdentifier().withVolume(s_muonEndcapMiddleAId), boundsFactory);
103 auto endcapMiddleCNode = buildMuonNode(gctx, endcapMiddleCStations, "EM_C", Acts::GeometryIdentifier().withVolume(s_muonEndcapMiddleCId), boundsFactory);
104 
105 //Add to the muon barrel child node (e.g calo or Itk) - if existed
106 if(childNode){
107  barrelNode->addChild(std::move(childNode));
108 }
109 
110 muonNode->addChild(std::move(barrelNode));
111 muonNode->addChild(std::move(endcapANode));
112 muonNode->addChild(std::move(endcapCNode));
113 muonNode->addChild(std::move(endcapMiddleANode));
114 muonNode->addChild(std::move(endcapMiddleCNode));
115 
116 return muonNode;
117 
118 }
119 
120 template<typename MuonElementsSet>
121 std::shared_ptr<Acts::Experimental::StaticBlueprintNode>
123  const Acts::GeometryContext& gctx,
124  const MuonElementsSet& elements,
125  const std::string& name,
126  const Acts::GeometryIdentifier& id,
127  Acts::VolumeBoundFactory& boundsFactory) const {
128 
129  const ActsGeometryContext* context = gctx.get<const ActsGeometryContext* >();
130  std::vector<std::string> stationNames;
131 
132  std::vector<std::shared_ptr<Acts::Experimental::StaticBlueprintNode>> nodes;
133 
134  double innerRadius = 0.0;
135  double outerRadius = std::numeric_limits<double>::lowest();
136  double maxZ = std::numeric_limits<double>::lowest();
137  double minZ = std::numeric_limits<double>::max();
138 
139  int chamberId = 1;
140 
141  std::visit([&](const auto& elems){
142 
143  for(const auto& element : elems){
144  const Amg::Transform3D& transform = element->localToGlobalTrans(*context);
145  std::string volName = element->identString();
146 
147  auto vol = std::make_unique<Acts::TrackingVolume>(
148  transform,
149  element->bounds(),
150  volName);
151 
152  // Get material per chamber, blend it and place it in the center of the volume
153  auto material = blendMaterial(*element);
154  vol->addSurface(std::move(material));
155  // //the chamber geometry id
156  Acts::GeometryIdentifier chId = id.withLayer(chamberId++);
157  vol->assignGeometryId(chId);
158 
159  std::pair<std::vector<staticNodePtr>,std::vector<surfacePtr>> innerStructure = getSensitiveElements(*context, *element, chId, boundsFactory);
160 
161  for(auto& surface: innerStructure.second){
162  vol->addSurface(surface);
163  }
164 
165  //calculate the bounds of the cylinder container
166  for(const auto& surface: vol->boundarySurfaces()){
167  const auto& surfaceRepr = surface->surfaceRepresentation();
168  const Acts::Polyhedron& polyhedron = surfaceRepr.polyhedronRepresentation(gctx);
169  const Amg::Vector3D& center = surfaceRepr.center(gctx);
170 
171  maxZ = std::max(maxZ, center.z());
172  minZ = std::min(minZ, center.z());
173 
174  // Outer radius needs to be treated differently due to curvature of cylindrical surface
175  for(const Amg::Vector3D& vertex: polyhedron.vertices){
176  outerRadius = std::max(outerRadius, vertex.perp());
177  }
178  }
179  if(m_dumpVolumes){
180  //for visualizing each chamber volume individually
181  Acts::ObjVisualization3D helper;
182  vol->visualize(helper, gctx, {.visible = true},
183  {.visible = true}, {.visible = true});
184  helper.write(volName + ".obj");
185  helper.clear();
186  }
187 
188  auto node = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(vol));
189  for(auto& childNode : innerStructure.first){
190  node->addChild(std::move(childNode));
191 
192  }
193 
194 
195 
196  nodes.emplace_back(std::move(node));
197  }
198  }, elements);
199 
200  double halfLengthZ = 0.5 * std::abs(maxZ - minZ);
201  ATH_MSG_DEBUG("Inner radius: " << innerRadius);
202  ATH_MSG_DEBUG("Outer radius: " << outerRadius);
203  ATH_MSG_DEBUG("Max Z: " << maxZ);
204  ATH_MSG_DEBUG("Min Z: " << minZ);
205  ATH_MSG_DEBUG("Half length Z: " << halfLengthZ);
206 
207  Amg::Transform3D trf = Amg::getTranslateZ3D(halfLengthZ + minZ);
208 
209  auto bounds = boundsFactory.makeBounds<Acts::CylinderVolumeBounds>(innerRadius, outerRadius, halfLengthZ);
210  auto volume = std::make_unique<Acts::TrackingVolume>(trf, bounds, name);
211  volume->assignGeometryId(id);
212  auto muonNode = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(volume));
213 
214  ATH_MSG_DEBUG("There are " << nodes.size() << " nodes");
215  std::ranges::for_each(nodes, [&muonNode](auto& node) {
216  muonNode->addChild(std::move(node));
217  });
218  return muonNode;
219  }
220 
221 template<typename T>
222 std::pair<std::vector<staticNodePtr>, std::vector<surfacePtr>>
224  const ActsGeometryContext& gctx,
225  const T& element,
226  const Acts::GeometryIdentifier& chId,
227  Acts::VolumeBoundFactory& boundsFactory) const {
228 
229  std::vector<staticNodePtr> readoutVolumes;
230  std::vector<surfacePtr> readoutSurfaces;
231  Acts::GeometryIdentifier::Value mdtId{1};
232 
233  for (const MuonGMR4::MuonReadoutElement* readoutEle : element.readoutEles()) {
234 
235  std::vector<surfacePtr> detSurfaces = readoutEle->getSurfaces();
236  switch(readoutEle->detectorType()){
237  case DetectorType::Mdt: {
238  const auto* mdtReadoutEle = static_cast<const MuonGMR4::MdtReadoutElement*>(readoutEle);
239  const MuonGMR4::MdtReadoutElement::parameterBook& parameters{mdtReadoutEle->getParameters()};
240 
241  // get the transform to the sector's frame
242  const Amg::Vector3D toChamber = element.globalToLocalTrans(gctx)*mdtReadoutEle->center(gctx);
243  const Acts::Transform3 mdtTransform = element.localToGlobalTrans(gctx) * Amg::getTranslate3D(toChamber);
244 
245  // create the MDT multilayer volume with the dedicated builder
246  Acts::Experimental::MultiWireVolumeBuilder::Config mwCfg;
247  mwCfg.name = m_detMgr->idHelperSvc()->toStringDetEl(mdtReadoutEle->identify());
248  mwCfg.mlSurfaces = detSurfaces;
249  mwCfg.transform = mdtTransform;
250 
251  auto mdtBounds = boundsFactory.makeBounds<Acts::TrapezoidVolumeBounds>(parameters.shortHalfX,
252  parameters.longHalfX, parameters.halfY, parameters.halfHeight);
253 
254  mwCfg.bounds = mdtBounds;
255  using BoundsV = Acts::TrapezoidVolumeBounds::BoundValues;
256  mwCfg.binning = {{{Acts::AxisDirection::AxisY, Acts::AxisBoundaryType::Bound,
257  -mdtBounds->get(BoundsV::eHalfLengthY),
258  mdtBounds->get(BoundsV::eHalfLengthY),
259  static_cast<std::size_t>(std::lround(2 * mdtBounds->get(BoundsV::eHalfLengthY) / parameters.tubePitch))}, 2u},
260  {{Acts::AxisDirection::AxisZ, Acts::AxisBoundaryType::Bound,
261  -mdtBounds->get(BoundsV::eHalfLengthZ),
262  mdtBounds->get(BoundsV::eHalfLengthZ),
263  static_cast<std::size_t>(std::lround(2 * mdtBounds->get(BoundsV::eHalfLengthZ) / parameters.tubePitch))}, 1u}};
264  Acts::Experimental::MultiWireVolumeBuilder mdtBuilder{mwCfg};
265  std::unique_ptr<Acts::TrackingVolume> mdtVolume = mdtBuilder.buildVolume();
266 
267  mdtVolume->assignGeometryId(chId.withExtra(mdtId++));
268  //create the blueprint node for the mdt multilayers
269  std::shared_ptr<Acts::Experimental::StaticBlueprintNode> mdtNode = std::make_shared<Acts::Experimental::StaticBlueprintNode>(std::move(mdtVolume));
270  mdtNode->setNavigationPolicyFactory(mdtBuilder.createNavigationPolicyFactory());
271  readoutVolumes.push_back(std::move(mdtNode));
272 
273  break;
274 
275  } case DetectorType::Rpc:
276  case DetectorType::Tgc:
277  case DetectorType::sTgc:
278  case DetectorType::Mm: {
279 
280  readoutSurfaces.insert(readoutSurfaces.end(), std::make_move_iterator(detSurfaces.begin()),
281  std::make_move_iterator(detSurfaces.end()));
282 
283  break;
284 
285  } default:
286  THROW_EXCEPTION("Unknown detector type for readout element: " << ActsTrk::to_string(readoutEle->detectorType()));
287  break;
288 
289  }
290  }
291 
292  return std::make_pair(std::move(readoutVolumes), std::move(readoutSurfaces));
293 }
294 
295 
296 template<typename T>
297 std::shared_ptr<Acts::Surface>
299  const T& element) const {
300 
301  const float thickness = element.halfZ() * 2;
302  PVConstLink parentVolume = element.readoutEles().front()->getMaterialGeom()->getParent();
303  GeoModelTools::GeoMaterialHelper geoMaterialHelper;
304  std::pair<GeoModelTools::GeoMaterialPtr, double> geoMaterials = geoMaterialHelper.collectMaterial(parentVolume);
305 
306  const Acts::Material aMat = Acts::GeoModel::geoMaterialConverter(*geoMaterials.first);
307  //rotate about the z axis
308  auto constPtr = element.surface().getSharedPtr();
309  //to assign the material shouldnt be const
310  auto ptr = std::const_pointer_cast<Acts::Surface>(constPtr);
311 
312  Acts::MaterialSlab slab{aMat, thickness};
313  std::shared_ptr<Acts::HomogeneousSurfaceMaterial> material = std::make_shared<Acts::HomogeneousSurfaceMaterial>(slab);
314  ptr->assignSurfaceMaterial(material);
315  return ptr;
316 
317 }
318 
319 template<typename T>
320 bool MuonBlueprintNodeBuilder::isElementInTheStation(const T& element, const std::vector<StIdx>& stationIndex, const EndcapSide& side) const {
321  StIdx stationIdx = toStationIndex(element.chamberIndex());
322  auto stationSide = element.side();
323  bool matchesName = std::ranges::any_of(stationIndex.begin(), stationIndex.end(), [&](const auto& n){
324  return stationIdx == n;
325  });
326 
327  bool etaSignCorrect = ((stationSide > 0 && side == EndcapSide::A) || (stationSide < 0 && side == EndcapSide::C) || (side == EndcapSide::Both));
328  return matchesName && etaSignCorrect;
329 }
330 
331 
332 } //namespace ActsTrk
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
MuonBlueprintNodeBuilder.h
TRT_PAI_gasdata::EO
const float EO[NO]
Energy levels for Oxygen.
Definition: TRT_PAI_gasdata.h:301
Muon::MuonStationIndex::StIndex::EM
@ EM
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
ActsTrk::MuonBlueprintNodeBuilder::EndcapSide::Both
@ Both
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
Amg::getTranslateZ3D
Amg::Transform3D getTranslateZ3D(const double Z)
: Returns a shift transformation along the z-axis
Definition: GeoPrimitivesHelpers.h:285
ActsTrk::DetectorType::Tgc
@ Tgc
Resitive Plate Chambers.
MuonGMR4::MuonReadoutElement
The MuonReadoutElement is an abstract class representing the geometry representing the muon detector.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MuonReadoutElement.h:38
Muon::IMuonIdHelperSvc::toStringDetEl
virtual std::string toStringDetEl(const Identifier &id) const =0
print all fields up to detector element to string
ActsTrk::MuonBlueprintNodeBuilder::m_dumpVolumes
Gaudi::Property< bool > m_dumpVolumes
Definition: MuonBlueprintNodeBuilder.h:74
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
ActsTrk::DetectorType::sTgc
@ sTgc
Micromegas (NSW)
SpectrometerSector.h
ActsTrk::MuonBlueprintNodeBuilder::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition: MuonBlueprintNodeBuilder.h:72
ActsTrk::MuonBlueprintNodeBuilder::EndcapSide::A
@ A
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
TRT::Hit::side
@ side
Definition: HitInfo.h:83
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:115
ActsTrk::MuonBlueprintNodeBuilder::EndcapSide::C
@ C
Muon::MuonStationIndex::toStationIndex
StIndex toStationIndex(ChIndex index)
convert ChIndex into StIndex
ActsTrk::MuonBlueprintNodeBuilder::m_useSectors
Gaudi::Property< bool > m_useSectors
Definition: MuonBlueprintNodeBuilder.h:76
ActsTrk::DetectorType::Mm
@ Mm
Maybe not needed in the migration.
MuonGMR4::MdtReadoutElement::parameterBook
Set of parameters to describe a MDT chamber.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MdtReadoutElement.h:22
beamspotman.n
n
Definition: beamspotman.py:727
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
ActsTrk::MuonBlueprintNodeBuilder::initialize
StatusCode initialize() override
Definition: MuonBlueprintNodeBuilder.cxx:43
ActsTrk::MuonBlueprintNodeBuilder::isElementInTheStation
bool isElementInTheStation(const T &element, const std::vector< StIdx > &stationNames, const EndcapSide &side) const
Check if the chamber is in this node.
Definition: MuonBlueprintNodeBuilder.cxx:320
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsTrk::MuonBlueprintNodeBuilder::blendMaterial
std::shared_ptr< Acts::Surface > blendMaterial(const T &element) const
Blend the sector's/chamber's material as plane surface.
Definition: MuonBlueprintNodeBuilder.cxx:298
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
ActsTrk::MuonBlueprintNodeBuilder::buildMuonNode
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.
Definition: MuonBlueprintNodeBuilder.cxx:122
Muon::MuonStationIndex::StIndex::BO
@ BO
Muon::MuonStationIndex::StIndex
StIndex
enum to classify the different station layers in the muon spectrometer
Definition: MuonStationIndex.h:23
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
ActsTrk::DetectorType::Mdt
@ Mdt
MuonSpectrometer.
MuonGMR4::MdtReadoutElement
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/MdtReadoutElement.h:18
Muon::MuonStationIndex::StIndex::BE
@ BE
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
THROW_EXCEPTION
#define THROW_EXCEPTION(MESSAGE)
Definition: throwExcept.h:10
Chamber.h
ActsTrk::MuonBlueprintNodeBuilder::EndcapSide
EndcapSide
Definition: MuonBlueprintNodeBuilder.h:54
MuonGMR4::MuonDetectorManager::getAllSectors
MuonSectorSet getAllSectors() const
: Returns all MuonChambers associated with the readout geometry
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonDetectorManager.cxx:207
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonGMR4::MuonDetectorManager::idHelperSvc
const Muon::IMuonIdHelperSvc * idHelperSvc() const
Returns a pointer to the central MuonIdHelperSvc.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonDetectorManager.cxx:159
ActsTrk::DetectorType::Rpc
@ Rpc
Monitored Drift Tubes.
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
ActsTrk
The AlignStoreProviderAlg loads the rigid alignment corrections and pipes them through the readout ge...
Definition: MSTrackingVolumeBuilder.cxx:25
ActsTrk::MuonBlueprintNodeBuilder::getSensitiveElements
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.
Definition: MuonBlueprintNodeBuilder.cxx:223
MuonStationIndex.h
CaloLCW_tf.trf
trf
Definition: CaloLCW_tf.py:20
Muon::MuonStationIndex::StIndex::BI
@ BI
Muon::MuonStationIndex::StIndex::BM
@ BM
MuonGMR4::MuonDetectorManager::getAllChambers
MuonChamberSet getAllChambers() const
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonDetectorManager.cxx:215
Material
@ Material
Definition: MaterialTypes.h:8
Muon::MuonStationIndex::StIndex::EI
@ EI
node
Definition: node.h:21
Amg::getTranslate3D
Amg::Transform3D getTranslate3D(const double X, const double Y, const double Z)
: Returns a shift transformation along an arbitrary axis
Definition: GeoPrimitivesHelpers.h:289
ActsTrk::MuonBlueprintNodeBuilder::buildBlueprintNode
std::shared_ptr< Acts::Experimental::BlueprintNode > buildBlueprintNode(const Acts::GeometryContext &gctx, std::shared_ptr< Acts::Experimental::BlueprintNode > &&childNode) override
Build the Muon Blueprint Node.
Definition: MuonBlueprintNodeBuilder.cxx:49