HGTD_DigitizationTool Class Reference

#include <HGTD_DigitizationTool.h>

Inheritance 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.
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int) override final
	called before the bunchXing loop
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)
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
	called at the end of the bunchXing loop
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
virtual bool	filterPassed () const =0
	flags whether the event should be removed or not
virtual void	resetFilter ()=0
	reset the filter
	DeclareInterfaceID (IPileUpTool, 1, 0)
	Creates the InterfaceID and interfaceID() method.

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.
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.
StatusCode	createAndStoreRDO (SiChargedDiodeCollection *, const InDetDD::SolidStateDetectorElementBase *)
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.
SG::WriteHandleKey< HGTD_RDO_Container >	m_output_rdo_cont_key {this, "OutputObjectName", "HGTD_RDOs", "Output Object name"}
SG::WriteHandle< HGTD_ALTIROC_RDO_Container >	m_hgtd_altiroc_rdo_container
	ALTIROC RDO container handle.
SG::WriteHandleKey< HGTD_ALTIROC_RDO_Container >	m_output_altiroc_rdo_cont_key {this, "AltirocOutputObject", "", "Key of HGTD_ALTIROC_RDO container"}
SG::WriteHandle< InDetSimDataCollection >	m_sdo_collection_map
	SDO Map handle.
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.
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"}
ToolHandle< HGTD_TdcCalibrationTool >	m_hgtd_tdc_calib_tool {this, "HGTD_TdcCalibrationTool","HGTD_TdcCalibrationTool", "Tool that handles the Time to Digital Converter (TDC)"}
const HGTD_ID *	m_id_helper {nullptr}
	Handle to the ID helper.
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.
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
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

Definition at line 51 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 23 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 320 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;
}

createAndStoreRDO()

StatusCode HGTD_DigitizationTool::createAndStoreRDO ( SiChargedDiodeCollection * charged_diodes, const InDetDD::SolidStateDetectorElementBase * element )

private

Definition at line 343 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);
 
  std::unique_ptr<HGTD_ALTIROC_RDO_Collection> altiroc_rdo_collection =
      std::make_unique<HGTD_ALTIROC_RDO_Collection>(idHash_de);
 
  // need the DE identifier
  const Identifier id_de = charged_diodes->identify();
  rdo_collection->setIdentifier(id_de);
  altiroc_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 charge_time = charge.time();
 
    unsigned int dummy_tot = 256;
    unsigned short dummy_bcid = 0;
    unsigned short dummy_l1a = 0;
    unsigned short dummy_l1id = 0;
 
 
    if(!m_output_rdo_cont_key.key().empty()){
      std::unique_ptr<HGTD_RDO> p_rdo = std::make_unique<HGTD_RDO>(
        id_readout, charge_time, dummy_tot, dummy_bcid, dummy_l1a, dummy_l1id);
 
      rdo_collection->push_back(p_rdo.release());
    }
 
    if(!m_output_altiroc_rdo_cont_key.key().empty()){
      uint8_t toa = m_hgtd_tdc_calib_tool->Time2TOA(element,charge_time);
      // Check overflow to not store out of range measurements
      if (m_hgtd_tdc_calib_tool->checkTOAoverflow(toa)){
        continue;
      } 
  
      uint8_t dummy_crc = 0;
  
      std::unique_ptr<HGTD_ALTIROC_RDO> p_altiroc_rdo = 
        std::make_unique<HGTD_ALTIROC_RDO>(id_readout,
                                          dummy_crc,
                                          toa,
                                          dummy_tot,
                                          dummy_l1id,
                                          dummy_bcid);
  
      altiroc_rdo_collection->push_back(p_altiroc_rdo.release());
    }
  }
  
  // Store the RDO collection
 
  // Only store the HGTD_RDO if its WriteHandleKey is set 
  if(!m_output_rdo_cont_key.key().empty()){
    const IdentifierHash identifyHash{rdo_collection->identifierHash()};
    if (m_hgtd_rdo_container
            ->addCollection(rdo_collection.release(), identifyHash).isFailure()) {
      ATH_MSG_FATAL("HGTD RDO collection could not be added to container!");
      return StatusCode::FAILURE;
    } 
  }
   
  // Only store the HGTD_ALTIROC_RDO if its WriteHandleKey is set 
  if(!m_output_altiroc_rdo_cont_key.key().empty()){
    const IdentifierHash identifyHash{altiroc_rdo_collection->identifierHash()};
    if (m_hgtd_altiroc_rdo_container
          ->addCollection(altiroc_rdo_collection.release(), identifyHash).isFailure()) {
      ATH_MSG_FATAL("HGTD ALTIROC RDO collection could not be added to container!");
      return StatusCode::FAILURE;
    }    
  }
 
  return StatusCode::SUCCESS;
}

createAndStoreSDO()

void HGTD_DigitizationTool::createAndStoreSDO ( SiChargedDiodeCollection * collection )

private

Definition at line 455 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();
      if (HepMC::ignoreTruthLink(trkLink, 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(trkLink) && 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
}

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 251 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 = InDetDD::HGTDDetEl::getDetectorElement(waferHash,*elements);
    // 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!!!
 
    ATH_CHECK(createAndStoreRDO(charged_diode_coll.get(),det_elem));
 
    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 29 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_sdo_coll_key.initialize());
 
  // Initialize RDO WriteHandleKey if keys not empty
  if(!m_output_rdo_cont_key.key().empty()){
    ATH_CHECK(m_output_rdo_cont_key.initialize());
  }
 
  // Initialize ALTIROC_RDO WriteHandleKey if keys not empty
  // Only retrieve TDC calibration tool if it will be used
  if(!m_output_altiroc_rdo_cont_key.key().empty()){
    ATH_CHECK(m_output_altiroc_rdo_cont_key.initialize());
    ATH_CHECK(m_hgtd_tdc_calib_tool.retrieve());
  }
  
  return StatusCode::SUCCESS;
}

interfaceID()

const InterfaceID & HGTD_DigitizationTool::interfaceID ( )

inlinestatic

Definition at line 143 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 141 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 165 of file HGTD_DigitizationTool.cxx.

                                                                                      {
  ATH_MSG_DEBUG("HGTD_DigitizationTool::prepareEvent()");
  // Create the IdentifiableContainer to contain the digit collections Create
  // a new RDO container
 
  if(!m_output_rdo_cont_key.key().empty()){
    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())));        
  }
 
  if(!m_output_altiroc_rdo_cont_key.key().empty()){
    m_hgtd_altiroc_rdo_container = SG::makeHandle(m_output_altiroc_rdo_cont_key, ctx);
    ATH_CHECK(m_hgtd_altiroc_rdo_container.record(std::make_unique<HGTD_ALTIROC_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()

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

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 102 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 IPileUpTool::resetFilter ( )

pure virtualinherited

reset the filter

resetFilter() [2/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; }

retrieveHitCollection()

StatusCode HGTD_DigitizationTool::retrieveHitCollection ( const EventContext & ctx )

private

Retrieve the SiHit collection and place it in a TimedHitCollection.

Definition at line 192 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;
}

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

{this, "ChargeThreshold", 625., "Minimum charge threshold in ASIC"};

m_diode_processor_tools

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

private

Definition at line 123 of file HGTD_DigitizationTool.h.

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_hgtd_altiroc_rdo_container

SG::WriteHandle<HGTD_ALTIROC_RDO_Container> HGTD_DigitizationTool::m_hgtd_altiroc_rdo_container

private

ALTIROC RDO container handle.

Definition at line 114 of file HGTD_DigitizationTool.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 124 of file HGTD_DigitizationTool.h.

{this, "FrontEnd", "HGTD_FrontEndTool", "Tool for pulse shape simulation"};

m_hgtd_rdo_container

SG::WriteHandle<HGTD_RDO_Container> HGTD_DigitizationTool::m_hgtd_rdo_container

private

RDO container handle.

Definition at line 111 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 125 of file HGTD_DigitizationTool.h.

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

m_hgtd_tdc_calib_tool

ToolHandle<HGTD_TdcCalibrationTool> HGTD_DigitizationTool::m_hgtd_tdc_calib_tool {this, "HGTD_TdcCalibrationTool","HGTD_TdcCalibrationTool", "Tool that handles the Time to Digital Converter (TDC)"}

private

Definition at line 126 of file HGTD_DigitizationTool.h.

{this, "HGTD_TdcCalibrationTool","HGTD_TdcCalibrationTool", "Tool that handles the Time to Digital Converter (TDC)"};

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

{this, "HGTDDetEleCollKey", "HGTD_DetectorElementCollection", "Key of HGTD_DetectorElementCollection for HGTD"};

m_hit_coll_ptrs

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

private

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

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

m_id_helper

const HGTD_ID* HGTD_DigitizationTool::m_id_helper {nullptr}

private

Handle to the ID helper.

Definition at line 128 of file HGTD_DigitizationTool.h.

{nullptr}; 

m_inputObjectName

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

private

Definition at line 109 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.

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

m_merge_svc

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

private

Definition at line 121 of file HGTD_DigitizationTool.h.

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

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

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

m_output_altiroc_rdo_cont_key

SG::WriteHandleKey<HGTD_ALTIROC_RDO_Container> HGTD_DigitizationTool::m_output_altiroc_rdo_cont_key {this, "AltirocOutputObject", "", "Key of HGTD_ALTIROC_RDO container"}

private

Definition at line 115 of file HGTD_DigitizationTool.h.

{this, "AltirocOutputObject", "", "Key of HGTD_ALTIROC_RDO container"};

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

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

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

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

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

{this, "RndmSvc", "AthRNGSvc", "Random Number Service used in HGTD & Pixel digitization"};  

m_sdo_collection_map

SG::WriteHandle<InDetSimDataCollection> HGTD_DigitizationTool::m_sdo_collection_map

private

SDO Map handle.

Definition at line 117 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 132 of file HGTD_DigitizationTool.h.

{nullptr};

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:

• HGTD_DigitizationTool.h
• HGTD_DigitizationTool.cxx