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::Experimental::BlueprintNode >	buildBlueprintNode (const Acts::GeometryContext &gctx, std::shared_ptr< Acts::Experimental::BlueprintNode > &&child) override
	Build the Itk Blueprint Node.

Private Member Functions
void	buildItkStripBlueprintNode (const Acts::GeometryContext &gctx, Acts::Experimental::BlueprintNode &node)
void	buildItkPixelBlueprintNode (const Acts::GeometryContext &gctx, Acts::Experimental::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}

Detailed Description

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

Definition at line 19 of file ItkBlueprintNodeBuilder.h.

Member Function Documentation

buildBlueprintNode()

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

override

Build the Itk Blueprint Node.

Parameters

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

Definition at line 203 of file ItkBlueprintNodeBuilder.cxx.

                                                              {
 
  auto itkNode =
      std::make_shared<Acts::Experimental::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, {AxisR, Bound, 20}, {AxisPhi, Closed, 40});
        mat.configureFace(PositiveDisc, {AxisR, Bound, 20}, {AxisPhi, Closed, 40});
      }
 
    auto& innerContainer = mat.addCylinderContainer("ITkInnerContainer", AxisR);
 
    // 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);
    }
  });
 
  return itkNode;
}

buildItkPixelBlueprintNode()

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

private

Definition at line 241 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);
  innerPixel.setResizeStrategy(ResizeStrategy::Gap);
 
  innerPixel.addMaterial("InnerPixelMaterial", [&](auto& mat) {
    mat.configureFace(OuterCylinder, {AxisRPhi, Closed, 20},
                      {AxisZ, Bound, 20});
    mat.configureFace(InnerCylinder, {AxisRPhi, Closed, 20},
                      {AxisZ, Bound, 20});
 
    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& mat) {
          mat.configureFace(NegativeDisc, {AxisR, Bound, 10},
                            {AxisPhi, Closed, 10});
          mat.configureFace(PositiveDisc, {AxisR, Bound, 10},
                            {AxisPhi, Closed, 10});
        });
    auto& barrel = brl_mat.addCylinderContainer("InnerPixel_Brl", AxisR);
 
    barrel.setAttachmentStrategy(AttachmentStrategy::Gap);
    barrel.setResizeStrategy(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;
      }
 
      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");
 
    for (const auto& [ilayer, surfaces] : layers) {
      ATH_MSG_DEBUG("- Layer " << ilayer << " has " << surfaces.size()
                               << " surfaces");
 
      barrel.addMaterial(
          std::format("InnerPixel_Brl_{}_Material", ilayer), [&](auto& lmat) {
            lmat.configureFace(OuterCylinder, {AxisRPhi, Closed, 40},
                               {AxisZ, Bound, 20});
 
            auto& layer =
                lmat.addLayer(std::format("InnerPixel_Brl_{}", ilayer));
 
            layer.setNavigationPolicyFactory(
                Acts::NavigationPolicyFactory{}
                    .add<Acts::SurfaceArrayNavigationPolicy>(
                        Acts::SurfaceArrayNavigationPolicy::Config{
                            .layerType = Cylinder,
                            .bins = {30, 10}})
                    .add<Acts::TryAllNavigationPolicy>(
                        Acts::TryAllNavigationPolicy::Config{.sensitives =
                                                                 false})
                    .asUniquePtr());
 
            layer.setSurfaces(surfaces);
            layer.setEnvelope(Acts::ExtentEnvelope{{
                .z = {5_mm, 5_mm},
                .r = {2_mm, 2_mm},
            }});
          });
    }
 
    // 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("InnerPixel_" + s + "EC", AxisZ);
      ec.setAttachmentStrategy(AttachmentStrategy::Gap);
      ec.setResizeStrategy(ResizeStrategy::Gap);
 
      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 = [&layerName, &pl](auto& parent) {
          auto& layer = parent.addLayer(layerName);
 
          layer.setNavigationPolicyFactory(
              Acts::NavigationPolicyFactory{}
                  .add<Acts::SurfaceArrayNavigationPolicy>(
                      Acts::SurfaceArrayNavigationPolicy::Config{
                          .layerType = Disc,
                          .bins = {30, 30}})
                  .add<Acts::TryAllNavigationPolicy>(
                      Acts::TryAllNavigationPolicy::Config{.sensitives = false})
                  .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);
        ec.addMaterial(layerName + "_Material", [&](auto& lmat) {
          lmat.configureFace(NegativeDisc, {AxisR, Bound, 10},
                             {AxisPhi, Closed, 40});
          lmat.configureFace(PositiveDisc, {AxisR, Bound, 10},
                             {AxisPhi, Closed, 40});
          addLayer(lmat);
        });
      }
    }
  });
 
  // Outer pixel: 3 outer barrel layers + outer endcaps
  auto& outerPixel = node.addCylinderContainer("OuterPixel", AxisR);
  outerPixel.setAttachmentStrategy(AttachmentStrategy::Gap);
  outerPixel.setResizeStrategy(ResizeStrategy::Gap);
 
  outerPixel.addMaterial("OuterPixelMaterial", [&](auto& opmat) {
    opmat.configureFace(OuterCylinder, {AxisRPhi, Bound, 20}, {AxisZ, Bound, 20});
    opmat.configureFace(InnerCylinder, {AxisRPhi, Bound, 20}, {AxisZ, Bound, 20});
 
    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, {AxisR, Bound, 10},
                            {AxisPhi, Closed, 10});
          bmat.configureFace(PositiveDisc, {AxisR, Bound, 10},
                            {AxisPhi, Closed, 10});
        });
    auto& barrel = brl_mat.addCylinderContainer("OuterPixel_Brl", AxisR);
 
    barrel.setAttachmentStrategy(AttachmentStrategy::Gap);
    barrel.setResizeStrategy(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;
      }
 
      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");
 
    for (const auto& [ilayer, surfaces] : layers) {
      ATH_MSG_DEBUG("- Layer " << ilayer << " has " << surfaces.size()
                               << " surfaces");
 
      barrel.addMaterial(
          std::format("OuterPixel_Brl_{}_Material", ilayer), [&](auto& lmat) {
            lmat.configureFace(OuterCylinder, {AxisRPhi, Closed, 40},
                               {AxisZ, Bound, 20});
 
            auto& layer =
                lmat.addLayer("OuterPixel_Brl_" + std::to_string(ilayer));
 
            layer.setNavigationPolicyFactory(
                Acts::NavigationPolicyFactory{}
                    .add<Acts::SurfaceArrayNavigationPolicy>(
                        Acts::SurfaceArrayNavigationPolicy::Config{
                            .layerType = Cylinder,
                            .bins = {30, 10}})
                    .add<Acts::TryAllNavigationPolicy>(
                        Acts::TryAllNavigationPolicy::Config{.sensitives =
                                                                 false})
                    .asUniquePtr());
 
            layer.setSurfaces(surfaces);
            layer.setEnvelope(Acts::ExtentEnvelope{{
                .z = {5_mm, 5_mm},
                .r = {2_mm, 2_mm},
            }});
          });
    }
 
    constexpr static auto addEndcapLayer = [](auto& parent, const auto& name,
                                              const auto& surfaces) {
      parent.addLayer(name, [&surfaces](auto& layer) {
        layer.setNavigationPolicyFactory(
            Acts::NavigationPolicyFactory{}
                .add<Acts::SurfaceArrayNavigationPolicy>(
                    Acts::SurfaceArrayNavigationPolicy::Config{
                        .layerType = Disc, .bins = {30, 30}})
                .add<Acts::TryAllNavigationPolicy>(
                    Acts::TryAllNavigationPolicy::Config{.sensitives = false})
                .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("OuterPixel_" + s + "EC", 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::Experimental::MaterialDesignatorBlueprintNode* material = nullptr;
        if (idx < (diskGroups.size() - 1)) {
          material = &ec_outer.addMaterial(
              "OuterPixel_" + s + "EC_" + std::to_string(idx) + "_Material",
              [&](auto& mat) {
                mat.configureFace(OuterCylinder, {AxisRPhi, Closed, 20},
                                  {AxisZ, Bound, 20});
              });
        }
 
        auto& ec_stack =
            material
                ? material->addCylinderContainer(
                      "OuterPixel_" + s + "EC_" + std::to_string(idx), AxisZ)
                : ec_outer.addCylinderContainer(
                      "OuterPixel_" + s + "EC_" + std::to_string(idx), AxisZ);
 
        ec_stack.setAttachmentStrategy(AttachmentStrategy::Gap);
        ec_stack.setResizeStrategy(ResizeStrategy::Gap);
 
        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, makeConstPtrVector(a));
          Acts::ProtoLayer pl_b(gctx, makeConstPtrVector(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];
          auto layerName = "OuterPixel_" + s + "EC_" + std::to_string(idx) +
                           "_" + std::to_string(i);
 
          ec_stack.addMaterial(layerName + "_Material", [&](auto& mat) {
            mat.configureFace(PositiveDisc, {AxisR, Bound, 10},
                              {AxisPhi, Closed, 40});
            mat.configureFace(NegativeDisc, {AxisR, Bound, 10},
                              {AxisPhi, Closed, 40});
            addEndcapLayer(mat, layerName, surfaces);
          });
        }
      }
    }
  });
}

buildItkStripBlueprintNode()

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

private

Definition at line 639 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);
  strip.setResizeStrategy(ResizeStrategy::Gap);
 
  strip.addMaterial("StripMaterial", [&](auto& mat) {
    mat.configureFace(OuterCylinder, {AxisRPhi, Closed, 20},
                      {AxisZ, Bound, 20});
    mat.configureFace(InnerCylinder, {AxisRPhi, Closed, 20},
                      {AxisZ, Bound, 20});
 
    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& mat) {
        mat.configureFace(NegativeDisc, {AxisR, Bound, 10},
                          {AxisPhi, Closed, 10});
        mat.configureFace(PositiveDisc, {AxisR, Bound, 10},
                          {AxisPhi, Closed, 10});
      });
      brl_mat.addCylinderContainer(
          "Strip_Brl", AxisR, [this, &elements](auto& barrel) {
            barrel.setAttachmentStrategy(AttachmentStrategy::Gap);
            barrel.setResizeStrategy(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);
            }
          });
    });
 
    // 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, makeConstPtrVector(a));
                  Acts::ProtoLayer pl_b(gctx, makeConstPtrVector(b));
                  return std::abs(pl_a.min(AxisZ)) < std::abs(pl_b.min(AxisZ));
                });
 
      stripContainer.withGeometryIdentifier([&sorted_layers, bec,
                                             &s](auto& geoId) {
        geoId.setAllVolumeIdsTo(s_stripVolumeId + std::floor(bec / 2))
            .incrementLayerIds(1);
 
        geoId.addCylinderContainer(
            "Strip_" + s + "EC", AxisZ, [&sorted_layers, &s](auto& ec) {
              ec.setAttachmentStrategy(AttachmentStrategy::Gap);
              ec.setResizeStrategy(ResizeStrategy::Gap);
 
              for (size_t i = 0; i < sorted_layers.size(); ++i) {
                const auto& surfaces = sorted_layers[i];
                auto layerName = "Strip_" + s + "EC_" + std::to_string(i);
                addStripEndcapLayer(ec, layerName, surfaces);
              }
            });
      });
    };
  });
 
  // 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, makeConstPtrVector(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 190 of file ItkBlueprintNodeBuilder.cxx.

                                               {
  // 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;
}

Member Data Documentation

m_buildPixel

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

private

Definition at line 41 of file ItkBlueprintNodeBuilder.h.

{this, "buildPixel", true};

m_buildStrip

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

private

Definition at line 42 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 39 of file ItkBlueprintNodeBuilder.h.

                                            {this, "doEndcapLayerMerging",
                                                true};

m_elementStore

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

private

Definition at line 37 of file ItkBlueprintNodeBuilder.h.

{nullptr};

m_itkPixelMgr

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

private

Definition at line 35 of file ItkBlueprintNodeBuilder.h.

{nullptr};

m_itkStripMgr

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

private

Definition at line 36 of file ItkBlueprintNodeBuilder.h.

{nullptr};

---

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

• ItkBlueprintNodeBuilder.h
• ItkBlueprintNodeBuilder.cxx