TRTDigitizationTool Class Reference

#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	ConditionsDependingInitialization (const EventContext &ctx)
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_PAITool >	m_TRTpaiToolXe {this, "PAI_Tool_Xe", "TRT_PAI_Process_Xe", "The PAI model for ionisation in the TRT Xe gas"}
	Configurable properties. More...
ToolHandle< ITRT_PAITool >	m_TRTpaiToolAr {this, "PAI_Tool_Ar", "TRT_PAI_Process_Ar", "The PAI model for ionisation in the TRT Ar gas"}
ToolHandle< ITRT_PAITool >	m_TRTpaiToolKr {this, "PAI_Tool_Kr", "TRT_PAI_Process_Kr", "The PAI model for ionisation in the TRT Kr gas"}
ToolHandle< ITRT_SimDriftTimeTool >	m_TRTsimdrifttimetool {this, "SimDriftTimeTool", "TRT_SimDriftTimeTool", "Drift time versus distance (r-t-relation) for TRT straws"}
ToolHandle< ITRT_StrawStatusSummaryTool >	m_sumTool {this, "InDetTRTStrawStatusSummaryTool", "TRT_StrawStatusSummaryTool", ""}
ToolHandle< ITRT_CalDbTool >	m_calDbTool {this, "InDetTRTCalDbTool", "TRT_CalDbTool", ""}
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service"}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number service. More...
ServiceHandle< ITRT_StrawNeighbourSvc >	m_TRTStrawNeighbourSvc {this, "TRT_StrawNeighbourSvc", "TRT_StrawNeighbourSvc", ""}
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
Gaudi::Property< bool >	m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}
SG::ReadHandleKey< TRTUncompressedHitCollection >	m_hitsContainerKey {this, "DataObjectName", "TRTUncompressedHits", "Data Object Name"}
std::string	m_dataObjectName {""}
SG::WriteHandleKey< TRT_RDO_Container >	m_outputRDOCollName {this,"OutputObjectName","TRT_RDOs","WHK Output Object name"}
	name of the output RDOs. More...
SG::WriteHandleKey< InDetSimDataCollection >	m_outputSDOCollName {this,"OutputSDOName","TRT_SDO_Map","WHK Output SDO container name"}
	name of the output SDOs. More...
SG::WriteHandle< TRT_RDO_Container >	m_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, ""}
TRTDigSettings *	m_settings {}
std::vector< std::pair< unsigned int, int > >	m_seen
std::vector< TRTDigit >	m_vDigits
	Vector of all digits. More...
TRTElectronicsProcessing *	m_pElectronicsProcessing {}
TRTProcessingOfStraw *	m_pProcessingOfStraw {}
TRTDigCondBase *	m_pDigConditions {}
TRTNoise *	m_pNoise {}
const InDetDD::TRT_DetectorManager *	m_manager {}
const TRT_ID *	m_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 {}
SG::ReadCondHandleKey< AthenaAttributeList >	m_digverscontainerkey { this, "DigVersContainerKey", "", "" }
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 65 of file TRTDigitizationTool.h.

Constructor & Destructor Documentation

TRTDigitizationTool()

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

Definition at line 63 of file TRTDigitizationTool.cxx.

: PileUpToolBase(type, name, parent)
{
  m_settings = new TRTDigSettings();
  m_settings->addPropertiesForOverrideableParameters(static_cast<AlgTool*>(this));
}

~TRTDigitizationTool()

TRTDigitizationTool::~TRTDigitizationTool

(

)

Destructor.

Definition at line 73 of file TRTDigitizationTool.cxx.

                                          {
 
  ATH_MSG_VERBOSE ( "Begin TRTDigitizationTool::Destructor");
  delete m_pElectronicsProcessing;
  delete m_pProcessingOfStraw;
  delete m_pDigConditions;
  delete m_pNoise;
  delete m_settings;
  ATH_MSG_VERBOSE ( "End TRTDigitizationTool::Destructor");
 
}

Member Function Documentation

ConditionsDependingInitialization()

StatusCode TRTDigitizationTool::ConditionsDependingInitialization ( const EventContext &  ctx )

private

Definition at line 863 of file TRTDigitizationTool.cxx.

{
  SG::ReadCondHandle<AthenaAttributeList> digvers (m_digverscontainerkey, ctx);
  int dig_vers_from_condDB = (**digvers)["TRT_Dig_Vers"].data<int>();
 
  if (dig_vers_from_condDB!=0) {
 
    if (StatusCode::SUCCESS == m_settings->DigSettingsFromCondDB(dig_vers_from_condDB)) {
      ATH_MSG_INFO ( "Retrieved TRT_Settings from CondDB with TRT digitization version: digversion = " <<
                     dig_vers_from_condDB );
    } else {
      ATH_MSG_WARNING ( "Unknown TRT digitization version: digversion = " << dig_vers_from_condDB <<
                        " read from CondDB. Overriding to use default from Det Desc tag: " <<
                        m_settings->digVers() );
    }
 
  } else {
    ATH_MSG_WARNING ( "TRT digitization version: digversion = " << dig_vers_from_condDB <<
                      " read from CondDB. Overriding to use default from Det Desc tag: " <<
                      m_settings->digVers() );
  }
 
  return StatusCode::SUCCESS;
 
}

createAndStoreRDOs()

StatusCode TRTDigitizationTool::createAndStoreRDOs ( )

private

Definition at line 709 of file TRTDigitizationTool.cxx.

{
 
  std::vector<TRTDigit>::const_iterator TRTDigitIter(m_vDigits.begin());
  std::vector<TRTDigit>::const_iterator endOfTRTDigits(m_vDigits.end());
 
  // for testing
  IdentifierHash IdHash; // default value is 0xFFFFFFFF
  IdentifierHash IdHashOld; // default value is 0xFFFFFFFF
  TRT_RDO_Collection *RDOColl(nullptr);
 
  Identifier idStraw;
 
  while (TRTDigitIter != endOfTRTDigits) {
    ATH_MSG_DEBUG ( "Digit ID " << TRTDigitIter->GetStrawID() << " Digit " << TRTDigitIter->GetDigit() );
 
    Identifier layer_id;
    bool identifierOK(false);
    idStraw = getIdentifier(TRTDigitIter->GetStrawID(), IdHash, layer_id, identifierOK);
    if (!identifierOK) {
      ATH_MSG_ERROR ( "Ignoring simhits with suspicious identifier (2)" );
      ++TRTDigitIter;
      continue;
    };
 
    // Create new TRT RDO Collection
    ATH_MSG_DEBUG ( " RDO ID " << m_trt_id->print_to_string(idStraw) );
 
    //TK: wauv - we are really betting the farm on the fact that the
    //ordering of digits will result in a similar ordering of the
    //idhash'es here... (this is not immediately the case when noise
    //hits are appended afterwards).
 
    if (IdHash != IdHashOld) {
      RDOColl = new TRT_RDO_Collection(IdHash);
      ATH_MSG_DEBUG ( "New TRT RDO Collection created with IdHash " << static_cast<int>(IdHash) );
      IdHashOld = IdHash;
      RDOColl->setIdentifier(layer_id);
 
      // Add to the container
      if (m_trtrdo_container->addCollection(RDOColl, RDOColl->identifyHash()).isFailure()) {
        ATH_MSG_FATAL ( "Container " << m_outputRDOCollName.key() << " could not be registered in StoreGate !" );
        return StatusCode::FAILURE;
      } else {
        ATH_MSG_DEBUG ( "Container " << m_outputRDOCollName.key() << " registered in StoreGate" );
      }
    }
 
    // Put RDO into Collection
    TRT_LoLumRawData *p_rdo(new TRT_LoLumRawData(idStraw, TRTDigitIter->GetDigit()));
    if (RDOColl) {
      RDOColl->push_back(p_rdo);
    } else {
      ATH_MSG_FATAL ( "Failed to create the TRT_RDO_Collection before trying to add an RDO to it! IdHash = " << static_cast<int>(IdHash) );
      delete p_rdo;
      return StatusCode::FAILURE;
    }
    ++TRTDigitIter;
  }
 
  m_vDigits.clear();
  return StatusCode::SUCCESS;
}

DeclareInterfaceID()

IPileUpTool::DeclareInterfaceID ( IPileUpTool  , 1  , 0    )

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.

{ return m_filterPassed; }

finalize()

StatusCode TRTDigitizationTool::finalize ( )

finaloverridevirtual

Finalize.

Definition at line 850 of file TRTDigitizationTool.cxx.

                                         {
 
  if (m_printUsedDigSettings) {
    m_settings->print("TRTDigSettings Settings : ");
  }
 
  ATH_MSG_INFO ( "TRTDigitizationTool::finalize()" );
 
  return StatusCode::SUCCESS;
}

getCosmicEventPhase()

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

staticprivate

Definition at line 890 of file TRTDigitizationTool.cxx.

                                                                                {
  // 13th February 2015: replace ComTime with a hack (fixme) based on an
  // event phase distribution from Alex (alejandro.alonso@cern.ch) that
  // is modelled as a Guassian of mean 5.48 ns and sigma 8.91 ns.
  return CLHEP::RandGaussZiggurat::shoot(rndmEngine, 5.48, 8.91);
}

getIdentifier()

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

private

Definition at line 775 of file TRTDigitizationTool.cxx.

{
  statusok = true;
 
  Identifier IdStraw;
 
  const int mask(0x0000001F);
  const int word_shift(5);
  int trtID, ringID, moduleID, layerID, strawID;
  int wheelID, planeID, sectorID;
 
  const InDetDD::TRT_BarrelElement *barrelElement;
  const InDetDD::TRT_EndcapElement *endcapElement;
 
  if ( !(hitID & 0x00200000) ) {      // barrel
    strawID   = hitID & mask;
    hitID   >>= word_shift;
    layerID   = hitID & mask;
    hitID   >>= word_shift;
    moduleID  = hitID & mask;
    hitID   >>= word_shift;
    ringID    = hitID & mask;
    trtID     = hitID >> word_shift;
 
    barrelElement = m_manager->getBarrelElement(trtID, ringID, moduleID, layerID);
    if ( barrelElement ) {
      hashId  = barrelElement->identifyHash();
      IdLayer = barrelElement->identify();
      IdStraw = m_trt_id->straw_id(IdLayer, strawID);
    } else {
      ATH_MSG_ERROR ( "Could not find detector element for barrel identifier with "
                      << "(ipos,iring,imod,ilayer,istraw) = ("
                      << trtID << ", " << ringID << ", " << moduleID << ", "
                      << layerID << ", " << strawID << ")" );
      statusok = false;
    }
  } else {                           // endcap
    strawID   = hitID & mask;
    hitID   >>= word_shift;
    planeID   = hitID & mask;
    hitID   >>= word_shift;
    sectorID  = hitID & mask;
    hitID   >>= word_shift;
    wheelID   = hitID & mask;
    trtID     = hitID >> word_shift;
 
    // change trtID (which is 2/3 for endcaps) to use 0/1 in getEndcapElement
    if (trtID == 3) { trtID = 0; }
    else            { trtID = 1; }
 
    endcapElement = m_manager->getEndcapElement(trtID, wheelID, planeID, sectorID);
 
    if ( endcapElement ) {
      hashId  = endcapElement->identifyHash();
      IdLayer = endcapElement->identify();
      IdStraw = m_trt_id->straw_id(IdLayer, strawID);
    } else {
      ATH_MSG_ERROR ( "Could not find detector element for endcap identifier with "
                      << "(ipos,iwheel,isector,iplane,istraw) = ("
                      << trtID << ", " << wheelID << ", " << sectorID << ", "
                      << planeID << ", " << strawID << ")" );
      ATH_MSG_ERROR ( "If this happens very rarely, don't be alarmed (it is a Geant4 'feature')" );
      ATH_MSG_ERROR ( "If it happens a lot, you probably have misconfigured geometry in the sim. job." );
      statusok = false;
    }
 
  }
 
  return IdStraw;
}

getRandomEngine() [1/2]

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

private

Definition at line 608 of file TRTDigitizationTool.cxx.

{
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, streamName);
  std::string rngName = name()+streamName;
  rngWrapper->setSeed( rngName, ctx );
  return rngWrapper->getEngine(ctx);
}

getRandomEngine() [2/2]

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

private

Definition at line 618 of file TRTDigitizationTool.cxx.

{
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this, streamName);
  rngWrapper->setSeed( streamName, ctx.slot(), randomSeedOffset, ctx.eventID().run_number() );
  return rngWrapper->getEngine(ctx);
}

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 86 of file TRTDigitizationTool.cxx.

{
 
  ATH_MSG_DEBUG ( name()<<"::initialize() begin" );
 
  // Get the TRT Detector Manager
  ATH_CHECK(detStore()->retrieve(m_manager,"TRT"));
  ATH_MSG_DEBUG ( "Retrieved TRT_DetectorManager with version "  << m_manager->getVersion().majorNum() );
 
  ATH_CHECK(detStore()->retrieve(m_trt_id, "TRT_ID"));
 
  ATH_CHECK( m_digverscontainerkey.initialize (SG::AllowEmpty) );
 
  // Fill setting defaults and process joboption overrides:
  m_settings->initialize(m_manager);
 
  if (m_printOverrideableSettings) {
    m_settings->printFlagsForOverrideableParameters("TRTDigSettings Overrideables : ");
  }
 
 
  ATH_CHECK(m_TRTpaiToolXe.retrieve());
  ATH_MSG_DEBUG ( "Retrieved the PAI Tool for Xe straws" );
 
  ATH_CHECK(m_TRTpaiToolAr.retrieve());
  ATH_MSG_DEBUG ( "Retrieved the PAI Tool for Ar straws" );
 
  ATH_CHECK(m_TRTpaiToolKr.retrieve());
  ATH_MSG_DEBUG ( "Retrieved the PAI Tool for Kr straws" );
 
  ATH_CHECK(m_TRTsimdrifttimetool.retrieve());
  ATH_MSG_DEBUG ( "Retrieved the Sim. Drifttime Tool" );
 
  // Check data object name
  if (m_hitsContainerKey.key().empty()) {
    ATH_MSG_FATAL ( "Property DataObjectName not set!" );
    return StatusCode::FAILURE;
  }
  m_dataObjectName = m_hitsContainerKey.key();
  ATH_MSG_DEBUG ( "Input hits: " << m_dataObjectName );
 
  // Initialize ReadHandleKey
  ATH_CHECK(m_hitsContainerKey.initialize(true));
 
  // Initialize data handle keys
  ATH_CHECK(m_outputRDOCollName.initialize());
  ATH_CHECK(m_outputSDOCollName.initialize());
 
  // Get Random Service
  ATH_CHECK(m_rndmSvc.retrieve());
 
  // Get the Particle Properties Service
  ATH_CHECK(m_ppSvc.retrieve());
  m_particleTable = m_ppSvc->PDT();
 
  //locate the PileUpMergeSvc and initialize our local ptr
  if (m_onlyUseContainerName) {
    ATH_CHECK(m_mergeSvc.retrieve());
  }
 
  //Retrieve TRT_StrawNeighbourService.
  ATH_CHECK(m_TRTStrawNeighbourSvc.retrieve());
 
  //Retrieve TRT_CalDbTool
  if (m_settings->getT0FromData()) {
    ATH_CHECK(m_calDbTool.retrieve());
  }
  else {
    m_calDbTool.disable();
  }
 
  m_minpileuptruthEkin = m_settings->pileUpSDOsMinEkin();
 
  // Set SDO readout range
  const double intervalBetweenCrossings(m_settings->timeInterval() / 3.);
 
  switch ( (m_settings->storeSDO() )) {
  case 0:  m_minCrossingTimeSDO =  -1.*CLHEP::ns;  m_maxCrossingTimeSDO = -1.*CLHEP::ns; break;
  case 1:  m_minCrossingTimeSDO =  -1.*CLHEP::ns;  m_maxCrossingTimeSDO = (intervalBetweenCrossings * 2. + 1.*CLHEP::ns); break;
  case 2:  m_minCrossingTimeSDO = -(intervalBetweenCrossings * 2. + 1.*CLHEP::ns);  m_maxCrossingTimeSDO = (intervalBetweenCrossings * 2. + 1.*CLHEP::ns); break;
  default:
    ATH_MSG_ERROR ( "storeSDO is out of range:"<<m_settings->storeSDO()<<"allowed values are: 0,1,2. Setting storeSDO = 2 " );
    m_minCrossingTimeSDO = -51.*CLHEP::ns;  m_maxCrossingTimeSDO = 51.*CLHEP::ns;
    break;
  }
 
  ATH_CHECK( m_fieldCacheCondObjInputKey.initialize() );
 
  return StatusCode::SUCCESS;
}

lateInitialize()

StatusCode TRTDigitizationTool::lateInitialize ( const EventContext &  ctx )

private

Definition at line 237 of file TRTDigitizationTool.cxx.

                                                                      {
 
  // setup the RNGs which are only used in the first event
  CLHEP::HepRandomEngine *fakeCondRndmEngine = getRandomEngine("TRT_FakeConditions", m_randomSeedOffset, ctx);
  CLHEP::HepRandomEngine *noiseInitRndmEngine = getRandomEngine("TRT_Noise", m_randomSeedOffset, ctx);
  CLHEP::HepRandomEngine *noiseElecRndmEngine = getRandomEngine("TRT_Noise_Electronics", m_randomSeedOffset, ctx);
  CLHEP::HepRandomEngine *noiseThreshRndmEngine = getRandomEngine("TRT_Noise_ThresholdFluctuations", m_randomSeedOffset, ctx);
  CLHEP::HepRandomEngine *noiseElecResetRndmEngine = getRandomEngine("TRT_ElectronicsNoiseReset", m_randomSeedOffset, ctx);
  m_first_event=false;
 
  if (!m_digverscontainerkey.empty()) {
 
    if ( ConditionsDependingInitialization(ctx).isFailure() ) {
      ATH_MSG_ERROR ( "Folder holder TRT digitization version exists in condDB, but tag is faulty" );
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG ( "Using Digitization version as defined in conditions tag" );
    }
 
  } else {
    ATH_MSG_DEBUG ( "No folder containing TRT digitization version found in CondDB. Using default from Det Desc tag: " << m_settings->digVers() );
  }
 
  //Resuming initialiazation. Section below had to be moved into event loop due to dependence on conditions data
 
  TRTElectronicsNoise *electronicsNoise(nullptr);
  if ( m_settings->noiseInUnhitStraws() || m_settings->noiseInSimhits() ) {
    electronicsNoise = new TRTElectronicsNoise(m_settings, noiseElecRndmEngine);
  }
  // ElectronicsProcessing is needed for the regular straw processing,
  // but also for the noise (it assumes ownership of electronicsnoise )
  m_pElectronicsProcessing = new TRTElectronicsProcessing( m_settings, electronicsNoise );
 
  m_pDigConditions = new TRTDigCondFakeMap(m_settings,
                                           m_manager,
                                           m_trt_id,
                                           m_UseGasMix,
                                           m_sumTool);
 
  m_pDigConditions->initialize(fakeCondRndmEngine);
 
  if ( m_settings->noiseInUnhitStraws() || m_settings->noiseInSimhits() ) {
 
    // In short this next constructor does 3 things;
    //     i)  tunes the amplitude of the electronics noise,
    //    ii) creates a pool of noise digits,
    //   iii) figures out exact low thresholds needed to reproduce actual
    //        straw noise-frequencies:
    m_pNoise = new TRTNoise( m_settings,
                             m_manager,
                             noiseInitRndmEngine,
                             noiseElecRndmEngine,
                             noiseThreshRndmEngine,
                             noiseElecResetRndmEngine,
                             m_pDigConditions,
                             m_pElectronicsProcessing,
                             electronicsNoise,
                             m_trt_id,
                             m_UseGasMix,
                             m_sumTool);
 
    ATH_MSG_DEBUG ( "Average straw noise level is " << m_pDigConditions->strawAverageNoiseLevel() );
 
  } else {
    m_pNoise = nullptr;
  }
 
  ITRT_PAITool *TRTpaiToolXe = &(* m_TRTpaiToolXe);
  ITRT_PAITool *TRTpaiToolAr = &(* m_TRTpaiToolAr);
  ITRT_PAITool *TRTpaiToolKr = &(* m_TRTpaiToolKr);
 
  ITRT_SimDriftTimeTool *pTRTsimdrifttimetool = &(*m_TRTsimdrifttimetool);
 
  const ITRT_CalDbTool* calDbTool = nullptr;
  if (m_settings->getT0FromData()) {
    calDbTool = m_calDbTool.get();
  }
  m_pProcessingOfStraw =
    new TRTProcessingOfStraw( m_settings,
                              m_manager,
                              TRTpaiToolXe,
                              pTRTsimdrifttimetool,
                              m_pElectronicsProcessing,
                              m_pNoise,
                              m_pDigConditions,
                              m_particleTable,
                              m_trt_id,
                              TRTpaiToolAr,
                              TRTpaiToolKr,
                              calDbTool);
 
  ATH_MSG_INFO ( "Gas Property:             UseGasMix is " << m_UseGasMix );
 
  return StatusCode::SUCCESS;
}

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 627 of file TRTDigitizationTool.cxx.

                                                                  {
  std::vector<std::pair<unsigned int, int> >::iterator ii(m_seen.begin());
  std::vector<std::pair<unsigned int, int> >::iterator ee(m_seen.end());
  while (ii != ee) {
    ATH_MSG_DEBUG( "mergeEvent: there are " << ii->first << " events in bunch xing " << ii->second );
    ++ii;
  }
 
  // Set the RNGs to use for this event.
  CLHEP::HepRandomEngine *rndmEngine = getRandomEngine("", ctx);
  CLHEP::HepRandomEngine *elecNoiseRndmEngine = getRandomEngine("TRT_ElectronicsNoise", ctx);
  CLHEP::HepRandomEngine *noiseRndmEngine = getRandomEngine("TRT_NoiseDigitPool", ctx);
  CLHEP::HepRandomEngine *strawRndmEngine = getRandomEngine("TRT_ProcessStraw", ctx);
  CLHEP::HepRandomEngine *elecProcRndmEngine = getRandomEngine("TRT_ThresholdFluctuations", ctx);
  CLHEP::HepRandomEngine *paiRndmEngine = getRandomEngine("TRT_PAI", ctx);
 
  if (m_first_event) {
    if(this->lateInitialize(ctx).isFailure()) {
      ATH_MSG_FATAL ( "lateInitialize method failed!" );
      return StatusCode::FAILURE;
    }
  }
 
  m_alreadyPrintedPDGcodeWarning = false;
 
  ATH_MSG_DEBUG ( "TRTDigitization::execute()"  );
 
  m_trtrdo_container = SG::makeHandle(m_outputRDOCollName, ctx);
  ATH_CHECK(m_trtrdo_container.record(std::make_unique<TRT_RDO_Container>(m_trt_id->straw_layer_hash_max())));
  ATH_MSG_DEBUG ( " TRT_RDO_Container created " );
  if (not m_trtrdo_container.isValid()) {
    ATH_MSG_FATAL ( "Container " << m_outputRDOCollName.key() << " could not be registered in StoreGate !" );
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG ( "Container " << m_outputRDOCollName.key() << " registered in StoreGate" );
  }
 
  //Set of all hitid's with simhits (used for noise simulation).
  std::set<int> sim_hitids;
  std::set<Identifier> simhitsIdentifiers;
 
  // Process the Hits straw by straw:
  //   get the iterator pairs for given straw
  ATH_CHECK(this->processStraws(ctx, *m_thpctrt, sim_hitids, simhitsIdentifiers, rndmEngine, strawRndmEngine, elecProcRndmEngine, elecNoiseRndmEngine,paiRndmEngine));
 
  delete m_thpctrt;
  for(TRTUncompressedHitCollection* ptr : m_trtHitCollList) delete ptr;
  m_trtHitCollList.clear();
  // no more hits
 
  //Noise in straws without simhits:
  if (m_settings->noiseInUnhitStraws()) {
    const unsigned int numberOfDigitsBeforeNoise(m_vDigits.size());
 
    m_pNoise->appendPureNoiseToProperDigits(m_vDigits, sim_hitids, noiseRndmEngine);
    if (m_settings->doCrosstalk()) {
      m_pNoise->appendCrossTalkNoiseToProperDigits(m_vDigits, simhitsIdentifiers,m_TRTStrawNeighbourSvc, noiseRndmEngine);
    }
 
    ATH_MSG_DEBUG ( " Number of digits " << m_vDigits.size() << " (" << m_vDigits.size()-numberOfDigitsBeforeNoise << " of those are pure noise)" );
 
    TRTNoise::sortDigits(m_vDigits);
 
  } else {
    ATH_MSG_DEBUG ( " Number of digits " << m_vDigits.size() );
  };
 
  // All digits are ready.
  // We just need to convert to relevant identifiers and output to storegate.
 
  if (createAndStoreRDOs().isFailure()) {
    ATH_MSG_FATAL ( "createAndStoreRDOs() failed!" );
    return StatusCode::FAILURE;
  }
  else {
    ATH_MSG_DEBUG ( "createAndStoreRDOs() succeeded" );
  }
 
  return StatusCode::SUCCESS;
}

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 182 of file TRTDigitizationTool.cxx.

{
  m_vDigits.clear();
  m_trtHitCollList.clear();
  m_thpctrt = new TimedHitCollection<TRTUncompressedHit>();
  m_HardScatterSplittingSkipper = false;
  return StatusCode::SUCCESS;
}

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 486 of file TRTDigitizationTool.cxx.

                                                                           {
 
  // Set the RNGs to use for this event.
  CLHEP::HepRandomEngine *rndmEngine = getRandomEngine("", ctx);
  CLHEP::HepRandomEngine *elecNoiseRndmEngine = getRandomEngine("TRT_ElectronicsNoise", ctx);
  CLHEP::HepRandomEngine *noiseRndmEngine = getRandomEngine("TRT_NoiseDigitPool", ctx);
  CLHEP::HepRandomEngine *strawRndmEngine = getRandomEngine("TRT_ProcessStraw", ctx);
  CLHEP::HepRandomEngine *elecProcRndmEngine = getRandomEngine("TRT_ThresholdFluctuations", ctx);
  CLHEP::HepRandomEngine *paiRndmEngine = getRandomEngine("TRT_PAI", ctx);
 
  if (m_first_event) {
    if(this->lateInitialize(ctx).isFailure()) {
      ATH_MSG_FATAL ( "lateInitialize method failed!" );
      return StatusCode::FAILURE;
    }
  }
 
  m_alreadyPrintedPDGcodeWarning = false;
 
  ATH_MSG_DEBUG ( "TRTDigitizationTool::processAllSubEvents()" );
 
  m_trtrdo_container = SG::makeHandle(m_outputRDOCollName, ctx);
  ATH_CHECK(m_trtrdo_container.record(std::make_unique<TRT_RDO_Container>(m_trt_id->straw_layer_hash_max())));
  ATH_MSG_DEBUG ( " TRT_RDO_Container created " );
 
  if (not m_trtrdo_container.isValid()) {
    ATH_MSG_FATAL ( "Container " << m_outputRDOCollName.key() << " could not be registered in StoreGate !" );
    return StatusCode::FAILURE;
  }else {
    ATH_MSG_DEBUG ( "Container " << m_outputRDOCollName.key() << " registered in StoreGate" );
  }
 
  m_vDigits.clear();
 
  //  get the container(s)
  using TimedHitCollList = PileUpMergeSvc::TimedList<TRTUncompressedHitCollection>::type;
  TimedHitCollection<TRTUncompressedHit> thpctrt;
  // In case of single hits container just load the collection using read handles
  if (!m_onlyUseContainerName) {
    SG::ReadHandle<TRTUncompressedHitCollection> hitCollection(m_hitsContainerKey, ctx);
    if (!hitCollection.isValid()) {
      ATH_MSG_ERROR("Could not get TRTUncompressedHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
      return StatusCode::FAILURE;
    }
 
    // Define Hit Collection
    thpctrt.reserve(1);
 
    // create a new hits collection
    thpctrt.insert(0, hitCollection.cptr());
    ATH_MSG_DEBUG("TRTUncompressedHitCollection found with " << hitCollection->size() << " hits");
  }
  else {
    TimedHitCollList hitCollList; // this is a list<pair<time_t, DataLink<TRTUncompressedHitCollection> > >
    unsigned int numberOfSimHits(0);
    if ( !(m_mergeSvc->retrieveSubEvtsData(m_dataObjectName, hitCollList, numberOfSimHits).isSuccess()) && hitCollList.empty() ) {
      ATH_MSG_ERROR ( "Could not fill TimedHitCollList" );
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_DEBUG ( hitCollList.size() << " TRTUncompressedHitCollections with key " << m_dataObjectName << " found" );
    }
 
    // Define Hit Collection
    thpctrt.reserve(numberOfSimHits);
 
    //now merge all collections into one
    TimedHitCollList::iterator   iColl(hitCollList.begin());
    TimedHitCollList::iterator endColl(hitCollList.end()  );
    m_HardScatterSplittingSkipper = false;
    // loop on the hit collections
    while ( iColl != endColl ) {
      //decide if this event will be processed depending on HardScatterSplittingMode & bunchXing
      if (m_HardScatterSplittingMode == 2 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; ++iColl; continue; }
      if (m_HardScatterSplittingMode == 1 && m_HardScatterSplittingSkipper )  { ++iColl; continue; }
      if (m_HardScatterSplittingMode == 1 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; }
      const TRTUncompressedHitCollection* p_collection(iColl->second);
      thpctrt.insert(iColl->first, p_collection);
      ATH_MSG_DEBUG ( "TRTUncompressedHitCollection found with " << p_collection->size() << " hits" );
      ++iColl;
    }
  }
 
  //Set of all hitid's with simhits (used for noise simulation).
  std::set<int> sim_hitids;
  std::set<Identifier> simhitsIdentifiers;
 
  // Process the Hits straw by straw: get the iterator pairs for given straw
  ATH_CHECK(this->processStraws(ctx, thpctrt, sim_hitids, simhitsIdentifiers, rndmEngine, strawRndmEngine, elecProcRndmEngine, elecNoiseRndmEngine,paiRndmEngine));
 
  // no more hits
 
  //Noise in straws without simhits:
  if (m_settings->noiseInUnhitStraws()) {
    const int numberOfDigitsBeforeNoise(m_vDigits.size());
 
    m_pNoise->appendPureNoiseToProperDigits(m_vDigits, sim_hitids, noiseRndmEngine);
    if (m_settings->doCrosstalk()) {
      m_pNoise->appendCrossTalkNoiseToProperDigits(m_vDigits, simhitsIdentifiers,m_TRTStrawNeighbourSvc, noiseRndmEngine);
    }
 
    ATH_MSG_DEBUG ( " Number of digits " << m_vDigits.size() << " (" << m_vDigits.size()-numberOfDigitsBeforeNoise << " of those are pure noise)" );
 
    TRTNoise::sortDigits(m_vDigits);
 
  } else {
    ATH_MSG_DEBUG ( " Number of digits " << m_vDigits.size() );
  }
 
  // All digits are ready.
  // We just need to convert to relevant identifiers and output to storegate.
 
  if (createAndStoreRDOs().isFailure()) {
    ATH_MSG_FATAL ( "createAndStoreRDOs() failed!" );
    return StatusCode::FAILURE;
  }
  else {
    ATH_MSG_DEBUG ( "createAndStoreRDOs() succeeded" );
  }
 
  return StatusCode::SUCCESS;
}

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 192 of file TRTDigitizationTool.cxx.

                                                                              {
 
  m_seen.emplace_back(std::distance(bSubEvents,eSubEvents), bunchXing);
  //decide if this event will be processed depending on HardScatterSplittingMode & bunchXing
  if (m_HardScatterSplittingMode == 2 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; return StatusCode::SUCCESS; }
  if (m_HardScatterSplittingMode == 1 && m_HardScatterSplittingSkipper )  { return StatusCode::SUCCESS; }
  if (m_HardScatterSplittingMode == 1 && !m_HardScatterSplittingSkipper ) { m_HardScatterSplittingSkipper = true; }
 
 
  //TRTUncompressedHit
 
  using TimedHitCollList = PileUpMergeSvc::TimedList<TRTUncompressedHitCollection>::type;
  TimedHitCollList hitCollList;
 
  if (!(m_mergeSvc->retrieveSubSetEvtData(m_dataObjectName, hitCollList, bunchXing,
                                          bSubEvents, eSubEvents).isSuccess()) &&
      hitCollList.empty()) {
    ATH_MSG_ERROR("Could not fill TimedHitCollList");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_VERBOSE(hitCollList.size() << " TRTUncompressedHitCollection with key " <<
                    m_dataObjectName << " found");
  }
 
  TimedHitCollList::iterator iColl(hitCollList.begin());
  TimedHitCollList::iterator endColl(hitCollList.end());
 
  for( ; iColl != endColl; ++iColl){
    TRTUncompressedHitCollection  *hitCollPtr = new TRTUncompressedHitCollection(*iColl->second);
    PileUpTimeEventIndex timeIndex(iColl->first);
    ATH_MSG_DEBUG("TRTUncompressedHitCollection found with " << hitCollPtr->size() <<
                  " hits");
    ATH_MSG_VERBOSE("time index info. time: " << timeIndex.time()
                    << " index: " << timeIndex.index()
                    << " type: " << timeIndex.type());
    m_thpctrt->insert(timeIndex, hitCollPtr);
    m_trtHitCollList.push_back(hitCollPtr);
  }
 
  return StatusCode::SUCCESS;
}

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 334 of file TRTDigitizationTool.cxx.

                                                                                   {
 
  // Create a map for the SDO
  SG::WriteHandle<InDetSimDataCollection> simDataMap(m_outputSDOCollName, ctx);
 
  MagField::AtlasFieldCache    fieldCache;
  if (m_settings->useMagneticFieldMap()) {
      
    // Get field cache object
    SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
    const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
 
    if (fieldCondObj == nullptr) {
        ATH_MSG_ERROR("Failed to retrieve AtlasFieldCacheCondObj with key " << m_fieldCacheCondObjInputKey.key());
        return StatusCode::FAILURE;
    }
    fieldCondObj->getInitializedCache (fieldCache);
  }
  
 
  
  ATH_CHECK(simDataMap.record(std::make_unique<InDetSimDataCollection>() ));
 
  // Register the map into StoreGate
  if (not simDataMap.isValid()) {
    ATH_MSG_FATAL ( "InDetSimData map " << m_outputSDOCollName.key() << " could not be registered in StoreGate !" );
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG ( "InDetSimData map " << m_outputSDOCollName.key() << " registered in StoreGate" );
  }
 
  m_cosmicEventPhase = 0.0;
  if (m_settings->doCosmicTimingPit()) {
    m_cosmicEventPhase = getCosmicEventPhase(rndmEngine);
  };
 
  // Create  a vector of deposits
  std::vector<InDetSimData::Deposit> depositVector(100);
 
  // loop over all straws
  TimedHitCollection<TRTUncompressedHit>::const_iterator i, e;
  while (thpctrt.nextDetectorElement(i, e)) {
 
    int hitID((*i)->GetHitID()); // Get hitID
 
    // evtIndex should be 0 for main event and 1,2,3,... for pileup events:
    // (event Id is a property of the TimedHitPtr)
    HepMcParticleLink::index_type evtIndex(i->eventId());
 
    if ( m_settings->noiseInUnhitStraws() ) {
      sim_hitids.insert(hitID);
    }
    //Safeguard against a rare case of hitID corruption found by Davide:
    if ( hitID & 0xc0000000 ) {
      ATH_MSG_ERROR ( "Hit ID not Valid (" << MSG::hex << hitID << ")" << MSG::dec );
      continue;
    }
 
    // Convert hitID to Identifier
    IdentifierHash IdHash;
    Identifier idLayer;
    bool identifierOK;
    Identifier idStraw(getIdentifier(hitID, IdHash, idLayer, identifierOK));
    if ( !identifierOK ) {
      ATH_MSG_ERROR ( "Ignoring simhits with suspicious identifier (1)" );
      continue;
    }
 
    //For crosstalk sim
    simhitsIdentifiers.insert(idStraw);
 
    // Fill a vector of deposits
    depositVector.clear();
    depositVector.reserve(std::distance(i,e));
    for (TimedHitCollection<TRTUncompressedHit>::const_iterator hit_iter(i); hit_iter != e; ++hit_iter ) {
      // create a new deposit
      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.
                                     (*hit_iter)->GetEnergyDeposit() );
      if (HepMC::ignoreTruthLink(deposit.first, m_vetoPileUpTruthLinks)) {
        continue;
      }
      ATH_MSG_VERBOSE ( "Deposit: trackID " << deposit.first << " energyDeposit " << deposit.second );
      depositVector.emplace_back(std::move(deposit));
    }
 
    const TimedHitPtr<TRTUncompressedHit>& theHit(*i);
    const double bunchCrossingTime(hitTime(theHit) - static_cast<double>(theHit->GetGlobalTime()));
 
    // Add the simdata object to the map.
    if ( !depositVector.empty() &&
         (evtIndex == 0 || ((*i)->GetKineticEnergy()>m_minpileuptruthEkin))  &&
         (bunchCrossingTime < m_maxCrossingTimeSDO) && (bunchCrossingTime > m_minCrossingTimeSDO) ) {
      simDataMap->try_emplace(idStraw, std::move(depositVector));
    }
 
    // Digitization for the given straw
    TRTDigit digit_straw;
 
    //if (m_settings->doCosmicTimingPit()) {
    //  if ( StatusCode::SUCCESS == evtStore()->retrieve(m_ComTime,"ComTime")) {
    //  ATH_MSG_VERBOSE ( "Found tool for cosmic timing: ComTime" );
    //  } else {
    //    ATH_MSG_ERROR ( "Did not find tool needed for cosmic timing: ComTime" );
    //  }
    //}
 
    // if StatusHT == 6 thats emulate argon, ==7 that's emulate krypton
    bool emulateArFlag = m_sumTool->getStatusHT(idStraw, ctx) == 6;
    bool emulateKrFlag = m_sumTool->getStatusHT(idStraw, ctx) == 7;
    const int statusHT = m_sumTool->getStatusHT(idStraw, ctx);
    m_pProcessingOfStraw->ProcessStraw(fieldCache, i, e, digit_straw,
                                       m_alreadyPrintedPDGcodeWarning,
                                       m_cosmicEventPhase, //m_ComTime,
                                       TRTDigiHelper::StrawGasType(statusHT,m_UseGasMix, &msg()),
                                       emulateArFlag,
                                       emulateKrFlag,
                                       strawRndmEngine,
                                       elecProcRndmEngine,
                                       elecNoiseRndmEngine,
                                       paiRndmEngine);
 
    // Print out the digits etc (for debugging)
    //int          mstrw = digit_straw.GetStrawID();
    //unsigned int mword = digit_straw.GetDigit();
    //std::cout << "AJB " << mstrw << ":" << mword << std::endl;
    //print_mword_properties(mword);
    //std::cout << "AJB "; bits24(mword);
    //std::cout << "AJB "; bits27(mword);
 
    // finally push back the output digit.
    if ( digit_straw.GetDigit() ) {
      m_vDigits.push_back(digit_straw);
    }
 
  } // end of straw loop
 
  return StatusCode::SUCCESS;
}

resetFilter() [1/2]

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ 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.

                                                       {
    //closed interval [m_firstXing,m_lastXing]
    return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
  }

Member Data Documentation

m_alreadyPrintedPDGcodeWarning

bool TRTDigitizationTool::m_alreadyPrintedPDGcodeWarning {false}

private

Definition at line 164 of file TRTDigitizationTool.h.

m_calDbTool

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

private

Definition at line 131 of file TRTDigitizationTool.h.

m_cosmicEventPhase

double TRTDigitizationTool::m_cosmicEventPhase {0.0}

private

Definition at line 169 of file TRTDigitizationTool.h.

m_dataObjectName

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

private

Definition at line 140 of file TRTDigitizationTool.h.

m_digverscontainerkey

SG::ReadCondHandleKey<AthenaAttributeList> TRTDigitizationTool::m_digverscontainerkey { this, "DigVersContainerKey", "", "" }

private

Definition at line 175 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 136 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 176 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 147 of file TRTDigitizationTool.h.

m_HardScatterSplittingSkipper

bool TRTDigitizationTool::m_HardScatterSplittingSkipper {false}

private

Definition at line 178 of file TRTDigitizationTool.h.

m_hitsContainerKey

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

private

Definition at line 139 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 160 of file TRTDigitizationTool.h.

m_maxCrossingTimeSDO

double TRTDigitizationTool::m_maxCrossingTimeSDO {0.0}

private

Definition at line 166 of file TRTDigitizationTool.h.

m_mergeSvc

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

private

Definition at line 132 of file TRTDigitizationTool.h.

m_minCrossingTimeSDO

double TRTDigitizationTool::m_minCrossingTimeSDO {0.0}

private

Definition at line 165 of file TRTDigitizationTool.h.

m_minpileuptruthEkin

double TRTDigitizationTool::m_minpileuptruthEkin {0.0}

private

Definition at line 167 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 138 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 141 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 142 of file TRTDigitizationTool.h.

m_particleTable

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

private

Definition at line 173 of file TRTDigitizationTool.h.

m_pDigConditions

TRTDigCondBase* TRTDigitizationTool::m_pDigConditions {}

private

Definition at line 157 of file TRTDigitizationTool.h.

m_pElectronicsProcessing

TRTElectronicsProcessing* TRTDigitizationTool::m_pElectronicsProcessing {}

private

Definition at line 155 of file TRTDigitizationTool.h.

m_pNoise

TRTNoise* TRTDigitizationTool::m_pNoise {}

private

Definition at line 158 of file TRTDigitizationTool.h.

m_pProcessingOfStraw

TRTProcessingOfStraw* TRTDigitizationTool::m_pProcessingOfStraw {}

private

Definition at line 156 of file TRTDigitizationTool.h.

m_ppSvc

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

private

Handle on the particle property service.

Definition at line 172 of file TRTDigitizationTool.h.

m_printOverrideableSettings

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

private

Definition at line 145 of file TRTDigitizationTool.h.

m_printUsedDigSettings

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

private

Definition at line 146 of file TRTDigitizationTool.h.

m_randomSeedOffset

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

private

Definition at line 149 of file TRTDigitizationTool.h.

m_rndmSvc

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

private

Random number service.

Definition at line 133 of file TRTDigitizationTool.h.

m_seen

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

private

Definition at line 153 of file TRTDigitizationTool.h.

m_settings

TRTDigSettings* TRTDigitizationTool::m_settings {}

private

Definition at line 151 of file TRTDigitizationTool.h.

m_sumTool

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

private

Definition at line 130 of file TRTDigitizationTool.h.

m_thpctrt

TimedHitCollection<TRTUncompressedHit>* TRTDigitizationTool::m_thpctrt {}

private

Definition at line 163 of file TRTDigitizationTool.h.

m_trt_id

const TRT_ID* TRTDigitizationTool::m_trt_id {}

private

TRT Id Helper.

Definition at line 161 of file TRTDigitizationTool.h.

m_trtHitCollList

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

private

Definition at line 162 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 127 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 128 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 126 of file TRTDigitizationTool.h.

m_trtrdo_container

SG::WriteHandle<TRT_RDO_Container> TRTDigitizationTool::m_trtrdo_container

private

Definition at line 143 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 129 of file TRTDigitizationTool.h.

m_TRTStrawNeighbourSvc

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

private

Definition at line 134 of file TRTDigitizationTool.h.

m_UseGasMix

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

private

Definition at line 148 of file TRTDigitizationTool.h.

m_vDigits

std::vector<TRTDigit> TRTDigitizationTool::m_vDigits

private

Vector of all digits.

Definition at line 154 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:

• TRTDigitizationTool.h
• TRTDigitizationTool.cxx