Conditions algorithms for emulating ITK strip defects. More...

#include <StripDefectsEmulatorCondAlg.h>

Inheritance diagram for InDet::StripDefectsEmulatorCondAlg:

Collaboration diagram for InDet::StripDefectsEmulatorCondAlg:

Public Member Functions
virtual StatusCode	initialize () override final

virtual StatusCode	execute (const EventContext &ctx) const override

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

virtual StatusCode	finalize () override

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

virtual bool	filterPassed (const EventContext &ctx) const

virtual void	setFilterPassed (bool state, const EventContext &ctx) const

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

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

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
std::unordered_multimap< unsigned int, unsigned int >	getModuleConnectionMap (const InDetDD::SiDetectorElementCollection &det_ele_coll) const
	Return the map which defines which modules are connected to the same sensor as a reference module. More...

bool	isModuleDefect (const EventContext &ctx, unsigned int id_hash) const
	Alternative method to declare strip modules as defect. More...

const StripDefectsEmulatorCondAlg &	derived () const

StatusCode	initializeBase (unsigned int n_masks, unsigned int wafer_hash_max)

StatusCode	initializeProbabilities (unsigned int n_masks)

StatusCode	initializeCornerDefects ()

StatusCode	checkProbabilities (unsigned int n_probabilities) const
	Consistency check of module patterns, probabilities. More...

double	totalProbability (const std::vector< unsigned int > &module_pattern_idx, unsigned int prob_idx) const
	Compute the total probability using the probabilities associated to the given list of patterns. More...

void	makeCumulativeProbabilityDist (std::vector< unsigned int > &module_pattern_idx, unsigned int prob_idx, std::vector< double > &cumulative_prob) const
	Create a cumulative distribution from the referenced set of probabilities. More...

unsigned int	throwNumberOfDefects (std::span< CLHEP::HepRandomEngine * > rndmEngine, const std::vector< unsigned int > &module_pattern_idx, unsigned int n_masks, unsigned int n_cells, std::vector< unsigned int > &n_mask_defects) const

void	printSummaryOfDefectGeneration (unsigned int n_masks, unsigned int n_error, unsigned int n_defects_total, const std::vector< std::array< unsigned int, kNCounts > > &counts) const

std::pair< unsigned int, unsigned int >	findHist (unsigned int pattern_i, unsigned int n_rows, unsigned int n_cols) const

void	histogramDefectModule (unsigned int module_pattern_i, unsigned int hist_pattern_i, unsigned int id_hash, const Amg::Vector3D &center) const

void	fillPerModuleHistograms (unsigned int module_pattern_i, unsigned int pattern_hist_i, unsigned int matrix_histogram_index, unsigned int matrix_index, unsigned int module_i, unsigned int n_masks, const std::vector< unsigned int > &n_mask_defects, const Amg::Vector3D &center) const

void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Static Protected Member Functions
static std::string	IDName ()
	Name of the SCT_ID helper. More...

Protected Attributes
ToolHandle< ISCT_ConditionsTool >	m_moduleVetoTool {this,"SCTConditionsTool","","Optional SCT conditions tool to mark modules as defect (alternative to ModulePattern)"}

SG::ReadCondHandleKey< T_DetectorElementCollection >	m_detEleCollKey

SG::WriteCondHandleKey< T_EmulatedDefects >	m_writeKey

Gaudi::Property< std::string >	m_idName

const T_ID *	m_idHelper

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

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

Gaudi::Property< std::vector< std::vector< double > > >	m_defectProbability

Gaudi::Property< std::vector< std::vector< double > > >	m_nDefectFractionsPerPattern

Gaudi::Property< std::vector< std::vector< double > > >	m_cornerDefectParamsPerPattern

Gaudi::Property< std::vector< std::vector< double > > >	m_cornerDefectNCornerFractionsPerPattern

std::vector< std::vector< std::vector< float > > >	m_perPatternAndMaskFractions

std::vector< std::vector< float > >	m_perPatternCornerDefectNCornerCummulativeProb

Gaudi::Property< bool >	m_rngPerDefectType {this, "RngPerDefectType", false, "One RNG per defect type to decorrelate randomness of defects."}

Gaudi::Property< bool >	m_oddRowToggle {this, "OddRowToggle", false}

Gaudi::Property< bool >	m_oddColToggle {this, "OddColToggle", false}

Gaudi::Property< bool >	m_checkerBoardToggle {this, "CheckerBoardDefects", false}

Gaudi::Property< unsigned int >	m_maxAttempts {this, "MaxRandomPositionAttempts", 10}

ServiceHandle< ITHistSvc >	m_histSvc {this,"HistSvc","THistSvc"}

Gaudi::Property< std::string >	m_histogramGroupName {this,"HistogramGroupName","", "Histogram group name or empty to disable histogramming"}

Gaudi::Property< bool >	m_fillHistogramsPerPattern {this, "FillHistogramsPerPattern", false, "If true, histogram per module defects etc. separately per pattern."}

Gaudi::Property< bool >	m_fillEtaPhiHistogramsPerPattern {this, "FillEtaPhiHistogramsPerPattern", false, "If true, histogram per eta, phi amd z, R are filled separately per pattern."}

Gaudi::Property< std::string >	m_outputFile {this,"DefectsOutputFile","", "Empty or file name to write out conditions data (.json or .root)."}

Gaudi::Property< std::vector< std::string > >	m_inputFiles {this,"DefectsInputFiles",{}, "Empty or file name to write out conditions data (.json or .root)."}

std::vector< std::string >	m_rngName

std::vector< std::string >	m_groupDefectHistNames

std::vector< unsigned int >	m_maxNGroupDefects

std::mutex	m_histMutex

std::vector< unsigned int > m_matrixTypeId	ATLAS_THREAD_SAFE

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

std::vector< std::vector< TH2 * > > m_hist	ATLAS_THREAD_SAFE

std::vector< std::vector< std::vector< TH1 * > > > m_groupDefectHists	ATLAS_THREAD_SAFE

std::vector< std::vector< TH2 * > > m_moduleHist	ATLAS_THREAD_SAFE

std::array< std::vector< TH2 * >, kNPosHists > m_defectModuleEtaPhiHist	ATLAS_THREAD_SAFE

std::array< std::vector< TH2 * >, kNPosHists > m_defectModuleEtaLayerHist	ATLAS_THREAD_SAFE

std::atomic< unsigned int >	m_modulesWithoutDefectParameters {}

bool	m_histogrammingEnabled = false

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> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Friends
class	DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >

Detailed Description

Conditions algorithms for emulating ITK strip defects.

The algorithm mask random strips and modules as defect. This data can be used to reject hits overlapping with these defects.

Definition at line 38 of file StripDefectsEmulatorCondAlg.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_DetectorElementCollection

using InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::T_DetectorElementCollection = detail::DetectorEmulatorCondAlgTraits<StripDefectsEmulatorCondAlg >::T_DetectorElementCollection

inherited

Definition at line 40 of file DefectsEmulatorCondAlgImpl.h.

◆ T_EmulatedDefects

using InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::T_EmulatedDefects = detail::DetectorEmulatorCondAlgTraits<StripDefectsEmulatorCondAlg >::T_EmulatedDefects

inherited

Definition at line 39 of file DefectsEmulatorCondAlgImpl.h.

◆ T_ID

using InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::T_ID = detail::DetectorEmulatorCondAlgTraits<StripDefectsEmulatorCondAlg >::T_ID

inherited

Definition at line 37 of file DefectsEmulatorCondAlgImpl.h.

◆ T_ModuleDesign

using InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::T_ModuleDesign = detail::DetectorEmulatorCondAlgTraits<StripDefectsEmulatorCondAlg >::T_ModuleDesign

inherited

Definition at line 41 of file DefectsEmulatorCondAlgImpl.h.

◆ T_ModuleHelper

using InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::T_ModuleHelper = detail::DetectorEmulatorCondAlgTraits<StripDefectsEmulatorCondAlg >::T_ModuleHelper

inherited

Definition at line 38 of file DefectsEmulatorCondAlgImpl.h.

Member Enumeration Documentation

◆ DefectTypes

enum InDet::DefectsEmulatorCondAlgBase::DefectTypes

protectedinherited

Enumerator
kModuleDefects
kCornerDefects
kMaskDefects

Definition at line 100 of file DefectsEmulatorCondAlgBase.h.

                        {
          kModuleDefects,
          kCornerDefects,
          kMaskDefects
       };

◆ ECornerDefectParams

enum InDet::DefectsEmulatorCondAlgBase::ECornerDefectParams

protectedinherited

Enumerator
kCornerDefectProb
kCornerDefectWidthColumnDirectionOffset
kCornerDefectWidthColumnDirection
kCornerDefectkWidthRowDirectionOffset
kCornerDefectkWidthRowDirection
kCornerDefectkSagittaOffset
kCornerDefectkSagitta
kNCornerDefectParams

Definition at line 112 of file DefectsEmulatorCondAlgBase.h.

                                {
          kCornerDefectProb,
          kCornerDefectWidthColumnDirectionOffset,
          kCornerDefectWidthColumnDirection,
          kCornerDefectkWidthRowDirectionOffset,
          kCornerDefectkWidthRowDirection,
          kCornerDefectkSagittaOffset,
          kCornerDefectkSagitta,
          kNCornerDefectParams
       };

◆ ECounts

enum InDet::DefectsEmulatorCondAlgBase::ECounts

protectedinherited

Enumerator
kNElements
kNDefects
kNRetries
kNMaxRtriesExceeded
kNModulesWithDefects
kMaxDefectsPerModule
kNCounts

Definition at line 159 of file DefectsEmulatorCondAlgBase.h.

                    {
          kNElements,
          kNDefects,
          kNRetries,
          kNMaxRtriesExceeded,
          kNModulesWithDefects,
          kMaxDefectsPerModule,
          kNCounts
       };

◆ EPerModuleHistType

enum InDet::DefectsEmulatorCondAlgBase::EPerModuleHistType

protectedinherited

Enumerator
kMatrixTypeId
kDefectModule
kDefectCell
kNPerModuleHistTypes

Definition at line 244 of file DefectsEmulatorCondAlgBase.h.

                               {
          kMatrixTypeId,
          kDefectModule,
          kDefectCell,
          kNPerModuleHistTypes
       };

◆ EPosHistType

enum InDet::DefectsEmulatorCondAlgBase::EPosHistType

protectedinherited

Enumerator
kDefectModulePos
kModulesWithDefectsPos
kNPosHists

Definition at line 236 of file DefectsEmulatorCondAlgBase.h.

                         {
          kDefectModulePos,
          kModulesWithDefectsPos,
          kNPosHists
       };

◆ EProbabilities

enum InDet::DefectsEmulatorCondAlgBase::EProbabilities

protectedinherited

Enumerator
kModuleDefectProb
kCellDefectProb
kNProb

Definition at line 106 of file DefectsEmulatorCondAlgBase.h.

                           {
          kModuleDefectProb,
          kCellDefectProb,
          kNProb
       };

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

 {
   return 0;
 }

◆ checkProbabilities()

StatusCode InDet::DefectsEmulatorCondAlgBase::checkProbabilities ( unsigned int n_probabilities ) const

protectedinherited

Consistency check of module patterns, probabilities.

Definition at line 188 of file DefectsEmulatorCondAlgBase.cxx.

                                                                                               {
      if (!(m_modulePattern.size() == m_defectProbability.size()
            && ModuleIdentifierMatchUtil::verifyModulePatternList(m_modulePattern.value())
            && ModuleIdentifierMatchUtil::verifyElementCount<double>(m_defectProbability.value(), n_probabilities))) {
         if (m_modulePattern.size() != m_defectProbability.size()) {
            ATH_MSG_ERROR( "size difference modulePattern vs defectProbability : " << m_modulePattern.size() << " != " << m_defectProbability.size() << "?");
         }
         bool ret = ModuleIdentifierMatchUtil::verifyModulePatternList(m_modulePattern.value());
         if (!ret) {
            ATH_MSG_ERROR( "Order problem in  modulePattern  : " <<  ret << "?");
         }
         ret = ModuleIdentifierMatchUtil::verifyElementCount<double>(m_defectProbability.value(), n_probabilities);
         if (!ret) {
            ATH_MSG_ERROR( "Size problem in  defectProbability : " << ret << " ( n_prob" << n_probabilities << ")?");
         }
      }
      return    m_modulePattern.size() == m_defectProbability.size()
         && ModuleIdentifierMatchUtil::verifyModulePatternList(m_modulePattern.value())
         && ModuleIdentifierMatchUtil::verifyElementCount<double>(m_defectProbability.value(), n_probabilities)
         ? StatusCode::SUCCESS : StatusCode::FAILURE;
   }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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

◆ DefectsEmulatorCondAlgBase()

InDet::DefectsEmulatorCondAlgBase::DefectsEmulatorCondAlgBase

inherited

Definition at line 43 of file DefectsEmulatorCondAlgBase.cxx.

24 : AthReentrantAlgorithm(name, pSvcLocator)

25 {}

◆ derived()

const StripDefectsEmulatorCondAlg & InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::derived

inlineprotectedinherited

Definition at line 49 of file DefectsEmulatorCondAlgImpl.h.

49 { return *static_cast<const T_Derived *>(this); }

◆ 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() [1/2]

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

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

virtual StatusCode InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.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();
 }

◆ fillPerModuleHistograms()

void InDet::DefectsEmulatorCondAlgBase::fillPerModuleHistograms	(	unsigned int	module_pattern_i,
		unsigned int	pattern_hist_i,
		unsigned int	matrix_histogram_index,
		unsigned int	matrix_index,
		unsigned int	module_i,
		unsigned int	n_masks,
		const std::vector< unsigned int > &	n_mask_defects,
		const Amg::Vector3D &	center
	)		const

protectedinherited

Definition at line 505 of file DefectsEmulatorCondAlgBase.cxx.

   {
      // all the following histograms are expected to have the same binning
      // i.e. one bin per ID hash organised in a matrix
      assert( pattern_hist_i < m_moduleHist.size());
      assert( kMatrixTypeId < m_moduleHist[pattern_hist_i].size());
      assert( kDefectModule < m_moduleHist[pattern_hist_i].size());
      unsigned int ids_per_col = static_cast<unsigned int>(m_moduleHist[pattern_hist_i][kDefectModule]->GetNbinsX());
      unsigned int bin_i=m_moduleHist[pattern_hist_i][kDefectModule]->GetBin( module_i%ids_per_col+1, module_i/ids_per_col+1);
      unsigned int mask_i=n_masks;
      for (; --mask_i>0; ) {
         assert( mask_i < n_mask_defects.size() && mask_i>0);
         if (!m_groupDefectHists.empty()) {
            m_groupDefectHists[pattern_hist_i][matrix_histogram_index][mask_i-1]->Fill(n_mask_defects[mask_i]);
         }
         assert( (kDefectCell+mask_i) < m_moduleHist[pattern_hist_i].size());
         m_moduleHist[pattern_hist_i][kDefectCell+mask_i]->SetBinContent(bin_i, n_mask_defects[mask_i]);
      }
      assert( (kDefectCell+mask_i) < m_moduleHist[pattern_hist_i].size());
      m_moduleHist[pattern_hist_i][kDefectCell+mask_i]->SetBinContent(bin_i, n_mask_defects[mask_i]);
      m_moduleHist[pattern_hist_i][kMatrixTypeId]->SetBinContent(bin_i, matrix_index+1 );
      unsigned int n_defects_total = std::accumulate(n_mask_defects.begin(),n_mask_defects.end(), 0u);
      if (n_defects_total>0) {
         unsigned int eta_phi_pattern_i = m_fillEtaPhiHistogramsPerPattern ? module_pattern_i  : 0;
         assert( kModulesWithDefectsPos < m_defectModuleEtaPhiHist.size());
         assert( eta_phi_pattern_i < m_defectModuleEtaPhiHist[kModulesWithDefectsPos].size() );
         m_defectModuleEtaPhiHist[kModulesWithDefectsPos][eta_phi_pattern_i]->Fill(center.z(), center.perp());
         m_defectModuleEtaLayerHist[kModulesWithDefectsPos][eta_phi_pattern_i]->Fill(center.x(), center.y(),n_defects_total);
      }
   }

◆ filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

◆ finalize()

StatusCode InDet::DefectsEmulatorCondAlgBase::finalize ( )

overridevirtualinherited

Definition at line 210 of file DefectsEmulatorCondAlgBase.cxx.

                                                  {
      if (m_modulesWithoutDefectParameters>0) {
         ATH_MSG_WARNING("No defect parameters for " << m_modulesWithoutDefectParameters << " modules.");
      }
      return StatusCode::SUCCESS;
   }

◆ findHist()

std::pair< unsigned int, unsigned int > InDet::DefectsEmulatorCondAlgBase::findHist	(	unsigned int	pattern_i,
		unsigned int	n_rows,
		unsigned int	n_cols
	)		const

protectedinherited

Definition at line 296 of file DefectsEmulatorCondAlgBase.cxx.

                                                                                                                                                 {
      unsigned int key=(n_rows << 16) | n_cols;
      assert( pattern_i < m_dimPerHist.size());
      assert( pattern_i < m_hist.size());
      unsigned int matrix_type_id;
      {
         std::vector<unsigned int>::const_iterator global_iter = std::find(m_matrixTypeId.begin(), m_matrixTypeId.end(), key );
         if (global_iter != m_matrixTypeId.end()) {
            matrix_type_id = global_iter - m_matrixTypeId.begin();
         }
         else {
            matrix_type_id =m_matrixTypeId.size();
            m_matrixTypeId.push_back(key);
         }
      }
  
      std::vector<unsigned int>::const_iterator iter = std::find(m_dimPerHist[pattern_i].begin(), m_dimPerHist[pattern_i].end(), key );
      if (iter == m_dimPerHist[pattern_i].end()) {
         HistUtil::StringCat name;
         name << "defects_" << pattern_i << "_" << (matrix_type_id) << "_" << n_rows << "_" << n_cols;
         HistUtil::StringCat title;
         title << "Defects for " << n_rows << "(rows) #times " << n_cols << " (columns) ID " << (matrix_type_id) << ", pattern " << pattern_i;
         {
            HistUtil::ProtectHistogramCreation protect;
            m_hist[pattern_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[pattern_i].back()->GetXaxis()->SetTitle("offline column");
         m_hist[pattern_i].back()->GetYaxis()->SetTitle("offline row");
         if ( m_histSvc->regHist(m_histogramGroupName.value() + name.str(),m_hist[pattern_i].back()).isFailure() ) {
            throw std::runtime_error("Failed to register histogram.");
         }
         m_dimPerHist[pattern_i].push_back(key);
  
         if (!m_groupDefectHists.empty()) {
            assert( pattern_i < m_groupDefectHists.size());
            assert( m_groupDefectHistNames.size() == m_maxNGroupDefects.size());
            m_groupDefectHists[pattern_i].emplace_back();
            m_groupDefectHists[pattern_i].back().resize(m_groupDefectHistNames.size());
            for (unsigned int group_i=0u; group_i < m_groupDefectHistNames.size(); ++group_i) {
               const std::string &group_name = m_groupDefectHistNames[group_i];
               HistUtil::StringCat hname;
               hname << "n_" << group_name << "_" << pattern_i << "_" << matrix_type_id << "_" << n_rows << "_" << n_cols;
               HistUtil::StringCat htitle;
               htitle << "Number of " << group_name << " defects for " << n_rows << "(rows) #times " << n_cols << " (columns) ID "
                      << (matrix_type_id) << ", pattern " << pattern_i;
  
               {
                  HistUtil::ProtectHistogramCreation protect;
                  assert(group_i < m_groupDefectHists[pattern_i].back().size());
                  m_groupDefectHists[pattern_i].back()[group_i]= new TH1F(hname.str().c_str(), htitle.str().c_str(),
                                                                             m_maxNGroupDefects[group_i]+1, -0.5,m_maxNGroupDefects[group_i]+.5);
               }
               if (m_histSvc->regHist(m_histogramGroupName.value() + m_groupDefectHists[pattern_i].back()[group_i]->GetName(),
                                      m_groupDefectHists[pattern_i].back()[group_i]).isFailure() ) {
                  throw std::runtime_error("Failed to register histogram.");
               }
            }
         }
         return std::make_pair(static_cast<unsigned int>(m_hist[pattern_i].size()-1), matrix_type_id);
      }
      else {
         return std::make_pair(static_cast<unsigned int>(iter-m_dimPerHist[pattern_i].begin()), matrix_type_id);
      }
   }

◆ getModuleConnectionMap()

std::unordered_multimap<unsigned int, unsigned int> InDet::StripDefectsEmulatorCondAlg::getModuleConnectionMap ( const InDetDD::SiDetectorElementCollection & det_ele_coll ) const

inlineprotected

Return the map which defines which modules are connected to the same sensor as a reference module.

Definition at line 57 of file StripDefectsEmulatorCondAlg.h.

                                                                                                                                              {
          return ConnectedModulesUtil::createModuleConnectionMap(*m_idHelper, det_ele_coll);
       }

◆ histogramDefectModule()

void InDet::DefectsEmulatorCondAlgBase::histogramDefectModule	(	unsigned int	module_pattern_i,
		unsigned int	hist_pattern_i,
		unsigned int	id_hash,
		const Amg::Vector3D &	center
	)		const

protectedinherited

Definition at line 490 of file DefectsEmulatorCondAlgBase.cxx.

                                                                                            {
      assert( hist_pattern_i < m_moduleHist.size() );
      unsigned int ids_per_col = static_cast<unsigned int>(m_moduleHist[hist_pattern_i][kDefectModule]->GetNbinsX());
      unsigned int bin_i=m_moduleHist[hist_pattern_i][kDefectModule]->GetBin( id_hash%ids_per_col+1, id_hash/ids_per_col+1);
      m_moduleHist[hist_pattern_i][kDefectModule]->SetBinContent(bin_i,1);
      unsigned int eta_phi_pattern_i = m_fillEtaPhiHistogramsPerPattern ? module_pattern_i  : 0;
      assert( kDefectModulePos < m_defectModuleEtaPhiHist.size());
      assert( eta_phi_pattern_i < m_defectModuleEtaPhiHist[kDefectModulePos].size() );
      m_defectModuleEtaPhiHist[kDefectModulePos][eta_phi_pattern_i]->Fill(center.z(), center.perp());
      m_defectModuleEtaLayerHist[kDefectModulePos][eta_phi_pattern_i]->Fill(center.x(), center.y());
   }

◆ IDName()

static std::string InDet::StripDefectsEmulatorCondAlg::IDName ( )

inlinestaticprotected

Name of the SCT_ID helper.

Definition at line 53 of file StripDefectsEmulatorCondAlg.h.

53 { return std::string("SCT_ID"); }

◆ initialize()

StatusCode InDet::StripDefectsEmulatorCondAlg::initialize ( )

finaloverridevirtual

Reimplemented from InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >.

Definition at line 7 of file StripDefectsEmulatorCondAlg.cxx.

                                                     {
     // There are no group defects defined for strips
     m_groupDefectHistNames.clear();
     m_maxNGroupDefects.clear();
     return DefectsEmulatorCondAlgImpl<StripDefectsEmulatorCondAlg>::initialize();
   }

◆ initializeBase()

StatusCode InDet::DefectsEmulatorCondAlgBase::initializeBase	(	unsigned int	n_masks,
		unsigned int	wafer_hash_max
	)

protectedinherited

Definition at line 27 of file DefectsEmulatorCondAlgBase.cxx.

                                                                                                         {
     ATH_CHECK(m_rndmSvc.retrieve());
     m_rngName.reserve( m_rngPerDefectType.value() ?  kMaskDefects + n_masks : 1);
     if (m_rngPerDefectType.value() ) {
        m_rngName.push_back(name()+"RngModuleDefects");
        m_rngName.push_back(name()+"RngCornerDefects");
        for (unsigned int mask_i=0; mask_i<n_masks; ++mask_i) {
           std::stringstream rng_name;
           rng_name << name() << "RngMaskDefect" << mask_i;
           m_rngName.push_back(rng_name.str());
        }
        assert(kMaskDefects+n_masks == m_rngName.size());
     }
     else {
        m_rngName.push_back(name()+"RandomEngine");
     }
     ATH_CHECK( initializeProbabilities(n_masks) );
     ATH_CHECK( initializeCornerDefects() );
     if (!m_outputFile.empty() && (!hasExtensions(m_outputFile.value(), ".root") && !hasExtensions(m_outputFile.value(), ".json"))) {
        ATH_MSG_ERROR("Output file \"" << m_outputFile.value() << "\" does not have extensions \".root\" or \".json\".");
        return StatusCode::FAILURE;
     }
     for (const std::string &input_file : m_inputFiles.value()) {
        if ((!hasExtensions(input_file, ".root") && !hasExtensions(input_file, ".json"))) {
           ATH_MSG_ERROR("Input file \"" << input_file << "\" does not have extensions \".root\" or \".json\".");
           return StatusCode::FAILURE;
        }
     }
  
     if (!m_histSvc.name().empty() && !m_histogramGroupName.value().empty()) {
        ATH_CHECK(m_histSvc.retrieve());
        m_histogrammingEnabled=true;
        // allow histogramming for at most 6 different pixel module types
        // histgram for additional module types will end up in the last histogram
        unsigned int n_pattern_for_histogramming = m_fillHistogramsPerPattern ? m_modulePattern.size() : 1;
        constexpr unsigned int n_different_matrices_max=6;
        m_dimPerHist.resize(n_pattern_for_histogramming);
        m_hist.resize(n_pattern_for_histogramming);
        if (!m_groupDefectHistNames.empty()) {
           m_groupDefectHists.resize(n_pattern_for_histogramming);
        }
        for (unsigned int pattern_i=0; pattern_i < n_pattern_for_histogramming; ++pattern_i) {
           m_dimPerHist[pattern_i].reserve(n_different_matrices_max);
           m_hist[pattern_i].reserve(n_different_matrices_max);
        }
        std::vector<std::string> hist_name {
           "matrix_type_id_per_module;Matrix type ID per module",
           "defect_module;Module is defect",
           "defects_per_module;Defect cells per module"};
        for (const std::string &group_name: m_groupDefectHistNames) {
           HistUtil::StringCat hname;
           hname << group_name << "defects_per_module;" << group_name <<" defects per module";
           hist_name.push_back(hname.str());
        }
        m_moduleHist.resize(n_pattern_for_histogramming);
        unsigned int max_y_axis = (((wafer_hash_max+99)/100+9)/10)*10;
  
        for (unsigned int pattern_i=0; pattern_i<m_moduleHist.size(); ++pattern_i) {
           m_moduleHist.at(pattern_i).resize(hist_name.size(), nullptr);
           for (unsigned int hist_i=0; hist_i<hist_name.size(); ++hist_i) {
              // support idHashes from 0 to 10k
              std::string::size_type pos = hist_name.at(hist_i).find(";");
              HistUtil::StringCat a_name;
              a_name << hist_name[hist_i].substr(0, (pos != std::string::npos ? pos : hist_name[hist_i].size())) << "_" << pattern_i;
              HistUtil::StringCat a_title;
              a_title << hist_name[hist_i].substr((pos != std::string::npos ? pos+1 : 0), hist_name[hist_i].size())
                      << " ( module pattern " << pattern_i << ")";
              {
                 HistUtil::ProtectHistogramCreation protect;
                 m_moduleHist.at(pattern_i).at(hist_i) = new TH2F(a_name.str().c_str(), a_title.str().c_str(),
                                                                  100, -0.5, 100-0.5,
                                                                  max_y_axis, -0.5, max_y_axis-0.5);
              }
              m_moduleHist[pattern_i][hist_i]->GetXaxis()->SetTitle("ID hash % 100");
              m_moduleHist[pattern_i][hist_i]->GetYaxis()->SetTitle("ID hash / 100");
              ATH_MSG_VERBOSE("Create histogram pattern " << pattern_i << " hist " << hist_i << " name " << a_name.str().c_str()
                              << " -> " << m_moduleHist[pattern_i][hist_i]->GetName());
              if ( m_histSvc->regHist(m_histogramGroupName.value() + m_moduleHist[pattern_i][hist_i]->GetName(),
                                      m_moduleHist[pattern_i][hist_i]).isFailure() ) {
                 return StatusCode::FAILURE;
              }
           }
        }
  
        unsigned int n_eta_phi_histograms = m_fillEtaPhiHistogramsPerPattern ? m_modulePattern.size() : 1;
        for (unsigned int pos_i=0; pos_i<m_defectModuleEtaPhiHist.size(); ++pos_i) {
           m_defectModuleEtaPhiHist.at(pos_i).resize(n_eta_phi_histograms, nullptr);
           m_defectModuleEtaLayerHist.at(pos_i).resize(n_eta_phi_histograms, nullptr);
        }
        std::array<std::string_view, kNPosHists> pos_hist_name {
           "defect_modules",
           "modules_with_defects"
        };
        std::array<std::string_view, kNPosHists> pos_hist_title {
           "Defect modules",
           "Modules with defects"
        };
        for (unsigned pattern_i=0; pattern_i< n_eta_phi_histograms; ++pattern_i) {
           for (unsigned int pos_i=0; pos_i<m_defectModuleEtaPhiHist.size(); ++pos_i) {
              {
                 HistUtil::StringCat a_name;
                 a_name << pos_hist_name.at(pos_i) << "_zr" << "_" << pattern_i;
                 HistUtil::StringCat a_title;
                 a_title << pos_hist_title.at(pos_i) << " vs global zr" << " ( module pattern " << pattern_i << ")";
                 {
                    HistUtil::ProtectHistogramCreation protect;
                    m_defectModuleEtaPhiHist.at(pos_i).at(pattern_i) = new TH2F(a_name.str().c_str(), a_title.str().c_str(),
                                                                                200, -3000, 3000,
                                                                                200, 0, 1050
                                                                                );
                 }
                 if ( m_histSvc->regHist(m_histogramGroupName.value() + m_defectModuleEtaPhiHist.at(pos_i).at(pattern_i)->GetName(),
                                         m_defectModuleEtaPhiHist.at(pos_i).at(pattern_i)).isFailure() ) {
                    return StatusCode::FAILURE;
                 }
              }
              {
                 HistUtil::StringCat a_name;
                 a_name << pos_hist_name.at(pos_i) << "_xy" << "_" << pattern_i;
                 HistUtil::StringCat a_title;
                 a_title << pos_hist_title.at(pos_i) << " vs global xy" << " ( module pattern " << pattern_i << ")";
                 {
                    HistUtil::ProtectHistogramCreation protect;
                    m_defectModuleEtaLayerHist.at(pos_i).at(pattern_i) = new TH2F(a_name.str().c_str(), a_title.str().c_str(),
                                                                                  200, -1050,1050,
                                                                                  200, -1050,1050
                                                                                  );
                 }
                 if ( m_histSvc->regHist(m_histogramGroupName.value() + m_defectModuleEtaLayerHist.at(pos_i).at(pattern_i)->GetName(),
                                         m_defectModuleEtaLayerHist.at(pos_i).at(pattern_i)).isFailure() ) {
                    return StatusCode::FAILURE;
                 }
              }
           }
        }
  
        if (n_masks>1) {
           m_maxNGroupDefects.resize( n_masks-1, 0u);
           for (const std::vector<std::vector<float> >  &fractions_per_pattern : m_perPatternAndMaskFractions) {
              for (unsigned int mask_i=0;  mask_i<n_masks-1; ++mask_i) {
                 m_maxNGroupDefects[mask_i] = std::max(m_maxNGroupDefects[mask_i], static_cast<unsigned int>(fractions_per_pattern[mask_i].size()));
              }
           }
  
           if (m_groupDefectHistNames.size() != n_masks-1) {
              ATH_MSG_FATAL("m_groupDefectHistNames does not contain a name per mask starting from the second mask "
                            "(the first mask must be the full matrix)");
              return StatusCode::FAILURE;
           }
           if (m_maxNGroupDefects.size() != n_masks-1) {
              ATH_MSG_FATAL("m_maxNGroupDefects does not contain a upper bin value for number of expected defects "
                            "per mask starting from the second mask (the first mask must be the full matrix)");
              return StatusCode::FAILURE;
           }
        }
     }
  
     return StatusCode::SUCCESS;
   }

◆ initializeCornerDefects()

StatusCode InDet::DefectsEmulatorCondAlgBase::initializeCornerDefects ( )

protectedinherited

Definition at line 443 of file DefectsEmulatorCondAlgBase.cxx.

                                                                   {
       if (!m_cornerDefectParamsPerPattern.empty()) {
         if (m_cornerDefectParamsPerPattern.size() != m_modulePattern.size()) {
            ATH_MSG_ERROR("Expected exactly one set of corner defect parameters per module pattern but the numbers disagree "
                          << m_cornerDefectParamsPerPattern.size() << " != " << m_modulePattern.size());
            return StatusCode::FAILURE;
         }
         if (m_cornerDefectParamsPerPattern.size() != m_cornerDefectNCornerFractionsPerPattern.size()) {
            ATH_MSG_ERROR("Expected exactly one set of n corner fractions per module pattern but the numbers disagree "
                          << m_cornerDefectParamsPerPattern.size() << " != " << m_cornerDefectNCornerFractionsPerPattern.size());
            return StatusCode::FAILURE;
         }
         m_perPatternCornerDefectNCornerCummulativeProb.resize( m_cornerDefectParamsPerPattern.size() );
         for (unsigned int pattern_i=0; pattern_i < m_cornerDefectParamsPerPattern.size(); ++pattern_i) {
            if (m_cornerDefectParamsPerPattern[pattern_i].empty()) continue;
            if (m_cornerDefectParamsPerPattern[pattern_i].size() != kNCornerDefectParams) {
               ATH_MSG_ERROR("Mismatch in number of corner defect parameters for pattern " << pattern_i << ". Expected " << kNCornerDefectParams
                             <<  " but got " << m_cornerDefectParamsPerPattern[pattern_i].size() );
               return StatusCode::FAILURE;
            }
            if (m_cornerDefectNCornerFractionsPerPattern[pattern_i].size()>4) {
               ATH_MSG_ERROR("Too many Fractions for corner defects for pattern " << pattern_i <<
                             ". Expected fractions for at most 4 corners but got " << m_cornerDefectNCornerFractionsPerPattern[pattern_i].size()
                             << ".");
               return StatusCode::FAILURE;
            }
            double scale = std::accumulate( m_cornerDefectNCornerFractionsPerPattern.value()[pattern_i].begin(),
                                            m_cornerDefectNCornerFractionsPerPattern.value()[pattern_i].end(),
                                            0.);
            if (std::abs(scale-1.)>1e-3) {
               ATH_MSG_ERROR("The fractions for corner defects in 1.." << m_cornerDefectNCornerFractionsPerPattern[pattern_i].size()
                             << " corner(s) for pattern " << pattern_i << " do not add up to ~1 but " << scale);
               return StatusCode::FAILURE;
            }
            m_perPatternCornerDefectNCornerCummulativeProb[pattern_i].reserve( m_cornerDefectNCornerFractionsPerPattern[pattern_i].size());
            scale = m_cornerDefectParamsPerPattern[pattern_i][kCornerDefectProb]/scale;
            double total = 0.;
            for (double fraction : m_cornerDefectNCornerFractionsPerPattern[pattern_i]) {
               total += fraction * scale;
               m_perPatternCornerDefectNCornerCummulativeProb[pattern_i].push_back( static_cast<float>(total) );
            }
         }
       }
       return StatusCode::SUCCESS;
    }

◆ initializeProbabilities()

StatusCode InDet::DefectsEmulatorCondAlgBase::initializeProbabilities ( unsigned int n_masks )

protectedinherited

Definition at line 373 of file DefectsEmulatorCondAlgBase.cxx.

                                                                                      {
      if (n_masks>1) {
         if (m_nDefectFractionsPerPattern.size() != m_modulePattern.size()) {
            ATH_MSG_ERROR("The number of fraction lists per pattern does not match the number of module patterns: "
                          << m_nDefectFractionsPerPattern.size() << " != " << m_modulePattern.size());
            return StatusCode::FAILURE;
         }
         if (m_defectProbability.size() != m_modulePattern.size()) {
            ATH_MSG_ERROR("The number of probability lists per pattern does not match the number of module patterns: "
                          << m_defectProbability.size() << " != " << m_modulePattern.size());
            return StatusCode::FAILURE;
         }
         m_perPatternAndMaskFractions.resize( m_nDefectFractionsPerPattern.size() );
         for (unsigned int pattern_i=0; pattern_i< m_perPatternAndMaskFractions.size(); ++pattern_i) {
            m_perPatternAndMaskFractions[pattern_i].reserve( n_masks-1);
            m_perPatternAndMaskFractions[pattern_i].emplace_back();
            if (m_defectProbability[pattern_i].size() != kCellDefectProb + n_masks) {
               ATH_MSG_ERROR("There should be one probability for the module to be defect, one probability for a pixel/strip etc. "
                             "to be defect and one probability for each group to be defect i.e. "
                             << (kCellDefectProb + n_masks) << " probabilities, but there are "
                             << m_defectProbability.size() << " for pattern " << pattern_i);
               return StatusCode::FAILURE;
            }
            double sum=0.;
            for (unsigned int value_i=0; value_i< m_nDefectFractionsPerPattern[pattern_i].size(); ++value_i) {
               if (m_nDefectFractionsPerPattern[pattern_i][value_i]<0.) {
                  if (value_i+1 < m_nDefectFractionsPerPattern[pattern_i].size()) {
                     if (m_perPatternAndMaskFractions[pattern_i].size() == n_masks-1) {
                        ATH_MSG_ERROR("More fraction lists than number of masks: "
                                      << m_perPatternAndMaskFractions[pattern_i].size()+1 << " > " << (n_masks-1)
                                      << " for pattern " << pattern_i);
                        return StatusCode::FAILURE;
                     }
                     m_perPatternAndMaskFractions[pattern_i].emplace_back();
                     sum=0.;
                  }
               }
               else {
                  sum += m_nDefectFractionsPerPattern[pattern_i][value_i];
                  m_perPatternAndMaskFractions[pattern_i].back().push_back(sum);
               }
            }
            for (unsigned int mask_i=0; mask_i< m_perPatternAndMaskFractions[pattern_i].size(); ++mask_i) {
               if (   m_perPatternAndMaskFractions[pattern_i][mask_i].empty()
                   || std::abs(m_perPatternAndMaskFractions[pattern_i][mask_i].back()-1.)>1e-5) {
                  ATH_MSG_ERROR("Empty fraction list or fractions do not add up to 1: "
                                << (!m_perPatternAndMaskFractions[pattern_i][mask_i].empty()
                                    ?m_perPatternAndMaskFractions[pattern_i][mask_i].back() : -1.f)
                                << " for pattern " << pattern_i << ", mask " << mask_i
                                << " (" << m_groupDefectHistNames.at(mask_i) << ")");
                  return StatusCode::FAILURE;
               }
               ATH_MSG_DEBUG("Fractions for pattern " << pattern_i << " mask " << mask_i
                            << " (" << m_groupDefectHistNames.at(mask_i) << "):"
                            << m_perPatternAndMaskFractions[pattern_i][mask_i]);
               assert( pattern_i < m_defectProbability.size() );
               assert( kNProb + mask_i < m_defectProbability[pattern_i].size() );
               for (float &value : m_perPatternAndMaskFractions[pattern_i][mask_i] ) {
                  value *= m_defectProbability[pattern_i][kNProb+mask_i];
               }
               ATH_MSG_DEBUG("Probabilities for pattern " << pattern_i << " mask " << mask_i
                            << " (" << m_groupDefectHistNames.at(mask_i) << ") for 1.."
                            << m_perPatternAndMaskFractions[pattern_i][mask_i].size() << " defects:"
                            << m_perPatternAndMaskFractions[pattern_i][mask_i]);
            }
         }
      }
      return checkProbabilities(kCellDefectProb+n_masks);
    }

◆ 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()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

 {
   // Reentrant algorithms are clonable.
   return true;
 }

◆ isModuleDefect()

bool InDet::StripDefectsEmulatorCondAlg::isModuleDefect	(	const EventContext &	ctx,
		unsigned int	id_hash
	)		const

inlineprotected

Alternative method to declare strip modules as defect.

If the module veto tool is enabled, the tool can be used alternatively to declare strip modules as defect.

Definition at line 63 of file StripDefectsEmulatorCondAlg.h.

                                                                                {
          return (m_moduleVetoTool.isEnabled() &&  !m_moduleVetoTool->isGood(id_hash, ctx));
       }

◆ makeCumulativeProbabilityDist()

void InDet::DefectsEmulatorCondAlgBase::makeCumulativeProbabilityDist	(	std::vector< unsigned int > &	module_pattern_idx,
		unsigned int	prob_idx,
		std::vector< double > &	cumulative_prob
	)		const

inlineprotectedinherited

Create a cumulative distribution from the referenced set of probabilities.

Parameters

module_pattern_idx	index of patterns for which the associated probabilities are to be considered
prob_idx	the index of the probability (e.g. module defect probability, single element defect probability)
cumulative_prob	output vector to be filled with the cumulative_distribution in ascending order Create a cumulative distributions using the specified probabilities associated to each pattern referenced by module_pattern_idx

Definition at line 147 of file DefectsEmulatorCondAlgBase.h.

                                                                                    {
          cumulative_prob.clear();
          double total_prob=0.f;
          for (unsigned int pattern_i : module_pattern_idx) {
             assert( prob_idx < m_defectProbability.value().at(pattern_i).size() );
             total_prob += m_defectProbability.value()[pattern_i][prob_idx];
             cumulative_prob.push_back(total_prob);
          }
       }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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.

◆ printSummaryOfDefectGeneration()

void InDet::DefectsEmulatorCondAlgBase::printSummaryOfDefectGeneration	(	unsigned int	n_masks,
		unsigned int	n_error,
		unsigned int	n_defects_total,
		const std::vector< std::array< unsigned int, kNCounts > > &	counts
	)		const

protectedinherited

Definition at line 263 of file DefectsEmulatorCondAlgBase.cxx.

                                                                                                                                   {
      assert(counts.size() == n_masks+1 );
      msg(MSG::INFO) << "Total cells: " << counts[0][kNElements] << ", module design of wrong type: " << n_error << ", defects "
                     << n_defects_total << ".\n";
      for (unsigned int mask_i=0; mask_i < counts.size(); ++mask_i) {
         msg() << "Defect " << (mask_i==0 ? "cells" : (mask_i>m_groupDefectHistNames.size() ? "modules" : m_groupDefectHistNames.at(mask_i-1)))
               << " " << counts[mask_i][kNDefects] << " / " << counts[mask_i][kNElements];
         if (counts[mask_i][kNRetries]>0 || counts[mask_i][kNMaxRtriesExceeded]>0) {
            msg() << "(";
            if (counts[mask_i][kNRetries]>0) {
               msg() << "retries " << counts[mask_i][kNRetries];
               if (counts[mask_i][kNMaxRtriesExceeded]>0) {
                  msg() << ";";
               }
            }
            if (counts[mask_i][kNMaxRtriesExceeded]>0) {
               msg() << "exceeded max attempts " << counts[mask_i][kNMaxRtriesExceeded];
            }
            msg() << ")";
         }
         if (counts[mask_i][kMaxDefectsPerModule]>0) {
            msg() << " max/module "  <<counts[mask_i][kMaxDefectsPerModule];
         }
         if (mask_i+1<counts.size()) {
            msg() << ".\n";
         }
      }
      msg() << endmsg;
   }

◆ 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed	(	bool	state,
		const EventContext &	ctx
	)		const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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 85 of file AthCommonReentrantAlgorithm.cxx.

 {
   return BaseAlg::sysExecute (ctx);
 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< 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

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.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.

◆ throwNumberOfDefects()

unsigned int InDet::DefectsEmulatorCondAlgBase::throwNumberOfDefects	(	std::span< CLHEP::HepRandomEngine * >	rndmEngine,
		const std::vector< unsigned int > &	module_pattern_idx,
		unsigned int	n_masks,
		unsigned int	n_cells,
		std::vector< unsigned int > &	n_mask_defects
	)		const

protectedinherited

Definition at line 218 of file DefectsEmulatorCondAlgBase.cxx.

   {
      n_mask_defects.clear();
      n_mask_defects.resize(n_masks, 0u);
  
      // to avoid throwing random numbers if not necessary
      // first identify the masks for which random numbers need to be thrown.
      std::vector<bool> has(n_masks, false);
      for (unsigned int mask_i=n_masks; mask_i-->1; ) {
         for (unsigned int match_i: module_pattern_idx) {
            assert(!m_perPatternAndMaskFractions.at(match_i).at(mask_i-1).empty());
            if (m_perPatternAndMaskFractions.at(match_i).at(mask_i-1).back()>0.) {
               has[mask_i]=true;
               break;
            }
         }
      }
  
      for (unsigned int mask_i=n_masks; mask_i-->1; ) {
         assert(mask_i>0 && mask_i<rndmEngine.size());
         float prob = !has.at(mask_i) ? 1. : CLHEP::RandFlat::shoot(rndmEngine[mask_i],1.);
  
         for (unsigned int match_i: module_pattern_idx) {
            unsigned int n_mask_defects_idx=m_perPatternAndMaskFractions.at(match_i).at(mask_i-1).size();
            for (; n_mask_defects_idx-->0 && prob <= m_perPatternAndMaskFractions[match_i][mask_i-1][n_mask_defects_idx];);
            if (++n_mask_defects_idx < m_perPatternAndMaskFractions[match_i][mask_i-1].size()) {
               n_mask_defects[mask_i] =  n_mask_defects_idx+1;
               break;
            }
  
            prob -= m_perPatternAndMaskFractions[match_i][mask_i-1].back();
            if (prob<=0.f) break;
         }
      }
      double defect_prob = totalProbability(module_pattern_idx,kCellDefectProb);
      n_mask_defects[0]= static_cast<unsigned int>(std::max(0,static_cast<int>(
                                                    CLHEP::RandPoisson::shoot(rndmEngine[0],
                                                                              n_cells * defect_prob))));
      return std::accumulate(n_mask_defects.begin(),n_mask_defects.end(), 0u);
   }

◆ totalProbability()

double InDet::DefectsEmulatorCondAlgBase::totalProbability	(	const std::vector< unsigned int > &	module_pattern_idx,
		unsigned int	prob_idx
	)		const

inlineprotectedinherited

Compute the total probability using the probabilities associated to the given list of patterns.

Parameters

module_pattern_idx	the index of the patterns
the	index of the probabilities to be used (e.g. module defect probability, single element defect probability)

Returns: sum of the referenced probabilities.

Definition at line 132 of file DefectsEmulatorCondAlgBase.h.

                                                                                                               {
          double total_prob=0;
          for (unsigned int pattern_i : module_pattern_idx) {
             assert( prob_idx < m_defectProbability.value().at(pattern_i).size() );
             total_prob += m_defectProbability.value()[pattern_i][prob_idx];
          }
          return total_prob;
       }

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

Friends And Related Function Documentation

◆ DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >

friend class DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >

friend

Definition at line 1 of file StripDefectsEmulatorCondAlg.h.

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/7]

std::vector<unsigned int> m_matrixTypeId InDet::DefectsEmulatorCondAlgBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 229 of file DefectsEmulatorCondAlgBase.h.

◆ ATLAS_THREAD_SAFE [2/7]

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

mutableprotectedinherited

Definition at line 230 of file DefectsEmulatorCondAlgBase.h.

◆ ATLAS_THREAD_SAFE [3/7]

std::vector< std::vector< TH2 *> > m_hist InDet::DefectsEmulatorCondAlgBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 232 of file DefectsEmulatorCondAlgBase.h.

◆ ATLAS_THREAD_SAFE [4/7]

std::vector< std::vector<std::vector< TH1 *> > > m_groupDefectHists InDet::DefectsEmulatorCondAlgBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 233 of file DefectsEmulatorCondAlgBase.h.

◆ ATLAS_THREAD_SAFE [5/7]

std::vector< std::vector< TH2 *> > m_moduleHist InDet::DefectsEmulatorCondAlgBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 234 of file DefectsEmulatorCondAlgBase.h.

◆ ATLAS_THREAD_SAFE [6/7]

std::array<std::vector<TH2 *>,kNPosHists> m_defectModuleEtaPhiHist InDet::DefectsEmulatorCondAlgBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 241 of file DefectsEmulatorCondAlgBase.h.

◆ ATLAS_THREAD_SAFE [7/7]

std::array<std::vector<TH2 *>,kNPosHists> m_defectModuleEtaLayerHist InDet::DefectsEmulatorCondAlgBase::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 242 of file DefectsEmulatorCondAlgBase.h.

◆ m_checkerBoardToggle

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_checkerBoardToggle {this, "CheckerBoardDefects", false}

protectedinherited

Definition at line 80 of file DefectsEmulatorCondAlgBase.h.

◆ m_cornerDefectNCornerFractionsPerPattern

Gaudi::Property<std::vector<std::vector<double> > > InDet::DefectsEmulatorCondAlgBase::m_cornerDefectNCornerFractionsPerPattern

protectedinherited

Initial value:

{this,"NCornerDefectFractionsPerPattern", {},

"List of fractions per pattern for exactly 1 to 4 corner defects under the codition that there is a defect." }

Definition at line 64 of file DefectsEmulatorCondAlgBase.h.

◆ m_cornerDefectParamsPerPattern

Gaudi::Property<std::vector<std::vector<double> > > InDet::DefectsEmulatorCondAlgBase::m_cornerDefectParamsPerPattern

protectedinherited

Initial value:

{this,"CornerDefectParamsPerPattern", {},
         "Set of corner defect parameters (probability, x-intersection pos min, max, y-intersection pos min, max, sagitta minm max). "
         "per module pattern.  " }

Definition at line 60 of file DefectsEmulatorCondAlgBase.h.

◆ m_defectProbability

Gaudi::Property<std::vector<std::vector<double> > > InDet::DefectsEmulatorCondAlgBase::m_defectProbability

protectedinherited

Initial value:

{this,"DefectProbabilities", {},

"Defect probabilities per module pattern: defect module, defect strip." }

Definition at line 53 of file DefectsEmulatorCondAlgBase.h.

◆ m_detEleCollKey

SG::ReadCondHandleKey<T_DetectorElementCollection> InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::m_detEleCollKey

protectedinherited

Definition at line 51 of file DefectsEmulatorCondAlgImpl.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_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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_fillEtaPhiHistogramsPerPattern

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_fillEtaPhiHistogramsPerPattern {this, "FillEtaPhiHistogramsPerPattern", false, "If true, histogram per eta, phi amd z, R are filled separately per pattern."}

protectedinherited

Definition at line 90 of file DefectsEmulatorCondAlgBase.h.

◆ m_fillHistogramsPerPattern

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_fillHistogramsPerPattern {this, "FillHistogramsPerPattern", false, "If true, histogram per module defects etc. separately per pattern."}

protectedinherited

Definition at line 88 of file DefectsEmulatorCondAlgBase.h.

◆ m_groupDefectHistNames

std::vector<std::string> InDet::DefectsEmulatorCondAlgBase::m_groupDefectHistNames

protectedinherited

Definition at line 225 of file DefectsEmulatorCondAlgBase.h.

◆ m_histMutex

std::mutex InDet::DefectsEmulatorCondAlgBase::m_histMutex

mutableprotectedinherited

Definition at line 227 of file DefectsEmulatorCondAlgBase.h.

◆ m_histogramGroupName

Gaudi::Property<std::string> InDet::DefectsEmulatorCondAlgBase::m_histogramGroupName {this,"HistogramGroupName","", "Histogram group name or empty to disable histogramming"}

protectedinherited

Definition at line 86 of file DefectsEmulatorCondAlgBase.h.

◆ m_histogrammingEnabled

bool InDet::DefectsEmulatorCondAlgBase::m_histogrammingEnabled = false

protectedinherited

Definition at line 253 of file DefectsEmulatorCondAlgBase.h.

◆ m_histSvc

ServiceHandle<ITHistSvc> InDet::DefectsEmulatorCondAlgBase::m_histSvc {this,"HistSvc","THistSvc"}

protectedinherited

Definition at line 85 of file DefectsEmulatorCondAlgBase.h.

◆ m_idHelper

const T_ID* InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::m_idHelper

protectedinherited

Definition at line 60 of file DefectsEmulatorCondAlgImpl.h.

◆ m_idName

Gaudi::Property<std::string> InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::m_idName

protectedinherited

Definition at line 57 of file DefectsEmulatorCondAlgImpl.h.

◆ m_inputFiles

Gaudi::Property<std::vector<std::string> > InDet::DefectsEmulatorCondAlgBase::m_inputFiles {this,"DefectsInputFiles",{}, "Empty or file name to write out conditions data (.json or .root)."}

protectedinherited

Definition at line 95 of file DefectsEmulatorCondAlgBase.h.

◆ m_maxAttempts

Gaudi::Property<unsigned int> InDet::DefectsEmulatorCondAlgBase::m_maxAttempts {this, "MaxRandomPositionAttempts", 10}

protectedinherited

Definition at line 82 of file DefectsEmulatorCondAlgBase.h.

◆ m_maxNGroupDefects

std::vector<unsigned int> InDet::DefectsEmulatorCondAlgBase::m_maxNGroupDefects

protectedinherited

Definition at line 226 of file DefectsEmulatorCondAlgBase.h.

◆ m_modulePattern

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

protectedinherited

Initial value:

{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)" }

Definition at line 49 of file DefectsEmulatorCondAlgBase.h.

◆ m_modulesWithoutDefectParameters

std::atomic<unsigned int> InDet::DefectsEmulatorCondAlgBase::m_modulesWithoutDefectParameters {}

mutableprotectedinherited

Definition at line 251 of file DefectsEmulatorCondAlgBase.h.

◆ m_moduleVetoTool

ToolHandle<ISCT_ConditionsTool> InDet::StripDefectsEmulatorCondAlg::m_moduleVetoTool {this,"SCTConditionsTool","","Optional SCT conditions tool to mark modules as defect (alternative to ModulePattern)"}

protected

Definition at line 48 of file StripDefectsEmulatorCondAlg.h.

◆ m_nDefectFractionsPerPattern

Gaudi::Property<std::vector<std::vector<double> > > InDet::DefectsEmulatorCondAlgBase::m_nDefectFractionsPerPattern

protectedinherited

Initial value:

{this,"NDefectFractionsPerPattern", {},
         "List of fractions per pattern for exactly 1 to n  defects under the codition that there is a defect, where -1. marks the"
         "end of this lists, before the fractions for the next mask start." }

Definition at line 56 of file DefectsEmulatorCondAlgBase.h.

◆ m_oddColToggle

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_oddColToggle {this, "OddColToggle", false}

protectedinherited

Definition at line 78 of file DefectsEmulatorCondAlgBase.h.

◆ m_oddRowToggle

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_oddRowToggle {this, "OddRowToggle", false}

protectedinherited

Definition at line 76 of file DefectsEmulatorCondAlgBase.h.

◆ m_outputFile

Gaudi::Property<std::string> InDet::DefectsEmulatorCondAlgBase::m_outputFile {this,"DefectsOutputFile","", "Empty or file name to write out conditions data (.json or .root)."}

protectedinherited

Definition at line 93 of file DefectsEmulatorCondAlgBase.h.

◆ m_perPatternAndMaskFractions

std::vector<std::vector<std::vector<float> > > InDet::DefectsEmulatorCondAlgBase::m_perPatternAndMaskFractions

protectedinherited

Definition at line 68 of file DefectsEmulatorCondAlgBase.h.

◆ m_perPatternCornerDefectNCornerCummulativeProb

std::vector<std::vector<float> > InDet::DefectsEmulatorCondAlgBase::m_perPatternCornerDefectNCornerCummulativeProb

protectedinherited

Definition at line 69 of file DefectsEmulatorCondAlgBase.h.

◆ m_rndmSvc

ServiceHandle<IAthRNGSvc> InDet::DefectsEmulatorCondAlgBase::m_rndmSvc {this, "RndmSvc", "AthRNGSvc", ""}

protectedinherited

Definition at line 47 of file DefectsEmulatorCondAlgBase.h.

◆ m_rngName

std::vector<std::string> InDet::DefectsEmulatorCondAlgBase::m_rngName

protectedinherited

Definition at line 98 of file DefectsEmulatorCondAlgBase.h.

◆ m_rngPerDefectType

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_rngPerDefectType {this, "RngPerDefectType", false, "One RNG per defect type to decorrelate randomness of defects."}

protectedinherited

Definition at line 71 of file DefectsEmulatorCondAlgBase.h.

◆ 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.

◆ m_writeKey

SG::WriteCondHandleKey<T_EmulatedDefects> InDet::DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >::m_writeKey

protectedinherited

Definition at line 54 of file DefectsEmulatorCondAlgImpl.h.

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

Public Types
using	T_ID = detail::DetectorEmulatorCondAlgTraits< StripDefectsEmulatorCondAlg >::T_ID

using	T_ModuleHelper = detail::DetectorEmulatorCondAlgTraits< StripDefectsEmulatorCondAlg >::T_ModuleHelper

using	T_EmulatedDefects = detail::DetectorEmulatorCondAlgTraits< StripDefectsEmulatorCondAlg >::T_EmulatedDefects

using	T_DetectorElementCollection = detail::DetectorEmulatorCondAlgTraits< StripDefectsEmulatorCondAlg >::T_DetectorElementCollection

using	T_ModuleDesign = detail::DetectorEmulatorCondAlgTraits< StripDefectsEmulatorCondAlg >::T_ModuleDesign

Protected Types
enum	DefectTypes { kModuleDefects, kCornerDefects, kMaskDefects }

enum	EProbabilities { kModuleDefectProb, kCellDefectProb, kNProb }

enum	ECornerDefectParams { kCornerDefectProb, kCornerDefectWidthColumnDirectionOffset, kCornerDefectWidthColumnDirection, kCornerDefectkWidthRowDirectionOffset, kCornerDefectkWidthRowDirection, kCornerDefectkSagittaOffset, kCornerDefectkSagitta, kNCornerDefectParams }

enum	ECounts { kNElements, kNDefects, kNRetries, kNMaxRtriesExceeded, kNModulesWithDefects, kMaxDefectsPerModule, kNCounts }

enum	EPosHistType { kDefectModulePos, kModulesWithDefectsPos, kNPosHists }

enum	EPerModuleHistType { kMatrixTypeId, kDefectModule, kDefectCell, kNPerModuleHistTypes }

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ T_DetectorElementCollection

◆ T_EmulatedDefects

◆ T_ID

◆ T_ModuleDesign

◆ T_ModuleHelper

Member Enumeration Documentation

◆ DefectTypes

◆ ECornerDefectParams

◆ ECounts

◆ EPerModuleHistType

◆ EPosHistType

◆ EProbabilities

Member Function Documentation

◆ cardinality()

◆ checkProbabilities()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ DefectsEmulatorCondAlgBase()

◆ derived()

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ fillPerModuleHistograms()

◆ filterPassed()

◆ finalize()

◆ findHist()

◆ getModuleConnectionMap()

◆ histogramDefectModule()

◆ IDName()

◆ initialize()

◆ initializeBase()

◆ initializeCornerDefects()

◆ initializeProbabilities()

◆ inputHandles()

◆ isClonable()

◆ isModuleDefect()

◆ makeCumulativeProbabilityDist()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ printSummaryOfDefectGeneration()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ throwNumberOfDefects()

◆ totalProbability()

◆ updateVHKA()

Friends And Related Function Documentation

◆ DefectsEmulatorCondAlgImpl< StripDefectsEmulatorCondAlg >

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/7]

◆ ATLAS_THREAD_SAFE [2/7]