PixelDigitizationTool Class Reference

#include <PixelDigitizationTool.h>

Inheritance diagram for PixelDigitizationTool:

Classes
struct	EventData

Public Member Functions
	PixelDigitizationTool (const std::string &type, const std::string &name, const IInterface *pIID)
virtual StatusCode	initialize () override
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override
StatusCode	processAllSubEventsConst (const EventContext &ctx) const
virtual StatusCode	finalize () override
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int) override
virtual StatusCode	mergeEvent (const EventContext &ctx) override
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final

Protected Member Functions
StatusCode	digitizeEvent (const EventContext &ctx, EventData &event_data) const
StatusCode	prepareEvent (const EventContext &ctx, EventData &event_data) const
void	addSDO (SiChargedDiodeCollection *collection, EventData &event_data) const
EventData &	getCurrentEventData ()

Protected Attributes
std::unique_ptr< EventData >	m_eventData
ServiceHandle< IAthRNGSvc >	m_rndmSvc
	Random number service.
ServiceHandle< PileUpMergeSvc >	m_mergeSvc
Gaudi::Property< bool >	m_createNoiseSDO

Private Member Functions
	PixelDigitizationTool ()
	PixelDigitizationTool (const PixelDigitizationTool &)
PixelDigitizationTool &	operator= (const PixelDigitizationTool &)

Private Attributes
std::vector< SiHitCollection * >	m_hitCollPtrs
Gaudi::Property< bool >	m_onlyUseContainerName
SG::ReadHandleKey< SiHitCollection >	m_hitsContainerKey
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_pixelDetEleCollKey
std::string	m_inputObjectName
SG::WriteHandleKey< PixelRDO_Container >	m_rdoContainerKey
SG::WriteHandleKey< InDetSimDataCollection >	m_simDataCollKey
Gaudi::Property< int >	m_HardScatterSplittingMode
Gaudi::Property< bool >	m_onlyHitElements
const PixelID *	m_detID {}
Gaudi::Property< std::string >	m_pixelIDName {this, "PixelIDName", "PixelID", "Pixel ID name"}
ToolHandleArray< SensorSimTool >	m_chargeTool
ToolHandleArray< FrontEndSimTool >	m_fesimTool
ToolHandle< EnergyDepositionTool >	m_energyDepositionTool

structors and AlgTool implementation
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset

Detailed Description

Definition at line 38 of file PixelDigitizationTool.h.

Constructor & Destructor Documentation

PixelDigitizationTool() [1/3]

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

Definition at line 15 of file PixelDigitizationTool.cxx.

                                                                     :
  PileUpToolBase(type, name, pIID) {
}

PixelDigitizationTool() [2/3]

PixelDigitizationTool::PixelDigitizationTool ( )

private

PixelDigitizationTool() [3/3]

PixelDigitizationTool::PixelDigitizationTool ( const PixelDigitizationTool & )

private

Member Function Documentation

addSDO()

void PixelDigitizationTool::addSDO ( SiChargedDiodeCollection * collection, EventData & event_data ) const

protected

Definition at line 282 of file PixelDigitizationTool.cxx.

                                                                                                    {
  using list_t = SiTotalCharge::list_t;
 
  std::vector<InDetSimData::Deposit> deposits;
  deposits.reserve(5); // no idea what a reasonable number for this would be with pileup
 
  // loop over the charged diodes
  SiChargedDiodeIterator EndOfDiodeCollection = collection->end();
  for (SiChargedDiodeIterator i_chargedDiode = collection->begin(); i_chargedDiode != EndOfDiodeCollection;
       ++i_chargedDiode) {
    deposits.clear();
    const list_t& charges = (*i_chargedDiode).second.totalCharge().chargeComposition();
 
    bool real_particle_hit = false;
    // loop over the list
    list_t::const_iterator EndOfChargeList = charges.end();
    for (list_t::const_iterator i_ListOfCharges = charges.begin(); i_ListOfCharges != EndOfChargeList;
         ++i_ListOfCharges) {
      const HepMcParticleLink& trkLink = i_ListOfCharges->particleLink();
      if (HepMC::ignoreTruthLink(trkLink, m_vetoPileUpTruthLinks)) {
        continue;
      }
      if (!real_particle_hit) {
        real_particle_hit = trkLink.isValid();
      }
      // check if this track number has been already used.
      std::vector<InDetSimData::Deposit>::reverse_iterator theDeposit = deposits.rend();  //dummy value
      std::vector<InDetSimData::Deposit>::reverse_iterator depositsR_end = deposits.rend();
      std::vector<InDetSimData::Deposit>::reverse_iterator i_Deposit = deposits.rbegin();
      for (; i_Deposit != depositsR_end; ++i_Deposit) {
        if ((*i_Deposit).first == trkLink) {
          theDeposit = i_Deposit;
          break;
        }
      }
 
      // if the charge has already hit the Diode add it to the deposit
      if (theDeposit != depositsR_end) (*theDeposit).second += i_ListOfCharges->charge();
      else { // create a new deposit
        deposits.emplace_back(trkLink, i_ListOfCharges->charge());
      }
    }
    // add the simdata object to the map:
    if (real_particle_hit || m_createNoiseSDO) {
      assert( event_data.m_simDataColl.isValid());
      event_data.m_simDataColl->try_emplace(collection->getId((*i_chargedDiode).first),
                                            std::move(deposits), (*i_chargedDiode).second.flag());
    }
  }
}

digitizeEvent()

StatusCode PixelDigitizationTool::digitizeEvent ( const EventContext & ctx, EventData & event_data ) const

protected

Definition at line 121 of file PixelDigitizationTool.cxx.

                                                                                                    {
  ATH_MSG_VERBOSE("PixelDigitizationTool::digitizeEvent()");
 
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> pixelDetEleHandle(m_pixelDetEleCollKey, ctx);
  const InDetDD::SiDetectorElementCollection* elements(*pixelDetEleHandle);
  if (not pixelDetEleHandle.isValid() or elements == nullptr) {
    ATH_MSG_FATAL(m_pixelDetEleCollKey.fullKey() << " is not available.");
    return StatusCode::FAILURE;
  }
 
  std::unique_ptr<SiChargedDiodeCollection> chargedDiodes = std::make_unique<SiChargedDiodeCollection>();
  std::vector<std::pair<double, double> > trfHitRecord;
  std::vector<double> initialConditions;
 
  std::vector<bool> processedElements;
  processedElements.resize(m_detID->wafer_hash_max(), false);
 
  // Set the RNG to use for this event.
  ATHRNG::RNGWrapper* rngWrapper = m_rndmSvc->getEngine(this);
  rngWrapper->setSeed(name(), ctx);
  CLHEP::HepRandomEngine* rndmEngine = rngWrapper->getEngine(ctx);
 
  TimedHitCollection<SiHit>::const_iterator firstHit, lastHit;

  // **** Loop over the Detectors with hits ****
  assert(event_data.m_timedHits);
  while (event_data.m_timedHits->nextDetectorElement(firstHit, lastHit)) {
    // Create the identifier for the collection
    ATH_MSG_DEBUG("create ID for the hit collection");
    Identifier id = m_detID->wafer_id((*firstHit)->getBarrelEndcap(),
                                      (*firstHit)->getLayerDisk(),
                                      (*firstHit)->getPhiModule(), (*firstHit)->getEtaModule());
    IdentifierHash wafer_hash = m_detID->wafer_hash(id);
 
    // Get the det element from the manager
    const InDetDD::SiDetectorElement* sielement = elements->getDetectorElement(wafer_hash);
 
    if (sielement == nullptr) {
      ATH_MSG_DEBUG(
        " Barrel=" << (*firstHit)->getBarrelEndcap() << " Layer=" << (*firstHit)->getLayerDisk() << " Eta=" <<
        (*firstHit)->getEtaModule() << " Phi=" << (*firstHit)->getPhiModule());
      ATH_MSG_ERROR("detector manager could not find element with id = " << id);
      break;
    }
 
    // Create the charged diodes collection
    chargedDiodes->setDetectorElement(sielement);
    const InDetDD::PixelModuleDesign* p_design = static_cast<const InDetDD::PixelModuleDesign*>(&(sielement->design()));

    // **** Loop over the hits and created charged diodes ****
    for (TimedHitCollection<SiHit>::const_iterator phit = firstHit; phit != lastHit; ++phit) {
      //skip hits which are more than 10us away
      if (std::abs((*phit)->meanTime()) < 10000.0 * CLHEP::ns) {
        ATH_MSG_DEBUG("HASH = " <<
          m_detID->wafer_hash(m_detID->wafer_id((*phit)->getBarrelEndcap(), (*phit)->getLayerDisk(),
                                                (*phit)->getPhiModule(), (*phit)->getEtaModule())));
 
        // Apply charge collection tools
        ATH_MSG_DEBUG("Running sensor simulation.");
 
        //Deposit energy in sensor
        ATH_CHECK(m_energyDepositionTool->depositEnergy(*phit, *sielement, trfHitRecord, initialConditions,
                                                        rndmEngine, ctx));
 
        //Create signal in sensor, loop over collection of loaded sensorTools
        for (unsigned int itool = 0; itool < m_chargeTool.size(); itool++) {
          ATH_MSG_DEBUG("Executing tool " << m_chargeTool[itool]->name());
          if (m_chargeTool[itool]->induceCharge(*phit, *chargedDiodes, *sielement, *p_design, trfHitRecord,
                                                initialConditions, rndmEngine, ctx) == StatusCode::FAILURE) {
            break;
          }
        }
        initialConditions.clear();
        trfHitRecord.clear();
        ATH_MSG_DEBUG("charges filled!");
      }
    }
 
    ATH_MSG_DEBUG("Hit collection ID=" << m_detID->show_to_string(chargedDiodes->identify()));
    ATH_MSG_DEBUG("in digitize elements with hits: ec - layer - eta - phi  " <<
      m_detID->barrel_ec(chargedDiodes->identify()) << " - " << m_detID->layer_disk(
                    chargedDiodes->identify()) << " - " << m_detID->eta_module(
                    chargedDiodes->identify()) << " - " << m_detID->phi_module(chargedDiodes->identify()));
 
    IdentifierHash idHash = chargedDiodes->identifyHash();
 
    assert(idHash < processedElements.size());
    processedElements[idHash] = true;

    // ***       Create and store RDO and SDO   ****
    PixelRDO_Collection* RDOColl = new PixelRDO_Collection(chargedDiodes->identifyHash());
    RDOColl->setIdentifier(chargedDiodes->identify());
    for (unsigned int itool = 0; itool < m_fesimTool.size(); itool++) {
      ATH_MSG_DEBUG("Executing tool " << m_fesimTool[itool]->name());
      m_fesimTool[itool]->process(*chargedDiodes, *RDOColl, rndmEngine);
    }
    assert(event_data.m_rdoContainer.isValid());
    ATH_CHECK(event_data.m_rdoContainer->addCollection(RDOColl, RDOColl->identifyHash()));
 
    ATH_MSG_DEBUG("Pixel RDOs '" << RDOColl->identifyHash() << "' added to container");
    addSDO(chargedDiodes.get(), event_data);
    chargedDiodes->clear();
  }
  event_data.m_timedHits.reset();
  ATH_MSG_DEBUG("hits processed");

  //  ***  Loop over the Detectors without hits ****
  if (!m_onlyHitElements) {
    ATH_MSG_DEBUG("processing elements without hits");
    for (unsigned int i = 0; i < processedElements.size(); i++) {
      if (!processedElements[i]) {
        IdentifierHash idHash = i;
        if (!idHash.is_valid()) {
          ATH_MSG_ERROR("PixelDetector element id hash is invalid = " << i);
        }
 
        const InDetDD::SiDetectorElement* element = elements->getDetectorElement(idHash);
        if (element) {
          ATH_MSG_DEBUG("In digitize of untouched elements: layer - phi - eta  " <<
            m_detID->layer_disk(element->identify()) << " - " << m_detID->phi_module(
                          element->identify()) << " - " << m_detID->eta_module(
                          element->identify()) << " - " << "size: " << processedElements.size());
 
          chargedDiodes->setDetectorElement(element);
          ATH_MSG_DEBUG("Digitize non hit element");
 
          // Create and store RDO and SDO
          PixelRDO_Collection* RDOColl = new PixelRDO_Collection(chargedDiodes->identifyHash());
          RDOColl->setIdentifier(chargedDiodes->identify());
          for (unsigned int itool = 0; itool < m_fesimTool.size(); itool++) {
            ATH_MSG_DEBUG("Executing tool " << m_fesimTool[itool]->name());
            m_fesimTool[itool]->process(*chargedDiodes, *RDOColl, rndmEngine);
          }
          assert( event_data.m_rdoContainer.isValid());
          ATH_CHECK(event_data.m_rdoContainer->addCollection(RDOColl, RDOColl->identifyHash()));
 
          ATH_MSG_DEBUG("Pixel RDOs '" << RDOColl->identifyHash() << "' added to container");
          addSDO(chargedDiodes.get(),event_data);
          chargedDiodes->clear();
        }
      }
    }
  }
  ATH_MSG_DEBUG("non-hits processed");
 
  return StatusCode::SUCCESS;
}

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

finalize()

StatusCode PixelDigitizationTool::finalize ( )

overridevirtual

Definition at line 58 of file PixelDigitizationTool.cxx.

                                           {
  return StatusCode::SUCCESS;
}

getCurrentEventData()

EventData & PixelDigitizationTool::getCurrentEventData ( )

inlineprotected

Definition at line 101 of file PixelDigitizationTool.h.

{ assert(m_eventData); return *m_eventData; }

initialize()

StatusCode PixelDigitizationTool::initialize ( )

overridevirtual

Reimplemented from PileUpToolBase.

Definition at line 24 of file PixelDigitizationTool.cxx.

                                             {
  ATH_MSG_DEBUG("PixelDigitizationTool::Initialize()");
 
  if (m_onlyUseContainerName) {
    ATH_CHECK(m_mergeSvc.retrieve());
  }
  ATH_CHECK(m_rndmSvc.retrieve());
 
  ATH_CHECK(detStore()->retrieve(m_detID, m_pixelIDName.value()));
  ATH_MSG_DEBUG("Pixel ID helper retrieved");
 
  ATH_CHECK(m_chargeTool.retrieve());
  ATH_CHECK(m_fesimTool.retrieve());
  ATH_CHECK(m_energyDepositionTool.retrieve());
 
  // check the input object name
  if (m_hitsContainerKey.key().empty()) {
    ATH_MSG_FATAL("Property InputObjectName not set !");
    return StatusCode::FAILURE;
  }
  if (m_onlyUseContainerName) m_inputObjectName = m_hitsContainerKey.key();
  ATH_MSG_DEBUG("Input objects in container : '" << m_inputObjectName << "'");
 
  ATH_CHECK(m_hitsContainerKey.initialize(true));
  ATH_CHECK(m_pixelDetEleCollKey.initialize());
  ATH_CHECK(m_rdoContainerKey.initialize());
  ATH_CHECK(m_simDataCollKey.initialize());
 
  return StatusCode::SUCCESS;
}

mergeEvent()

StatusCode PixelDigitizationTool::mergeEvent ( const EventContext & ctx )

overridevirtual

Definition at line 358 of file PixelDigitizationTool.cxx.

                                                                    {
  ATH_MSG_VERBOSE("PixelDigitizationTool::mergeEvent()");
 
  // Digitize hits
  ATH_CHECK(digitizeEvent(ctx, getCurrentEventData()));
 
  for (auto & hitCollPtr : m_hitCollPtrs) {
    hitCollPtr->Clear();
    delete hitCollPtr;
  }
  m_hitCollPtrs.clear();
 
  return StatusCode::SUCCESS;
}

operator=()

PixelDigitizationTool & PixelDigitizationTool::operator= ( const PixelDigitizationTool & )

private

prepareEvent() [1/2]

StatusCode PixelDigitizationTool::prepareEvent ( const EventContext & ctx, EventData & event_data ) const

protected

Definition at line 336 of file PixelDigitizationTool.cxx.

                                                                                                   {
  ATH_MSG_VERBOSE("PixelDigitizationTool::prepareEvent()");
 
  // Prepare event
  event_data.m_rdoContainer = SG::makeHandle(m_rdoContainerKey, ctx);
  ATH_CHECK(event_data.m_rdoContainer.record(std::make_unique<PixelRDO_Container>(m_detID->wafer_hash_max())));
  ATH_MSG_DEBUG("PixelRDO_Container " << event_data.m_rdoContainer.name() << " registered in StoreGate");
 
  event_data.m_simDataColl = SG::makeHandle(m_simDataCollKey, ctx);
  ATH_CHECK(event_data.m_simDataColl.record(std::make_unique<InDetSimDataCollection>()));
  ATH_MSG_DEBUG("InDetSimDataCollection " << event_data.m_simDataColl.name() << " registered in StoreGate");
 
  // Create hit collection
  event_data.m_timedHits = std::make_unique<TimedHitCollection<SiHit> >();
 
  event_data.m_HardScatterSplittingSkipper = false;
  return StatusCode::SUCCESS;
}

prepareEvent() [2/2]

virtual StatusCode PixelDigitizationTool::prepareEvent ( const EventContext & ctx, unsigned int  )

inlineoverridevirtual

Definition at line 51 of file PixelDigitizationTool.h.

                                                                                  {
     if (!m_eventData) { m_eventData = std::make_unique<EventData>(); }
     return prepareEvent(ctx, *m_eventData);
  }

processAllSubEvents()

virtual StatusCode PixelDigitizationTool::processAllSubEvents ( const EventContext & ctx )

inlineoverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 45 of file PixelDigitizationTool.h.

                                                                           {
     return processAllSubEventsConst(ctx);
  }

processAllSubEventsConst()

StatusCode PixelDigitizationTool::processAllSubEventsConst

(

const EventContext &

ctx

)

const

Definition at line 65 of file PixelDigitizationTool.cxx.

                                                                                        {
  // Prepare event
  ATH_MSG_DEBUG("Prepare event");
  EventData event_data;
  ATH_CHECK(prepareEvent(ctx, event_data));
 
  // Get the container(s)
  using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
  // In case of single hits container just load the collection using read handles
  if (!m_onlyUseContainerName) {
    SG::ReadHandle<SiHitCollection> hitCollection(m_hitsContainerKey, ctx);
    if (!hitCollection.isValid()) {
      ATH_MSG_ERROR(
        "Could not get Pixel SiHitCollection container " << hitCollection.name() << " from store " <<
          hitCollection.store());
      return StatusCode::FAILURE;
    }
 
    assert(event_data.m_timedHits);
    // create a new hits collection
    event_data.m_timedHits->reserve(1);
    event_data.m_timedHits->insert(0, hitCollection.cptr());
    ATH_MSG_DEBUG("SiHitCollection found with " << hitCollection->size() << " hits");
  } else {
    TimedHitCollList hitCollList;
    unsigned int numberOfSiHits(0);
    ATH_CHECK(m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList, numberOfSiHits));
    event_data.m_timedHits->reserve(numberOfSiHits);
    // Now merge all collections into one
    for (auto & iColl : hitCollList) {
      // Decide if this event will be processed depending on HardScatterSplittingMode
      if (m_HardScatterSplittingMode == 2 && !event_data.m_HardScatterSplittingSkipper) {
        event_data.m_HardScatterSplittingSkipper = true;
        continue;
      }
      if (m_HardScatterSplittingMode == 1 && event_data.m_HardScatterSplittingSkipper) {
        continue;
      }
      if (m_HardScatterSplittingMode == 1 && !event_data.m_HardScatterSplittingSkipper) {
        event_data.m_HardScatterSplittingSkipper = true;
      }
      const SiHitCollection* p_collection(iColl.second);
      event_data.m_timedHits->insert(iColl.first, p_collection);
      ATH_MSG_DEBUG("SiTrackerHitCollection found with" << p_collection->size() << " hits"); // loop on the hit collections
    }
  }
  // Digitize hits
  ATH_CHECK(digitizeEvent(ctx, event_data));
 
  ATH_MSG_DEBUG("Digitize success!");
  return StatusCode::SUCCESS;
}

processBunchXing()

StatusCode PixelDigitizationTool::processBunchXing ( int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 376 of file PixelDigitizationTool.cxx.

                                                                                {
  ATH_MSG_VERBOSE("PixelDigitizationTool::processBunchXing() " << bunchXing);
  //decide if this event will be processed depending on HardScatterSplittingMode & bunchXing
  EventData &event_data = getCurrentEventData();
  if (m_HardScatterSplittingMode == 2 && !event_data.m_HardScatterSplittingSkipper) {
    event_data.m_HardScatterSplittingSkipper = true;
    return StatusCode::SUCCESS;
  }
  if (m_HardScatterSplittingMode == 1 && event_data.m_HardScatterSplittingSkipper) {
    return StatusCode::SUCCESS;
  }
  if (m_HardScatterSplittingMode == 1 && !event_data.m_HardScatterSplittingSkipper) {
    event_data.m_HardScatterSplittingSkipper = true;
  }
 
  using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
  TimedHitCollList hitCollList;
 
  if (!(m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitCollList, bunchXing,
                                          bSubEvents, eSubEvents).isSuccess()) &&
      hitCollList.empty()) {
    ATH_MSG_ERROR("Could not fill TimedHitCollList");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_VERBOSE(hitCollList.size() << " SiHitCollections with key " << m_inputObjectName << " found");
  }
 
  TimedHitCollList::iterator iColl(hitCollList.begin());
  TimedHitCollList::iterator endColl(hitCollList.end());
 
  for (; iColl != endColl; ++iColl) {
    SiHitCollection* hitCollPtr = new SiHitCollection(*iColl->second);
    PileUpTimeEventIndex timeIndex(iColl->first);
    ATH_MSG_DEBUG("SiHitCollection found with " << hitCollPtr->size() << " hits");
    ATH_MSG_VERBOSE(
      "time index info. time: " << timeIndex.time() << " index: " << timeIndex.index() << " type: " <<
        timeIndex.type());
    assert(event_data.m_timedHits);
    event_data.m_timedHits->insert(timeIndex, hitCollPtr);
    m_hitCollPtrs.push_back(hitCollPtr);
  }
  return StatusCode::SUCCESS;
}

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

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

Member Data Documentation

m_chargeTool

ToolHandleArray<SensorSimTool> PixelDigitizationTool::m_chargeTool

private

Initial value:

{
    this, "ChargeTools", {}, "List of charge tools"
  }

Definition at line 113 of file PixelDigitizationTool.h.

                                              {
    this, "ChargeTools", {}, "List of charge tools"
  };

m_createNoiseSDO

Gaudi::Property<bool> PixelDigitizationTool::m_createNoiseSDO

protected

Initial value:

{
    this, "CreateNoiseSDO", false, "Set create noise SDO flag"
  }

Definition at line 130 of file PixelDigitizationTool.h.

                                       {
    this, "CreateNoiseSDO", false, "Set create noise SDO flag"
  };

m_detID

const PixelID* PixelDigitizationTool::m_detID {}

private

Definition at line 108 of file PixelDigitizationTool.h.

{};

m_energyDepositionTool

ToolHandle<EnergyDepositionTool> PixelDigitizationTool::m_energyDepositionTool

private

Initial value:

{
    this, "EnergyDepositionTool", "EnergyDepositionTool", "Energy deposition tool"
  }

Definition at line 119 of file PixelDigitizationTool.h.

                                                          {
    this, "EnergyDepositionTool", "EnergyDepositionTool", "Energy deposition tool"
  };

m_eventData

std::unique_ptr<EventData> PixelDigitizationTool::m_eventData

protected

Definition at line 102 of file PixelDigitizationTool.h.

m_fesimTool

ToolHandleArray<FrontEndSimTool> PixelDigitizationTool::m_fesimTool

private

Initial value:

{
    this, "FrontEndSimTools", {}, "List of Front-End simulation tools"
  }

Definition at line 116 of file PixelDigitizationTool.h.

                                               {
    this, "FrontEndSimTools", {}, "List of Front-End simulation tools"
  };

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

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.

                                {this, "FirstXing", -999,
      "First bunch-crossing in which det is live"};

m_HardScatterSplittingMode

Gaudi::Property<int> PixelDigitizationTool::m_HardScatterSplittingMode

private

Initial value:

{
    this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"
  }

Definition at line 87 of file PixelDigitizationTool.h.

                                                                      {
    this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting"
  };

m_hitCollPtrs

std::vector<SiHitCollection*> PixelDigitizationTool::m_hitCollPtrs

private

Definition at line 67 of file PixelDigitizationTool.h.

m_hitsContainerKey

SG::ReadHandleKey<SiHitCollection> PixelDigitizationTool::m_hitsContainerKey

private

Initial value:

{
    this, "InputObjectName", "", "Input HITS collection name"
  }

Definition at line 72 of file PixelDigitizationTool.h.

                                                              {
    this, "InputObjectName", "", "Input HITS collection name"
  };

m_inputObjectName

std::string PixelDigitizationTool::m_inputObjectName

private

Initial value:

{
    ""
  }

Definition at line 78 of file PixelDigitizationTool.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.

                                {this, "LastXing", 999,
      "Last bunch-crossing in which det is live"};

m_mergeSvc

ServiceHandle<PileUpMergeSvc> PixelDigitizationTool::m_mergeSvc

protected

Initial value:

{
    this, "PileUpMergeSvc", "PileUpMergeSvc", ""
  }

Definition at line 126 of file PixelDigitizationTool.h.

                                            {
    this, "PileUpMergeSvc", "PileUpMergeSvc", ""
  };

m_onlyHitElements

Gaudi::Property<bool> PixelDigitizationTool::m_onlyHitElements

private

Initial value:

{
    this, "OnlyHitElements", false, "Process only elements with hits"
  }

Definition at line 104 of file PixelDigitizationTool.h.

                                                             {
    this, "OnlyHitElements", false, "Process only elements with hits"
  };

m_onlyUseContainerName

Gaudi::Property<bool> PixelDigitizationTool::m_onlyUseContainerName

private

Initial value:

{
    this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."
  }

Definition at line 69 of file PixelDigitizationTool.h.

                                             {
    this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."
  };

m_pixelDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> PixelDigitizationTool::m_pixelDetEleCollKey

private

Initial value:

{
    this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"
  }

Definition at line 75 of file PixelDigitizationTool.h.

                                                                               {
    this, "PixelDetEleCollKey", "PixelDetectorElementCollection", "Key of SiDetectorElementCollection for Pixel"
  };

m_pixelIDName

Gaudi::Property<std::string> PixelDigitizationTool::m_pixelIDName {this, "PixelIDName", "PixelID", "Pixel ID name"}

private

Definition at line 109 of file PixelDigitizationTool.h.

{this, "PixelIDName", "PixelID", "Pixel ID name"};

m_rdoContainerKey

SG::WriteHandleKey<PixelRDO_Container> PixelDigitizationTool::m_rdoContainerKey

private

Initial value:

{
    this, "RDOCollName", "PixelRDOs", "RDO collection name"
  }

Definition at line 81 of file PixelDigitizationTool.h.

                                                             {
    this, "RDOCollName", "PixelRDOs", "RDO collection name"
  };

m_rndmSvc

ServiceHandle<IAthRNGSvc> PixelDigitizationTool::m_rndmSvc

protected

Initial value:

{
    this, "RndmSvc", "AthRNGSvc", ""
  }

Random number service.

Definition at line 123 of file PixelDigitizationTool.h.

                                      {
    this, "RndmSvc", "AthRNGSvc", ""
  };  

m_simDataCollKey

SG::WriteHandleKey<InDetSimDataCollection> PixelDigitizationTool::m_simDataCollKey

private

Initial value:

{
    this, "SDOCollName", "PixelSDO_Map", "SDO collection name"
  }

Definition at line 84 of file PixelDigitizationTool.h.

                                                            {
    this, "SDOCollName", "PixelSDO_Map", "SDO collection name"
  };

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.

                                           {this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"};

---

The documentation for this class was generated from the following files:

• PixelDigitizationTool.h
• PixelDigitizationTool.cxx