ActsTrk::ItkBlueprintNodeBuilder Class Reference

Helper class to build the ItkBlueprint node It adds the system as a node to the Blueprint. More...

#include <ItkBlueprintNodeBuilder.h>

Inheritance diagram for ActsTrk::ItkBlueprintNodeBuilder:

Collaboration diagram for ActsTrk::ItkBlueprintNodeBuilder:

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

Private Member Functions
Acts::SurfaceArrayNavigationPolicy::Config	surfaceArrayConfig (Acts::SurfaceArrayNavigationPolicy::LayerType layerType, const Gaudi::Property< std::vector< unsigned int > > &neighborWindow) const
	Configuration of the surface array navigation policy of one layer.
void	buildItkStripBlueprintNode (const Acts::GeometryContext &gctx, Acts::BlueprintNode &node)
void	buildItkPixelBlueprintNode (const Acts::GeometryContext &gctx, Acts::BlueprintNode &node)

Private Attributes
const InDetDD::SiDetectorManager *	m_itkPixelMgr {nullptr}
const InDetDD::SiDetectorManager *	m_itkStripMgr {nullptr}
std::shared_ptr< ActsElementVector >	m_elementStore {nullptr}
Gaudi::Property< bool >	m_doEndcapLayerMerging
Gaudi::Property< bool >	m_buildPixel {this, "buildPixel", true}
Gaudi::Property< bool >	m_buildStrip {this, "buildStrip", true}
Gaudi::Property< std::vector< unsigned int > >	m_itkPixelInnerBarrelNeighborWindow
	Most bins the surface array lookup serves on each side of the crossing, as {phi, z} for the barrel and {r, phi} for the endcap.
Gaudi::Property< std::vector< unsigned int > >	m_itkPixelInnerEndcapNeighborWindow
Gaudi::Property< std::vector< unsigned int > >	m_itkPixelOuterBarrelNeighborWindow
Gaudi::Property< std::vector< unsigned int > >	m_itkPixelOuterEndcapNeighborWindow
Gaudi::Property< std::vector< unsigned int > >	m_itkStripBarrelNeighborWindow
Gaudi::Property< std::vector< unsigned int > >	m_itkStripEndcapNeighborWindow
Gaudi::Property< unsigned int >	m_surfaceArrayOverfill
	Extra cells per direction and axis that each surface fills around its footprint.

Detailed Description

Helper class to build the ItkBlueprint node It adds the system as a node to the Blueprint.

Definition at line 23 of file ItkBlueprintNodeBuilder.h.

Member Function Documentation

buildBlueprintNode()

std::shared_ptr< Acts::BlueprintNode > ActsTrk::ItkBlueprintNodeBuilder::buildBlueprintNode ( const Acts::GeometryContext & gctx, std::shared_ptr< Acts::BlueprintNode > && child )

override

Build the Itk Blueprint Node.

Parameters

gctx	Geometry context
child	Optional beam pipe node to nest inside the ITk AxisR container.

Wrap the ITk into a separate volume

Setup a fixed geometry Identifier

Definition at line 253 of file ItkBlueprintNodeBuilder.cxx.

                                                  {
 
  auto itkNode =
      std::make_shared<Acts::CylinderContainerBlueprintNode>(
          "itkNode", AxisZ);
  itkNode->setAttachmentStrategy(AttachmentStrategy::Gap);
  itkNode->setResizeStrategy(ResizeStrategy::Gap);
 
  auto& itk = itkNode->addCylinderContainer("ItkNodeMain", AxisR);
  itk.setAttachmentStrategy(AttachmentStrategy::Gap);
  itk.setResizeStrategy(ResizeStrategy::Gap);
 
  itk.addMaterial("ItkNodeMain_Material", [&](auto& mat) {
      if (m_buildStrip) {
        mat.configureFace(NegativeDisc,
                          AxisSpec::DeferredEquidistant(50, AxisR),
                          AxisSpec::DeferredEquidistant(50, AxisPhi),
                          "ItkNodeMain_Material_NegativeDisc");
        mat.configureFace(PositiveDisc,
                          AxisSpec::DeferredEquidistant(50, AxisR),
                          AxisSpec::DeferredEquidistant(50, AxisPhi),
                          "ItkNodeMain_Material_PositiveDisc");
      }
 
    auto& innerContainer = mat.addCylinderContainer("ITkInnerContainer", AxisR);
    // The radial dead bands between the R-stacked sub-detectors (beampipe /
    // InnerPixel / OuterPixel / Strip) are genuine empty space, but the default
    // Midpoint attachment splits each band at its midpoint and lets BOTH
    // neighbours fill their half with a ResizeStrategy::Gap volume -> two thin
    // gap volumes per interface. Second makes a single neighbour own the whole
    // band -> one gap per interface. Material is unaffected: each sub-detector
    // keeps ResizeStrategy::Gap, so its material-bearing shell stays frozen at
    // its true edge and only the empty band is merged.
    innerContainer.setAttachmentStrategy(AttachmentStrategy::Second);
    innerContainer.setResizeStrategy(ResizeStrategy::Gap);
    // Beam pipe is passed in as an optional child from BeamPipeBlueprintNodeBuilder
    if (childNode) {
      innerContainer.addChild(std::move(childNode));
    }
 
    if (m_buildPixel) {
      buildItkPixelBlueprintNode(gctx, innerContainer);
    }
    if (m_buildStrip) {
      buildItkStripBlueprintNode(gctx, innerContainer);
    }
  });
  Acts::ExtentEnvelope envelope{};
  envelope[AxisDirection::AxisZ] = {20_mm, 20_mm};
  envelope[AxisDirection::AxisR] = {1_mm, 2_mm};
  auto padNode = std::make_shared<Acts::PadBlueprintNode>("ITkEnvelope", envelope);
  padNode->addChild(itkNode);
  auto idNode = std::make_shared<Acts::GeometryIdentifierBlueprintNode>();
  idNode->setDirectChildVolumeIdTo(s_ITkEnvelopeId);
  idNode->addChild(std::move(padNode));
  return idNode;
}

buildItkPixelBlueprintNode()

void ActsTrk::ItkBlueprintNodeBuilder::buildItkPixelBlueprintNode ( const Acts::GeometryContext & gctx, Acts::BlueprintNode & node )

private

Definition at line 315 of file ItkBlueprintNodeBuilder.cxx.

                             {
 
  // Get ITkPixel parameters from detector manager
  if (!m_itkPixelMgr) {
    ATH_MSG_ERROR("ITkPixel manager not available");
    throw std::runtime_error("ITkPixel manager not available");
  }
 
  ATH_MSG_DEBUG("Detector manager has "
                << m_itkPixelMgr->getDetectorElementCollection()->size()
                << " elements");
 
  std::vector<std::shared_ptr<ActsDetectorElement>> elements;
 
  InDetDD::SiDetectorElementCollection::const_iterator iter;
  for (const auto* element : *m_itkPixelMgr->getDetectorElementCollection()) {
    const InDetDD::SiDetectorElement* siDetElement =
        dynamic_cast<const InDetDD::SiDetectorElement*>(element);
    if (siDetElement == nullptr) {
      ATH_MSG_ERROR("Detector element was nullptr");
      throw std::runtime_error{"Corrupt detector element collection"};
    }
    elements.push_back(std::make_shared<ActsDetectorElement>(*siDetElement));
  }
  ATH_MSG_VERBOSE("Retrieved " << elements.size() << " elements");
 
  // Copy to service level store to extend lifetime
  m_elementStore->vector().insert(m_elementStore->vector().end(),
                                  elements.begin(), elements.end());
 
  // Inner pixel: 2 innermost barrel layers + inner endcap disks
  auto& innerPixel = node.addCylinderContainer("InnerPixel", AxisR);
  innerPixel.setAttachmentStrategy(AttachmentStrategy::Gap);
  // Inner edge Expand: extend all InnerPixel cylinders (endcaps + barrel_0)
  // inward onto the beam pipe, removing InnerPixel::Gap1. The InnerCylinder
  // material (30.9) is dropped below so the expanded face fuses cleanly with
  // the beam pipe outer material (23.9, the kept lower-r surface). Outer edge
  // stays Gap.
  innerPixel.setResizeStrategies(ResizeStrategy::Expand, ResizeStrategy::Gap);
 
  innerPixel.addMaterial("InnerPixelMaterial", [&](auto& mat) {
    mat.configureFace(OuterCylinder,
                      AxisSpec::DeferredEquidistant(50, AxisRPhi),
                      AxisSpec::DeferredEquidistant(100, AxisZ),
                      "InnerPixelMaterial");
 
    auto& innerPixelContainer = mat.addCylinderContainer("InnerPixel", AxisZ);
 
    // Add barrel container
    auto& barrelGeoId = innerPixelContainer.withGeometryIdentifier();
    barrelGeoId.setAllVolumeIdsTo(s_innerPixelVolumeId)
        .incrementLayerIds(1)
        .sortBy([](auto& a, auto& b) {
          auto& boundsA =
              dynamic_cast<const Acts::CylinderVolumeBounds&>(a.volumeBounds());
          auto& boundsB =
              dynamic_cast<const Acts::CylinderVolumeBounds&>(b.volumeBounds());
 
          using enum Acts::CylinderVolumeBounds::BoundValues;
          double aMidR = (boundsA.get(eMinR) + boundsA.get(eMaxR)) / 2.0;
          double bMidR = (boundsB.get(eMinR) + boundsB.get(eMaxR)) / 2.0;
 
          return aMidR < bMidR;
        });
 
    auto& brl_mat =
        barrelGeoId.addMaterial("InnerPixel_Material", [&](auto& material) {
          material.configureFace(NegativeDisc,
                                 AxisSpec::DeferredEquidistant(50, AxisR),
                                 AxisSpec::DeferredEquidistant(50, AxisPhi),
                                 "InnerPixel_Material_NegativeDisc");
          material.configureFace(PositiveDisc,
                                 AxisSpec::DeferredEquidistant(50, AxisR),
                                 AxisSpec::DeferredEquidistant(50, AxisPhi),
                                 "InnerPixel_Material_PositiveDisc");
        });
    auto& barrel = brl_mat.addCylinderContainer("InnerPixel_Brl", AxisR);
 
    // Barrel layers carry material only on their OuterCylinder face. Attaching
    // with Second extends the outer (higher-R) neighbour's material-free inner
    // face inward to meet each layer's outer face, collapsing the inter-layer
    // gap volumes while leaving every material surface fixed.
    barrel.setAttachmentStrategy(AttachmentStrategy::Second);
    // Inner edge Expand: Brl_0's inner cylinder is material-free, so it extends
    // inward onto the beam pipe (the InnerPixel container also expands inward,
    // so the endcaps reach the beam pipe too) removing the barrel's share of the
    // InnerPixel beam-pipe gap.
    // Outer edge Expand: the outermost layer grows out onto the InnerPixel
    // OuterCylinder shell (123.7), removing InnerPixel_Brl::Gap1 (the gap after
    // the last barrel layer). Its own OuterCylinder material is dropped below
    // (kept only up to the second-outermost layer) so the expanded face fuses
    // cleanly with the container shell (the kept surface).
    barrel.setResizeStrategies(ResizeStrategy::Expand, ResizeStrategy::Expand);
 
    std::map<int, std::vector<std::shared_ptr<Acts::Surface>>> layers{};
 
    for (auto& element : elements) {
      IdentityHelper id = element->identityHelper();
      if (id.bec() != 0) {
        continue;
      }
 
      if (id.layer_disk() >= 2) {
        continue;
      }
 
      int elementLayer = id.layer_disk();
      layers[elementLayer].push_back(element->surface().getSharedPtr());
    }
 
    ATH_MSG_DEBUG("Adding " << layers.size() << " layers to InnerPixel barrel");
 
    const int outermostBrlLayer = layers.rbegin()->first;
    for (const auto& [ilayer, surfaces] : layers) {
      ATH_MSG_DEBUG("- Layer " << ilayer << " has " << surfaces.size()
                               << " surfaces");
 
      auto configureLayer = [&](auto& node) {
        auto& layer = node.addLayer(std::format("InnerPixel_Brl_{}", ilayer));
        layer.setNavigationPolicyFactory(
            Acts::NavigationPolicyFactory{}
                .add<Acts::SurfaceArrayNavigationPolicy>(surfaceArrayConfig(
                    Cylinder, m_itkPixelInnerBarrelNeighborWindow))
                .add<Acts::CylinderNavigationPolicy>()
                .asUniquePtr());
        layer.setSurfaces(surfaces);
        layer.setEnvelope(Acts::ExtentEnvelope{{
            .z = {5_mm, 5_mm},
            .r = {2_mm, 2_mm},
        }});
      };
 
      // Outermost layer expands onto the container OuterCylinder shell, so
      // drop its own OuterCylinder; skip the MaterialDesignator wrapper to
      // avoid empty-designator warnings.
      if (ilayer != outermostBrlLayer) {
        const std::string materialName =
            std::format("InnerPixel_Brl_{}_Material", ilayer);
        barrel.addMaterial(
            materialName,
            [&](auto& lmat) {
              lmat.configureFace(OuterCylinder,
                                 AxisSpec::DeferredEquidistant(50, AxisRPhi),
                                 AxisSpec::DeferredEquidistant(100, AxisZ),
                                 materialName);
              configureLayer(lmat);
            });
      } else {
        configureLayer(barrel);
      }
    }
 
    // Add endcap containers
    for (int bec : {-2, 2}) {
      std::string s = bec > 0 ? "p" : "n";
      auto& ecGeoId = innerPixelContainer.withGeometryIdentifier();
      ecGeoId.setAllVolumeIdsTo(s_innerPixelVolumeId + std::floor(bec / 2))
          .incrementLayerIds(1);
      auto& ec = ecGeoId.addCylinderContainer(std::format("InnerPixel_{:}EC", s), AxisZ);
      // Collapse the inter-disk gaps by extending the outer disk inward onto
      // its neighbour (Second for +z, First for -z), keeping the material
      // surface at the smaller-|z| side of each gap (see per-disk material
      // handling below).
      ec.setAttachmentStrategy(bec > 0 ? AttachmentStrategy::Second
                                       : AttachmentStrategy::First);
      // Barrel-facing edge Expand: extend the innermost disk toward the barrel
      // (smaller |z|), removing the barrel<->endcap transition gap. That edge is
      // the low-z (inner) side for +z endcaps and the high-z (outer) side for -z
      // endcaps. The far (z-end) edge stays Gap. The innermost disk's inward disc
      // material is dropped below so the expanded face fuses with the barrel end
      // disc (the kept, smaller-|z| surface).
      ec.setResizeStrategies(
          bec > 0 ? ResizeStrategy::Expand : ResizeStrategy::Gap,
          bec > 0 ? ResizeStrategy::Gap : ResizeStrategy::Expand);
 
      std::map<std::tuple<int, int, int>,
               std::vector<std::shared_ptr<Acts::Surface>>>
          initialLayers{};
 
      for (auto& element : elements) {
        IdentityHelper id = element->identityHelper();
        if (id.bec() * bec <= 0) {
          continue;
        }
 
        if (id.layer_disk() >= 3) {
          continue;
        }
 
        std::tuple<int, int, int> key{id.bec(), id.layer_disk(),
                                      id.eta_module()};
        initialLayers[key].push_back(element->surface().getSharedPtr());
      }
 
      ATH_MSG_DEBUG("Found " << initialLayers.size()
                             << " initial layers to InnerPixel " << s << "EC");
 
      std::vector<LayerData> protoLayers;
      protoLayers.reserve(initialLayers.size());
 
      for (const auto& [key, surfaces] : initialLayers) {
        auto& layer = protoLayers.emplace_back(gctx, surfaces);
        layer.protoLayer.envelope[AxisR] = {2_mm, 2_mm};
        layer.protoLayer.envelope[AxisZ] = {1_mm, 1_mm};
      }
 
      std::ranges::sort(protoLayers,
                        [](const LayerData& a, const LayerData& b) {
                          return std::abs(a.protoLayer.medium(AxisZ)) <
                                 std::abs(b.protoLayer.medium(AxisZ));
                        });
 
      ATH_MSG_DEBUG("Found " << protoLayers.size() << " initial layers");
 
      std::vector<LayerData> mergedLayers;
      if (m_doEndcapLayerMerging) {
        mergedLayers = mergeLayers(gctx, std::move(protoLayers));
      } else {
        mergedLayers = std::move(protoLayers);
      }
 
      ATH_MSG_DEBUG("After merging: " << mergedLayers.size() << " layers");
 
      for (const auto [key, pl] : Acts::enumerate(mergedLayers)) {
        ATH_MSG_DEBUG("- Layer " << key << " has " << pl.surfaces.size()
                                 << " surfaces");
 
        pl.protoLayer.medium(AxisZ);
        auto layerName = std::format("InnerPixel_{}EC_{}", key, s);
 
        auto addLayer = [this, &layerName, &pl](auto& parent) {
          auto& layer = parent.addLayer(layerName);
 
          layer.setNavigationPolicyFactory(
              Acts::NavigationPolicyFactory{}
                  .add<Acts::SurfaceArrayNavigationPolicy>(surfaceArrayConfig(
                      Disc, m_itkPixelInnerEndcapNeighborWindow))
                  .add<Acts::CylinderNavigationPolicy>()
                  .asUniquePtr());
 
          layer.setSurfaces(pl.surfaces);
          layer.setEnvelope(Acts::ExtentEnvelope{{
              .z = {1_mm, 1_mm},
              .r = {2_mm, 2_mm},
          }});
        };
 
        ATH_MSG_VERBOSE("Add inner pixel layer"
                        << key << " / " << mergedLayers.size()
                        << " at z = " << pl.protoLayer.medium(AxisZ));
        ATH_MSG_VERBOSE("Adding material for layer " << layerName);
        // Keep material only on each disk's outward disc (away from the IP);
        // the inward disc is dropped so it can fuse with the adjacent disk's
        // kept outward disc without the "both portals carry material" fuse
        // error. The innermost disk drops its inward disc too: it is expanded
        // toward the barrel and fuses with the barrel end disc (the kept,
        // smaller-|z| surface).
        const auto outwardDisc = (bec > 0) ? PositiveDisc : NegativeDisc;
        const std::string materialName = layerName + "_Material";
        ec.addMaterial(materialName, [&](auto& lmat) {
          lmat.configureFace(outwardDisc,
                             AxisSpec::DeferredEquidistant(50, AxisR),
                             AxisSpec::DeferredEquidistant(50, AxisPhi),
                             materialName);
          addLayer(lmat);
        });
      }
    }
  });
 
  // Outer pixel: 3 outer barrel layers + outer endcaps
  auto& outerPixel = node.addCylinderContainer("OuterPixel", AxisR);
  outerPixel.setAttachmentStrategy(AttachmentStrategy::Gap);
  // Inner edge Expand: extend all OuterPixel cylinders inward onto the
  // InnerPixel outer shell (123.7), removing OuterPixel::Gap1. The InnerCylinder
  // material (147.7) is dropped below so the expanded face fuses cleanly with
  // the InnerPixel OuterCylinder (123.7, the kept lower-r surface). Outer edge
  // stays Gap (the OuterPixel/Strip interface is handled from the Strip side).
  outerPixel.setResizeStrategies(ResizeStrategy::Expand, ResizeStrategy::Gap);
 
  outerPixel.addMaterial("OuterPixelMaterial", [&](auto& opmat) {
    opmat.configureFace(OuterCylinder,
                        AxisSpec::DeferredEquidistant(50, AxisRPhi),
                        AxisSpec::DeferredEquidistant(100, AxisZ),
                        "OuterPixelMaterial");
 
    auto& outerPixelContainer = opmat.addCylinderContainer("OuterPixel", AxisZ);
 
    auto& barrelGeoId = outerPixelContainer.withGeometryIdentifier();
    barrelGeoId.setAllVolumeIdsTo(s_outerPixelVolumeId).incrementLayerIds(1);
 
    auto& brl_mat =
        barrelGeoId.addMaterial("OuterPixel_Material", [&](auto& bmat) {
          bmat.configureFace(NegativeDisc,
                             AxisSpec::DeferredEquidistant(50, AxisR),
                             AxisSpec::DeferredEquidistant(50, AxisPhi),
                             "OuterPixel_Material_NegativeDisc");
          bmat.configureFace(PositiveDisc,
                             AxisSpec::DeferredEquidistant(50, AxisR),
                             AxisSpec::DeferredEquidistant(50, AxisPhi),
                             "OuterPixel_Material_PositiveDisc");
        });
    auto& barrel = brl_mat.addCylinderContainer("OuterPixel_Brl", AxisR);
 
    // See InnerPixel_Brl: layers carry material only on OuterCylinder, so
    // Second attachment removes the inter-layer gaps without moving any
    // material surface.
    barrel.setAttachmentStrategy(AttachmentStrategy::Second);
    // Inner edge Expand: the innermost layer's inner cylinder is material-free,
    // so it extends inward onto the container inner shell and fuses with the
    // OuterPixelMaterial InnerCylinder (one material side, nothing moves).
    // Outer edge Expand: the outermost layer grows out onto the OuterPixel
    // OuterCylinder shell (316.7), removing the gap after the last barrel layer.
    // Its own OuterCylinder material is dropped below so the expanded face fuses
    // cleanly with the container shell (the kept surface).
    barrel.setResizeStrategies(ResizeStrategy::Expand, ResizeStrategy::Expand);
 
    std::map<int, std::vector<std::shared_ptr<Acts::Surface>>> layers{};
 
    for (auto& element : elements) {
      IdentityHelper id = element->identityHelper();
      if (id.bec() != 0) {
        continue;
      }
 
      if (id.layer_disk() <= 1) {
        continue;
      }
 
      int elementLayer = id.layer_disk();
      layers[elementLayer].push_back(element->surface().getSharedPtr());
    }
 
    ATH_MSG_DEBUG("Adding " << layers.size() << " layers to OuterPixel barrel");
 
    const int outermostBrlLayer = layers.rbegin()->first;
    for (const auto& [ilayer, surfaces] : layers) {
      ATH_MSG_DEBUG("- Layer " << ilayer << " has " << surfaces.size()
                               << " surfaces");
 
      auto configureLayer = [&](auto& node) {
        auto& layer = node.addLayer(std::format("OuterPixel_Brl_{:}", ilayer));
        layer.setNavigationPolicyFactory(
            Acts::NavigationPolicyFactory{}
                .add<Acts::SurfaceArrayNavigationPolicy>(surfaceArrayConfig(
                    Cylinder, m_itkPixelOuterBarrelNeighborWindow))
                .add<Acts::CylinderNavigationPolicy>()
                .asUniquePtr());
        layer.setSurfaces(surfaces);
        layer.setEnvelope(Acts::ExtentEnvelope{{
            .z = {5_mm, 5_mm},
            .r = {2_mm, 2_mm},
        }});
      };
 
      // Outermost layer expands onto the container OuterCylinder shell, so
      // drop its own OuterCylinder; skip the MaterialDesignator wrapper to
      // avoid empty-designator warnings.
      if (ilayer != outermostBrlLayer) {
        const std::string materialName =
            std::format("OuterPixel_Brl_{}_Material", ilayer);
        barrel.addMaterial(
            materialName,
            [&](auto& lmat) {
              lmat.configureFace(OuterCylinder,
                                 AxisSpec::DeferredEquidistant(50, AxisRPhi),
                                 AxisSpec::DeferredEquidistant(100, AxisZ),
                                 materialName);
              configureLayer(lmat);
            });
      } else {
        configureLayer(barrel);
      }
    }
 
    const auto endcapSurfaceArrayConfig =
        surfaceArrayConfig(Disc, m_itkPixelOuterEndcapNeighborWindow);
    auto addEndcapLayer = [&endcapSurfaceArrayConfig](
                              auto& parent, const auto& name,
                              const auto& surfaces) {
      parent.addLayer(name, [&surfaces, &endcapSurfaceArrayConfig](auto& layer) {
        layer.setNavigationPolicyFactory(
            Acts::NavigationPolicyFactory{}
                .add<Acts::SurfaceArrayNavigationPolicy>(endcapSurfaceArrayConfig)
                .add<Acts::CylinderNavigationPolicy>()
                .asUniquePtr());
 
        layer.setSurfaces(surfaces);
      });
    };
 
    for (int bec : {-2, 2}) {
      const std::string s = bec > 0 ? "p" : "n";
 
      auto& ec_outer_geoId = outerPixelContainer.withGeometryIdentifier();
      ec_outer_geoId
          .setAllVolumeIdsTo(s_outerPixelVolumeId + std::floor(bec / 2))
          .incrementLayerIds(1);
 
      auto& ec_outer =
          ec_outer_geoId.addCylinderContainer(std::format("OuterPixel_{:}EC", s), AxisR);
 
      // Three groups of disks stacked in R
      std::array diskGroups{std::pair{3, 4}, std::pair{6, 5}, std::pair{7, 8}};
 
      for (size_t idx = 0; idx < diskGroups.size(); ++idx) {
        auto [disk1, disk2] = diskGroups[idx];
 
        Acts::MaterialDesignatorBlueprintNode* material = nullptr;
        if (idx < (diskGroups.size() - 1)) {
          const std::string materialName =
              "OuterPixel_" + s + "EC_" + std::to_string(idx) + "_Material";
          material = &ec_outer.addMaterial(
              materialName,
              [&](auto& mat) {
                mat.configureFace(OuterCylinder,
                                  AxisSpec::DeferredEquidistant(50, AxisRPhi),
                                  AxisSpec::DeferredEquidistant(100, AxisZ),
                                  materialName);
              });
        }
 
        auto& ec_stack =
            material
                ? material->addCylinderContainer(
                     std::format("OuterPixel_{:}EC_{:}", s, idx), AxisZ)
                : ec_outer.addCylinderContainer(
                     std::format("OuterPixel_{:}EC_{:}", s, idx), AxisZ);
 
        // Collapse inter-disk gaps by extending the outer disk inward (Second
        // for +z, First for -z); material kept only on outward discs (see
        // below), so surviving material sits at the smaller-|z| side of each gap.
        ec_stack.setAttachmentStrategy(bec > 0 ? AttachmentStrategy::Second
                                               : AttachmentStrategy::First);
        // Barrel-facing edge Expand: extend the innermost disk of each R-group
        // toward the barrel (smaller |z|), removing the barrel<->endcap gap; far
        // (z-end) edge stays Gap. Innermost inward disc dropped below so the
        // expanded face fuses with the barrel end disc (kept, smaller |z|).
        ec_stack.setResizeStrategies(
            bec > 0 ? ResizeStrategy::Expand : ResizeStrategy::Gap,
            bec > 0 ? ResizeStrategy::Gap : ResizeStrategy::Expand);
 
        std::map<std::tuple<int, int>,
                 std::vector<std::shared_ptr<Acts::Surface>>>
            eta_rings;
 
        for (auto& element : elements) {
          IdentityHelper id = element->identityHelper();
          if (id.bec() != bec ||
              (id.layer_disk() != disk1 && id.layer_disk() != disk2)) {
            continue;
          }
          std::tuple<int, int> key{id.layer_disk(), id.eta_module()};
          eta_rings[key].push_back(element->surface().getSharedPtr());
        }
 
        ATH_MSG_DEBUG("Found " << eta_rings.size() << " eta rings in group "
                               << idx);
 
        std::vector<std::vector<std::shared_ptr<Acts::Surface>>> sorted_rings;
        sorted_rings.reserve(eta_rings.size());
        for (const auto& [key, surfaces] : eta_rings) {
          sorted_rings.push_back(surfaces);
        }
 
        std::ranges::sort(sorted_rings, [&gctx](const auto& a, const auto& b) {
          Acts::ProtoLayer pl_a(gctx, Acts::unpackConstSmartPointers(a));
          Acts::ProtoLayer pl_b(gctx, Acts::unpackConstSmartPointers(b));
          return std::abs(pl_a.min(AxisZ)) < std::abs(pl_b.min(AxisZ));
        });
 
        for (size_t i = 0; i < sorted_rings.size(); ++i) {
          const auto& surfaces = sorted_rings[i];
          const std::string layerName = std::format("OuterPixel_{:}EC_{:}_{:}", s,idx, i);
 
          const auto outwardDisc = (bec > 0) ? PositiveDisc : NegativeDisc;
          const std::string materialName = layerName + "_Material";
          ec_stack.addMaterial(materialName, [&](auto& mat) {
            mat.configureFace(outwardDisc,
                              AxisSpec::DeferredEquidistant(50, AxisR),
                              AxisSpec::DeferredEquidistant(50, AxisPhi),
                              materialName);
            addEndcapLayer(mat, layerName, surfaces);
          });
        }
      }
    }
  });
}

buildItkStripBlueprintNode()

void ActsTrk::ItkBlueprintNodeBuilder::buildItkStripBlueprintNode ( const Acts::GeometryContext & gctx, Acts::BlueprintNode & node )

private

Definition at line 807 of file ItkBlueprintNodeBuilder.cxx.

                             {
 
  // Get ITkStrip parameters from detector manager
  if (!m_itkStripMgr) {
    ATH_MSG_ERROR("ITkStrip manager not available");
    throw std::runtime_error("ITkStrip manager not available");
  }
 
  ATH_MSG_DEBUG("Detector manager has "
                << m_itkStripMgr->getDetectorElementCollection()->size()
                << " elements");
 
  std::vector<std::shared_ptr<ActsDetectorElement>> elements;
 
  InDetDD::SiDetectorElementCollection::const_iterator iter;
  for (const auto* element : *m_itkStripMgr->getDetectorElementCollection()) {
    const InDetDD::SiDetectorElement* siDetElement =
        dynamic_cast<const InDetDD::SiDetectorElement*>(element);
    if (siDetElement == nullptr) {
      ATH_MSG_ERROR("Detector element was nullptr");
      throw std::runtime_error{"Corrupt detector element collection"};
    }
    elements.push_back(std::make_shared<ActsDetectorElement>(*siDetElement));
  }
  ATH_MSG_VERBOSE("Retrieved " << elements.size() << " elements");
 
  // Copy to service level store to extend lifetime
  m_elementStore->vector().insert(m_elementStore->vector().end(),
                                  elements.begin(), elements.end());
 
  auto& strip = node.addCylinderContainer("Strip", AxisR);
  strip.setAttachmentStrategy(AttachmentStrategy::Gap);
  // Inner edge Expand: extend all Strip cylinders inward onto the OuterPixel
  // outer shell (316.7), removing Strip::Gap1. The InnerCylinder material
  // (382.5) is dropped below so the expanded face fuses cleanly with the
  // OuterPixel OuterCylinder (316.7, the kept lower-r surface). Outer edge stays
  // Gap (Strip::Gap2, the resize gap up to the ItkNodeMain envelope, carries
  // the Strip outer material and must not move).
  strip.setResizeStrategies(ResizeStrategy::Expand, ResizeStrategy::Gap);
 
  strip.addMaterial("StripMaterial", [&](auto& mat) {
    mat.configureFace(OuterCylinder,
                      AxisSpec::DeferredEquidistant(50, AxisRPhi),
                      AxisSpec::DeferredEquidistant(100, AxisZ),
                      "StripMaterial");
 
    auto& stripContainer = mat.addCylinderContainer("Strip", AxisZ);
 
    // Add barrel container
    stripContainer.withGeometryIdentifier([this, &elements](auto& geoId) {
      geoId.setAllVolumeIdsTo(s_stripVolumeId).incrementLayerIds(1);
 
      auto& brl_mat =
          geoId.addMaterial("Strip_Brl_Material", [&](auto& material) {
            material.configureFace(NegativeDisc,
                                   AxisSpec::DeferredEquidistant(50, AxisR),
                                   AxisSpec::DeferredEquidistant(50, AxisPhi),
                                   "Strip_Brl_Material_NegativeDisc");
            material.configureFace(PositiveDisc,
                                   AxisSpec::DeferredEquidistant(50, AxisR),
                                   AxisSpec::DeferredEquidistant(50, AxisPhi),
                                   "Strip_Brl_Material_PositiveDisc");
          });
      brl_mat.addCylinderContainer(
          "Strip_Brl", AxisR, [this, &elements](auto& barrel) {
            // Collapse the inter-layer gaps by extending the outer layer inward
            // (Second); material kept only on OuterCylinder faces (see
            // addStripBarrelLayer) so it stays at the lower-radius side.
            barrel.setAttachmentStrategy(AttachmentStrategy::Second);
            // Inner edge: Expand the innermost layer onto the StripMaterial
            // inner shell (382.5), removing Strip_Brl::Gap1. The layer's own
            // InnerCylinder material (385.5, redundant with the full-z shell
            // 3mm below it) is dropped in addStripBarrelLayer so the expanded
            // face fuses cleanly (one material side). Outer edge stays Gap
            // (invariant, see OuterPixel_Brl).
            barrel.setResizeStrategies(ResizeStrategy::Expand,
                                       ResizeStrategy::Gap);
 
            std::map<int, std::vector<std::shared_ptr<Acts::Surface>>> layers{};
 
            for (auto& element : elements) {
              IdentityHelper id = element->identityHelper();
              if (id.bec() != 0) {
                continue;
              }
 
              int elementLayer = id.layer_disk();
              layers[elementLayer].push_back(element->surface().getSharedPtr());
            }
 
            ATH_MSG_DEBUG("Adding " << layers.size()
                                    << " layers to Strip barrel");
 
            for (const auto& [ilayer, surfaces] : layers) {
              ATH_MSG_DEBUG("- Layer " << ilayer << " has " << surfaces.size()
                                       << " surfaces");
              addStripBarrelLayer(
                  barrel, ilayer, surfaces,
                  surfaceArrayConfig(Cylinder, m_itkStripBarrelNeighborWindow));
            }
          });
    });
 
    // Add endcap containers
    for (int bec : {-2, 2}) {
      const std::string s = bec > 0 ? "p" : "n";
 
      std::map<int, std::vector<std::shared_ptr<Acts::Surface>>> layers{};
 
      for (auto& element : elements) {
        IdentityHelper id = element->identityHelper();
        if (id.bec() * bec <= 0) {
          continue;
        }
 
        layers[id.layer_disk()].push_back(element->surface().getSharedPtr());
      }
 
      ATH_MSG_DEBUG("Found " << layers.size() << " layers in Strip " << s
                             << "EC");
 
      std::vector<std::vector<std::shared_ptr<Acts::Surface>>> sorted_layers;
      sorted_layers.reserve(layers.size());
      for (const auto& [key, surfaces] : layers) {
        sorted_layers.push_back(surfaces);
      }
 
      std::sort(sorted_layers.begin(), sorted_layers.end(),
                [&gctx](const auto& a, const auto& b) {
                  Acts::ProtoLayer pl_a(gctx, Acts::unpackConstSmartPointers(a));
                  Acts::ProtoLayer pl_b(gctx, Acts::unpackConstSmartPointers(b));
                  return std::abs(pl_a.min(AxisZ)) < std::abs(pl_b.min(AxisZ));
                });
 
      const auto endcapSurfaceArrayConfig =
          surfaceArrayConfig(Disc, m_itkStripEndcapNeighborWindow);
      stripContainer.withGeometryIdentifier([&sorted_layers, bec, &s,
                                             &endcapSurfaceArrayConfig](auto& geoId) {
        geoId.setAllVolumeIdsTo(s_stripVolumeId + std::floor(bec / 2))
            .incrementLayerIds(1);
 
        geoId.addCylinderContainer(
            std::format("Strip_{:}_EC", s), AxisZ,
            [&sorted_layers, &s, bec, &endcapSurfaceArrayConfig](auto& ec) {
              // Collapse inter-disk gaps; material kept on outward discs only
              // (see addStripEndcapLayer), so it stays at the smaller-|z| side.
              ec.setAttachmentStrategy(bec > 0 ? AttachmentStrategy::Second
                                               : AttachmentStrategy::First);
              // Barrel-facing edge Expand: extend the innermost disk toward the
              // barrel (smaller |z|), removing the barrel<->endcap gap; far edge
              // stays Gap. Innermost inward disc dropped (addStripEndcapLayer) so
              // the expanded face fuses with the barrel end disc.
              ec.setResizeStrategies(
                  bec > 0 ? ResizeStrategy::Expand : ResizeStrategy::Gap,
                  bec > 0 ? ResizeStrategy::Gap : ResizeStrategy::Expand);
 
              for (size_t i = 0; i < sorted_layers.size(); ++i) {
                const auto& surfaces = sorted_layers[i];
                auto layerName = std::format("Strip_{:}EC_{:}", s, i);
                addStripEndcapLayer(ec, layerName, surfaces, bec,
                                    endcapSurfaceArrayConfig);
              }
            });
      });
    };
  });
 
  // Explicit spacer volume beyond the strip detector's natural outer radius.
  // Without it, the outer cylinder carrying the strip container material
  // coincides with the ITk node boundary, causing volume merging issues.
  std::vector<std::shared_ptr<Acts::Surface>> allStripSurfaces;
  allStripSurfaces.reserve(elements.size());
  for (auto& element : elements) {
    allStripSurfaces.push_back(element->surface().getSharedPtr());
  }
  Acts::ProtoLayer stripExtent(gctx, Acts::unpackConstSmartPointers(allStripSurfaces));
 
  constexpr double spacerClearance = 5_mm;
  constexpr double spacerThickness = 5_mm;
  double spacerRmin = stripExtent.max(AxisR) + spacerClearance;
  double spacerHalfZ = std::max(std::abs(stripExtent.min(AxisZ)),
                                std::abs(stripExtent.max(AxisZ))) +
                       spacerClearance;
 
  strip.addStaticVolume(
      Acts::Transform3::Identity(),
      std::make_shared<Acts::CylinderVolumeBounds>(
          spacerRmin, spacerRmin + spacerThickness, spacerHalfZ),
      "Strip_OuterSpacer");
}

initialize()

StatusCode ActsTrk::ItkBlueprintNodeBuilder::initialize ( )

override

Definition at line 211 of file ItkBlueprintNodeBuilder.cxx.

                                               {
  for (const Gaudi::Property<std::vector<unsigned int>>* window :
       {&m_itkPixelInnerBarrelNeighborWindow, &m_itkPixelInnerEndcapNeighborWindow,
        &m_itkPixelOuterBarrelNeighborWindow, &m_itkPixelOuterEndcapNeighborWindow,
        &m_itkStripBarrelNeighborWindow, &m_itkStripEndcapNeighborWindow}) {
    if (!toNeighborWindow(window->value()).has_value()) {
      ATH_MSG_FATAL((*window)
                    << " must hold two bin counts of at most "
                    << static_cast<unsigned int>(std::numeric_limits<std::uint8_t>::max()));
      return StatusCode::FAILURE;
    }
  }
  if (m_surfaceArrayOverfill.value() > std::numeric_limits<std::uint8_t>::max()) {
    ATH_MSG_FATAL(m_surfaceArrayOverfill
                  << " exceeds " << static_cast<unsigned int>(std::numeric_limits<std::uint8_t>::max()));
    return StatusCode::FAILURE;
  }
 
  // Retrieve the detector managers from the detector store for enabled systems
  if (m_buildPixel) {
    ATH_CHECK(detStore()->retrieve(m_itkPixelMgr, "ITkPixel"));
  }
  if (m_buildStrip) {
    ATH_CHECK(detStore()->retrieve(m_itkStripMgr, "ITkStrip"));
  }
  m_elementStore = std::make_shared<ActsElementVector>();
  return StatusCode::SUCCESS;
}

surfaceArrayConfig()

Acts::SurfaceArrayNavigationPolicy::Config ActsTrk::ItkBlueprintNodeBuilder::surfaceArrayConfig ( Acts::SurfaceArrayNavigationPolicy::LayerType layerType, const Gaudi::Property< std::vector< unsigned int > > & neighborWindow ) const

private

Configuration of the surface array navigation policy of one layer.

Parameters

layerType	The layer type of the surface array
neighborWindow	The neighbor window bound property, checked in initialize()

Definition at line 241 of file ItkBlueprintNodeBuilder.cxx.

                                                                        {
  return Acts::SurfaceArrayNavigationPolicy::Config{
      .layerType = layerType,
      .bins = {0, 0},
      .numberOfBinsFactor = 5.0,
      .neighborWindow = *toNeighborWindow(neighborWindow.value()),
      .overfill = static_cast<std::uint8_t>(m_surfaceArrayOverfill.value())};
}

Member Data Documentation

m_buildPixel

Gaudi::Property<bool> ActsTrk::ItkBlueprintNodeBuilder::m_buildPixel {this, "buildPixel", true}

private

Definition at line 45 of file ItkBlueprintNodeBuilder.h.

{this, "buildPixel", true};

m_buildStrip

Gaudi::Property<bool> ActsTrk::ItkBlueprintNodeBuilder::m_buildStrip {this, "buildStrip", true}

private

Definition at line 46 of file ItkBlueprintNodeBuilder.h.

{this, "buildStrip", true};

m_doEndcapLayerMerging

Gaudi::Property<bool> ActsTrk::ItkBlueprintNodeBuilder::m_doEndcapLayerMerging

private

Initial value:

{this, "doEndcapLayerMerging",
                                                true}

Definition at line 43 of file ItkBlueprintNodeBuilder.h.

                                            {this, "doEndcapLayerMerging",
                                                true};

m_elementStore

std::shared_ptr<ActsElementVector> ActsTrk::ItkBlueprintNodeBuilder::m_elementStore {nullptr}

private

Definition at line 41 of file ItkBlueprintNodeBuilder.h.

{nullptr};

m_itkPixelInnerBarrelNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::ItkBlueprintNodeBuilder::m_itkPixelInnerBarrelNeighborWindow

private

Initial value:

{
      this, "ITkPixelInnerBarrelNeighborWindow", {1, 8},
      "Neighbor window bound {phi, z} of the ITk inner pixel barrel layers"}

Most bins the surface array lookup serves on each side of the crossing, as {phi, z} for the barrel and {r, phi} for the endcap.

The lookup sizes the window from the crossing angle and the layer thickness, so these values only cap it. The defaults cover the steepest crossing for |z0| < 200 mm at a bin factor of 5.

Definition at line 53 of file ItkBlueprintNodeBuilder.h.

                                                                            {
      this, "ITkPixelInnerBarrelNeighborWindow", {1, 8},
      "Neighbor window bound {phi, z} of the ITk inner pixel barrel layers"};

m_itkPixelInnerEndcapNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::ItkBlueprintNodeBuilder::m_itkPixelInnerEndcapNeighborWindow

private

Initial value:

{
      this, "ITkPixelInnerEndcapNeighborWindow", {2, 1},
      "Neighbor window bound {r, phi} of the ITk inner pixel endcap layers"}

Definition at line 56 of file ItkBlueprintNodeBuilder.h.

                                                                            {
      this, "ITkPixelInnerEndcapNeighborWindow", {2, 1},
      "Neighbor window bound {r, phi} of the ITk inner pixel endcap layers"};

m_itkPixelMgr

const InDetDD::SiDetectorManager* ActsTrk::ItkBlueprintNodeBuilder::m_itkPixelMgr {nullptr}

private

Definition at line 39 of file ItkBlueprintNodeBuilder.h.

{nullptr};

m_itkPixelOuterBarrelNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::ItkBlueprintNodeBuilder::m_itkPixelOuterBarrelNeighborWindow

private

Initial value:

{
      this, "ITkPixelOuterBarrelNeighborWindow", {1, 3},
      "Neighbor window bound {phi, z} of the ITk outer pixel barrel layers"}

Definition at line 59 of file ItkBlueprintNodeBuilder.h.

                                                                            {
      this, "ITkPixelOuterBarrelNeighborWindow", {1, 3},
      "Neighbor window bound {phi, z} of the ITk outer pixel barrel layers"};

m_itkPixelOuterEndcapNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::ItkBlueprintNodeBuilder::m_itkPixelOuterEndcapNeighborWindow

private

Initial value:

{
      this, "ITkPixelOuterEndcapNeighborWindow", {4, 1},
      "Neighbor window bound {r, phi} of the ITk outer pixel endcap and inclined layers"}

Definition at line 62 of file ItkBlueprintNodeBuilder.h.

                                                                            {
      this, "ITkPixelOuterEndcapNeighborWindow", {4, 1},
      "Neighbor window bound {r, phi} of the ITk outer pixel endcap and inclined layers"};

m_itkStripBarrelNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::ItkBlueprintNodeBuilder::m_itkStripBarrelNeighborWindow

private

Initial value:

{
      this, "ITkStripBarrelNeighborWindow", {1, 4},
      "Neighbor window bound {phi, z} of the ITk strip barrel layers"}

Definition at line 65 of file ItkBlueprintNodeBuilder.h.

                                                                       {
      this, "ITkStripBarrelNeighborWindow", {1, 4},
      "Neighbor window bound {phi, z} of the ITk strip barrel layers"};

m_itkStripEndcapNeighborWindow

Gaudi::Property<std::vector<unsigned int> > ActsTrk::ItkBlueprintNodeBuilder::m_itkStripEndcapNeighborWindow

private

Initial value:

{
      this, "ITkStripEndcapNeighborWindow", {2, 1},
      "Neighbor window bound {r, phi} of the ITk strip endcap layers"}

Definition at line 68 of file ItkBlueprintNodeBuilder.h.

                                                                       {
      this, "ITkStripEndcapNeighborWindow", {2, 1},
      "Neighbor window bound {r, phi} of the ITk strip endcap layers"};

m_itkStripMgr

const InDetDD::SiDetectorManager* ActsTrk::ItkBlueprintNodeBuilder::m_itkStripMgr {nullptr}

private

Definition at line 40 of file ItkBlueprintNodeBuilder.h.

{nullptr};

m_surfaceArrayOverfill

Gaudi::Property<unsigned int> ActsTrk::ItkBlueprintNodeBuilder::m_surfaceArrayOverfill

private

Initial value:

{this, "SurfaceArrayOverfill", 0,
      "Extra cells per direction and axis that each surface fills in the surface arrays"}

Extra cells per direction and axis that each surface fills around its footprint.

Definition at line 73 of file ItkBlueprintNodeBuilder.h.

                                                    {this, "SurfaceArrayOverfill", 0,
      "Extra cells per direction and axis that each surface fills in the surface arrays"};

---

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

• ItkBlueprintNodeBuilder.h
• ItkBlueprintNodeBuilder.cxx