Algorithm which selectively copies hits from an input SCT_RDO_Container. More...

#include <StripDefectsEmulatorAlg.h>

Inheritance diagram for InDet::StripDefectsEmulatorAlg:

Collaboration diagram for InDet::StripDefectsEmulatorAlg:

Public Types
using	T_ID_Helper
using	T_ID_Adapter
	Adapter to support different types of RDO collections, and ID helpers.
using	T_DefectsData
using	T_RDORawData
using	T_ModuleHelper
using	T_ModuleDesign

Public Member Functions
	DefectsEmulatorBase (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
StatusCode	initializeBase (unsigned int wafer_hash_max)
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Attributes
static constexpr ActsTrk::DetectorType	DETECTOR_TYPE

Protected Types
enum	EHistType

Protected Member Functions
virtual bool	setModuleData (const ActsDetectorElement &acts_detector_element, ModuleIdentifierMatchUtil::ModuleData_t &module_data) const override
	Set the module data for matching for the given detector element.
std::tuple< TH2 , TH2 , TH1 * >	findHist (unsigned int n_rows, unsigned int n_cols) const
	Get rejected hits and noise histograms for a certain module design.
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
ServiceHandle< ITHistSvc >	m_histSvc
Gaudi::Property< std::string >	m_histogramGroupName
Gaudi::Property< std::vector< std::vector< int > > >	m_modulePattern
Gaudi::Property< std::vector< float > >	m_noiseProbability
Gaudi::Property< std::vector< std::vector< double > > >	m_noiseShape
std::mutex	m_histMutex
std::vector< unsigned int > m_dimPerHist	ATLAS_THREAD_SAFE
std::array< TH2 *, kNHistTypes > m_moduleHist	ATLAS_THREAD_SAFE
std::array< std::vector< TH2 * >, 2 > m_hist	ATLAS_THREAD_SAFE
std::vector< TH1 * > m_noiseShapeHist	ATLAS_THREAD_SAFE
std::atomic< std::size_t >	m_rejectedRDOs
std::atomic< std::size_t >	m_totalRDOs
std::atomic< std::size_t >	m_splitRDOs
std::atomic< std::size_t >	m_totalNoise
PublicToolHandle< ActsTrk::ITrackingGeometryTool >	m_trackingGeometryTool
ServiceHandle< IAthRNGSvc >	m_rndmSvc
std::string	m_rngName
std::vector< unsigned short >	m_noiseParamIdx
std::vector< std::vector< float > >	m_noiseShapeCummulative
unsigned int	m_maxNShape
bool	m_histogrammingEnabled

Static Protected Attributes
static const std::array< std::string_view, kNHistTypes >	s_histNames
static const std::array< std::string_view, kNHistTypes >	s_histTitles

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< T_DefectsData >	m_emulatedDefects
SG::ReadHandleKey< SCT_RDO_Container >	m_origRdoContainerKey
SG::WriteHandleKey< SCT_RDO_Container >	m_rdoOutContainerKey
Gaudi::Property< std::string >	m_idHelperName
T_ID_Helper	m_idHelper
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Algorithm which selectively copies hits from an input SCT_RDO_Container.

Hits will be copied unless they are marked as defects in the "defects" conditions data. This is a specialization of DefectsEmulatorAlg for SCT_RDOs. RDOs referring to a group of strips are split if overlapping with a defect not covering the full group of strips.

Definition at line 194 of file StripDefectsEmulatorAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ T_DefectsData

using InDet::DefectsEmulatorAlg< SCT_RDO_Container >::T_DefectsData

inherited

Definition at line 37 of file DefectsEmulatorAlg.h.

◆ T_ID_Adapter

using InDet::DefectsEmulatorAlg< SCT_RDO_Container >::T_ID_Adapter

inherited

Adapter to support different types of RDO collections, and ID helpers.

Must have the following traits:

The adapter is constructable from the ID_Helper
provides methods row_index and column_index to compute the row and column index from an Identifier
provides a method cloneOrRejectHit which returns the number of newly added hits and takes as arguments: a module helper and matching emulated defects conditions data, a module id hash, a row and column index, the input RDO, and the collection to which the "cloned" RDOs are added.

Definition at line 36 of file DefectsEmulatorAlg.h.

◆ T_ID_Helper

using InDet::DefectsEmulatorAlg< SCT_RDO_Container >::T_ID_Helper

inherited

Definition at line 25 of file DefectsEmulatorAlg.h.

◆ T_ModuleDesign

using InDet::DefectsEmulatorAlg< SCT_RDO_Container >::T_ModuleDesign

inherited

Definition at line 40 of file DefectsEmulatorAlg.h.

◆ T_ModuleHelper

using InDet::DefectsEmulatorAlg< SCT_RDO_Container >::T_ModuleHelper

inherited

Definition at line 39 of file DefectsEmulatorAlg.h.

◆ T_RDORawData

using InDet::DefectsEmulatorAlg< SCT_RDO_Container >::T_RDORawData

inherited

Definition at line 38 of file DefectsEmulatorAlg.h.

Member Enumeration Documentation

◆ EHistType

enum InDet::DefectsEmulatorBase::EHistType

protectedinherited

Definition at line 71 of file DefectsEmulatorBase.h.

                  {
      kRejectedHits,
      kNoiseHits,
      kNHistTypes
   };

Member Function Documentation

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ DefectsEmulatorBase()

	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

inherited

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ execute()

virtual StatusCode InDet::DefectsEmulatorAlg< SCT_RDO_Container >::execute ( const EventContext & ctx ) const

overridevirtualinherited

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

◆ filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

◆ finalize()

StatusCode InDet::DefectsEmulatorBase::finalize ( )

overridevirtualinherited

Definition at line 35 of file DefectsEmulatorBase.cxx.

                                          {
     ATH_MSG_INFO( "Total number of rejected RDOs " << m_rejectedRDOs << ", kept " << m_totalRDOs
                   << (m_splitRDOs>0 ?  (", split " + std::to_string(m_splitRDOs) ) : "")
                   << ", additional noise " << m_totalNoise);
     return StatusCode::SUCCESS;
  }

◆ findHist()

std::tuple< TH2 , TH2 , TH1 * > InDet::DefectsEmulatorBase::findHist	(	unsigned int	n_rows,
		unsigned int	n_cols ) const

protectedinherited

Get rejected hits and noise histograms for a certain module design.

Parameters

n_rows	the number of rows of the module design
n_cols	the number of columns of the module design

Returns: rejected_hits per cell, noise per cell, noise shape histograms calls during execute must be protected by m_histMutex

Definition at line 54 of file DefectsEmulatorBase.cxx.

                                                                                                           {
     unsigned int key=(n_rows << 16) | n_cols;
     std::vector<unsigned int>::const_iterator iter = std::find(m_dimPerHist.begin(),m_dimPerHist.end(), key );
     if (iter == m_dimPerHist.end()) {
        if (m_dimPerHist.size() == m_dimPerHist.capacity()) {
           if (m_dimPerHist.capacity()==0) {
              return std::make_tuple(nullptr,nullptr,nullptr);
           }
           else {
              return std::make_tuple(m_hist[kRejectedHits].back(),
                                     m_hist[kNoiseHits].empty() ? nullptr : m_hist[kNoiseHits].back(),
                                     m_noiseShapeHist.empty() ? nullptr : m_noiseShapeHist.back());
           }
        }
        else {
           // if no "sensor" with this dimensions has been registered yet, create histograms
           // and register it.
           for (unsigned int hist_type_i=0; hist_type_i<kNHistTypes; ++hist_type_i) {
              HistUtil::StringCat name;
              name << s_histNames.at(hist_type_i) << "_hits_" << n_rows << "_" << n_cols;
              HistUtil::StringCat title;
              title << s_histTitles.at(hist_type_i) << "hits for " << n_rows << "(rows) #times " << n_cols << " (columns)";
              {
                 HistUtil::ProtectHistogramCreation protect;
                 m_hist.at(hist_type_i).push_back(new TH2F(name.str().c_str(), title.str().c_str(),
                                           n_cols, -0.5, n_cols-0.5,
                                           n_rows, -0.5, n_rows-0.5
                                           ));
              }
              m_hist[hist_type_i].back()->GetXaxis()->SetTitle("offline column");
              m_hist[hist_type_i].back()->GetYaxis()->SetTitle("offline row");
              if ( m_histSvc->regHist(m_histogramGroupName.value() + name.str(),m_hist[hist_type_i].back()).isFailure() ) {
                 throw std::runtime_error("Failed to register histogram.");
              }
           }
           {
              std::stringstream name;
              name << "noise_shape_" << n_rows << "_" << n_cols;
              std::stringstream title;
              title << "Noise shape for " << n_rows << "(rows) #times " << n_cols << " (columns)";
              m_noiseShapeHist.push_back(new TH1F(name.str().c_str(), title.str().c_str(), m_maxNShape+1, -0.5, m_maxNShape+.5));
              m_noiseShapeHist.back()->GetXaxis()->SetTitle("offline column");
              m_noiseShapeHist.back()->GetYaxis()->SetTitle("offline row");
              if ( m_histSvc->regHist(m_histogramGroupName.value() + name.str(),m_noiseShapeHist.back()).isFailure() ) {
                 throw std::runtime_error("Failed to register histogram.");
              }
           }
           m_dimPerHist.push_back(key);
           return std::make_tuple(m_hist[kRejectedHits].back(),
                                  m_hist[kNoiseHits].empty() ? nullptr : m_hist[kNoiseHits].back(),
                                  m_noiseShapeHist.empty() ? nullptr : m_noiseShapeHist.back()
                                  );
        }
     }
     else {
        return std::make_tuple(m_hist[kRejectedHits].at(iter-m_dimPerHist.begin()),
                               m_hist[kNoiseHits].empty() ? nullptr : m_hist[kNoiseHits].at(iter-m_dimPerHist.begin()),
                               m_noiseShapeHist.empty() ? nullptr : m_noiseShapeHist.at(iter-m_dimPerHist.begin()));
     }
  }

◆ initialize()

virtual StatusCode InDet::DefectsEmulatorAlg< SCT_RDO_Container >::initialize ( )

overridevirtualinherited

◆ initializeBase()

StatusCode InDet::DefectsEmulatorBase::initializeBase ( unsigned int wafer_hash_max )

inherited

Definition at line 34 of file DefectsEmulatorBase.cxx.

                                                                           {
     ATH_CHECK( m_trackingGeometryTool.retrieve( DisableTool{m_noiseProbability.empty()} ));
     if (!m_noiseProbability.value().empty()) {
        if (m_modulePattern.value().size() != m_noiseProbability.value().size()) {
           ATH_MSG_FATAL("Number of module patterns and noise probabilities  differs: "
                         << m_modulePattern.value().size() << " != " << m_noiseProbability.size() );
           return StatusCode::FAILURE;
        }
 
        if (m_noiseProbability.value().size() != m_noiseShape.value().size()) {
           ATH_MSG_FATAL("Number of noise probabilities and number of noise shapes differs: "
                         << m_noiseProbability.size() << " != " << m_noiseShape.size());
           return StatusCode::FAILURE;
        }
        ATH_CHECK(m_rndmSvc.retrieve());
        m_rngName = name()+"RandomEngine";
 
        if (wafer_hash_max>std::numeric_limits<unsigned short>::max()) {
           ATH_MSG_FATAL("Maximjum wafer hash too large (" << wafer_hash_max
                         << "). This algorithm only supports wafer hashes up to "
                         << std::numeric_limits<unsigned short>::max());
           return StatusCode::FAILURE;
        }
        m_noiseParamIdx.resize(wafer_hash_max, static_cast<unsigned short>(m_noiseProbability.size()));
        m_maxNShape=0;
        std::shared_ptr<const Acts::TrackingGeometry> tracking_geometry = m_trackingGeometryTool->trackingGeometry();
 
        ModuleIdentifierMatchUtil::ModuleData_t module_data;
        std::vector<unsigned int> module_pattern_idx;
        module_pattern_idx.reserve( m_modulePattern.value().size() );
 
        // Associate noise probabilities and noise shapes to module identifier hashes.
        // The association is done according to the module match criteria. The derived
        // class has to ensure that only modules with umambigous identifier hash are
        // considered.
        using Counter = struct { unsigned int n_detector_elements, n_missing_detector_elements, n_wrong_type,
                                 n_no_matching_pattern, n_detector_elements_of_correct_type; };
        Counter counter {0u,0u,0u,0u,0u};
        tracking_geometry->visitSurfaces([&counter, &module_data, &module_pattern_idx, this](const Acts::Surface *surface_ptr) {
           
         const auto *acts_detector_element = getActsDetectorElement(surface_ptr);
              
         if (!acts_detector_element) return;
         if (setModuleData(*acts_detector_element, module_data)) {
               ModuleIdentifierMatchUtil::moduleMatches(m_modulePattern.value(), module_data, module_pattern_idx);
               if (module_pattern_idx.empty()) {
                  ++counter.n_no_matching_pattern;
               } else {
                  m_noiseParamIdx.at(acts_detector_element->identifyHash()) = module_pattern_idx.front();
               }
            ++counter.n_detector_elements_of_correct_type;
         }
        }, true /*sensitive surfaces*/);
        ATH_MSG_DEBUG("Visited surfaces with " << counter.n_detector_elements << " / "
                      << (counter.n_missing_detector_elements + counter.n_detector_elements)
                      << " (wrong type " << counter.n_wrong_type << ")"
                      << " expected detector type " << counter.n_detector_elements_of_correct_type
                      << " without match " << counter.n_no_matching_pattern);
        if (counter.n_missing_detector_elements || counter.n_wrong_type>0) {
           ATH_MSG_ERROR("Encountered " << counter.n_wrong_type << " associated detector elements with wrong type and "
                         << counter.n_missing_detector_elements << " surfaces without detector element.");
        }
 
        // create normalised cummulative distributions of noise shape distributions
        m_noiseShapeCummulative.resize( m_noiseShape.size());
        unsigned int pattern_i=0;
        for (const std::vector<double> &shape : m_noiseShape.value()) {
           m_noiseShapeCummulative[pattern_i].reserve( shape.size());
           double scale=std::accumulate(shape.begin(), shape.end(),0.);
           if (std::abs(scale-1.)>1e-5) {
              ATH_MSG_FATAL("Noise shape integral for pattern " << pattern_i << " not 1. but " << scale);
              return StatusCode::FAILURE;
           }
           //coverity[DIVIDE_BY_ZERO:FALSE]
           scale = 1./scale;
           double sum =0.;
           for (double value : shape) {
              sum += value * scale;
              m_noiseShapeCummulative[pattern_i].push_back( sum );
           }
           m_maxNShape=std::max(m_maxNShape,static_cast<unsigned int>(shape.size()));
           ++pattern_i;
        }
        ATH_CHECK(  (m_noiseProbability.size() == m_noiseShapeCummulative.size()));
     }
 
     if (!m_histSvc.name().empty() && !m_histogramGroupName.value().empty()) {
        ATH_CHECK( m_histSvc.retrieve() );
        // reserve space for histograms for 6 different sensor types
        constexpr unsigned int n_different_pixel_matrices_max=6;
        m_dimPerHist.reserve(n_different_pixel_matrices_max);
        for (unsigned int hist_type_i=0; hist_type_i<kNHistTypes; ++hist_type_i) {
           m_hist[hist_type_i].reserve(n_different_pixel_matrices_max);
        }
 
        // create per id-hash histograms
        m_noiseShapeHist.reserve(n_different_pixel_matrices_max);
 
        unsigned int max_y_axis = (((wafer_hash_max+99)/100+9)/10)*10;
        for (unsigned int hist_type_i=0; hist_type_i<kNHistTypes; ++hist_type_i) {
           {
              HistUtil::StringCat hist_name;
              hist_name << s_histNames.at(hist_type_i) << "_hits_per_module";
              HistUtil::StringCat hist_title;
              hist_title << s_histTitles.at(hist_type_i) << " hits per module";
 
              HistUtil::ProtectHistogramCreation protect;
              m_moduleHist.at(hist_type_i) = new TH2F(hist_name.str().c_str(), hist_title.str().c_str(),
                                                      100, -0.5, 100-0.5,
                                                      max_y_axis, -0.5, max_y_axis-0.5
                                                      );
           }
           m_moduleHist[hist_type_i]->GetXaxis()->SetTitle("ID hash % 100");
           m_moduleHist[hist_type_i]->GetYaxis()->SetTitle("ID hash / 100");
           if ( m_histSvc->regHist(m_histogramGroupName.value() + m_moduleHist[hist_type_i]->GetName(),m_moduleHist[hist_type_i]).isFailure() ) {
              return StatusCode::FAILURE;
           }
        }
        m_histogrammingEnabled=true;
     }
     return StatusCode::SUCCESS;
  }

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

◆ msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed	(	bool	state,
		const EventContext &	ctx ) const

inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

◆ setModuleData()

virtual bool InDet::DefectsEmulatorAlg< SCT_RDO_Container >::setModuleData	(	const ActsDetectorElement &	acts_detector_element,
		ModuleIdentifierMatchUtil::ModuleData_t &	module_data ) const

overrideprotectedvirtualinherited

Set the module data for matching for the given detector element.

Parameters

acts_detector_element	the detector element in question
module_data	destination for the module data for matching

Returns: True if the given module is to be considered for matching. The implementation has to ensure that only modules are considered which have unique identifier hashes i.e. modules of one detector type.

Implements InDet::DefectsEmulatorBase.

◆ sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/4]

std::vector< TH1 *> m_noiseShapeHist InDet::DefectsEmulatorBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 84 of file DefectsEmulatorBase.h.

◆ ATLAS_THREAD_SAFE [2/4]

std::array<std::vector< TH2 *>,2> m_hist InDet::DefectsEmulatorBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 83 of file DefectsEmulatorBase.h.

◆ ATLAS_THREAD_SAFE [3/4]

std::array<TH2 *,kNHistTypes> m_moduleHist InDet::DefectsEmulatorBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 82 of file DefectsEmulatorBase.h.

82{};

◆ ATLAS_THREAD_SAFE [4/4]

std::vector<unsigned int> m_dimPerHist InDet::DefectsEmulatorBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 81 of file DefectsEmulatorBase.h.

◆ DETECTOR_TYPE

ActsTrk::DetectorType InDet::DefectsEmulatorAlg< SCT_RDO_Container >::DETECTOR_TYPE

staticconstexprinherited

Definition at line 42 of file DefectsEmulatorAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_emulatedDefects

SG::ReadCondHandleKey<T_DefectsData> InDet::DefectsEmulatorAlg< SCT_RDO_Container >::m_emulatedDefects

privateinherited

Definition at line 55 of file DefectsEmulatorAlg.h.

56{this, "EmulatedDefectsKey", ""};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_histMutex

std::mutex InDet::DefectsEmulatorBase::m_histMutex

mutableprotectedinherited

Definition at line 79 of file DefectsEmulatorBase.h.

◆ m_histogramGroupName

Gaudi::Property<std::string> InDet::DefectsEmulatorBase::m_histogramGroupName

protectedinherited

Definition at line 58 of file DefectsEmulatorBase.h.

59{this,"HistogramGroupName","", "Histogram group name or empty to disable histogramming"};

◆ m_histogrammingEnabled

bool InDet::DefectsEmulatorBase::m_histogrammingEnabled

protectedinherited

Definition at line 102 of file DefectsEmulatorBase.h.

◆ m_histSvc

ServiceHandle<ITHistSvc> InDet::DefectsEmulatorBase::m_histSvc

protectedinherited

Definition at line 56 of file DefectsEmulatorBase.h.

57{this,"HistSvc","THistSvc"};

◆ m_idHelper

T_ID_Helper InDet::DefectsEmulatorAlg< SCT_RDO_Container >::m_idHelper

privateinherited

Definition at line 64 of file DefectsEmulatorAlg.h.

64{};

◆ m_idHelperName

Gaudi::Property<std::string> InDet::DefectsEmulatorAlg< SCT_RDO_Container >::m_idHelperName

privateinherited

Definition at line 61 of file DefectsEmulatorAlg.h.

62{this, "IDHelper",""};

◆ m_maxNShape

unsigned int InDet::DefectsEmulatorBase::m_maxNShape

protectedinherited

Definition at line 100 of file DefectsEmulatorBase.h.

100{};

◆ m_modulePattern

Gaudi::Property<std::vector<std::vector<int> > > InDet::DefectsEmulatorBase::m_modulePattern

protectedinherited

Definition at line 61 of file DefectsEmulatorBase.h.

      {this,"ModulePatterns", {},
       "Integer ranges to select: (0-1) barrel/end-cap range, (2-3) layer, (4-5) eta index range, (6-7) phi index range, "
       "(8-9) module number of columns or strips, (10) both sides (0,1), (11) all rows (0,1)" };

◆ m_noiseParamIdx

std::vector<unsigned short> InDet::DefectsEmulatorBase::m_noiseParamIdx

protectedinherited

Definition at line 97 of file DefectsEmulatorBase.h.

◆ m_noiseProbability

Gaudi::Property<std::vector<float> > InDet::DefectsEmulatorBase::m_noiseProbability

protectedinherited

Definition at line 66 of file DefectsEmulatorBase.h.

67{this,"NoiseProbability",0., "Probability for a cell to produce a spurious hit per module pattern"};

◆ m_noiseShape

Gaudi::Property<std::vector<std::vector<double> > > InDet::DefectsEmulatorBase::m_noiseShape

protectedinherited

Definition at line 68 of file DefectsEmulatorBase.h.

69{this,"NoiseShape",{}, "Shape of noise distribution (e.g. used for Pixel tot distribution or strip time bin distribution."};

◆ m_noiseShapeCummulative

std::vector<std::vector<float> > InDet::DefectsEmulatorBase::m_noiseShapeCummulative

protectedinherited

Definition at line 98 of file DefectsEmulatorBase.h.

◆ m_origRdoContainerKey

SG::ReadHandleKey<SCT_RDO_Container> InDet::DefectsEmulatorAlg< SCT_RDO_Container >::m_origRdoContainerKey

privateinherited

Definition at line 57 of file DefectsEmulatorAlg.h.

58{this, "InputKey", ""};

◆ m_rdoOutContainerKey

SG::WriteHandleKey<SCT_RDO_Container> InDet::DefectsEmulatorAlg< SCT_RDO_Container >::m_rdoOutContainerKey

privateinherited

Definition at line 59 of file DefectsEmulatorAlg.h.

60{this, "OutputKey", ""};

◆ m_rejectedRDOs

std::atomic<std::size_t> InDet::DefectsEmulatorBase::m_rejectedRDOs

mutableprotectedinherited

Definition at line 87 of file DefectsEmulatorBase.h.

87{};

◆ m_rndmSvc

ServiceHandle<IAthRNGSvc> InDet::DefectsEmulatorBase::m_rndmSvc

protectedinherited

Definition at line 95 of file DefectsEmulatorBase.h.

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

◆ m_rngName

std::string InDet::DefectsEmulatorBase::m_rngName

protectedinherited

Definition at line 96 of file DefectsEmulatorBase.h.

◆ m_splitRDOs

std::atomic<std::size_t> InDet::DefectsEmulatorBase::m_splitRDOs

mutableprotectedinherited

Definition at line 89 of file DefectsEmulatorBase.h.

89{};

◆ m_totalNoise

std::atomic<std::size_t> InDet::DefectsEmulatorBase::m_totalNoise

mutableprotectedinherited

Definition at line 90 of file DefectsEmulatorBase.h.

90{};

◆ m_totalRDOs

std::atomic<std::size_t> InDet::DefectsEmulatorBase::m_totalRDOs

mutableprotectedinherited

Definition at line 88 of file DefectsEmulatorBase.h.

88{};

◆ m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> InDet::DefectsEmulatorBase::m_trackingGeometryTool

protectedinherited

Definition at line 92 of file DefectsEmulatorBase.h.

93{this, "TrackingGeometryTool", "ActsTrackingGeometryTool"};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ s_histNames

const std::array< std::string_view, DefectsEmulatorBase::kNHistTypes > InDet::DefectsEmulatorBase::s_histNames

staticprotectedinherited

Definition at line 76 of file DefectsEmulatorBase.h.

◆ s_histTitles

const std::array< std::string_view, DefectsEmulatorBase::kNHistTypes > InDet::DefectsEmulatorBase::s_histTitles

staticprotectedinherited

Definition at line 77 of file DefectsEmulatorBase.h.

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

StripDefectsEmulatorAlg.h

Public Types

Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ T_DefectsData

◆ T_ID_Adapter

◆ T_ID_Helper

◆ T_ModuleDesign

◆ T_ModuleHelper

◆ T_RDORawData

Member Enumeration Documentation

◆ EHistType

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ DefectsEmulatorBase()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ finalize()

◆ findHist()

◆ initialize()

◆ initializeBase()

◆ inputHandles()

◆ isClonable()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ setModuleData()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/4]

◆ ATLAS_THREAD_SAFE [2/4]

◆ ATLAS_THREAD_SAFE [3/4]

◆ ATLAS_THREAD_SAFE [4/4]

◆ DETECTOR_TYPE

◆ m_detStore

◆ m_emulatedDefects

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_histMutex

◆ m_histogramGroupName

◆ m_histogrammingEnabled

◆ m_histSvc

◆ m_idHelper

◆ m_idHelperName

◆ m_maxNShape

◆ m_modulePattern

◆ m_noiseParamIdx

◆ m_noiseProbability

◆ m_noiseShape

◆ m_noiseShapeCummulative

◆ m_origRdoContainerKey

◆ m_rdoOutContainerKey

◆ m_rejectedRDOs

◆ m_rndmSvc

◆ m_rngName

◆ m_splitRDOs

◆ m_totalNoise

◆ m_totalRDOs

◆ m_trackingGeometryTool

◆ m_varHandleArraysDeclared