MuonR4::MuonDigitizationTool Class Reference

Barebone implementation of the I/O infrastructure for all MuonDigitizationTools. More...

#include <MuonDigitizationTool.h>

Inheritance diagram for MuonR4::MuonDigitizationTool:

Public Member Functions
StatusCode	initialize () override
StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
StatusCode	mergeEvent (const EventContext &ctx) override final
StatusCode	prepareEvent (const EventContext &ctx, const unsigned int) override final
	When being run from PileUpToolsAlgs, this method is called at the start of the subevts loop.
StatusCode	processAllSubEvents (const EventContext &ctx) override final
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.
StatusCode	processAllSubEvents (const EventContext &ctx) const
	Reentrant version of the digitization tool.
	PileUpToolBase (const std::string &type, const std::string &name, const IInterface *parent)

Protected Types
using	TimedHit = TimedHitPtr<xAOD::MuonSimHit>
using	TimedHits = std::vector<TimedHitPtr<xAOD::MuonSimHit>>
template<class DetType>
using	OutDigitCache_t = std::vector<std::unique_ptr<DetType>>
	DigitContainers are sorted by DigitCollections which are the ensemble of all hits in a given MuonChamber.
using	DeadTimeMap = std::unordered_map<Identifier, double>

Protected Member Functions
CLHEP::HepRandomEngine *	getRandomEngine (const EventContext &ctx) const
virtual StatusCode	digitize (const EventContext &ctx, const TimedHits &hitsToDigit, xAOD::MuonSimHitContainer *sdoContainer) const =0
	Digitize the time ordered hits and write them to the digit format specific for the detector technology.
xAOD::MuonSimHit *	addSDO (const TimedHit &hit, xAOD::MuonSimHitContainer *sdoContainer) const
	Adds the timed simHit to the output SDO container.
const ActsTrk::GeometryContext &	getGeoCtx (const EventContext &ctx) const
	Returns the reference to the ActsTrk::GeometryContext needed to fetch global positions from the Readout geometry.
template<class DigitColl>
DigitColl *	fetchCollection (const Identifier &hitId, OutDigitCache_t< DigitColl > &digitCache) const
	Helper function that provides fetches the proper DigitCollection from the DigitCache for a given hit identifier If the Collection is fetched for the first time, it's inserted into the cache first.
template<class DigitCont, class DigitColl>
StatusCode	writeDigitContainer (const EventContext &ctx, const SG::WriteHandleKey< DigitCont > &key, OutDigitCache_t< DigitColl > &&digitCache, unsigned int hashMax) const
	Helper function to move the collected digits into the final DigitContainer.

Static Protected Member Functions
static double	hitTime (const TimedHit &hit)
	Returns the global time of the hit which is the sum of eventTime & individual hit time.
static bool	passDeadTime (const Identifier &channelId, const double hitTime, const double deadTimeWindow, DeadTimeMap &deadTimeMap)
	Returns whether the new digit is within the dead time window.

Protected Attributes
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc

Private Types
using	PileUpHits = PileUpMergeSvc::TimedList<xAOD::MuonSimHitContainer>::type
using	SimHitLocalCopy
	Create a local copy of the sim hits to ensure overlayed hits across the events remain valid.

Private Member Functions
StatusCode	fillTimedHits (PileUpHits &&hitColl, TimedHits &timedHits) const
	Translates the PileUpHits into the timed hits format.

Private Attributes
SG::ReadHandleKey< xAOD::MuonSimHitContainer >	m_simHitKey {this, "SimHitKey", ""}
SG::ReadHandleKey< ActsTrk::GeometryContext >	m_geoCtxKey
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}
Gaudi::Property< std::string >	m_streamName {this, "StreamName", ""}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
SG::WriteHandleKey< xAOD::MuonSimHitContainer >	m_sdoKey {this, "OutputSDOName", ""}
Gaudi::Property< bool >	m_onlyUseContainerName
Gaudi::Property< bool >	m_includePileUpTruth {this, "IncludePileUpTruth", true, "Include pile-up truth info"}
std::string	m_inputObjectName {""}
TimedHits	m_timedHits {}
std::vector< SimHitLocalCopy >	m_simHits {}

structors and AlgTool implementation
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset

Detailed Description

Barebone implementation of the I/O infrastructure for all MuonDigitizationTools.

Definition at line 30 of file MuonDigitizationTool.h.

Member Typedef Documentation

DeadTimeMap

using MuonR4::MuonDigitizationTool::DeadTimeMap = std::unordered_map<Identifier, double>

protected

Definition at line 100 of file MuonDigitizationTool.h.

OutDigitCache_t

template<class DetType>

using MuonR4::MuonDigitizationTool::OutDigitCache_t = std::vector<std::unique_ptr<DetType>>

protected

DigitContainers are sorted by DigitCollections which are the ensemble of all hits in a given MuonChamber.

To fill the final DigitContainer thread-safely, the DigitCollections shall be cached pre cached in a OutDigitCache_t vector which is later moved to the final DigitContainer

Definition at line 80 of file MuonDigitizationTool.h.

PileUpHits

using MuonR4::MuonDigitizationTool::PileUpHits = PileUpMergeSvc::TimedList<xAOD::MuonSimHitContainer>::type

private

Definition at line 116 of file MuonDigitizationTool.h.

SimHitLocalCopy

using MuonR4::MuonDigitizationTool::SimHitLocalCopy

private

Initial value:

 std::pair<std::unique_ptr<xAOD::MuonSimHitContainer>,
                                              std::unique_ptr<xAOD::MuonSimHitAuxContainer>>

Create a local copy of the sim hits to ensure overlayed hits across the events remain valid.

Definition at line 143 of file MuonDigitizationTool.h.

TimedHit

using MuonR4::MuonDigitizationTool::TimedHit = TimedHitPtr<xAOD::MuonSimHit>

protected

Definition at line 57 of file MuonDigitizationTool.h.

TimedHits

using MuonR4::MuonDigitizationTool::TimedHits = std::vector<TimedHitPtr<xAOD::MuonSimHit>>

protected

Definition at line 58 of file MuonDigitizationTool.h.

Member Function Documentation

addSDO()

xAOD::MuonSimHit * MuonR4::MuonDigitizationTool::addSDO ( const TimedHit & hit, xAOD::MuonSimHitContainer * sdoContainer ) const

protected

Adds the timed simHit to the output SDO container.

The hit may be rejected if it's originating from pile-up and the pile-up truth skimming strategy is applied

Definition at line 142 of file MuonDigitizationTool.cxx.

                                                                                                {
        if(!sdoContainer) {
            ATH_MSG_VERBOSE("No SDO container setup of writing");
            return nullptr;
        }
        if (!m_includePileUpTruth && HepMC::ignoreTruthLink(hit->genParticleLink(), m_vetoPileUpTruthLinks)) { 
            ATH_MSG_VERBOSE("Hit "<<m_idHelperSvc->toString(hit->identify())<<" is a pile-up truth link");
            return nullptr; 
        }
        ATH_MSG_VERBOSE(m_idHelperSvc->toString(hit->identify())<<", pdgID: "<<hit->pdgId()<< " genParticleLink :"<<hit->genParticleLink());
        ATH_MSG_VERBOSE("Genparticle: "<<hit->genParticleLink());        
        xAOD::MuonSimHit* sdoHit = sdoContainer->push_back(std::make_unique<xAOD::MuonSimHit>());
        (*sdoHit) = (*hit);
        static const SG::Accessor<float> acc_eventTime{"MuSim_evtTime"};
        static const SG::Accessor<unsigned short> acc_eventID{"MuSim_evtID"};
        static const SG::Accessor<unsigned short> acc_puType{"MuSim_puType"};
        acc_eventTime(*sdoHit) = hit.eventTime();
        acc_eventID(*sdoHit) = hit.eventId();
        acc_puType(*sdoHit) = hit.pileupType();
        return sdoHit;
    }

digitize()

virtual StatusCode MuonR4::MuonDigitizationTool::digitize ( const EventContext & ctx, const TimedHits & hitsToDigit, xAOD::MuonSimHitContainer * sdoContainer ) const

protectedpure virtual

Digitize the time ordered hits and write them to the digit format specific for the detector technology.

A new MuonSimHitContainer pointer is parsed to also create the MuonSDO. If a new SDO should be added to the container plese use the addSDO() method as defined below.

Implemented in MuonR4::MdtDigitizationTool, MuonR4::MM_DigitizationTool, MuonR4::MmFastDigiTool, MuonR4::RpcFastDigiTool, MuonR4::sTgcDigitizationTool, MuonR4::sTgcFastDigiTool, and MuonR4::TgcFastDigiTool.

fetchCollection()

template<class DigitColl>

DigitColl * MuonR4::MuonDigitizationTool::fetchCollection ( const Identifier & hitId, OutDigitCache_t< DigitColl > & digitCache ) const

protected

Helper function that provides fetches the proper DigitCollection from the DigitCache for a given hit identifier If the Collection is fetched for the first time, it's inserted into the cache first.

fillTimedHits()

StatusCode MuonR4::MuonDigitizationTool::fillTimedHits ( PileUpHits && hitColl, TimedHits & timedHits ) const

private

Translates the PileUpHits into the timed hits format.

Definition at line 44 of file MuonDigitizationTool.cxx.

                                                                                                   {
        for (const auto& [timeIndex, simHitColl] : hitColl) {
            timedHits.reserve(timedHits.capacity() + simHitColl->size());
            for (const xAOD::MuonSimHit* simHit : *simHitColl) {
                timedHits.emplace_back(timeIndex.time(), timeIndex.index(), simHit, timeIndex.type());
            }           
        }
        std::stable_sort(timedHits.begin(), timedHits.end(), 
                 [](const TimedHit& a, const TimedHit& b){
                    if (a->identify() != b->identify()){
                        return a->identify() < b->identify();
                    }
                    if (a.eventId() != b.eventId()) {
                       return a.eventId() < b.eventId();
                    } 
                    return a.eventTime() < b.eventTime(); 
                }); 
        return StatusCode::SUCCESS;
    }

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

getGeoCtx()

const ActsTrk::GeometryContext & MuonR4::MuonDigitizationTool::getGeoCtx ( const EventContext & ctx ) const

protected

Returns the reference to the ActsTrk::GeometryContext needed to fetch global positions from the Readout geometry.

Definition at line 135 of file MuonDigitizationTool.cxx.

                                                                                               {
        const ActsTrk::GeometryContext* gctx{};
        if (!SG::get(gctx, m_geoCtxKey, ctx).isSuccess()) {
            THROW_EXCEPTION("Failed to retrieve the geometry context "<<m_geoCtxKey.fullKey());
        }
        return *gctx;
    }

getRandomEngine()

CLHEP::HepRandomEngine * MuonR4::MuonDigitizationTool::getRandomEngine ( const EventContext & ctx ) const

protected

Definition at line 129 of file MuonDigitizationTool.cxx.

                                                                                            {
        ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_streamName);
        std::string rngName = m_streamName;
        rngWrapper->setSeed(rngName, ctx);
        return rngWrapper->getEngine(ctx);
    }

hitTime()

double MuonR4::MuonDigitizationTool::hitTime ( const TimedHit & hit )

staticprotected

Returns the global time of the hit which is the sum of eventTime & individual hit time.

Definition at line 63 of file MuonDigitizationTool.cxx.

                                                            {
        return hit.eventTime() + hit->globalTime();
    }

initialize()

StatusCode MuonR4::MuonDigitizationTool::initialize ( )

overridevirtual

Initialize ReadHandleKey

Reimplemented from PileUpToolBase.

Reimplemented in MuonR4::RpcFastDigiTool, MuonR4::sTgcDigitizationTool, MuonR4::sTgcFastDigiTool, and MuonR4::TgcFastDigiTool.

Definition at line 11 of file MuonDigitizationTool.cxx.

                                               {
        ATH_MSG_INFO("SimHitKey "<<m_simHitKey.key()<<", "<<m_streamName<<", SDO container: "<<m_sdoKey.key());
        if (m_simHitKey.empty() && m_inputObjectName.empty()) {
            ATH_MSG_FATAL("Property <SimHitKey> not set !");
            return StatusCode::FAILURE;
        }
        if (m_streamName.empty()) {
            ATH_MSG_FATAL("Property "<<m_streamName<<" not set !");
            return StatusCode::FAILURE;
        }
        if (m_onlyUseContainerName) {
            m_inputObjectName = m_simHitKey.key();
            ATH_CHECK(m_mergeSvc.retrieve());
        }
        ATH_CHECK(m_simHitKey.initialize());
        ATH_CHECK(m_geoCtxKey.initialize());
        ATH_CHECK(m_sdoKey.initialize(!m_sdoKey.empty()));
        ATH_CHECK(m_rndmSvc.retrieve());
        ATH_CHECK(detStore()->retrieve(m_detMgr));
        ATH_CHECK(m_idHelperSvc.retrieve());
        return StatusCode::SUCCESS;
    }

mergeEvent()

StatusCode MuonR4::MuonDigitizationTool::mergeEvent ( const EventContext & ctx )

finaloverride

Definition at line 92 of file MuonDigitizationTool.cxx.

                                                                       {
        ATH_MSG_DEBUG("mergeEvent()");
        
        SG::WriteHandle<xAOD::MuonSimHitContainer> sdoContainer{};
        if (!m_sdoKey.empty()) {
             sdoContainer = SG::WriteHandle<xAOD::MuonSimHitContainer>{m_sdoKey, ctx};
             ATH_CHECK(sdoContainer.record(std::make_unique<xAOD::MuonSimHitContainer>(),
                                           std::make_unique<xAOD::MuonSimHitAuxContainer>()));
        }
        ATH_CHECK(digitize(ctx, m_timedHits, !m_sdoKey.empty() ? sdoContainer.ptr() : nullptr));
        m_timedHits.clear();
        m_simHits.clear();
        return StatusCode::SUCCESS;
    }

passDeadTime()

bool MuonR4::MuonDigitizationTool::passDeadTime ( const Identifier & channelId, const double hitTime, const double deadTimeWindow, DeadTimeMap & deadTimeMap )

staticprotected

Returns whether the new digit is within the dead time window.

channelId: Identifier of the fired channel

hitTime: Current hit time

deadTimeWindow: Dead time to pass before the next hit may be accepted

deadTimeMap: Map storing the last hit times from each Identifier

Channel not seen before

Update dead time map & accept hit

Definition at line 164 of file MuonDigitizationTool.cxx.

                                                                      {
        auto insertItr = deadTimeMap.insert(std::make_pair(channelId,hitTime));
        if (insertItr.second) {
            return true;
        }
        if (hitTime - insertItr.first->second < deadTimeWindow) {
            return false;
        }
        insertItr.first->second = hitTime;
        return true;
    }

PileUpToolBase()

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

Definition at line 22 of file PileUpToolBase.cxx.

  : base_class(type, name, parent)
{
}

prepareEvent()

StatusCode MuonR4::MuonDigitizationTool::prepareEvent ( const EventContext & ctx, const unsigned int nInputEvents )

finaloverride

When being run from PileUpToolsAlgs, this method is called at the start of the subevts loop.

Not able to access SubEvents

Definition at line 35 of file MuonDigitizationTool.cxx.

                                                                             {
 
        ATH_MSG_DEBUG("prepareEvent() called for " << nInputEvents << " input events");
        m_timedHits.clear();
        m_simHits.clear();
        return StatusCode::SUCCESS;
    }

processAllSubEvents() [1/2]

StatusCode MuonR4::MuonDigitizationTool::processAllSubEvents

(

const EventContext &

ctx

)

const

Reentrant version of the digitization tool.

In case of single hits container just load the collection using read handles

Definition at line 71 of file MuonDigitizationTool.cxx.

                                                                                      {
        PileUpHits hitCollList{};
        TimedHits timedHits{};
        if (!m_onlyUseContainerName) {            
            const xAOD::MuonSimHitContainer* hitCollection{nullptr};
            ATH_CHECK(SG::get(hitCollection, m_simHitKey, ctx));
            hitCollList.emplace_back(PileUpTimeEventIndex(0), hitCollection);
         } else {
            ATH_CHECK(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList));
        }
        ATH_CHECK(fillTimedHits(std::move(hitCollList), timedHits));
        SG::WriteHandle<xAOD::MuonSimHitContainer> sdoContainer{};
        if (!m_sdoKey.empty()) {
             sdoContainer = SG::WriteHandle<xAOD::MuonSimHitContainer>{m_sdoKey, ctx};
             ATH_CHECK(sdoContainer.record(std::make_unique<xAOD::MuonSimHitContainer>(),
                                           std::make_unique<xAOD::MuonSimHitAuxContainer>()));
        }
        ATH_CHECK(digitize(ctx, timedHits, !m_sdoKey.empty() ? sdoContainer.ptr() : nullptr));
        return StatusCode::SUCCESS;
    }

processAllSubEvents() [2/2]

StatusCode MuonR4::MuonDigitizationTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.

Reimplemented from PileUpToolBase.

Definition at line 66 of file MuonDigitizationTool.cxx.

                                                                                {
        const MuonDigitizationTool* digiTool = this;
        return digiTool->processAllSubEvents(ctx);
    }

processBunchXing()

StatusCode MuonR4::MuonDigitizationTool::processBunchXing ( int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 108 of file MuonDigitizationTool.cxx.

                                                                                   {        
        ATH_MSG_DEBUG("processBunchXing()" << bunchXing);
        PileUpHits hitList{}, hitListPermanent{};
        ATH_CHECK(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitList, bunchXing, bSubEvents, eSubEvents));
        ATH_MSG_VERBOSE(hitList.size() << " hits in  xAODMuonSimHitContainer " << m_inputObjectName << " found");
        for (auto& [hitPtr, hitContainer] : hitList) {
            auto copyContainer = std::make_unique<xAOD::MuonSimHitContainer>();
            auto copyAuxContainer = std::make_unique<xAOD::MuonSimHitAuxContainer>();
            copyContainer->setStore(copyAuxContainer.get());
            for (const xAOD::MuonSimHit* copyMe : *hitContainer) {
               (*copyContainer->push_back(std::make_unique<xAOD::MuonSimHit>())) = (*copyMe);
            }
            hitListPermanent.emplace_back(hitPtr, copyContainer.get());
            m_simHits.emplace_back(std::move(copyContainer), std::move(copyAuxContainer));
        } 
        ATH_CHECK(fillTimedHits(std::move(hitListPermanent), m_timedHits));
        return StatusCode::SUCCESS;
    }

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

                                                       {
    //closed interval [m_firstXing,m_lastXing]
    return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
  }

writeDigitContainer()

template<class DigitCont, class DigitColl>

StatusCode MuonR4::MuonDigitizationTool::writeDigitContainer ( const EventContext & ctx, const SG::WriteHandleKey< DigitCont > & key, OutDigitCache_t< DigitColl > && digitCache, unsigned int hashMax ) const

protected

Helper function to move the collected digits into the final DigitContainer.

The function needs the maximal size of the container in advance which is provided by calling the module_hash_max() function of the corresponding MuonIdHelper.

Member Data Documentation

m_detMgr

const MuonGMR4::MuonDetectorManager* MuonR4::MuonDigitizationTool::m_detMgr {nullptr}

protected

Definition at line 111 of file MuonDigitizationTool.h.

{nullptr};

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

{this, "FirstXing", -999,
      "First bunch-crossing in which det is live"}

Definition at line 54 of file PileUpToolBase.h.

                                {this, "FirstXing", -999,
      "First bunch-crossing in which det is live"};

m_geoCtxKey

SG::ReadHandleKey<ActsTrk::GeometryContext> MuonR4::MuonDigitizationTool::m_geoCtxKey

private

Initial value:

{this, "AlignmentKey", "ActsAlignment", 
                                                               "Geometry context"}

Definition at line 123 of file MuonDigitizationTool.h.

                                                               {this, "AlignmentKey", "ActsAlignment", 
                                                               "Geometry context"};

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::MuonDigitizationTool::m_idHelperSvc

protected

Initial value:

{this, "MuonIdHelperSvc", 
                                                                "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 113 of file MuonDigitizationTool.h.

                                                             {this, "MuonIdHelperSvc", 
                                                                "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_includePileUpTruth

Gaudi::Property<bool> MuonR4::MuonDigitizationTool::m_includePileUpTruth {this, "IncludePileUpTruth", true, "Include pile-up truth info"}

private

Definition at line 137 of file MuonDigitizationTool.h.

{this, "IncludePileUpTruth", true, "Include pile-up truth info"};

m_inputObjectName

std::string MuonR4::MuonDigitizationTool::m_inputObjectName {""}

private

Definition at line 139 of file MuonDigitizationTool.h.

{""};

m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing

protectedinherited

Initial value:

{this, "LastXing", 999,
      "Last bunch-crossing in which det is live"}

Definition at line 56 of file PileUpToolBase.h.

                                {this, "LastXing", 999,
      "Last bunch-crossing in which det is live"};

m_mergeSvc

ServiceHandle<PileUpMergeSvc> MuonR4::MuonDigitizationTool::m_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}

private

Definition at line 126 of file MuonDigitizationTool.h.

{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};

m_onlyUseContainerName

Gaudi::Property<bool> MuonR4::MuonDigitizationTool::m_onlyUseContainerName

private

Initial value:

{this, "OnlyUseContainerName", false,
                                                         "Don't use the ReadHandleKey directly. Just extract the container name from it."}

Definition at line 134 of file MuonDigitizationTool.h.

                                                      {this, "OnlyUseContainerName", false,
                                                         "Don't use the ReadHandleKey directly. Just extract the container name from it."};

m_rndmSvc

ServiceHandle<IAthRNGSvc> MuonR4::MuonDigitizationTool::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}

private

Definition at line 130 of file MuonDigitizationTool.h.

{this, "RndmSvc", "AthRNGSvc", ""};  // Random number service

m_sdoKey

SG::WriteHandleKey<xAOD::MuonSimHitContainer> MuonR4::MuonDigitizationTool::m_sdoKey {this, "OutputSDOName", ""}

private

Definition at line 132 of file MuonDigitizationTool.h.

{this, "OutputSDOName", ""};

m_simHitKey

SG::ReadHandleKey<xAOD::MuonSimHitContainer> MuonR4::MuonDigitizationTool::m_simHitKey {this, "SimHitKey", ""}

private

Definition at line 121 of file MuonDigitizationTool.h.

{this, "SimHitKey", ""};

m_simHits

std::vector<SimHitLocalCopy> MuonR4::MuonDigitizationTool::m_simHits {}

private

Definition at line 145 of file MuonDigitizationTool.h.

{};

m_streamName

Gaudi::Property<std::string> MuonR4::MuonDigitizationTool::m_streamName {this, "StreamName", ""}

private

Definition at line 128 of file MuonDigitizationTool.h.

{this, "StreamName", ""};

m_timedHits

TimedHits MuonR4::MuonDigitizationTool::m_timedHits {}

private

Definition at line 141 of file MuonDigitizationTool.h.

{};

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

{this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.

                                           {this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"};

---

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

• MuonDigitizationTool.h
• MuonDigitizationTool.cxx