ActsTrk::TracccMeasurementDeviceConverterAlg Class Reference

Algorithm converting traccc measurements (device buffer) to xAOD clusters (host container). More...

#include <TracccMeasurementDeviceConverterAlg.h>

Inheritance diagram for ActsTrk::TracccMeasurementDeviceConverterAlg:

Collaboration diagram for ActsTrk::TracccMeasurementDeviceConverterAlg:

Public Member Functions
virtual StatusCode	initialize () override
	Function initializing the algorithm.
virtual StatusCode	execute (const EventContext &ctx) const override
	Function executing the algorithm.
virtual StatusCode	finalize () override
	Function finalizing the algorthm.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
The input device traccc measurement collection name
SG::ReadHandleKey< traccc::edm::measurement_collection::buffer >	m_inputMeasKey
The output host resident cluster collection names
{@
SG::WriteHandleKey< xAOD::PixelClusterContainer >	m_outputPixelKey
SG::WriteHandleKey< xAOD::StripClusterContainer >	m_outputStripKey
The host memory resource tool to use for memory allocations
ToolHandle< AthDevice::IMemoryResourcesTool >	m_mrTool
The copy tool used for copying data from device
ToolHandle< AthDevice::ICopiesTool >	m_copiesTool
Tool that provides CUDA streams
ToolHandle< AthCUDA::IStreamTool >	m_streamTool
Name of the detector object on device
Gaudi::Property< std::string >	m_deviceDetectorName
SG::ReadCondHandleKey< traccc::detector_conditions_description::buffer >	m_deviceCondKey
const traccc::detector_buffer *	m_detector {nullptr}
std::atomic< int >	m_nPix = 0
	The object counters for debug prints in finalize method {.
std::atomic< int >	m_nStrip = 0
std::atomic< int >	m_nMeas = 0

Detailed Description

Algorithm converting traccc measurements (device buffer) to xAOD clusters (host container).

This algorithm converts the Traccc measurements into dedicated data format on device. The converted data is then transferred to host and used to create the corresponding xAOD cluster objects. The data format is designed to match the memory layout of the xAOD cluster containers so that the on-host "conversion" is only a few memory copy operations.

Author

Fabrice Le Goff flego.nosp@m.ff@c.nosp@m.ern.c.nosp@m.h

Definition at line 60 of file TracccMeasurementDeviceConverterAlg.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode ActsTrk::TracccMeasurementDeviceConverterAlg::execute ( const EventContext & ctx ) const

overridevirtual

Function executing the algorithm.

Definition at line 49 of file TracccMeasurementDeviceConverterAlg.cxx.

{
  SG::ReadCondHandle<traccc::detector_conditions_description::buffer>
    detector_conditions_handle{m_deviceCondKey, ctx};
  ATH_CHECK(detector_conditions_handle.isValid());
  if ((*detector_conditions_handle) == nullptr) {
    ATH_MSG_ERROR("null detector conditions");
    return StatusCode::FAILURE;
  }
  auto const & detector_conditions = **detector_conditions_handle;
 
  // ---- Create (empty) output objects
 
  // Create non-owning SG containers
  auto pixel_cont = std::make_unique<xAOD::PixelClusterContainer>(
      SG::VIEW_ELEMENTS, SG::ALWAYS_TRACK_INDICES);
  auto strip_cont = std::make_unique<xAOD::StripClusterContainer>(
      SG::VIEW_ELEMENTS, SG::ALWAYS_TRACK_INDICES);
 
  // Create Aux containers
  auto pixel_aux = std::make_unique<xAOD::PixelClusterAuxContainer>();
  auto strip_aux = std::make_unique<xAOD::StripClusterAuxContainer>();
 
  // Associate the Aux container to the containers
  pixel_cont->setStore(pixel_aux.get());
  strip_cont->setStore(strip_aux.get());
 
  // ---- Read input
  auto device_copy = m_copiesTool->deviceCopy(ctx);
  cudaStream_t cuda_stream = static_cast<cudaStream_t>(m_streamTool->stream(ctx));
  auto traccc_measurements = SG::makeHandle(m_inputMeasKey, ctx);
  ATH_CHECK(traccc_measurements.isValid());
  traccc::edm::measurement_collection::const_view::size_type const n_meas =
    device_copy->get_size(*traccc_measurements);
 
  // ---- Nothing to convert
  if (n_meas == 0) {
    // We still need to register empty containers in SG
    SG::WriteHandle<xAOD::PixelClusterContainer> pixelHandle{m_outputPixelKey, ctx};
    ATH_CHECK(pixelHandle.record(std::move(pixel_cont), std::move(pixel_aux)));
 
    SG::WriteHandle<xAOD::StripClusterContainer> stripHandle{m_outputStripKey, ctx};
    ATH_CHECK(stripHandle.record(std::move(strip_cont), std::move(strip_aux)));
 
    ATH_MSG_DEBUG("Converted 0 pixel clusters, 0 strip clusters");
    return StatusCode::SUCCESS;
  }
 
  // ---- Create output buffers
  // They are allocated during the conversion when we know how many pixels and strips there are
  std::unique_ptr<DevicePixelMeasurementContainer::buffer> converted_pixel_meas_device_buffer{nullptr};
  std::unique_ptr<DeviceStripMeasurementContainer::buffer> converted_strip_meas_device_buffer{nullptr};
 
  // ---- Conversion on GPU
  DevicePixelMeasurementContainer::view::size_type n_pixels = 0;
  DeviceStripMeasurementContainer::view::size_type n_strips = 0;
  ATH_CHECK(convertMeasurementsOnGPU(cuda_stream, m_mrTool->mainMR(), *device_copy,
    m_detector->as_view<traccc::itk_detector>(), detector_conditions,
    n_meas, *traccc_measurements, n_pixels, n_strips,
    converted_pixel_meas_device_buffer, converted_strip_meas_device_buffer));
  if (!converted_pixel_meas_device_buffer or !converted_strip_meas_device_buffer)[[unlikely]]{
    ATH_MSG_ERROR("nullptr detected");
    return StatusCode::FAILURE;
  }
  // Create const device objects to access the field vectors directly
  DevicePixelMeasurementContainer::device pixel_meas_device{*converted_pixel_meas_device_buffer};
  DeviceStripMeasurementContainer::device strip_meas_device{*converted_strip_meas_device_buffer};
 
  // ---- Feed output SG containers
 
  // Create data pools
  DataPool<xAOD::PixelCluster> pixel_pool(ctx, n_pixels);
  DataPool<xAOD::StripCluster> strip_pool(ctx, n_strips);
 
  // Reserve space and set element pointers in SG containers
  pixel_cont->push_new(n_pixels, [&pixel_pool]() {
    return pixel_pool.nextElementPtr(); });
  strip_cont->push_new(n_strips, [&strip_pool]() {
    return strip_pool.nextElementPtr(); });
 
  // ---- Copy data from vecmem containers on device directly to SG containers
  { // Pixels
    auto span_id = s_acc_id.getDataSpan(*pixel_cont);
    auto span_id_hash = s_acc_id_hash.getDataSpan(*pixel_cont);
    auto span_local_pos = s_acc_loc_pos_xy.getDataSpan(*pixel_cont);
    auto span_local_cov = s_acc_loc_cov_xy.getDataSpan(*pixel_cont);
    auto span_global_pos = s_acc_global_pos.getDataSpan(*pixel_cont);
    (*device_copy)(
      vecmem::data::vector_view<unsigned long>(n_pixels, pixel_meas_device.identifier().data()),
      vecmem::data::vector_view<unsigned long>(n_pixels, span_id.data())
      )->ignore();
    (*device_copy)(
      vecmem::data::vector_view<std::array<float, 2>>(n_pixels, pixel_meas_device.local_position().data()),
      vecmem::data::vector_view<std::array<float, 2>>(n_pixels, span_local_pos.data())
      )->ignore();
    (*device_copy)(
      vecmem::data::vector_view<std::array<float, 4>>(n_pixels, pixel_meas_device.local_variance().data()),
      vecmem::data::vector_view<std::array<float, 4>>(n_pixels, span_local_cov.data())
      )->ignore();
    (*device_copy)(
      vecmem::data::vector_view<xAOD::ArrayFloat3>(n_pixels,
        reinterpret_cast<xAOD::ArrayFloat3*>(pixel_meas_device.global_position().data())),
      vecmem::data::vector_view<xAOD::ArrayFloat3>(n_pixels, span_global_pos.data())
      )->ignore();
    (*device_copy)(
      vecmem::data::vector_view<unsigned int>(n_pixels, pixel_meas_device.module_id_hash().data()),
      vecmem::data::vector_view<unsigned int>(n_pixels, span_id_hash.data())
      )->wait();
  }
  {  // Strips
    auto span_id = s_acc_id.getDataSpan(*strip_cont);
    auto span_id_hash = s_acc_id_hash.getDataSpan(*strip_cont);
    auto span_local_pos = s_acc_loc_pos_x.getDataSpan(*strip_cont);
    auto span_local_cov = s_acc_loc_cov_x.getDataSpan(*strip_cont);
    CUDA_ERROR_CHECK(cudaMemcpy(span_id.data(), strip_meas_device.identifier().data(),
      sizeof(unsigned long) * n_strips, cudaMemcpyDeviceToHost));
    CUDA_ERROR_CHECK(cudaMemcpy(span_local_pos.data(), strip_meas_device.local_position().data(),
      sizeof(float) * n_strips, cudaMemcpyDeviceToHost));
    CUDA_ERROR_CHECK(cudaMemcpy(span_local_cov.data(), strip_meas_device.local_variance().data(),
      sizeof(float) * n_strips, cudaMemcpyDeviceToHost));
    CUDA_ERROR_CHECK(cudaMemcpy(span_id_hash.data(), strip_meas_device.module_id_hash().data(),
      sizeof(unsigned int) * n_strips, cudaMemcpyDeviceToHost));
  }
 
  // ---- Register to SG
  SG::WriteHandle<xAOD::PixelClusterContainer> pixelHandle{m_outputPixelKey, ctx};
  ATH_CHECK(pixelHandle.record(std::move(pixel_cont), std::move(pixel_aux)));
 
  SG::WriteHandle<xAOD::StripClusterContainer> stripHandle{m_outputStripKey, ctx};
  ATH_CHECK(stripHandle.record(std::move(strip_cont), std::move(strip_aux)));
 
  // ---- Et voilà
  ATH_MSG_DEBUG("Converted " << n_pixels << " pixel clusters, "
    << n_strips  << " strip clusters");
 
  m_nMeas += n_pixels + n_strips;
  m_nPix  += n_pixels;
  m_nStrip += n_strips;
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode ActsTrk::TracccMeasurementDeviceConverterAlg::finalize ( )

overridevirtual

Function finalizing the algorthm.

Definition at line 191 of file TracccMeasurementDeviceConverterAlg.cxx.

{
  ATH_MSG_DEBUG("Finalizing.");
 
  ATH_MSG_DEBUG("Received total number of measurements = " << m_nMeas
                  << ", of which pixel clusters = " << m_nPix
                  << " and strip clusters = " << m_nStrip);
 
  ATH_MSG_DEBUG("Successfully finalized");
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ActsTrk::TracccMeasurementDeviceConverterAlg::initialize ( )

overridevirtual

Function initializing the algorithm.

Definition at line 32 of file TracccMeasurementDeviceConverterAlg.cxx.

{
  ATH_CHECK(m_mrTool.retrieve());
  ATH_CHECK(m_copiesTool.retrieve());
  ATH_CHECK(m_streamTool.retrieve());
 
  ATH_CHECK(m_inputMeasKey.initialize());
  ATH_CHECK(m_outputPixelKey.initialize());
  ATH_CHECK(m_outputStripKey.initialize());
  ATH_CHECK(m_deviceCondKey.initialize());
 
  ATH_CHECK(detStore()->retrieve(m_detector, m_deviceDetectorName.value()));
 
  ATH_MSG_DEBUG("Successfully initialized");
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_copiesTool

ToolHandle<AthDevice::ICopiesTool> ActsTrk::TracccMeasurementDeviceConverterAlg::m_copiesTool

private

Initial value:

{
    this, "CopiesProviderTool", "", "Tool that provides vecmem copy objects"}

Definition at line 93 of file TracccMeasurementDeviceConverterAlg.h.

                                               {
    this, "CopiesProviderTool", "", "Tool that provides vecmem copy objects"};

m_detector

const traccc::detector_buffer* ActsTrk::TracccMeasurementDeviceConverterAlg::m_detector {nullptr}

private

Definition at line 106 of file TracccMeasurementDeviceConverterAlg.h.

{nullptr};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_deviceCondKey

SG::ReadCondHandleKey<traccc::detector_conditions_description::buffer> ActsTrk::TracccMeasurementDeviceConverterAlg::m_deviceCondKey

private

Initial value:

{
      this, "DeviceConditionsObjectName", "",
      "Key for reading the per-IOV traccc device conditions object"}

Definition at line 102 of file TracccMeasurementDeviceConverterAlg.h.

                                                                                  {
      this, "DeviceConditionsObjectName", "",
      "Key for reading the per-IOV traccc device conditions object"};

m_deviceDetectorName

Gaudi::Property<std::string> ActsTrk::TracccMeasurementDeviceConverterAlg::m_deviceDetectorName

private

Initial value:

{
    this, "DeviceDetectorName", "",
    "Detray device detector object"}

Definition at line 99 of file TracccMeasurementDeviceConverterAlg.h.

                                               {
    this, "DeviceDetectorName", "",
    "Detray device detector object"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_inputMeasKey

SG::ReadHandleKey<traccc::edm::measurement_collection::buffer> ActsTrk::TracccMeasurementDeviceConverterAlg::m_inputMeasKey

private

Initial value:

{
      this, "InputMeasurements", "TracccMeasurements",
      "Input traccc measurement collection buffer"}

Definition at line 75 of file TracccMeasurementDeviceConverterAlg.h.

                                                                       {
      this, "InputMeasurements", "TracccMeasurements",
      "Input traccc measurement collection buffer"};

m_mrTool

ToolHandle<AthDevice::IMemoryResourcesTool> ActsTrk::TracccMeasurementDeviceConverterAlg::m_mrTool

private

Initial value:

{
    this, "MemoryResourcesTool", "", "Tool that provides memory resources"}

Definition at line 90 of file TracccMeasurementDeviceConverterAlg.h.

                                                    {
    this, "MemoryResourcesTool", "", "Tool that provides memory resources"};

m_nMeas

std::atomic<int> ActsTrk::TracccMeasurementDeviceConverterAlg::m_nMeas = 0

mutableprivate

Definition at line 112 of file TracccMeasurementDeviceConverterAlg.h.

m_nPix

std::atomic<int> ActsTrk::TracccMeasurementDeviceConverterAlg::m_nPix = 0

mutableprivate

The object counters for debug prints in finalize method {.

Definition at line 110 of file TracccMeasurementDeviceConverterAlg.h.

m_nStrip

std::atomic<int> ActsTrk::TracccMeasurementDeviceConverterAlg::m_nStrip = 0

mutableprivate

Definition at line 111 of file TracccMeasurementDeviceConverterAlg.h.

m_outputPixelKey

SG::WriteHandleKey<xAOD::PixelClusterContainer> ActsTrk::TracccMeasurementDeviceConverterAlg::m_outputPixelKey

private

Initial value:

{
      this, "OutputPixelClusters", "ITkTracccPixelClusters",
      "Output xAOD pixel cluster container"}

Definition at line 81 of file TracccMeasurementDeviceConverterAlg.h.

                                                              {
      this, "OutputPixelClusters", "ITkTracccPixelClusters",
      "Output xAOD pixel cluster container"};

m_outputStripKey

SG::WriteHandleKey<xAOD::StripClusterContainer> ActsTrk::TracccMeasurementDeviceConverterAlg::m_outputStripKey

private

Initial value:

{
      this, "OutputStripClusters", "ITkTracccStripClusters",
      "Output xAOD strip cluster container"}

Definition at line 84 of file TracccMeasurementDeviceConverterAlg.h.

                                                              {
      this, "OutputStripClusters", "ITkTracccStripClusters",
      "Output xAOD strip cluster container"};

m_streamTool

ToolHandle<AthCUDA::IStreamTool> ActsTrk::TracccMeasurementDeviceConverterAlg::m_streamTool

private

Initial value:

{
    this, "StreamTool", "", "Tool that provides CUDA streams"}

Definition at line 96 of file TracccMeasurementDeviceConverterAlg.h.

                                             {
    this, "StreamTool", "", "Tool that provides CUDA streams"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

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

• TracccMeasurementDeviceConverterAlg.h
• TracccMeasurementDeviceConverterAlg.cxx