ActsTrk::GbtsLayerTool Class Reference

Builds the GBTS layer geometry from the ITk readout geometry. More...

#include <GbtsLayerTool.h>

Inheritance diagram for ActsTrk::GbtsLayerTool:

Collaboration diagram for ActsTrk::GbtsLayerTool:

Classes
struct	ModuleEntry
	One module, as grouped into a layer. More...

Public Member Functions
	GbtsLayerTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~GbtsLayerTool ()=default
virtual StatusCode	initialize () override
virtual const std::vector< Acts::Experimental::GbtsLayerDescription > &	layerDescriptions () const override
virtual const std::vector< short > &	pixelLayers () const override
virtual const std::vector< short > &	stripLayers () const override
virtual const std::vector< GbtsTechnology > &	layerTechnologies () const override

Private Types
using	LayerKey = std::tuple<int, int, short, short>
	Layer key: (side, technology, volume id, layer id).

Private Member Functions
StatusCode	buildLayers ()
	Group the modules into layers and fill the descriptions and hash maps.

Private Attributes
Gaudi::Property< bool >	m_dumpGeometry
Gaudi::Property< std::string >	m_geometryDumpDir
const PixelID *	m_pixelId {nullptr}
const SCT_ID *	m_stripId {nullptr}
const InDetDD::PixelDetectorManager *	m_pixelManager {nullptr}
const InDetDD::SCT_DetectorManager *	m_stripManager {nullptr}
std::vector< Acts::Experimental::GbtsLayerDescription >	m_layerDescriptions
std::vector< GbtsTechnology >	m_layerTechnologies
	What each layer is made of, parallel to m_layerDescriptions.
std::vector< short >	m_pixelLayers
	Wafer hash addressable dense GBTS layer indices.
std::vector< short >	m_stripLayers

Detailed Description

Builds the GBTS layer geometry from the ITk readout geometry.

Ported from the trigger's TrigL2LayerNumberToolITk so that the ACTS GBTS seeding does not have to reach into the trigger for its geometry. The grouping is unchanged - modules are keyed by (side, technology, volume, layer) and each group becomes one GBTS layer - but the result is handed out as Acts::Experimental::GbtsLayerDescription directly, rather than as a TrigInDetSiLayer the caller has to convert.

Definition at line 36 of file GbtsLayerTool.h.

Member Typedef Documentation

LayerKey

using ActsTrk::GbtsLayerTool::LayerKey = std::tuple<int, int, short, short>

private

Layer key: (side, technology, volume id, layer id).

The side is the barrel/endcap code, with the barrel remapped so that it sorts first.

Definition at line 71 of file GbtsLayerTool.h.

Constructor & Destructor Documentation

GbtsLayerTool()

ActsTrk::GbtsLayerTool::GbtsLayerTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 31 of file GbtsLayerTool.cxx.

    : base_class(type, name, parent) {}

~GbtsLayerTool()

virtual ActsTrk::GbtsLayerTool::~GbtsLayerTool ( )

virtualdefault

Member Function Documentation

buildLayers()

StatusCode ActsTrk::GbtsLayerTool::buildLayers ( )

private

Group the modules into layers and fill the descriptions and hash maps.

Definition at line 50 of file GbtsLayerTool.cxx.

                                      {
  std::map<LayerKey, std::vector<ModuleEntry>> hashMap;
 
  // Pixel modules. The GBTS volume id follows the trigger convention:
  // 7 / 8 / 9 for the negative endcap, the barrel and the positive endcap,
  // refined by the layer or disk number.
  for (int hash = 0; hash < static_cast<int>(m_pixelId->wafer_hash_max());
       ++hash) {
    const Identifier offlineId = m_pixelId->wafer_id(hash);
    if (offlineId == 0) {
      continue;
    }
 
    const short barrelEc = m_pixelId->barrel_ec(offlineId);
    if (std::abs(barrelEc) > 2) {
      continue;  // no DBM needed
    }
 
    const short phiIndex = m_pixelId->phi_module(offlineId);
    const short etaIndex = m_pixelId->eta_module(offlineId);
    const int layerDisk = m_pixelId->layer_disk(offlineId);
    const int etaModule = m_pixelId->eta_module(offlineId);
 
    int volId = -1;
    if (barrelEc == 0) {
      volId = 8;
    } else if (barrelEc == -2) {
      volId = 7;
    } else if (barrelEc == 2) {
      volId = 9;
    }
 
    int newVol = 0;
    int newLay = 0;
    if (volId == 7 || volId == 9) {
      newVol = 10 * volId + layerDisk;
      newLay = etaModule;
    } else if (volId == 8) {
      newVol = 10 * volId + layerDisk;
      newLay = 0;
    }
 
    const LayerKey key{barrelEc == 0 ? kBarrelSideKey : barrelEc, kPixel,
                       static_cast<short>(newVol), static_cast<short>(newLay)};
    hashMap[key].push_back(ModuleEntry{phiIndex, etaIndex, hash});
  }
 
  // Strip modules. Volume 13 is the barrel, 12 and 14 the two endcaps.
  for (int hash = 0; hash < static_cast<int>(m_stripId->wafer_hash_max());
       ++hash) {
    const Identifier offlineId = m_stripId->wafer_id(hash);
    if (offlineId == 0) {
      continue;
    }
 
    const short barrelEc = m_stripId->barrel_ec(offlineId);
    const short phiIndex = m_stripId->phi_module(offlineId);
    const short etaIndex = m_stripId->eta_module(offlineId);
 
    int volId = 13;
    if (barrelEc != 0) {
      volId = 12;
    }
    if (barrelEc > 0) {
      volId = 14;
    }
 
    const int layerDisk = m_stripId->layer_disk(offlineId);
 
    const LayerKey key{barrelEc == 0 ? kBarrelSideKey : barrelEc, kStrip,
                       static_cast<short>(volId),
                       static_cast<short>(layerDisk)};
    hashMap[key].push_back(ModuleEntry{phiIndex, etaIndex, hash});
  }
 
  m_pixelLayers.assign(m_pixelId->wafer_hash_max(), kNoLayer);
  m_stripLayers.assign(m_stripId->wafer_hash_max(), kNoLayer);
  m_layerDescriptions.clear();
  m_layerDescriptions.reserve(hashMap.size());
  m_layerTechnologies.clear();
  m_layerTechnologies.reserve(hashMap.size());
 
  std::ofstream geometryStream;
  if (m_dumpGeometry) {
    geometryStream.open(m_geometryDumpDir);
  }
 
  // The layer id packs the volume and the layer into one integer, and the
  // connection table addresses a layer by it. It has room for the ITk
  // layouts in the release: the pixel endcaps reach disk 8, and their
  // volumes, 10 * 7 + disk, only run into the barrel's 80 at disk 10.
  // Nothing enforces that though, and two layers carrying the same id would
  // silently become one layer in GbtsGeometry.
  std::set<int> layerIds;
 
  short layerIndex = 0;
  for (const auto& [key, modules] : hashMap) {
    const auto& [sideKey, technology, volId, layId] = key;
 
    const short barrelEc = sideKey == kBarrelSideKey ? 0 : sideKey;
    const int combinedId = static_cast<int>(volId) * 1000 + layId;
 
    if (!layerIds.insert(combinedId).second) {
      ATH_MSG_ERROR("Two GBTS layers carry the id "
                    << combinedId << ": this detector does not fit the layer "
                    "id encoding");
      return StatusCode::FAILURE;
    }
 
    float refCoordSum = 0.f;
    int nModules = 0;
    double minZ = 100000.0;
    double maxZ = -100000.0;
    double minR = 100000.0;
    double maxR = -100000.0;
 
    for (const ModuleEntry& module : modules) {
      const InDetDD::SiDetectorElement* element = nullptr;
      if (technology == kPixel) {
        m_pixelLayers[module.hash] = layerIndex;
        element = m_pixelManager->getDetectorElement(module.hash);
      } else {
        m_stripLayers[module.hash] = layerIndex;
        element = m_stripManager->getDetectorElement(module.hash);
      }
      if (element == nullptr) [[unlikely]] {
        ATH_MSG_WARNING("SiDetectorElement pointer is null.");
        continue;
      }
 
      minZ = std::min(minZ, element->zMin());
      maxZ = std::max(maxZ, element->zMax());
      minR = std::min(minR, element->rMin());
      maxR = std::max(maxR, element->rMax());
 
      // The reference coordinate is the one that is constant across the
      // layer: the radius for a barrel layer, z for an endcap one.
      const Amg::Vector3D& centre = element->center();
      refCoordSum += barrelEc == 0
                         ? std::hypot(centre(0), centre(1))
                         : centre(2);
      ++nModules;
    }
 
    if (nModules == 0) [[unlikely]] {
      ATH_MSG_ERROR("GBTS layer " << combinedId << " has no modules.");
      return StatusCode::FAILURE;
    }
 
    Acts::Experimental::GbtsLayerDescription& layer =
        m_layerDescriptions.emplace_back();
    m_layerTechnologies.push_back(technology == kPixel ? GbtsTechnology::Pixel
                                                       : GbtsTechnology::Strip);
    layer.id = combinedId;
    layer.type = barrelEc == 0 ? Acts::Experimental::GbtsLayerType::Barrel
                               : Acts::Experimental::GbtsLayerType::Endcap;
    layer.technology = technology == kPixel
                           ? Acts::Experimental::GbtsLayerTechnology::Pixel
                           : Acts::Experimental::GbtsLayerTechnology::Strip;
    layer.refCoord = refCoordSum / nModules;
    // The bounds span the coordinate the layer extends along.
    layer.minBound = barrelEc == 0 ? minZ : minR;
    layer.maxBound = barrelEc == 0 ? maxZ : maxR;
 
    if (m_dumpGeometry) {
      geometryStream << minR << " " << maxR << " " << minZ << " " << maxZ << " "
                     << combinedId << "\n";
    }
 
    ATH_MSG_DEBUG("Layer " << layerIndex << " (" << combinedId
                           << ") : reference coordinate = " << layer.refCoord
                           << " boundaries: " << layer.minBound << " "
                           << layer.maxBound << " type=" << barrelEc
                           << " technology="
                           << (technology == kPixel ? "pixel" : "strip"));
 
    ++layerIndex;
  }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ActsTrk::GbtsLayerTool::initialize ( )

overridevirtual

Definition at line 35 of file GbtsLayerTool.cxx.

                                     {
  ATH_MSG_DEBUG("Initializing " << name() << "...");
 
  ATH_CHECK(detStore()->retrieve(m_pixelId, "PixelID"));
  ATH_CHECK(detStore()->retrieve(m_stripId, "SCT_ID"));
  ATH_CHECK(detStore()->retrieve(m_pixelManager, "ITkPixel"));
  ATH_CHECK(detStore()->retrieve(m_stripManager, "ITkStrip"));
 
  ATH_CHECK(buildLayers());
 
  ATH_MSG_INFO("Built " << m_layerDescriptions.size() << " GBTS layers");
 
  return StatusCode::SUCCESS;
}

layerDescriptions()

virtual const std::vector< Acts::Experimental::GbtsLayerDescription > & ActsTrk::GbtsLayerTool::layerDescriptions ( ) const

inlineoverridevirtual

Definition at line 45 of file GbtsLayerTool.h.

                                     {
    return m_layerDescriptions;
  }

layerTechnologies()

virtual const std::vector< GbtsTechnology > & ActsTrk::GbtsLayerTool::layerTechnologies ( ) const

inlineoverridevirtual

Definition at line 57 of file GbtsLayerTool.h.

                                                                              {
    return m_layerTechnologies;
  }

pixelLayers()

virtual const std::vector< short > & ActsTrk::GbtsLayerTool::pixelLayers ( ) const

inlineoverridevirtual

Definition at line 49 of file GbtsLayerTool.h.

                                                               {
    return m_pixelLayers;
  }

stripLayers()

virtual const std::vector< short > & ActsTrk::GbtsLayerTool::stripLayers ( ) const

inlineoverridevirtual

Definition at line 53 of file GbtsLayerTool.h.

                                                               {
    return m_stripLayers;
  }

Member Data Documentation

m_dumpGeometry

Gaudi::Property<bool> ActsTrk::GbtsLayerTool::m_dumpGeometry

private

Initial value:

{this, "dumpGbtsGeometry", false,
                                       "dump the layer geometry to a file"}

Definition at line 76 of file GbtsLayerTool.h.

                                    {this, "dumpGbtsGeometry", false,
                                       "dump the layer geometry to a file"};

m_geometryDumpDir

Gaudi::Property<std::string> ActsTrk::GbtsLayerTool::m_geometryDumpDir

private

Initial value:

{
      this, "geometryDump", "", "file to dump the layer geometry to"}

Definition at line 78 of file GbtsLayerTool.h.

                                            {
      this, "geometryDump", "", "file to dump the layer geometry to"};

m_layerDescriptions

std::vector<Acts::Experimental::GbtsLayerDescription> ActsTrk::GbtsLayerTool::m_layerDescriptions

private

Definition at line 86 of file GbtsLayerTool.h.

m_layerTechnologies

std::vector<GbtsTechnology> ActsTrk::GbtsLayerTool::m_layerTechnologies

private

What each layer is made of, parallel to m_layerDescriptions.

Definition at line 88 of file GbtsLayerTool.h.

m_pixelId

const PixelID* ActsTrk::GbtsLayerTool::m_pixelId {nullptr}

private

Definition at line 81 of file GbtsLayerTool.h.

{nullptr};

m_pixelLayers

std::vector<short> ActsTrk::GbtsLayerTool::m_pixelLayers

private

Wafer hash addressable dense GBTS layer indices.

Definition at line 90 of file GbtsLayerTool.h.

m_pixelManager

const InDetDD::PixelDetectorManager* ActsTrk::GbtsLayerTool::m_pixelManager {nullptr}

private

Definition at line 83 of file GbtsLayerTool.h.

{nullptr};

m_stripId

const SCT_ID* ActsTrk::GbtsLayerTool::m_stripId {nullptr}

private

Definition at line 82 of file GbtsLayerTool.h.

{nullptr};

m_stripLayers

std::vector<short> ActsTrk::GbtsLayerTool::m_stripLayers

private

Definition at line 90 of file GbtsLayerTool.h.

m_stripManager

const InDetDD::SCT_DetectorManager* ActsTrk::GbtsLayerTool::m_stripManager {nullptr}

private

Definition at line 84 of file GbtsLayerTool.h.

{nullptr};

---

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

• GbtsLayerTool.h
• GbtsLayerTool.cxx