HGTD_DigitizationTool Class Reference

#include <HGTD_DigitizationTool.h>

Inheritance diagram for HGTD_DigitizationTool:

Collaboration diagram for HGTD_DigitizationTool:

Public Member Functions
	HGTD_DigitizationTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override final
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final
	alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents. More...
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int) override final
	called before the bunchXing loop More...
virtual StatusCode	processBunchXing (int bunch_xing, SubEventIterator sub_event_itr, SubEventIterator sub_event_itr_end) override final
	called for each active bunch-crossing (time in ns) More...
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
	called at the end of the bunchXing loop 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...

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Private Member Functions
StatusCode	retrieveHitCollection (const EventContext &ctx)
	Retrieve the SiHit collection and place it in a TimedHitCollection. More...
StatusCode	digitizeHitsPerDetectorElement (const EventContext &ctx, CLHEP::HepRandomEngine *rndmEngine)
void	applyProcessorTools (SiChargedDiodeCollection *, CLHEP::HepRandomEngine *rndmEngine) const
	FIXME: will be implemented once we know how much noise we expect. More...
std::unique_ptr< HGTD_RDO_Collection >	createRDOCollection (SiChargedDiodeCollection *) const
StatusCode	storeRDOCollection (std::unique_ptr< HGTD_RDO_Collection >)
void	createAndStoreSDO (SiChargedDiodeCollection *collection)

Private Attributes
FloatProperty	m_charge_threshold {this, "ChargeThreshold", 625., "Minimum charge threshold in ASIC"}
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", "HGTD_Hits", "Input HITS collection name"}
std::string	m_inputObjectName {""}
SG::WriteHandle< HGTD_RDO_Container >	m_hgtd_rdo_container
	RDO container handle. More...
SG::WriteHandleKey< HGTD_RDO_Container >	m_output_rdo_cont_key {this, "OutputObjectName", "HGTD_RDOs", "Output Object name"}
SG::WriteHandle< InDetSimDataCollection >	m_sdo_collection_map
	SDO Map handle. More...
SG::WriteHandleKey< InDetSimDataCollection >	m_output_sdo_coll_key {this, "OutputSDOName", "HGTD_SDO_Map", "Output SDO container name"}
SG::ReadCondHandleKey< InDetDD::HGTD_DetectorElementCollection >	m_HGTDDetEleCollKey {this, "HGTDDetEleCollKey", "HGTD_DetectorElementCollection", "Key of HGTD_DetectorElementCollection for HGTD"}
ServiceHandle< PileUpMergeSvc >	m_merge_svc {this, "MergeSvc", "PileUpMergeSvc", "Merge service used in Pixel & HGTD digitization"}
ServiceHandle< IAthRNGSvc >	m_rndm_svc {this, "RndmSvc", "AthRNGSvc", "Random Number Service used in HGTD & Pixel digitization"}
	Random number service. More...
std::list< ISiChargedDiodesProcessorTool * >	m_diode_processor_tools
ToolHandle< IFrontEnd >	m_hgtd_front_end_tool {this, "FrontEnd", "HGTD_FrontEndTool", "Tool for pulse shape simulation"}
ToolHandle< IHGTD_SurfaceChargesGenerator >	m_hgtd_surf_charge_gen {this, "SurfaceChargesGenerator", "HGTD_SurfaceChargesGenerator", "Choice of using a more detailed charge drift model"}
const HGTD_ID *	m_id_helper {nullptr}
	Handle to the ID helper. More...
std::unique_ptr< TimedHitCollection< SiHit > >	m_timed_hit_coll {nullptr}
std::vector< bool >	m_processed_elements
	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. More...
std::vector< std::unique_ptr< SiHitCollection > >	m_hit_coll_ptrs {}

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 48 of file HGTD_DigitizationTool.h.

Constructor & Destructor Documentation

HGTD_DigitizationTool()

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

Definition at line 22 of file HGTD_DigitizationTool.cxx.

    : PileUpToolBase(type, name, parent) {
}

Member Function Documentation

applyProcessorTools()

void HGTD_DigitizationTool::applyProcessorTools ( SiChargedDiodeCollection *  charged_diodes, CLHEP::HepRandomEngine *  rndmEngine  ) const

private

FIXME: will be implemented once we know how much noise we expect.

Step by step processor tools applied on diodes. These should simulate: Preamplifier -> Discriminator -> TDC. Is called within digitizeHitsPerDetectorElement.

Used tools: FrontEndTool, which calls the Amplifier inside

Definition at line 302 of file HGTD_DigitizationTool.cxx.

                                            {
  ATH_MSG_DEBUG("applyProcessorTools()");
  int processorNumber = 0;
 
  // std::list<ISiChargedDiodesProcessorTool *>::iterator provessor_itr =
  //     m_diode_processor_tools.begin();
  // for (; provessor_itr != m_diode_processor_tools.end(); ++provessor_itr) {
  //   (*provessor_itr)->process(*charged_diodes, rndmEngine);
 
  //   processorNumber++;
  //   ATH_MSG_DEBUG("Applied processor # " << processorNumber);
  // }
  for (ISiChargedDiodesProcessorTool* proc: m_diode_processor_tools) {
    proc->process(*charged_diodes, rndmEngine);
 
    processorNumber++;
    ATH_MSG_DEBUG("Applied processor # " << processorNumber);
  }
  return;
}

createAndStoreSDO()

void HGTD_DigitizationTool::createAndStoreSDO ( SiChargedDiodeCollection *  collection )

private

Definition at line 399 of file HGTD_DigitizationTool.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 i_chargedDiode = charged_diodes->begin();
  SiChargedDiodeIterator i_chargedDiode_end = charged_diodes->end();
 
  for (; i_chargedDiode != i_chargedDiode_end; ++i_chargedDiode) {
    deposits.clear();
    const list_t &charges =
        (*i_chargedDiode).second.totalCharge().chargeComposition();
 
    bool real_particle_hit = false;
 
    // loop over the list of elements inside the charged diode
    list_t::const_iterator charge_list_itr_end = charges.end();
    list_t::const_iterator charge_list_itr = charges.begin();
 
    for (; charge_list_itr != charge_list_itr_end; ++charge_list_itr) {
 
      const HepMcParticleLink &trkLink = charge_list_itr->particleLink();
      const int barcode = HepMC::barcode(trkLink);
      if (HepMC::ignoreTruthLink(barcode, m_vetoPileUpTruthLinks)) {
        continue;
      }
      if (!real_particle_hit) {
        // Types of SiCharges expected from HGTD
        // Noise:                        barcode==0 &&
        // processType()==SiCharge::noise
        // Delta Rays:                   barcode==0 &&
        // processType()==SiCharge::track
        // Pile Up Tracks With No Truth: barcode!=0 &&
        // processType()==SiCharge::cut_track
        // Tracks With Truth:            barcode!=0 &&
        // processType()==SiCharge::track
        if (!HepMC::no_truth_link(barcode) && charge_list_itr->processType() == SiCharge::track) {
          real_particle_hit = true;
        }
        // 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;
        }
      }
 
      // Diode has already a hit, check which one that arrived first.
      if (theDeposit != depositsR_end) {
        if((*theDeposit).second > charge_list_itr->time()){
          (*theDeposit).first = trkLink;
          (*theDeposit).second = charge_list_itr->time();
        }
      } else { // create a new deposit with the track lick and the ToA
        deposits.emplace_back(trkLink, charge_list_itr->time());
      }
    } // END LOOP charges within diode
 
    // add the simdata object to the map if the deposit originated from a
    // particle to which the truth information was kept. Can be HS and PU.
    if (real_particle_hit) {
 
      InDetDD::SiReadoutCellId readout_cell =
          (*i_chargedDiode).second.getReadoutCell();
      int eta_index = readout_cell.etaIndex();
      int phi_index = readout_cell.phiIndex();
      const Identifier id_readout = m_id_helper->pixel_id(
          charged_diodes->identify(), phi_index, eta_index);
 
      m_sdo_collection_map->try_emplace(id_readout, std::move(deposits), (*i_chargedDiode).second.flag());
    }
  } // END LOOP charged diodes
}

createRDOCollection()

std::unique_ptr< HGTD_RDO_Collection > HGTD_DigitizationTool::createRDOCollection ( SiChargedDiodeCollection *  charged_diodes ) const

private

Definition at line 337 of file HGTD_DigitizationTool.cxx.

                                                    {
 
  IdentifierHash idHash_de = charged_diodes->identifyHash();
 
  std::unique_ptr<HGTD_RDO_Collection> rdo_collection =
      std::make_unique<HGTD_RDO_Collection>(idHash_de);
 
  // need the DE identifier
  const Identifier id_de = charged_diodes->identify();
  rdo_collection->setIdentifier(id_de);
 
  SiChargedDiodeIterator i_chargedDiode = charged_diodes->begin();
  SiChargedDiodeIterator i_chargedDiode_end = charged_diodes->end();
 
  for (; i_chargedDiode != i_chargedDiode_end; ++i_chargedDiode) {
 
    // skip deposits below the charge threshold of ~2fC after amplif.
    // the charge here is the purely deposited charge, so factor ~20 less
    // FIXME: gain radiation dependent, compensated with higher bias voltage
    // more precise modelling in the future
    SiChargedDiode& diode = (*i_chargedDiode).second;
    if (diode.totalCharge().charge() < m_charge_threshold) {
      ATH_MSG_DEBUG("charge of " << diode.totalCharge().charge()
                                 << " does not pass threshold of "
                                 << m_charge_threshold);
      continue;
    }
 
    InDetDD::SiReadoutCellId readout_cell =
        (*i_chargedDiode).second.getReadoutCell();
    int eta_index = readout_cell.etaIndex();
    int phi_index = readout_cell.phiIndex();
 
    ATH_MSG_DEBUG("readout_cell ID: " << readout_cell << " eta:" << eta_index
                                      << " phi:" << phi_index);
 
    // FIXME the method takes ID, phi, eta
    // FIXME switching order here to fix upstream issue with orientations
    const Identifier id_readout =
        m_id_helper->pixel_id(charged_diodes->identify(), phi_index, eta_index);
 
    const SiTotalCharge& charge = diode.totalCharge();
 
    // this is the time of the main charge. For now this might be OK as long as
    // the toal deposit just gets transformed into "one charge", but will need a
    // change in the future!!
    float toa = charge.time();
 
    unsigned int dummy_tot = 256;
    unsigned short dummy_bcid = 0;
    unsigned short dummy_l1a = 0;
    unsigned short dummy_l1id = 0;
 
    std::unique_ptr<HGTD_RDO> p_rdo = std::make_unique<HGTD_RDO>(
        id_readout, toa, dummy_tot, dummy_bcid, dummy_l1a, dummy_l1id);
 
    rdo_collection->push_back(p_rdo.release());
  }
  return rdo_collection;
}

DeclareInterfaceID()

IPileUpTool::DeclareInterfaceID ( IPileUpTool  , 1  , 0    )

inherited

Creates the InterfaceID and interfaceID() method.

digitizeHitsPerDetectorElement()

StatusCode HGTD_DigitizationTool::digitizeHitsPerDetectorElement ( const EventContext &  ctx, CLHEP::HepRandomEngine *  rndmEngine  )

private

Definition at line 231 of file HGTD_DigitizationTool.cxx.

                                                                                                                          {
  ATH_MSG_DEBUG("HGTD_DigitizationTool::digitizeHitsPerDetectorElement");
 
  // Get HGTD_DetectorElementCollection
  SG::ReadCondHandle<InDetDD::HGTD_DetectorElementCollection> hgtdDetEleColl(m_HGTDDetEleCollKey, ctx);
  const InDetDD::HGTD_DetectorElementCollection* elements(hgtdDetEleColl.retrieve());
  if (elements==nullptr) {
    ATH_MSG_FATAL(m_HGTDDetEleCollKey.fullKey() << " could not be retrieved");
    return StatusCode::FAILURE;
  }
 
  // the iterators mark the start and end of si hits that belong to one
  // collection which means that they were found on the same detector element
  // (module)
  TimedHitCollection<SiHit>::const_iterator coll_itr;
  TimedHitCollection<SiHit>::const_iterator coll_itr_end;
 
  // the nextDetectorElement method sets the iterators to a range belonging to
  // one module, so we iterate over modules (detector elements) in the while
  // loop
  while (m_timed_hit_coll->nextDetectorElement(coll_itr, coll_itr_end)) {
 
    const TimedHitPtr<SiHit> &fist_hit = *coll_itr;
 
    Identifier id = m_id_helper->wafer_id(
        fist_hit->getBarrelEndcap(), fist_hit->getLayerDisk(),
        fist_hit->getPhiModule(), fist_hit->getEtaModule());
    IdentifierHash waferHash{m_id_helper->wafer_hash(id)};
 
    // get the det element from the manager
    const InDetDD::HGTD_DetectorElement *det_elem = elements->getDetectorElement(waferHash);
    // FIXME check for null??
    // create a diode collection holding the digitized hits
    // FIXME (init once outside the while loop and use clear and set det elem??)
    std::unique_ptr<SiChargedDiodeCollection> charged_diode_coll =
        std::make_unique<SiChargedDiodeCollection>(det_elem);
 
    // Loop over the hits on the selected detector element and created charged
    // diodes
    for (; coll_itr != coll_itr_end; ++coll_itr) {
 
      const TimedHitPtr<SiHit> &current_hit = *coll_itr;
 
      // use the surface charge generator to produce the charged diode
      // and add it to the charged diode collection
      // 
      // hits that are too far away in time to be captured by the ASICs
      // are handled internally by the surface charge generator
      // 
      m_hgtd_surf_charge_gen->createSurfaceChargesFromHit(
          current_hit, charged_diode_coll.get(), det_elem, rndmEngine, ctx);
 
    } // END LOOP over hits
    // now that the charges have been built, apply all digitization tools
    applyProcessorTools(charged_diode_coll.get(), rndmEngine);
    // at this point, the RDOs and SDOs need to be created!!!
    std::unique_ptr<HGTD_RDO_Collection> rdo_collection =
        createRDOCollection(charged_diode_coll.get());
 
    ATH_CHECK(storeRDOCollection(std::move(rdo_collection)));
 
    createAndStoreSDO(charged_diode_coll.get());
 
    ATH_MSG_DEBUG("charges filled for module " << id);
  } // END LOOP over detector elements
 
  return StatusCode::SUCCESS;
}

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

initialize()

StatusCode HGTD_DigitizationTool::initialize ( )

finaloverridevirtual

Reimplemented from PileUpToolBase.

Definition at line 28 of file HGTD_DigitizationTool.cxx.

                                             {
 
  ATH_CHECK(detStore()->retrieve(m_id_helper, "HGTD_ID"));
 
  if (m_onlyUseContainerName) {
    ATH_CHECK(m_merge_svc.retrieve());
  }
 
  ATH_CHECK(m_rndm_svc.retrieve());
 
  ATH_CHECK(m_hgtd_surf_charge_gen.retrieve());
 
  ATH_CHECK(m_hgtd_front_end_tool.retrieve());
 
  // add the front end to the set of tools used for diode processing
  m_diode_processor_tools.push_back(&(*m_hgtd_front_end_tool));
 
  // 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));
  ATH_CHECK(m_HGTDDetEleCollKey.initialize());
  ATH_CHECK(m_output_rdo_cont_key.initialize());
  ATH_CHECK(m_output_sdo_coll_key.initialize());
 
  return StatusCode::SUCCESS;
}

interfaceID()

const InterfaceID & HGTD_DigitizationTool::interfaceID ( )

inlinestatic

Definition at line 137 of file HGTD_DigitizationTool.h.

                                                             {
  return IID_IHGTD_DigitizationTool;
}

mergeEvent()

StatusCode HGTD_DigitizationTool::mergeEvent ( const EventContext &  )

finaloverridevirtual

called at the end of the bunchXing loop

Reimplemented from IPileUpTool.

Definition at line 129 of file HGTD_DigitizationTool.cxx.

                                                                    {
  ATH_MSG_VERBOSE("HGTD_DigitizationTool::mergeEvent()");
 
  // Set the RNG to use for this event.
  ATHRNG::RNGWrapper* rngWrapper = m_rndm_svc->getEngine(this);
  rngWrapper->setSeed(name(), ctx);
  CLHEP::HepRandomEngine* rndmEngine = rngWrapper->getEngine(ctx);
 
  ATH_CHECK(digitizeHitsPerDetectorElement(ctx, rndmEngine));
 
  // FIXME: needs to be added once noise/selftriggering has to go in
  // ATH_CHECK(simulateNoisePerDetectorElement());
 
  m_hit_coll_ptrs.clear();
 
  m_timed_hit_coll.reset(nullptr);
 
  ATH_MSG_DEBUG("Digitize success!");
  return StatusCode::SUCCESS;
}

prepareEvent()

StatusCode HGTD_DigitizationTool::prepareEvent ( const EventContext &  , unsigned int    )

finaloverridevirtual

called before the bunchXing loop

Reimplemented from IPileUpTool.

Definition at line 153 of file HGTD_DigitizationTool.cxx.

                                                                                      {
  ATH_MSG_DEBUG("HGTD_DigitizationTool::prepareEvent()");
  // Create the IdentifiableContainer to contain the digit collections Create
  // a new RDO container
  m_hgtd_rdo_container = SG::makeHandle(m_output_rdo_cont_key, ctx);
  ATH_CHECK(m_hgtd_rdo_container.record(std::make_unique<HGTD_RDO_Container>(m_id_helper->wafer_hash_max())));
 
  // Create a map for the SDO and register it into StoreGate
  m_sdo_collection_map = SG::makeHandle(m_output_sdo_coll_key, ctx);
  ATH_CHECK(m_sdo_collection_map.record(std::make_unique<InDetSimDataCollection>()));
 
  m_processed_elements.clear(); // FIXME not sure I need this vector??
  m_processed_elements.resize(m_id_helper->wafer_hash_max(), false);
 
  m_timed_hit_coll = std::make_unique<TimedHitCollection<SiHit>>();
 
  return StatusCode::SUCCESS;
}

processAllSubEvents() [1/2]

StatusCode HGTD_DigitizationTool::processAllSubEvents ( const EventContext &  ctx )

finaloverridevirtual

alternative interface which uses the PileUpMergeSvc to obtain all the required SubEvents.

Implements IPileUpTool.

Definition at line 62 of file HGTD_DigitizationTool.cxx.

                                                                             {
 
  ATH_MSG_DEBUG("processAllSubEvents");
 
  if (prepareEvent(ctx, 0).isFailure()) {
    return StatusCode::FAILURE;
  }
  // Set the RNG to use for this event.
  ATHRNG::RNGWrapper* rngWrapper = m_rndm_svc->getEngine(this);
  rngWrapper->setSeed(name(), ctx);
  CLHEP::HepRandomEngine* rndmEngine = rngWrapper->getEngine(ctx);
 
  ATH_MSG_DEBUG("Begin digitizeAllHits");
 
  if (retrieveHitCollection(ctx).isSuccess()) {
    ATH_CHECK(digitizeHitsPerDetectorElement(ctx, rndmEngine));
  } else {
    ATH_MSG_DEBUG("retrieveHitCollection found no hits");
  }
 
  // FIXME: needs to be added once noise/selftriggering has to go in
  // ATH_CHECK(simulateNoisePerDetectorElement());
 
  ATH_MSG_DEBUG("processAllSubEvents successful!");
  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 HGTD_DigitizationTool::processBunchXing ( int  bunchXing, SubEventIterator  bSubEvents, SubEventIterator  eSubEvents  )

finaloverridevirtual

called for each active bunch-crossing (time in ns)

Implements IPileUpTool.

Definition at line 90 of file HGTD_DigitizationTool.cxx.

                                                                            {
 
  ATH_MSG_DEBUG("HGTD_DigitizationTool::processBunchXing " << bunch_xing);
 
  // FIXME removed m_HardScatterSplittingMode and
  // m_HardScatterSplittingSkipper until we have confirmed we need this
 
  using TimedHitCollList_t = PileUpMergeSvc::TimedList<SiHitCollection>::type;
  // this is a list<pair<time_t, DataLink<SiHitCollection> >
  TimedHitCollList_t timed_hit_coll_list;
 
  if ((not (m_merge_svc->retrieveSubSetEvtData(m_inputObjectName, timed_hit_coll_list, bunch_xing,
                                               sub_event_itr, sub_event_itr_end).isSuccess())) and
      timed_hit_coll_list.size() == 0) {
    ATH_MSG_ERROR("Could not fill TimedHitCollList");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_VERBOSE(timed_hit_coll_list.size() << " SiHitCollections with key " <<
        m_inputObjectName << " found");
  }
 
  TimedHitCollList_t::iterator endColl{timed_hit_coll_list.end()};
  for (TimedHitCollList_t::iterator iColl{timed_hit_coll_list.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_timed_hit_coll->insert(timeIndex, hitCollPtr.get());
    m_hit_coll_ptrs.push_back(std::move(hitCollPtr));
  }
 
  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

retrieveHitCollection()

StatusCode HGTD_DigitizationTool::retrieveHitCollection ( const EventContext &  ctx )

private

Retrieve the SiHit collection and place it in a TimedHitCollection.

Definition at line 172 of file HGTD_DigitizationTool.cxx.

                                                                               {
  ATH_MSG_DEBUG("HGTD_DigitizationTool::retrieveHitCollection()");
 
  using TimedHitCollList_t = 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 HGTD SiHitCollection container " << hitCollection.name() << " from store " << hitCollection.store());
      return StatusCode::FAILURE;
    }
 
    // create a new hits collection
    m_timed_hit_coll = std::make_unique<TimedHitCollection<SiHit>>(1);
    m_timed_hit_coll->insert(0, hitCollection.cptr());
    ATH_MSG_DEBUG("SiHitCollection found with " << hitCollection->size() << " hits");
 
    return StatusCode::SUCCESS;
  }
 
  TimedHitCollList_t timed_hit_coll_list;
  unsigned int n_si_hits(0);
 
  if (m_merge_svc
          ->retrieveSubEvtsData(m_inputObjectName, timed_hit_coll_list,
                                n_si_hits)
          .isFailure() and
      timed_hit_coll_list.size() == 0) { // FIXME is the size check relevant??
    ATH_MSG_ERROR("Could not fill TimedHitCollList_t");
    return StatusCode::FAILURE;
  } else {
    ATH_MSG_DEBUG(timed_hit_coll_list.size() << " SiHitCollections with key " << m_inputObjectName << " found");
  }
 
  // create a new hits collection
  m_timed_hit_coll = std::make_unique<TimedHitCollection<SiHit>>(n_si_hits);
 
  // now merge all collections into one
  TimedHitCollList_t::iterator coll_itr(timed_hit_coll_list.begin());
  TimedHitCollList_t::iterator coll_itr_end(timed_hit_coll_list.end());
 
  while (coll_itr != coll_itr_end) {
 
    // FIXME removed m_HardScatterSplittingMode and
    // m_HardScatterSplittingSkipper until we have confirmed we need this
 
    const SiHitCollection *collection(coll_itr->second);
 
    m_timed_hit_coll->insert(coll_itr->first, collection);
 
    ATH_MSG_DEBUG("SiTrackerHitCollection found with" << collection->size()
                                                      << " hits");
    ++coll_itr;
  }
  return StatusCode::SUCCESS;
}

storeRDOCollection()

StatusCode HGTD_DigitizationTool::storeRDOCollection ( std::unique_ptr< HGTD_RDO_Collection >  coll )

private

Definition at line 325 of file HGTD_DigitizationTool.cxx.

                                             {
  const IdentifierHash identifyHash{coll->identifierHash()};
  // Create the RDO collection
  if (m_hgtd_rdo_container
          ->addCollection(coll.release(), identifyHash).isFailure()) {
    ATH_MSG_FATAL("HGTD RDO collection could not be added to container!");
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

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_charge_threshold

FloatProperty HGTD_DigitizationTool::m_charge_threshold {this, "ChargeThreshold", 625., "Minimum charge threshold in ASIC"}

private

Definition at line 104 of file HGTD_DigitizationTool.h.

m_diode_processor_tools

std::list<ISiChargedDiodesProcessorTool*> HGTD_DigitizationTool::m_diode_processor_tools

private

Definition at line 118 of file HGTD_DigitizationTool.h.

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.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_hgtd_front_end_tool

ToolHandle<IFrontEnd> HGTD_DigitizationTool::m_hgtd_front_end_tool {this, "FrontEnd", "HGTD_FrontEndTool", "Tool for pulse shape simulation"}

private

Definition at line 119 of file HGTD_DigitizationTool.h.

m_hgtd_rdo_container

SG::WriteHandle<HGTD_RDO_Container> HGTD_DigitizationTool::m_hgtd_rdo_container

private

RDO container handle.

Definition at line 110 of file HGTD_DigitizationTool.h.

m_hgtd_surf_charge_gen

ToolHandle<IHGTD_SurfaceChargesGenerator> HGTD_DigitizationTool::m_hgtd_surf_charge_gen {this, "SurfaceChargesGenerator", "HGTD_SurfaceChargesGenerator", "Choice of using a more detailed charge drift model"}

private

Definition at line 120 of file HGTD_DigitizationTool.h.

m_HGTDDetEleCollKey

SG::ReadCondHandleKey<InDetDD::HGTD_DetectorElementCollection> HGTD_DigitizationTool::m_HGTDDetEleCollKey {this, "HGTDDetEleCollKey", "HGTD_DetectorElementCollection", "Key of HGTD_DetectorElementCollection for HGTD"}

private

Definition at line 114 of file HGTD_DigitizationTool.h.

m_hit_coll_ptrs

std::vector<std::unique_ptr<SiHitCollection> > HGTD_DigitizationTool::m_hit_coll_ptrs {}

private

Definition at line 133 of file HGTD_DigitizationTool.h.

m_hitsContainerKey

SG::ReadHandleKey<SiHitCollection> HGTD_DigitizationTool::m_hitsContainerKey {this, "InputObjectName", "HGTD_Hits", "Input HITS collection name"}

private

Definition at line 107 of file HGTD_DigitizationTool.h.

m_id_helper

const HGTD_ID* HGTD_DigitizationTool::m_id_helper {nullptr}

private

Handle to the ID helper.

Definition at line 122 of file HGTD_DigitizationTool.h.

m_inputObjectName

std::string HGTD_DigitizationTool::m_inputObjectName {""}

private

Definition at line 108 of file HGTD_DigitizationTool.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_merge_svc

ServiceHandle<PileUpMergeSvc> HGTD_DigitizationTool::m_merge_svc {this, "MergeSvc", "PileUpMergeSvc", "Merge service used in Pixel & HGTD digitization"}

private

Definition at line 116 of file HGTD_DigitizationTool.h.

m_onlyUseContainerName

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

private

Definition at line 106 of file HGTD_DigitizationTool.h.

m_output_rdo_cont_key

SG::WriteHandleKey<HGTD_RDO_Container> HGTD_DigitizationTool::m_output_rdo_cont_key {this, "OutputObjectName", "HGTD_RDOs", "Output Object name"}

private

Definition at line 111 of file HGTD_DigitizationTool.h.

m_output_sdo_coll_key

SG::WriteHandleKey<InDetSimDataCollection> HGTD_DigitizationTool::m_output_sdo_coll_key {this, "OutputSDOName", "HGTD_SDO_Map", "Output SDO container name"}

private

Definition at line 113 of file HGTD_DigitizationTool.h.

m_processed_elements

std::vector<bool> HGTD_DigitizationTool::m_processed_elements

private

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.

This is useful for adding random noise (?!) NB. an element is an hgtd module

Definition at line 131 of file HGTD_DigitizationTool.h.

m_rndm_svc

ServiceHandle<IAthRNGSvc> HGTD_DigitizationTool::m_rndm_svc {this, "RndmSvc", "AthRNGSvc", "Random Number Service used in HGTD & Pixel digitization"}

private

Random number service.

Definition at line 117 of file HGTD_DigitizationTool.h.

m_sdo_collection_map

SG::WriteHandle<InDetSimDataCollection> HGTD_DigitizationTool::m_sdo_collection_map

private

SDO Map handle.

Definition at line 112 of file HGTD_DigitizationTool.h.

m_timed_hit_coll

std::unique_ptr<TimedHitCollection<SiHit> > HGTD_DigitizationTool::m_timed_hit_coll {nullptr}

private

Definition at line 126 of file HGTD_DigitizationTool.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:

• HGTD_DigitizationTool.h
• HGTD_DigitizationTool.cxx