ATLAS Offline Software
TRTDigitizationTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // TRTDigitizationTool.cxx
7 //
8 // Implementation file for class TRTDigitizationTool
9 //
11 
12 #include "TRTDigitizationTool.h"
15 #include "TRTProcessingOfStraw.h"
17 
18 #include "TRTDigCondBase.h"
19 #include "TRTDigCondFakeMap.h"
20 
21 #include "TRTNoise.h"
22 #include "TRTDigiHelper.h"
23 #include "TRTElectronicsNoise.h"
24 
25 #include "Identifier/Identifier.h"
28 
30 
31 // Det descr includes:
32 #include "InDetIdentifier/TRT_ID.h"
34 #include "TRTDigSettings.h"
35 
38 
39 // Gaudi includes
40 #include "GaudiKernel/EventContext.h"
41 #include "GaudiKernel/ThreadLocalContext.h"
42 
43 //CondDB
45 
46 // Random Number Generation
48 #include "CLHEP/Random/RandomEngine.h"
49 #include "CLHEP/Random/RandGaussZiggurat.h"
50 
51 
52 //_____________________________________________________________________________
54  const std::string& name,
55  const IInterface* parent)
57 {
58  m_settings = new TRTDigSettings();
59  m_settings->addPropertiesForOverrideableParameters(static_cast<AlgTool*>(this));
60 }
61 
62 //_____________________________________________________________________________
64 
65  ATH_MSG_VERBOSE ( "Begin TRTDigitizationTool::Destructor");
67  delete m_pProcessingOfStraw;
68  delete m_pDigConditions;
69  delete m_pNoise;
70  delete m_settings;
71  ATH_MSG_VERBOSE ( "End TRTDigitizationTool::Destructor");
72 
73 }
74 
75 //_____________________________________________________________________________
77 {
78 
79  ATH_MSG_DEBUG ( name()<<"::initialize() begin" );
80 
81  // Get the TRT Detector Manager
83  ATH_MSG_DEBUG ( "Retrieved TRT_DetectorManager with version " << m_manager->getVersion().majorNum() );
84 
85  ATH_CHECK(detStore()->retrieve(m_trt_id, "TRT_ID"));
86 
87  // Fill setting defaults and process joboption overrides:
89 
91  m_settings->printFlagsForOverrideableParameters("TRTDigSettings Overrideables : ");
92  }
93 
95 
96  ATH_CHECK(m_TRTpaiToolXe.retrieve());
97  ATH_MSG_DEBUG ( "Retrieved the PAI Tool for Xe straws" );
98 
99  ATH_CHECK(m_TRTpaiToolAr.retrieve());
100  ATH_MSG_DEBUG ( "Retrieved the PAI Tool for Ar straws" );
101 
102  ATH_CHECK(m_TRTpaiToolKr.retrieve());
103  ATH_MSG_DEBUG ( "Retrieved the PAI Tool for Kr straws" );
104 
106  ATH_CHECK(m_TRTsimdrifttimetool.retrieve());
107  ATH_MSG_DEBUG ( "Retrieved the Sim. Drifttime Tool" );
108 
109  // Check data object name
110  if (m_hitsContainerKey.key().empty()) {
111  ATH_MSG_FATAL ( "Property DataObjectName not set!" );
112  return StatusCode::FAILURE;
113  }
115  ATH_MSG_DEBUG ( "Input hits: " << m_dataObjectName );
116 
117  // Initialize ReadHandleKey
118  ATH_CHECK(m_hitsContainerKey.initialize(true));
119 
120  // Initialize data handle keys
121  ATH_CHECK(m_outputRDOCollName.initialize());
123 
124  // Get Random Service
125  ATH_CHECK(m_rndmSvc.retrieve());
126 
127  // Get the Particle Properties Service
128  ATH_CHECK(m_ppSvc.retrieve());
129  m_particleTable = m_ppSvc->PDT();
130 
131  //locate the PileUpMergeSvc and initialize our local ptr
133  ATH_CHECK(m_mergeSvc.retrieve());
134  }
135 
136  //Retrieve TRT_StrawNeighbourService.
137  ATH_CHECK(m_TRTStrawNeighbourSvc.retrieve());
138 
139  //Retrieve TRT_CalDbTool
140  if (m_settings->getT0FromData()) {
141  ATH_CHECK(m_calDbTool.retrieve());
142  }
143  else {
144  m_calDbTool.disable();
145  }
146 
148 
149  // Set SDO readout range
150  const double intervalBetweenCrossings(m_settings->timeInterval() / 3.);
151 
152  switch ( (m_settings->storeSDO() )) {
153  case 0: m_minCrossingTimeSDO = -1.*CLHEP::ns; m_maxCrossingTimeSDO = -1.*CLHEP::ns; break;
154  case 1: m_minCrossingTimeSDO = -1.*CLHEP::ns; m_maxCrossingTimeSDO = (intervalBetweenCrossings * 2. + 1.*CLHEP::ns); break;
155  case 2: m_minCrossingTimeSDO = -(intervalBetweenCrossings * 2. + 1.*CLHEP::ns); m_maxCrossingTimeSDO = (intervalBetweenCrossings * 2. + 1.*CLHEP::ns); break;
156  default:
157  ATH_MSG_ERROR ( "storeSDO is out of range:"<<m_settings->storeSDO()<<"allowed values are: 0,1,2. Setting storeSDO = 2 " );
159  break;
160  }
161 
165 
166  return StatusCode::SUCCESS;
167 }
168 
169 //_____________________________________________________________________________
170 StatusCode TRTDigitizationTool::prepareEvent(const EventContext& /*ctx*/, unsigned int)
171 {
172  m_vDigits.clear();
173  m_trtHitCollList.clear();
176  return StatusCode::SUCCESS;
177 }
178 
179 //_____________________________________________________________________________
181  SubEventIterator bSubEvents,
182  SubEventIterator eSubEvents) {
183 
184  m_seen.emplace_back(std::distance(bSubEvents,eSubEvents), bunchXing);
185  //decide if this event will be processed depending on HardScatterSplittingMode & bunchXing
186  if (m_HardScatterSplittingMode == 2 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; return StatusCode::SUCCESS; }
187  if (m_HardScatterSplittingMode == 1 && m_HardScatterSplittingSkipper ) { return StatusCode::SUCCESS; }
189 
190 
191  //TRTUncompressedHit
192 
194  TimedHitCollList hitCollList;
195 
196  if (!(m_mergeSvc->retrieveSubSetEvtData(m_dataObjectName, hitCollList, bunchXing,
197  bSubEvents, eSubEvents).isSuccess()) &&
198  hitCollList.empty()) {
199  ATH_MSG_ERROR("Could not fill TimedHitCollList");
200  return StatusCode::FAILURE;
201  } else {
202  ATH_MSG_VERBOSE(hitCollList.size() << " TRTUncompressedHitCollection with key " <<
203  m_dataObjectName << " found");
204  }
205 
206  TimedHitCollList::iterator iColl(hitCollList.begin());
207  TimedHitCollList::iterator endColl(hitCollList.end());
208 
209  for( ; iColl != endColl; ++iColl){
210  TRTUncompressedHitCollection *hitCollPtr = new TRTUncompressedHitCollection(*iColl->second);
211  PileUpTimeEventIndex timeIndex(iColl->first);
212  ATH_MSG_DEBUG("TRTUncompressedHitCollection found with " << hitCollPtr->size() <<
213  " hits");
214  ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time()
215  << " index: " << timeIndex.index()
216  << " type: " << timeIndex.type());
217  m_thpctrt->insert(timeIndex, hitCollPtr);
218  m_trtHitCollList.push_back(hitCollPtr);
219  }
220 
221  return StatusCode::SUCCESS;
222 }
223 
224 //_____________________________________________________________________________
226 
227  // setup the RNGs which are only used in the first event
228  CLHEP::HepRandomEngine *fakeCondRndmEngine = getRandomEngine("TRT_FakeConditions", m_randomSeedOffset, ctx);
229  CLHEP::HepRandomEngine *noiseInitRndmEngine = getRandomEngine("TRT_Noise", m_randomSeedOffset, ctx);
230  CLHEP::HepRandomEngine *noiseElecRndmEngine = getRandomEngine("TRT_Noise_Electronics", m_randomSeedOffset, ctx);
231  CLHEP::HepRandomEngine *noiseThreshRndmEngine = getRandomEngine("TRT_Noise_ThresholdFluctuations", m_randomSeedOffset, ctx);
232  CLHEP::HepRandomEngine *noiseElecResetRndmEngine = getRandomEngine("TRT_ElectronicsNoiseReset", m_randomSeedOffset, ctx);
233  m_first_event=false;
234 
235  //Resuming initialiazation. Section below had to be moved into event loop due to dependence on conditions data
236 
237  TRTElectronicsNoise *electronicsNoise(nullptr);
239  electronicsNoise = new TRTElectronicsNoise(m_settings, noiseElecRndmEngine);
240  }
241  // ElectronicsProcessing is needed for the regular straw processing,
242  // but also for the noise (it assumes ownership of electronicsnoise )
244 
246  m_manager,
247  m_trt_id,
248  m_UseGasMix,
249  m_sumTool);
250 
251  m_pDigConditions->initialize(fakeCondRndmEngine);
252 
254 
255  // In short this next constructor does 3 things;
256  // i) tunes the amplitude of the electronics noise,
257  // ii) creates a pool of noise digits,
258  // iii) figures out exact low thresholds needed to reproduce actual
259  // straw noise-frequencies:
261  m_manager,
262  noiseInitRndmEngine,
263  noiseElecRndmEngine,
264  noiseThreshRndmEngine,
265  noiseElecResetRndmEngine,
268  electronicsNoise,
269  m_trt_id,
270  m_UseGasMix,
271  m_sumTool);
272 
273  ATH_MSG_DEBUG ( "Average straw noise level is " << m_pDigConditions->strawAverageNoiseLevel() );
274 
275  } else {
276  m_pNoise = nullptr;
277  }
278 
279  ITRT_PAITool *TRTpaiToolXe = &(* m_TRTpaiToolXe);
280  ITRT_PAITool *TRTpaiToolAr = &(* m_TRTpaiToolAr);
281  ITRT_PAITool *TRTpaiToolKr = &(* m_TRTpaiToolKr);
282 
283  ITRT_SimDriftTimeTool *pTRTsimdrifttimetool = &(*m_TRTsimdrifttimetool);
284 
285  const ITRT_CalDbTool* calDbTool = nullptr;
286  if (m_settings->getT0FromData()) {
287  calDbTool = m_calDbTool.get();
288  }
291  m_manager,
292  TRTpaiToolXe,
293  pTRTsimdrifttimetool,
295  m_pNoise,
298  m_trt_id,
299  TRTpaiToolAr,
300  TRTpaiToolKr,
301  calDbTool);
302 
303  ATH_MSG_INFO ( "Gas Property: UseGasMix is " << m_UseGasMix );
304 
305  return StatusCode::SUCCESS;
306 }
307 
308 //_____________________________________________________________________________
311  std::set<int>& sim_hitids, std::set<Identifier>& simhitsIdentifiers,
312  CLHEP::HepRandomEngine *rndmEngine,
313  CLHEP::HepRandomEngine *strawRndmEngine,
314  CLHEP::HepRandomEngine *elecProcRndmEngine,
315  CLHEP::HepRandomEngine *elecNoiseRndmEngine,
316  CLHEP::HepRandomEngine *paiRndmEngine) {
317 
318  // Create a map for the SDO
320 
322  MagField::AtlasFieldCache fieldCache;
324 
325  // Get field cache object
327  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
328 
329  if (fieldCondObj == nullptr) {
330  ATH_MSG_ERROR("Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
331  return StatusCode::FAILURE;
332  }
333  fieldCondObj->getInitializedCache (fieldCache);
334  }
335 
337 
338 
339  ATH_CHECK(simDataMap.record(std::make_unique<InDetSimDataCollection>() ));
340 
341  // Register the map into StoreGate
342  if (not simDataMap.isValid()) {
343  ATH_MSG_FATAL ( "InDetSimData map " << m_outputSDOCollName.key() << " could not be registered in StoreGate !" );
344  return StatusCode::FAILURE;
345  } else {
346  ATH_MSG_DEBUG ( "InDetSimData map " << m_outputSDOCollName.key() << " registered in StoreGate" );
347  }
348 
349  m_cosmicEventPhase = 0.0;
350  if (m_settings->doCosmicTimingPit()) {
352  };
353 
354  // Create a vector of deposits
355  std::vector<InDetSimData::Deposit> depositVector(100);
356 
357  // loop over all straws
359  while (thpctrt.nextDetectorElement(i, e)) {
360 
361  int hitID((*i)->GetHitID()); // Get hitID
362 
363  // evtIndex should be 0 for main event and 1,2,3,... for pileup events:
364  // (event Id is a property of the TimedHitPtr)
365  HepMcParticleLink::index_type evtIndex(i->eventId());
366 
367  if ( m_settings->noiseInUnhitStraws() ) {
368  sim_hitids.insert(hitID);
369  }
370  //Safeguard against a rare case of hitID corruption found by Davide:
371  if ( hitID & 0xc0000000 ) {
372  ATH_MSG_ERROR ( "Hit ID not Valid (" << MSG::hex << hitID << ")" << MSG::dec );
373  continue;
374  }
375 
376  // Convert hitID to Identifier
377  IdentifierHash IdHash;
378  Identifier idLayer;
379  bool identifierOK;
380  Identifier idStraw(getIdentifier(hitID, IdHash, idLayer, identifierOK));
381  if ( !identifierOK ) {
382  ATH_MSG_ERROR ( "Ignoring simhits with suspicious identifier (1)" );
383  continue;
384  }
385 
386  //For crosstalk sim
387  simhitsIdentifiers.insert(idStraw);
388 
390  // Fill a vector of deposits
391  depositVector.clear();
392  depositVector.reserve(std::distance(i,e));
393  for (TimedHitCollection<TRTUncompressedHit>::const_iterator hit_iter(i); hit_iter != e; ++hit_iter ) {
394  // create a new deposit
395  InDetSimData::Deposit deposit( HepMcParticleLink::getRedirectedLink((*hit_iter)->particleLink(), hit_iter->eventId(), ctx), // This link should now correctly resolve to the TruthEvent McEventCollection in the main StoreGateSvc.
396  (*hit_iter)->GetEnergyDeposit() );
397  if (HepMC::ignoreTruthLink(deposit.first, m_vetoPileUpTruthLinks)) {
398  continue;
399  }
400  ATH_MSG_VERBOSE ( "Deposit: trackID " << deposit.first << " energyDeposit " << deposit.second );
401  depositVector.emplace_back(std::move(deposit));
402  }
403 
404  const TimedHitPtr<TRTUncompressedHit>& theHit(*i);
405  const double bunchCrossingTime(hitTime(theHit) - static_cast<double>(theHit->GetGlobalTime()));
406 
407  // Add the simdata object to the map.
408  if ( !depositVector.empty() &&
409  (evtIndex == 0 || ((*i)->GetKineticEnergy()>m_minpileuptruthEkin)) &&
410  (bunchCrossingTime < m_maxCrossingTimeSDO) && (bunchCrossingTime > m_minCrossingTimeSDO) ) {
411  simDataMap->try_emplace(idStraw, std::move(depositVector));
412  }
414 
415  // Digitization for the given straw
416  TRTDigit digit_straw;
417 
419  //if (m_settings->doCosmicTimingPit()) {
420  // if ( StatusCode::SUCCESS == evtStore()->retrieve(m_ComTime,"ComTime")) {
421  // ATH_MSG_VERBOSE ( "Found tool for cosmic timing: ComTime" );
422  // } else {
423  // ATH_MSG_ERROR ( "Did not find tool needed for cosmic timing: ComTime" );
424  // }
425  //}
426 
427  // if StatusHT == 6 thats emulate argon, ==7 that's emulate krypton
428  bool emulateArFlag = m_sumTool->getStatusHT(idStraw, ctx) == 6;
429  bool emulateKrFlag = m_sumTool->getStatusHT(idStraw, ctx) == 7;
430  const int statusHT = m_sumTool->getStatusHT(idStraw, ctx);
431  m_pProcessingOfStraw->ProcessStraw(fieldCache, i, e, digit_straw,
433  m_cosmicEventPhase, //m_ComTime,
435  emulateArFlag,
436  emulateKrFlag,
437  strawRndmEngine,
438  elecProcRndmEngine,
439  elecNoiseRndmEngine,
440  paiRndmEngine);
441 
442  // Print out the digits etc (for debugging)
443  //int mstrw = digit_straw.GetStrawID();
444  //unsigned int mword = digit_straw.GetDigit();
445  //std::cout << "AJB " << mstrw << ":" << mword << std::endl;
446  //print_mword_properties(mword);
447  //std::cout << "AJB "; bits24(mword);
448  //std::cout << "AJB "; bits27(mword);
449 
450  // finally push back the output digit.
451  if ( digit_straw.GetDigit() ) {
452  m_vDigits.push_back(digit_straw);
453  }
454 
455  } // end of straw loop
456 
457  return StatusCode::SUCCESS;
458 }
459 
460 //_____________________________________________________________________________
462 
463  // Set the RNGs to use for this event.
464  CLHEP::HepRandomEngine *rndmEngine = getRandomEngine("", ctx);
465  CLHEP::HepRandomEngine *elecNoiseRndmEngine = getRandomEngine("TRT_ElectronicsNoise", ctx);
466  CLHEP::HepRandomEngine *noiseRndmEngine = getRandomEngine("TRT_NoiseDigitPool", ctx);
467  CLHEP::HepRandomEngine *strawRndmEngine = getRandomEngine("TRT_ProcessStraw", ctx);
468  CLHEP::HepRandomEngine *elecProcRndmEngine = getRandomEngine("TRT_ThresholdFluctuations", ctx);
469  CLHEP::HepRandomEngine *paiRndmEngine = getRandomEngine("TRT_PAI", ctx);
470 
471  if (m_first_event) {
472  if(this->lateInitialize(ctx).isFailure()) {
473  ATH_MSG_FATAL ( "lateInitialize method failed!" );
474  return StatusCode::FAILURE;
475  }
476  }
477 
479 
480  ATH_MSG_DEBUG ( "TRTDigitizationTool::processAllSubEvents()" );
481 
483  ATH_CHECK(m_trtrdo_container.record(std::make_unique<TRT_RDO_Container>(m_trt_id->straw_layer_hash_max())));
484  ATH_MSG_DEBUG ( " TRT_RDO_Container created " );
485 
486  if (not m_trtrdo_container.isValid()) {
487  ATH_MSG_FATAL ( "Container " << m_outputRDOCollName.key() << " could not be registered in StoreGate !" );
488  return StatusCode::FAILURE;
489  }else {
490  ATH_MSG_DEBUG ( "Container " << m_outputRDOCollName.key() << " registered in StoreGate" );
491  }
492 
493  m_vDigits.clear();
494 
495  // get the container(s)
498  // In case of single hits container just load the collection using read handles
499  if (!m_onlyUseContainerName) {
501  if (!hitCollection.isValid()) {
502  ATH_MSG_ERROR("Could not get TRTUncompressedHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
503  return StatusCode::FAILURE;
504  }
505 
506  // Define Hit Collection
507  thpctrt.reserve(1);
508 
509  // create a new hits collection
510  thpctrt.insert(0, hitCollection.cptr());
511  ATH_MSG_DEBUG("TRTUncompressedHitCollection found with " << hitCollection->size() << " hits");
512  }
513  else {
514  TimedHitCollList hitCollList; // this is a list<pair<time_t, DataLink<TRTUncompressedHitCollection> > >
515  unsigned int numberOfSimHits(0);
516  if ( !(m_mergeSvc->retrieveSubEvtsData(m_dataObjectName, hitCollList, numberOfSimHits).isSuccess()) && hitCollList.empty() ) {
517  ATH_MSG_ERROR ( "Could not fill TimedHitCollList" );
518  return StatusCode::FAILURE;
519  } else {
520  ATH_MSG_DEBUG ( hitCollList.size() << " TRTUncompressedHitCollections with key " << m_dataObjectName << " found" );
521  }
522 
523  // Define Hit Collection
524  thpctrt.reserve(numberOfSimHits);
525 
526  //now merge all collections into one
527  TimedHitCollList::iterator iColl(hitCollList.begin());
528  TimedHitCollList::iterator endColl(hitCollList.end() );
530  // loop on the hit collections
531  while ( iColl != endColl ) {
532  //decide if this event will be processed depending on HardScatterSplittingMode & bunchXing
534  if (m_HardScatterSplittingMode == 1 && m_HardScatterSplittingSkipper ) { ++iColl; continue; }
536  const TRTUncompressedHitCollection* p_collection(iColl->second);
537  thpctrt.insert(iColl->first, p_collection);
538  ATH_MSG_DEBUG ( "TRTUncompressedHitCollection found with " << p_collection->size() << " hits" );
539  ++iColl;
540  }
541  }
542 
543  //Set of all hitid's with simhits (used for noise simulation).
544  std::set<int> sim_hitids;
545  std::set<Identifier> simhitsIdentifiers;
546 
547  // Process the Hits straw by straw: get the iterator pairs for given straw
548  ATH_CHECK(this->processStraws(ctx, thpctrt, sim_hitids, simhitsIdentifiers, rndmEngine, strawRndmEngine, elecProcRndmEngine, elecNoiseRndmEngine,paiRndmEngine));
549 
550  // no more hits
551 
552  //Noise in straws without simhits:
554  const int numberOfDigitsBeforeNoise(m_vDigits.size());
555 
556  m_pNoise->appendPureNoiseToProperDigits(m_vDigits, sim_hitids, noiseRndmEngine);
557  if (m_settings->doCrosstalk()) {
558  m_pNoise->appendCrossTalkNoiseToProperDigits(m_vDigits, simhitsIdentifiers,m_TRTStrawNeighbourSvc, noiseRndmEngine);
559  }
560 
561  ATH_MSG_DEBUG ( " Number of digits " << m_vDigits.size() << " (" << m_vDigits.size()-numberOfDigitsBeforeNoise << " of those are pure noise)" );
562 
564 
565  } else {
566  ATH_MSG_DEBUG ( " Number of digits " << m_vDigits.size() );
567  }
568 
569  // All digits are ready.
570  // We just need to convert to relevant identifiers and output to storegate.
571 
572  if (createAndStoreRDOs().isFailure()) {
573  ATH_MSG_FATAL ( "createAndStoreRDOs() failed!" );
574  return StatusCode::FAILURE;
575  }
576  else {
577  ATH_MSG_DEBUG ( "createAndStoreRDOs() succeeded" );
578  }
579 
580  return StatusCode::SUCCESS;
581 }
582 
583 CLHEP::HepRandomEngine* TRTDigitizationTool::getRandomEngine(const std::string& streamName,
584  const EventContext& ctx) const
585 {
586  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, streamName);
587  std::string rngName = name()+streamName;
588  rngWrapper->setSeed( rngName, ctx );
589  return rngWrapper->getEngine(ctx);
590 }
591 
592 //_____________________________________________________________________________
593 CLHEP::HepRandomEngine* TRTDigitizationTool::getRandomEngine(const std::string& streamName, unsigned long int randomSeedOffset,
594  const EventContext& ctx) const
595 {
596  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, streamName);
597  rngWrapper->setSeed( streamName, ctx.slot(), randomSeedOffset, ctx.eventID().run_number() );
598  return rngWrapper->getEngine(ctx);
599 }
600 
601 //_____________________________________________________________________________
602 StatusCode TRTDigitizationTool::mergeEvent(const EventContext& ctx) {
603  std::vector<std::pair<unsigned int, int> >::iterator ii(m_seen.begin());
604  std::vector<std::pair<unsigned int, int> >::iterator ee(m_seen.end());
605  while (ii != ee) {
606  ATH_MSG_DEBUG( "mergeEvent: there are " << ii->first << " events in bunch xing " << ii->second );
607  ++ii;
608  }
609 
610  // Set the RNGs to use for this event.
611  CLHEP::HepRandomEngine *rndmEngine = getRandomEngine("", ctx);
612  CLHEP::HepRandomEngine *elecNoiseRndmEngine = getRandomEngine("TRT_ElectronicsNoise", ctx);
613  CLHEP::HepRandomEngine *noiseRndmEngine = getRandomEngine("TRT_NoiseDigitPool", ctx);
614  CLHEP::HepRandomEngine *strawRndmEngine = getRandomEngine("TRT_ProcessStraw", ctx);
615  CLHEP::HepRandomEngine *elecProcRndmEngine = getRandomEngine("TRT_ThresholdFluctuations", ctx);
616  CLHEP::HepRandomEngine *paiRndmEngine = getRandomEngine("TRT_PAI", ctx);
617 
618  if (m_first_event) {
619  if(this->lateInitialize(ctx).isFailure()) {
620  ATH_MSG_FATAL ( "lateInitialize method failed!" );
621  return StatusCode::FAILURE;
622  }
623  }
624 
626 
627  ATH_MSG_DEBUG ( "TRTDigitization::execute()" );
628 
630  ATH_CHECK(m_trtrdo_container.record(std::make_unique<TRT_RDO_Container>(m_trt_id->straw_layer_hash_max())));
631  ATH_MSG_DEBUG ( " TRT_RDO_Container created " );
632  if (not m_trtrdo_container.isValid()) {
633  ATH_MSG_FATAL ( "Container " << m_outputRDOCollName.key() << " could not be registered in StoreGate !" );
634  return StatusCode::FAILURE;
635  } else {
636  ATH_MSG_DEBUG ( "Container " << m_outputRDOCollName.key() << " registered in StoreGate" );
637  }
638 
639  //Set of all hitid's with simhits (used for noise simulation).
640  std::set<int> sim_hitids;
641  std::set<Identifier> simhitsIdentifiers;
642 
643  // Process the Hits straw by straw:
644  // get the iterator pairs for given straw
645  ATH_CHECK(this->processStraws(ctx, *m_thpctrt, sim_hitids, simhitsIdentifiers, rndmEngine, strawRndmEngine, elecProcRndmEngine, elecNoiseRndmEngine,paiRndmEngine));
646 
647  delete m_thpctrt;
649  m_trtHitCollList.clear();
650  // no more hits
651 
652  //Noise in straws without simhits:
654  const unsigned int numberOfDigitsBeforeNoise(m_vDigits.size());
655 
656  m_pNoise->appendPureNoiseToProperDigits(m_vDigits, sim_hitids, noiseRndmEngine);
657  if (m_settings->doCrosstalk()) {
658  m_pNoise->appendCrossTalkNoiseToProperDigits(m_vDigits, simhitsIdentifiers,m_TRTStrawNeighbourSvc, noiseRndmEngine);
659  }
660 
661  ATH_MSG_DEBUG ( " Number of digits " << m_vDigits.size() << " (" << m_vDigits.size()-numberOfDigitsBeforeNoise << " of those are pure noise)" );
662 
664 
665  } else {
666  ATH_MSG_DEBUG ( " Number of digits " << m_vDigits.size() );
667  };
668 
669  // All digits are ready.
670  // We just need to convert to relevant identifiers and output to storegate.
671 
672  if (createAndStoreRDOs().isFailure()) {
673  ATH_MSG_FATAL ( "createAndStoreRDOs() failed!" );
674  return StatusCode::FAILURE;
675  }
676  else {
677  ATH_MSG_DEBUG ( "createAndStoreRDOs() succeeded" );
678  }
679 
680  return StatusCode::SUCCESS;
681 }
682 
683 //_____________________________________________________________________________
685 {
686 
687  std::vector<TRTDigit>::const_iterator TRTDigitIter(m_vDigits.begin());
688  std::vector<TRTDigit>::const_iterator endOfTRTDigits(m_vDigits.end());
689 
690  // for testing
691  IdentifierHash IdHash; // default value is 0xFFFFFFFF
692  IdentifierHash IdHashOld; // default value is 0xFFFFFFFF
693  TRT_RDO_Collection *RDOColl(nullptr);
694 
695  Identifier idStraw;
696 
697  while (TRTDigitIter != endOfTRTDigits) {
698  ATH_MSG_DEBUG ( "Digit ID " << TRTDigitIter->GetStrawID() << " Digit " << TRTDigitIter->GetDigit() );
699 
700  Identifier layer_id;
701  bool identifierOK(false);
702  idStraw = getIdentifier(TRTDigitIter->GetStrawID(), IdHash, layer_id, identifierOK);
703  if (!identifierOK) {
704  ATH_MSG_ERROR ( "Ignoring simhits with suspicious identifier (2)" );
705  ++TRTDigitIter;
706  continue;
707  };
708 
709  // Create new TRT RDO Collection
710  ATH_MSG_DEBUG ( " RDO ID " << m_trt_id->print_to_string(idStraw) );
711 
712  //TK: wauv - we are really betting the farm on the fact that the
713  //ordering of digits will result in a similar ordering of the
714  //idhash'es here... (this is not immediately the case when noise
715  //hits are appended afterwards).
716 
717  if (IdHash != IdHashOld) {
718  RDOColl = new TRT_RDO_Collection(IdHash);
719  ATH_MSG_DEBUG ( "New TRT RDO Collection created with IdHash " << static_cast<int>(IdHash) );
720  IdHashOld = IdHash;
721  RDOColl->setIdentifier(layer_id);
722 
723  // Add to the container
724  if (m_trtrdo_container->addCollection(RDOColl, RDOColl->identifyHash()).isFailure()) {
725  ATH_MSG_FATAL ( "Container " << m_outputRDOCollName.key() << " could not be registered in StoreGate !" );
726  return StatusCode::FAILURE;
727  } else {
728  ATH_MSG_DEBUG ( "Container " << m_outputRDOCollName.key() << " registered in StoreGate" );
729  }
730  }
731 
732  // Put RDO into Collection
733  TRT_LoLumRawData *p_rdo(new TRT_LoLumRawData(idStraw, TRTDigitIter->GetDigit()));
734  if (RDOColl) {
735  RDOColl->push_back(p_rdo);
736  } else {
737  ATH_MSG_FATAL ( "Failed to create the TRT_RDO_Collection before trying to add an RDO to it! IdHash = " << static_cast<int>(IdHash) );
738  delete p_rdo;
739  return StatusCode::FAILURE;
740  }
741  ++TRTDigitIter;
742  }
743 
744  m_vDigits.clear();
745  return StatusCode::SUCCESS;
746 }
747 
748 
749 //_____________________________________________________________________________
751  IdentifierHash& hashId,
752  Identifier& IdLayer,
753  bool & statusok ) const
754 {
755  statusok = true;
756 
757  Identifier IdStraw;
758 
759  const int mask(0x0000001F);
760  const int word_shift(5);
761  int trtID, ringID, moduleID, layerID, strawID;
762  int wheelID, planeID, sectorID;
763 
764  const InDetDD::TRT_BarrelElement *barrelElement;
765  const InDetDD::TRT_EndcapElement *endcapElement;
766 
767  if ( !(hitID & 0x00200000) ) { // barrel
768  strawID = hitID & mask;
769  hitID >>= word_shift;
770  layerID = hitID & mask;
771  hitID >>= word_shift;
772  moduleID = hitID & mask;
773  hitID >>= word_shift;
774  ringID = hitID & mask;
775  trtID = hitID >> word_shift;
776 
777  barrelElement = m_manager->getBarrelElement(trtID, ringID, moduleID, layerID);
778  if ( barrelElement ) {
779  hashId = barrelElement->identifyHash();
780  IdLayer = barrelElement->identify();
781  IdStraw = m_trt_id->straw_id(IdLayer, strawID);
782  } else {
783  ATH_MSG_ERROR ( "Could not find detector element for barrel identifier with "
784  << "(ipos,iring,imod,ilayer,istraw) = ("
785  << trtID << ", " << ringID << ", " << moduleID << ", "
786  << layerID << ", " << strawID << ")" );
787  statusok = false;
788  }
789  } else { // endcap
790  strawID = hitID & mask;
791  hitID >>= word_shift;
792  planeID = hitID & mask;
793  hitID >>= word_shift;
794  sectorID = hitID & mask;
795  hitID >>= word_shift;
796  wheelID = hitID & mask;
797  trtID = hitID >> word_shift;
798 
799  // change trtID (which is 2/3 for endcaps) to use 0/1 in getEndcapElement
800  if (trtID == 3) { trtID = 0; }
801  else { trtID = 1; }
802 
803  endcapElement = m_manager->getEndcapElement(trtID, wheelID, planeID, sectorID);
804 
805  if ( endcapElement ) {
806  hashId = endcapElement->identifyHash();
807  IdLayer = endcapElement->identify();
808  IdStraw = m_trt_id->straw_id(IdLayer, strawID);
809  } else {
810  ATH_MSG_ERROR ( "Could not find detector element for endcap identifier with "
811  << "(ipos,iwheel,isector,iplane,istraw) = ("
812  << trtID << ", " << wheelID << ", " << sectorID << ", "
813  << planeID << ", " << strawID << ")" );
814  ATH_MSG_ERROR ( "If this happens very rarely, don't be alarmed (it is a Geant4 'feature')" );
815  ATH_MSG_ERROR ( "If it happens a lot, you probably have misconfigured geometry in the sim. job." );
816  statusok = false;
817  }
818 
819  }
820 
821  return IdStraw;
822 }
823 
824 //_____________________________________________________________________________
826 
828  m_settings->print("TRTDigSettings Settings : ");
829  }
830 
831  ATH_MSG_INFO ( "TRTDigitizationTool::finalize()" );
832 
833  return StatusCode::SUCCESS;
834 }
835 
836 //_____________________________________________________________________________
837 double TRTDigitizationTool::getCosmicEventPhase(CLHEP::HepRandomEngine *rndmEngine) {
838  // 13th February 2015: replace ComTime with a hack (fixme) based on an
839  // event phase distribution from Alex (alejandro.alonso@cern.ch) that
840  // is modelled as a Guassian of mean 5.48 ns and sigma 8.91 ns.
841  return CLHEP::RandGaussZiggurat::shoot(rndmEngine, 5.48, 8.91);
842 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
TRTProcessingOfStraw.h
TRTDigSettings::pileUpSDOsMinEkin
double pileUpSDOsMinEkin() const
Get minimum Ekin for pileup track to enter MC-truth.
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
TRTDigCondFakeMap.h
TRTDigSettings::getT0FromData
bool getT0FromData() const
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
TRTDigSettings::doCosmicTimingPit
bool doCosmicTimingPit() const
Cosmics timing corresponding to pit setup?
InDetDD::TRT_BarrelElement
Definition: TRT_BarrelElement.h:43
TRTDigit::GetDigit
unsigned GetDigit() const
Get digit.
Definition: TRTDigit.h:27
InDetRawDataCollection::setIdentifier
void setIdentifier(Identifier id)
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TRTDigitizationTool::m_rndmSvc
ServiceHandle< IAthRNGSvc > m_rndmSvc
Random number service.
Definition: TRTDigitizationTool.h:129
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
TRT_DetectorManager.h
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
TRTDigSettings.h
TRTDigSettings::useMagneticFieldMap
bool useMagneticFieldMap() const
ITRT_PAITool
Definition: ITRT_PAITool.h:20
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
TRT_LoLumRawData
Definition: TRT_LoLumRawData.h:25
TRTDigitizationTool::m_calDbTool
ToolHandle< ITRT_CalDbTool > m_calDbTool
Definition: TRTDigitizationTool.h:127
SG::VarHandleBase::name
const std::string & name() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:75
InDetDD::TRT_DetectorManager::getBarrelElement
const TRT_BarrelElement * getBarrelElement(unsigned int positive, unsigned int moduleIndex, unsigned int phiIndex, unsigned int strawLayerIndex) const
Access Barrel Elements:---------------—(Fast)-------------------------—.
Definition: TRT_DetectorManager.cxx:100
TRTDigitizationTool::m_vDigits
std::vector< TRTDigit > m_vDigits
Vector of all digits.
Definition: TRTDigitizationTool.h:150
TRTNoise::sortDigits
static void sortDigits(std::vector< TRTDigit > &digitVect)
Definition: TRTNoise.cxx:447
TRT_RDO_Collection.h
AtlasHitsVector
Definition: AtlasHitsVector.h:32
TRTNoise::appendCrossTalkNoiseToProperDigits
void appendCrossTalkNoiseToProperDigits(std::vector< TRTDigit > &digitVect, const std::set< Identifier > &simhitsIdentifiers, const ServiceHandle< ITRT_StrawNeighbourSvc > &m_TRTStrawNeighbourSvc, CLHEP::HepRandomEngine *noiseRndmEngine)
Definition: TRTNoise.cxx:356
TRTDigitizationTool::m_outputRDOCollName
SG::WriteHandleKey< TRT_RDO_Container > m_outputRDOCollName
name of the output RDOs.
Definition: TRTDigitizationTool.h:137
TRT_ID.h
This is an Identifier helper class for the TRT subdetector. This class is a factory for creating comp...
TRTDigitizationTool::processBunchXing
virtual StatusCode processBunchXing(int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
called for each active bunch-crossing to process current SubEvents bunchXing is in ns
Definition: TRTDigitizationTool.cxx:180
InDetDD::TRT_EndcapElement
Definition: TRT_EndcapElement.h:43
TRTDigitizationTool::~TRTDigitizationTool
~TRTDigitizationTool()
Destructor.
Definition: TRTDigitizationTool.cxx:63
TRTElectronicsProcessing
Electronics Processing.
Definition: TRTElectronicsProcessing.h:23
TRTDigSettings::printFlagsForOverrideableParameters
void printFlagsForOverrideableParameters(const std::string &front="") const
Print TRT digitization settings overrideable parameters.
Definition: TRTDigSettings.cxx:251
TRTDigitizationTool::processStraws
StatusCode processStraws(const EventContext &ctx, TimedHitCollection< TRTUncompressedHit > &thpctrt, std::set< int > &sim_hitids, std::set< Identifier > &simhitsIdentifiers, CLHEP::HepRandomEngine *rndmEngine, CLHEP::HepRandomEngine *strawRndmEngine, CLHEP::HepRandomEngine *elecProcRndmEngine, CLHEP::HepRandomEngine *elecNoiseRndmEngine, CLHEP::HepRandomEngine *paiRndmEngine)
Definition: TRTDigitizationTool.cxx:309
TRTDigSettings::addPropertiesForOverrideableParameters
void addPropertiesForOverrideableParameters(Algorithm *alg)
Add properties for overrideable parameters.
Definition: TRTDigSettings.cxx:214
TRTDigSettings::noiseInUnhitStraws
bool noiseInUnhitStraws() const
Query whether simulation of noise in unhit straws.
TRTDigitizationTool::m_trtrdo_container
SG::WriteHandle< TRT_RDO_Container > m_trtrdo_container
Definition: TRTDigitizationTool.h:139
PileUpTimeEventIndex::index
index_type index() const
the index of the component event in PileUpEventInfo
Definition: PileUpTimeEventIndex.cxx:76
TRTDigitizationTool::m_seen
std::vector< std::pair< unsigned int, int > > m_seen
Definition: TRTDigitizationTool.h:149
TRTDigitizationTool::m_pNoise
TRTNoise * m_pNoise
Definition: TRTDigitizationTool.h:154
TimedHitPtr< TRTUncompressedHit >
TRTDigitizationTool.h
a sample implementation of IPileUpTool to test the framework
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
TRTDigitizationTool::m_settings
TRTDigSettings * m_settings
Definition: TRTDigitizationTool.h:147
TRTDigitizationTool::m_fieldCacheCondObjInputKey
SG::ReadCondHandleKey< AtlasFieldCacheCondObj > m_fieldCacheCondObjInputKey
Definition: TRTDigitizationTool.h:132
HepMC::ignoreTruthLink
bool ignoreTruthLink(const T &p, bool vetoPileUp)
Helper function for SDO creation in PileUpTools.
Definition: MagicNumbers.h:344
TRTDigitizationTool::m_pDigConditions
TRTDigCondBase * m_pDigConditions
Definition: TRTDigitizationTool.h:153
TimedHitCollection::nextDetectorElement
bool nextDetectorElement(const_iterator &b, const_iterator &e)
sets an iterator range with the hits of current detector element returns a bool when done
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
ReadCondHandle.h
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:459
PileUpToolBase::m_vetoPileUpTruthLinks
Gaudi::Property< int > m_vetoPileUpTruthLinks
Definition: PileUpToolBase.h:58
TRTDigitizationTool::m_particleTable
const HepPDT::ParticleDataTable * m_particleTable
Definition: TRTDigitizationTool.h:169
PileUpMergeSvc::TimedList::type
std::list< value_t > type
type of the collection of timed data object
Definition: PileUpMergeSvc.h:73
TRTDigitizationTool::m_mergeSvc
ServiceHandle< PileUpMergeSvc > m_mergeSvc
Definition: TRTDigitizationTool.h:128
InDetRawDataCollection::identifyHash
virtual IdentifierHash identifyHash() const override final
TRTDigitizationTool::m_randomSeedOffset
Gaudi::Property< unsigned long int > m_randomSeedOffset
Definition: TRTDigitizationTool.h:145
TRTDigCondFakeMap
"Fake" straw map until "real" map is known.
Definition: TRTDigCondFakeMap.h:14
TRTDigitizationTool::m_manager
const InDetDD::TRT_DetectorManager * m_manager
Definition: TRTDigitizationTool.h:156
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
TRTElectronicsNoise
Simulate TRT Electronics Noise For description of metod, see Thomas Kittelmanns PhD thesis chapters ...
Definition: TRTElectronicsNoise.h:18
TRTDigitizationTool::getRandomEngine
CLHEP::HepRandomEngine * getRandomEngine(const std::string &streamName, const EventContext &ctx) const
Definition: TRTDigitizationTool.cxx:583
TRT_RDO_Collection
InDetRawDataCollection< TRT_RDORawData > TRT_RDO_Collection
Definition: TRT_RDO_Collection.h:20
TRTDigitizationTool::createAndStoreRDOs
StatusCode createAndStoreRDOs()
Definition: TRTDigitizationTool.cxx:684
TRTNoise::appendPureNoiseToProperDigits
void appendPureNoiseToProperDigits(std::vector< TRTDigit > &digitVect, const std::set< int > &sim_hitids, CLHEP::HepRandomEngine *noiseRndmEngine)
Append noise digits to list of digits from proper hits.
Definition: TRTNoise.cxx:333
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TimedHitCollection::insert
void insert(const PileUpTimeEventIndex &timeEventIndex, const AtlasHitsVector< HIT > *inputCollection)
TRTDigitizationTool::prepareEvent
virtual StatusCode prepareEvent(const EventContext &ctx, const unsigned int nInputEvents) override final
return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase...
Definition: TRTDigitizationTool.cxx:170
lumiFormat.i
int i
Definition: lumiFormat.py:85
TRTDigitizationTool::m_TRTpaiToolAr
ToolHandle< ITRT_PAITool > m_TRTpaiToolAr
Definition: TRTDigitizationTool.h:123
TimedHitCollection::reserve
void reserve(unsigned int numberOfHits)
reserve a timed vector numberOfHits in size.
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
TRTDigitizationTool::m_minpileuptruthEkin
double m_minpileuptruthEkin
Definition: TRTDigitizationTool.h:163
TRTDigitizationTool::m_dataObjectName
std::string m_dataObjectName
Definition: TRTDigitizationTool.h:136
TRTDigitizationTool::getCosmicEventPhase
static double getCosmicEventPhase(CLHEP::HepRandomEngine *rndmEngine)
Definition: TRTDigitizationTool.cxx:837
SG::VarHandleBase::store
std::string store() const
Return the name of the store holding the object we are proxying.
Definition: StoreGate/src/VarHandleBase.cxx:382
TRTDigitizationTool::m_UseGasMix
Gaudi::Property< int > m_UseGasMix
Definition: TRTDigitizationTool.h:144
TRTNoise
Simulation of noise hits in the TRT.
Definition: TRTNoise.h:39
InDetSimData.h
InDetRawDataCollection
Definition: InDetRawDataCollection.h:31
InDetDD::InDetDetectorManager::getVersion
const Version & getVersion() const
Get version information.
Definition: InDetDetectorManager.cxx:33
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TimedHitCollection.h
TRTDigitizationTool::m_pProcessingOfStraw
TRTProcessingOfStraw * m_pProcessingOfStraw
Definition: TRTDigitizationTool.h:152
InDetDD::Version::majorNum
int majorNum() const
Major version number.
Definition: Version.cxx:62
TRTDigitizationTool::m_printOverrideableSettings
Gaudi::Property< bool > m_printOverrideableSettings
Definition: TRTDigitizationTool.h:141
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
InDetDD::TRT_BaseElement::identify
virtual Identifier identify() const override final
identifier of this detector element:
TRTDigitizationTool::m_sumTool
ToolHandle< ITRT_StrawStatusSummaryTool > m_sumTool
Definition: TRTDigitizationTool.h:126
TRTElectronicsProcessing.h
TRTDigiHelper.h
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
TRTDigit
Class for TRT digits.
Definition: TRTDigit.h:11
TRTDigitizationTool::m_TRTpaiToolKr
ToolHandle< ITRT_PAITool > m_TRTpaiToolKr
Definition: TRTDigitizationTool.h:124
ITRT_CalDbTool
Definition: ITRT_CalDbTool.h:30
InDetDD::TRT_BaseElement::identifyHash
virtual IdentifierHash identifyHash() const override final
identifier hash
TRTDigitizationTool::getIdentifier
Identifier getIdentifier(int hitID, IdentifierHash &hashId, Identifier &layerID, bool &statusok) const
Definition: TRTDigitizationTool.cxx:750
TRTDigSettings::noiseInSimhits
bool noiseInSimhits() const
Query whether simulation of noise in hit straws.
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
PileUpToolBase
Definition: PileUpToolBase.h:18
TRTProcessingOfStraw
TRT Digitization: Processing of a TRT Straws.
Definition: TRTProcessingOfStraw.h:54
TRTDigitizationTool::processAllSubEvents
virtual StatusCode processAllSubEvents(const EventContext &ctx) override final
Perform digitization:
Definition: TRTDigitizationTool.cxx:461
TRTDigitizationTool::m_HardScatterSplittingMode
Gaudi::Property< int > m_HardScatterSplittingMode
Definition: TRTDigitizationTool.h:143
TRTProcessingOfStraw::ProcessStraw
void ProcessStraw(MagField::AtlasFieldCache &fieldCache, hitCollConstIter i, hitCollConstIter e, TRTDigit &outdigit, bool &m_alreadyPrintedPDGcodeWarning, double m_cosmicEventPhase, int strawGasType, bool emulationArflag, bool emulationKrflag, CLHEP::HepRandomEngine *rndmEngine, CLHEP::HepRandomEngine *elecProcRndmEngine, CLHEP::HepRandomEngine *elecNoiseRndmEngine, CLHEP::HepRandomEngine *paiRndmEngine)
Process this straw all the way from Geant4 hit to output digit.
Definition: TRTProcessingOfStraw.cxx:250
InDetDD::TRT_DetectorManager::getEndcapElement
const TRT_EndcapElement * getEndcapElement(unsigned int positive, unsigned int wheelIndex, unsigned int strawLayerIndex, unsigned int phiIndex) const
Access Endcap Elements:---------------—(Fast)--------------------------—.
Definition: TRT_DetectorManager.cxx:116
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
AtlasDetectorID::print_to_string
std::string print_to_string(Identifier id, const IdContext *context=0) const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:418
TRTDigitizationTool::TRTDigitizationTool
TRTDigitizationTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TRTDigitizationTool.cxx:53
WriteHiveWithMetaData.streamName
string streamName
Definition: WriteHiveWithMetaData.py:22
SG::WriteHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
TRTDigitizationTool::m_TRTStrawNeighbourSvc
ServiceHandle< ITRT_StrawNeighbourSvc > m_TRTStrawNeighbourSvc
Definition: TRTDigitizationTool.h:130
ATHRNG::RNGWrapper
A wrapper class for event-slot-local random engines.
Definition: RNGWrapper.h:56
PileUpTimeEventIndex::time
time_type time() const
bunch xing time in ns
Definition: PileUpTimeEventIndex.cxx:71
TRTDigitizationTool::m_trtHitCollList
std::vector< TRTUncompressedHitCollection * > m_trtHitCollList
Definition: TRTDigitizationTool.h:158
TRTDigCondBase.h
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)
TRTElectronicsNoise.h
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
TRTDigitizationTool::lateInitialize
StatusCode lateInitialize(const EventContext &ctx)
Definition: TRTDigitizationTool.cxx:225
SG::WriteHandle< InDetSimDataCollection >
TRTDigitizationTool::m_trt_id
const TRT_ID * m_trt_id
TRT Id Helper.
Definition: TRTDigitizationTool.h:157
TRTDigitizationTool::m_TRTpaiToolXe
ToolHandle< ITRT_PAITool > m_TRTpaiToolXe
Configurable properties.
Definition: TRTDigitizationTool.h:122
TRTDigitizationTool::m_printUsedDigSettings
Gaudi::Property< bool > m_printUsedDigSettings
Definition: TRTDigitizationTool.h:142
TRTUncompressedHitCollection.h
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
TRTDigitizationTool::m_pElectronicsProcessing
TRTElectronicsProcessing * m_pElectronicsProcessing
Definition: TRTDigitizationTool.h:151
TRTDigSettings::storeSDO
unsigned int storeSDO() const
TRTDigitizationTool::m_cosmicEventPhase
double m_cosmicEventPhase
Definition: TRTDigitizationTool.h:165
TRTDigSettings::timeInterval
double timeInterval() const
Get time interval covered by each digit.
TRTDigitizationTool::initialize
virtual StatusCode initialize() override final
Initialize.
Definition: TRTDigitizationTool.cxx:76
TRTDigitizationTool::mergeEvent
virtual StatusCode mergeEvent(const EventContext &ctx) override final
called at the end of the subevts loop. Not (necessarily) able to access SubEvents
Definition: TRTDigitizationTool.cxx:602
TRTNoise.h
InDetSimDataCollection.h
MagField::AtlasFieldCache
Local cache for magnetic field (based on MagFieldServices/AtlasFieldSvcTLS.h)
Definition: AtlasFieldCache.h:43
ITRT_SimDriftTimeTool
Definition: ITRT_SimDriftTimeTool.h:30
TRTDigitizationTool::m_maxCrossingTimeSDO
double m_maxCrossingTimeSDO
Definition: TRTDigitizationTool.h:162
TRTDigSettings::print
void print(const std::string &front="") const
Printing of TRT digitization settings.
Definition: TRTDigSettings.cxx:181
AtlasHitsVector::size
size_type size() const
Definition: AtlasHitsVector.h:142
SubEventIterator
std::vector< xAOD::EventInfo::SubEvent >::const_iterator SubEventIterator
Definition: IPileUpTool.h:22
TRTDigitizationTool::finalize
virtual StatusCode finalize() override final
Finalize.
Definition: TRTDigitizationTool.cxx:825
TRTDigSettings::initialize
void initialize(const InDetDD::TRT_DetectorManager *detmgr)
Initialize: fill defaults and overwrite by user values where appropriate.
Definition: TRTDigSettings.cxx:47
TRTDigiHelper::StrawGasType
int StrawGasType(int statusHT, int useGasMix, MsgStream *log)
Definition: TRTDigiHelper.cxx:11
TRTDigitizationTool::m_alreadyPrintedPDGcodeWarning
bool m_alreadyPrintedPDGcodeWarning
Definition: TRTDigitizationTool.h:160
TRTDigitizationTool::m_outputSDOCollName
SG::WriteHandleKey< InDetSimDataCollection > m_outputSDOCollName
name of the output SDOs.
Definition: TRTDigitizationTool.h:138
hitTime
float hitTime(const AFP_SIDSimHit &hit)
Definition: AFP_SIDSimHit.h:39
TRTDigitizationTool::m_first_event
bool m_first_event
Definition: TRTDigitizationTool.h:171
TRTDigSettings
Class containing parameters and settings used by TRT digitization.
Definition: TRTDigSettings.h:34
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
TRT_ID::straw_layer_hash_max
size_type straw_layer_hash_max() const
Definition: TRT_ID.h:914
InDetSimData::Deposit
std::pair< HepMcParticleLink, float > Deposit
Definition: InDetSimData.h:48
TRTDigitizationTool::m_hitsContainerKey
SG::ReadHandleKey< TRTUncompressedHitCollection > m_hitsContainerKey
Definition: TRTDigitizationTool.h:135
TRTDigSettings::doCrosstalk
bool doCrosstalk() const
Switch on crosstalk noise based on Cosmic 08 measurements.
PileUpTimeEventIndex
a struct encapsulating the identifier of a pile-up event
Definition: PileUpTimeEventIndex.h:12
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
PileUpTimeEventIndex::type
PileUpType type() const
the pileup type - minbias, cavern, beam halo, signal?
Definition: PileUpTimeEventIndex.cxx:81
TRTDigitizationTool::m_HardScatterSplittingSkipper
bool m_HardScatterSplittingSkipper
Definition: TRTDigitizationTool.h:173
TRTDigitizationTool::m_TRTsimdrifttimetool
ToolHandle< ITRT_SimDriftTimeTool > m_TRTsimdrifttimetool
Definition: TRTDigitizationTool.h:125
TRTDigitizationTool::m_thpctrt
TimedHitCollection< TRTUncompressedHit > * m_thpctrt
Definition: TRTDigitizationTool.h:159
TRTDigitizationTool::m_onlyUseContainerName
Gaudi::Property< bool > m_onlyUseContainerName
Definition: TRTDigitizationTool.h:134
TRTDigCondBase::strawAverageNoiseLevel
float strawAverageNoiseLevel() const
Get average noise level in straw.
Definition: TRTDigCondBase.cxx:47
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
TimedHitCollection< TRTUncompressedHit >
python.SystemOfUnits.ns
float ns
Definition: SystemOfUnits.py:146
TRTDigitizationTool::m_minCrossingTimeSDO
double m_minCrossingTimeSDO
Definition: TRTDigitizationTool.h:161
TRT_ID::straw_id
Identifier straw_id(int barrel_ec, int phi_module, int layer_or_wheel, int straw_layer, int straw) const
Three ways of getting id for a single straw:
Definition: TRT_ID.h:575
TRT_LoLumRawData.h
TRTDigitizationTool::m_ppSvc
ServiceHandle< IPartPropSvc > m_ppSvc
Handle on the particle property service.
Definition: TRTDigitizationTool.h:168
TRTDigCondBase::initialize
void initialize(CLHEP::HepRandomEngine *rndmEngine)
Definition: TRTDigCondBase.cxx:64
Identifier
Definition: IdentifierFieldParser.cxx:14
TRTUncompressedHitCollection
AtlasHitsVector< TRTUncompressedHit > TRTUncompressedHitCollection
Definition: TRTUncompressedHitCollection.h:16