ATLAS Offline Software
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 | List of all members
MuonR4::RpcFastDigiTool Class Referencefinal

#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...
 
 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. More...
 
using DeadTimeMap = std::unordered_map< Identifier, double >
 

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
 
xAOD::MuonSimHitaddSDO (const TimedHit &hit, xAOD::MuonSimHitContainer *sdoContainer) const
 Adds the timed simHit to the output SDO container. More...
 
const ActsGeometryContextgetGeoCtx (const EventContext &ctx) const
 Returns the reference to the ActsGeometryContext needed to fetch global positions from the Readout geometry. 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...
 
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. More...
 

Protected Attributes

const MuonGMR4::MuonDetectorManagerm_detMgr {nullptr}
 
ServiceHandle< Muon::IMuonIdHelperSvcm_idHelperSvc
 

Private Types

using EdgeSide = MuonGMR4::RpcReadoutElement::EdgeSide
 
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::RpcReadoutElement &reEle, const double hitTime, const Amg::Vector2D &locPos, const Muon::DigitEffiData *effiMap, RpcDigitCollection &outContainer, CLHEP::HepRandomEngine *rndEngine, DeadTimeMap &deadTimes) const
 Digitize the sim hit as Rpc strip 1D hit. More...
 
bool digitizeHitBI (const Identifier &gasGapId, const MuonGMR4::RpcReadoutElement &reEle, const double hitTime, const Amg::Vector2D &locPos, const Muon::DigitEffiData *effiMap, RpcDigitCollection &outContainer, CLHEP::HepRandomEngine *rndEngine, DeadTimeMap &deadTimes) 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}
 
int m_stIdxBIS {-1}
 
SG::WriteHandleKey< RpcDigitContainerm_writeKey {this, "OutputObjectName", "RPC_DIGITS"}
 
SG::ReadCondHandleKey< Muon::DigitEffiDatam_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
 
Gaudi::Property< double > m_deadTime {this, "deadTime", 100.*Gaudi::Units::nanosecond}
 
Gaudi::Property< bool > m_digitizeMuonOnly
 
SG::ReadHandleKey< xAOD::MuonSimHitContainerm_simHitKey {this, "SimHitKey", ""}
 
SG::ReadHandleKey< ActsGeometryContextm_geoCtxKey
 
ServiceHandle< PileUpMergeSvcm_mergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}
 
Gaudi::Property< std::string > m_streamName {this, "StreamName", ""}
 
ServiceHandle< IAthRNGSvcm_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
 
SG::WriteHandleKey< xAOD::MuonSimHitContainerm_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< SimHitLocalCopym_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 16 of file RpcFastDigiTool.h.

Member Typedef Documentation

◆ DeadTimeMap

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

Definition at line 100 of file MuonDigitizationTool.h.

◆ DigiCache

Definition at line 74 of file RpcFastDigiTool.h.

◆ EdgeSide

Definition at line 29 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 80 of file MuonDigitizationTool.h.

◆ PileUpHits

Definition at line 116 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 143 of file MuonDigitizationTool.h.

◆ TimedHit

Definition at line 57 of file MuonDigitizationTool.h.

◆ TimedHits

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

Definition at line 58 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 18 of file RpcFastDigiTool.cxx.

18  :
19  MuonDigitizationTool{type,name, pIID} {}

Member Function Documentation

◆ addSDO()

xAOD::MuonSimHit * 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 142 of file MuonDigitizationTool.cxx.

143  {
144  if(!sdoContainer) {
145  ATH_MSG_VERBOSE("No SDO container setup of writing");
146  return nullptr;
147  }
148  if (!m_includePileUpTruth && HepMC::ignoreTruthLink(hit->genParticleLink(), m_vetoPileUpTruthLinks)) {
149  ATH_MSG_VERBOSE("Hit "<<m_idHelperSvc->toString(hit->identify())<<" is a pile-up truth link");
150  return nullptr;
151  }
152  ATH_MSG_VERBOSE(m_idHelperSvc->toString(hit->identify())<<", pdgID: "<<hit->pdgId()<< " genParticleLink :"<<hit->genParticleLink());
153  ATH_MSG_VERBOSE("Genparticle: "<<hit->genParticleLink());
154  xAOD::MuonSimHit* sdoHit = sdoContainer->push_back(std::make_unique<xAOD::MuonSimHit>());
155  (*sdoHit) = (*hit);
156  static const SG::Accessor<float> acc_eventTime{"MuSim_evtTime"};
157  static const SG::Accessor<unsigned short> acc_eventID{"MuSim_evtID"};
158  static const SG::Accessor<unsigned short> acc_puType{"MuSim_puType"};
159  acc_eventTime(*sdoHit) = hit.eventTime();
160  acc_eventID(*sdoHit) = hit.eventId();
161  acc_puType(*sdoHit) = hit.pileupType();
162  return sdoHit;
163  }

◆ 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

Standard digitization path

We need to rotate the local frame in order to be consistent with the Identifier

Write everything at the end into the final digit container

Implements MuonR4::MuonDigitizationTool.

Definition at line 35 of file RpcFastDigiTool.cxx.

37  {
38  const RpcIdHelper& idHelper{m_idHelperSvc->rpcIdHelper()};
39  // Prepare the temporary cache
40  DigiCache digitCache{};
42  const Muon::DigitEffiData* efficiencyMap{nullptr};
43  ATH_CHECK(SG::get(efficiencyMap, m_effiDataKey, ctx));
44 
45  CLHEP::HepRandomEngine* rndEngine = getRandomEngine(ctx);
46  xAOD::ChamberViewer viewer{hitsToDigit, m_idHelperSvc.get()};
47  do {
48  DeadTimeMap deadTimes{};
49  for (const TimedHit& simHit : viewer) {
50  if (m_digitizeMuonOnly && !MC::isMuon(simHit)){
51  continue;
52  }
53  const Identifier hitId{simHit->identify()};
54 
55  const MuonGMR4::RpcReadoutElement* readOutEle = m_detMgr->getRpcReadoutElement(hitId);
56  const Amg::Vector3D locPos{xAOD::toEigen(simHit->localPosition())};
57  RpcDigitCollection* digiColl = fetchCollection(hitId, digitCache);
58  bool run4_BIS = ((m_idHelperSvc->stationName(hitId) == m_stIdxBIS) && (abs(m_idHelperSvc->stationEta(hitId)) < 7));
59  if ((m_idHelperSvc->stationName(hitId) != m_stIdxBIL) && !(run4_BIS)) {
61  const bool digitizedEta = digitizeHit(hitId, false, *readOutEle,
62  hitTime(simHit), locPos.block<2,1>(0,0),
63  efficiencyMap, *digiColl, rndEngine, deadTimes);
64 
65  const bool digitizedPhi = digitizeHit(hitId, true, *readOutEle, hitTime(simHit),
66  etaToPhi*locPos.block<2,1>(0,0),
67  efficiencyMap, *digiColl, rndEngine, deadTimes);
68  if (digitizedEta) {
69  xAOD::MuonSimHit* sdo = addSDO(simHit, sdoContainer);
70  const Identifier digitId{(*digiColl)[digiColl->size() -1 - digitizedPhi]->identify()};
71  sdo->setIdentifier(digitId);
72  } else if (digitizedPhi) {
73  xAOD::MuonSimHit* sdo = addSDO(simHit, sdoContainer);
75  Amg::Vector3D phiPos{locPos};
76  phiPos.block<2,1>(0,0) = etaToPhi * phiPos.block<2,1>(0,0);
77  Amg::Vector3D locDir{xAOD::toEigen(simHit->localDirection())};
78  locDir.block<2,1>(0,0) = etaToPhi * locDir.block<2,1>(0,0);
79  const Identifier digitId{(*digiColl)[digiColl->size() -1]->identify()};
80  sdo->setIdentifier(digitId);
82  sdo->setLocalPosition(xAOD::toStorage(phiPos));
83  }
84  } else if (digitizeHitBI(hitId, *readOutEle, hitTime(simHit), locPos.block<2,1>(0,0),
85  efficiencyMap, *digiColl, rndEngine, deadTimes)) {
86  xAOD::MuonSimHit* sdo = addSDO(simHit, sdoContainer);
87  const Identifier digitId{(*digiColl)[digiColl->size() -1]->identify()};
88  sdo->setIdentifier(digitId);
89  }
90  }
91  } while (viewer.next());
93  ATH_CHECK(writeDigitContainer(ctx, m_writeKey, std::move(digitCache), idHelper.module_hash_max()));
94  return StatusCode::SUCCESS;
95  }

◆ digitizeHit()

bool MuonR4::RpcFastDigiTool::digitizeHit ( const Identifier gasGapId,
const bool  measuresPhi,
const MuonGMR4::RpcReadoutElement reEle,
const double  hitTime,
const Amg::Vector2D locPos,
const Muon::DigitEffiData effiMap,
RpcDigitCollection outContainer,
CLHEP::HepRandomEngine *  rndEngine,
DeadTimeMap deadTimes 
) const
private

Digitize the sim hit as Rpc strip 1D hit.


Parameters
gasGapIdIdentifier of the associated gasGap
measuresPhiProcess a phi or an eta strip
designPtrPointer to the striplayout of the gasGap
hitTimeGlobal time of the hit
locPosOnStripLocal position of the hit perpendicular to the strip plane
effiMapPointer to an efficiency look-up table
outContainerDigitCollection to push the new digit into
rndEngineRandom engine used for smearing
deadTimesReference to the last digitized times in order to apply the dead time model

Final check whether the digit is actually efficient

Correct for the signal propagation time

Definition at line 96 of file RpcFastDigiTool.cxx.

104  {
105 
106  ++(m_allHits[measuresPhi]);
107  const MuonGMR4::StripDesign& design{measuresPhi ? *reEle.getParameters().phiDesign
108  : *reEle.getParameters().etaDesign};
109 
110  const double uncert = design.stripPitch() / std::sqrt(12.);
111  const double smearedX = CLHEP::RandGaussZiggurat::shoot(rndEngine, locPos.x(), uncert);
112  const Amg::Vector2D locHitPos{smearedX, locPos.y()};
113 
114  if (!design.insideTrapezoid(locHitPos)) {
115  ATH_MSG_VERBOSE("The hit "<<Amg::toString(locHitPos)<<" is outside of the trapezoid bounds for "
116  <<m_idHelperSvc->toStringGasGap(gasGapId)<<", measuresPhi: "<<(measuresPhi ? "yay" : "nay"));
117  return false;
118  }
119  const int strip = design.stripNumber(locHitPos);
120  if (strip < 0) {
121  ATH_MSG_VERBOSE("Hit " << Amg::toString(locHitPos) << " cannot trigger any signal in a strip for "
122  << m_idHelperSvc->toStringGasGap(gasGapId) <<std::endl<<design<<
123  std::endl<<", measuresPhi: "<<(measuresPhi ? "yay" : "nay"));
124  return false;
125  }
126 
127  const RpcIdHelper& id_helper{m_idHelperSvc->rpcIdHelper()};
128 
129  bool isValid{false};
130  const Identifier digitId{id_helper.channelID(gasGapId,
131  id_helper.doubletZ(gasGapId),
132  id_helper.doubletPhi(gasGapId),
133  id_helper.gasGap(gasGapId),
134  measuresPhi, strip, isValid)};
135 
136  if (!isValid) {
137  ATH_MSG_WARNING("Invalid hit identifier obtained for "<<m_idHelperSvc->toStringGasGap(gasGapId)
138  <<", eta strip "<<strip<<" & hit "<<Amg::toString(locHitPos,2 )
139  <<" /// "<<design);
140  return false;
141  }
143  if (effiMap && effiMap->getEfficiency(digitId) < CLHEP::RandFlat::shoot(rndEngine,0.,1.)) {
144  ATH_MSG_VERBOSE("Hit is marked as inefficient");
145  return false;
146  }
147 
148  if (!passDeadTime(digitId, hitTime, m_deadTime, deadTimes)) {
149  ATH_MSG_VERBOSE("Reject hit due to dead map constraint");
150  return false;
151  }
153  const double signalTime = hitTime + reEle.distanceToEdge(reEle.measurementHash(digitId),
155  const double digitTime = CLHEP::RandGaussZiggurat::shoot(rndEngine, signalTime, m_stripTimeResolution);
156  outContainer.push_back(std::make_unique<RpcDigit>(digitId, digitTime, timeOverThreshold(rndEngine)));
157  ++(m_acceptedHits[measuresPhi]);
158  return true;
159  }

◆ digitizeHitBI()

bool MuonR4::RpcFastDigiTool::digitizeHitBI ( const Identifier gasGapId,
const MuonGMR4::RpcReadoutElement reEle,
const double  hitTime,
const Amg::Vector2D locPos,
const Muon::DigitEffiData effiMap,
RpcDigitCollection outContainer,
CLHEP::HepRandomEngine *  rndEngine,
DeadTimeMap deadTimes 
) const
private

Digitize the sim hit as Rpc strip 2D hit.


Parameters
gasGapIdIdentifier of the associated gasGap
designPtrPointer to the striplayout of the gasGap
hitTimeGlobal time of the hit
locPosLocal position of the hit inside the strip plane
effiMapPointer to an efficiency look-up table
outContainerDigitCollection to push the new digit into
rndEngineRandom engine used for smearing
deadTimesReference to the last digitized times in order to apply the dead time model

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 160 of file RpcFastDigiTool.cxx.

167  {
168 
169  ++(m_allHits[false]);
170  const MuonGMR4::StripDesign& design{*reEle.getParameters().etaDesign};
171  const RpcIdHelper& id_helper{m_idHelperSvc->rpcIdHelper()};
172 
173 
175  const double uncert = design.stripPitch() / std::sqrt(12.);
176  const double smearedX = CLHEP::RandGaussZiggurat::shoot(rndEngine, locPos.x(), uncert);
177 
179  // True propagation time in nanoseconds along strip to y=-stripLength/2 (L) and y=stripLength/2 (R)
180  const IdentifierHash layHash = reEle.layerHash(gasGapId);
181  const double propagationTimeL = reEle.distanceToEdge(layHash, locPos, EdgeSide::readOut) / m_propagationVelocity;
182  const double propagationTimeR = reEle.distanceToEdge(layHash, locPos, EdgeSide::highVoltage)/ m_propagationVelocity;
183 
185  const double smearedTimeL = CLHEP::RandGaussZiggurat::shoot(rndEngine, propagationTimeL, m_stripTimeResolution);
186  const double smearedTimeR = CLHEP::RandGaussZiggurat::shoot(rndEngine, propagationTimeR, m_stripTimeResolution);
187 
188  const double smearedDeltaT = smearedTimeR - smearedTimeL;
189 
190  /*
191  |--- d1, t1 ---||--- d1, t1 ---||-- d --| For t2 > t1:
192  ||||||||||||||||X|||||||||||||||||||||||| <- RPC strip, deltaT = t2 - t1, d1 = v_prop * t1 (likewise for d2),
193  |-------- d2, t2 -------| X is a hit l = d1 + d2, d = d2 - d1 -> d = l - 2d1 = v_prop * deltaT
194  |----------------- l -------------------|
195  Hence, d1 = 0.5 * (l - d) = 0.5 * (l - v_prop * deltaT)
196 
197  Then converting to coordinate system where 0 -> -0.5*l to match strip local coordinates
198  d1 -> d1 = -0.5*l + 0.5* (l-d) = -0.5*d = -0.5 * v_pro*deltaT
199  */
200  const double smearedY = -0.5 * m_propagationVelocity * smearedDeltaT; //in mm
201  //If smearedDeltaT == 0 position is in the centre of the strip (0).
202 
203  const Amg::Vector2D locHitPos{smearedX, smearedY};
204 
205  if (!design.insideTrapezoid(locHitPos)) {
206  ATH_MSG_VERBOSE("The hit "<<Amg::toString(locHitPos)<<" is outside of the trapezoid bounds for "
207  <<m_idHelperSvc->toStringGasGap(gasGapId));
208  return false;
209  }
210 
211  const int strip = design.stripNumber(locHitPos);
212  if (strip < 0) {
213  ATH_MSG_VERBOSE("Hit " << Amg::toString(locHitPos) << " cannot trigger any signal in a strip for "
214  << m_idHelperSvc->toStringGasGap(gasGapId) <<std::endl<<design);
215  return false;
216  }
217 
218 
219  bool isValid{false};
220  const Identifier digitId{id_helper.channelID(gasGapId,
221  id_helper.doubletZ(gasGapId),
222  id_helper.doubletPhi(gasGapId),
223  id_helper.gasGap(gasGapId),
224  false, strip, isValid)};
225  if (!isValid) {
226  ATH_MSG_WARNING("Failed to create a valid strip "<<m_idHelperSvc->toStringGasGap(gasGapId)
227  <<", strip: "<<strip);
228  return false;
229  }
230  if (!passDeadTime(digitId, hitTime, m_deadTime, deadTimes)) {
231  ATH_MSG_VERBOSE("Reject hit due to dead map constraint");
232  return false;
233  }
234  ATH_MSG_VERBOSE("Digitize hit "<<m_idHelperSvc->toString(digitId)<<" located at: "<<Amg::toString(locHitPos));
236  const bool effiSignal1 = !effiMap || effiMap->getEfficiency(gasGapId) >= CLHEP::RandFlat::shoot(rndEngine,0., 1.);
237  const bool effiSignal2 = !effiMap || effiMap->getEfficiency(gasGapId) >= CLHEP::RandFlat::shoot(rndEngine,0., 1.);
238  if (effiSignal1) {
239  outContainer.push_back(std::make_unique<RpcDigit>(digitId, hitTime + smearedTimeR, timeOverThreshold(rndEngine)));
240  }
241  if (effiSignal2) {
242  outContainer.push_back(std::make_unique<RpcDigit>(digitId, hitTime + smearedTimeL, timeOverThreshold(rndEngine), true));
243  }
244  if (effiSignal1 || effiSignal2) {
245  ++(m_acceptedHits[false]);
246  return true;
247  }
248  return false;
249  }

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

44  {
45  for (const auto& [timeIndex, simHitColl] : hitColl) {
46  timedHits.reserve(timedHits.capacity() + simHitColl->size());
47  for (const xAOD::MuonSimHit* simHit : *simHitColl) {
48  timedHits.emplace_back(timeIndex.time(), timeIndex.index(), simHit, timeIndex.type());
49  }
50  }
51  std::stable_sort(timedHits.begin(), timedHits.end(),
52  [](const TimedHit& a, const TimedHit& b){
53  if (a->identify() != b->identify()){
54  return a->identify() < b->identify();
55  }
56  if (a.eventId() != b.eventId()) {
57  return a.eventId() < b.eventId();
58  }
59  return a.eventTime() < b.eventTime();
60  });
61  return StatusCode::SUCCESS;
62  }

◆ 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 29 of file RpcFastDigiTool.cxx.

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

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

135  {
136  const ActsGeometryContext* gctx{};
137  if (!SG::get(gctx, m_geoCtxKey, ctx).isSuccess()) {
138  THROW_EXCEPTION("Failed to retrieve the geometry context "<<m_geoCtxKey.fullKey());
139  }
140  return *gctx;
141  }

◆ getRandomEngine()

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

Definition at line 129 of file MuonDigitizationTool.cxx.

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

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

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

◆ initialize()

StatusCode MuonR4::RpcFastDigiTool::initialize ( )
finaloverridevirtual

Reimplemented from MuonR4::MuonDigitizationTool.

Definition at line 21 of file RpcFastDigiTool.cxx.

21  {
25  m_stIdxBIL = m_idHelperSvc->rpcIdHelper().stationNameIndex("BIL");
26  m_stIdxBIS = m_idHelperSvc->rpcIdHelper().stationNameIndex("BIS");
27  return StatusCode::SUCCESS;
28  }

◆ mergeEvent()

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

Definition at line 92 of file MuonDigitizationTool.cxx.

92  {
93  ATH_MSG_DEBUG("mergeEvent()");
94 
96  if (!m_sdoKey.empty()) {
98  ATH_CHECK(sdoContainer.record(std::make_unique<xAOD::MuonSimHitContainer>(),
99  std::make_unique<xAOD::MuonSimHitAuxContainer>()));
100  }
101  ATH_CHECK(digitize(ctx, m_timedHits, !m_sdoKey.empty() ? sdoContainer.ptr() : nullptr));
102  m_timedHits.clear();
103  m_simHits.clear();
104  return StatusCode::SUCCESS;
105  }

◆ passDeadTime()

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

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.

167  {
168  auto insertItr = deadTimeMap.insert(std::make_pair(channelId,hitTime));
170  if (insertItr.second) {
171  return true;
172  }
173  if (hitTime - insertItr.first->second < deadTimeWindow) {
174  return false;
175  }
177  insertItr.first->second = hitTime;
178  return true;
179  }

◆ PileUpToolBase()

PileUpToolBase::PileUpToolBase
inherited

Definition at line 22 of file PileUpToolBase.cxx.

10  : base_class(type, name, parent)
11 {
12 }

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

36  {
37 
38  ATH_MSG_DEBUG("prepareEvent() called for " << nInputEvents << " input events");
39  m_timedHits.clear();
40  m_simHits.clear();
41  return StatusCode::SUCCESS;
42  }

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

71  {
72  PileUpHits hitCollList{};
73  TimedHits timedHits{};
75  if (!m_onlyUseContainerName) {
76  const xAOD::MuonSimHitContainer* hitCollection{nullptr};
77  ATH_CHECK(SG::get(hitCollection, m_simHitKey, ctx));
78  hitCollList.emplace_back(PileUpTimeEventIndex(0), hitCollection);
79  } else {
80  ATH_CHECK(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList));
81  }
82  ATH_CHECK(fillTimedHits(std::move(hitCollList), timedHits));
84  if (!m_sdoKey.empty()) {
86  ATH_CHECK(sdoContainer.record(std::make_unique<xAOD::MuonSimHitContainer>(),
87  std::make_unique<xAOD::MuonSimHitAuxContainer>()));
88  }
89  ATH_CHECK(digitize(ctx, timedHits, !m_sdoKey.empty() ? sdoContainer.ptr() : nullptr));
90  return StatusCode::SUCCESS;
91  }

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

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

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

110  {
111  ATH_MSG_DEBUG("processBunchXing()" << bunchXing);
112  PileUpHits hitList{}, hitListPermanent{};
113  ATH_CHECK(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitList, bunchXing, bSubEvents, eSubEvents));
114  ATH_MSG_VERBOSE(hitList.size() << " hits in xAODMuonSimHitContainer " << m_inputObjectName << " found");
115  for (auto& [hitPtr, hitContainer] : hitList) {
116  auto copyContainer = std::make_unique<xAOD::MuonSimHitContainer>();
117  auto copyAuxContainer = std::make_unique<xAOD::MuonSimHitAuxContainer>();
118  copyContainer->setStore(copyAuxContainer.get());
119  for (const xAOD::MuonSimHit* copyMe : *hitContainer) {
120  (*copyContainer->push_back(std::make_unique<xAOD::MuonSimHit>())) = (*copyMe);
121  }
122  hitListPermanent.emplace_back(hitPtr, copyContainer.get());
123  m_simHits.emplace_back(std::move(copyContainer), std::move(copyAuxContainer));
124  }
125  ATH_CHECK(fillTimedHits(std::move(hitListPermanent), m_timedHits));
126  return StatusCode::SUCCESS;
127  }

◆ 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; }

◆ timeOverThreshold()

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

Roll the time over threshold for each signal digit.

Definition at line 250 of file RpcFastDigiTool.cxx.

250  {
251  //mn Time-over-threshold modeled as a narrow and a wide gaussian
252  //mn based on the fit documented in https://its.cern.ch/jira/browse/ATLASRECTS-7820
253  constexpr double tot_mean_narrow = 16.;
254  constexpr double tot_sigma_narrow = 2.;
255  constexpr double tot_mean_wide = 15.;
256  constexpr double tot_sigma_wide = 4.5;
257 
258  double thetot = 0.;
259 
260  if (CLHEP::RandFlat::shoot(rndmEngine)<0.75) {
261  thetot = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tot_mean_narrow, tot_sigma_narrow);
262  } else {
263  thetot = CLHEP::RandGaussZiggurat::shoot(rndmEngine, tot_mean_wide, tot_sigma_wide);
264  }
265 
266  return std::max(thetot, 0.);
267  }

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

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

◆ 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 80 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 81 of file RpcFastDigiTool.h.

◆ m_deadTime

Gaudi::Property<double> MuonR4::RpcFastDigiTool::m_deadTime {this, "deadTime", 100.*Gaudi::Units::nanosecond}
private

Definition at line 89 of file RpcFastDigiTool.h.

◆ m_detMgr

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

Definition at line 111 of file MuonDigitizationTool.h.

◆ m_digitizeMuonOnly

Gaudi::Property<bool> MuonR4::RpcFastDigiTool::m_digitizeMuonOnly
private
Initial value:
{this, "ProcessTrueMuonsOnly", false,
"If set to true hit with pdgId != 13 are skipped"}

Definition at line 91 of file RpcFastDigiTool.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 77 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 123 of file MuonDigitizationTool.h.

◆ m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::MuonDigitizationTool::m_idHelperSvc
protectedinherited
Initial value:
{this, "MuonIdHelperSvc",
"Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Definition at line 113 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 137 of file MuonDigitizationTool.h.

◆ m_inputObjectName

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

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.

◆ m_mergeSvc

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

Definition at line 126 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 134 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 83 of file RpcFastDigiTool.h.

◆ m_rndmSvc

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

Definition at line 130 of file MuonDigitizationTool.h.

◆ m_sdoKey

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

Definition at line 132 of file MuonDigitizationTool.h.

◆ m_simHitKey

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

Definition at line 121 of file MuonDigitizationTool.h.

◆ m_simHits

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

Definition at line 145 of file MuonDigitizationTool.h.

◆ m_stIdxBIL

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

Definition at line 30 of file RpcFastDigiTool.h.

◆ m_stIdxBIS

int MuonR4::RpcFastDigiTool::m_stIdxBIS {-1}
private

Definition at line 31 of file RpcFastDigiTool.h.

◆ m_streamName

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

Definition at line 128 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 86 of file RpcFastDigiTool.h.

◆ m_timedHits

TimedHits MuonR4::MuonDigitizationTool::m_timedHits {}
privateinherited

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.

◆ m_writeKey

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

Definition at line 75 of file RpcFastDigiTool.h.


The documentation for this class was generated from the following files:
MuonR4::MuonDigitizationTool::m_inputObjectName
std::string m_inputObjectName
Definition: MuonDigitizationTool.h:139
ATHRNG::RNGWrapper::setSeed
void setSeed(const std::string &algName, const EventContext &ctx)
Set the random seed using a string (e.g.
Definition: RNGWrapper.h:169
MuonR4::MuonDigitizationTool::m_geoCtxKey
SG::ReadHandleKey< ActsGeometryContext > m_geoCtxKey
Definition: MuonDigitizationTool.h:123
MuonR4::MuonDigitizationTool::passDeadTime
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.
Definition: MuonDigitizationTool.cxx:164
xAOD::MuonSimHit_v1
Definition: MuonSimHit_v1.h:18
MuonR4::MuonDigitizationTool::m_simHitKey
SG::ReadHandleKey< xAOD::MuonSimHitContainer > m_simHitKey
Definition: MuonDigitizationTool.h:121
MuonGMR4::StripDesign
Definition: StripDesign.h:30
MuonR4::RpcFastDigiTool::m_effiDataKey
SG::ReadCondHandleKey< Muon::DigitEffiData > m_effiDataKey
Definition: RpcFastDigiTool.h:77
MuonR4::MuonDigitizationTool::fillTimedHits
StatusCode fillTimedHits(PileUpHits &&hitColl, TimedHits &timedHits) const
Translates the PileUpHits into the timed hits format.
Definition: MuonDigitizationTool.cxx:44
xAOD::MuonSimHit_v1::setIdentifier
void setIdentifier(const Identifier &id)
Sets the global ATLAS identifier.
Definition: xAODMuonSimHit_V1.cxx:43
MuonR4::RpcFastDigiTool::m_stripTimeResolution
Gaudi::Property< double > m_stripTimeResolution
Definition: RpcFastDigiTool.h:86
MuonR4::MuonDigitizationTool::m_streamName
Gaudi::Property< std::string > m_streamName
Definition: MuonDigitizationTool.h:128
MuonR4::MuonDigitizationTool::PileUpHits
PileUpMergeSvc::TimedList< xAOD::MuonSimHitContainer >::type PileUpHits
Definition: MuonDigitizationTool.h:116
PileUpToolBase::m_filterPassed
bool m_filterPassed
Definition: PileUpToolBase.h:60
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
SG::Accessor< float >
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
RpcDigitCollection
Definition: RpcDigitCollection.h:17
MuonR4::MuonDigitizationTool::m_onlyUseContainerName
Gaudi::Property< bool > m_onlyUseContainerName
Definition: MuonDigitizationTool.h:134
MuonR4::MuonDigitizationTool::m_mergeSvc
ServiceHandle< PileUpMergeSvc > m_mergeSvc
Definition: MuonDigitizationTool.h:126
MuonR4::MuonDigitizationTool::TimedHit
TimedHitPtr< xAOD::MuonSimHit > TimedHit
Definition: MuonDigitizationTool.h:57
MuonR4::RpcFastDigiTool::m_stIdxBIL
int m_stIdxBIL
Definition: RpcFastDigiTool.h:30
xAOD::toStorage
MeasVector< N > toStorage(const AmgVector(N)&amgVec)
Converts the double precision of the AmgVector into the floating point storage precision of the MeasV...
Definition: MeasurementDefs.h:69
MuonR4::MuonDigitizationTool::m_sdoKey
SG::WriteHandleKey< xAOD::MuonSimHitContainer > m_sdoKey
Definition: MuonDigitizationTool.h:132
MuonGMR4::RpcReadoutElement::parameterBook::etaDesign
StripDesignPtr etaDesign
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/RpcReadoutElement.h:39
xAOD::MuonSimHit_v1::setLocalPosition
void setLocalPosition(MeasVector< 3 > vec)
Sets the local position of the traversing particle.
Definition: xAODMuonSimHit_V1.cxx:56
python.SystemOfUnits.nanosecond
float nanosecond
Definition: SystemOfUnits.py:134
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:867
PileUpToolBase::m_lastXing
Gaudi::Property< int > m_lastXing
Definition: PileUpToolBase.h:56
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
HepMC::ignoreTruthLink
bool ignoreTruthLink(const T &p, bool vetoPileUp)
Helper function for SDO creation in PileUpTools.
Definition: MagicNumbers.h:344
MuonR4::RpcFastDigiTool::DigiCache
OutDigitCache_t< RpcDigitCollection > DigiCache
Definition: RpcFastDigiTool.h:74
MuonGMR4::RpcReadoutElement
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/RpcReadoutElement.h:17
RpcIdHelper
Definition: RpcIdHelper.h:51
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
keylayer_zslicemap.strip
strip
Definition: keylayer_zslicemap.py:151
std::stable_sort
void stable_sort(std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, std::reverse_iterator< DataModel_detail::iterator< DVL > > end, Compare comp)
Specialization of stable_sort for DataVector/List.
Definition: DVL_algorithms.h:711
MuonGMR4::RpcReadoutElement::getParameters
const parameterBook & getParameters() const
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/RpcReadoutElement.cxx:33
PileUpToolBase::m_vetoPileUpTruthLinks
Gaudi::Property< int > m_vetoPileUpTruthLinks
Definition: PileUpToolBase.h:58
MuonR4::RpcFastDigiTool::m_deadTime
Gaudi::Property< double > m_deadTime
Definition: RpcFastDigiTool.h:89
xAOD::ChamberViewer
Definition: ChamberViewer.h:59
MuonR4::RpcFastDigiTool::m_digitizeMuonOnly
Gaudi::Property< bool > m_digitizeMuonOnly
Definition: RpcFastDigiTool.h:91
MuonR4::MuonDigitizationTool::m_timedHits
TimedHits m_timedHits
Definition: MuonDigitizationTool.h:141
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
MuonGMR4::RpcReadoutElement::parameterBook::phiDesign
StripDesignPtr phiDesign
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/RpcReadoutElement.h:38
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition: ReadCondHandle.h:287
MuonR4::RpcFastDigiTool::digitizeHitBI
bool digitizeHitBI(const Identifier &gasGapId, const MuonGMR4::RpcReadoutElement &reEle, const double hitTime, const Amg::Vector2D &locPos, const Muon::DigitEffiData *effiMap, RpcDigitCollection &outContainer, CLHEP::HepRandomEngine *rndEngine, DeadTimeMap &deadTimes) const
Digitize the sim hit as Rpc strip 2D hit.
Definition: RpcFastDigiTool.cxx:160
MuonR4::MuonDigitizationTool::digitize
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 technolog...
MuonR4::MuonDigitizationTool::getRandomEngine
CLHEP::HepRandomEngine * getRandomEngine(const EventContext &ctx) const
Definition: MuonDigitizationTool.cxx:129
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonR4::RpcFastDigiTool::m_writeKey
SG::WriteHandleKey< RpcDigitContainer > m_writeKey
Definition: RpcFastDigiTool.h:75
MuonR4::RpcFastDigiTool::m_stIdxBIS
int m_stIdxBIS
Definition: RpcFastDigiTool.h:31
Muon::DigitEffiData::getEfficiency
double getEfficiency(const Identifier &channelId, bool isInnerQ1=false) const
Returns the signal generation efficiency of the sTgc channel.
Definition: DigitEffiData.cxx:38
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MuonGMR4::RpcReadoutElement::measurementHash
IdentifierHash measurementHash(const Identifier &measId) const override final
Constructs the identifier hash from the full measurement Identifier.
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
CaloCondBlobAlgs_fillNoiseFromASCII.channelId
channelId
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:121
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
MuonR4::RpcFastDigiTool::m_propagationVelocity
Gaudi::Property< double > m_propagationVelocity
Definition: RpcFastDigiTool.h:83
Muon::DigitEffiData
Definition: DigitEffiData.h:23
MuonR4::MuonDigitizationTool::addSDO
xAOD::MuonSimHit * addSDO(const TimedHit &hit, xAOD::MuonSimHitContainer *sdoContainer) const
Adds the timed simHit to the output SDO container.
Definition: MuonDigitizationTool.cxx:142
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
MuonR4::MuonDigitizationTool::writeDigitContainer
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.
xAOD::MuonSimHit_v1::setLocalDirection
void setLocalDirection(MeasVector< 3 > vec)
Sets the local direction of the traversing particle.
Definition: xAODMuonSimHit_V1.cxx:62
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
MuonGMR4::RpcReadoutElement::layerHash
IdentifierHash layerHash(const Identifier &measId) const override final
python.PhysicalConstants.c_light
float c_light
Definition: PhysicalConstants.py:73
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
THROW_EXCEPTION
#define THROW_EXCEPTION(MESSAGE)
Definition: throwExcept.h:10
python.copyTCTOutput.locDir
locDir
Definition: copyTCTOutput.py:112
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
MuonR4::MuonDigitizationTool::hitTime
static double hitTime(const TimedHit &hit)
Returns the global time of the hit which is the sum of eventTime & individual hit time.
Definition: MuonDigitizationTool.cxx:63
MuonR4::MuonDigitizationTool::initialize
StatusCode initialize() override
Definition: MuonDigitizationTool.cxx:11
MuonR4::MuonDigitizationTool::m_includePileUpTruth
Gaudi::Property< bool > m_includePileUpTruth
Definition: MuonDigitizationTool.h:137
MuonR4::MuonDigitizationTool::m_simHits
std::vector< SimHitLocalCopy > m_simHits
Definition: MuonDigitizationTool.h:145
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
a
TList * a
Definition: liststreamerinfos.cxx:10
MuonR4::MuonDigitizationTool::TimedHits
std::vector< TimedHitPtr< xAOD::MuonSimHit > > TimedHits
Definition: MuonDigitizationTool.h:58
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonR4::MuonDigitizationTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonDigitizationTool.h:113
PileUpToolBase::m_firstXing
Gaudi::Property< int > m_firstXing
Definition: PileUpToolBase.h:54
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
MuonR4::MuonDigitizationTool::m_rndmSvc
ServiceHandle< IAthRNGSvc > m_rndmSvc
Definition: MuonDigitizationTool.h:130
MuonR4::MuonDigitizationTool::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition: MuonDigitizationTool.h:111
MuonGMR4::RpcReadoutElement::EdgeSide::highVoltage
@ highVoltage
MuonR4::MuonDigitizationTool::DeadTimeMap
std::unordered_map< Identifier, double > DeadTimeMap
Definition: MuonDigitizationTool.h:100
MuonR4::RpcFastDigiTool::digitizeHit
bool digitizeHit(const Identifier &gasGapId, const bool measuresPhi, const MuonGMR4::RpcReadoutElement &reEle, const double hitTime, const Amg::Vector2D &locPos, const Muon::DigitEffiData *effiMap, RpcDigitCollection &outContainer, CLHEP::HepRandomEngine *rndEngine, DeadTimeMap &deadTimes) const
Digitize the sim hit as Rpc strip 1D hit.
Definition: RpcFastDigiTool.cxx:96
MuonGMR4::RpcReadoutElement::EdgeSide::readOut
@ readOut
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
MuonGMR4::RpcReadoutElement::distanceToEdge
double distanceToEdge(const IdentifierHash &measHash, const Amg::Vector2D &posInStripPlane, const EdgeSide side) const
Returns the disance to the readout.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/RpcReadoutElement.cxx:117
MuonR4::MuonDigitizationTool::fetchCollection
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 ...
PileUpTimeEventIndex
a struct encapsulating the identifier of a pile-up event
Definition: PileUpTimeEventIndex.h:12
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
MuonR4::RpcFastDigiTool::timeOverThreshold
static double timeOverThreshold(CLHEP::HepRandomEngine *rndmEngine)
Roll the time over threshold for each signal digit.
Definition: RpcFastDigiTool.cxx:250
isMuon
bool isMuon(const T &p)
Definition: AtlasPID.h:202
Identifier
Definition: IdentifierFieldParser.cxx:14