ATLAS Offline Software
Public Member Functions | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
MuonR4::sTgcFastDigiTool Class Referencefinal

#include <sTgcFastDigiTool.h>

Inheritance diagram for MuonR4::sTgcFastDigiTool:
Collaboration diagram for MuonR4::sTgcFastDigiTool:

Public Member Functions

 sTgcFastDigiTool (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 DigiCache = OutDigitCache_t< sTgcDigitCollection >
 
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 digitizeStrip (const EventContext &ctx, const TimedHit &timedHit, const NswErrorCalibData *errorCalibDB, const Muon::DigitEffiData *effiData, CLHEP::HepRandomEngine *rndEngine, sTgcDigitCollection &outCollection) const
 
bool digitizeWire (const EventContext &ctx, const TimedHit &timedHit, const Muon::DigitEffiData *effiData, CLHEP::HepRandomEngine *rndEngine, sTgcDigitCollection &outCollection) const
 
bool digitizePad (const EventContext &ctx, const TimedHit &timedHit, const Muon::DigitEffiData *effiData, CLHEP::HepRandomEngine *rndEngine, sTgcDigitCollection &outCollection) const
 
int associateBCIdTag (const EventContext &ctx, const TimedHit &timedHit) const
 : Associates the global bcIdTag to the digit More...
 
StatusCode fillTimedHits (PileUpHits &&hitColl, TimedHits &timedHits) const
 Translates the PileUpHits into the timed hits format. More...
 

Private Attributes

SG::WriteHandleKey< sTgcDigitContainerm_writeKey {this, "OutputObjectName", "sTGC_DIGITS"}
 
SG::ReadCondHandleKey< Muon::DigitEffiDatam_effiDataKey
 
SG::ReadCondHandleKey< NswErrorCalibDatam_uncertCalibKey
 
std::array< std::atomic< unsigned >, 3 > m_allHits ATLAS_THREAD_SAFE {}
 
std::array< std::atomic< unsigned >, 3 > m_acceptedHits ATLAS_THREAD_SAFE {}
 
Gaudi::Property< bool > m_digitizeStrip {this, "doStrips", true, "Digitize strip hits"}
 
Gaudi::Property< bool > m_digitizeWire {this, "doWires", true, "Digitize wire hits"}
 
Gaudi::Property< bool > m_digitizePads {this, "doPads", false, "Digitize pad hits"}
 
Gaudi::Property< double > m_deadTime {this, "deadTime", 300. * Gaudi::Units::ns}
 
Gaudi::Property< bool > m_digitizeMuonOnly
 
Gaudi::Property< double > m_energyDepositThreshold {this,"energyDepositThreshold",300.0*CLHEP::eV}
 
Gaudi::Property< double > m_limitElectronKineticEnergy {this,"limitElectronKineticEnergy",5.0*CLHEP::MeV}
 
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 14 of file sTgcFastDigiTool.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 54 of file sTgcFastDigiTool.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

◆ sTgcFastDigiTool()

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

Definition at line 17 of file sTgcFastDigiTool.cxx.

17  :
18  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  }

◆ associateBCIdTag()

int MuonR4::sTgcFastDigiTool::associateBCIdTag ( const EventContext &  ctx,
const TimedHit timedHit 
) const
private

: Associates the global bcIdTag to the digit

Parameters
ctxEventContext
timedHitHit to calculate the time from

To be implemented

Definition at line 299 of file sTgcFastDigiTool.cxx.

300  {
302  return 0;
303  }

◆ digitize()

StatusCode MuonR4::sTgcFastDigiTool::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

Write everything at the end into the final digit container

Implements MuonR4::MuonDigitizationTool.

Definition at line 37 of file sTgcFastDigiTool.cxx.

39  {
40  const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
41  // Prepare the temporary cache
42  DigiCache digitCache{};
44  const Muon::DigitEffiData* efficiencyMap{nullptr};
45  ATH_CHECK(SG::get(efficiencyMap, m_effiDataKey, ctx));
46  const NswErrorCalibData* nswUncertDB{nullptr};
47  ATH_CHECK(SG::get(nswUncertDB, m_uncertCalibKey, ctx));
48 
49  CLHEP::HepRandomEngine* rndEngine = getRandomEngine(ctx);
50  xAOD::ChamberViewer viewer{hitsToDigit, m_idHelperSvc.get()};
51  do {
52  for (const TimedHit& simHit : viewer) {
54  if (m_digitizeMuonOnly && !MC::isMuon(simHit)){
55  continue;
56  }
57 
58  if (simHit->energyDeposit() < m_energyDepositThreshold){
59  ATH_MSG_VERBOSE("Hit with Energy Deposit of " << simHit->energyDeposit()
60  << " less than " << m_energyDepositThreshold << ". Skip this hit." );
61  continue;
62  }
63 
64  const double hitKineticEnergy = simHit->kineticEnergy();
65  if (hitKineticEnergy < m_limitElectronKineticEnergy && MC::isElectron(simHit)) {
66  ATH_MSG_DEBUG("Skip electron hit with kinetic energy " << hitKineticEnergy
67  << ", which is less than the lower limit of " << m_limitElectronKineticEnergy);
68  continue;
69  }
70  sTgcDigitCollection* digiColl = fetchCollection(simHit->identify(), digitCache);
71  const bool digitizedStrip = digitizeStrip(ctx, simHit, nswUncertDB, efficiencyMap, rndEngine, *digiColl);
72  const bool digitizedWire = digitizeWire(ctx, simHit, efficiencyMap, rndEngine, *digiColl);
73  const bool digitizedPad = digitizePad(ctx, simHit, efficiencyMap, rndEngine, *digiColl);
74 
75  if (digitizedStrip) {
76  xAOD::MuonSimHit* sdo = addSDO(simHit, sdoContainer);
77  size_t stripIdx = digiColl->size() - 1 - digitizedWire - digitizedPad;
78  sdo->setIdentifier(digiColl->at(stripIdx)->identify());
79  } else if (digitizedWire || digitizedPad) {
80  xAOD::MuonSimHit* sdo = addSDO(simHit, sdoContainer);
81  sdo->setIdentifier(digiColl->at(digiColl->size() - 1)->identify());
82  const MuonGMR4::sTgcReadoutElement* re{m_detMgr->getsTgcReadoutElement(simHit->identify())};
83 
84  const Amg::Transform3D etaToPhi{re->globalToLocalTrans(getGeoCtx(ctx), re->layerHash(sdo->identify())) *
85  re->localToGlobalTrans(getGeoCtx(ctx), re->layerHash(simHit->identify()))};
86 
87  sdo->setLocalDirection(xAOD::toStorage(etaToPhi * xAOD::toEigen(sdo->localDirection())));
88  sdo->setLocalPosition(xAOD::toStorage(etaToPhi * xAOD::toEigen(sdo->localPosition())));
89  }
90  }
91  } while (viewer.next());
93  ATH_CHECK(writeDigitContainer(ctx, m_writeKey, std::move(digitCache),
94  idHelper.module_hash_max()));
95  return StatusCode::SUCCESS;
96  }

◆ digitizePad()

bool MuonR4::sTgcFastDigiTool::digitizePad ( const EventContext &  ctx,
const TimedHit timedHit,
const Muon::DigitEffiData effiData,
CLHEP::HepRandomEngine *  rndEngine,
sTgcDigitCollection outCollection 
) const
private

Sim hits are always expressed in the eta view of the gasGap...

Check efficiencies

Definition at line 305 of file sTgcFastDigiTool.cxx.

309  {
310 
311  if (!m_digitizePads) {
312  return false;
313  }
314 
315  ++m_allHits[channelType::Pad];
316 
317  const Identifier hitId{timedHit->identify()};
318  const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
319  const MuonGMR4::sTgcReadoutElement* readOutEle = m_detMgr->getsTgcReadoutElement(hitId);
320  const int gasGap = idHelper.gasGap(hitId);
321 
322 
324  // Rotate the sim hit into the wire view
325  const IdentifierHash stripLayHash{readOutEle->createHash(gasGap, channelType::Strip, 0)};
326  const IdentifierHash padLayerHash{readOutEle->createHash(gasGap, channelType::Pad, 0)};
327 
328  const ActsGeometryContext& gctx{getGeoCtx(ctx)};
329  const Amg::Transform3D toPad{readOutEle->globalToLocalTrans(gctx, padLayerHash) *
330  readOutEle->localToGlobalTrans(gctx, stripLayHash)};
331 
332  const Amg::Vector2D padPos{(toPad*xAOD::toEigen(timedHit->localPosition())).block<2,1>(0,0)};
334  const MuonGMR4::PadDesign& design{readOutEle->padDesign(padLayerHash)};
335 
336  const auto [padEta, padPhi] = design.channelNumber(padPos);
337  if (padEta < 0 || padPhi < 0) {
338  ATH_MSG_VERBOSE("The pad "<<Amg::toString(padPos)<<" in "<<m_idHelperSvc->toStringGasGap(hitId)
339  <<" is outside of the acceptance of "<<std::endl<<design);
340  return false;
341  }
342  bool isValid{false};
343  const Identifier padId = idHelper.padID(hitId, readOutEle->multilayer(),
344  gasGap, channelType::Pad, padEta, padPhi, isValid);
345 
346 
347  if (!isValid) {
348  ATH_MSG_WARNING("Failed to decuce a valid pad Identifier from "<<Amg::toString(padPos)
349  <<" in "<<m_idHelperSvc->toStringGasGap(hitId));
350  return false;
351  }
352 
354  bool isInnerQ1 = readOutEle->isEtaZero(readOutEle->measurementHash(hitId), padPos);
355  if (efficiencyMap && efficiencyMap->getEfficiency(hitId, isInnerQ1) < CLHEP::RandFlat::shoot(rndEngine,0.,1.)){
356  ATH_MSG_VERBOSE("Simulated pad hit "<<xAOD::toEigen(timedHit->localPosition())
357  << m_idHelperSvc->toString(hitId) <<" is rejected because of efficency modelling");
358  return false;
359  }
360 
361 
362 
363  outCollection.push_back(std::make_unique<sTgcDigit>(padId,
364  associateBCIdTag(ctx, timedHit),
365  hitTime(timedHit), 666, false, false));
366 
367  ++m_acceptedHits[channelType::Pad];
368 
369  return true;
370  }

◆ digitizeStrip()

bool MuonR4::sTgcFastDigiTool::digitizeStrip ( const EventContext &  ctx,
const TimedHit timedHit,
const NswErrorCalibData errorCalibDB,
const Muon::DigitEffiData effiData,
CLHEP::HepRandomEngine *  rndEngine,
sTgcDigitCollection outCollection 
) const
private

Check efficiencies

We're using the NSW uncertainty DB to smear the truth-hit positions using the best known uncertainties. In the process of digit -> RDO -> PRD, the smeared hit position is gonna be lost However, recall that the simplest way to generate a sTgc prd strip prd is the clustering by means of center of gravity. On average, a muon passage makes 3-4 strips to fire. Assuming 3 strips, the smeared position can be written as

        x = w_{1}*(c - p) + w_{2}*c + w_{3}*(c + p),

where c is the strip centre, p the pitch and w_{i} are the induced charge fractions on each strip

      1 =  w_{1} + w_{2} + w_{3}
      x = (w_{1} + w_{2} + w_{3}) * c + (w_{3} - w_{1})*p
         --> x = c + (w_{3} - w_{1}) *p
         --> (x-c) / p = (w_{3} - w_{1})  
         --> (x-c) / p + w_{1} = w_{3}

            1 =  2 * w_{1} + w_{2} + (x-c) / p
            1 - (x-c) /p - 2*w_{1} = w_{2}

            0< w_{1} < 0.5 - (x-c) / 2p  

Definition at line 97 of file sTgcFastDigiTool.cxx.

102  {
103 
104  if (!m_digitizeStrip) {
105  return false;
106  }
107  ++m_allHits[channelType::Strip];
108  const Identifier hitId{timedHit->identify()};
109  const MuonGMR4::sTgcReadoutElement* readOutEle{m_detMgr->getsTgcReadoutElement(hitId)};
110 
111  const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
112 
113  const int gasGap = idHelper.gasGap(hitId);
114  const MuonGMR4::StripDesign& design{readOutEle->stripDesign(hitId)};
115 
116  const Amg::Vector2D stripPos{xAOD::toEigen(timedHit->localPosition()).block<2,1>(0,0)};
117 
118  const int stripNum = design.stripNumber(stripPos);
119  if (stripNum < 0) {
120  ATH_MSG_VERBOSE("Strip hit "<<Amg::toString(stripPos)<<" "<<m_idHelperSvc->toStringGasGap(hitId)
121  <<" is out of range "<<std::endl<<design);
122  return false;
123  }
124 
125 
126  bool isValid{false};
127  const Identifier stripId = idHelper.channelID(hitId, readOutEle->multilayer(),
128  gasGap, channelType::Strip, stripNum, isValid);
129 
130  if (!isValid) {
131  ATH_MSG_WARNING("Failed to deduce a valid identifier from "
132  <<m_idHelperSvc->toStringGasGap(hitId)<<" strip: "<<stripNum);
133  return false;
134  }
135 
137  bool isInnerQ1 = readOutEle->isEtaZero(readOutEle->measurementHash(hitId), stripPos);
138  if (efficiencyMap && efficiencyMap->getEfficiency(hitId, isInnerQ1) < CLHEP::RandFlat::shoot(rndEngine,0.,1.)){
139  ATH_MSG_VERBOSE("Simulated strip hit "<<xAOD::toEigen(timedHit->localPosition())
140  << m_idHelperSvc->toString(hitId) <<" is rejected because of efficency modelling");
141  return false;
142  }
143 
144  NswErrorCalibData::Input errorCalibInput{};
145  errorCalibInput.stripId= stripId;
146  errorCalibInput.locTheta = M_PI - timedHit->localDirection().theta();
147  errorCalibInput.clusterAuthor = 3; // centroid
148 
149  const double uncert = errorCalibDB->clusterUncertainty(errorCalibInput);
150  const double smearedX = CLHEP::RandGaussZiggurat::shoot(rndEngine, stripPos.x(), uncert);
151 
152  const Amg::Vector2D digitPos{smearedX * Amg::Vector2D::UnitX()};
153 
154  const int digitStrip = design.stripNumber(digitPos);
155  if (digitStrip < 0) {
156  ATH_MSG_VERBOSE("Smeared strip hit "<<Amg::toString(digitPos)<<" "<<m_idHelperSvc->toStringGasGap(hitId)
157  <<" is out of range "<<std::endl<<design);
158  return false;
159  }
160  const Identifier digitId = idHelper.channelID(hitId, readOutEle->multilayer(),
161  gasGap, channelType::Strip, digitStrip, isValid);
162 
163  if (!isValid) {
164  ATH_MSG_WARNING("Failed to deduce a valid identifier from "
165  <<m_idHelperSvc->toStringGasGap(hitId)<<" digit: "<<digitStrip);
166  return false;
167  }
168  constexpr double dummyCharge = 66666;
189  const double pull = (smearedX - (*design.center(digitStrip)).x()) / design.stripPitch();
190  const double w1 = CLHEP::RandFlat::shoot(rndEngine, 0., 0.5 *(1. - pull));
191  const double w2 = 1. - pull -2.*w1;
192  const double w3 = pull + w1;
193 
194  if (digitStrip> 1) {
195  const Identifier stripIdB = idHelper.channelID(hitId, readOutEle->multilayer(),
196  gasGap, channelType::Strip, digitStrip -1);
197  outCollection.push_back(std::make_unique<sTgcDigit>(stripIdB,
198  associateBCIdTag(ctx, timedHit),
199  hitTime(timedHit), dummyCharge * w1, false, false));
200  }
201  outCollection.push_back(std::make_unique<sTgcDigit>(digitId,
202  associateBCIdTag(ctx, timedHit),
203  hitTime(timedHit), dummyCharge * w2, false, false));
204 
205  if (digitStrip + 1 <= design.numStrips()) {
206  const Identifier stripIdA = idHelper.channelID(hitId, readOutEle->multilayer(),
207  gasGap, channelType::Strip, digitStrip + 1);
208 
209  outCollection.push_back(std::make_unique<sTgcDigit>(stripIdA,
210  associateBCIdTag(ctx, timedHit),
211  hitTime(timedHit), dummyCharge * w3, false, false));
212  }
213  ++m_acceptedHits[channelType::Strip];
214  return true;
215  }

◆ digitizeWire()

bool MuonR4::sTgcFastDigiTool::digitizeWire ( const EventContext &  ctx,
const TimedHit timedHit,
const Muon::DigitEffiData effiData,
CLHEP::HepRandomEngine *  rndEngine,
sTgcDigitCollection outCollection 
) const
private

Check efficiencies

Sim hits are always expressed in the eta view of the gasGap...

Check efficiencies

Definition at line 217 of file sTgcFastDigiTool.cxx.

221  {
222 
223  if (!m_digitizeWire) {
224  return false;
225  }
226 
227  ++m_allHits[channelType::Wire];
228 
229  const Identifier hitId{timedHit->identify()};
231  if (efficiencyMap && efficiencyMap->getEfficiency(hitId) < CLHEP::RandFlat::shoot(rndEngine,0.,1.)){
232  ATH_MSG_VERBOSE("Simulated wire hit "<<xAOD::toEigen(timedHit->localPosition())
233  << m_idHelperSvc->toString(hitId) <<" is rejected because of efficency modelling");
234  return false;
235  }
236  const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
237  const MuonGMR4::sTgcReadoutElement* readOutEle = m_detMgr->getsTgcReadoutElement(hitId);
238  const int gasGap = idHelper.gasGap(hitId);
239 
240 
242  // Rotate the sim hit into the wire view
243  const IdentifierHash stripLayHash{readOutEle->createHash(gasGap, channelType::Strip, 0)};
244  const IdentifierHash wireLayHash{readOutEle->createHash(gasGap, channelType::Wire, 0)};
245 
246  const ActsGeometryContext& gctx{getGeoCtx(ctx)};
247  const Amg::Transform3D toWire{readOutEle->globalToLocalTrans(gctx, wireLayHash) *
248  readOutEle->localToGlobalTrans(gctx, stripLayHash)};
249 
250  const Amg::Vector2D wirePos{(toWire*xAOD::toEigen(timedHit->localPosition())).block<2,1>(0,0)};
251  // do not digitise wires that are never read out in reality
252  bool isInnerQ1 = readOutEle->isEtaZero(readOutEle->measurementHash(hitId), wirePos);
253  if(isInnerQ1) return false;
254 
256  if (efficiencyMap && efficiencyMap->getEfficiency(hitId, isInnerQ1) < CLHEP::RandFlat::shoot(rndEngine,0.,1.)){
257  ATH_MSG_VERBOSE("Simulated wire hit "<<xAOD::toEigen(timedHit->localPosition())
258  << m_idHelperSvc->toString(hitId) <<" is rejected because of efficency modelling");
259  return false;
260  }
261 
262  const MuonGMR4::WireGroupDesign& design{readOutEle->wireDesign(wireLayHash)};
263 
264  const int wireGrpNum = design.stripNumber(wirePos);
265  if (wireGrpNum < 0) {
266  ATH_MSG_VERBOSE("The wire "<<Amg::toString(wirePos)<<" in "<<m_idHelperSvc->toStringGasGap(hitId)
267  <<" is outside of the acceptance of "<<std::endl<<design);
268  return false;
269  }
270  const double uncert = design.stripPitch() * design.numWiresInGroup(wireGrpNum);
271 
272  const double smearedX = CLHEP::RandGaussZiggurat::shoot(rndEngine, wirePos.x(), uncert);
273 
274  const Amg::Vector2D digitPos{smearedX * Amg::Vector2D::UnitX()};
275 
276  const int digitWire = design.stripNumber(digitPos);
277  if (digitWire < 0) {
278  ATH_MSG_VERBOSE("Strip hit "<<Amg::toString(digitPos)<<" "<<m_idHelperSvc->toStringGasGap(hitId)
279  <<" is out of range "<<std::endl<<design);
280  return false;
281  }
282  bool isValid{false};
283  const Identifier digitId = idHelper.channelID(hitId, readOutEle->multilayer(),
284  gasGap, channelType::Wire, digitWire, isValid);
285 
286  if (!isValid) {
287  ATH_MSG_WARNING("Failed to deduce a valid identifier from "
288  <<m_idHelperSvc->toStringGasGap(hitId)<<" digit: "<<digitWire);
289  return false;
290  }
291  outCollection.push_back(std::make_unique<sTgcDigit>(digitId,
292  associateBCIdTag(ctx, timedHit),
293  hitTime(timedHit), 666, false, false));
294 
295 
296  ++m_acceptedHits[channelType::Wire];
297  return true;
298  }

◆ 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::sTgcFastDigiTool::finalize ( )
finaloverride

Definition at line 27 of file sTgcFastDigiTool.cxx.

27  {
28  ATH_MSG_INFO("Tried to convert "<<m_allHits[channelType::Strip]<<"/"
29  <<m_allHits[channelType::Wire]<<"/"
30  <<m_allHits[channelType::Pad]<<" strip/wire/pad hits. In, "
31  <<percentage(m_acceptedHits[channelType::Strip], m_allHits[channelType::Strip]) <<"/"
32  <<percentage(m_acceptedHits[channelType::Wire], m_allHits[channelType::Wire])<<"/"
33  <<percentage(m_acceptedHits[channelType::Pad], m_allHits[channelType::Pad])
34  <<"% of the cases, the conversion was successful");
35  return StatusCode::SUCCESS;
36  }

◆ 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::sTgcFastDigiTool::initialize ( )
finaloverridevirtual

Reimplemented from MuonR4::MuonDigitizationTool.

Definition at line 20 of file sTgcFastDigiTool.cxx.

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

◆ 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>, 3> m_allHits MuonR4::sTgcFastDigiTool::ATLAS_THREAD_SAFE {}
mutableprivate

Definition at line 64 of file sTgcFastDigiTool.h.

◆ ATLAS_THREAD_SAFE [2/2]

std::array<std::atomic<unsigned>, 3> m_acceptedHits MuonR4::sTgcFastDigiTool::ATLAS_THREAD_SAFE {}
mutableprivate

Definition at line 65 of file sTgcFastDigiTool.h.

◆ m_deadTime

Gaudi::Property<double> MuonR4::sTgcFastDigiTool::m_deadTime {this, "deadTime", 300. * Gaudi::Units::ns}
private

Definition at line 71 of file sTgcFastDigiTool.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::sTgcFastDigiTool::m_digitizeMuonOnly
private
Initial value:
{this, "ProcessTrueMuonsOnly", false,
"If set to true hit with pdgId != 13 are skipped"}

Definition at line 73 of file sTgcFastDigiTool.h.

◆ m_digitizePads

Gaudi::Property<bool> MuonR4::sTgcFastDigiTool::m_digitizePads {this, "doPads", false, "Digitize pad hits"}
private

Definition at line 69 of file sTgcFastDigiTool.h.

◆ m_digitizeStrip

Gaudi::Property<bool> MuonR4::sTgcFastDigiTool::m_digitizeStrip {this, "doStrips", true, "Digitize strip hits"}
private

Definition at line 67 of file sTgcFastDigiTool.h.

◆ m_digitizeWire

Gaudi::Property<bool> MuonR4::sTgcFastDigiTool::m_digitizeWire {this, "doWires", true, "Digitize wire hits"}
private

Definition at line 68 of file sTgcFastDigiTool.h.

◆ m_effiDataKey

SG::ReadCondHandleKey<Muon::DigitEffiData> MuonR4::sTgcFastDigiTool::m_effiDataKey
private
Initial value:
{this, "EffiDataKey", "sTgcDigitEff",
"Efficiency constants of the individual sTgc gasGaps"}

Definition at line 57 of file sTgcFastDigiTool.h.

◆ m_energyDepositThreshold

Gaudi::Property<double> MuonR4::sTgcFastDigiTool::m_energyDepositThreshold {this,"energyDepositThreshold",300.0*CLHEP::eV}
private

Definition at line 75 of file sTgcFastDigiTool.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_limitElectronKineticEnergy

Gaudi::Property<double> MuonR4::sTgcFastDigiTool::m_limitElectronKineticEnergy {this,"limitElectronKineticEnergy",5.0*CLHEP::MeV}
private

Definition at line 76 of file sTgcFastDigiTool.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_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_streamName

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

Definition at line 128 of file MuonDigitizationTool.h.

◆ m_timedHits

TimedHits MuonR4::MuonDigitizationTool::m_timedHits {}
privateinherited

Definition at line 141 of file MuonDigitizationTool.h.

◆ m_uncertCalibKey

SG::ReadCondHandleKey<NswErrorCalibData> MuonR4::sTgcFastDigiTool::m_uncertCalibKey
private
Initial value:
{this, "ErrorCalibKey", "NswUncertData",
"Key of the parametrized NSW uncertainties"}

Definition at line 61 of file sTgcFastDigiTool.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<sTgcDigitContainer> MuonR4::sTgcFastDigiTool::m_writeKey {this, "OutputObjectName", "sTGC_DIGITS"}
private

Definition at line 55 of file sTgcFastDigiTool.h.


The documentation for this class was generated from the following files:
MuonR4::MuonDigitizationTool::m_inputObjectName
std::string m_inputObjectName
Definition: MuonDigitizationTool.h:139
NswErrorCalibData
Definition: NswErrorCalibData.h:19
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
xAOD::MuonSimHit_v1
Definition: MuonSimHit_v1.h:18
MuonGMR4::sTgcReadoutElement::multilayer
int multilayer() const
Returns the multilayer of the sTgcReadoutElement.
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
MuonR4::sTgcFastDigiTool::m_limitElectronKineticEnergy
Gaudi::Property< double > m_limitElectronKineticEnergy
Definition: sTgcFastDigiTool.h:76
MuonGMR4::StripDesign::stripNumber
virtual int stripNumber(const Amg::Vector2D &pos) const
Calculates the number of the strip whose center is closest to the given point.
MuonR4::MuonDigitizationTool::m_simHitKey
SG::ReadHandleKey< xAOD::MuonSimHitContainer > m_simHitKey
Definition: MuonDigitizationTool.h:121
MuonGMR4::StripDesign
Definition: StripDesign.h:30
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
MuonGMR4::WireGroupDesign
Definition: WireGroupDesign.h:23
xAOD::MuonSimHit_v1::identify
Identifier identify() const
Returns the global ATLAS identifier of the SimHit.
Definition: xAODMuonSimHit_V1.cxx:42
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
MuonR4::sTgcFastDigiTool::m_effiDataKey
SG::ReadCondHandleKey< Muon::DigitEffiData > m_effiDataKey
Definition: sTgcFastDigiTool.h:57
SG::Accessor< float >
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
MuonR4::sTgcFastDigiTool::m_digitizeMuonOnly
Gaudi::Property< bool > m_digitizeMuonOnly
Definition: sTgcFastDigiTool.h:73
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::sTgcFastDigiTool::associateBCIdTag
int associateBCIdTag(const EventContext &ctx, const TimedHit &timedHit) const
: Associates the global bcIdTag to the digit
Definition: sTgcFastDigiTool.cxx:299
M_PI
#define M_PI
Definition: ActiveFraction.h:11
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
xAOD::MuonSimHit_v1::setLocalPosition
void setLocalPosition(MeasVector< 3 > vec)
Sets the local position of the traversing particle.
Definition: xAODMuonSimHit_V1.cxx:56
MuonGMR4::MuonReadoutElement::globalToLocalTrans
Amg::Transform3D globalToLocalTrans(const ActsGeometryContext &ctx) const
Transformations to translate between local <-> global coordinates.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonReadoutElement.cxx:78
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
MuonR4::sTgcFastDigiTool::m_writeKey
SG::WriteHandleKey< sTgcDigitContainer > m_writeKey
Definition: sTgcFastDigiTool.h:55
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
x
#define x
MuonGMR4::sTgcReadoutElement::measurementHash
IdentifierHash measurementHash(const Identifier &measId) const override final
Constructs the identifier hash from the full measurement Identifier.
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
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
PileUpToolBase::m_vetoPileUpTruthLinks
Gaudi::Property< int > m_vetoPileUpTruthLinks
Definition: PileUpToolBase.h:58
MuonGMR4::PadDesign::channelNumber
std::pair< int, int > channelNumber(const Amg::Vector2D &hitPos) const
Function to retrieve the pad eta and phi given a local position coordinate.
MuonR4::sTgcFastDigiTool::m_uncertCalibKey
SG::ReadCondHandleKey< NswErrorCalibData > m_uncertCalibKey
Definition: sTgcFastDigiTool.h:61
xAOD::ChamberViewer
Definition: ChamberViewer.h:59
MuonGMR4::sTgcReadoutElement::wireDesign
const WireGroupDesign & wireDesign(const Identifier &measId) const
Retrieves the readoutElement Layer given the Identifier/Hash.
MuonR4::sTgcFastDigiTool::m_digitizePads
Gaudi::Property< bool > m_digitizePads
Definition: sTgcFastDigiTool.h:69
MuonR4::MuonDigitizationTool::m_timedHits
TimedHits m_timedHits
Definition: MuonDigitizationTool.h:141
MuonGMR4::sTgcReadoutElement::createHash
static IdentifierHash createHash(const unsigned int gasGap, const unsigned int channelType, const unsigned int channel, const unsigned int wireInGrp=0)
Create a measurement hash from the Identifier fields.
Amg::toString
std::string toString(const Translation3D &translation, int precision=4)
GeoPrimitvesToStringConverter.
Definition: GeoPrimitivesToStringConverter.h:40
sTgcDigitCollection
Definition: sTgcDigitCollection.h:18
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::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
xAOD::EgammaHelpers::isElectron
bool isElectron(const xAOD::Egamma *eg)
is the object an electron (not Fwd)
Definition: EgammaxAODHelpers.cxx:12
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
test_pyathena.parent
parent
Definition: test_pyathena.py:15
python.StandardJetMods.pull
pull
Definition: StandardJetMods.py:304
xAOD::MuonSimHit_v1::localDirection
ConstVectorMap< 3 > localDirection() const
Returns the local direction of the traversing particle.
Definition: xAODMuonSimHit_V1.cxx:66
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
NswErrorCalibData::clusterUncertainty
double clusterUncertainty(const Input &clustInfo) const
Definition: NswErrorCalibData.cxx:96
MuonGMR4::sTgcReadoutElement::isEtaZero
bool isEtaZero(const IdentifierHash &measurementHash, const Amg::Vector2D &localPosition) const
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/sTgcReadoutElement.cxx:321
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
MuonR4::sTgcFastDigiTool::digitizeWire
bool digitizeWire(const EventContext &ctx, const TimedHit &timedHit, const Muon::DigitEffiData *effiData, CLHEP::HepRandomEngine *rndEngine, sTgcDigitCollection &outCollection) const
Definition: sTgcFastDigiTool.cxx:217
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
MuonR4::sTgcFastDigiTool::DigiCache
OutDigitCache_t< sTgcDigitCollection > DigiCache
Definition: sTgcFastDigiTool.h:54
NswErrorCalibData::Input::stripId
Identifier stripId
Identifier of the strip.
Definition: NswErrorCalibData.h:27
Muon::DigitEffiData
Definition: DigitEffiData.h:23
MuonR4::MuonDigitizationTool::getGeoCtx
const ActsGeometryContext & getGeoCtx(const EventContext &ctx) const
Returns the reference to the ActsGeometryContext needed to fetch global positions from the Readout ge...
Definition: MuonDigitizationTool.cxx:135
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
MuonGMR4::WireGroupDesign::stripNumber
int stripNumber(const Amg::Vector2D &pos) const override
Calculates the number of the strip whose center is closest to the given point.
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.
MuonR4::sTgcFastDigiTool::m_digitizeWire
Gaudi::Property< bool > m_digitizeWire
Definition: sTgcFastDigiTool.h:68
sTgcIdHelper
Definition: sTgcIdHelper.h:55
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
MuonR4::sTgcFastDigiTool::m_energyDepositThreshold
Gaudi::Property< double > m_energyDepositThreshold
Definition: sTgcFastDigiTool.h:75
THROW_EXCEPTION
#define THROW_EXCEPTION(MESSAGE)
Definition: throwExcept.h:10
MuonGMR4::sTgcReadoutElement
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/MuonReadoutGeometryR4/sTgcReadoutElement.h:20
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
MuonGMR4::sTgcReadoutElement::padDesign
const PadDesign & padDesign(const Identifier &measId) const
Retrieves the readoutElement Layer given the Identifier/Hash.
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::sTgcFastDigiTool::digitizeStrip
bool digitizeStrip(const EventContext &ctx, const TimedHit &timedHit, const NswErrorCalibData *errorCalibDB, const Muon::DigitEffiData *effiData, CLHEP::HepRandomEngine *rndEngine, sTgcDigitCollection &outCollection) const
Definition: sTgcFastDigiTool.cxx:97
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
MuonDigit::identify
Identifier identify() const
Definition: MuonDigit.h:30
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
re
const boost::regex re(r_e)
PileUpToolBase::m_firstXing
Gaudi::Property< int > m_firstXing
Definition: PileUpToolBase.h:54
xAOD::MuonSimHit_v1::localPosition
ConstVectorMap< 3 > localPosition() const
Returns the local postion of the traversing particle.
Definition: xAODMuonSimHit_V1.cxx:60
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
MuonR4::MuonDigitizationTool::m_rndmSvc
ServiceHandle< IAthRNGSvc > m_rndmSvc
Definition: MuonDigitizationTool.h:130
MuonGMR4::MuonReadoutElement::localToGlobalTrans
const Amg::Transform3D & localToGlobalTrans(const ActsGeometryContext &ctx) const
Returns the local to global transformation into the ATLAS coordinate system.
Definition: MuonPhaseII/MuonDetDescr/MuonReadoutGeometryR4/src/MuonReadoutElement.cxx:81
MuonR4::MuonDigitizationTool::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition: MuonDigitizationTool.h:111
MuonR4::sTgcFastDigiTool::m_digitizeStrip
Gaudi::Property< bool > m_digitizeStrip
Definition: sTgcFastDigiTool.h:67
NswErrorCalibData::Input
Helper struct to be parsed to the object to derive the specific error of the cluster.
Definition: NswErrorCalibData.h:25
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
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::PadDesign
Definition: PadDesign.h:24
MuonR4::sTgcFastDigiTool::digitizePad
bool digitizePad(const EventContext &ctx, const TimedHit &timedHit, const Muon::DigitEffiData *effiData, CLHEP::HepRandomEngine *rndEngine, sTgcDigitCollection &outCollection) const
Definition: sTgcFastDigiTool.cxx:305
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.
isMuon
bool isMuon(const T &p)
Definition: AtlasPID.h:202
Identifier
Definition: IdentifierFieldParser.cxx:14