#include <RpcFastDigiTool.h>

Inheritance diagram for MuonR4::RpcFastDigiTool:

Collaboration diagram for MuonR4::RpcFastDigiTool:

Public Member Functions
	RpcFastDigiTool (const std::string &type, const std::string &name, const IInterface *pIID)

StatusCode	initialize () override final

StatusCode	finalize () override final

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. More...

StatusCode	processAllSubEvents (const EventContext &ctx) override final
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents. More...

StatusCode	processAllSubEvents (const EventContext &ctx) const
	Reentrant version of the digitization tool. More...

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. More...

Protected Member Functions
StatusCode	digitize (const EventContext &ctx, const TimedHits &hitsToDigit, xAOD::MuonSimHitContainer *sdoContainer) const override final
	Digitize the time ordered hits and write them to the digit format specific for the detector technology. More...

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

void	addSDO (const TimedHit &hit, xAOD::MuonSimHitContainer *sdoContainer) const
	Adds the timed simHit to the output SDO container. More...

const ActsGeometryContext &	getGeoCtx (const EventContext &ctx) const
	Returns the reference to the ActsGeometryContext needed to fetch global positions from the Readout geometry. More...

template<class Container >
StatusCode	retrieveContainer (const EventContext &ctx, const SG::ReadHandleKey< Container > &key, const Container *&contPtr) const
	Helper function to retrieve a container from StoreGate. More...

template<class Container >
StatusCode	retrieveConditions (const EventContext &ctx, const SG::ReadCondHandleKey< Container > &key, const Container *&contPtr) const
	Helper function to access the conditions data. More...

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. More...

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. More...

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. More...

Protected Attributes
const MuonGMR4::MuonDetectorManager *	m_detMgr {nullptr}

ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc

Private Types
using	DigiCache = OutDigitCache_t< RpcDigitCollection >

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

using	SimHitLocalCopy = 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. More...

Private Member Functions
bool	digitizeHit (const Identifier &gasGapId, const bool measuresPhi, const MuonGMR4::StripDesignPtr &designPtr, const double hitTime, const double locPos, const Muon::DigitEffiData effiMap, RpcDigitCollection &outContainer, CLHEP::HepRandomEngine rndEngine) const
	Digitize the sim hit as Rpc strip 1D hit. More...

bool	digitizeHit (const Identifier &gasGapId, const MuonGMR4::StripDesignPtr &designPtr, const double hitTime, const Amg::Vector2D &locPos, const Muon::DigitEffiData effiMap, RpcDigitCollection &outContainer, CLHEP::HepRandomEngine rndEngine) const
	Digitize the sim hit as Rpc strip 2D hit. More...

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

Static Private Member Functions
static double	timeOverThreshold (CLHEP::HepRandomEngine *rndmEngine)
	Roll the time over threshold for each signal digit. More...

Private Attributes
int	m_stIdxBIL {-1}

SG::WriteHandleKey< RpcDigitContainer >	m_writeKey {this, "OutputObjectName", "RPC_DIGITS"}

SG::ReadCondHandleKey< Muon::DigitEffiData >	m_effiDataKey

std::array< std::atomic< unsigned >, 2 > m_allHits	ATLAS_THREAD_SAFE {}

std::array< std::atomic< unsigned >, 2 > m_acceptedHits	ATLAS_THREAD_SAFE {}

Gaudi::Property< double >	m_propagationVelocity

Gaudi::Property< double >	m_stripTimeResolution

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

SG::ReadHandleKey< ActsGeometryContext >	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
virtual StatusCode	processAllSubEvents (const EventContext &ctx)=0
	dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface. More...

virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing More...

virtual bool	filterPassed () const override
	dummy implementation of passing filter More...

virtual void	resetFilter () override
	dummy implementation of filter reset More...

Gaudi::Property< int >	m_firstXing

Gaudi::Property< int >	m_lastXing

Gaudi::Property< int >	m_vetoPileUpTruthLinks

bool	m_filterPassed {true}

Detailed Description

Definition at line 15 of file RpcFastDigiTool.h.

Member Typedef Documentation

◆ DigiCache

using MuonR4::RpcFastDigiTool::DigiCache = OutDigitCache_t<RpcDigitCollection>

private

Definition at line 69 of file RpcFastDigiTool.h.

◆ OutDigitCache_t

template<class DetType >

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

protectedinherited

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 98 of file MuonDigitizationTool.h.

◆ PileUpHits

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

privateinherited

Definition at line 125 of file MuonDigitizationTool.h.

◆ SimHitLocalCopy

using MuonR4::MuonDigitizationTool::SimHitLocalCopy = std::pair<std::unique_ptr<xAOD::MuonSimHitContainer>, std::unique_ptr<xAOD::MuonSimHitAuxContainer> >

privateinherited

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

Definition at line 152 of file MuonDigitizationTool.h.

◆ TimedHit

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

protectedinherited

Definition at line 59 of file MuonDigitizationTool.h.

◆ TimedHits

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

protectedinherited

Definition at line 60 of file MuonDigitizationTool.h.

Constructor & Destructor Documentation

◆ RpcFastDigiTool()

MuonR4::RpcFastDigiTool::RpcFastDigiTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pIID
	)

Definition at line 15 of file RpcFastDigiTool.cxx.

15 :

16 MuonDigitizationTool{type,name, pIID} {}

Member Function Documentation

◆ addSDO()

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

protectedinherited

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 148 of file MuonDigitizationTool.cxx.

                                                                                                      {
         if(!sdoContainer) {
             ATH_MSG_VERBOSE("No SDO container setup of writing");
             return;
         }
         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; 
         }
         
         xAOD::MuonSimHit* sdoHit = sdoContainer->push_back(std::make_unique<xAOD::MuonSimHit>());
         (*sdoHit) = (*hit);
         static const SG::Accessor<float> acc_eventTime{"SDO_evtTime"};
         static const SG::Accessor<unsigned short> acc_eventID{"SDO_evtID"};
         static const SG::Accessor<unsigned short> acc_puType{"SDO_puType"};
         acc_eventTime(*sdoHit) = hit.eventTime();
         acc_eventID(*sdoHit) = hit.eventId();
         acc_puType(*sdoHit) = hit.pileupType();
     }

◆ digitize()

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

finaloverrideprotectedvirtual

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.

Fetch the conditions for efficiency calculations

ignore radiation for now

Standard digitization path

Write everything at the end into the final digit container

Implements MuonR4::MuonDigitizationTool.

Definition at line 31 of file RpcFastDigiTool.cxx.

                                                                                       {
         const RpcIdHelper& idHelper{m_idHelperSvc->rpcIdHelper()};
         // Prepare the temporary cache
         DigiCache digitCache{};
         const Muon::DigitEffiData* efficiencyMap{nullptr};
         ATH_CHECK(retrieveConditions(ctx, m_effiDataKey, efficiencyMap));
  
         CLHEP::HepRandomEngine* rndEngine = getRandomEngine(ctx);
         for (const TimedHit& simHit : hitsToDigit) {
             const Identifier hitId{simHit->identify()};
             if (std::abs(simHit->pdgId()) != 13) continue;
             
             const MuonGMR4::RpcReadoutElement* readOutEle = m_detMgr->getRpcReadoutElement(hitId);
             const Amg::Vector3D locPos{xAOD::toEigen(simHit->localPosition())};
             RpcDigitCollection* digiColl = fetchCollection(hitId, digitCache);
             if (m_idHelperSvc->stationName(hitId) != m_stIdxBIL) {
                 bool digitized = digitizeHit(hitId, false, readOutEle->getParameters().etaDesign, 
                                              hitTime(simHit), locPos.x(), 
                                              efficiencyMap, *digiColl, rndEngine);
                 digitized |=  digitizeHit(hitId, true, readOutEle->getParameters().phiDesign,  
                                           hitTime(simHit), locPos.y(),
                                           efficiencyMap, *digiColl, rndEngine);
                 if (digitized) {
                     addSDO(simHit, sdoContainer);
                 }
             } else if (digitizeHit(hitId, readOutEle->getParameters().etaDesign, 
                        hitTime(simHit), locPos.block<2,1>(0,0),
                        efficiencyMap, *digiColl, rndEngine)) {
                 addSDO(simHit, sdoContainer);
             }
         }
         ATH_CHECK(writeDigitContainer(ctx, m_writeKey, std::move(digitCache), idHelper.module_hash_max()));
         return StatusCode::SUCCESS;
     }   

◆ digitizeHit() [1/2]

bool MuonR4::RpcFastDigiTool::digitizeHit	(	const Identifier &	gasGapId,
		const bool	measuresPhi,
		const MuonGMR4::StripDesignPtr &	designPtr,
		const double	hitTime,
		const double	locPos,
		const Muon::DigitEffiData *	effiMap,
		RpcDigitCollection &	outContainer,
		CLHEP::HepRandomEngine *	rndEngine
	)		const

private

Digitize the sim hit as Rpc strip 1D hit.

Parameters

gasGapId	Identifier of the associated gasGap
measuresPhi	Process a phi or an eta strip
designPtr	Pointer to the striplayout of the gasGap
hitTime	Global time of the hit
locPosOnStrip	Local position of the hit perpendicular to the strip plane
effiMap	Pointer to an efficiency look-up table
outContainer	DigitCollection to push the new digit into
rndEngine	Random engine used for smearing

There're Rpc chambers without phi strips (BI)

Final check whether the digit is actually efficient

Definition at line 71 of file RpcFastDigiTool.cxx.

                                                                              {
  
         if (!designPtr){
             return false;
         }
         ++(m_allHits[measuresPhi]);
         const MuonGMR4::StripDesign& design{*designPtr};
  
         const double uncert = design.stripPitch() / std::sqrt(12.);
         const double smearedX = CLHEP::RandGaussZiggurat::shoot(rndEngine, locPosOnStrip, uncert);
         const Amg::Vector2D locHitPos{smearedX * Amg::Vector2D::UnitX()};
  
         if (!design.insideTrapezoid(locHitPos)) {
             ATH_MSG_VERBOSE("The hit "<<Amg::toString(locHitPos)<<" is outside of the trapezoid bounds for "
                             <<m_idHelperSvc->toStringGasGap(gasGapId)<<", measuresPhi: "<<(measuresPhi ? "yay" : "nay"));
             return false;
         }
         const int strip = design.stripNumber(locHitPos);
         if (strip < 0) {
             ATH_MSG_VERBOSE("Hit " << Amg::toString(locHitPos) << " cannot trigger any signal in a strip for "
                             << m_idHelperSvc->toStringGasGap(gasGapId) <<std::endl<<design<<
                             std::endl<<", measuresPhi: "<<(measuresPhi ? "yay" : "nay"));
             return false;
         }
  
         const RpcIdHelper& id_helper{m_idHelperSvc->rpcIdHelper()};
  
         bool isValid{false};
         const Identifier digitId{id_helper.channelID(gasGapId, 
                                                      id_helper.doubletZ(gasGapId), 
                                                      id_helper.doubletPhi(gasGapId), 
                                                      id_helper.gasGap(gasGapId),
                                                      measuresPhi, strip, isValid)};
  
         if (!isValid) {
             ATH_MSG_WARNING("Invalid hit identifier obtained for "<<m_idHelperSvc->toStringGasGap(gasGapId)
                             <<",  eta strip "<<strip<<" & hit "<<Amg::toString(locHitPos,2 )
                             <<" /// "<<design);
             return false;
         }
         if (effiMap && effiMap->getEfficiency(digitId) < CLHEP::RandFlat::shoot(rndEngine,0.,1.)) {
             ATH_MSG_VERBOSE("Hit is marked as inefficient");
             return false;            
         }
         outContainer.push_back(std::make_unique<RpcDigit>(digitId, hitTime, timeOverThreshold(rndEngine)));
         ++(m_acceptedHits[measuresPhi]);
         return true;
     }

◆ digitizeHit() [2/2]

bool MuonR4::RpcFastDigiTool::digitizeHit	(	const Identifier &	gasGapId,
		const MuonGMR4::StripDesignPtr &	designPtr,
		const double	hitTime,
		const Amg::Vector2D &	locPos,
		const Muon::DigitEffiData *	effiMap,
		RpcDigitCollection &	outContainer,
		CLHEP::HepRandomEngine *	rndEngine
	)		const

private

Digitize the sim hit as Rpc strip 2D hit.

Parameters

gasGapId	Identifier of the associated gasGap
designPtr	Pointer to the striplayout of the gasGap
hitTime	Global time of the hit
locPos	Local position of the hit inside the strip plane
effiMap	Pointer to an efficiency look-up table
outContainer	DigitCollection to push the new digit into
rndEngine	Random engine used for smearing

Smeared x coordinate

Smear the Phi Coordinate

Smeared propagation time in nanoseconds along strip to y=-stripLength/2 (L) and y=stripLength/2 (R)

Check whether the digit is actually efficient

Definition at line 128 of file RpcFastDigiTool.cxx.

                                                                              {
         
         ++(m_allHits[false]);
         const MuonGMR4::StripDesign& design{*designPtr};
         const RpcIdHelper& id_helper{m_idHelperSvc->rpcIdHelper()};
  
  
         const double uncert = design.stripPitch() / std::sqrt(12.);
         const double smearedX = CLHEP::RandGaussZiggurat::shoot(rndEngine, locPos.x(), uncert);
  
         const double stripLength = design.stripLength(1); // in mm, assuming lenLeftEdge() == lenRightEdge() i.e. rectangular strip
  
         // Distance in mm along strip to y=-stripLength/2 (L) and y=stripLength/2 (R)
         const double stripLeft = -(stripLength / 2);     
         const double stripRight = (stripLength / 2);     
         const double distToL = std::abs(stripLeft  - locPos.y());  
         const double distToR = std::abs(stripRight - locPos.y()); 
     
         // True propagation time in nanoseconds along strip to y=-stripLength/2 (L) and y=stripLength/2 (R)
         const double propagationTimeL = distToL / m_propagationVelocity; 
         const double propagationTimeR = distToR / m_propagationVelocity; 
  
         const double smearedTimeL = CLHEP::RandGaussZiggurat::shoot(rndEngine, propagationTimeL, m_stripTimeResolution); 
         const double smearedTimeR = CLHEP::RandGaussZiggurat::shoot(rndEngine, propagationTimeR, m_stripTimeResolution);     
         
         const double smearedDeltaT = smearedTimeR - smearedTimeL;
  
         /*
             |--- d1, t1 ---||--- d1, t1 ---||-- d --|                      For t2 > t1: 
             ||||||||||||||||X|||||||||||||||||||||||| <- RPC strip,            deltaT = t2 - t1,  d1 = v_prop * t1 (likewise for d2), 
                         |-------- d2, t2 -------|    X is a hit             l = d1 + d2, d = d2 - d1 -> d = l - 2d1 = v_prop * deltaT                         
             |----------------- l -------------------|
                                                     Hence, d1 = 0.5 * (l - d) = 0.5 * (l - v_prop * deltaT)
  
             Then converting to coordinate system where  0 -> -0.5*l to match strip local coordinates
                                             d1 -> d1 = -0.5*l + 0.5* (l-d) = -0.5*d = -0.5 * v_pro*deltaT
         */
         const double smearedY =  -0.5 * m_propagationVelocity * smearedDeltaT; //in mm
         //If smearedDeltaT == 0 position is in the centre of the strip (0).
  
         const Amg::Vector2D locHitPos{smearedX, smearedY};
  
         if (!design.insideTrapezoid(locHitPos)) {
             ATH_MSG_VERBOSE("The hit "<<Amg::toString(locHitPos)<<" is outside of the trapezoid bounds for "
                             <<m_idHelperSvc->toStringGasGap(gasGapId));
             return false;
         }
  
         const int strip = design.stripNumber(locHitPos);
         if (strip < 0) {
             ATH_MSG_VERBOSE("Hit " << Amg::toString(locHitPos) << " cannot trigger any signal in a strip for "
                             << m_idHelperSvc->toStringGasGap(gasGapId) <<std::endl<<design);
             return false;
         }
  
  
         bool isValid{false};
         const Identifier digitId{id_helper.channelID(gasGapId, 
                                                      id_helper.doubletZ(gasGapId), 
                                                      id_helper.doubletPhi(gasGapId), 
                                                      id_helper.gasGap(gasGapId),
                                                      false, strip, isValid)};
         if (!isValid) {
             ATH_MSG_WARNING("Failed to create a valid strip "<<m_idHelperSvc->toStringGasGap(gasGapId)
                           <<", strip: "<<strip);
             return false;
         }
  
         const bool effiSignal1 = !effiMap ||  effiMap->getEfficiency(gasGapId) >= CLHEP::RandFlat::shoot(rndEngine,0.,1.);
         const bool effiSignal2 = !effiMap ||  effiMap->getEfficiency(gasGapId) >= CLHEP::RandFlat::shoot(rndEngine,0., 1.);
         if (effiSignal1) {
             outContainer.push_back(std::make_unique<RpcDigit>(digitId, hitTime + smearedTimeR, timeOverThreshold(rndEngine)));
         }
         if (effiSignal2) {
             outContainer.push_back(std::make_unique<RpcDigit>(digitId, hitTime + smearedTimeL, timeOverThreshold(rndEngine), true));
         }
         if (effiSignal1 || effiSignal2) {
             ++(m_acceptedHits[false]);
             return true;
         }
         return false;
     }

◆ fetchCollection()

template<class DigitColl >

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

protectedinherited

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

privateinherited

Translates the PileUpHits into the timed hits format.

Definition at line 50 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::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.

49 { return m_filterPassed; }

◆ finalize()

StatusCode MuonR4::RpcFastDigiTool::finalize ( )

finaloverride

Definition at line 25 of file RpcFastDigiTool.cxx.

                                          {
         ATH_MSG_INFO("Tried to convert "<<m_allHits[0]<<"/"<<m_allHits[1]<<" hits. In, "
                     <<percentage(m_acceptedHits[0], m_allHits[0]) <<"/"
                     <<percentage(m_acceptedHits[1], m_allHits[1]) <<"% of the cases, the conversion was successful");
         return StatusCode::SUCCESS;
     }

◆ getGeoCtx()

const ActsGeometryContext & MuonR4::MuonDigitizationTool::getGeoCtx ( const EventContext & ctx ) const

protectedinherited

Returns the reference to the ActsGeometryContext needed to fetch global positions from the Readout geometry.

Definition at line 141 of file MuonDigitizationTool.cxx.

                                                                                             {
         const ActsGeometryContext* gctx{};
         if (!retrieveContainer(ctx, m_geoCtxKey, gctx).isSuccess()) {
             THROW_EXCEPTION("Failed to retrieve the geometry context "<<m_geoCtxKey.fullKey());
         }
         return *gctx;
     }

◆ getRandomEngine()

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

protectedinherited

Definition at line 135 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 )

staticprotectedinherited

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

Definition at line 69 of file MuonDigitizationTool.cxx.

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

◆ initialize()

StatusCode MuonR4::RpcFastDigiTool::initialize ( )

finaloverridevirtual

Reimplemented from MuonR4::MuonDigitizationTool.

Definition at line 18 of file RpcFastDigiTool.cxx.

                                            {
         ATH_CHECK(MuonDigitizationTool::initialize());
         ATH_CHECK(m_writeKey.initialize());
         ATH_CHECK(m_effiDataKey.initialize(!m_effiDataKey.empty()));
         m_stIdxBIL = m_idHelperSvc->rpcIdHelper().stationNameIndex("BIL");
         return StatusCode::SUCCESS;
     }

◆ mergeEvent()

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

finaloverrideinherited

Definition at line 98 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;
     }

◆ prepareEvent()

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

finaloverrideinherited

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

Not able to access SubEvents

Definition at line 41 of file MuonDigitizationTool.cxx.

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

◆ processAllSubEvents() [1/3]

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

inherited

Reentrant version of the digitization tool.

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

Definition at line 77 of file MuonDigitizationTool.cxx.

                                                                                       {
         PileUpHits hitCollList{};
         TimedHits timedHits{};
         if (!m_onlyUseContainerName) {            
             const xAOD::MuonSimHitContainer* hitCollection{nullptr};
             ATH_CHECK(retrieveContainer(ctx, m_simHitKey, hitCollection));
             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/3]

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

finaloverridevirtualinherited

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

Reimplemented from PileUpToolBase.

Definition at line 72 of file MuonDigitizationTool.cxx.

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

◆ processAllSubEvents() [3/3]

virtual StatusCode IPileUpTool::processAllSubEvents

inherited

dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface.

◆ processBunchXing()

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

finaloverridevirtualinherited

Reimplemented from PileUpToolBase.

Definition at line 114 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.

51 { m_filterPassed=true; }

◆ retrieveConditions()

template<class Container >

StatusCode MuonR4::MuonDigitizationTool::retrieveConditions	(	const EventContext &	ctx,
		const SG::ReadCondHandleKey< Container > &	key,
		const Container *&	contPtr
	)		const

protectedinherited

Helper function to access the conditions data.

If the key is empty, the conditions object is assigned to be a nullptr Otherwise, a failure is returned if the Conditions data are not available in the event.

◆ retrieveContainer()

template<class Container >

StatusCode MuonR4::MuonDigitizationTool::retrieveContainer	(	const EventContext &	ctx,
		const SG::ReadHandleKey< Container > &	key,
		const Container *&	contPtr
	)		const

protectedinherited

Helper function to retrieve a container from StoreGate.

If the readHandleKey is empty, the container is assigned to be a nullptr and the operation is marked as success. Otherwise, a failure is returned if the Container cannot be fetched from StoreGate

◆ timeOverThreshold()

double MuonR4::RpcFastDigiTool::timeOverThreshold ( CLHEP::HepRandomEngine * rndmEngine )

staticprivate

Roll the time over threshold for each signal digit.

Definition at line 220 of file RpcFastDigiTool.cxx.

                                                                               {
         //mn Time-over-threshold modeled as a narrow and a wide gaussian
         //mn based on the fit documented in https://its.cern.ch/jira/browse/ATLASRECTS-7820
         constexpr double tot_mean_narrow = 16.;
         constexpr double tot_sigma_narrow = 2.;
         constexpr double tot_mean_wide = 15.;
         constexpr double tot_sigma_wide = 4.5;
  
         double thetot = 0.;
  
         if (CLHEP::RandFlat::shoot(rndmEngine)<0.75) {
           thetot = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tot_mean_narrow, tot_sigma_narrow);
         } else {
           thetot = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tot_mean_wide, tot_sigma_wide);
         }
  
         return std::max(thetot, 0.);
     }

◆ 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

protectedinherited

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

◆ ATLAS_THREAD_SAFE [1/2]

std::array<std::atomic<unsigned>, 2> m_allHits MuonR4::RpcFastDigiTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 75 of file RpcFastDigiTool.h.

◆ ATLAS_THREAD_SAFE [2/2]

std::array<std::atomic<unsigned>, 2> m_acceptedHits MuonR4::RpcFastDigiTool::ATLAS_THREAD_SAFE {}

mutableprivate

Definition at line 76 of file RpcFastDigiTool.h.

◆ m_detMgr

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

protectedinherited

Definition at line 120 of file MuonDigitizationTool.h.

◆ m_effiDataKey

SG::ReadCondHandleKey<Muon::DigitEffiData> MuonR4::RpcFastDigiTool::m_effiDataKey

private

Initial value:

{this, "EffiDataKey", "RpcDigitEff",

"Efficiency constants of the individual Rpc gasGaps"}

Definition at line 72 of file RpcFastDigiTool.h.

◆ m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

◆ 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.

◆ m_geoCtxKey

SG::ReadHandleKey<ActsGeometryContext> MuonR4::MuonDigitizationTool::m_geoCtxKey

privateinherited

Initial value:

{this, "AlignmentKey", "ActsAlignment",

"Geometry context"}

Definition at line 132 of file MuonDigitizationTool.h.

◆ m_idHelperSvc

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

protectedinherited

Initial value:

{this, "MuonIdHelperSvc",

"Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 122 of file MuonDigitizationTool.h.

◆ m_includePileUpTruth

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

privateinherited

Definition at line 146 of file MuonDigitizationTool.h.

◆ m_inputObjectName

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

privateinherited

Definition at line 148 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.

◆ m_mergeSvc

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

privateinherited

Definition at line 135 of file MuonDigitizationTool.h.

◆ m_onlyUseContainerName

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

privateinherited

Initial value:

{this, "OnlyUseContainerName", false,

"Don't use the ReadHandleKey directly. Just extract the container name from it."}

Definition at line 143 of file MuonDigitizationTool.h.

◆ m_propagationVelocity

Gaudi::Property<double> MuonR4::RpcFastDigiTool::m_propagationVelocity

private

Initial value:

{this, "propSpeed", 0.5 * Gaudi::Units::c_light,

"Propagation speed of the signal inside the strip"}

Definition at line 78 of file RpcFastDigiTool.h.

◆ m_rndmSvc

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

privateinherited

Definition at line 139 of file MuonDigitizationTool.h.

◆ m_sdoKey

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

privateinherited

Definition at line 141 of file MuonDigitizationTool.h.

◆ m_simHitKey

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

privateinherited

Definition at line 130 of file MuonDigitizationTool.h.

◆ m_simHits

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

privateinherited

Definition at line 154 of file MuonDigitizationTool.h.

◆ m_stIdxBIL

int MuonR4::RpcFastDigiTool::m_stIdxBIL {-1}

private

Definition at line 28 of file RpcFastDigiTool.h.

◆ m_streamName

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

privateinherited

Definition at line 137 of file MuonDigitizationTool.h.

◆ m_stripTimeResolution

Gaudi::Property<double> MuonR4::RpcFastDigiTool::m_stripTimeResolution

private

Initial value:

{this, "timeResolution", 0.6 * Gaudi::Units::nanosecond,

"Estimated time resolution of the strip readout"}

Definition at line 81 of file RpcFastDigiTool.h.

◆ m_timedHits

TimedHits MuonR4::MuonDigitizationTool::m_timedHits {}

privateinherited

Definition at line 150 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.

◆ m_writeKey

SG::WriteHandleKey<RpcDigitContainer> MuonR4::RpcFastDigiTool::m_writeKey {this, "OutputObjectName", "RPC_DIGITS"}

private

Definition at line 70 of file RpcFastDigiTool.h.

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

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

structors and AlgTool implementation

Detailed Description

Member Typedef Documentation

◆ DigiCache

◆ OutDigitCache_t

◆ PileUpHits

◆ SimHitLocalCopy

◆ TimedHit

◆ TimedHits

Constructor & Destructor Documentation

◆ RpcFastDigiTool()

Member Function Documentation

◆ addSDO()

◆ digitize()

◆ digitizeHit() [1/2]

◆ digitizeHit() [2/2]

◆ fetchCollection()

◆ fillTimedHits()

◆ filterPassed()

◆ finalize()

◆ getGeoCtx()

◆ getRandomEngine()

◆ hitTime()

◆ initialize()

◆ mergeEvent()

◆ prepareEvent()

◆ processAllSubEvents() [1/3]

◆ processAllSubEvents() [2/3]

◆ processAllSubEvents() [3/3]

◆ processBunchXing()

◆ resetFilter()

◆ retrieveConditions()

◆ retrieveContainer()

◆ timeOverThreshold()

◆ toProcess()

◆ writeDigitContainer()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

◆ ATLAS_THREAD_SAFE [2/2]

◆ m_detMgr

◆ m_effiDataKey

◆ m_filterPassed

◆ m_firstXing

◆ m_geoCtxKey

◆ m_idHelperSvc

◆ m_includePileUpTruth

◆ m_inputObjectName

◆ m_lastXing

◆ m_mergeSvc

◆ m_onlyUseContainerName

◆ m_propagationVelocity

◆ m_rndmSvc

◆ m_sdoKey

◆ m_simHitKey

◆ m_simHits

◆ m_stIdxBIL

◆ m_streamName

◆ m_stripTimeResolution

◆ m_timedHits

◆ m_vetoPileUpTruthLinks

◆ m_writeKey