TracccMeasurementDeviceConverterAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ACTSGPUEVENT_TRACCCMEASUREMENTDEVICECONVERTERALG_H
#define ACTSGPUEVENT_TRACCCMEASUREMENTDEVICECONVERTERALG_H
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
#include "AthCUDAInterfaces/IStreamTool.h"
#include "AthDeviceInterfaces/IMemoryResourcesTool.h"
#include "AthDeviceInterfaces/ICopiesTool.h"
#include "xAODInDetMeasurement/PixelClusterContainer.h"
#include "xAODInDetMeasurement/StripClusterContainer.h"
#include "GaudiKernel/ToolHandle.h"
#include "ActsGPUEvent/TracccDetectorConditionsDescription.h"
#include "ActsGPUEvent/TracccDetectorGeometryDescription.h"
#include "ActsGPUEvent/TracccMeasurementCollection.h"
#include "src/DeviceMeasurementContainers.h"
 
#include <traccc/edm/measurement_collection.hpp>
#include <traccc/geometry/detector.hpp>
#include <vecmem/memory/memory_resource.hpp>
#include <traccc/geometry/detector_conditions_description.hpp>
#include <traccc/geometry/detector_buffer.hpp>
 
#include <cuda_runtime_api.h>

#define CUDA_ERROR_CHECK(EXP)                                      \
  do {                                                             \
    cudaError_t errorCode = EXP;                                   \
    if (errorCode != cudaSuccess) {                                \
      errorcheck::ReportMessage(MSG::ERROR, ERRORCHECK_ARGS,       \
        __PRETTY_FUNCTION__,                                       \
        StatusCode::FAILURE)                                       \
              .msgstream()                                         \
          << "Failed to execute: " << #EXP << " ("                 \
          << cudaGetErrorString(errorCode) << ")";                 \
      return StatusCode::FAILURE;                                  \
    }                                                              \
  } while (false)
 
namespace ActsTrk {

class TracccMeasurementDeviceConverterAlg : public AthReentrantAlgorithm
{
public:
  using AthReentrantAlgorithm::AthReentrantAlgorithm;

  virtual StatusCode initialize() override;
  virtual StatusCode execute(const EventContext& ctx) const override;
  virtual StatusCode finalize() override;
 
private:

  SG::ReadHandleKey<traccc::edm::measurement_collection::buffer> m_inputMeasKey{
      this, "InputMeasurements", "TracccMeasurements",
      "Input traccc measurement collection buffer"};

  SG::WriteHandleKey<xAOD::PixelClusterContainer> m_outputPixelKey{
      this, "OutputPixelClusters", "ITkTracccPixelClusters",
      "Output xAOD pixel cluster container"};
  SG::WriteHandleKey<xAOD::StripClusterContainer> m_outputStripKey{
      this, "OutputStripClusters", "ITkTracccStripClusters",
      "Output xAOD strip cluster container"};


  ToolHandle<AthDevice::IMemoryResourcesTool> m_mrTool{
    this, "MemoryResourcesTool", "", "Tool that provides memory resources"};

  ToolHandle<AthDevice::ICopiesTool> m_copiesTool{
    this, "CopiesProviderTool", "", "Tool that provides vecmem copy objects"};

  ToolHandle<AthCUDA::IStreamTool> m_streamTool{
    this, "StreamTool", "", "Tool that provides CUDA streams"};

  Gaudi::Property<std::string> m_deviceDetectorName{
    this, "DeviceDetectorName", "",
    "Detray device detector object"};
  SG::ReadCondHandleKey<traccc::detector_conditions_description::buffer> m_deviceCondKey{
      this, "DeviceConditionsObjectName", "",
      "Key for reading the per-IOV traccc device conditions object"};
 
  const traccc::detector_buffer* m_detector{nullptr};

  mutable std::atomic<int> m_nPix = 0;
  mutable std::atomic<int> m_nStrip = 0;
  mutable std::atomic<int> m_nMeas = 0;
};
 
// Converts the "input" traccc measurements into the output GPU buffer,
// output_pixel_meas and output_strip_meas.
//
// The provided output buffers are allocated during this function and their
// respective sizes are returned in output_n_pixels and output_n_strips.
//
// If nb_measurements is 0 this function returns immediately, no allocation
// takes place and no output counter is set.
//
// The input measurement container contains both Pixels and Strips measurements
// that need to be separated. Internally this functions counts each type and
// then allocate the output buffers, and finally converts the input measurements
// in place in the output buffers.
StatusCode convertMeasurementsOnGPU(
    cudaStream_t stream
  , vecmem::memory_resource & mr
  , vecmem::copy const & copy
  , traccc::itk_detector::view_type const & detector_view
  , traccc::detector_conditions_description::const_view const & detector_conditions_view
  , traccc::edm::measurement_collection::const_view::size_type nb_measurements
  , const traccc::edm::measurement_collection::const_view & input
  , DevicePixelMeasurementContainer::view::size_type & output_n_pixels
  , DeviceStripMeasurementContainer::view::size_type & output_n_strips
  , std::unique_ptr<DevicePixelMeasurementContainer::buffer> & output_pixel_meas
  , std::unique_ptr<DeviceStripMeasurementContainer::buffer> & output_strip_meas
  );
 
 
} // namespace ActsTrk
 
#endif // ACTSGPUEVENT_TRACCCMEASUREMENTDEVICECONVERTERALG_H