ITk::StripDigitizationTool Class Reference

#include <StripDigitizationTool.h>

Inheritance diagram for ITk::StripDigitizationTool:

Public Member Functions
	StripDigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~StripDigitizationTool ()
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int) override final
	Called before processing physics events.
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
virtual StatusCode	initialize () override final
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
bool	digitizeElement (const EventContext &ctx, SiChargedDiodeCollectionMap &chargedDiodes, TimedHitCollection< SiHit > *&thpcsi, CLHEP::HepRandomEngine *rndmEngine)
void	applyProcessorTools (SiChargedDiodeCollection *chargedDiodes, CLHEP::HepRandomEngine *rndmEngine) const
void	addSDO (SiChargedDiodeCollection *collection, SG::WriteHandle< InDetSimDataCollection > *simDataCollMap) const
void	storeTool (ISiChargedDiodesProcessorTool *p_processor)

Private Member Functions
StatusCode	initServices ()
	initialize the required services
StatusCode	initFrontEndTool ()
	Initialize the StripFrontEnd AlgTool.
StatusCode	initDisabledCells ()
	Initialize the StripRandomDisabledCellGenerator AlgTool.
StatusCode	initSurfaceChargesGeneratorTool ()
	Initialize the StripSurfaceChargesGenerator AlgTool.
StatusCode	createAndStoreRDO (SiChargedDiodeCollection *chDiodeCollection, SG::WriteHandle< SCT_RDO_Container > *rdoContainer) const
	RDO and SDO methods.
std::unique_ptr< SCT_RDO_Collection >	createRDO (SiChargedDiodeCollection *collection) const
	Create RDOs from the SiChargedDiodeCollection for the current wafer.
StatusCode	getNextEvent (const EventContext &ctx)
void	digitizeAllHits (const EventContext &ctx, SG::WriteHandle< SCT_RDO_Container > *rdoContainer, SG::WriteHandle< InDetSimDataCollection > *simDataCollMap, std::vector< bool > *processedElements, TimedHitCollection< SiHit > *thpcsi, CLHEP::HepRandomEngine *rndmEngine)
	digitize all hits
void	digitizeNonHits (const EventContext &ctx, SG::WriteHandle< SCT_RDO_Container > *rdoContainer, SG::WriteHandle< InDetSimDataCollection > *simDataCollMap, const std::vector< bool > *processedElements, CLHEP::HepRandomEngine *rndmEngine) const
	digitize SCT without hits
void	SetupRdoOutputType (Gaudi::Details::PropertyBase &)
	Called when m_WriteSCT1_RawData is altered.

Private Attributes
FloatProperty	m_tfix {this, "FixedTime", -999., "Fixed time for Cosmics run selection"}
BooleanProperty	m_enableHits {this, "EnableHits", true, "Enable hits"}
BooleanProperty	m_onlyHitElements {this, "OnlyHitElements", false, "Process only elements with hits"}
BooleanProperty	m_cosmicsRun {this, "CosmicsRun", false, "Cosmics run selection"}
BooleanProperty	m_barrelonly {this, "BarrelOnly", false, "Only Barrel layers"}
BooleanProperty	m_randomDisabledCells {this, "RandomDisabledCells", false, "Use Random disabled cells, default no"}
BooleanProperty	m_createNoiseSDO {this, "CreateNoiseSDO", false, "Create SDOs for strips with only noise hits (huge increase in SDO collection size"}
IntegerProperty	m_HardScatterSplittingMode {this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting. Process all SiHit or just those from signal or background events"}
BooleanProperty	m_WriteSCT1_RawData {this, "WriteSCT1_RawData", false, "Write out SCT1_RawData rather than SCT3_RawData"}
BooleanProperty	m_onlyUseContainerName {this, "OnlyUseContainerName", true, "Don't use the ReadHandleKey directly. Just extract the container name from it."}
SG::ReadHandleKey< SiHitCollection >	m_hitsContainerKey {this, "InputObjectName", "StripHits", "Input HITS collection name"}
std::string	m_inputObjectName {""}
SG::WriteHandleKey< SCT_RDO_Container >	m_rdoContainerKey {this, "OutputObjectName", "SCT_RDOs", "Output Object name"}
SG::WriteHandle< SCT_RDO_Container >	m_rdoContainer
	RDO container handle.
SG::WriteHandleKey< InDetSimDataCollection >	m_simDataCollMapKey {this, "OutputSDOName", "StripSDO_Map", "Output SDO container name"}
SG::WriteHandle< InDetSimDataCollection >	m_simDataCollMap
	SDO Map handle.
SG::ReadCondHandleKey< InDetDD::SiDetectorElementCollection >	m_stripDetEleCollKey {this, "StripDetEleCollKey", "ITkStripDetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}
ToolHandle< IFrontEnd >	m_sct_FrontEnd {this, "FrontEnd", "StripFrontEnd", "Handle the Front End Electronic tool"}
ToolHandle< ISurfaceChargesGenerator >	m_sct_SurfaceChargesGenerator {this, "SurfaceChargesGenerator", "StripSurfaceChargesGenerator", "Choice of using a more detailed charge drift model"}
ToolHandle< IRandomDisabledCellGenerator >	m_sct_RandomDisabledCellGenerator {this, "RandomDisabledCellGenerator", "StripRandomDisabledCellGenerator", ""}
ServiceHandle< IAthRNGSvc >	m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}
	Random number service.
ServiceHandle< PileUpMergeSvc >	m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service used in Pixel & SCT digitization"}
const SCT_ID *	m_detID {nullptr}
	Handle to the ID helper.
std::unique_ptr< TimedHitCollection< SiHit > >	m_thpcsi {nullptr}
std::vector< ISiChargedDiodesProcessorTool * >	m_diodeCollectionTools
std::vector< bool >	m_processedElements
	vector of processed elements - set by digitizeHits() *‍/
std::vector< std::unique_ptr< SiHitCollection > >	m_hitCollPtrs
bool	m_HardScatterSplittingSkipper {false}

Detailed Description

Definition at line 58 of file StripDigitizationTool.h.

Constructor & Destructor Documentation

StripDigitizationTool()

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

Definition at line 45 of file StripDigitizationTool.cxx.

                                                                     :
  base_class(type, name, parent) {
  m_WriteSCT1_RawData.declareUpdateHandler(&StripDigitizationTool::SetupRdoOutputType, this);
}

~StripDigitizationTool()

ITk::StripDigitizationTool::~StripDigitizationTool ( )

virtualdefault

Member Function Documentation

addSDO()

void ITk::StripDigitizationTool::addSDO ( SiChargedDiodeCollection * collection, SG::WriteHandle< InDetSimDataCollection > * simDataCollMap ) const

protected

Definition at line 872 of file StripDigitizationTool.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 (not real_particle_hit) {
        // Types of SiCharges expected from SCT
        // Noise:                        barcode==0 and
        // processType()==SiCharge::noise
        // Delta Rays:                   barcode==0 and
        // processType()==SiCharge::track
        // Pile Up Tracks With No Truth: barcode!=0 and
        // processType()==SiCharge::cut_track
        // Tracks With Truth:            barcode!=0 and
        // processType()==SiCharge::track
        if (!HepMC::no_truth_link(trkLink) && i_ListOfCharges->processType() == SiCharge::track) {
          real_particle_hit = true;
        }
      }
      // check if this track number has been already used.
      const auto theDeposit = std::ranges::find_if(
        deposits.rbegin(), deposits.rend(),
        [&trkLink](const InDetSimData::Deposit& deposit) {
          return deposit.first == trkLink;
      });
 
      // if the charge has already hit the Diode add it to the deposit
      if (theDeposit != deposits.rend()) {
        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 or m_createNoiseSDO) {
      InDetDD::SiReadoutCellId roCell{(*i_chargedDiode).second.getReadoutCell()};
      int strip{roCell.strip()};
      const InDetDD::SCT_ModuleSideDesign& sctDesign{dynamic_cast<const InDetDD::SCT_ModuleSideDesign&>(collection->design())};
 
      int row2D{sctDesign.row(strip)};
      Identifier id_readout;
      if (row2D < 0) { // SCT sensors and new-style ITkStrip sensors
        id_readout = m_detID->strip_id(collection->identify(),strip);
      } else { // old-style (21.9) ITkStrip sensors
        int strip2D{sctDesign.strip(strip)};
        id_readout = m_detID->strip_id(collection->identify(),row2D, strip2D);
      }
      (*simDataCollMap)->try_emplace(id_readout, std::move(deposits), (*i_chargedDiode).second.flag());
    }
  }
}

applyProcessorTools()

void ITk::StripDigitizationTool::applyProcessorTools ( SiChargedDiodeCollection * chargedDiodes, CLHEP::HepRandomEngine * rndmEngine ) const

protected

Definition at line 543 of file StripDigitizationTool.cxx.

                                                                                                                                {
  ATH_MSG_DEBUG("applyProcessorTools()");
  int processorNumber{0};
 
  for (ISiChargedDiodesProcessorTool* proc: m_diodeCollectionTools) {
    proc->process(*chargedDiodes, rndmEngine);
 
    processorNumber++;
    ATH_MSG_DEBUG("Applied processor # " << processorNumber);
  }
}

createAndStoreRDO()

StatusCode ITk::StripDigitizationTool::createAndStoreRDO ( SiChargedDiodeCollection * chDiodeCollection, SG::WriteHandle< SCT_RDO_Container > * rdoContainer ) const

private

RDO and SDO methods.

Create RDOs from the SiChargedDiodeCollection for the current wafer and save to StoreGate

Parameters

chDiodeCollection

list of the SiChargedDiodes on the current wafer

Definition at line 642 of file StripDigitizationTool.cxx.

                                                                                                                                                     {
 
  // Create the RDO collection
  std::unique_ptr<SCT_RDO_Collection> RDOColl{createRDO(chDiodeCollection)};
  const IdentifierHash identifyHash{RDOColl->identifyHash()};
 
  // Add it to storegate
  Identifier id_coll{RDOColl->identify()};
  int barrelec{m_detID->barrel_ec(id_coll)};
 
  if ((not m_barrelonly) or (std::abs(barrelec) <= 1)) {
    if ((*rdoContainer)->addCollection(RDOColl.release(), identifyHash).isFailure()) {
      ATH_MSG_FATAL("SCT RDO collection could not be added to container!");
      return StatusCode::FAILURE;
    }
  } else {
    ATH_MSG_VERBOSE("Not saving SCT_RDO_Collection: " << m_detID->show_to_string(RDOColl->identify()) << " to container!");
  }
  return StatusCode::SUCCESS;
} // StripDigitization::createAndStoreRDO()

createRDO()

std::unique_ptr< SCT_RDO_Collection > ITk::StripDigitizationTool::createRDO ( SiChargedDiodeCollection * collection ) const

private

Create RDOs from the SiChargedDiodeCollection for the current wafer.

Parameters

collection

list of the SiChargedDiodes on the current wafer

Definition at line 666 of file StripDigitizationTool.cxx.

                                                                                                             {
 
  // create a new SCT RDO collection
  std::unique_ptr<SCT_RDO_Collection> p_rdocoll;
 
  // need the DE identifier
  const Identifier id_de{collection->identify()};
  IdentifierHash idHash_de{collection->identifyHash()};
  try {
    p_rdocoll = std::make_unique<SCT_RDO_Collection>(idHash_de);
  } catch (const std::bad_alloc&) {
    ATH_MSG_FATAL("Could not create a new SCT_RDORawDataCollection !");
  }
  p_rdocoll->setIdentifier(id_de);
 
  SiChargedDiodeIterator i_chargedDiode{collection->begin()};
  SiChargedDiodeIterator i_chargedDiode_end{collection->end()};
  // Choice of producing SCT1_RawData or SCT3_RawData
  if (m_WriteSCT1_RawData.value()) {
    for (; i_chargedDiode != i_chargedDiode_end; ++i_chargedDiode) {
      unsigned int flagmask{static_cast<unsigned int>((*i_chargedDiode).second.flag() & 0xFE)};
 
      if (!flagmask) { // now check it wasn't masked:
        // create new SCT RDO, using method 1 for mask:
        // GroupSize=1: need readout id, make use of
        // SiTrackerDetDescr
        InDetDD::SiReadoutCellId roCell{(*i_chargedDiode).second.getReadoutCell()};
        int strip{roCell.strip()};
        if (strip > 0xffff) { // In upgrade layouts strip can be bigger
          // than 4000
          ATH_MSG_FATAL("Strip number too big for SCT1 raw data format.");
        }
        const Identifier id_readout{m_detID->strip_id(collection->identify(), strip)};
 
        // build word, masks taken from SiTrackerEvent/SCTRawData.cxx
        const unsigned int strip_rdo{static_cast<unsigned int>((strip & 0xFFFF) << 16)};
 
        // user can define what GroupSize is, here 1: TC. Incorrect,
        // GroupSize >= 1
        int size{SiHelper::GetStripNum((*i_chargedDiode).second)};
        unsigned int size_rdo{static_cast<unsigned int>(size & 0xFFFF)};
 
        // TC. Need to check if there are disabled strips in the cluster
        int cluscounter{0};
        if (size > 1) {
          SiChargedDiodeIterator it2{i_chargedDiode};
          ++it2;
          for (; it2 != i_chargedDiode_end; ++it2) {
            ++cluscounter;
            if (cluscounter >= size) {
              break;
            }
            if (it2->second.flag() & 0xDE) {
              int tmp{cluscounter};
              while ((it2 != i_chargedDiode_end) and (cluscounter < size - 1) and (it2->second.flag() & 0xDE)) {
                ++it2;
                ++cluscounter;
              }
              if ((it2 != collection->end()) and !(it2->second.flag() & 0xDE)) {
                SiHelper::ClusterUsed(it2->second, false);
                SiHelper::SetStripNum(it2->second, size - cluscounter, &msg());
              }
              // groupSize=tmp;
              size_rdo = tmp & 0xFFFF;
              break;
            }
          }
        }
        unsigned int StripWord{strip_rdo | size_rdo};
        SCT1_RawData* p_rdo{new SCT1_RawData(id_readout, StripWord)};
        if (p_rdo) {
          p_rdocoll->push_back(p_rdo);
        }
      }
    }
  } else {
    // Under the current scheme time bin and ERRORS are hard-coded to
    // default values.
    int ERRORS{0};
    static const std::vector<int> dummyvector;
    for (; i_chargedDiode != i_chargedDiode_end; ++i_chargedDiode) {
      unsigned int flagmask{static_cast<unsigned int>((*i_chargedDiode).second.flag() & 0xFE)};
 
      if (!flagmask) { // Check it wasn't masked
        int tbin{SiHelper::GetTimeBin((*i_chargedDiode).second)};
        // create new SCT RDO
        InDetDD::SiReadoutCellId roCell{(*i_chargedDiode).second.getReadoutCell()};
        int strip{roCell.strip()};
        const InDetDD::SCT_ModuleSideDesign& sctDesign{static_cast<const InDetDD::SCT_ModuleSideDesign&>(collection->design())};
        int row2D{sctDesign.row(strip)};
        Identifier id_readout;
        if (row2D < 0) { // SCT sensors
          id_readout = m_detID->strip_id(collection->identify(), strip);
        } else { // Upgrade sensors
          int strip2D{sctDesign.strip(strip)};
          id_readout = m_detID->strip_id(collection->identify(), row2D, strip2D);
        }
                
        // build word (compatible with
        // StripRawDataByteStreamCnv/src/StripRodDecoder.cxx)
        int size{SiHelper::GetStripNum((*i_chargedDiode).second)};
        int groupSize{size};
 
        // TC. Need to check if there are disabled strips in the cluster
        int cluscounter{0};
        if (size > 1) {
          SiChargedDiode* diode{i_chargedDiode->second.nextInCluster()};
          while (diode) {//check if there is a further strip in the cluster
            ++cluscounter;
            if (cluscounter >= size) {
              ATH_MSG_WARNING("Cluster size reached while neighbouring strips still defined.");
              break;
            }
            if (diode->flag() & 0xDE) {//see if it is disabled/below threshold/disconnected/etc (0xDE corresponds to BT_SET | DISABLED_SET | BADTOT_SET | DISCONNECTED_SET | MASKOFF_SET)
              int tmp{cluscounter};
              while ((cluscounter < size - 1) and (diode->flag() & 0xDE)) { //check its not the end and still disabled
                diode = diode->nextInCluster();
                cluscounter++;
              }
              if (diode and !(diode->flag() & 0xDE)) {
                SiHelper::ClusterUsed(*diode, false);
                SiHelper::SetStripNum(*diode, size - cluscounter, &msg());
              }
              groupSize = tmp;
              break;
            }
            diode = diode->nextInCluster();
          }
        }
 
        int stripIn11bits{strip & 0x7ff};
        if (stripIn11bits != strip) {
          ATH_MSG_DEBUG("Strip number " << strip << " doesn't fit into 11 bits - will be truncated");
        }
                
        unsigned int StripWord{static_cast<unsigned int>(groupSize | (stripIn11bits << 11) | (tbin << 22) | (ERRORS << 25))};
        SCT3_RawData *p_rdo{new SCT3_RawData(id_readout, StripWord, &dummyvector)};
        if (p_rdo) {
          p_rdocoll->push_back(p_rdo);
        }
      }
    }
  }
  return p_rdocoll;
} // StripDigitization::createRDO()

digitizeAllHits()

void ITk::StripDigitizationTool::digitizeAllHits ( const EventContext & ctx, SG::WriteHandle< SCT_RDO_Container > * rdoContainer, SG::WriteHandle< InDetSimDataCollection > * simDataCollMap, std::vector< bool > * processedElements, TimedHitCollection< SiHit > * thpcsi, CLHEP::HepRandomEngine * rndmEngine )

private

digitize all hits

Definition at line 298 of file StripDigitizationTool.cxx.

                                                                                                                                                                                                                                                                                    {
  //
  // In order to process all element rather than just those with hits we
  // create a vector to keep track of which elements have been processed.
  // NB. an element is an sct module
  //
  ATH_MSG_DEBUG("Digitizing hits");
  int hitcount{0}; // First, elements with hits.
 
  //map with key representing the row of strips
  SiChargedDiodeCollectionMap chargedDiodesMap;
 
  while (digitizeElement(ctx, chargedDiodesMap, thpcsi, rndmEngine)) {
    
    ATH_MSG_DEBUG("Digitizing "<<chargedDiodesMap.size()<<" Element(s)");
 
    hitcount++;  // Hitcount will be a number in the hit collection minus
    // number of hits in missing mods
    
    for (SiChargedDiodeCollectionIterator & chargedDiodesIter : chargedDiodesMap){
    
    SiChargedDiodeCollection & chargedDiodes = *chargedDiodesIter.second;
    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()) << " - "
                  << " processing hit number " << hitcount);
 
    // Have a flag to check if the module is present or not
    // Generally assume it is:
 
    IdentifierHash idHash{chargedDiodes.identifyHash()};
 
    assert(idHash < processedElements->size());
    (*processedElements)[idHash] = true;
 
    // create and store RDO and SDO
 
    if (not chargedDiodes.empty()) {
      StatusCode sc{createAndStoreRDO(&chargedDiodes, rdoContainer)};
      if (sc.isSuccess()) { // error msg is given inside
        // createAndStoreRDO()
        addSDO(&chargedDiodes, simDataCollMap);
      }
    }
 
    chargedDiodes.clear();
  }
  }
  ATH_MSG_DEBUG("hits processed");
}

digitizeElement()

bool ITk::StripDigitizationTool::digitizeElement ( const EventContext & ctx, SiChargedDiodeCollectionMap & chargedDiodes, TimedHitCollection< SiHit > *& thpcsi, CLHEP::HepRandomEngine * rndmEngine )

protected

Definition at line 404 of file StripDigitizationTool.cxx.

                                                                                                                                                                                         {
  if (nullptr == thpcsi) {
    ATH_MSG_ERROR("thpcsi should not be nullptr!");
 
    return false;
  }
 
  chargedDiodesMap.clear();
 
  // get the iterator pairs for this DetEl
 
  TimedHitCollection<SiHit>::const_iterator i, e;
  if (!thpcsi->nextDetectorElement(i, e)) { // no more hits
    return false;
  }
 
  // create the identifier for the collection:
  ATH_MSG_DEBUG("create ID for the hit collection");
  const TimedHitPtr<SiHit>& firstHit{*i};
  int barrel{firstHit->getBarrelEndcap()};
  Identifier id{m_detID->wafer_id(barrel,
                                  firstHit->getLayerDisk(),
                                  firstHit->getPhiModule(),
                                  firstHit->getEtaModule(),
                                  firstHit->getSide())};
  IdentifierHash waferHash{m_detID->wafer_hash(id)};
 
  // Get StripDetectorElementCollection
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> stripDetEle(m_stripDetEleCollKey, ctx);
  const InDetDD::SiDetectorElementCollection* elements(stripDetEle.retrieve());
  if (elements==nullptr) {
    ATH_MSG_FATAL(m_stripDetEleCollKey.fullKey() << " could not be retrieved");
    return false;
  }
 
  // get the det element from the manager
  const InDetDD::SiDetectorElement* sielement{elements->getDetectorElement(waferHash)};
 
  if (sielement == nullptr) {
    ATH_MSG_DEBUG("Barrel=" << barrel << " layer=" << firstHit->getLayerDisk() << " Eta=" << firstHit->getEtaModule() << " Phi=" << firstHit->getPhiModule() << " Side=" << firstHit->getSide());
    ATH_MSG_ERROR("detector manager could not find element with id = " << id);
    return false;
  }
 
 
  //Now we have to get the sub-elements if they exist!
  const InDetDD::SCT_ModuleSideDesign * thisDesign = static_cast<const InDetDD::SCT_ModuleSideDesign*>(&sielement->design());
  
  const InDetDD::SCT_ModuleSideDesign * motherDesign = thisDesign->getMother();
  
  //should become un-ordederd map
  std::map<int, const InDetDD::SCT_ModuleSideDesign *> children;
  
  if(motherDesign){
    //see above
    children = motherDesign->getChildren();
  }
  else {
    //if no mother/children relationship, just use what you got intially
    children.emplace(0,thisDesign);
  }
 
  
  for (const std::pair <const int, const InDetDD::SCT_ModuleSideDesign *> &subDesign : children){
    
    //Create the charged diodes collection.
    //We are incrementing the eta index with the number of the 
    //sub-element (child) in the returned set.
    //This "fills in" the gaps in the SiHitIdentifiers with the 
    //number of the strip row, such that the SCT_ID is continuous
    //once we split the single simulated sensor into multiple SiDetectorElements
    Identifier id_child{m_detID->wafer_id(firstHit->getBarrelEndcap(), firstHit->getLayerDisk(),
                        firstHit->getPhiModule(), firstHit->getEtaModule()+subDesign.first,
                      firstHit->getSide())};
    
    IdentifierHash hash_child = m_detID->wafer_hash(id_child);
    
    const InDetDD::SiDetectorElement* sielement_child{elements->getDetectorElement(hash_child)};
 
    if(sielement_child){
      
      std::unique_ptr<SiChargedDiodeCollection> thisChargedDiode(std::make_unique<SiChargedDiodeCollection>()); 
      int i_index = subDesign.first;
      thisChargedDiode->setDetectorElement(sielement_child);
      chargedDiodesMap.insert({i_index,std::move(thisChargedDiode)});
 
    }
    
    else ATH_MSG_ERROR("detector manager could not find element with id = "<<id_child<<" Barrel=" << firstHit->getBarrelEndcap() << " layer=" <<
               firstHit->getLayerDisk() << " Eta=" << firstHit->getEtaModule()+subDesign.first <<" Phi=" << firstHit->getPhiModule() 
               << " Side=" <<firstHit->getSide());
  }
 
 
  // Loop over the hits and created charged diodes:
  while (i != e) {
    const TimedHitPtr<SiHit>& phit{*i++};
 
    // skip hits which are more than 10us away
    if (std::abs(phit->meanTime()) < 10000. * CLHEP::ns) {
      ATH_MSG_DEBUG("HASH = " << m_detID->wafer_hash(m_detID->wafer_id(phit->getBarrelEndcap(),
                                                                       phit->getLayerDisk(),
                                                                       phit->getPhiModule(),
                                                                       phit->getEtaModule(),
                                                                       phit->getSide())));
      ATH_MSG_DEBUG("calling process() for all methods");
 
      if(!motherDesign) {
    //no row splitting
    //should only be one diode collection here, so just use it
    if(chargedDiodesMap.size()>1) {
      ATH_MSG_WARNING("More DiodesCollections("<<chargedDiodesMap.size()<<") than expected (1). Please check your configuration!");
    }
 
        SiDigitizationSurfaceChargeInserter inserter(sielement,chargedDiodesMap[0].get());
    m_sct_SurfaceChargesGenerator->process(sielement, phit, inserter, rndmEngine, ctx);
      }
      
      else{
    //with row splitting
        MultiElementChargeInserter inserter(chargedDiodesMap,motherDesign);
    m_sct_SurfaceChargesGenerator->process(sielement, phit,inserter, rndmEngine, ctx);
      }
 
      ATH_MSG_DEBUG("charges filled!");
    }
  }
  
  //Now loop over set of diodes and apply processors
  for (SiChargedDiodeCollectionIterator & theDiode : chargedDiodesMap){
    if(theDiode.second) applyProcessorTools(theDiode.second.get(), rndmEngine); // !< Use of the new AlgTool surface
  }
  // charges generator class
  return true;
}

digitizeNonHits()

void ITk::StripDigitizationTool::digitizeNonHits ( const EventContext & ctx, SG::WriteHandle< SCT_RDO_Container > * rdoContainer, SG::WriteHandle< InDetSimDataCollection > * simDataCollMap, const std::vector< bool > * processedElements, CLHEP::HepRandomEngine * rndmEngine ) const

private

digitize SCT without hits

Definition at line 356 of file StripDigitizationTool.cxx.

                                                                                                                                                                                                                                                             {
  // Get StripDetectorElementCollection
  SG::ReadCondHandle<InDetDD::SiDetectorElementCollection> stripDetEle(m_stripDetEleCollKey, ctx);
  const InDetDD::SiDetectorElementCollection* elements{stripDetEle.retrieve()};
  if (elements==nullptr) {
    ATH_MSG_FATAL(m_stripDetEleCollKey.fullKey() << " could not be retrieved");
    return;
  }
 
  ATH_MSG_DEBUG("processing elements without hits");
  SiChargedDiodeCollection chargedDiodes;
 
  for (unsigned int i{0}; i < processedElements->size(); i++) {
    if (not (*processedElements)[i]) {
      IdentifierHash idHash{i};
      if (not idHash.is_valid()) {
        ATH_MSG_ERROR("SCT Detector 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("calling applyProcessorTools() for NON hits");
        applyProcessorTools(&chargedDiodes, rndmEngine);
 
        // Create and store RDO and SDO
        // Don't create empty ones.
        if (not chargedDiodes.empty()) {
          StatusCode sc{createAndStoreRDO(&chargedDiodes, rdoContainer)};
          if (sc.isSuccess()) {// error msg is given inside
            // createAndStoreRDO()
            addSDO(&chargedDiodes, simDataCollMap);
          }
        }
 
        chargedDiodes.clear();
      }
    }
  }
 
  }

getNextEvent()

StatusCode ITk::StripDigitizationTool::getNextEvent ( const EventContext & ctx )

private

Definition at line 815 of file StripDigitizationTool.cxx.

                                                                      {
  ATH_MSG_DEBUG("StripDigitizationTool::getNextEvent");
  //  get the container(s)
  using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
  // this is a list<pair<time_t, DataLink<SiHitCollection> >
 
  // 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 SCT SiHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
      return StatusCode::FAILURE;
    }
 
    // create a new hits collection
    m_thpcsi = std::make_unique<TimedHitCollection<SiHit>>(1);
    m_thpcsi->insert(0, hitCollection.cptr());
    ATH_MSG_DEBUG("SiHitCollection found with " << hitCollection->size() << " hits");
 
    return StatusCode::SUCCESS;
  }
 
  TimedHitCollList hitCollList;
  unsigned int numberOfSiHits{0};
  if (not (m_mergeSvc->retrieveSubEvtsData(m_inputObjectName, hitCollList, numberOfSiHits).isSuccess()) and hitCollList.empty()) {
    ATH_MSG_ERROR("Could not fill TimedHitCollList");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG(hitCollList.size() << " SiHitCollections with key " << m_inputObjectName << " found");
  }
  // create a new hits collection
  m_thpcsi = std::make_unique<TimedHitCollection<SiHit>>(numberOfSiHits);
  // now merge all collections into one
  TimedHitCollList::iterator endColl{hitCollList.end()};
  for (TimedHitCollList::iterator iColl{hitCollList.begin()}; iColl != endColl; ++iColl) {
    // decide if this event will be processed depending on
    // HardScatterSplittingMode & bunchXing
    if (m_HardScatterSplittingMode == 2 and (not m_HardScatterSplittingSkipper)) {
      m_HardScatterSplittingSkipper = true;
      continue;
    }
    if (m_HardScatterSplittingMode == 1 and m_HardScatterSplittingSkipper) {
      continue;
    }
    if (m_HardScatterSplittingMode == 1 and (not m_HardScatterSplittingSkipper)) {
      m_HardScatterSplittingSkipper = true;
    }
    const SiHitCollection* p_collection{iColl->second};
    m_thpcsi->insert(iColl->first, p_collection);
    ATH_MSG_DEBUG("SiTrackerHitCollection found with " << p_collection->size() << " hits"); // loop on the hit collections
  }
  return StatusCode::SUCCESS;
}

initDisabledCells()

StatusCode ITk::StripDigitizationTool::initDisabledCells ( )

private

Initialize the StripRandomDisabledCellGenerator AlgTool.

Definition at line 210 of file StripDigitizationTool.cxx.

                                                    {
  // +++ Retrieve the StripRandomDisabledCellGenerator
  ATH_CHECK(m_sct_RandomDisabledCellGenerator.retrieve());
 
  storeTool(&(*m_sct_RandomDisabledCellGenerator));
 
  ATH_MSG_INFO("Retrieved the StripRandomDisabledCellGenerator tool:" << m_sct_RandomDisabledCellGenerator);
  return StatusCode::SUCCESS;
}

initFrontEndTool()

StatusCode ITk::StripDigitizationTool::initFrontEndTool ( )

private

Initialize the StripFrontEnd AlgTool.

Definition at line 182 of file StripDigitizationTool.cxx.

                                                   {
  ATH_CHECK(m_sct_FrontEnd.retrieve());
 
  storeTool(&(*m_sct_FrontEnd));
 
  ATH_MSG_DEBUG("Retrieved and initialised tool " << m_sct_FrontEnd);
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ITk::StripDigitizationTool::initialize ( )

finaloverridevirtual

Definition at line 57 of file StripDigitizationTool.cxx.

                                             {
  ATH_MSG_DEBUG("StripDigitizationTool::initialize()");
 
  // +++ Init the services
  ATH_CHECK(initServices());
 
  // +++ Get the Surface Charges Generator tool
  ATH_CHECK(initSurfaceChargesGeneratorTool());
 
  // +++ Get the Front End tool
  ATH_CHECK(initFrontEndTool());
 
  // +++ Initialise for disabled cells from the random disabled cells tool
  // +++ Default off, since disabled cells taken form configuration in
  // reconstruction stage
  if (m_randomDisabledCells) {
    ATH_CHECK(initDisabledCells());
    ATH_MSG_INFO("Use of Random disabled cells");
  } else {
    m_sct_RandomDisabledCellGenerator.disable();
  }
 
  // 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 << "'");
 
  // Initialize ReadHandleKey
  ATH_CHECK(m_hitsContainerKey.initialize(true));
 
  // +++ Initialize WriteHandleKey
  ATH_CHECK(m_rdoContainerKey.initialize());
  ATH_CHECK(m_simDataCollMapKey.initialize());
 
  // Initialize ReadCondHandleKey
  ATH_CHECK(m_stripDetEleCollKey.initialize());
 
  ATH_MSG_DEBUG("SiDigitizationTool::initialize() complete");
 
  return StatusCode::SUCCESS;
}

initServices()

StatusCode ITk::StripDigitizationTool::initServices ( )

private

initialize the required services

Definition at line 194 of file StripDigitizationTool.cxx.

                                               {
  // Get SCT ID helper for hash function and Store them using methods from the
  // SiDigitization.
  ATH_CHECK(detStore()->retrieve(m_detID, "SCT_ID"));
 
  if (m_onlyUseContainerName) {
    ATH_CHECK(m_mergeSvc.retrieve());
  }
  ATH_CHECK(m_rndmSvc.retrieve());
 
  return StatusCode::SUCCESS;
}

initSurfaceChargesGeneratorTool()

StatusCode ITk::StripDigitizationTool::initSurfaceChargesGeneratorTool ( )

private

Initialize the StripSurfaceChargesGenerator AlgTool.

Definition at line 166 of file StripDigitizationTool.cxx.

                                                                  {
  ATH_CHECK(m_sct_SurfaceChargesGenerator.retrieve());
 
  if (m_cosmicsRun and m_tfix > -998) {
    m_sct_SurfaceChargesGenerator->setFixedTime(m_tfix);
    ATH_MSG_INFO("Use of FixedTime = " << m_tfix << " in cosmics");
  }
 
  ATH_MSG_DEBUG("Retrieved and initialised tool " << m_sct_SurfaceChargesGenerator);
 
  return StatusCode::SUCCESS;
}

interfaceID()

const InterfaceID & ITk::StripDigitizationTool::interfaceID ( )

inlinestatic

Definition at line 161 of file StripDigitizationTool.h.

                                                             {
  return IID_IStripDigitizationTool;
}

mergeEvent()

StatusCode ITk::StripDigitizationTool::mergeEvent ( const EventContext & ctx )

finaloverridevirtual

Definition at line 274 of file StripDigitizationTool.cxx.

                                                                    {
  ATH_MSG_VERBOSE("StripDigitizationTool::mergeEvent()");
 
  // 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);
 
  if (m_enableHits) {
    digitizeAllHits(ctx, &m_rdoContainer, &m_simDataCollMap, &m_processedElements, m_thpcsi.get(), rndmEngine);
  }
 
  if (not m_onlyHitElements) {
    digitizeNonHits(ctx, &m_rdoContainer, &m_simDataCollMap, &m_processedElements, rndmEngine);
  }
 
  m_hitCollPtrs.clear();
 
  m_thpcsi.reset(nullptr);
 
  ATH_MSG_DEBUG("Digitize success!");
  return StatusCode::SUCCESS;
}

prepareEvent()

StatusCode ITk::StripDigitizationTool::prepareEvent ( const EventContext & ctx, unsigned int  )

finaloverridevirtual

Called before processing physics events.

Definition at line 252 of file StripDigitizationTool.cxx.

                                                                                      {
  ATH_MSG_VERBOSE("StripDigitizationTool::prepareEvent()");
  // Create the IdentifiableContainer to contain the digit collections Create
  // a new RDO container
  m_rdoContainer = SG::makeHandle(m_rdoContainerKey, ctx);
  ATH_CHECK(m_rdoContainer.record(std::make_unique<SCT_RDO_Container>(m_detID->wafer_hash_max())));
 
  // Create a map for the SDO and register it into StoreGate
  m_simDataCollMap = SG::makeHandle(m_simDataCollMapKey, ctx);
  ATH_CHECK(m_simDataCollMap.record(std::make_unique<InDetSimDataCollection>()));
 
  m_processedElements.clear();
  m_processedElements.resize(m_detID->wafer_hash_max(), false);
 
  m_thpcsi = std::make_unique<TimedHitCollection<SiHit>>();
  m_HardScatterSplittingSkipper = false;
  return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode ITk::StripDigitizationTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

Definition at line 220 of file StripDigitizationTool.cxx.

                                                                             {
  if (prepareEvent(ctx, 0).isFailure()) {
    return StatusCode::FAILURE;
  }
  // 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);
 
  ATH_MSG_VERBOSE("Begin digitizeAllHits");
  if (m_enableHits and (not getNextEvent(ctx).isFailure())) {
    digitizeAllHits(ctx, &m_rdoContainer, &m_simDataCollMap, &m_processedElements, m_thpcsi.get(), rndmEngine);
  } else {
    ATH_MSG_DEBUG("no hits found in event!");
  }
  ATH_MSG_DEBUG("Digitized Elements with Hits");
 
  // loop over elements without hits
  if (not m_onlyHitElements) {
    digitizeNonHits(ctx, &m_rdoContainer, &m_simDataCollMap, &m_processedElements, rndmEngine);
    ATH_MSG_DEBUG("Digitized Elements without Hits");
  }
 
  m_thpcsi.reset(nullptr);
 
  ATH_MSG_VERBOSE("Digitize success!");
  return StatusCode::SUCCESS;
}

processBunchXing()

StatusCode ITk::StripDigitizationTool::processBunchXing ( int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents )

finaloverridevirtual

Definition at line 555 of file StripDigitizationTool.cxx.

                                                                               {
    ATH_MSG_VERBOSE("StripDigitizationTool::processBunchXing() " << bunchXing);
    // decide if this event will be processed depending on
    // HardScatterSplittingMode & bunchXing
    if (m_HardScatterSplittingMode == 2 and (not m_HardScatterSplittingSkipper)) {
        m_HardScatterSplittingSkipper = true;
        return StatusCode::SUCCESS;
    }
    if (m_HardScatterSplittingMode == 1 and m_HardScatterSplittingSkipper) {
        return StatusCode::SUCCESS;
    }
    if (m_HardScatterSplittingMode == 1 and (not m_HardScatterSplittingSkipper)) {
        m_HardScatterSplittingSkipper = true;
    }
 
    using TimedHitCollList = PileUpMergeSvc::TimedList<SiHitCollection>::type;
    TimedHitCollList hitCollList;
 
    if ((not (m_mergeSvc->retrieveSubSetEvtData(m_inputObjectName, hitCollList, bunchXing,
                                                bSubEvents, eSubEvents).isSuccess())) and
        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 endColl{hitCollList.end()};
    for (TimedHitCollList::iterator iColl{hitCollList.begin()}; iColl != endColl; ++iColl) {
      std::unique_ptr<SiHitCollection> hitCollPtr{std::make_unique<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());
      m_thpcsi->insert(timeIndex, hitCollPtr.get());
      m_hitCollPtrs.push_back(std::move(hitCollPtr));
    }
 
    return StatusCode::SUCCESS;
 
}

SetupRdoOutputType()

void ITk::StripDigitizationTool::SetupRdoOutputType ( Gaudi::Details::PropertyBase & )

private

Called when m_WriteSCT1_RawData is altered.

Does nothing, but required by Gaudi.

Definition at line 605 of file StripDigitizationTool.cxx.

                                                                         {
}

storeTool()

void ITk::StripDigitizationTool::storeTool ( ISiChargedDiodesProcessorTool * p_processor )

inlineprotected

Definition at line 84 of file StripDigitizationTool.h.

{m_diodeCollectionTools.push_back(p_processor);}

Member Data Documentation

m_barrelonly

BooleanProperty ITk::StripDigitizationTool::m_barrelonly {this, "BarrelOnly", false, "Only Barrel layers"}

private

Definition at line 130 of file StripDigitizationTool.h.

{this, "BarrelOnly", false, "Only Barrel layers"};

m_cosmicsRun

BooleanProperty ITk::StripDigitizationTool::m_cosmicsRun {this, "CosmicsRun", false, "Cosmics run selection"}

private

Definition at line 129 of file StripDigitizationTool.h.

{this, "CosmicsRun", false, "Cosmics run selection"};

m_createNoiseSDO

BooleanProperty ITk::StripDigitizationTool::m_createNoiseSDO {this, "CreateNoiseSDO", false, "Create SDOs for strips with only noise hits (huge increase in SDO collection size"}

private

Definition at line 132 of file StripDigitizationTool.h.

{this, "CreateNoiseSDO", false, "Create SDOs for strips with only noise hits (huge increase in SDO collection size"};

m_detID

const SCT_ID* ITk::StripDigitizationTool::m_detID {nullptr}

private

Handle to the ID helper.

Definition at line 152 of file StripDigitizationTool.h.

{nullptr}; 

m_diodeCollectionTools

std::vector<ISiChargedDiodesProcessorTool*> ITk::StripDigitizationTool::m_diodeCollectionTools

private

Definition at line 154 of file StripDigitizationTool.h.

m_enableHits

BooleanProperty ITk::StripDigitizationTool::m_enableHits {this, "EnableHits", true, "Enable hits"}

private

Definition at line 127 of file StripDigitizationTool.h.

{this, "EnableHits", true, "Enable hits"};

m_HardScatterSplittingMode

IntegerProperty ITk::StripDigitizationTool::m_HardScatterSplittingMode {this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting. Process all SiHit or just those from signal or background events"}

private

Definition at line 133 of file StripDigitizationTool.h.

{this, "HardScatterSplittingMode", 0, "Control pileup & signal splitting. Process all SiHit or just those from signal or background events"};

m_HardScatterSplittingSkipper

bool ITk::StripDigitizationTool::m_HardScatterSplittingSkipper {false}

private

Definition at line 157 of file StripDigitizationTool.h.

{false};

m_hitCollPtrs

std::vector<std::unique_ptr<SiHitCollection> > ITk::StripDigitizationTool::m_hitCollPtrs

private

Definition at line 156 of file StripDigitizationTool.h.

m_hitsContainerKey

SG::ReadHandleKey<SiHitCollection> ITk::StripDigitizationTool::m_hitsContainerKey {this, "InputObjectName", "StripHits", "Input HITS collection name"}

private

Definition at line 137 of file StripDigitizationTool.h.

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

m_inputObjectName

std::string ITk::StripDigitizationTool::m_inputObjectName {""}

private

Definition at line 138 of file StripDigitizationTool.h.

{""};

m_mergeSvc

ServiceHandle<PileUpMergeSvc> ITk::StripDigitizationTool::m_mergeSvc {this, "MergeSvc", "PileUpMergeSvc", "Merge service used in Pixel & SCT digitization"}

private

Definition at line 150 of file StripDigitizationTool.h.

{this, "MergeSvc", "PileUpMergeSvc", "Merge service used in Pixel & SCT digitization"}; 

m_onlyHitElements

BooleanProperty ITk::StripDigitizationTool::m_onlyHitElements {this, "OnlyHitElements", false, "Process only elements with hits"}

private

Definition at line 128 of file StripDigitizationTool.h.

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

m_onlyUseContainerName

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

private

Definition at line 136 of file StripDigitizationTool.h.

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

m_processedElements

std::vector<bool> ITk::StripDigitizationTool::m_processedElements

private

vector of processed elements - set by digitizeHits() *‍/

Definition at line 155 of file StripDigitizationTool.h.

m_randomDisabledCells

BooleanProperty ITk::StripDigitizationTool::m_randomDisabledCells {this, "RandomDisabledCells", false, "Use Random disabled cells, default no"}

private

Definition at line 131 of file StripDigitizationTool.h.

{this, "RandomDisabledCells", false, "Use Random disabled cells, default no"};

m_rdoContainer

SG::WriteHandle<SCT_RDO_Container> ITk::StripDigitizationTool::m_rdoContainer

private

RDO container handle.

Definition at line 141 of file StripDigitizationTool.h.

m_rdoContainerKey

SG::WriteHandleKey<SCT_RDO_Container> ITk::StripDigitizationTool::m_rdoContainerKey {this, "OutputObjectName", "SCT_RDOs", "Output Object name"}

private

Definition at line 140 of file StripDigitizationTool.h.

{this, "OutputObjectName", "SCT_RDOs", "Output Object name"};

m_rndmSvc

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

private

Random number service.

Definition at line 149 of file StripDigitizationTool.h.

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

m_sct_FrontEnd

ToolHandle<IFrontEnd> ITk::StripDigitizationTool::m_sct_FrontEnd {this, "FrontEnd", "StripFrontEnd", "Handle the Front End Electronic tool"}

private

Definition at line 146 of file StripDigitizationTool.h.

{this, "FrontEnd", "StripFrontEnd", "Handle the Front End Electronic tool"};

m_sct_RandomDisabledCellGenerator

ToolHandle<IRandomDisabledCellGenerator> ITk::StripDigitizationTool::m_sct_RandomDisabledCellGenerator {this, "RandomDisabledCellGenerator", "StripRandomDisabledCellGenerator", ""}

private

Definition at line 148 of file StripDigitizationTool.h.

{this, "RandomDisabledCellGenerator", "StripRandomDisabledCellGenerator", ""};

m_sct_SurfaceChargesGenerator

ToolHandle<ISurfaceChargesGenerator> ITk::StripDigitizationTool::m_sct_SurfaceChargesGenerator {this, "SurfaceChargesGenerator", "StripSurfaceChargesGenerator", "Choice of using a more detailed charge drift model"}

private

Definition at line 147 of file StripDigitizationTool.h.

{this, "SurfaceChargesGenerator", "StripSurfaceChargesGenerator", "Choice of using a more detailed charge drift model"};

m_simDataCollMap

SG::WriteHandle<InDetSimDataCollection> ITk::StripDigitizationTool::m_simDataCollMap

private

SDO Map handle.

Definition at line 143 of file StripDigitizationTool.h.

m_simDataCollMapKey

SG::WriteHandleKey<InDetSimDataCollection> ITk::StripDigitizationTool::m_simDataCollMapKey {this, "OutputSDOName", "StripSDO_Map", "Output SDO container name"}

private

Definition at line 142 of file StripDigitizationTool.h.

{this, "OutputSDOName", "StripSDO_Map", "Output SDO container name"};

m_stripDetEleCollKey

SG::ReadCondHandleKey<InDetDD::SiDetectorElementCollection> ITk::StripDigitizationTool::m_stripDetEleCollKey {this, "StripDetEleCollKey", "ITkStripDetectorElementCollection", "Key of SiDetectorElementCollection for SCT"}

private

Definition at line 144 of file StripDigitizationTool.h.

{this, "StripDetEleCollKey", "ITkStripDetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};

m_tfix

FloatProperty ITk::StripDigitizationTool::m_tfix {this, "FixedTime", -999., "Fixed time for Cosmics run selection"}

private

Definition at line 126 of file StripDigitizationTool.h.

{this, "FixedTime", -999., "Fixed time for Cosmics run selection"};

m_thpcsi

std::unique_ptr<TimedHitCollection<SiHit> > ITk::StripDigitizationTool::m_thpcsi {nullptr}

private

Definition at line 153 of file StripDigitizationTool.h.

{nullptr};

m_WriteSCT1_RawData

BooleanProperty ITk::StripDigitizationTool::m_WriteSCT1_RawData {this, "WriteSCT1_RawData", false, "Write out SCT1_RawData rather than SCT3_RawData"}

private

Definition at line 134 of file StripDigitizationTool.h.

{this, "WriteSCT1_RawData", false, "Write out SCT1_RawData rather than SCT3_RawData"};

---

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

• StripDigitizationTool.h
• StripDigitizationTool.cxx