ATLAS Offline Software
MuonDigitizationTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
5 
8 #include <GeoModelKernel/throwExcept.h>
9 
10 namespace MuonR4{
11 
13  const std::string& name,
14  const IInterface* pIID):
15  PileUpToolBase{type,name, pIID} {}
16 
18  ATH_MSG_INFO("SimHitKey "<<m_simHitKey.key()<<", "<<m_streamName<<", SDO container: "<<m_sdoKey.key());
19  if (m_simHitKey.empty() && m_inputObjectName.empty()) {
20  ATH_MSG_FATAL("Property <SimHitKey> not set !");
21  return StatusCode::FAILURE;
22  }
23  if (m_streamName.empty()) {
24  ATH_MSG_FATAL("Property "<<m_streamName<<" not set !");
25  return StatusCode::FAILURE;
26  }
29  ATH_CHECK(m_mergeSvc.retrieve());
30  }
32  ATH_CHECK(m_simHitKey.initialize());
34  ATH_CHECK(m_sdoKey.initialize(!m_sdoKey.empty()));
35  ATH_CHECK(m_rndmSvc.retrieve());
37  ATH_CHECK(m_idHelperSvc.retrieve());
38  return StatusCode::SUCCESS;
39  }
40 
41  StatusCode MuonDigitizationTool::prepareEvent(const EventContext& /*ctx*/,
42  unsigned int nInputEvents) {
43 
44  ATH_MSG_DEBUG("prepareEvent() called for " << nInputEvents << " input events");
45  m_timedHits.clear();
46  m_simHits.clear();
47  return StatusCode::SUCCESS;
48  }
49 
51  for (const auto& [timeIndex, simHitColl] : hitColl) {
52  timedHits.reserve(timedHits.capacity() + simHitColl->size());
53  for (const xAOD::MuonSimHit* simHit : *simHitColl) {
54  timedHits.emplace_back(timeIndex.time(), timeIndex.index(), simHit, timeIndex.type());
55  }
56  }
57  std::sort(timedHits.begin(), timedHits.end(),
58  [](const TimedHit& a, const TimedHit& b){
59  if (a->identify() != b->identify()){
60  return a->identify() < b->identify();
61  }
62  if (a.eventId() != b.eventId()) {
63  return a.eventId() < b.eventId();
64  }
65  return a.eventTime() < b.eventTime();
66  });
67  return StatusCode::SUCCESS;
68  }
70  return hit.eventTime() + hit->globalTime();
71  }
72  StatusCode MuonDigitizationTool::processAllSubEvents(const EventContext& ctx) {
73  const MuonDigitizationTool* digiTool = this;
74  return digiTool->processAllSubEvents(ctx);
75  }
76 
77  StatusCode MuonDigitizationTool::processAllSubEvents(const EventContext& ctx) const {
78  PileUpHits hitCollList{};
79  TimedHits timedHits{};
81  if (!m_onlyUseContainerName) {
82  const xAOD::MuonSimHitContainer* hitCollection{nullptr};
83  ATH_CHECK(retrieveContainer(ctx, m_simHitKey, hitCollection));
84  hitCollList.emplace_back(PileUpTimeEventIndex(0), hitCollection);
85  } else {
86  ATH_CHECK(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList));
87  }
88  ATH_CHECK(fillTimedHits(std::move(hitCollList), timedHits));
90  if (!m_sdoKey.empty()) {
91  sdoContainer = SG::WriteHandle<xAOD::MuonSimHitContainer>{m_sdoKey, ctx};
92  ATH_CHECK(sdoContainer.record(std::make_unique<xAOD::MuonSimHitContainer>(),
93  std::make_unique<xAOD::MuonSimHitAuxContainer>()));
94  }
95  ATH_CHECK(digitize(ctx, timedHits, !m_sdoKey.empty() ? sdoContainer.ptr() : nullptr));
96  return StatusCode::SUCCESS;
97  }
98  StatusCode MuonDigitizationTool::mergeEvent(const EventContext& ctx) {
99  ATH_MSG_DEBUG("mergeEvent()");
100 
102  if (!m_sdoKey.empty()) {
103  sdoContainer = SG::WriteHandle<xAOD::MuonSimHitContainer>{m_sdoKey, ctx};
104  ATH_CHECK(sdoContainer.record(std::make_unique<xAOD::MuonSimHitContainer>(),
105  std::make_unique<xAOD::MuonSimHitAuxContainer>()));
106  }
107  ATH_CHECK(digitize(ctx, m_timedHits, !m_sdoKey.empty() ? sdoContainer.ptr() : nullptr));
108  m_timedHits.clear();
109  m_simHits.clear();
110  return StatusCode::SUCCESS;
111  }
112 
113 
114  StatusCode MuonDigitizationTool::processBunchXing(int bunchXing,
115  SubEventIterator bSubEvents,
116  SubEventIterator eSubEvents) {
117  ATH_MSG_DEBUG("processBunchXing()" << bunchXing);
118  PileUpHits hitList{}, hitListPermanent{};
119  ATH_CHECK(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitList, bunchXing, bSubEvents, eSubEvents));
120  ATH_MSG_VERBOSE(hitList.size() << " hits in xAODMuonSimHitContainer " << m_inputObjectName << " found");
121  for (auto& [hitPtr, hitContainer] : hitList) {
122  auto copyContainer = std::make_unique<xAOD::MuonSimHitContainer>();
123  auto copyAuxContainer = std::make_unique<xAOD::MuonSimHitAuxContainer>();
124  copyContainer->setStore(copyAuxContainer.get());
125  for (const xAOD::MuonSimHit* copyMe : *hitContainer) {
126  (*copyContainer->push_back(std::make_unique<xAOD::MuonSimHit>())) = (*copyMe);
127  }
128  hitListPermanent.emplace_back(hitPtr, copyContainer.get());
129  m_simHits.emplace_back(std::move(copyContainer), std::move(copyAuxContainer));
130  }
131  ATH_CHECK(fillTimedHits(std::move(hitListPermanent), m_timedHits));
132  return StatusCode::SUCCESS;
133  }
134 
135  CLHEP::HepRandomEngine* MuonDigitizationTool::getRandomEngine(const EventContext&ctx) const {
136  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, m_streamName);
137  std::string rngName = m_streamName;
138  rngWrapper->setSeed(rngName, ctx);
139  return rngWrapper->getEngine(ctx);
140  }
141  const ActsGeometryContext& MuonDigitizationTool::getGeoCtx(const EventContext& ctx) const {
142  const ActsGeometryContext* gctx{};
143  if (!retrieveContainer(ctx, m_geoCtxKey, gctx).isSuccess()) {
144  THROW_EXCEPTION("Failed to retrieve the geometry context "<<m_geoCtxKey.fullKey());
145  }
146  return *gctx;
147  }
148  xAOD::MuonSimHit* MuonDigitizationTool::addSDO(const TimedHit& hit,
149  xAOD::MuonSimHitContainer* sdoContainer) const {
150  if(!sdoContainer) {
151  ATH_MSG_VERBOSE("No SDO container setup of writing");
152  return nullptr;
153  }
154  if (!m_includePileUpTruth && HepMC::ignoreTruthLink(hit->genParticleLink(), m_vetoPileUpTruthLinks)) {
155  ATH_MSG_VERBOSE("Hit "<<m_idHelperSvc->toString(hit->identify())<<" is a pile-up truth link");
156  return nullptr;
157  }
158 
159  xAOD::MuonSimHit* sdoHit = sdoContainer->push_back(std::make_unique<xAOD::MuonSimHit>());
160  (*sdoHit) = (*hit);
161  static const SG::Accessor<float> acc_eventTime{"MuSim_evtTime"};
162  static const SG::Accessor<unsigned short> acc_eventID{"MuSim_evtID"};
163  static const SG::Accessor<unsigned short> acc_puType{"MuSim_puType"};
164  acc_eventTime(*sdoHit) = hit.eventTime();
165  acc_eventID(*sdoHit) = hit.eventId();
166  acc_puType(*sdoHit) = hit.pileupType();
167  return sdoHit;
168  }
169  bool MuonDigitizationTool::passDeadTime(const Identifier& channelId,
170  const double hitTime,
171  const double deadTimeWindow,
172  DeadTimeMap& deadTimeMap) {
173  auto insertItr = deadTimeMap.insert(std::make_pair(channelId,hitTime));
175  if (insertItr.second) {
176  return true;
177  }
178  if (hitTime - insertItr.first->second < deadTimeWindow) {
179  return false;
180  }
182  insertItr.first->second = hitTime;
183  return true;
184  }
185 }
MuonR4::MuonDigitizationTool::m_inputObjectName
std::string m_inputObjectName
Definition: MuonDigitizationTool.h:168
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
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:152
xAOD::MuonSimHit_v1
Definition: MuonSimHit_v1.h:18
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
MuonR4::MuonDigitizationTool::m_simHitKey
SG::ReadHandleKey< xAOD::MuonSimHitContainer > m_simHitKey
Definition: MuonDigitizationTool.h:150
MuonR4::MuonDigitizationTool::fillTimedHits
StatusCode fillTimedHits(PileUpHits &&hitColl, TimedHits &timedHits) const
Translates the PileUpHits into the timed hits format.
Definition: MuonDigitizationTool.cxx:50
MuonR4::MuonDigitizationTool::m_streamName
Gaudi::Property< std::string > m_streamName
Definition: MuonDigitizationTool.h:157
MuonR4::MuonDigitizationTool::PileUpHits
PileUpMergeSvc::TimedList< xAOD::MuonSimHitContainer >::type PileUpHits
Definition: MuonDigitizationTool.h:145
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
SG::Accessor< float >
MuonR4::MuonDigitizationTool::m_onlyUseContainerName
Gaudi::Property< bool > m_onlyUseContainerName
Definition: MuonDigitizationTool.h:163
MuonR4::MuonDigitizationTool::m_mergeSvc
ServiceHandle< PileUpMergeSvc > m_mergeSvc
Definition: MuonDigitizationTool.h:155
MuonR4::MuonDigitizationTool::m_sdoKey
SG::WriteHandleKey< xAOD::MuonSimHitContainer > m_sdoKey
Definition: MuonDigitizationTool.h:161
MuonSimHitAuxContainer.h
TimedHitPtr< xAOD::MuonSimHit >
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
THROW_EXCEPTION
#define THROW_EXCEPTION(MSG)
Definition: MMReadoutElement.cxx:48
HepMC::ignoreTruthLink
bool ignoreTruthLink(const T &p, bool vetoPileUp)
Helper function for SDO creation in PileUpTools.
Definition: MagicNumbers.h:345
MuonDigitizationTool.h
TimedHitPtr::eventTime
float eventTime() const
t0 offset of the bunch xing containing the hit in ns.
Definition: TimedHitPtr.h:53
MuonR4::MuonDigitizationTool::MuonDigitizationTool
MuonDigitizationTool(const std::string &type, const std::string &name, const IInterface *pIID)
Definition: MuonDigitizationTool.cxx:12
TimedHitPtr::pileupType
int pileupType() const
the type of event which the hit came from (signal, low pt minbias, high pt minbias,...
Definition: TimedHitPtr.h:49
MuonR4::MuonDigitizationTool::m_timedHits
TimedHits m_timedHits
Definition: MuonDigitizationTool.h:170
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
MuonR4::MuonDigitizationTool::prepareEvent
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.
Definition: MuonDigitizationTool.cxx:41
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
CaloCondBlobAlgs_fillNoiseFromASCII.channelId
channelId
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:122
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
PileUpToolBase
Definition: PileUpToolBase.h:18
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
RNGWrapper.h
MuonR4::MuonDigitizationTool::processAllSubEvents
StatusCode processAllSubEvents(const EventContext &ctx) override final
alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.
Definition: MuonDigitizationTool.cxx:72
MuonR4
This header ties the generic definitions in this package.
Definition: HoughEventData.h:16
MuonR4::MuonDigitizationTool::initialize
StatusCode initialize() override
Definition: MuonDigitizationTool.cxx:17
MuonR4::MuonDigitizationTool::m_simHits
std::vector< SimHitLocalCopy > m_simHits
Definition: MuonDigitizationTool.h:174
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
a
TList * a
Definition: liststreamerinfos.cxx:10
MuonR4::MuonDigitizationTool
Barebone implementation of the I/O infrastructure for all MuonDigitizationTools.
Definition: MuonDigitizationTool.h:41
TimedHitPtr::eventId
unsigned short eventId() const
the index of the component event in PileUpEventInfo.
Definition: TimedHitPtr.h:45
MuonR4::MuonDigitizationTool::TimedHits
std::vector< TimedHitPtr< xAOD::MuonSimHit > > TimedHits
Definition: MuonDigitizationTool.h:71
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
MuonR4::MuonDigitizationTool::m_idHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
Definition: MuonDigitizationTool.h:142
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
MuonR4::MuonDigitizationTool::m_rndmSvc
ServiceHandle< IAthRNGSvc > m_rndmSvc
Definition: MuonDigitizationTool.h:159
MuonR4::MuonDigitizationTool::m_detMgr
const MuonGMR4::MuonDetectorManager * m_detMgr
Definition: MuonDigitizationTool.h:140
SubEventIterator
std::vector< xAOD::EventInfo::SubEvent >::const_iterator SubEventIterator
Definition: IPileUpTool.h:22
MuonR4::MuonDigitizationTool::DeadTimeMap
std::unordered_map< Identifier, double > DeadTimeMap
Definition: MuonDigitizationTool.h:129
hitTime
float hitTime(const AFP_SIDSimHit &hit)
Definition: AFP_SIDSimHit.h:39
PileUpTimeEventIndex
a struct encapsulating the identifier of a pile-up event
Definition: PileUpTimeEventIndex.h:12
Identifier
Definition: IdentifierFieldParser.cxx:14