DeviceGBTSSeedingAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#include "DeviceGBTSSeedingAlg.h"
 
#include "StoreGate/ReadHandle.h"
#include "StoreGate/WriteHandle.h"
 
// traccc EDM
#include "traccc/edm/silicon_cell_collection.hpp"
#include "traccc/edm/measurement_collection.hpp"
#include "TrigInDetPattRecoTools/GNN_FasTrackConnector.h"
#include "TrigInDetPattRecoTools/GNN_Geometry.h"
#include "PixelReadoutGeometry/PixelDetectorManager.h"
 
#include "PathResolver/PathResolver.h"
 
// vecmem
#include "vecmem/memory/memory_resource.hpp"
 
// ACTS logging
#include "ActsInterop/Logger.h"
 
#include <fstream>
#include <memory>
#include <cstdint>
#include <unordered_map>
#include <algorithm>
#include <vector>
 
namespace ActsTrk {
 
// -----------------------------------------------------------------------
StatusCode DeviceGBTSSeedingAlg::initialize()
{
  ATH_MSG_DEBUG("Initializing " << name());
 
  ATH_CHECK(m_seedingAlgProviderTool.retrieve());
  ATH_CHECK(m_inputPixelSPKey.initialize());
  ATH_CHECK(m_inputMeasKey.initialize());
  ATH_CHECK(m_outputPixelSeedsKey.initialize());
  ATH_CHECK(detStore()->retrieve(m_idMapping, m_geoIdMappingObjectName.value()));
 
  ATH_CHECK(detStore()->retrieve(m_pixelManager, "ITkPixel"));
  ATH_CHECK(detStore()->retrieve(m_pixelID, "PixelID") );
  ATH_CHECK(m_layerNumberTool.retrieve());
  ATH_CHECK(configureGBTS());
 
  ATH_MSG_DEBUG("Successfully initialized");
  return StatusCode::SUCCESS;
}
 
StatusCode DeviceGBTSSeedingAlg::execute(const EventContext& ctx) const
{
  ATH_MSG_DEBUG("Executing device GBTS seeding.");
 
  // ---- 1. Read input traccc measurements from StoreGate --------------------------------
  auto inputTracccPixelSpacepoints = SG::makeHandle(m_inputPixelSPKey, ctx);
  ATH_CHECK(inputTracccPixelSpacepoints.isValid());
  ATH_MSG_DEBUG("Read traccc spacepoints from '"
                         << inputTracccPixelSpacepoints.key() << "'");
 
  auto inputTracccMeasurements = SG::makeHandle(m_inputMeasKey, ctx);
  ATH_CHECK(inputTracccMeasurements.isValid());
  ATH_MSG_DEBUG("Read traccc measurements from '"
                         << inputTracccMeasurements.key() << "'");
 
  // ---- 2. Get traccc seeding alg ---------------------------------------------
  auto seeding_alg = m_seedingAlgProviderTool->getGBTSAlgorithm(ctx, m_gbts_config);
 
  // ---- 3. Run traccc pixel seed formation ---------------------------------------------
  traccc::edm::seed_collection::buffer pixel_seeds_gpu_buffer = (*seeding_alg)(*inputTracccPixelSpacepoints, *inputTracccMeasurements);
 
  ATH_MSG_DEBUG("Reconstructed " << seeding_alg.copy().get_size(pixel_seeds_gpu_buffer) << " pixel seeds.");
 
  // ---- 4. Write output traccc seeds to StoreGate -------------------------
  auto outputTracccPixelSeeds = SG::makeHandle(m_outputPixelSeedsKey, ctx);
  ATH_CHECK(outputTracccPixelSeeds.record(
    std::make_unique<traccc::edm::seed_collection::buffer>(
        std::move(pixel_seeds_gpu_buffer))));
  ATH_MSG_DEBUG("Wrote spacepoint buffer to '" << m_outputPixelSeedsKey.key() << "'");
 
  return StatusCode::SUCCESS;
}
 
StatusCode DeviceGBTSSeedingAlg::configureGBTS()
{
 
    // traccc-gbts defaults are ITk tuned
    // get layer linking scheme from the athena tools
    std::string conn_fileName =
        PathResolver::find_file(m_connectionFileName, "DATAPATH");
    if (conn_fileName.empty()) {
        ATH_MSG_FATAL("Cannot find layer connections file for GBTS "
                      << conn_fileName);
        return StatusCode::FAILURE;
    }
    std::ifstream ifs(conn_fileName.c_str());
    std::unique_ptr<GNN_FASTRACK_CONNECTOR> gbts_connector =
        std::make_unique<GNN_FASTRACK_CONNECTOR>(ifs, false);
    ATH_MSG_INFO("Layer connections are initialized from file for GBTS "
                 << conn_fileName);
 
    const std::vector<Acts::Experimental::GbtsLayerDescription>& layerDescs =
        m_layerNumberTool->layerDescriptions();
 
    std::vector<TrigInDetSiLayer> layerGeometry;
    layerGeometry.reserve(layerDescs.size());
    for (const auto& layer : layerDescs) {
        TrigInDetSiLayer converted;
        converted.m_subdet = layer.id;
        converted.m_type =
            (layer.type == Acts::Experimental::GbtsLayerType::Endcap) ? 1 : 0;
        converted.m_refCoord = layer.refCoord;
        converted.m_minBound = layer.minBound;
        converted.m_maxBound = layer.maxBound;
        layerGeometry.push_back(converted);
    }
 
    std::unique_ptr<TrigFTF_GNN_Geometry> GBTS_geo =
        std::make_unique<TrigFTF_GNN_Geometry>(layerGeometry, gbts_connector);   
 
    traccc::device::gbts_layerInfo layerInfo;
    // convert save and convert layer info to SoA
    layerInfo.reserve(GBTS_geo->num_layers());
 
    for (unsigned int index = 0; index < GBTS_geo->num_layers(); ++index) {
        const TrigFTF_GNN_Layer* layer =
            GBTS_geo->getTrigFTF_GNN_LayerByIndex(index);
        // pixel barrel=0 pixel endcap=1 pixel inc. barrel=2 strip=3
        int vol_id =
            (layer->m_layer.m_subdet - (layer->m_layer.m_subdet % 1000)) / 1000;
        int is_inc_barrel = (vol_id == 97) | (vol_id == 95) | (vol_id == 93) |
                            (vol_id == 77) | (vol_id == 75) | (vol_id == 73);
        char type = (layer->m_layer.m_type != 0) + is_inc_barrel;
        if (layer->m_layer.m_subdet <= 20000) {
            type = 3;
        }
        // eta prediction cut occurs for type=0 and cluster width cut for type=1
        layerInfo.addLayer(type, layer->m_bins[0], layer->num_bins(),
                           layer->m_minEta, layer->m_etaBin);
    }
 
    const std::vector<short>& pixel_h2l = m_layerNumberTool->pixelLayers();
 
    std::vector<std::pair<std::uint64_t, short>> identifierBinning;
    identifierBinning.reserve(m_idMapping->size());
 
    // construct identifier -> layer table
    IdContext pixel_context = m_pixelID->wafer_context();
    for (const auto& [detrayId, compactId] : m_idMapping->detrayToAthenaMap()) {
        Identifier athenaId(compactId);
        if (m_pixelManager->identifierBelongs(athenaId)) {
            IdentifierHash idHash{};//default c'tor produces detectable invalid hash
            int rc = m_pixelID->get_hash(athenaId, idHash, &pixel_context); //rc=0 is ok
            if (rc!=0)[[unlikely]] continue;
            const short layer = pixel_h2l.at(static_cast<int>(idHash));
            if (layer == IGbtsLayerTool::kNoLayer) [[unlikely]] continue;
            identifierBinning.push_back(std::make_pair(
                detrayId, pixel_h2l.at(static_cast<int>(idHash))));
        }
    }
    ATH_MSG_INFO(identifierBinning.size() << " identifiers with a layer");
 
    std::vector<std::pair<unsigned int, std::vector<unsigned int>>> binGroups;
    {
        const auto & rawBinGroups = GBTS_geo->bin_groups();
        binGroups.reserve(rawBinGroups.size());
        for (const auto& p : rawBinGroups) {
            binGroups.emplace_back(static_cast<unsigned int>(p.first),
                                    std::vector<unsigned int>(p.second.begin(), p.second.end()));
        }
    }
 
    for (auto& pair : binGroups) {
        bool barrel = (pair.first <= 83);  // unsigned, so `0 <= pair.first` is always true — dropped
        if (barrel) {
            pair.second.push_back(pair.first);
        }
    }
 
    // traccc::gbts_seedfinder_config gbts_config;
    if (!m_gbts_config.setLinkingScheme(binGroups, std::move(layerInfo), identifierBinning,
                                    900.0f, makeActsAthenaLogger(this, "GBTSConfig")))
        return StatusCode::FAILURE;
 
    return StatusCode::SUCCESS;
}
 
 
} // namespace ActsTrk