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::MM_DigitizationTool Class Referencefinal

#include <MM_DigitizationTool.h>

Inheritance diagram for MuonR4::MM_DigitizationTool:
Collaboration diagram for MuonR4::MM_DigitizationTool:

Public Member Functions

 MM_DigitizationTool (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 NoiseCalibConstants = NswCalibDbTimeChargeData::CalibConstants
 
using DigiCache = OutDigitCache_t< MmDigitCollection >
 
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

MM_ElectronicsToolInput combinedStripResponseAllHits (const EventContext &ctx, const std::vector< MM_ElectronicsToolInput > &v_stripDigitOutput) const
 
StatusCode fillTimedHits (PileUpHits &&hitColl, TimedHits &timedHits) const
 Translates the PileUpHits into the timed hits format. More...
 

Private Attributes

SG::WriteHandleKey< MmDigitContainerm_writeKey {this, "OutputObjectName", "MM_DIGITS"}
 
SG::ReadCondHandleKey< Muon::DigitEffiDatam_effiDataKey {this, "EffiDataKey", "MmDigitEff", "Efficiency constants of the individual MM gasGaps"}
 
SG::ReadCondHandleKey< NswErrorCalibDatam_uncertCalibKey {this, "ErrorCalibKey", "NswUncertData", "Key of the parametrized NSW uncertainties"}
 
SG::ReadCondHandleKey< NswCalibDbThresholdDatam_condThrshldsKey
 
SG::ReadCondHandleKey< AtlasFieldCacheCondObjm_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}
 
ToolHandle< Muon::INSWCalibSmearingToolm_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"}
 
ToolHandle< Muon::INSWCalibToolm_calibrationTool {this, "CalibrationTool", "Muon::NSWCalibTool/NSWCalibTool"}
 
Gaudi::Property< bool > m_digitizeMuonOnly {this, "ProcessTrueMuonsOnly", true, "If set to true hit with pdgId != 13 are skipped"}
 
Gaudi::Property< std::string > m_vmmReadoutMode {this, "vmmReadoutMode", "peak", "For readout (DAQ) path. Can be peak or threshold"}
 
Gaudi::Property< std::string > m_vmmARTMode {this, "vmmARTMode", "threshold", "For ART (trigger) path. Can be peak or threshold"}
 
Gaudi::Property< double > m_energyThreshold {this, "EnergyThreshold", 50, "Minimal energy to process an electron sim hit"}
 
Gaudi::Property< double > m_timeWindowLowerOffset
 
Gaudi::Property< double > m_timeWindowUpperOffset
 
Gaudi::Property< double > m_DiffMagSecondMuonHit {this, "DiffMagSecondMuonHit", 0.1}
 
Gaudi::Property< int > m_maskMultiplet {this, "MaskMultiplet", 0, "0: all, 1: first, 2: second, 3: both"}
 
Gaudi::Property< bool > m_writeOutputFile {this, "SaveInternalHistos", false}
 
Gaudi::Property< bool > m_needsMcEventCollHelper {this, "UseMcEventCollectionHelper", false}
 
Gaudi::Property< bool > m_checkMMSimHits {this, "CheckSimHits", true, "Control on the hit validity"}
 
Gaudi::Property< bool > m_useTimeWindow {this, "UseTimeWindow", true}
 
Gaudi::Property< bool > m_vmmNeighborLogic {this, "VMMNeighborLogic", false}
 
Gaudi::Property< bool > m_doSmearing
 
Gaudi::Property< float > m_qThreshold {this, "qThreshold", 0.001, "Charge Threshold"}
 
Gaudi::Property< float > m_driftGapWidth {this, "DriftGapWidth", 5.04, "Drift Gap Width of 5.04 mm"}
 
Gaudi::Property< float > m_crossTalk1 {this, "crossTalk1", 0.3, "Strip Cross Talk with Nearest Neighbor"}
 
Gaudi::Property< float > m_crossTalk2 {this, "crossTalk2", 0.09, "Strip Cross Talk with 2nd Nearest Neighbor"}
 
Gaudi::Property< float > m_avalancheGain {this, "AvalancheGain", 6.0e3, "avalanche Gain for rach gas mixture"}
 
Gaudi::Property< float > m_electronicsThreshold
 
Gaudi::Property< float > m_stripdeadtime {this, "StripDeadTime", 200, "dead-time for strip, default value 200 ns = 8 BCs"}
 
Gaudi::Property< float > m_ARTdeadtime {this, "ARTDeadTime", 200, "dead-time for ART, default value 200 ns = 8 BCs"}
 
Gaudi::Property< bool > m_useCondThresholds
 
Gaudi::Property< bool > m_useThresholdScaling
 
Gaudi::Property< float > m_thresholdScaleFactor
 
Gaudi::Property< float > m_vmmDeadtime {this, "vmmDeadtime", 200, "Specifies how much before the lower time limit the VMM simulation should start evaluating the signal"}
 
Gaudi::Property< float > m_vmmUpperGrazeWindow {this, "vmmUpperGrazeWindow", 150, "Specifies how much above the upper time window boundary the VMM sim evaluates the signal."}
 
Gaudi::Property< double > m_deadTime {this, "deadTime", 300. * Gaudi::Units::ns}
 
std::unique_ptr< MM_StripsResponseSimulationm_StripsResponseSimulation {}
 
std::unique_ptr< MM_ElectronicsResponseSimulationm_ElectronicsResponseSimulation {}
 
std::map< int, NoiseCalibConstantsm_noiseParams {}
 Define a map to cache the noise parameters individually Key: stationName * std::abs(stationEta) More...
 
std::array< std::atomic< unsigned >, 8 > m_allHits ATLAS_THREAD_SAFE {}
 
std::array< std::atomic< unsigned >, 8 > m_acceptedHits ATLAS_THREAD_SAFE {}
 
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 33 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

Member Typedef Documentation

◆ DeadTimeMap

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

Definition at line 100 of file MuonDigitizationTool.h.

◆ DigiCache

◆ NoiseCalibConstants

◆ 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

◆ MM_DigitizationTool()

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

Definition at line 36 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

36  :
37  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  }

◆ combinedStripResponseAllHits()

MM_ElectronicsToolInput MM_DigitizationTool::combinedStripResponseAllHits ( const EventContext &  ctx,
const std::vector< MM_ElectronicsToolInput > &  v_stripDigitOutput 
) const
private

Definition at line 427 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

428  {
429  // set up pointer to conditions object
430 
431  const MmIdHelper &idHelper{m_idHelperSvc->mmIdHelper()};
432 
433  const NswCalibDbThresholdData *thresholdData{nullptr};
434  if (!SG::get(thresholdData, m_condThrshldsKey, ctx).isSuccess()) {
435  THROW_EXCEPTION("Cannot find conditions data container for VMM thresholds!");
436  }
437 
438  std::vector<int> v_stripStripResponseAllHits{};
439  std::vector<std::vector<float>> v_timeStripResponseAllHits{}, v_qStripResponseAllHits{};
440  std::vector<float> v_stripThresholdResponseAllHits{};
441 
442  Identifier digitID = v_stripDigitOutput.at(0).digitID();
443  double max_kineticEnergy = 0.0;
444 
445  // Loop over strip digit output elements
446  for (const MM_ElectronicsToolInput &i_stripDigitOutput : v_stripDigitOutput) {
447  //--- Just to get Digit id with the largest kinetic energy, but the Digit id is no longer meaningful
448  if (i_stripDigitOutput.kineticEnergy() > max_kineticEnergy) {
449  digitID = i_stripDigitOutput.digitID();
450  max_kineticEnergy = i_stripDigitOutput.kineticEnergy();
451  }
452  //---
453  for (size_t i = 0; i < i_stripDigitOutput.NumberOfStripsPos().size(); ++i) {
454  int strip_id = i_stripDigitOutput.NumberOfStripsPos().at(i);
455  bool found = false;
456 
457  for (size_t ii = 0; ii < v_stripStripResponseAllHits.size(); ++ii) {
458  if (v_stripStripResponseAllHits.at(ii) == strip_id) {
459  v_timeStripResponseAllHits.at(ii).insert(v_timeStripResponseAllHits.at(ii).end(),
460  i_stripDigitOutput.chipTime().at(i).begin(), i_stripDigitOutput.chipTime().at(i).end());
461 
462  v_qStripResponseAllHits.at(ii).insert(v_qStripResponseAllHits.at(ii).end(),
463  i_stripDigitOutput.chipCharge().at(i).begin(), i_stripDigitOutput.chipCharge().at(i).end());
464  found = true;
465  }
466  }
467 
468  if (found) {
469  continue;
470  }
471 
472  v_stripStripResponseAllHits.push_back(strip_id);
473  v_timeStripResponseAllHits.push_back(i_stripDigitOutput.chipTime().at(i));
474  v_qStripResponseAllHits.push_back(i_stripDigitOutput.chipCharge().at(i));
475  if (m_useCondThresholds) {
476  const Identifier id = idHelper.channelID(digitID,
477  idHelper.multilayer(digitID),
478  idHelper.gasGap(digitID), strip_id);
479  float threshold = 0;
480  if (!thresholdData->getThreshold(id, threshold)) {
481  THROW_EXCEPTION("Cannot find retrieve VMM threshold from conditions data base!");
482  }
483  v_stripThresholdResponseAllHits.push_back(threshold);
484  } else if (m_useThresholdScaling) {
485  Identifier id = idHelper.channelID(digitID,
486  idHelper.multilayer(digitID),
487  idHelper.gasGap(digitID), strip_id);
488 
489  const MuonGMR4::MmReadoutElement *detectorReadoutElement = m_detMgr->getMmReadoutElement(id);
490  const MuonGMR4::StripDesign &design{detectorReadoutElement->stripLayer(id).design()};
491  double stripLength = design.stripLength(strip_id);
492  const int noise_id = m_idHelperSvc->stationName(digitID) * std::abs(m_idHelperSvc->stationEta(digitID));
493  const NoiseCalibConstants &noise = m_noiseParams.at(noise_id);
494  double threshold = (noise.slope * stripLength + noise.intercept) * m_thresholdScaleFactor;
495  v_stripThresholdResponseAllHits.push_back(threshold);
496  } else {
497  v_stripThresholdResponseAllHits.push_back(m_electronicsThreshold);
498  }
499  }
500  }
501  return MM_ElectronicsToolInput(std::move(v_stripStripResponseAllHits), std::move(v_qStripResponseAllHits),
502  std::move(v_timeStripResponseAllHits), std::move(v_stripThresholdResponseAllHits),
503  digitID, max_kineticEnergy);
504  }

◆ digitize()

StatusCode MM_DigitizationTool::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.

Reject hit within the dead time interval

Implements MuonR4::MuonDigitizationTool.

Definition at line 197 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

199  {
200 
201  const MmIdHelper &idHelper{m_idHelperSvc->mmIdHelper()};
202  CLHEP::HepRandomEngine *rndEngine = getRandomEngine(ctx);
203  const ActsGeometryContext &gctx{getGeoCtx(ctx)};
204 
205  // Prepare the temporary cache
206  DigiCache digitCache{};
207 
208  // Fetch the conditions for efficiency calculations
209  const Muon::DigitEffiData *efficiencyMap{nullptr};
210  ATH_CHECK(SG::get(efficiencyMap , m_effiDataKey, ctx));
211 
212  const NswErrorCalibData *errorCalibDB{nullptr};
213  ATH_CHECK(SG::get(errorCalibDB, m_uncertCalibKey, ctx));
214 
215  MagField::AtlasFieldCache fieldCache;
216  const AtlasFieldCacheCondObj *fieldCondObj{nullptr};
217  ATH_CHECK(SG::get(fieldCondObj, m_fieldCondObjInputKey, ctx));
218  fieldCondObj->getInitializedCache(fieldCache);
219 
220  xAOD::ChamberViewer viewer{hitsToDigit, m_idHelperSvc.get()};
221  do {
222 
223  std::array<std::vector<MM_ElectronicsToolInput>, 8> v_stripDigitOutput{};
224  DeadTimeMap deadTimes{};
225 
226  for (const TimedHit &simHit : viewer) {
227  // ignore radiation if you want
228  if (m_digitizeMuonOnly && !MC::isMuon(simHit)) {
229  ATH_MSG_VERBOSE("Hit is not from a muon - skipping ");
230  continue;
231  }
232 
233  const Identifier hitId{simHit->identify()};
234 
235  const double hitKineticEnergy = simHit->kineticEnergy();
236  // Don't consider electron hits below m_energyThreshold.
237  // Electrons aren't consider for now in any case due to the cut above.
238  // But this may change.
239  if (hitKineticEnergy < m_energyThreshold && MC::isElectron(simHit)) {
240  continue;
241  }
242  const MuonGMR4::MmReadoutElement *readOutEle = m_detMgr->getMmReadoutElement(hitId);
243  const MuonGMR4::StripDesign &design{readOutEle->stripLayer(hitId).design()};
244 
245  const Amg::Vector3D locPos{xAOD::toEigen(simHit->localPosition())};
246  const Amg::Vector3D locDir{xAOD::toEigen(simHit->localDirection())};
247 
248  const Amg::Transform3D &locToGlobal{readOutEle->localToGlobalTrans(gctx, readOutEle->layerHash(hitId))};
249  const Amg::Vector3D globalHitPosition{locToGlobal * locPos};
250 
251  // We could use the MuonDigitizationTool::hitTime which returns the global time
252  // of the hit which is the sum of eventTime & individual hit time,
253  // but we want to have access on both contributions.
254  const double globalHitTime = simHit->globalTime();
255  const double tofCorrection = globalHitPosition.mag() / CLHEP::c_light;
256  const double eventTime = simHit.eventTime();
257  const double bunchTime = globalHitTime - tofCorrection + eventTime;
258 
259  const HepMcParticleLink particleLink = simHit->genParticleLink();
260  // Print some information about the MicroMegas hit
261  ATH_MSG_VERBOSE("hitID " << m_idHelperSvc->toString(hitId) <<" ("<< simHit.get()<< ") Hit bunch time " << bunchTime << " tof/G4 hit time " << globalHitTime
262  << " globalHitPosition " << Amg::toString(globalHitPosition) << " hit: r " << globalHitPosition.perp() << " z " << globalHitPosition.z()
263  << " mclink " << particleLink << "Kinetic energy " << hitKineticEnergy);
264 
265  // Angles, Geometry, and Coordinates.
266  // This is not an incident angle yet. It's atan(z/x),
267  // ... so it's the complement of the angle w.r.t. a vector normal to the detector surface
268  double inAngleCompliment_XZ = std::atan2(locDir.z(), locDir.x()) / CLHEP::degree;
269  double inAngleCompliment_YZ = std::atan2(locDir.z(), locDir.y()) / CLHEP::degree;
270 
271  // This is basically to handle the atan ambiguity
272  if (inAngleCompliment_XZ < 0.0)
273  inAngleCompliment_XZ += 180;
274  if (inAngleCompliment_YZ < 0.0)
275  inAngleCompliment_YZ += 180;
276 
277  // This gets the actual incidence angle from its complement.
278  double inAngle_XZ = 90. - inAngleCompliment_XZ;
279  double inAngle_YZ = 90. - inAngleCompliment_YZ;
280 
281  const IdentifierHash measHash{readOutEle->measurementHash(hitId)};
282  int readoutSide = readOutEle->readoutSide(measHash);
283  if (readoutSide == 1) {
284  inAngle_XZ = (-inAngle_XZ);
285  }
286 
287  // Move the hit position to the readout plane
288  int gasGap = idHelper.gasGap(hitId);
289  // TO DO: THERE IS NO DESING THICKNESS, BUT HOW TO GET DIFFERENT THICKNESSES LIKE BEFORE?
290  // double shift = 0.5 * design.thickness();
291  double shift = 0.5 * m_driftGapWidth;
292  std::optional<double> lambda{std::nullopt};
293  if (gasGap == 1 || gasGap == 3) {
294  lambda = Amg::intersect<3>(locPos, locDir, Amg::Vector3D::UnitZ(), -shift);
295  } else if (gasGap == 2 || gasGap == 4) {
296  lambda = Amg::intersect<3>(locPos, locDir, Amg::Vector3D::UnitZ(), shift);
297  }
298 
299  const Amg::Vector3D hitOnSurface = locPos + lambda.value_or(0.) * locDir;
300  const Amg::Vector2D positionOnSurface{hitOnSurface.x(), hitOnSurface.y()};
301 
302  // Account For Time Offset
303  const double shiftTimeOffset = (globalHitTime - tofCorrection) * m_StripsResponseSimulation->getDriftVelocity();
304  const Amg::Vector3D hitAfterTimeShift(hitOnSurface.x(), hitOnSurface.y(), shiftTimeOffset);
305  lambda = Amg::intersect<3>(hitAfterTimeShift, locDir, Amg::Vector3D::UnitZ(), -shiftTimeOffset);
306  const Amg::Vector3D hitAfterTimeShiftOnSurface = hitAfterTimeShift + lambda.value_or(0.) * locDir;
307 
308  if (std::abs(hitAfterTimeShiftOnSurface.z()) > 0.1) {
309  ATH_MSG_WARNING("Bad propagation to surface after time shift " << Amg::toString(hitAfterTimeShiftOnSurface));
310  }
311 
312  // Calculate the index for the global hit counter
313  const unsigned int hitGapInNsw = (idHelper.multilayer(hitId) - 1) * 4 + idHelper.gasGap(hitId) - 1;
314  ++m_allHits[hitGapInNsw];
315 
316  bool isValid{false};
317 
318  int channelNumber = design.stripNumber(positionOnSurface);
319  // Checks if the hit is outside of the panel
320  if (channelNumber < 0) {
321  // Checks if the point is inside the trapezoid where the strips are mounted.
322  if (!design.insideTrapezoid(positionOnSurface)) {
323  ATH_MSG_WARNING("Hit " << m_idHelperSvc->toString(hitId) << " " << Amg::toString(positionOnSurface)
324  << " is outside bounds " << std::endl
325  << design << " rejecting it");
326  }
327  continue;
328  }
329  const Identifier clusId = idHelper.channelID(hitId, idHelper.multilayer(hitId),
330  idHelper.gasGap(hitId), channelNumber, isValid);
331 
332  if (!isValid) {
333  ATH_MSG_WARNING("Invalid strip identifier for layer " << m_idHelperSvc->toStringGasGap(hitId)<< " channel " << channelNumber
334  << " positionOnSurface " << Amg::toString(positionOnSurface));
335  continue;
336  }
337 
338  if (efficiencyMap && efficiencyMap->getEfficiency(clusId) < CLHEP::RandFlat::shoot(rndEngine, 0., 1.)) {
339  ATH_MSG_VERBOSE("Simulated hit " <<Amg::toString(locPos) << " hitting strip " << m_idHelperSvc->toString(clusId)
340  << " is rejected because of effiency modelling");
341  continue;
342  }
343  if (!passDeadTime(clusId, hitTime(simHit), m_deadTime, deadTimes)) {
345  continue;
346  }
347 
348  double distToStrip = design.distanceToStrip(positionOnSurface, channelNumber);
349 
350  // Obtain Magnetic Field At Detector Surface
351  Amg::Vector3D hitOnSurfaceGlobal{locToGlobal * hitOnSurface};
352  Amg::Vector3D magneticField{Amg::Vector3D::Zero()};
353  fieldCache.getField(hitOnSurfaceGlobal.data(), magneticField.data());
354 
355  // B-field in local cordinate, X ~ #strip, increasing to outer R, Z ~ global Z but positive to IP
356  Amg::Vector3D localMagneticField{locToGlobal.linear().inverse() * magneticField};
357  if (readoutSide == -1) {
358  localMagneticField[Amg::y] = -localMagneticField[Amg::y];
359  }
360 
361  // Strip Response Simulation For This Hit
362  const MM_DigitToolInput stripDigitInput(channelNumber, distToStrip, inAngle_XZ, inAngle_YZ, localMagneticField,
363  design.firstStripNumber(),
364  design.numStrips() + design.firstStripNumber() - 1,
365  idHelper.gasGap(hitId), eventTime + globalHitTime);
366  constexpr double gainFraction = 1.0;
367 
368  MM_StripToolOutput tmpStripOutput = m_StripsResponseSimulation->GetResponseFrom(stripDigitInput, gainFraction, design.stripPitch(), rndEngine);
369 
370  MM_ElectronicsToolInput stripDigitOutput(tmpStripOutput.NumberOfStripsPos(), tmpStripOutput.chipCharge(),
371  tmpStripOutput.chipTime(), clusId, hitKineticEnergy);
372 
373  ATH_MSG_VERBOSE(__func__ << "() : " << __LINE__ << " Prepared strip for digitization: " << m_idHelperSvc->toString(clusId));
374  v_stripDigitOutput[hitGapInNsw].push_back(std::move(stripDigitOutput));
375 
376  addSDO(simHit, sdoContainer)->setIdentifier(clusId);
377  ++m_acceptedHits[hitGapInNsw];
378  } // end of loop over hits
379 
380  // Now at Detector Element Level (VMM)
381  for (std::vector<MM_ElectronicsToolInput> &elecHitsPerLayer : v_stripDigitOutput) {
382  if (elecHitsPerLayer.empty()) {
383  continue;
384  }
385  // VMM Simulation
386  // Combine all strips (for this VMM) into a single VMM-level object
387  MM_ElectronicsToolInput stripDigitOutputAllHits = combinedStripResponseAllHits(ctx, std::move(elecHitsPerLayer));
388 
389  // Create Electronics Output with peak or threshold finding setting
390  MM_DigitToolOutput electronicsOutputForReadout{m_vmmReadoutMode == "peak" ?
391  m_ElectronicsResponseSimulation->getPeakResponseFrom(std::move(stripDigitOutputAllHits)) :
392  m_ElectronicsResponseSimulation->getThresholdResponseFrom(std::move(stripDigitOutputAllHits))};
393  if (!electronicsOutputForReadout.isValid()) {
394  ATH_MSG_DEBUG(__func__ << "() : " << __LINE__
395  << " there is no electronics response (peak or threshold finding mode) even though there is a strip response.");
396  }
397 
398  for (unsigned int firedCh = 0; firedCh < electronicsOutputForReadout.stripPos().size(); ++firedCh) {
399 
400  const int channel = electronicsOutputForReadout.stripPos()[firedCh];
401  double time = electronicsOutputForReadout.stripTime()[firedCh];
402  double charge = electronicsOutputForReadout.stripCharge()[firedCh];
403  bool isValid{false};
404  const Identifier digitID = idHelper.channelID(stripDigitOutputAllHits.digitID(),
405  idHelper.multilayer(stripDigitOutputAllHits.digitID()),
406  idHelper.gasGap(stripDigitOutputAllHits.digitID()),
407  channel, isValid);
408 
409  if (!isValid) {
410  ATH_MSG_DEBUG("Ghost strip fired... Ghost busters... ");
411  continue;
412  }
413  ATH_MSG_VERBOSE(__func__ << "() " << __LINE__ <<": Final digitized strip: " << m_idHelperSvc->toString(digitID)
414  <<", time: "<<time<<", charge: "<<charge);
415  MmDigitCollection *outColl = fetchCollection(digitID, digitCache);
416  outColl->push_back(std::make_unique<MmDigit>(digitID, time, charge));
417  }
418  }
419  } while (viewer.next());
420  // Write everything at the end into the final digit container
421  ATH_CHECK(writeDigitContainer(ctx, m_writeKey, std::move(digitCache), idHelper.module_hash_max()));
422 
423  return StatusCode::SUCCESS;
424  }

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

Definition at line 180 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

180  {
181 
182  std::stringstream statstr{};
183  unsigned allHits{0};
184  for (unsigned int g = 0; g < m_allHits.size(); ++g) {
185  allHits += m_allHits[g];
186  statstr << " *** Layer " << (g + 1) << " " << percentage(m_acceptedHits[g], m_allHits[g])
187  << "% of " << m_allHits[g] << std::endl;
188  }
189  if (!allHits) {
190  return StatusCode::SUCCESS;
191  }
192  ATH_MSG_INFO("Tried to convert " << allHits << " hits. Successes rate per layer " << std::endl
193  << statstr.str());
194  return StatusCode::SUCCESS;
195  }

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

Reimplemented from PileUpToolBase.

Definition at line 39 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx.

39  {
40  ATH_MSG_DEBUG("MM_DigitizationTool:: in initialize()");
41 
43 
49  ATH_CHECK(m_calibrationTool.retrieve());
50  ATH_CHECK(m_smearingTool.retrieve());
51 
52  // get gas properties from calibration tool
53  const NSWCalib::MicroMegaGas prop = m_calibrationTool->mmGasProperties();
54  const double peakTime = m_calibrationTool->mmPeakTime();
55 
57  strip_cfg.NSWCalib::MicroMegaGas::operator=(prop);
59  strip_cfg.qThreshold = m_qThreshold;
60  strip_cfg.driftGapWidth = m_driftGapWidth;
61  strip_cfg.crossTalk1 = m_crossTalk1;
62  strip_cfg.crossTalk2 = m_crossTalk2;
63  strip_cfg.avalancheGain = m_avalancheGain;
64  m_StripsResponseSimulation = std::make_unique<MM_StripsResponseSimulation>(std::move(strip_cfg));
65 
66  m_timeWindowLowerOffset += peakTime; // account for peak time in time window
67  m_timeWindowUpperOffset += peakTime; // account for peak time in time window
68 
70  elec_sim_cfg.peakTime = peakTime;
71  elec_sim_cfg.timeWindowLowerOffset = m_timeWindowLowerOffset;
72  elec_sim_cfg.timeWindowUpperOffset = m_timeWindowUpperOffset;
73  elec_sim_cfg.vmmDeadtime = m_vmmDeadtime;
74  elec_sim_cfg.vmmUpperGrazeWindow = m_vmmUpperGrazeWindow;
75  elec_sim_cfg.stripDeadTime = m_stripdeadtime;
76  elec_sim_cfg.artDeadTime = m_ARTdeadtime;
77  elec_sim_cfg.useNeighborLogic = m_vmmNeighborLogic;
78  // ElectronicsResponseSimulation Creation
79  m_ElectronicsResponseSimulation = std::make_unique<MM_ElectronicsResponseSimulation>(std::move(elec_sim_cfg));
80 
81  // Configuring various VMM modes of signal readout
82  //
83  std::string vmmReadoutMode = m_vmmReadoutMode;
84  // convert vmmReadoutMode to lower case
85  std::for_each(vmmReadoutMode.begin(), vmmReadoutMode.end(), [](char &c){ c = ::tolower(c); });
86  if (vmmReadoutMode.find("peak") != std::string::npos) {
87  m_vmmReadoutMode = "peak";
88  } else if (vmmReadoutMode.find("threshold") != std::string::npos){
89  m_vmmReadoutMode = "threshold";
90  } else {
91  ATH_MSG_ERROR("MM_DigitizationTool can't interperet vmmReadoutMode option! (Should be 'peak' or 'threshold'.) Contains: "
92  << m_vmmReadoutMode);
93  return StatusCode::FAILURE;
94  }
95  std::string vmmARTMode = m_vmmARTMode;
96  // convert vmmARTMode to lower case
97  std::for_each(vmmARTMode.begin(), vmmARTMode.end(), [](char &c){ c = ::tolower(c); });
98  if (vmmARTMode.find("peak") != std::string::npos) {
99  m_vmmARTMode = "peak";
100  }
101  else if (vmmARTMode.find("threshold") != std::string::npos) {
102  m_vmmARTMode = "threshold";
103  }
104  else {
105  ATH_MSG_ERROR("MM_DigitizationTool can't interperet vmmARTMode option! (Should be 'peak' or 'threshold'.) Contains: " << m_vmmARTMode);
106  return StatusCode::FAILURE;
107  }
108 
109  if (m_doSmearing) {
110  ATH_MSG_INFO("Running in smeared mode!");
111  }
112 
113  // get shortest and longest strip length for threshold scaling
114  Identifier tmpId{0}; // temporary identifier to work with ReadoutElement
115  int stripNumberShortestStrip{-1}, stripNumberLongestStrip{-1};
116  Identifier tmpIdShortestStrip{0}, tmpIdLongestStrip{0};
117  double shortestStripLength{FLT_MAX}, longestStripLength{0};
118  IdentifierHash tmpIdHashShortestStrip{0}, tmpIdHashLongestStrip{0};
119  NoiseCalibConstants noise_smallEta1{}, noise_smallEta2{}, noise_largeEta1{}, noise_largeEta2{};
120  //
121  for (std::string sectorType : {"MML", "MMS"}) {
122  for (int etaStation : {1, 2}) {
123  // identifier for first gas gap in a MM sector, layer is eta layer
124  tmpId = m_idHelperSvc->mmIdHelper().channelID(sectorType, etaStation, 1, 1, 1, 1);
125  const MuonGMR4::MmReadoutElement *detectorReadoutElement = m_detMgr->getMmReadoutElement(tmpId);
126  const MuonGMR4::StripDesign &design{detectorReadoutElement->stripLayer(tmpId).design()};
127  stripNumberShortestStrip = design.firstStripNumber();
128  tmpIdShortestStrip = m_idHelperSvc->mmIdHelper().channelID(sectorType, etaStation, 1, 1, 1, stripNumberShortestStrip); // identifier for the shortest strip
129  tmpIdHashShortestStrip = detectorReadoutElement->measurementHash(tmpIdShortestStrip);
130  shortestStripLength = detectorReadoutElement->stripLength(tmpIdHashShortestStrip);
131  stripNumberLongestStrip = design.numStrips() + stripNumberShortestStrip - 1;
132  tmpIdLongestStrip = m_idHelperSvc->mmIdHelper().channelID(sectorType, etaStation, 1, 1, 1, stripNumberLongestStrip); // identifier for the longest strip
133  tmpIdHashLongestStrip = detectorReadoutElement->measurementHash(tmpIdLongestStrip);
134  longestStripLength = design.stripLength(tmpIdHashLongestStrip);
135 
136  // now get the slope and intercept for the threshold scaling
137  // function is m_noiseSlope * stripLength + m_noiseIntercept
138  if (sectorType == "MMS") {
139  if (etaStation == 1) {
140  noise_smallEta1 = m_noiseParams[m_idHelperSvc->stationName(tmpId)];
141  noise_smallEta1.slope = (maxNoiseSmall_eta1 - minNoiseSmall_eta1) / (longestStripLength - shortestStripLength);
142  noise_smallEta1.intercept = minNoiseSmall_eta1 - noise_smallEta1.slope * shortestStripLength;
143  }
144  else if (etaStation == 2) {
145  noise_smallEta2 = m_noiseParams[m_idHelperSvc->stationName(tmpId) * 2];
146  noise_smallEta2.slope = (maxNoiseSmall_eta2 - minNoiseSmall_eta2) / (longestStripLength - shortestStripLength);
147  noise_smallEta2.intercept = minNoiseSmall_eta2 - noise_smallEta2.slope * shortestStripLength;
148  }
149  } else if (sectorType == "MML") {
150  if (etaStation == 1) {
151  noise_largeEta1 = m_noiseParams[m_idHelperSvc->stationName(tmpId)];
152  noise_largeEta1.slope = (maxNoiseLarge_eta1 - minNoiseLarge_eta1) / (longestStripLength - shortestStripLength);
153  noise_largeEta1.intercept = minNoiseLarge_eta1 - noise_largeEta1.slope * shortestStripLength;
154  } else if (etaStation == 2) {
155  noise_largeEta2 = m_noiseParams[m_idHelperSvc->stationName(tmpId) * 2];
156  noise_largeEta2.slope = (maxNoiseLarge_eta2 - minNoiseLarge_eta2) / (longestStripLength - shortestStripLength);
157  noise_largeEta2.intercept = minNoiseLarge_eta2 - noise_largeEta2.slope * shortestStripLength;
158  }
159  } // end of if over sector types
160  } // end of loop over eta stations
161  } // end of loop over sector types
162 
163  ATH_MSG_DEBUG("Configuration MM_DigitizationTool ");
164  ATH_MSG_DEBUG("OutputObjectName " << m_writeKey.key());
165  ATH_MSG_DEBUG("UseTimeWindow " << m_useTimeWindow);
166  ATH_MSG_DEBUG("CheckSimHits " << m_checkMMSimHits);
167  ATH_MSG_DEBUG("Threshold " << m_qThreshold);
168  ATH_MSG_DEBUG("TransverseDiffusSigma " << m_StripsResponseSimulation->getTransversDiffusionSigma());
169  ATH_MSG_DEBUG("LogitundinalDiffusSigma" << m_StripsResponseSimulation->getLongitudinalDiffusionSigma());
170  ATH_MSG_DEBUG("Interaction density mean: " << m_StripsResponseSimulation->getInteractionDensityMean());
171  ATH_MSG_DEBUG("Interaction density sigma: " << m_StripsResponseSimulation->getInteractionDensitySigma());
172  ATH_MSG_DEBUG("DriftVelocity stripResponse: " << m_StripsResponseSimulation->getDriftVelocity());
173  ATH_MSG_DEBUG("crossTalk1 " << m_crossTalk1);
174  ATH_MSG_DEBUG("crossTalk2 " << m_crossTalk2);
175  ATH_MSG_DEBUG("EnergyThreshold " << m_energyThreshold);
176 
177  return StatusCode::SUCCESS;
178  }

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

◆ ATLAS_THREAD_SAFE [2/2]

std::array<std::atomic<unsigned>, 8> m_acceptedHits MuonR4::MM_DigitizationTool::ATLAS_THREAD_SAFE {}
mutableprivate

◆ m_ARTdeadtime

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_ARTdeadtime {this, "ARTDeadTime", 200, "dead-time for ART, default value 200 ns = 8 BCs"}
private

◆ m_avalancheGain

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_avalancheGain {this, "AvalancheGain", 6.0e3, "avalanche Gain for rach gas mixture"}
private

◆ m_calibrationTool

ToolHandle<Muon::INSWCalibTool> MuonR4::MM_DigitizationTool::m_calibrationTool {this, "CalibrationTool", "Muon::NSWCalibTool/NSWCalibTool"}
private

◆ m_checkMMSimHits

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_checkMMSimHits {this, "CheckSimHits", true, "Control on the hit validity"}
private

◆ m_condThrshldsKey

SG::ReadCondHandleKey<NswCalibDbThresholdData> MuonR4::MM_DigitizationTool::m_condThrshldsKey
private
Initial value:
{ this, "CondThrshldsKey", "NswCalibDbThresholdData",
"Key of NswCalibDbThresholdData object containing calibration data (VMM thresholds)"}

Definition at line 56 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ m_crossTalk1

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_crossTalk1 {this, "crossTalk1", 0.3, "Strip Cross Talk with Nearest Neighbor"}
private

◆ m_crossTalk2

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_crossTalk2 {this, "crossTalk2", 0.09, "Strip Cross Talk with 2nd Nearest Neighbor"}
private

◆ m_deadTime

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

◆ m_detMgr

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

Definition at line 111 of file MuonDigitizationTool.h.

◆ m_DiffMagSecondMuonHit

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_DiffMagSecondMuonHit {this, "DiffMagSecondMuonHit", 0.1}
private

◆ m_digitizeMuonOnly

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

◆ m_doSmearing

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_doSmearing
private
Initial value:
{this, "doSmearing", true,
"set the usage or not of the smearing tool for realistic detector performance"}

Definition at line 81 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ m_driftGapWidth

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_driftGapWidth {this, "DriftGapWidth", 5.04, "Drift Gap Width of 5.04 mm"}
private

◆ m_effiDataKey

SG::ReadCondHandleKey<Muon::DigitEffiData> MuonR4::MM_DigitizationTool::m_effiDataKey {this, "EffiDataKey", "MmDigitEff", "Efficiency constants of the individual MM gasGaps"}
private

◆ m_ElectronicsResponseSimulation

std::unique_ptr<MM_ElectronicsResponseSimulation> MuonR4::MM_DigitizationTool::m_ElectronicsResponseSimulation {}
private

◆ m_electronicsThreshold

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_electronicsThreshold
private
Initial value:
{this, "electronicsThreshold", 15000,
"threshold Voltage for histoBNL, 2*(Intrinsic noise ~3k e)"}

Definition at line 97 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ m_energyThreshold

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_energyThreshold {this, "EnergyThreshold", 50, "Minimal energy to process an electron sim hit"}
private

◆ m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> MuonR4::MM_DigitizationTool::m_fieldCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj"}
private

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

Gaudi::Property<int> MuonR4::MM_DigitizationTool::m_maskMultiplet {this, "MaskMultiplet", 0, "0: all, 1: first, 2: second, 3: both"}
private

◆ m_mergeSvc

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

Definition at line 126 of file MuonDigitizationTool.h.

◆ m_needsMcEventCollHelper

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_needsMcEventCollHelper {this, "UseMcEventCollectionHelper", false}
private

◆ m_noiseParams

std::map<int, NoiseCalibConstants> MuonR4::MM_DigitizationTool::m_noiseParams {}
private

Define a map to cache the noise parameters individually Key: stationName * std::abs(stationEta)

Definition at line 123 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.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_qThreshold

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_qThreshold {this, "qThreshold", 0.001, "Charge Threshold"}
private

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

ToolHandle<Muon::INSWCalibSmearingTool> MuonR4::MM_DigitizationTool::m_smearingTool {this, "SmearingTool", "Muon::NSWCalibSmearingTool/MMCalibSmearingTool"}
private

◆ m_streamName

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

Definition at line 128 of file MuonDigitizationTool.h.

◆ m_stripdeadtime

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_stripdeadtime {this, "StripDeadTime", 200, "dead-time for strip, default value 200 ns = 8 BCs"}
private

◆ m_StripsResponseSimulation

std::unique_ptr<MM_StripsResponseSimulation> MuonR4::MM_DigitizationTool::m_StripsResponseSimulation {}
private

◆ m_thresholdScaleFactor

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_thresholdScaleFactor
private
Initial value:
{this, "thresholdScaleFactor", 7.0,
"Use x times the strip length dependent noise as MM threshold"}

Definition at line 107 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ m_timedHits

TimedHits MuonR4::MuonDigitizationTool::m_timedHits {}
privateinherited

Definition at line 141 of file MuonDigitizationTool.h.

◆ m_timeWindowLowerOffset

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_timeWindowLowerOffset
private
Initial value:
{this, "WindowLowerOffset", -12.5,
"lower boundary of the time window in which digits are accepted"}

Definition at line 68 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ m_timeWindowUpperOffset

Gaudi::Property<double> MuonR4::MM_DigitizationTool::m_timeWindowUpperOffset
private
Initial value:
{this, "WindowUpperOffset", 187.5,
"upper boundary of the time window in which digits are accepted"}

Definition at line 70 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ m_uncertCalibKey

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

◆ m_useCondThresholds

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_useCondThresholds
private
Initial value:
{this, "useCondThresholds", false,
"Use conditions data to get thresholds, overrules useThresholdScaling"}

Definition at line 103 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ m_useThresholdScaling

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_useThresholdScaling
private
Initial value:
{this, "useThresholdScaling", true,
"Use a strip length dependent threshold in MM digitiation"}

Definition at line 105 of file MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h.

◆ m_useTimeWindow

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_useTimeWindow {this, "UseTimeWindow", true}
private

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

Gaudi::Property<std::string> MuonR4::MM_DigitizationTool::m_vmmARTMode {this, "vmmARTMode", "threshold", "For ART (trigger) path. Can be peak or threshold"}
private

◆ m_vmmDeadtime

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_vmmDeadtime {this, "vmmDeadtime", 200, "Specifies how much before the lower time limit the VMM simulation should start evaluating the signal"}
private

◆ m_vmmNeighborLogic

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_vmmNeighborLogic {this, "VMMNeighborLogic", false}
private

◆ m_vmmReadoutMode

Gaudi::Property<std::string> MuonR4::MM_DigitizationTool::m_vmmReadoutMode {this, "vmmReadoutMode", "peak", "For readout (DAQ) path. Can be peak or threshold"}
private

◆ m_vmmUpperGrazeWindow

Gaudi::Property<float> MuonR4::MM_DigitizationTool::m_vmmUpperGrazeWindow {this, "vmmUpperGrazeWindow", 150, "Specifies how much above the upper time window boundary the VMM sim evaluates the signal."}
private

◆ m_writeKey

SG::WriteHandleKey<MmDigitContainer> MuonR4::MM_DigitizationTool::m_writeKey {this, "OutputObjectName", "MM_DIGITS"}
private

◆ m_writeOutputFile

Gaudi::Property<bool> MuonR4::MM_DigitizationTool::m_writeOutputFile {this, "SaveInternalHistos", false}
private

The documentation for this class was generated from the following files:
MmDigitCollection
Definition: MmDigitCollection.h:18
MuonR4::MM_DigitizationTool::m_electronicsThreshold
Gaudi::Property< float > m_electronicsThreshold
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:97
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
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
MuonGMR4::MmReadoutElement
Definition: MmReadoutElement.h:18
MuonGMR4::MmReadoutElement::stripLength
double stripLength(const IdentifierHash &measHash) const
Returns the strip length.
dumpTgcDigiDeadChambers.gasGap
list gasGap
Definition: dumpTgcDigiDeadChambers.py:33
MuonR4::MuonDigitizationTool::m_simHitKey
SG::ReadHandleKey< xAOD::MuonSimHitContainer > m_simHitKey
Definition: MuonDigitizationTool.h:121
MuonGMR4::StripDesign
Definition: StripDesign.h:30
NswCalibDbThresholdData
Definition: NswCalibDbThresholdData.h:17
MuonR4::MM_DigitizationTool::m_effiDataKey
SG::ReadCondHandleKey< Muon::DigitEffiData > m_effiDataKey
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:53
MuonR4::MM_DigitizationTool::m_ElectronicsResponseSimulation
std::unique_ptr< MM_ElectronicsResponseSimulation > m_ElectronicsResponseSimulation
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:118
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
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
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
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
MuonR4::MM_DigitizationTool::m_StripsResponseSimulation
std::unique_ptr< MM_StripsResponseSimulation > m_StripsResponseSimulation
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:117
SG::Accessor< float >
MuonR4::MM_DigitizationTool::m_useTimeWindow
Gaudi::Property< bool > m_useTimeWindow
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:79
MuonR4::MM_DigitizationTool::m_vmmUpperGrazeWindow
Gaudi::Property< float > m_vmmUpperGrazeWindow
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:112
MuonGMR4::StripDesign::stripLength
virtual double stripLength(int stripNumb) const
Returns length of the strip.
MuonR4::MM_DigitizationTool::m_calibrationTool
ToolHandle< Muon::INSWCalibTool > m_calibrationTool
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:61
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
MM_StripToolOutput::NumberOfStripsPos
const std::vector< int > & NumberOfStripsPos() const
Definition: MM_StripToolOutput.h:17
MuonR4::MM_DigitizationTool::m_uncertCalibKey
SG::ReadCondHandleKey< NswErrorCalibData > m_uncertCalibKey
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:54
MuonR4::MuonDigitizationTool::m_onlyUseContainerName
Gaudi::Property< bool > m_onlyUseContainerName
Definition: MuonDigitizationTool.h:134
Amg::y
@ y
Definition: GeoPrimitives.h:35
MuonR4::MuonDigitizationTool::m_mergeSvc
ServiceHandle< PileUpMergeSvc > m_mergeSvc
Definition: MuonDigitizationTool.h:126
MM_StripToolOutput::chipCharge
const std::vector< std::vector< float > > & chipCharge() const
Definition: MM_StripToolOutput.h:18
MuonR4::MuonDigitizationTool::TimedHit
TimedHitPtr< xAOD::MuonSimHit > TimedHit
Definition: MuonDigitizationTool.h:57
MuonR4::MM_DigitizationTool::m_crossTalk2
Gaudi::Property< float > m_crossTalk2
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:92
MuonR4::MM_DigitizationTool::m_doSmearing
Gaudi::Property< bool > m_doSmearing
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:81
MuonR4::MuonDigitizationTool::m_sdoKey
SG::WriteHandleKey< xAOD::MuonSimHitContainer > m_sdoKey
Definition: MuonDigitizationTool.h:132
MuonR4::MM_DigitizationTool::m_timeWindowUpperOffset
Gaudi::Property< double > m_timeWindowUpperOffset
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:70
MuonR4::MM_DigitizationTool::m_writeOutputFile
Gaudi::Property< bool > m_writeOutputFile
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:76
MM_StripsResponseSimulation::ConfigModule
Definition: MM_StripsResponseSimulation.h:64
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
MuonR4::MM_DigitizationTool::m_crossTalk1
Gaudi::Property< float > m_crossTalk1
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:91
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::MM_DigitizationTool::m_vmmARTMode
Gaudi::Property< std::string > m_vmmARTMode
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:65
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
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
MM_DigitToolInput
Definition: MM_DigitToolInput.h:25
MuonR4::MM_DigitizationTool::m_smearingTool
ToolHandle< Muon::INSWCalibSmearingTool > m_smearingTool
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:60
MM_ElectronicsResponseSimulation::ConfigModule
Definition: MM_ElectronicsResponseSimulation.h:34
MuonR4::MM_DigitizationTool::m_useThresholdScaling
Gaudi::Property< bool > m_useThresholdScaling
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:105
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
MuonR4::MM_DigitizationTool::m_digitizeMuonOnly
Gaudi::Property< bool > m_digitizeMuonOnly
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:63
MM_DigitToolOutput
Definition: MM_DigitToolOutput.h:25
MuonR4::MM_DigitizationTool::DigiCache
OutDigitCache_t< MmDigitCollection > DigiCache
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:128
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
xAOD::ChamberViewer
Definition: ChamberViewer.h:59
MuonR4::MM_DigitizationTool::m_vmmNeighborLogic
Gaudi::Property< bool > m_vmmNeighborLogic
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:80
MuonR4::MM_DigitizationTool::m_ARTdeadtime
Gaudi::Property< float > m_ARTdeadtime
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:100
MM_ElectronicsToolInput
Definition: MM_ElectronicsToolInput.h:9
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
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
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
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
MuonR4::MM_DigitizationTool::m_vmmReadoutMode
Gaudi::Property< std::string > m_vmmReadoutMode
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:64
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonR4::MM_DigitizationTool::m_deadTime
Gaudi::Property< double > m_deadTime
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:115
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
MuonR4::MM_DigitizationTool::m_thresholdScaleFactor
Gaudi::Property< float > m_thresholdScaleFactor
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:107
MuonGMR4::MmReadoutElement::readoutSide
int readoutSide(const IdentifierHash &measHash) const
Returns the readout side.
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
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
MuonGMR4::StripDesign::firstStripNumber
int firstStripNumber() const
Returns the number of the first strip.
CaloCondBlobAlgs_fillNoiseFromASCII.channelId
channelId
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:121
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
MuonR4::MM_DigitizationTool::m_writeKey
SG::WriteHandleKey< MmDigitContainer > m_writeKey
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:51
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
MuonGMR4::StripLayer::design
const StripDesign & design(bool phiView=false) const
Returns the underlying strip design.
MuonGMR4::MmReadoutElement::stripLayer
const StripLayer & stripLayer(const Identifier &measId) const
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
MuonR4::MM_DigitizationTool::m_fieldCondObjInputKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCondObjInputKey
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:59
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.
threshold
Definition: chainparser.cxx:74
MuonR4::MM_DigitizationTool::NoiseCalibConstants
NswCalibDbTimeChargeData::CalibConstants NoiseCalibConstants
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:120
MM_StripToolOutput::chipTime
const std::vector< std::vector< float > > & chipTime() const
Definition: MM_StripToolOutput.h:19
charge
double charge(const T &p)
Definition: AtlasPID.h:986
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)
checkTriggerxAOD.found
found
Definition: checkTriggerxAOD.py:328
MuonR4::MM_DigitizationTool::m_qThreshold
Gaudi::Property< float > m_qThreshold
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:89
python.PhysicalConstants.c_light
float c_light
Definition: PhysicalConstants.py:73
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonR4::MM_DigitizationTool::m_stripdeadtime
Gaudi::Property< float > m_stripdeadtime
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:99
MuonR4::MM_DigitizationTool::m_noiseParams
std::map< int, NoiseCalibConstants > m_noiseParams
Define a map to cache the noise parameters individually Key: stationName * std::abs(stationEta)
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:123
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
MM_StripToolOutput
Definition: MM_StripToolOutput.h:9
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
MM_StripsResponseSimulation::ConfigModule::writeOutputFile
bool writeOutputFile
Definition: MM_StripsResponseSimulation.h:80
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
MM_ElectronicsToolInput::digitID
const Identifier & digitID() const
Definition: MM_ElectronicsToolInput.h:35
MuonR4::MM_DigitizationTool::m_timeWindowLowerOffset
Gaudi::Property< double > m_timeWindowLowerOffset
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:68
MmIdHelper
Definition: MmIdHelper.h:54
MuonGMR4::MmReadoutElement::measurementHash
IdentifierHash measurementHash(const Identifier &measId) const override final
Constructs the identifier hash from the full measurement Identifier.
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
MuonGMR4::MmReadoutElement::layerHash
IdentifierHash layerHash(const Identifier &measId) const override final
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
MuonR4::MM_DigitizationTool::m_energyThreshold
Gaudi::Property< double > m_energyThreshold
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:67
MagField::AtlasFieldCache
Local cache for magnetic field (based on MagFieldServices/AtlasFieldSvcTLS.h)
Definition: AtlasFieldCache.h:43
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
MuonR4::MuonDigitizationTool::m_rndmSvc
ServiceHandle< IAthRNGSvc > m_rndmSvc
Definition: MuonDigitizationTool.h:130
MuonR4::MM_DigitizationTool::m_useCondThresholds
Gaudi::Property< bool > m_useCondThresholds
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:103
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
MagField::AtlasFieldCache::getField
void getField(const double *ATH_RESTRICT xyz, double *ATH_RESTRICT bxyz, double *ATH_RESTRICT deriv=nullptr)
get B field value at given position xyz[3] is in mm, bxyz[3] is in kT if deriv[9] is given,...
Definition: AtlasFieldCache.cxx:42
MuonR4::MM_DigitizationTool::combinedStripResponseAllHits
MM_ElectronicsToolInput combinedStripResponseAllHits(const EventContext &ctx, const std::vector< MM_ElectronicsToolInput > &v_stripDigitOutput) const
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.cxx:427
MuonR4::MuonDigitizationTool::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition: MuonDigitizationTool.h:111
MuonR4::MM_DigitizationTool::m_checkMMSimHits
Gaudi::Property< bool > m_checkMMSimHits
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:78
MuonR4::MM_DigitizationTool::m_vmmDeadtime
Gaudi::Property< float > m_vmmDeadtime
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:109
MuonR4::MuonDigitizationTool::DeadTimeMap
std::unordered_map< Identifier, double > DeadTimeMap
Definition: MuonDigitizationTool.h:100
MM_ElectronicsResponseSimulation::ConfigModule::peakTime
float peakTime
power of responce function
Definition: MM_ElectronicsResponseSimulation.h:36
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
MuonR4::MM_DigitizationTool::m_driftGapWidth
Gaudi::Property< float > m_driftGapWidth
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:90
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
python.compressB64.c
def c
Definition: compressB64.py:93
MuonR4::MM_DigitizationTool::m_condThrshldsKey
SG::ReadCondHandleKey< NswCalibDbThresholdData > m_condThrshldsKey
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:56
NSWCalib::MicroMegaGas
Definition: INSWCalibTool.h:36
python.SystemOfUnits.degree
tuple degree
Definition: SystemOfUnits.py:121
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
isMuon
bool isMuon(const T &p)
Definition: AtlasPID.h:202
MuonR4::MM_DigitizationTool::m_avalancheGain
Gaudi::Property< float > m_avalancheGain
Definition: MuonPhaseII/MuonDigitization/MmDigitizationR4/src/MM_DigitizationTool.h:94
Identifier
Definition: IdentifierFieldParser.cxx:14