ATLAS Offline Software
Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
TRTDigitizationTool Class Referenceabstract

#include <TRTDigitizationTool.h>

Inheritance diagram for TRTDigitizationTool:
Collaboration diagram for TRTDigitizationTool:

Public Member Functions

 TRTDigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
 
 ~TRTDigitizationTool ()
 Destructor. More...
 
virtual StatusCode initialize () override final
 Initialize. More...
 
virtual StatusCode finalize () override final
 Finalize. More...
 
virtual StatusCode mergeEvent (const EventContext &ctx) override final
 called at the end of the subevts loop. Not (necessarily) able to access SubEvents More...
 
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 More...
 
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 as FirstXing<=bunchXing<=LastXing More...
 
virtual StatusCode processAllSubEvents (const EventContext &ctx) override final
 Perform digitization: More...
 
virtual bool toProcess (int bunchXing) const =0
 flags whether this tool is "live" for bunchXing (time in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing More...
 
virtual bool filterPassed () const =0
 flags whether the event should be removed or not More...
 
virtual void resetFilter ()=0
 reset the filter More...
 
 DeclareInterfaceID (IPileUpTool, 1, 0)
 Creates the InterfaceID and interfaceID() method. More...
 

Private Member Functions

CLHEP::HepRandomEngine * getRandomEngine (const std::string &streamName, const EventContext &ctx) const
 
CLHEP::HepRandomEngine * getRandomEngine (const std::string &streamName, unsigned long int randomSeedOffset, const EventContext &ctx) const
 
Identifier getIdentifier (int hitID, IdentifierHash &hashId, Identifier &layerID, bool &statusok) const
 
StatusCode lateInitialize (const EventContext &ctx)
 
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)
 
StatusCode createAndStoreRDOs ()
 

Static Private Member Functions

static double getCosmicEventPhase (CLHEP::HepRandomEngine *rndmEngine)
 

Private Attributes

ToolHandle< ITRT_PAIToolm_TRTpaiToolXe {this, "PAI_Tool_Xe", "TRT_PAI_Process_Xe", "The PAI model for ionisation in the TRT Xe gas"}
 Configurable properties. More...
 
ToolHandle< ITRT_PAIToolm_TRTpaiToolAr {this, "PAI_Tool_Ar", "TRT_PAI_Process_Ar", "The PAI model for ionisation in the TRT Ar gas"}
 
ToolHandle< ITRT_PAIToolm_TRTpaiToolKr {this, "PAI_Tool_Kr", "TRT_PAI_Process_Kr", "The PAI model for ionisation in the TRT Kr gas"}
 
ToolHandle< ITRT_SimDriftTimeToolm_TRTsimdrifttimetool {this, "SimDriftTimeTool", "TRT_SimDriftTimeTool", "Drift time versus distance (r-t-relation) for TRT straws"}
 
ToolHandle< ITRT_StrawStatusSummaryToolm_sumTool {this, "InDetTRTStrawStatusSummaryTool", "TRT_StrawStatusSummaryTool", ""}
 
ToolHandle< ITRT_CalDbToolm_calDbTool {this, "InDetTRTCalDbTool", "TRT_CalDbTool", ""}
 
ServiceHandle< PileUpMergeSvcm_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service"}
 
ServiceHandle< IAthRNGSvcm_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
 Random number service. More...
 
ServiceHandle< ITRT_StrawNeighbourSvcm_TRTStrawNeighbourSvc {this, "TRT_StrawNeighbourSvc", "TRT_StrawNeighbourSvc", ""}
 
SG::ReadCondHandleKey< AtlasFieldCacheCondObjm_fieldCacheCondObjInputKey
 
Gaudi::Property< bool > m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}
 
SG::ReadHandleKey< TRTUncompressedHitCollectionm_hitsContainerKey {this, "DataObjectName", "TRTUncompressedHits", "Data Object Name"}
 
std::string m_dataObjectName {""}
 
SG::WriteHandleKey< TRT_RDO_Containerm_outputRDOCollName {this,"OutputObjectName","TRT_RDOs","WHK Output Object name"}
 name of the output RDOs. More...
 
SG::WriteHandleKey< InDetSimDataCollectionm_outputSDOCollName {this,"OutputSDOName","TRT_SDO_Map","WHK Output SDO container name"}
 name of the output SDOs. More...
 
SG::WriteHandle< TRT_RDO_Containerm_trtrdo_container
 
Gaudi::Property< bool > m_printOverrideableSettings {this, "PrintOverrideableSettings", false, "Print overrideable settings"}
 
Gaudi::Property< bool > m_printUsedDigSettings {this, "PrintDigSettings", true, "Print ditigization settings"}
 
Gaudi::Property< int > m_HardScatterSplittingMode {this, "HardScatterSplittingMode", 0, ""}
 
Gaudi::Property< int > m_UseGasMix {this, "UseGasMix", 0, ""}
 
Gaudi::Property< unsigned long int > m_randomSeedOffset {this, "RandomSeedOffset", 678910, ""}
 
TRTDigSettingsm_settings {}
 
std::vector< std::pair< unsigned int, int > > m_seen
 
std::vector< TRTDigitm_vDigits
 Vector of all digits. More...
 
TRTElectronicsProcessingm_pElectronicsProcessing {}
 
TRTProcessingOfStrawm_pProcessingOfStraw {}
 
TRTDigCondBasem_pDigConditions {}
 
TRTNoisem_pNoise {}
 
const InDetDD::TRT_DetectorManagerm_manager {}
 
const TRT_IDm_trt_id {}
 TRT Id Helper. More...
 
std::vector< TRTUncompressedHitCollection * > m_trtHitCollList
 
TimedHitCollection< TRTUncompressedHit > * m_thpctrt {}
 
bool m_alreadyPrintedPDGcodeWarning {false}
 
double m_minCrossingTimeSDO {0.0}
 
double m_maxCrossingTimeSDO {0.0}
 
double m_minpileuptruthEkin {0.0}
 
double m_cosmicEventPhase {0.0}
 
ServiceHandle< IPartPropSvc > m_ppSvc {this, "PartPropSvc", "PartPropSvc"}
 Handle on the particle property service. More...
 
const HepPDT::ParticleDataTable * m_particleTable {}
 
bool m_first_event {true}
 
bool m_HardScatterSplittingSkipper {false}
 

structors and AlgTool implementation

virtual bool toProcess (int bunchXing) const override
 the method this base class helps implementing More...
 
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 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 63 of file TRTDigitizationTool.h.

Constructor & Destructor Documentation

◆ TRTDigitizationTool()

TRTDigitizationTool::TRTDigitizationTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 53 of file TRTDigitizationTool.cxx.

57 {
58  m_settings = new TRTDigSettings();
59  m_settings->addPropertiesForOverrideableParameters(static_cast<AlgTool*>(this));
60 }

◆ ~TRTDigitizationTool()

TRTDigitizationTool::~TRTDigitizationTool ( )

Destructor.

Definition at line 63 of file TRTDigitizationTool.cxx.

63  {
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 }

Member Function Documentation

◆ createAndStoreRDOs()

StatusCode TRTDigitizationTool::createAndStoreRDOs ( )
private

Definition at line 684 of file TRTDigitizationTool.cxx.

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 }

◆ DeclareInterfaceID()

IPileUpTool::DeclareInterfaceID ( IPileUpTool  ,
,
 
)
inherited

Creates the InterfaceID and interfaceID() method.

◆ filterPassed() [1/2]

virtual bool IPileUpTool::filterPassed ( ) const
pure virtualinherited

flags whether the event should be removed or not

◆ filterPassed() [2/2]

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 TRTDigitizationTool::finalize ( )
finaloverridevirtual

Finalize.

Definition at line 825 of file TRTDigitizationTool.cxx.

825  {
826 
828  m_settings->print("TRTDigSettings Settings : ");
829  }
830 
831  ATH_MSG_INFO ( "TRTDigitizationTool::finalize()" );
832 
833  return StatusCode::SUCCESS;
834 }

◆ getCosmicEventPhase()

double TRTDigitizationTool::getCosmicEventPhase ( CLHEP::HepRandomEngine *  rndmEngine)
staticprivate

Definition at line 837 of file TRTDigitizationTool.cxx.

837  {
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 }

◆ getIdentifier()

Identifier TRTDigitizationTool::getIdentifier ( int  hitID,
IdentifierHash hashId,
Identifier layerID,
bool &  statusok 
) const
private

Definition at line 750 of file TRTDigitizationTool.cxx.

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 }

◆ getRandomEngine() [1/2]

CLHEP::HepRandomEngine * TRTDigitizationTool::getRandomEngine ( const std::string &  streamName,
const EventContext &  ctx 
) const
private

Definition at line 583 of file TRTDigitizationTool.cxx.

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 }

◆ getRandomEngine() [2/2]

CLHEP::HepRandomEngine * TRTDigitizationTool::getRandomEngine ( const std::string &  streamName,
unsigned long int  randomSeedOffset,
const EventContext &  ctx 
) const
private

Definition at line 593 of file TRTDigitizationTool.cxx.

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 }

◆ initialize()

StatusCode TRTDigitizationTool::initialize ( )
finaloverridevirtual

Initialize.

Get the PAI Tool for Xe, Ar, Kr gas mixtures:

Get the Sim-DriftTime Tool:

Reimplemented from PileUpToolBase.

Definition at line 76 of file TRTDigitizationTool.cxx.

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 }

◆ lateInitialize()

StatusCode TRTDigitizationTool::lateInitialize ( const EventContext &  ctx)
private

Definition at line 225 of file TRTDigitizationTool.cxx.

225  {
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 }

◆ mergeEvent()

StatusCode TRTDigitizationTool::mergeEvent ( const EventContext &  ctx)
finaloverridevirtual

called at the end of the subevts loop. Not (necessarily) able to access SubEvents

Reimplemented from IPileUpTool.

Definition at line 602 of file TRTDigitizationTool.cxx.

602  {
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 }

◆ prepareEvent()

StatusCode TRTDigitizationTool::prepareEvent ( const EventContext &  ctx,
const unsigned int  nInputEvents 
)
finaloverridevirtual

return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing

Reimplemented from IPileUpTool.

Definition at line 170 of file TRTDigitizationTool.cxx.

171 {
172  m_vDigits.clear();
173  m_trtHitCollList.clear();
176  return StatusCode::SUCCESS;
177 }

◆ processAllSubEvents() [1/2]

StatusCode TRTDigitizationTool::processAllSubEvents ( const EventContext &  ctx)
finaloverridevirtual

Perform digitization:

  • Get G4 hits
  • Process hits straw by straw [call ProcessStraw() ]
  • Add noise
  • Create RDO collection

Implements IPileUpTool.

Definition at line 461 of file TRTDigitizationTool.cxx.

461  {
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 }

◆ processAllSubEvents() [2/2]

virtual StatusCode IPileUpTool::processAllSubEvents
inherited

dummy implementation to allow compilation while all Digitization packages are migrated to use this new interface.

◆ processBunchXing()

StatusCode TRTDigitizationTool::processBunchXing ( int  bunchXing,
SubEventIterator  bSubEvents,
SubEventIterator  eSubEvents 
)
finaloverridevirtual

called for each active bunch-crossing to process current SubEvents bunchXing is in ns

Implements IPileUpTool.

Definition at line 180 of file TRTDigitizationTool.cxx.

182  {
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 }

◆ processStraws()

StatusCode TRTDigitizationTool::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 
)
private

Definition at line 309 of file TRTDigitizationTool.cxx.

316  {
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 }

◆ resetFilter() [1/2]

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

◆ resetFilter() [2/2]

virtual void IPileUpTool::resetFilter ( )
pure virtualinherited

reset the filter

◆ toProcess() [1/2]

virtual bool IPileUpTool::toProcess ( int  bunchXing) const
pure virtualinherited

flags whether this tool is "live" for bunchXing (time in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing

◆ toProcess() [2/2]

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  }

Member Data Documentation

◆ m_alreadyPrintedPDGcodeWarning

bool TRTDigitizationTool::m_alreadyPrintedPDGcodeWarning {false}
private

Definition at line 160 of file TRTDigitizationTool.h.

◆ m_calDbTool

ToolHandle<ITRT_CalDbTool> TRTDigitizationTool::m_calDbTool {this, "InDetTRTCalDbTool", "TRT_CalDbTool", ""}
private

Definition at line 127 of file TRTDigitizationTool.h.

◆ m_cosmicEventPhase

double TRTDigitizationTool::m_cosmicEventPhase {0.0}
private

Definition at line 165 of file TRTDigitizationTool.h.

◆ m_dataObjectName

std::string TRTDigitizationTool::m_dataObjectName {""}
private

Definition at line 136 of file TRTDigitizationTool.h.

◆ m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> TRTDigitizationTool::m_fieldCacheCondObjInputKey
private
Initial value:
{this, "AtlasFieldCacheCondObj", "fieldCondObj",
"Name of the Magnetic Field conditions object key"}

Definition at line 132 of file TRTDigitizationTool.h.

◆ m_filterPassed

bool PileUpToolBase::m_filterPassed {true}
protectedinherited

Definition at line 60 of file PileUpToolBase.h.

◆ m_first_event

bool TRTDigitizationTool::m_first_event {true}
private

Definition at line 171 of file TRTDigitizationTool.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_HardScatterSplittingMode

Gaudi::Property<int> TRTDigitizationTool::m_HardScatterSplittingMode {this, "HardScatterSplittingMode", 0, ""}
private

Definition at line 143 of file TRTDigitizationTool.h.

◆ m_HardScatterSplittingSkipper

bool TRTDigitizationTool::m_HardScatterSplittingSkipper {false}
private

Definition at line 173 of file TRTDigitizationTool.h.

◆ m_hitsContainerKey

SG::ReadHandleKey<TRTUncompressedHitCollection> TRTDigitizationTool::m_hitsContainerKey {this, "DataObjectName", "TRTUncompressedHits", "Data Object Name"}
private

Definition at line 135 of file TRTDigitizationTool.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_manager

const InDetDD::TRT_DetectorManager* TRTDigitizationTool::m_manager {}
private

Definition at line 156 of file TRTDigitizationTool.h.

◆ m_maxCrossingTimeSDO

double TRTDigitizationTool::m_maxCrossingTimeSDO {0.0}
private

Definition at line 162 of file TRTDigitizationTool.h.

◆ m_mergeSvc

ServiceHandle<PileUpMergeSvc> TRTDigitizationTool::m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service"}
private

Definition at line 128 of file TRTDigitizationTool.h.

◆ m_minCrossingTimeSDO

double TRTDigitizationTool::m_minCrossingTimeSDO {0.0}
private

Definition at line 161 of file TRTDigitizationTool.h.

◆ m_minpileuptruthEkin

double TRTDigitizationTool::m_minpileuptruthEkin {0.0}
private

Definition at line 163 of file TRTDigitizationTool.h.

◆ m_onlyUseContainerName

Gaudi::Property<bool> TRTDigitizationTool::m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}
private

Definition at line 134 of file TRTDigitizationTool.h.

◆ m_outputRDOCollName

SG::WriteHandleKey<TRT_RDO_Container> TRTDigitizationTool::m_outputRDOCollName {this,"OutputObjectName","TRT_RDOs","WHK Output Object name"}
private

name of the output RDOs.

Definition at line 137 of file TRTDigitizationTool.h.

◆ m_outputSDOCollName

SG::WriteHandleKey<InDetSimDataCollection> TRTDigitizationTool::m_outputSDOCollName {this,"OutputSDOName","TRT_SDO_Map","WHK Output SDO container name"}
private

name of the output SDOs.

Definition at line 138 of file TRTDigitizationTool.h.

◆ m_particleTable

const HepPDT::ParticleDataTable* TRTDigitizationTool::m_particleTable {}
private

Definition at line 169 of file TRTDigitizationTool.h.

◆ m_pDigConditions

TRTDigCondBase* TRTDigitizationTool::m_pDigConditions {}
private

Definition at line 153 of file TRTDigitizationTool.h.

◆ m_pElectronicsProcessing

TRTElectronicsProcessing* TRTDigitizationTool::m_pElectronicsProcessing {}
private

Definition at line 151 of file TRTDigitizationTool.h.

◆ m_pNoise

TRTNoise* TRTDigitizationTool::m_pNoise {}
private

Definition at line 154 of file TRTDigitizationTool.h.

◆ m_pProcessingOfStraw

TRTProcessingOfStraw* TRTDigitizationTool::m_pProcessingOfStraw {}
private

Definition at line 152 of file TRTDigitizationTool.h.

◆ m_ppSvc

ServiceHandle<IPartPropSvc> TRTDigitizationTool::m_ppSvc {this, "PartPropSvc", "PartPropSvc"}
private

Handle on the particle property service.

Definition at line 168 of file TRTDigitizationTool.h.

◆ m_printOverrideableSettings

Gaudi::Property<bool> TRTDigitizationTool::m_printOverrideableSettings {this, "PrintOverrideableSettings", false, "Print overrideable settings"}
private

Definition at line 141 of file TRTDigitizationTool.h.

◆ m_printUsedDigSettings

Gaudi::Property<bool> TRTDigitizationTool::m_printUsedDigSettings {this, "PrintDigSettings", true, "Print ditigization settings"}
private

Definition at line 142 of file TRTDigitizationTool.h.

◆ m_randomSeedOffset

Gaudi::Property<unsigned long int> TRTDigitizationTool::m_randomSeedOffset {this, "RandomSeedOffset", 678910, ""}
private

Definition at line 145 of file TRTDigitizationTool.h.

◆ m_rndmSvc

ServiceHandle<IAthRNGSvc> TRTDigitizationTool::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
private

Random number service.

Definition at line 129 of file TRTDigitizationTool.h.

◆ m_seen

std::vector<std::pair<unsigned int, int> > TRTDigitizationTool::m_seen
private

Definition at line 149 of file TRTDigitizationTool.h.

◆ m_settings

TRTDigSettings* TRTDigitizationTool::m_settings {}
private

Definition at line 147 of file TRTDigitizationTool.h.

◆ m_sumTool

ToolHandle<ITRT_StrawStatusSummaryTool> TRTDigitizationTool::m_sumTool {this, "InDetTRTStrawStatusSummaryTool", "TRT_StrawStatusSummaryTool", ""}
private

Definition at line 126 of file TRTDigitizationTool.h.

◆ m_thpctrt

TimedHitCollection<TRTUncompressedHit>* TRTDigitizationTool::m_thpctrt {}
private

Definition at line 159 of file TRTDigitizationTool.h.

◆ m_trt_id

const TRT_ID* TRTDigitizationTool::m_trt_id {}
private

TRT Id Helper.

Definition at line 157 of file TRTDigitizationTool.h.

◆ m_trtHitCollList

std::vector<TRTUncompressedHitCollection*> TRTDigitizationTool::m_trtHitCollList
private

Definition at line 158 of file TRTDigitizationTool.h.

◆ m_TRTpaiToolAr

ToolHandle<ITRT_PAITool> TRTDigitizationTool::m_TRTpaiToolAr {this, "PAI_Tool_Ar", "TRT_PAI_Process_Ar", "The PAI model for ionisation in the TRT Ar gas"}
private

Definition at line 123 of file TRTDigitizationTool.h.

◆ m_TRTpaiToolKr

ToolHandle<ITRT_PAITool> TRTDigitizationTool::m_TRTpaiToolKr {this, "PAI_Tool_Kr", "TRT_PAI_Process_Kr", "The PAI model for ionisation in the TRT Kr gas"}
private

Definition at line 124 of file TRTDigitizationTool.h.

◆ m_TRTpaiToolXe

ToolHandle<ITRT_PAITool> TRTDigitizationTool::m_TRTpaiToolXe {this, "PAI_Tool_Xe", "TRT_PAI_Process_Xe", "The PAI model for ionisation in the TRT Xe gas"}
private

Configurable properties.

Definition at line 122 of file TRTDigitizationTool.h.

◆ m_trtrdo_container

SG::WriteHandle<TRT_RDO_Container> TRTDigitizationTool::m_trtrdo_container
private

Definition at line 139 of file TRTDigitizationTool.h.

◆ m_TRTsimdrifttimetool

ToolHandle<ITRT_SimDriftTimeTool> TRTDigitizationTool::m_TRTsimdrifttimetool {this, "SimDriftTimeTool", "TRT_SimDriftTimeTool", "Drift time versus distance (r-t-relation) for TRT straws"}
private

Definition at line 125 of file TRTDigitizationTool.h.

◆ m_TRTStrawNeighbourSvc

ServiceHandle<ITRT_StrawNeighbourSvc> TRTDigitizationTool::m_TRTStrawNeighbourSvc {this, "TRT_StrawNeighbourSvc", "TRT_StrawNeighbourSvc", ""}
private

Definition at line 130 of file TRTDigitizationTool.h.

◆ m_UseGasMix

Gaudi::Property<int> TRTDigitizationTool::m_UseGasMix {this, "UseGasMix", 0, ""}
private

Definition at line 144 of file TRTDigitizationTool.h.

◆ m_vDigits

std::vector<TRTDigit> TRTDigitizationTool::m_vDigits
private

Vector of all digits.

Definition at line 150 of file TRTDigitizationTool.h.

◆ m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks
protectedinherited
Initial value:
{this, "VetoPileUpTruthLinks", true,
"Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.


The documentation for this class was generated from the following files:
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
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
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
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
PileUpToolBase::m_filterPassed
bool m_filterPassed
Definition: PileUpToolBase.h:60
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
AtlasFieldCacheCondObj
Definition: AtlasFieldCacheCondObj.h:19
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
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
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
InDetDD::TRT_EndcapElement
Definition: TRT_EndcapElement.h:43
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
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 >
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
PileUpToolBase::m_lastXing
Gaudi::Property< int > m_lastXing
Definition: PileUpToolBase.h:56
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
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
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)
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.
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
TRTDigitizationTool::m_UseGasMix
Gaudi::Property< int > m_UseGasMix
Definition: TRTDigitizationTool.h:144
TRTNoise
Simulation of noise hits in the TRT.
Definition: TRTNoise.h:39
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
TRTDigitizationTool::m_pProcessingOfStraw
TRTProcessingOfStraw * m_pProcessingOfStraw
Definition: TRTDigitizationTool.h:152
InDetDD::Version::majorNum
int majorNum() const
Major version number.
Definition: Version.cxx:62
PileUpToolBase::PileUpToolBase
PileUpToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition: PileUpToolBase.cxx:7
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
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.
TRTProcessingOfStraw
TRT Digitization: Processing of a TRT Straws.
Definition: TRTProcessingOfStraw.h:54
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
WriteHiveWithMetaData.streamName
string streamName
Definition: WriteHiveWithMetaData.py:22
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
TRTDigitizationTool::m_trtHitCollList
std::vector< TRTUncompressedHitCollection * > m_trtHitCollList
Definition: TRTDigitizationTool.h:158
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
ATHRNG::RNGWrapper::getEngine
CLHEP::HepRandomEngine * getEngine(const EventContext &ctx) const
Retrieve the random engine corresponding to the provided EventContext.
Definition: RNGWrapper.h:134
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
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.
PileUpToolBase::m_firstXing
Gaudi::Property< int > m_firstXing
Definition: PileUpToolBase.h:54
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
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
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
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