TritonTracccTrackMaker Class Reference

TritonTracccTrackMaker is an algorithm that uses the Traccc-algorithm to reconstruct tracks from cells. More...

#include <TritonTracccTrackMaker.h>

Inheritance diagram for TritonTracccTrackMaker:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
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
StatusCode	serializeCells (const traccc::edm::silicon_cell_collection::const_device &cells, std::vector< uint8_t > &out) const
std::unordered_map< int64_t, int >	readAndConvertClusters (const EventContext &eventContext) const
StatusCode	convertInDetToXaodCluster (const InDet::PixelCluster &indetCluster, const InDetDD::SiDetectorElement &element, xAOD::PixelCluster &xaodCluster) const
StatusCode	convertInDetToXaodCluster (const InDet::SCT_Cluster &indetCluster, const InDetDD::SiDetectorElement &element, xAOD::StripCluster &xaodCluster) const
const Acts::Surface *	actsSurfaceFromAtlasId (const Identifier &atlasID) const
Acts::BoundMatrix	buildBoundCovariance (const LocalMeasurementInfoInTracks &state) const
std::optional< Acts::BoundTrackParameters >	convertToActsParameters (const LocalMeasurementInfoInTracks &state) const
StatusCode	convertTracks (EventContext const &eventContext, std::vector< TracccTrackParameters > &trackParams, std::vector< LocalMeasurementInfoInTracks > &measInfo, const std::unordered_map< int64_t, int > &cluster_map, unsigned &nb_output_tracks) const
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.

Protected Attributes
SG::ReadHandleKey< traccc::edm::silicon_cell_collection::const_view >	m_tracccCellsKey
const PixelID *	m_pixelID {nullptr}
const SCT_ID *	m_stripID {nullptr}
SG::WriteHandleKey< ActsTrk::TrackContainer >	m_ActsTracccTrackContainerKey
ActsTrk::MutableTrackContainerHandlesHelper	m_tracksBackendHandlesHelper
Trk::PdgToParticleHypothesis	m_pdgToParticleHypothesis
std::shared_ptr< const Acts::TrackingGeometry >	m_trackingGeometry
const ActsTrk::DetectorElementToActsGeometryIdMap *	m_detEleToGeoIdMap {nullptr}
ToolHandle< ITracccTritonTool >	m_tracccTrackingTool
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc
ActsTrk::ContextUtility	m_ctxProvider {this}
	Utility to fetch the geometry, magnetic field and calibration context in the event.
StringProperty	m_featureNames
std::vector< std::string >	m_featureNamesVec
Gaudi::Property< bool >	m_doTruth
	Truth association for plotting and debugging.
SG::ReadHandleKey< ActsTrk::MeasurementToTruthParticleAssociation >	m_pixelClustersToTruth
SG::ReadHandleKey< ActsTrk::MeasurementToTruthParticleAssociation >	m_stripClustersToTruth
SG::ReadHandleKey< InDet::PixelClusterContainer >	m_inputPixelClusterContainerKey
SG::ReadHandleKey< InDet::SCT_ClusterContainer >	m_inputStripClusterContainerKey
SG::WriteHandleKey< xAOD::PixelClusterContainer >	m_xAODPixelClusterFromInDetClusterKey
SG::WriteHandleKey< xAOD::StripClusterContainer >	m_xAODStripClusterFromInDetClusterKey
SG::WriteHandleKey< xAOD::SpacePointContainer >	m_xAODSpacepointFromInDetClusterKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_pixelDetEleCollKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_stripDetEleCollKey

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

Detailed Description

TritonTracccTrackMaker is an algorithm that uses the Traccc-algorithm to reconstruct tracks from cells.

Cells are sent to a Traccc backend using Triton and tracks are sent back.

Author

miles.nosp@m..cb@.nosp@m.cern..nosp@m.ch

Definition at line 67 of file TritonTracccTrackMaker.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

actsSurfaceFromAtlasId()

const Acts::Surface * TritonTracccTrackMaker::actsSurfaceFromAtlasId ( const Identifier & atlasID ) const

protected

Definition at line 422 of file TritonTracccTrackMaker.cxx.

{
    const bool isPixel = m_pixelID->is_pixel(atlasID);
    const IdentifierHash hash = isPixel ? m_pixelID->wafer_hash(atlasID)
                                        : m_stripID->wafer_hash(atlasID);
    const auto measType = isPixel ? xAOD::UncalibMeasType::PixelClusterType
                                  : xAOD::UncalibMeasType::StripClusterType;
 
    const auto geoKey = ActsTrk::makeDetectorElementKey(
        measType, static_cast<unsigned int>(hash));
    const auto it = m_detEleToGeoIdMap->find(geoKey);
    if (it != m_detEleToGeoIdMap->end()) {
        const Acts::Surface* surface = m_trackingGeometry->findSurface(
            ActsTrk::DetectorElementToActsGeometryIdMap::getValue(*it));
        if (surface) {
            return surface;
        }
    }
    ATH_MSG_DEBUG("No Acts surface corresponding to this ATLAS id: " << atlasID);
    return nullptr;
}

buildBoundCovariance()

Acts::BoundMatrix TritonTracccTrackMaker::buildBoundCovariance ( const LocalMeasurementInfoInTracks & state ) const

protected

Definition at line 445 of file TritonTracccTrackMaker.cxx.

{
    // traccc's model output is in Acts-native units
    Acts::BoundMatrix cov = Acts::BoundMatrix::Zero();
    for (unsigned int i = 0; i < 5; i++) {
        for (unsigned int j = 0; j < 5; j++) {
            size_t index = i * 5 + j;
            cov(i, j) = state.covariances[index];
        }
    }
 
    // traccc does not fit the time parameter (yet). Give it a
    // large placeholder uncertainty instead of leaving it at zero.
    constexpr double kUnconstrainedTimeVariance = 1e6;
    cov(Acts::eBoundTime, Acts::eBoundTime) = kUnconstrainedTimeVariance;
 
    return cov;
}

convertInDetToXaodCluster() [1/2]

StatusCode TritonTracccTrackMaker::convertInDetToXaodCluster ( const InDet::PixelCluster & indetCluster, const InDetDD::SiDetectorElement & element, xAOD::PixelCluster & xaodCluster ) const

protected

Definition at line 336 of file TritonTracccTrackMaker.cxx.

{
    IdentifierHash idHash = element.identifyHash();
 
    auto localPos = indetCluster.localPosition();
    auto localCov = indetCluster.localCovariance();
 
    xAOD::MeasVector<2> localPosition = xAOD::toStorage(localPos);
 
    xAOD::MeasMatrix<2> localCovariance;
    localCovariance.setZero();
    localCovariance(0, 0) = localCov(0, 0);
    localCovariance(1, 1) = localCov(1, 1);
 
    auto globalPos = indetCluster.globalPosition();
    Eigen::Matrix<float, 3, 1> globalPosition(globalPos.x(), globalPos.y(),
                                              globalPos.z());
 
    const auto& RDOs = indetCluster.rdoList();
    const auto& ToTs = indetCluster.totList();
    const auto& charges = indetCluster.chargeList();
    const auto& width = indetCluster.width();
    //coverity[UNINIT]
    xaodCluster.setMeasurement<2>(idHash, localPosition, localCovariance);
    xaodCluster.setIdentifier(indetCluster.identify().get_compact());
    xaodCluster.setRDOlist(RDOs);
    xaodCluster.globalPosition() = globalPosition;
    xaodCluster.setToTlist(ToTs);
    xaodCluster.setChargelist(charges);
    xaodCluster.setLVL1A(indetCluster.LVL1A());
    xaodCluster.setChannelsInPhiEta(width.colRow()[0], width.colRow()[1]);
    xaodCluster.setWidthInEta(static_cast<float>(width.widthPhiRZ()[1]));
 
    return StatusCode::SUCCESS;
}

convertInDetToXaodCluster() [2/2]

StatusCode TritonTracccTrackMaker::convertInDetToXaodCluster ( const InDet::SCT_Cluster & indetCluster, const InDetDD::SiDetectorElement & element, xAOD::StripCluster & xaodCluster ) const

protected

Definition at line 374 of file TritonTracccTrackMaker.cxx.

{
    constexpr double one_over_twelve = 1. / 12.;
    IdentifierHash idHash = element.identifyHash();
 
    auto localPos = indetCluster.localPosition();
 
    xAOD::MeasVector<1> localPosition;
    xAOD::MeasMatrix<1> localCovariance;
    localCovariance.setZero();
 
    if (element.isBarrel()) {
        localPosition(0, 0) = localPos.x();
        localCovariance(0, 0) =
            element.phiPitch() * element.phiPitch() * one_over_twelve;
    } else {
        InDetDD::SiCellId cellId = element.cellIdOfPosition(localPos);
        const InDetDD::StripStereoAnnulusDesign* design =
            dynamic_cast<const InDetDD::StripStereoAnnulusDesign*>(
                &element.design());
        if (design == nullptr) {
            return StatusCode::FAILURE;
        }
        InDetDD::SiLocalPosition localInPolar =
            design->localPositionOfCellPC(cellId);
        localPosition(0, 0) = localInPolar.xPhi();
        localCovariance(0, 0) =
            design->phiPitchPhi() * design->phiPitchPhi() * one_over_twelve;
    }
 
    auto globalPos = indetCluster.globalPosition();
    Eigen::Matrix<float, 3, 1> globalPosition(globalPos.x(), globalPos.y(),
                                              globalPos.z());
 
    const auto& RDOs = indetCluster.rdoList();
    const auto& width = indetCluster.width();
    //coverity[UNINIT]
    xaodCluster.setMeasurement<1>(idHash, localPosition, localCovariance);
    xaodCluster.setIdentifier(indetCluster.identify().get_compact());
    xaodCluster.setRDOlist(RDOs);
    xaodCluster.globalPosition() = globalPosition;
    xaodCluster.setChannelsInPhi(width.colRow()[0]);
 
    return StatusCode::SUCCESS;
}

convertToActsParameters()

std::optional< Acts::BoundTrackParameters > TritonTracccTrackMaker::convertToActsParameters ( const LocalMeasurementInfoInTracks & state ) const

protected

Definition at line 466 of file TritonTracccTrackMaker.cxx.

{
    using namespace Acts::UnitLiterals;
    std::shared_ptr<const Acts::Surface> actsSurface;
    Acts::BoundVector params{};
 
    Identifier const atlas_ID(static_cast<Identifier::value_type>(state.athena_id[0]));
 
    // get the associated surface
    const Acts::Surface* surface = actsSurfaceFromAtlasId(atlas_ID);
    if (!surface) {
        return std::nullopt;
    }
    actsSurface = surface->getSharedPtr();
 
    // Construct track parameters
    ATH_MSG_VERBOSE("Constructing track parameters for this state");
    params << state.local_x[0], state.local_y[0],
        state.phi[0], state.theta[0], state.qop[0], state.time[0];
 
    Acts::BoundMatrix const cov = buildBoundCovariance(state);
 
    Acts::ParticleHypothesis hypothesis{Acts::ParticleHypothesis::pion()};
    
    return Acts::BoundTrackParameters(actsSurface, params, cov, hypothesis);
}

convertTracks()

StatusCode TritonTracccTrackMaker::convertTracks ( EventContext const & eventContext, std::vector< TracccTrackParameters > & trackParams, std::vector< LocalMeasurementInfoInTracks > & measInfo, const std::unordered_map< int64_t, int > & cluster_map, unsigned & nb_output_tracks ) const

protected

Definition at line 494 of file TritonTracccTrackMaker.cxx.

{
    nb_output_tracks = 0;
 
    Acts::VectorTrackContainer track_backend;
    Acts::VectorMultiTrajectory track_state_backend;
    ActsTrk::MutableTrackContainer track_container(
        std::move(track_backend), std::move(track_state_backend));
 
    SG::WriteHandle<ActsTrk::TrackContainer> trackContainerHandle(
        m_ActsTracccTrackContainerKey, eventContext);
 
    Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(eventContext);
 
    if (m_doTruth) {
        ATH_MSG_DEBUG("Will map truth");
        ATH_MSG_DEBUG("retrieving cluster container keys: "
                        << m_xAODPixelClusterFromInDetClusterKey.key() << ","
                        << m_xAODStripClusterFromInDetClusterKey.key());
    }
 
    // Debug stats
    float chi2_min = std::numeric_limits<float>::max();
    float chi2_max = std::numeric_limits<float>::min();
 
    float ndf_min = std::numeric_limits<float>::max();
    float ndf_max = std::numeric_limits<float>::min();
 
    unsigned meas_min = std::numeric_limits<unsigned>::max();
    unsigned meas_max = std::numeric_limits<unsigned>::min();
 
    int excluded_ndf = 0;
    int excluded_no_sp = 0;
    int excluded_weird_state = 0;
 
    for (std::size_t i = 0; i < trackParams.size(); i++) {
        auto fit_res = trackParams.at(i);
        auto& states = measInfo.at(i);
        if (states.local_x.size() < 1) {
            excluded_no_sp += 1;
            continue;
        }
 
        // In Acts ndf, aka nDoF, is unsigned int. This makes sure the number is
        // safe to cast; exclude the track otherwise.
        if (fit_res.ndf >
                static_cast<float>(std::numeric_limits<unsigned int>::max()) ||
            fit_res.ndf <
                static_cast<float>(std::numeric_limits<unsigned int>::min())) {
            excluded_ndf += 1;
            continue;
        }
 
        // Create the MutableTrack and add the parameters
        auto actsTrack = track_container.makeTrack();
        enum TrackValidity { VALID, INVALID_STATE, INVALID_GLOBAL };
        TrackValidity track_validity = VALID;
 
 
        actsTrack.chi2() = fit_res.chi2;
        actsTrack.nDoF() = fit_res.ndf;
 
        Acts::TrackStatePropMask const mask =
            Acts::TrackStatePropMask::Smoothed;
 
        bool first_state = true;
        for (size_t j = 0; j < states.local_x.size(); ++j) {
            auto actsTSOS = actsTrack.appendTrackState(mask);
 
            // Build a measurement struct for this state
            LocalMeasurementInfoInTracks singleState;
            singleState.local_x = {states.local_x[j]};
            singleState.local_y = {states.local_y[j]};
            singleState.phi = {states.phi[j]};
            singleState.theta = {states.theta[j]};
            singleState.qop = {states.qop[j]};
            singleState.time = {states.time[j]};
            singleState.covariances = {};
            for (size_t k = 0; k < 25; ++k) {
                singleState.covariances.push_back(states.covariances[j * 25 + k]);
            }
            singleState.athena_id = {states.athena_id[j]};
 
            std::optional<Acts::BoundTrackParameters> params_opt =
                convertToActsParameters(singleState);
            if (!params_opt.has_value()) {
                // if the measurement was "buggy", the whole track is dismissed.
                ATH_MSG_DEBUG(
                    "convertToActsParameters failed: track state is weird");
                track_validity = INVALID_STATE;
                break;
 
            }
 
            Acts::BoundTrackParameters const& parameters = params_opt.value();
            ATH_MSG_DEBUG("Track parameters: " << parameters.parameters());
 
            if (m_doTruth) {
                SG::ReadHandle<xAOD::PixelClusterContainer> pixelClustersHandle(
                    m_xAODPixelClusterFromInDetClusterKey.key(), eventContext);
                ATH_CHECK(pixelClustersHandle.isValid());
                const xAOD::PixelClusterContainer* inputPixelClusters =
                    pixelClustersHandle.cptr();
 
                SG::ReadHandle<xAOD::StripClusterContainer> stripClustersHandle(
                    m_xAODStripClusterFromInDetClusterKey.key(), eventContext);
                ATH_CHECK(stripClustersHandle.isValid());
                const xAOD::StripClusterContainer* inputStripClusters =
                    stripClustersHandle.cptr();
 
                // match measurement to the cluster container
                int cl_index = -1;
                if (auto it = cluster_map.find(states.athena_id[j]);
                    it != cluster_map.end()) {
                    cl_index = it->second;
                } else {
                    return StatusCode::FAILURE;
                }
 
                // Determine detector type from athena_id
                Identifier id(static_cast<Identifier::value_type>(states.athena_id[j]));
                bool isPixel = m_pixelID->is_pixel(id);
 
                const xAOD::UncalibratedMeasurement* umeas = nullptr;
                if (isPixel) {
                    umeas = inputPixelClusters->at(cl_index);
                } else {
                    umeas = inputStripClusters->at(cl_index);
                }
 
                actsTSOS.setUncalibratedSourceLink(
                    ActsTrk::detail::MeasurementCalibratorBase::pack(umeas));
            }
 
            // This is the conversion of global track parameters
            // Because Traccc does not do backpropagation yet,
            // we do not have the reference surface ie the perigee.
            // So for now we will set the global track params with
            // the reference surface being the surface of first measurement
            // and enable back propagation during ACTS->xAOD conversion
            // this will find the pergee and re-set the global trk params.
            if (first_state) {
                // This is the first track state, so we need to set the track
                // global parameters
 
                std::optional<Acts::BoundTrackParameters> params_gl =
                    convertToActsParameters(singleState);
 
                if (!params_gl.has_value()) {
                    // if the params are "buggy", the whole track is dismissed.
                    ATH_MSG_DEBUG(
                        "convertToActsParameters failed: track state is weird");
                    track_validity = INVALID_GLOBAL;
                    break;
                }
 
                Acts::BoundTrackParameters const& parameters_gl =
                    params_gl.value();
 
                ATH_MSG_VERBOSE("First state of track.");
                actsTrack.parameters() = parameters_gl.parameters();
                actsTrack.covariance() = *parameters_gl.covariance();
                actsTrack.setReferenceSurface(
                    parameters_gl.referenceSurface().getSharedPtr());
                first_state = false;
 
            }
            
            actsTSOS.setReferenceSurface(
                parameters.referenceSurface().getSharedPtr());
            actsTSOS.smoothed() = parameters.parameters();
            actsTSOS.smoothedCovariance() = *parameters.covariance();
            // Mark this state as a measurement for temporary efficiency matching
            actsTSOS.typeFlags().setIsMeasurement();
            if (!(actsTSOS.hasSmoothed() &&
                    actsTSOS.hasReferenceSurface())) {
                ATH_MSG_INFO(
                    "TrackState does not have smoothed state ["
                    << actsTSOS.hasSmoothed()
                    << "] or reference surface ["
                    << actsTSOS.hasReferenceSurface() << "].");
            } else {
                ATH_MSG_DEBUG(
                    "TrackState has smoothed state and reference "
                    "surface.");
            }
        }
 
        // ATH_MSG_INFO("Done with states of this track.");
    if (track_validity == INVALID_STATE) {
            ATH_MSG_INFO("excluding track " << i << " for weird state");
            excluded_weird_state += 1;
            track_container.removeTrack(actsTrack.index());
        } else if (track_validity == INVALID_GLOBAL) {
            ATH_MSG_INFO("excluding track " << i
                                             << " for weird global params");
            track_container.removeTrack(actsTrack.index());
        }
 
 
        // Debug stats
        chi2_min = std::min(fit_res.chi2, chi2_min);
        chi2_max = std::max(fit_res.chi2, chi2_max);
        ndf_min = std::min(fit_res.ndf, ndf_min);
        ndf_max = std::max(fit_res.ndf, ndf_max);
        meas_min = std::min<unsigned>(states.local_x.size(), meas_min);
        meas_max = std::max<unsigned>(states.local_x.size(), meas_max);
    }
 
    nb_output_tracks = track_container.size();
    ATH_MSG_DEBUG("Wrote out "<< nb_output_tracks << " tracks from " << trackParams.size() << " candidates"
      << ", excluded:"
      << " no sp: " << excluded_no_sp
      << ", weird sp: " << excluded_weird_state
      << ", ndf: " << excluded_ndf
    );
 
    Acts::ConstVectorTrackContainer ctrack_backend(
        std::move(track_container.container()));
    Acts::ConstVectorMultiTrajectory ctrack_state_backend(
        std::move(track_container.trackStateContainer()));
    std::unique_ptr<ActsTrk::TrackContainer> ctrack_container =
        std::make_unique<ActsTrk::TrackContainer>(
            std::move(ctrack_backend), std::move(ctrack_state_backend));
 
    ATH_CHECK(trackContainerHandle.record(std::move(ctrack_container)));
 
    return StatusCode::SUCCESS;
}

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 TritonTracccTrackMaker::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 72 of file TritonTracccTrackMaker.cxx.

{
 
    // fill cells struct for sending to traccc
    auto cell_start = std::chrono::high_resolution_clock::now();
 
    // Read the cells produced by RDOtoTracccCellConverterAlg.
    auto cells_handle = SG::makeHandle(m_tracccCellsKey, ctx);
    ATH_CHECK(cells_handle.isValid());
 
    traccc::edm::silicon_cell_collection::const_device cells{*cells_handle};
 
    std::vector<uint8_t> cells_buffer;
    ATH_CHECK(serializeCells(cells, cells_buffer));
 
    auto cell_end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> cell_time = cell_end - cell_start;
    ATH_MSG_INFO("Cell reading time: " << cell_time.count() << " ms");  
 
    std::unordered_map<int64_t, int> cluster_map;
    if (m_doTruth)
    {
        cluster_map = readAndConvertClusters(ctx);
    }
 
    // create output containers
    std::vector<TracccTrackParameters> TracccTrackParams;
    std::vector<LocalMeasurementInfoInTracks> TracccMeasurementsInfoInTracks;
 
    // Run the inference 
    auto traccc_start = std::chrono::high_resolution_clock::now();
    ATH_CHECK(m_tracccTrackingTool->getTracks(cells_buffer, TracccTrackParams, TracccMeasurementsInfoInTracks));
    auto traccc_end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> traccc_time = traccc_end - traccc_start;
    ATH_MSG_INFO("Traccc total inference time: " << traccc_time.count() << " ms");
 
    // convert to ACTs tracks
    unsigned int nb_output_tracks = 0;
    auto convert_start = std::chrono::high_resolution_clock::now();
    ATH_CHECK(convertTracks(ctx, TracccTrackParams, TracccMeasurementsInfoInTracks, 
                            cluster_map, nb_output_tracks));
    auto convert_end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> convert_time = convert_end - convert_start;
    ATH_MSG_INFO("Traccc total conversion time: " << convert_time.count() << " ms");
 
    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();
  }

initialize()

StatusCode TritonTracccTrackMaker::initialize ( )

overridevirtual

Definition at line 15 of file TritonTracccTrackMaker.cxx.

{
    // input handles / tools
    ATH_CHECK(detStore()->retrieve(m_pixelID, "PixelID"));
    ATH_CHECK(detStore()->retrieve(m_stripID, "SCT_ID"));
 
    ATH_CHECK(m_tracccCellsKey.initialize());
 
    // output container
    ATH_CHECK(m_ActsTracccTrackContainerKey.initialize());
 
    ATH_CHECK(m_tracksBackendHandlesHelper.initialize(
        ActsTrk::prefixFromTrackContainerName(
            m_ActsTracccTrackContainerKey.key())));
 
    // geometry helper for output
    if (!m_trackingGeometrySvc.empty()) {
        ATH_CHECK(m_trackingGeometrySvc.retrieve());
        m_trackingGeometry = m_trackingGeometrySvc->trackingGeometry();
        if (!m_trackingGeometry) {
            ATH_MSG_DEBUG("Null Acts::TrackingGeometry from tracking geometry service");
            return StatusCode::FAILURE;
        }
 
        m_detEleToGeoIdMap = m_trackingGeometrySvc->surfaceIdMap();
        if (!m_detEleToGeoIdMap) {
            ATH_MSG_DEBUG("Null detector element to Acts geometry ID map from "
                          "tracking geometry service");
            return StatusCode::FAILURE;
        }
    }
 
    // tools
    ATH_CHECK(m_tracccTrackingTool.retrieve());
 
    m_featureNamesVec = CxxUtils::tokenize(m_featureNames, ",");
 
    // Initialize condition handle keys
    ATH_CHECK(m_pixelDetEleCollKey.initialize());
    ATH_CHECK(m_stripDetEleCollKey.initialize());
 
    // Initialize cluster container keys
    ATH_CHECK(m_inputPixelClusterContainerKey.initialize());
    ATH_CHECK(m_inputStripClusterContainerKey.initialize());
    ATH_CHECK(m_xAODPixelClusterFromInDetClusterKey.initialize());
    ATH_CHECK(m_xAODStripClusterFromInDetClusterKey.initialize());
    ATH_CHECK(m_xAODSpacepointFromInDetClusterKey.initialize());
 
    // Initialize truth association keys if needed
    ATH_CHECK(m_pixelClustersToTruth.initialize(m_doTruth));
    ATH_CHECK(m_stripClustersToTruth.initialize(m_doTruth));
 
    ATH_CHECK(m_ctxProvider.initialize());
 
    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.

readAndConvertClusters()

std::unordered_map< int64_t, int > TritonTracccTrackMaker::readAndConvertClusters ( const EventContext & eventContext ) const

protected

Definition at line 173 of file TritonTracccTrackMaker.cxx.

{
    int nPix = 0;
    int nStrip = 0;
    std::unordered_map<int64_t, int> traccc_to_xaod_cluster_map;
 
    ATH_MSG_INFO("Converting InDet clusters to xAOD");
    SG::WriteHandle<xAOD::PixelClusterContainer>
        xAODPixelContainerFromInDetClusters(
            m_xAODPixelClusterFromInDetClusterKey, eventContext);
    if ((xAODPixelContainerFromInDetClusters.record(
             std::make_unique<xAOD::PixelClusterContainer>(),
             std::make_unique<xAOD::PixelClusterAuxContainer>()))
            .isFailure()) {
        ATH_MSG_FATAL(
            "Could not record xAOD Pixel container from InDet Clusters");
        throw std::runtime_error(
            "creation of xAOD Pixel container from InDet Clusters failed");
    }
 
    SG::WriteHandle<xAOD::StripClusterContainer>
        xAODStripContainerFromInDetClusters(
            m_xAODStripClusterFromInDetClusterKey, eventContext);
    if ((xAODStripContainerFromInDetClusters.record(
             std::make_unique<xAOD::StripClusterContainer>(),
             std::make_unique<xAOD::StripClusterAuxContainer>()))
            .isFailure()) {
        ATH_MSG_FATAL(
            "Could not record xAOD Strip container from InDet Clusters");
        throw std::runtime_error(
            "creation of xAOD Strip container from InDet Clusters failed");
    }
 
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(
        m_pixelDetEleCollKey, eventContext);
 
    const InDetDD::SiDetectorElementCollection* pixElements{};
    if (SG::get(pixElements, m_pixelDetEleCollKey, eventContext).isFailure() ||
        pixElements == nullptr) {
        ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
        std::ostringstream errMsg;
        errMsg << m_pixelDetEleCollKey.fullKey() << " is not available.";
        throw std::runtime_error(errMsg.str());
    }
 
    SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> stripDetEleHandle(
        m_stripDetEleCollKey, eventContext);
    const InDetDD::SiDetectorElementCollection* stripElements(
        *stripDetEleHandle);
    if (not stripDetEleHandle.isValid() or stripElements == nullptr) {
        ATH_MSG_FATAL(m_stripDetEleCollKey.fullKey() << " is not available.");
        std::ostringstream errMsg;
        errMsg << m_stripDetEleCollKey.fullKey() << " is not available.";
        throw std::runtime_error(errMsg.str());
    }
 
    SG::WriteHandle<xAOD::SpacePointContainer>
        xAODSpacepointContainerFromInDetClusters(
            m_xAODSpacepointFromInDetClusterKey, eventContext);
    if (xAODSpacepointContainerFromInDetClusters
            .record(std::make_unique<xAOD::SpacePointContainer>(),
                    std::make_unique<xAOD::SpacePointAuxContainer>())
            .isFailure()) {
        throw std::runtime_error(
            "creation of InDet spacepoint containers failed");
    }
 
    ATH_MSG_DEBUG("Reading clusters");
    
    const InDet::PixelClusterContainer* inputPixelClusterContainer{};
    if (SG::get(inputPixelClusterContainer, m_inputPixelClusterContainerKey,
                eventContext)
            .isFailure() ||
        inputPixelClusterContainer == nullptr) {
        ATH_MSG_FATAL(m_inputPixelClusterContainerKey.fullKey()
                      << " is not available.");
        std::ostringstream errMsg;
        errMsg << m_inputPixelClusterContainerKey.fullKey()
               << " is not available.";
        throw std::runtime_error(errMsg.str());
    }
 
    for (const auto* const clusterCollection : *inputPixelClusterContainer) {
        if (!clusterCollection)
            continue;
        for (const auto* const theCluster : *clusterCollection) {
 
            const InDetDD::SiDetectorElement* element =
                theCluster->detectorElement();
            const Identifier Pixel_ModuleID = element->identify();
 
            auto pixelCl = xAODPixelContainerFromInDetClusters->push_back(
                                        std::make_unique<xAOD::PixelCluster>());
            if ((convertInDetToXaodCluster(*theCluster, *element, *pixelCl))
                    .isFailure()) {
                ATH_MSG_FATAL("Could not convert InDet pixel cluster to xAOD");
                throw std::runtime_error(
                    "conversion of InDet pixel cluster to xAOD failed");
            }
 
            auto xaod_sp = xAODSpacepointContainerFromInDetClusters->push_back(
                                            std::make_unique<xAOD::SpacePoint>());
            const IdentifierHash Pixel_ModuleHash =
                m_pixelID->wafer_hash(Pixel_ModuleID);
 
            xAOD::MeasVector<2> globalVariance(xAOD::MeasVector<2>::Zero());
            xAOD::MeasVector<3> globalPosition{xAOD::toStorage(theCluster->globalPosition())};
 
            xaod_sp->setSpacePoint(Pixel_ModuleHash, globalPosition,
                                   globalVariance(0, 0), globalVariance(1, 0),
                                   {pixelCl});
 
            size_t index = xAODPixelContainerFromInDetClusters->size() - 1;
            traccc_to_xaod_cluster_map[Pixel_ModuleID.get_compact()] = index;
 
            nPix++;
        }
    }
    ATH_MSG_DEBUG("Read " << nPix << " pixel clusters");
 
    const InDet::SCT_ClusterContainer* inputStripClusterContainer{};
    if (SG::get(inputStripClusterContainer, m_inputStripClusterContainerKey,
                eventContext)
            .isFailure() ||
        inputStripClusterContainer == nullptr) {
        ATH_MSG_FATAL(m_inputStripClusterContainerKey.fullKey()
                      << " is not available.");
        std::ostringstream errMsg;
        errMsg << m_inputStripClusterContainerKey.fullKey()
               << " is not available.";
        throw std::runtime_error(errMsg.str());
    }
 
    for (const auto* const clusterCollection : *inputStripClusterContainer) {
        if (!clusterCollection)
            continue;
        for (const auto* const theCluster : *clusterCollection) {
 
            const InDetDD::SiDetectorElement* element =
                theCluster->detectorElement();
            const Identifier Strip_ModuleID = element->identify();
 
            xAOD::StripCluster* stripCl = new xAOD::StripCluster();
            xAODStripContainerFromInDetClusters->push_back(stripCl);
            if ((convertInDetToXaodCluster(*theCluster, *element, *stripCl))
                    .isFailure()) {
                ATH_MSG_FATAL("Could not convert InDet strip cluster to xAOD");
                throw std::runtime_error(
                    "conversion of InDet strip cluster to xAOD failed");
            }
            size_t index = xAODStripContainerFromInDetClusters->size() - 1;
            traccc_to_xaod_cluster_map[Strip_ModuleID.get_compact()] = index;
 
            nStrip++;
        }
    }
 
    ATH_MSG_DEBUG("Read " << nStrip << " strip clusters");
 
    return traccc_to_xaod_cluster_map;
}

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 380 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 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

serializeCells()

StatusCode TritonTracccTrackMaker::serializeCells ( const traccc::edm::silicon_cell_collection::const_device & cells, std::vector< uint8_t > & out ) const

protected

Definition at line 137 of file TritonTracccTrackMaker.cxx.

{
    const uint64_t nCells = cells.size();
 
    // Reserve: 8-byte header + 5 columns * (4 or 4-byte scalars) per cell.
    out.clear();
    out.reserve(sizeof(uint64_t) + nCells * (3 * sizeof(uint32_t) + 2 * sizeof(float)));
 
    // Header: number of cells.
    appendBytes(out, nCells);
 
    // SoA column blocks, in silicon_cell_collection column order.
    for (uint64_t i = 0; i < nCells; ++i) {
        appendBytes(out, static_cast<uint32_t>(cells.channel0()[i]));
    }
    for (uint64_t i = 0; i < nCells; ++i) {
        appendBytes(out, static_cast<uint32_t>(cells.channel1()[i]));
    }
    for (uint64_t i = 0; i < nCells; ++i) {
        appendBytes(out, static_cast<float>(cells.activation()[i]));
    }
    for (uint64_t i = 0; i < nCells; ++i) {
        appendBytes(out, static_cast<float>(cells.time()[i]));
    }
    for (uint64_t i = 0; i < nCells; ++i) {
        appendBytes(out, static_cast<uint32_t>(cells.module_index()[i]));
    }
 
    ATH_MSG_DEBUG("Serialized " << nCells << " traccc cells into "
                  << out.size() << " bytes");
 
    return StatusCode::SUCCESS;
}

setFilterPassed()

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

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

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, AthFilterAlgorithm, 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 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_ActsTracccTrackContainerKey

SG::WriteHandleKey<ActsTrk::TrackContainer> TritonTracccTrackMaker::m_ActsTracccTrackContainerKey

protected

Initial value:

{
        this, "TracccTracks", "TracccTracks",
        "Output track collection (ActsTrk variant)"}

---

@name Output helpers

Definition at line 113 of file TritonTracccTrackMaker.h.

                                                                         {
        this, "TracccTracks", "TracccTracks",
        "Output track collection (ActsTrk variant)"};

m_ctxProvider

ActsTrk::ContextUtility TritonTracccTrackMaker::m_ctxProvider {this}

protected

Utility to fetch the geometry, magnetic field and calibration context in the event.

Definition at line 154 of file TritonTracccTrackMaker.h.

{this};

m_detEleToGeoIdMap

const ActsTrk::DetectorElementToActsGeometryIdMap* TritonTracccTrackMaker::m_detEleToGeoIdMap {nullptr}

protected

Definition at line 123 of file TritonTracccTrackMaker.h.

{nullptr};

m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_doTruth

Gaudi::Property<bool> TritonTracccTrackMaker::m_doTruth

protected

Initial value:

{
        this, "doTruth", true,
        "Create output containers and link to truth"}

Truth association for plotting and debugging.

Definition at line 162 of file TritonTracccTrackMaker.h.

                                 {
        this, "doTruth", true,
        "Create output containers and link to truth"};

m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 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_featureNames

StringProperty TritonTracccTrackMaker::m_featureNames

protected

Initial value:

{this, "FeatureNames",
                                "geometry_id,measurement_id,channel0,channel1,timestamp,value"}

Definition at line 156 of file TritonTracccTrackMaker.h.

                                 {this, "FeatureNames",
                                "geometry_id,measurement_id,channel0,channel1,timestamp,value"};

m_featureNamesVec

std::vector<std::string> TritonTracccTrackMaker::m_featureNamesVec

protected

Definition at line 158 of file TritonTracccTrackMaker.h.

m_inputPixelClusterContainerKey

SG::ReadHandleKey<InDet::PixelClusterContainer> TritonTracccTrackMaker::m_inputPixelClusterContainerKey

protected

Initial value:

{
            this, "InputPixelClustersName", "ITkPixelClusters",
            "name of the input InDet pixel cluster container"}

Definition at line 179 of file TritonTracccTrackMaker.h.

                                       {
            this, "InputPixelClustersName", "ITkPixelClusters",
            "name of the input InDet pixel cluster container"};

m_inputStripClusterContainerKey

SG::ReadHandleKey<InDet::SCT_ClusterContainer> TritonTracccTrackMaker::m_inputStripClusterContainerKey

protected

Initial value:

{
            this, "InputStripClustersName", "ITkStripClusters",
            "name of the input InDet strip cluster container"}

Definition at line 183 of file TritonTracccTrackMaker.h.

                                       {
            this, "InputStripClustersName", "ITkStripClusters",
            "name of the input InDet strip cluster container"};

m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis TritonTracccTrackMaker::m_pdgToParticleHypothesis

protected

Definition at line 120 of file TritonTracccTrackMaker.h.

m_pixelClustersToTruth

SG::ReadHandleKey<ActsTrk::MeasurementToTruthParticleAssociation> TritonTracccTrackMaker::m_pixelClustersToTruth

protected

Initial value:

{
            this, "PixelClustersToTruthParticlesMap",
            "PixelClustersForTruthSeedingToTruthParticlesMap",
            "Association map from pixel measurements to generator particles."}

Definition at line 167 of file TritonTracccTrackMaker.h.

                              {
            this, "PixelClustersToTruthParticlesMap",
            "PixelClustersForTruthSeedingToTruthParticlesMap",
            "Association map from pixel measurements to generator particles."};

m_pixelDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> TritonTracccTrackMaker::m_pixelDetEleCollKey

protected

Initial value:

{this, "PixelDetEleCollKey",
                             "ITkPixelDetectorElementCollection",
                             "Key of SiDetectorElementCollection for Pixel"}

Definition at line 204 of file TritonTracccTrackMaker.h.

                            {this, "PixelDetEleCollKey",
                             "ITkPixelDetectorElementCollection",
                             "Key of SiDetectorElementCollection for Pixel"};

m_pixelID

const PixelID* TritonTracccTrackMaker::m_pixelID {nullptr}

protected

Definition at line 91 of file TritonTracccTrackMaker.h.

{nullptr};

m_stripClustersToTruth

SG::ReadHandleKey<ActsTrk::MeasurementToTruthParticleAssociation> TritonTracccTrackMaker::m_stripClustersToTruth

protected

Initial value:

{
            this, "StripClustersToTruthParticlesMap",
            "StripClustersForTruthSeedingToTruthParticlesMap",
            "Association map from strip measurements to generator particles."}

Definition at line 173 of file TritonTracccTrackMaker.h.

                              {
            this, "StripClustersToTruthParticlesMap",
            "StripClustersForTruthSeedingToTruthParticlesMap",
            "Association map from strip measurements to generator particles."};

m_stripDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> TritonTracccTrackMaker::m_stripDetEleCollKey

protected

Initial value:

{this, "StripDetEleCollKey",
                             "ITkStripDetectorElementCollection",
                             "Key of SiDetectorElementCollection for Strip"}

Definition at line 208 of file TritonTracccTrackMaker.h.

                            {this, "StripDetEleCollKey",
                             "ITkStripDetectorElementCollection",
                             "Key of SiDetectorElementCollection for Strip"};

m_stripID

const SCT_ID* TritonTracccTrackMaker::m_stripID {nullptr}

protected

Definition at line 92 of file TritonTracccTrackMaker.h.

{nullptr};

m_tracccCellsKey

SG::ReadHandleKey<traccc::edm::silicon_cell_collection::const_view> TritonTracccTrackMaker::m_tracccCellsKey

protected

Initial value:

{
            this, "TracccCells", "TracccCells",
            "Input traccc cell collection (from RDOtoTracccCellConverterAlg)"}

---

@name Input helpers

Definition at line 83 of file TritonTracccTrackMaker.h.

                        {
            this, "TracccCells", "TracccCells",
            "Input traccc cell collection (from RDOtoTracccCellConverterAlg)"};

m_tracccTrackingTool

ToolHandle<ITracccTritonTool> TritonTracccTrackMaker::m_tracccTrackingTool

protected

Initial value:

{
        this, "TracccTritonTool", "TracccTritonTool"}

---

@name Tool handles

Definition at line 146 of file TritonTracccTrackMaker.h.

                                                      {
        this, "TracccTritonTool", "TracccTritonTool"};

m_trackingGeometry

std::shared_ptr<const Acts::TrackingGeometry> TritonTracccTrackMaker::m_trackingGeometry

protected

Definition at line 122 of file TritonTracccTrackMaker.h.

m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> TritonTracccTrackMaker::m_trackingGeometrySvc

protected

Initial value:

{
        this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

Definition at line 149 of file TritonTracccTrackMaker.h.

                                                                    {
        this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

m_tracksBackendHandlesHelper

ActsTrk::MutableTrackContainerHandlesHelper TritonTracccTrackMaker::m_tracksBackendHandlesHelper

protected

Initial value:

{
        this}

Definition at line 118 of file TritonTracccTrackMaker.h.

                                                                          {
        this};

m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_xAODPixelClusterFromInDetClusterKey

SG::WriteHandleKey<xAOD::PixelClusterContainer> TritonTracccTrackMaker::m_xAODPixelClusterFromInDetClusterKey

protected

Initial value:

{
            this, "xAODPixelClusterFromInDetClusterKey",
            "xAODPixelClustersFromInDetCluster",
            "InDet cluster->xAOD PixelClusters Container"}

Definition at line 188 of file TritonTracccTrackMaker.h.

                                             {
            this, "xAODPixelClusterFromInDetClusterKey",
            "xAODPixelClustersFromInDetCluster",
            "InDet cluster->xAOD PixelClusters Container"};

m_xAODSpacepointFromInDetClusterKey

SG::WriteHandleKey<xAOD::SpacePointContainer> TritonTracccTrackMaker::m_xAODSpacepointFromInDetClusterKey

protected

Initial value:

{
            this, "xAODSpacepointFromInDetClusterKey",
            "xAODSpacepointFromInDetCluster",
            "InDet cluster->xAOD Spacepoint Container"}

Definition at line 198 of file TritonTracccTrackMaker.h.

                                           {
            this, "xAODSpacepointFromInDetClusterKey",
            "xAODSpacepointFromInDetCluster",
            "InDet cluster->xAOD Spacepoint Container"};

m_xAODStripClusterFromInDetClusterKey

SG::WriteHandleKey<xAOD::StripClusterContainer> TritonTracccTrackMaker::m_xAODStripClusterFromInDetClusterKey

protected

Initial value:

{
            this, "xAODStripClusterFromInDetClusterKey",
            "xAODStripClustersFromInDetCluster",
            "InDet cluster ->xAOD StripClusters Container"}

Definition at line 193 of file TritonTracccTrackMaker.h.

                                             {
            this, "xAODStripClusterFromInDetClusterKey",
            "xAODStripClustersFromInDetCluster",
            "InDet cluster ->xAOD StripClusters Container"};

---

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

• TritonTracccTrackMaker.h
• TritonTracccTrackMaker.cxx