RobustTrackingGeometryBuilderImpl.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
namespace InDet {
template <RobustTrackingGeometryBuilderImpl::ToolType type,
          typename LayerBuilders, typename PipeBuilder>
std::unique_ptr<Trk::TrackingGeometry>
RobustTrackingGeometryBuilderImpl::trackingGeometryImpl(
    const LayerBuilders& layerHandles, const PipeBuilder& pipeHandle,
    [[maybe_unused]] const EventContext* ctx,
    [[maybe_unused]] SG::WriteCondHandle<Trk::TrackingGeometry>* whandle)
    const {
 
  // only one assumption:
  // layer builders are ordered in increasing r
 
  ////////////////////////////////////////////////////////////////////////////////////////////////////////
  // The Overall Geometry
 
  // retrieve all the layers and sort them
  unsigned int numLayBuilders = layerHandles.size();
 
  // central sector extend
  double centralExtendZ = 0.;
  // endcap extends
  double endcapMaxExtend = 0.;
  double endcapMinExtend = 10e10;
  // and the overallExtend(s)
  double overallExtendZ = 0.;
  double overallRmin = 10e10;
  double overallRmax = 0.;
 
  // cylinder layers at growing radii
  std::vector<std::vector<Trk::Layer*> > providedCylinderLayers;
  providedCylinderLayers.reserve(numLayBuilders);
  std::vector<double> cylinderInnerRadii(numLayBuilders, 10e10);
  std::vector<double> cylinderOuterRadii(numLayBuilders, 0.);
  std::vector<double> cylinderExtendsInZ(numLayBuilders, 0.);
 
  // negative disc layers and positive disc layers
  std::vector<std::vector<Trk::Layer*> > providedDiscLayersNeg;
  std::vector<std::vector<Trk::Layer*> > providedDiscLayersPos;
  providedDiscLayersNeg.reserve(numLayBuilders);
  providedDiscLayersPos.reserve(numLayBuilders);
  std::vector<double> discInnerRadii(numLayBuilders, 10e10);
  std::vector<double> discOuterRadii(numLayBuilders, 0.);
  std::vector<double> discMinZ(numLayBuilders, 10e10);
  std::vector<double> discMaxZ(numLayBuilders, 0.);
 
  // (I) PARSE THE LAYERS FOR OVERALL DIMENSIONS
  // -------------------------------------------------------------
  ATH_MSG_DEBUG("[ STEP 1 ] : Parse the provided layers for the dimensions.");
  // fill the layers into the vectors
  for (unsigned int ilb = 0; ilb < layerHandles.size(); ++ilb) {
 
    Trk::BinningType binningType =
        (m_layerBinningType.size() == layerHandles.size())
            ? (Trk::BinningType)m_layerBinningType[ilb]
            : Trk::arbitrary;
 
    // retrieve the cylinder and disc layers
    ATH_MSG_DEBUG("[ LayerBuilder : '" << layerHandles[ilb]->identification()
                                       << "' ] being processed. ");
    // (a) cylinder
    std::unique_ptr<const std::vector<Trk::CylinderLayer*> > cylinderLayers =
        nullptr;
    if constexpr (type == Cond) {
      cylinderLayers = layerHandles[ilb]->cylindricalLayers(*ctx, *whandle);
    } else {
      cylinderLayers = layerHandles[ilb]->cylindricalLayers();
    }
    // (a)
    std::vector<Trk::Layer*> cylinderVolumeLayers;
    if (cylinderLayers && !cylinderLayers->empty()) {
      // screen output
      ATH_MSG_DEBUG("          Processing CylinderLayers : ");
      // the ones to be filled into the double-vector
      for (const auto& cylIter : *cylinderLayers) {
        // get the CylinderBounds
        const Trk::CylinderBounds& cylBounds =
            (cylIter)->surfaceRepresentation().bounds();
        double currentR = cylBounds.r();
        // rmin/rmax with thicknes in mind
        double currentRmin =
            binningType != Trk::biequidistant
                ? currentR - 0.5 * (cylIter)->thickness() - m_layerEnvelopeCover
                : currentR + 0.5 * (cylIter)->thickness() -
                      m_layerEnvelopeCover;
        double currentRmax =
            currentR + 0.5 * (cylIter)->thickness() + m_layerEnvelopeCover;
        // safe
        double extendZ =
            cylIter->surfaceRepresentation().center().z() < 0.
                ? std::abs(cylIter->surfaceRepresentation().center().z() -
                       cylBounds.halflengthZ()) -
                      m_layerEnvelopeCover
                : cylIter->surfaceRepresentation().center().z() +
                      cylBounds.halflengthZ() + m_layerEnvelopeCover;
        // note the dimension
        takeSmaller(cylinderInnerRadii[ilb], currentRmin);
        takeBigger(cylinderOuterRadii[ilb], currentRmax);
        takeBigger(cylinderExtendsInZ[ilb], extendZ);
        // push it into the vector
        cylinderVolumeLayers.push_back(cylIter);
        // overall dimensions
        takeSmaller(overallRmin, currentRmin);
        takeBigger(overallRmax, currentRmax);
        takeBigger(centralExtendZ, extendZ);
        // in case no disc layers are provided
        takeBigger(overallExtendZ, centralExtendZ);
      }
      // special treatment for bi-equidistant binning - a navigation layer will
      // be added before and after the layers
      if (binningType == Trk::biequidistant) {
        double rStep = (cylinderOuterRadii[ilb] - cylinderInnerRadii[ilb]) /
                       (cylinderLayers->size() - 1);
        ATH_MSG_VERBOSE("           -> bi-equidistant : rStep estimated as "
                        << rStep);
        cylinderInnerRadii[ilb] -= rStep;
        cylinderOuterRadii[ilb] += rStep;
        takeBigger(overallRmax, cylinderOuterRadii[ilb]);
      }
      ATH_MSG_VERBOSE("           -> yield (rMin/rMax/halflengthZ) = "
                      << cylinderInnerRadii[ilb] << " / "
                      << cylinderOuterRadii[ilb] << " / "
                      << cylinderExtendsInZ[ilb]);
 
    } else
      ATH_MSG_DEBUG("          No cylindrical layers processed.");
 
    providedCylinderLayers.push_back(cylinderVolumeLayers);
    // if after parsing of cylinder layers the maximal extend of cylinders is
    // bigger than the minmal of discs reset the disc min extend (tiple will be
    // swallowed)!
    endcapMinExtend =
        (centralExtendZ > endcapMinExtend) ? 10e10 : endcapMinExtend;
 
    // (b) discs
    std::unique_ptr<const std::vector<Trk::DiscLayer*> > discLayers = nullptr;
    if constexpr (type == Cond) {
      discLayers = layerHandles[ilb]->discLayers(*ctx, *whandle);
    } else {
      discLayers = layerHandles[ilb]->discLayers();
    }
 
    std::vector<Trk::Layer*> discVolumeLayersNeg;
    std::vector<Trk::Layer*> discVolumeLayersPos;
    if (discLayers && !discLayers->empty()) {
      // screen output
      ATH_MSG_DEBUG("          Processing DiscLayers : ");
      for (const auto& discIter : *discLayers) {
        // get the DiscBounds
        const Trk::DiscBounds* discBounds =
            dynamic_cast<const Trk::DiscBounds*>(
                &(discIter->surfaceRepresentation().bounds()));
        // get the current Z min/max
        double discZ = discIter->surfaceRepresentation().center().z();
        double currentZmin = binningType != Trk::biequidistant
                                 ? (discZ - 0.5 * discIter->thickness())
                                 : (discZ + 0.5 * discIter->thickness());
        double currentZmax = discZ + 0.5 * discIter->thickness();
        // force it to be symmetrized
        if (currentZmax > 0.) {
          takeSmaller(discMinZ[ilb], currentZmin);
          takeBigger(discMaxZ[ilb], currentZmax);
          // push it into the vector
          discVolumeLayersPos.push_back(discIter);
        } else {
          // in symmetrized setup only interested in total numbers
          double negMinZ = std::abs(currentZmax);
          double negMaxZ = std::abs(currentZmin);
          takeSmaller(discMinZ[ilb], negMinZ);
          takeBigger(discMaxZ[ilb], negMaxZ);
          // push it into the vector
          discVolumeLayersNeg.push_back(discIter);
        }
 
        // radial dimensions
        if (discBounds) {
          double currentRmin = discBounds->rMin();
          double currentRmax = discBounds->rMax();
          // note the dimension
          takeSmaller(discInnerRadii[ilb], currentRmin);
          takeBigger(discOuterRadii[ilb], currentRmax);
          // overall dimensions
          takeSmaller(overallRmin, currentRmin);
          takeBigger(overallRmax, currentRmax);
        }
        // min/max extend of the discs
        takeSmaller(endcapMinExtend, discMinZ[ilb]);
        takeBigger(endcapMaxExtend, discMaxZ[ilb]);
        takeBigger(overallExtendZ, endcapMaxExtend);
      }
      // special treatment for bi-equidistant binning - a navigation layer will
      // be added before and after the layers
      if (binningType == Trk::biequidistant) {
        double zStep =
            (discMaxZ[ilb] - discMinZ[ilb]) / (discLayers->size() / 2 - 1);
        discMinZ[ilb] -= zStep;
        discMaxZ[ilb] += zStep;
        takeBigger(overallExtendZ, discMaxZ[ilb]);
      }
 
      ATH_MSG_VERBOSE("           -> yield (rMin/rMax/zMin/zMax) = "
                      << discInnerRadii[ilb] << " / " << discOuterRadii[ilb]
                      << " / " << discMinZ[ilb] << " / " << discMaxZ[ilb]);
 
    } else
      ATH_MSG_DEBUG("          No disk-like layers processed.");
 
    // fill the layers into the double-vector
    providedDiscLayersNeg.push_back(discVolumeLayersNeg);
    providedDiscLayersPos.push_back(discVolumeLayersPos);
 
    if (msgLvl(MSG::VERBOSE)) {
      // summary after this step
      ATH_MSG_VERBOSE(
          "[ Summary STEP 1  ---------------------------------------- ]  ");
      ATH_MSG_VERBOSE(
          "                      overall minimum r : " << overallRmin);
      ATH_MSG_VERBOSE(
          "                      overall maximum r : " << overallRmax);
      ATH_MSG_VERBOSE(
          "                       overall z extend : " << overallExtendZ);
      ATH_MSG_VERBOSE(
          "                central sector z extend : " << centralExtendZ);
      ATH_MSG_VERBOSE(
          "                maximum endcap z extend : " << endcapMaxExtend);
      ATH_MSG_VERBOSE(
          "                minimum endcap z extend : " << endcapMinExtend);
    }
  }
 
  // (II) update the positions
  // ------------------------------------------------------------
  ATH_MSG_DEBUG(
      "[ STEP 2 ] : Closing the gaps from the parsed original dimensions.");
  // i.e. close the gap
  double oldCeZ = centralExtendZ;
  centralExtendZ = 0.5 * (endcapMinExtend + oldCeZ);
  endcapMinExtend = centralExtendZ;
 
  ATH_MSG_DEBUG("             central sector extend in z recalculated to be "
                << centralExtendZ << " (was " << oldCeZ << ")");
 
  // (III) create the sub volumes
  // -------------------------------------------------------------
  ATH_MSG_DEBUG("[ STEP 3 ] : Create the sub volumes.");
 
  std::vector<Trk::TrackingVolume*> centralSectorVolumes;
  std::vector<Trk::TrackingVolume*> negativeSectorVolumes;
  std::vector<Trk::TrackingVolume*> positiveSectorVolumes;
 
  // --------------------------------------------------------------------------------------------------
  // first the beampipe volume
  Trk::TrackingVolume* beamPipeVolume = nullptr;
  // the Volume Bounds
  Trk::CylinderVolumeBounds* beamPipeBounds =
      new Trk::CylinderVolumeBounds(overallRmin, overallExtendZ);
  // BinnedArray needed
  Trk::BinnedArray<Trk::Layer>* beamPipeLayerArray = nullptr;
 
  std::unique_ptr<const std::vector<Trk::CylinderLayer*> > beamPipeVecPtr =
      nullptr;
  if constexpr (type == Cond) {
    beamPipeVecPtr = pipeHandle->cylindricalLayers(*ctx, *whandle);
  } else {
    beamPipeVecPtr = pipeHandle->cylindricalLayers();
  }
 
  if (!beamPipeVecPtr->empty()) {
    beamPipeLayerArray = m_layerArrayCreator->cylinderLayerArray(
        *beamPipeVecPtr, 0., beamPipeBounds->outerRadius(), Trk::arbitrary);
  }
  // create the TrackingVolume
  beamPipeVolume =
      new Trk::TrackingVolume(nullptr, beamPipeBounds, *m_materialProperties,
                              beamPipeLayerArray, nullptr, "InDet::BeamPipe");
  // set the color code
  beamPipeVolume->registerColorCode(46);
 
  // beampipe + detectors / prepared
  std::vector<Trk::TrackingVolume*> idVolumes;
  idVolumes.push_back(beamPipeVolume);
 
  // --------------------------------------------------------------------------------------------------
  double lastCentralOuterR = beamPipeBounds->outerRadius();
  double lastNegEndcapOuterR = lastCentralOuterR;
  double lastPosEndcapOuterR = lastCentralOuterR;
 
  // loop over double-vectors, access the dimensions from the parsing
  auto pclIter = providedCylinderLayers.begin();
  auto pclEnd = providedCylinderLayers.end();
  auto pndlIter = providedDiscLayersNeg.begin();
  auto pndlEnd = providedDiscLayersNeg.end();
  auto ppdlIter = providedDiscLayersPos.begin();
  auto ppdlEnd = providedDiscLayersPos.end();
 
  // the number of layer builders
  unsigned int numLayerBuilders = layerHandles.size();
 
  // loop over the prepared volumes
  for (unsigned int ilb = 0;
       pclIter != pclEnd && pndlIter != pndlEnd && ppdlIter != ppdlEnd;
       ++pclIter, ++pndlIter, ++ppdlIter, ++ilb) {
    // color code configuration (from jobOptions/declareProperty interface)
    int colorCode = (m_colorCodesConfig.size() == numLayerBuilders)
                        ? m_colorCodesConfig[ilb]
                        : 21;
 
    Trk::BinningType binningType =
        (m_layerBinningType.size() == numLayerBuilders)
            ? (Trk::BinningType)m_layerBinningType[ilb]
            : Trk::arbitrary;
 
    // volume name base
    std::string baseName = layerHandles[ilb]->identification();
    ATH_MSG_DEBUG("[ Volume Creation : '" << baseName << "'] carried out.");
    ATH_MSG_DEBUG("       + color code                     : " << colorCode);
 
    // maxmmal z extend for volume set & endcap inner z
    double currentSetExtendZ = (!(*pndlIter).empty() || !(*ppdlIter).empty())
                                   ? discMaxZ[ilb]
                                   : cylinderExtendsInZ[ilb];
    double currentEndcapInnerZ = (!(*pndlIter).empty() || !(*ppdlIter).empty())
                                     ? discMinZ[ilb]
                                     : currentSetExtendZ;
 
    // radii for the sectors
    double currentCentralOuterR = 0.;
    double currentEndcapOuterR = 0.;
 
    if (m_isITk) {
      double NextInnerRadii =
          ((ilb != cylinderOuterRadii.size() - 1) &&
           cylinderInnerRadii[ilb + 1] < discInnerRadii[ilb + 1])
              ? cylinderInnerRadii[ilb + 1]
              : discInnerRadii[ilb + 1];
      currentCentralOuterR =
          (ilb != cylinderOuterRadii.size() - 1)
              ? 0.5 * (NextInnerRadii + cylinderOuterRadii[ilb])
              : overallRmax;
      currentEndcapOuterR = (ilb != discOuterRadii.size() - 1)
                                ? 0.5 * (NextInnerRadii + discOuterRadii[ilb])
                                : overallRmax;
    } else {
      // we build from inside to outside, don't take middle position, but tend
      // towards outer extend
      currentCentralOuterR =
          (ilb != cylinderOuterRadii.size() - 1)
              ? (m_outwardsFraction * cylinderInnerRadii[ilb + 1] +
                 (1. - m_outwardsFraction) * cylinderOuterRadii[ilb])
              : overallRmax;
      currentEndcapOuterR =
          (ilb != discOuterRadii.size() - 1)
              ? (m_outwardsFraction * discInnerRadii[ilb + 1] +
                 (1. - m_outwardsFraction) * discOuterRadii[ilb])
              : overallRmax;
    }
 
    ATH_MSG_VERBOSE("       + checking the sector boundaries : ");
    ATH_MSG_VERBOSE("         central sector ext. z (boundary)  = "
                    << currentSetExtendZ << " (" << centralExtendZ << ")");
    ATH_MSG_VERBOSE("       + current volume radii rMax (c/d)   = "
                    << currentCentralOuterR << " / " << currentEndcapOuterR);
    // estimate the case
    // cases are :
    enum PackCase { contained, radial, central, split };
    //   0 - both cylinders and disc are contained in the central sector
    //   1 - radial packing, volumes can't be put in in central / ec sectors
    //   2 - only central sector exists
    //   3 - standard ecn / central / ecp sectors split
    bool endcapsExist = !(*pndlIter).empty() && !(*ppdlIter).empty();
    // case flag set
    PackCase caseFlag = (currentSetExtendZ < centralExtendZ && endcapsExist)
                            ? contained
                            : split;
    if (currentSetExtendZ > centralExtendZ &&
        currentEndcapInnerZ < centralExtendZ && endcapsExist)
      caseFlag = radial;
    if (!endcapsExist)
      caseFlag = central;
 
    // case 0 and 1 can be handled together :
    if (caseFlag == contained || caseFlag == radial) {
      // create the volume sizes for the compact volume
      double currentCentralExtendZ =
          0.5 * (cylinderExtendsInZ[ilb] + discMinZ[ilb]);
      double currentExtendZ = contained ? centralExtendZ : overallExtendZ;
      // in the radial wrapping case : take the smaller radius, assumes that
      // packing is possible
      double currentOuterR = currentCentralOuterR < currentEndcapOuterR
                                 ? currentCentralOuterR
                                 : currentEndcapOuterR;
      // create the tiple container
      Trk::TrackingVolume* tripleContainer = packVolumeTriple(
          (*pndlIter), (*pclIter), (*ppdlIter), lastCentralOuterR,
          currentOuterR, currentExtendZ, currentCentralExtendZ, baseName,
          colorCode, binningType);
 
      // cache the last central / ec outer radius
      lastCentralOuterR = currentOuterR;
      if (contained) {
        ATH_MSG_VERBOSE(
            "       + case I   : provided cylinder and disc layers are "
            "entirely contained in central sector.");
        // and push the centralSectorVolumes
        centralSectorVolumes.push_back(tripleContainer);
      } else {
        ATH_MSG_VERBOSE(
            "       + case II  : split into negative - central - positive "
            "sectors doesn't work, radial wrapping");
        // cache the laster endcap radii  (need to be equal since this is
        // radially wrapped)
        lastNegEndcapOuterR = currentOuterR;
        lastPosEndcapOuterR = currentOuterR;
        // the triple goes into the radial packing volumes
        idVolumes.push_back(tripleContainer);
      }
      // case 2 and 3
    } else {
      // output for case 3 and 4
      if (!endcapsExist)
        ATH_MSG_VERBOSE("       + case III : only central sector.");
      else
        ATH_MSG_VERBOSE(
            "       + case IV  : split into negative - central - positive "
            "sectors.");
      // build the name
      std::string volumeBase = m_namespace + "Detectors::" + baseName;
      // cylinder layers exist -------------------------------
      if (!(*pclIter).empty()) {
 
        ATH_MSG_VERBOSE("       -> central sector is being build.");
        // create the cylinder barrel
        Trk::TrackingVolume* barrel =
            m_trackingVolumeCreator->createTrackingVolume(
                (*pclIter), *m_materialProperties, lastCentralOuterR,
                currentCentralOuterR, -centralExtendZ, centralExtendZ,
                volumeBase + "::Barrel", binningType);
        // register the color code
        barrel->registerColorCode(colorCode);
        // cache the last ones
        lastCentralOuterR = currentCentralOuterR;
        // and push the centralSectorVolumes
        centralSectorVolumes.push_back(barrel);
      }
 
      // negative disc layers exist ------------------------------
      if (!(*pndlIter).empty()) {
 
        ATH_MSG_VERBOSE("       -> negative endcap is being build.");
        // create the cylinder barrel
        Trk::TrackingVolume* negEndcap =
            m_trackingVolumeCreator->createTrackingVolume(
                (*pndlIter), *m_materialProperties, lastNegEndcapOuterR,
                currentEndcapOuterR, -overallExtendZ, -endcapMinExtend,
                volumeBase + "::NegativeEndcap", binningType);
        // register the color code
        negEndcap->registerColorCode(colorCode);
        // cache the last ones
        lastNegEndcapOuterR = currentEndcapOuterR;
        // and push the negativeSectorVolumes
        negativeSectorVolumes.push_back(negEndcap);
      }
      // positive disc layers exist --------------------------------
      if (!(*ppdlIter).empty()) {
 
        ATH_MSG_VERBOSE("       -> positive endcap is being build.");
        // create the cylinder barrel
        Trk::TrackingVolume* posEndcap =
            m_trackingVolumeCreator->createTrackingVolume(
                (*ppdlIter), *m_materialProperties, lastPosEndcapOuterR,
                currentEndcapOuterR, endcapMinExtend, overallExtendZ,
                volumeBase + "::PositiveEndcap", binningType);
        // register the color code
        posEndcap->registerColorCode(colorCode);
        // cache the last ones
        lastPosEndcapOuterR = currentEndcapOuterR;
        // and push the positiveSectorVolumes
        positiveSectorVolumes.push_back(posEndcap);
      }
    }
  }
 
  // (IV) create the container
  // ---------------------------------------------------------
  ATH_MSG_DEBUG("[ STEP 4 ] : Create the container volume");
 
  bool enclose = (!m_enclosingEnvelopeSvc.empty());
 
  Trk::TrackingVolume* detectorContainer =
      packVolumeTriple(negativeSectorVolumes, centralSectorVolumes,
                       positiveSectorVolumes, "Container");
 
  // get the dimensions from the envelope service
  const RZPairVector& envelopeDefs =
      m_enclosingEnvelopeSvc->getInDetRZBoundary();
  ATH_MSG_VERBOSE(
      "       -> retrieved Inner Detector envelope definitions at size "
      << envelopeDefs.size());
  double enclosingVolumeRadius = envelopeDefs[1].first;
  double enclosingVolumeHalfZ = fabs(envelopeDefs[1].second);
 
  // central enclosure volume
  Trk::TrackingVolume* centralEnclosure =
      enclose ? m_trackingVolumeCreator->createGapTrackingVolume(
                    *m_materialProperties, overallRmax, enclosingVolumeRadius,
                    -overallExtendZ, overallExtendZ, 1, true,
                    m_namespace + "Gaps::CentralEnclosure")
              : nullptr;
 
  // push the detector container into the ID volumes
  idVolumes.push_back(detectorContainer);
  if (centralEnclosure)
    idVolumes.push_back(centralEnclosure);
 
  std::string volumeName =
      enclose ? "InDet::Detectors::BpPixSctTrt" : m_exitVolume;
 
  ATH_MSG_VERBOSE("       -> inserting beam pipe into detectors.");
 
  Trk::TrackingVolume* detectorWithBp =
      m_trackingVolumeCreator->createContainerTrackingVolume(
          idVolumes, *m_materialProperties, volumeName, m_buildBoundaryLayers,
          m_replaceJointBoundaries);
 
  // if packing is needed
  // ------------------------------------------------------------------
  Trk::TrackingVolume* highestIdVolume = nullptr;
  if (enclose) {
 
    // negative positions
    std::vector<double> negDiscPositionZ(m_enclosingDiscPositionZ);
    for (double& posIter : negDiscPositionZ)
      posIter *= -1;
 
    Trk::TrackingVolume* negativeEnclosure =
        !negDiscPositionZ.empty()
            ? m_trackingVolumeCreator->createGapTrackingVolume(
                  *m_materialProperties, 0., enclosingVolumeRadius,
                  -enclosingVolumeHalfZ, -overallExtendZ, negDiscPositionZ,
                  false, m_namespace + "Gaps::NegativeEnclosure")
            : m_trackingVolumeCreator->createGapTrackingVolume(
                  *m_materialProperties, 0., enclosingVolumeRadius,
                  -enclosingVolumeHalfZ, -overallExtendZ, 1, false,
                  m_namespace + "Gaps::NegativeEnclosure");
 
    Trk::TrackingVolume* positiveEnclosure =
        !m_enclosingDiscPositionZ.empty()
            ? m_trackingVolumeCreator->createGapTrackingVolume(
                  *m_materialProperties, 0., enclosingVolumeRadius,
                  overallExtendZ, enclosingVolumeHalfZ,
                  m_enclosingDiscPositionZ, false,
                  m_namespace + "Gaps::PositiveEnclosure")
            : m_trackingVolumeCreator->createGapTrackingVolume(
                  *m_materialProperties, 0., enclosingVolumeRadius,
                  overallExtendZ, enclosingVolumeHalfZ, 1, false,
                  m_namespace + "Gaps::PositiveEnclosure");
 
    std::vector<Trk::TrackingVolume*> enclosedVolumes;
    enclosedVolumes.push_back(negativeEnclosure);
    enclosedVolumes.push_back(detectorWithBp);
    enclosedVolumes.push_back(positiveEnclosure);
 
    Trk::TrackingVolume* enclosedDetector =
        m_trackingVolumeCreator->createContainerTrackingVolume(
            enclosedVolumes, *m_materialProperties, m_exitVolume,
            m_buildBoundaryLayers, m_replaceJointBoundaries);
 
    highestIdVolume = enclosedDetector;
  } else
    highestIdVolume = detectorWithBp;
 
  // (V) create the TrackingGeometry
  // ------------------------------------------------------
  auto trackingGeometry =
      std::make_unique<Trk::TrackingGeometry>(highestIdVolume);
 
  if (m_indexStaticLayers) {
    ATH_MSG_VERBOSE("Re-index the static layers ...");
    // ST temporary hack till layer numbering resolved
    // trackingGeometry->indexStaticLayers(geometrySignature());
    trackingGeometry->indexStaticLayers(Trk::Global);
  }
 
  return trackingGeometry;
}
 
}  // namespace InDet