ActsTrk::GnnPipelineTool Class Reference

#include <GnnPipelineTool.h>

Inheritance diagram for ActsTrk::GnnPipelineTool:

Collaboration diagram for ActsTrk::GnnPipelineTool:

Public Member Functions
	GnnPipelineTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~GnnPipelineTool ()
StatusCode	initialize () override
StatusCode	buildSeed (const std::vector< const xAOD::SpacePointContainer * > &spacePointCollections, ActsTrk::SeedContainer &seeds) const override

Private Member Functions
const Acts::Logger &	logger () const
StatusCode	buildFeatures (const std::vector< const xAOD::SpacePointContainer * > &spacePointCollections, std::vector< float > &features, std::vector< std::uint64_t > &moduleIds, std::vector< int > &ids, std::vector< const xAOD::SpacePoint * > &allSPPtrs, std::size_t nFeatures=12) const

Private Attributes
Gaudi::Property< std::string >	m_moduleMapPath
Gaudi::Property< std::string >	m_gnnPath
Gaudi::Property< bool >	m_usePhiOverlapSps
Gaudi::Property< unsigned int >	m_maxGpuInstances
Gaudi::Property< unsigned int >	m_numTrtContexts
Gaudi::Property< double >	m_edgeCut
Gaudi::Property< unsigned int >	m_minCandidateMeasurements
Gaudi::Property< int >	m_cudaDeviceIndex
std::unique_ptr< const Acts::Logger >	m_logger
ServiceHandle< IChronoStatSvc >	m_chronoSvc {"ChronoStatSvc", name()}
const PixelID *	m_pixelIdHelper {nullptr}
const SCT_ID *	m_stripIdHelper {nullptr}
std::unique_ptr< ActsPlugins::GnnPipeline >	m_gnnPipeline
std::optional< std::counting_semaphore<> > m_gpuInstanceCount	ATLAS_THREAD_SAFE {}

Detailed Description

Definition at line 32 of file GnnPipelineTool.h.

Constructor & Destructor Documentation

GnnPipelineTool()

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

Definition at line 26 of file GnnPipelineTool.cxx.

    : base_class(type, name, parent) {}

~GnnPipelineTool()

ActsTrk::GnnPipelineTool::~GnnPipelineTool ( )

virtualdefault

Member Function Documentation

buildFeatures()

StatusCode ActsTrk::GnnPipelineTool::buildFeatures ( const std::vector< const xAOD::SpacePointContainer * > & spacePointCollections, std::vector< float > & features, std::vector< std::uint64_t > & moduleIds, std::vector< int > & ids, std::vector< const xAOD::SpacePoint * > & allSPPtrs, std::size_t nFeatures = 12 ) const

inlineprivate

Definition at line 48 of file GnnFeatures.h.

                               {
 
  std::size_t nSP = 0;
  for (const auto* spc : spacePointCollections) {
    nSP += spc->size();
  }
  moduleIds.reserve(nSP);
  allSPPtrs.reserve(nSP);
 
  std::size_t skipped = 0;
  for (const auto* spc : spacePointCollections) {
    for (const auto* sp : *spc) {
      const auto* cl1 = sp->measurements().front();
      Identifier atlasIdCl1(
          static_cast<Identifier::value_type>(cl1->identifier()));
 
      if (!m_usePhiOverlapSps.value() && sp->measurements().size() == 2) {
        const auto* cl2 = sp->measurements().at(1);
        Identifier atlasIdCl2(
            static_cast<Identifier::value_type>(cl2->identifier()));
 
        int overlapFlag = detail::computeOverlapSpFlag(
            m_stripIdHelper->eta_module(atlasIdCl1),
            m_stripIdHelper->phi_module(atlasIdCl1),
            m_stripIdHelper->eta_module(atlasIdCl2),
            m_stripIdHelper->phi_module(atlasIdCl2));
 
        if (overlapFlag == 2 || overlapFlag == 3) {
          ++skipped;
          ACTS_VERBOSE("Skip phi overlap spacepoint (flag=" << overlapFlag
                                                            << ")");
          continue;
        }
      }
 
      Identifier waferIdCl1 =
          cl1->type() == xAOD::UncalibMeasType::PixelClusterType
              ? m_pixelIdHelper->wafer_id(atlasIdCl1)
              : m_stripIdHelper->wafer_id(atlasIdCl1);
      moduleIds.push_back(waferIdCl1.get_compact());
      allSPPtrs.push_back(sp);
    }
  }
 
  ACTS_DEBUG("Skipped " << skipped << " SPs because of phi overlap");
  nSP = allSPPtrs.size();
  ACTS_DEBUG("Keep " << nSP << " SPs for feature creation");
 
  std::vector<std::size_t> idxs(nSP);
  std::iota(idxs.begin(), idxs.end(), 0);
  std::ranges::sort(
      idxs, [&](auto a, auto b) { return moduleIds.at(a) < moduleIds.at(b); });
  std::ranges::sort(moduleIds);
 
  features.assign(nFeatures * nSP, 0.f);
  ids.resize(nSP);
 
  for (std::size_t k = 0; k < nSP; ++k) {
    ids.at(k) = static_cast<int>(k);
    auto i = idxs.at(k);
 
    std::span<float> f(features.data() + k * nFeatures, nFeatures);
    const auto& sp = *allSPPtrs.at(i);
 
    using namespace Acts::VectorHelpers;
 
    Acts::Vector3 spp{sp.x(), sp.y(), sp.z()};
 
    if (sp.measurements().size() == 1) {
      for (std::size_t j = 0; j < nFeatures; j += 4) {
        f[j + 0] = perp(spp) / 1000.f;
        f[j + 1] = phi(spp) / std::numbers::pi_v<float>;
        f[j + 2] = sp.z() / 1000.f;
        f[j + 3] = eta(spp);
      }
    } else {
      std::size_t j = 0;
      f[j + 0] = perp(spp) / 1000.f;
      f[j + 1] = phi(spp) / std::numbers::pi_v<float>;
      f[j + 2] = sp.z() / 1000.f;
      f[j + 3] = eta(spp);
 
      for (const auto* m : sp.measurements()) {
        const auto* cl = static_cast<const xAOD::StripCluster*>(m);
        auto gp = cl->globalPosition();
        j += 4;
        f[j + 0] = perp(gp) / 1000.f;
        f[j + 1] = phi(gp) / std::numbers::pi_v<float>;
        f[j + 2] = gp.z() / 1000.f;
        f[j + 3] = eta(gp);
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

buildSeed()

StatusCode ActsTrk::GnnPipelineTool::buildSeed ( const std::vector< const xAOD::SpacePointContainer * > & spacePointCollections, ActsTrk::SeedContainer & seeds ) const

override

Definition at line 174 of file GnnPipelineTool.cxx.

                                   {
  return StatusCode::FAILURE;
}

initialize()

StatusCode ActsTrk::GnnPipelineTool::initialize ( )

override

Definition at line 168 of file GnnPipelineTool.cxx.

                                       {
  m_logger = makeActsAthenaLogger(this, "ActsGnn");
  ACTS_ERROR("Cannot initialize ActsGnn without the Acts GNN plugin");
  return StatusCode::FAILURE;
}

logger()

const Acts::Logger & ActsTrk::GnnPipelineTool::logger ( ) const

inlineprivate

Definition at line 66 of file GnnPipelineTool.h.

{ return *m_logger; }

Member Data Documentation

ATLAS_THREAD_SAFE

std::optional<std::counting_semaphore<> > m_gpuInstanceCount ActsTrk::GnnPipelineTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 84 of file GnnPipelineTool.h.

{};

m_chronoSvc

ServiceHandle<IChronoStatSvc> ActsTrk::GnnPipelineTool::m_chronoSvc {"ChronoStatSvc", name()}

private

Definition at line 69 of file GnnPipelineTool.h.

{"ChronoStatSvc", name()};

m_cudaDeviceIndex

Gaudi::Property<int> ActsTrk::GnnPipelineTool::m_cudaDeviceIndex

private

Initial value:

{this, "cudaDeviceIndex", 0,
                                         "CUDA device index for GNN inference"}

Definition at line 63 of file GnnPipelineTool.h.

                                      {this, "cudaDeviceIndex", 0,
                                         "CUDA device index for GNN inference"};

m_edgeCut

Gaudi::Property<double> ActsTrk::GnnPipelineTool::m_edgeCut

private

Initial value:

{this, "edgeCut", 0.5,
                                    "Edge cut to apply after the GNN"}

Definition at line 58 of file GnnPipelineTool.h.

                                 {this, "edgeCut", 0.5,
                                    "Edge cut to apply after the GNN"};

m_gnnPath

Gaudi::Property<std::string> ActsTrk::GnnPipelineTool::m_gnnPath

private

Initial value:

{this, "gnnPath", "",
                                         "Path to the gnn file"}

Definition at line 48 of file GnnPipelineTool.h.

                                    {this, "gnnPath", "",
                                         "Path to the gnn file"};

m_gnnPipeline

std::unique_ptr<ActsPlugins::GnnPipeline> ActsTrk::GnnPipelineTool::m_gnnPipeline

private

Definition at line 82 of file GnnPipelineTool.h.

m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::GnnPipelineTool::m_logger

private

Definition at line 67 of file GnnPipelineTool.h.

m_maxGpuInstances

Gaudi::Property<unsigned int> ActsTrk::GnnPipelineTool::m_maxGpuInstances

private

Initial value:

{
      this, "maxGpuInstances", 1,
      "Number of events that can be on GPU in parallel"}

Definition at line 53 of file GnnPipelineTool.h.

                                               {
      this, "maxGpuInstances", 1,
      "Number of events that can be on GPU in parallel"};

m_minCandidateMeasurements

Gaudi::Property<unsigned int> ActsTrk::GnnPipelineTool::m_minCandidateMeasurements

private

Initial value:

{
      this, "minCandidateMeasurements", 7,
      "Minimum number of spacepoints to cut for in the GNN candidates"}

Definition at line 60 of file GnnPipelineTool.h.

                                                        {
      this, "minCandidateMeasurements", 7,
      "Minimum number of spacepoints to cut for in the GNN candidates"};

m_moduleMapPath

Gaudi::Property<std::string> ActsTrk::GnnPipelineTool::m_moduleMapPath

private

Initial value:

{this, "moduleMapPath", "",
                                               "Path to the module map files"}

Definition at line 46 of file GnnPipelineTool.h.

                                          {this, "moduleMapPath", "",
                                               "Path to the module map files"};

m_numTrtContexts

Gaudi::Property<unsigned int> ActsTrk::GnnPipelineTool::m_numTrtContexts

private

Initial value:

{
      this, "numTrtContexts", 1, "Number of TensorRT contexts to allocate"}

Definition at line 56 of file GnnPipelineTool.h.

                                              {
      this, "numTrtContexts", 1, "Number of TensorRT contexts to allocate"};

m_pixelIdHelper

const PixelID* ActsTrk::GnnPipelineTool::m_pixelIdHelper {nullptr}

private

Definition at line 71 of file GnnPipelineTool.h.

{nullptr};

m_stripIdHelper

const SCT_ID* ActsTrk::GnnPipelineTool::m_stripIdHelper {nullptr}

private

Definition at line 72 of file GnnPipelineTool.h.

{nullptr};

m_usePhiOverlapSps

Gaudi::Property<bool> ActsTrk::GnnPipelineTool::m_usePhiOverlapSps

private

Initial value:

{
      this, "usePhiOverlapSps", false,
      "Whether to use phi overlap spacepoints"}

Definition at line 50 of file GnnPipelineTool.h.

                                        {
      this, "usePhiOverlapSps", false,
      "Whether to use phi overlap spacepoints"};

---

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

• GnnPipelineTool.h
• GnnFeatures.h
• GnnPipelineTool.cxx