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

#include <PixelDefectsEmulatorCondAlg.h>

Inheritance diagram for InDet::PixelDefectsEmulatorCondAlg:

Collaboration diagram for InDet::PixelDefectsEmulatorCondAlg:

Public Types
using	T_ID
using	T_ModuleHelper
using	T_EmulatedDefects
using	T_DetectorElementCollection
using	T_ModuleDesign

Public Member Functions
virtual StatusCode	initialize () override final
	DefectsEmulatorCondAlgBase (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
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`.
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

Protected Types
enum	DefectTypes
enum	EProbabilities
enum	ECornerDefectParams
enum	ECounts
enum	EPosHistType
enum	EPerModuleHistType

Protected Member Functions
const PixelDefectsEmulatorCondAlg &	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.
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.
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.
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
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.

Static Protected Member Functions
static std::string	IDName ()
	The name of the PixelID identifier utility.
static std::unordered_multimap< unsigned int, unsigned int >	getModuleConnectionMap (const InDetDD::SiDetectorElementCollection &det_ele)
	Get the map which defines which modules are connected to the same physical sensor.
static bool	isModuleDefect (const EventContext &ctx, unsigned int id_hash)
	Provide alternative method to mark modules as defect.

Protected Attributes
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
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
Gaudi::Property< bool >	m_oddRowToggle
Gaudi::Property< bool >	m_oddColToggle
Gaudi::Property< bool >	m_checkerBoardToggle
Gaudi::Property< unsigned int >	m_maxAttempts
ServiceHandle< ITHistSvc >	m_histSvc
Gaudi::Property< std::string >	m_histogramGroupName
Gaudi::Property< bool >	m_fillHistogramsPerPattern
Gaudi::Property< bool >	m_fillEtaPhiHistogramsPerPattern
Gaudi::Property< std::string >	m_outputFile
Gaudi::Property< std::vector< std::string > >	m_inputFiles
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

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

Friends
class	DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >

Detailed Description

Conditions algorithms for emulating ITK pixel defects.

The algorithm mask random pixels, core columns (group of 8 or 4 consecutive columns of a chip), circuits or modules as defect. This data can be used to reject RDOs overlapping with these defects.

Definition at line 35 of file PixelDefectsEmulatorCondAlg.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< PixelDefectsEmulatorCondAlg >::T_DetectorElementCollection

inherited

Definition at line 40 of file DefectsEmulatorCondAlgImpl.h.

◆ T_EmulatedDefects

using InDet::DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >::T_EmulatedDefects

inherited

Definition at line 39 of file DefectsEmulatorCondAlgImpl.h.

◆ T_ID

using InDet::DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >::T_ID

inherited

Definition at line 37 of file DefectsEmulatorCondAlgImpl.h.

◆ T_ModuleDesign

using InDet::DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >::T_ModuleDesign

inherited

Definition at line 41 of file DefectsEmulatorCondAlgImpl.h.

◆ T_ModuleHelper

using InDet::DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >::T_ModuleHelper

inherited

Definition at line 38 of file DefectsEmulatorCondAlgImpl.h.

Member Enumeration Documentation

◆ DefectTypes

enum InDet::DefectsEmulatorCondAlgBase::DefectTypes

protectedinherited

Definition at line 100 of file DefectsEmulatorCondAlgBase.h.

                       {
         kModuleDefects,
         kCornerDefects,
         kMaskDefects
      };

◆ ECornerDefectParams

enum InDet::DefectsEmulatorCondAlgBase::ECornerDefectParams

protectedinherited

Definition at line 112 of file DefectsEmulatorCondAlgBase.h.

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

◆ ECounts

enum InDet::DefectsEmulatorCondAlgBase::ECounts

protectedinherited

Definition at line 159 of file DefectsEmulatorCondAlgBase.h.

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

◆ EPerModuleHistType

enum InDet::DefectsEmulatorCondAlgBase::EPerModuleHistType

protectedinherited

Definition at line 244 of file DefectsEmulatorCondAlgBase.h.

                              {
         kMatrixTypeId,
         kDefectModule,
         kDefectCell,
         kNPerModuleHistTypes
      };

◆ EPosHistType

enum InDet::DefectsEmulatorCondAlgBase::EPosHistType

protectedinherited

Definition at line 236 of file DefectsEmulatorCondAlgBase.h.

                        {
         kDefectModulePos,
         kModulesWithDefectsPos,
         kNPosHists
      };

◆ EProbabilities

enum InDet::DefectsEmulatorCondAlgBase::EProbabilities

protectedinherited

Definition at line 106 of file DefectsEmulatorCondAlgBase.h.

                          {
         kModuleDefectProb,
         kCellDefectProb,
         kNProb
      };

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

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

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

◆ DefectsEmulatorCondAlgBase()

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

inherited

◆ derived()

const PixelDefectsEmulatorCondAlg & InDet::DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >::derived ( ) const

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

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::DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >::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 ( ) const

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 215 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 40 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 203 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::PixelDefectsEmulatorCondAlg::getModuleConnectionMap ( const InDetDD::SiDetectorElementCollection & det_ele )

inlinestaticprotected

Get the map which defines which modules are connected to the same physical sensor.

For pixel each physical sensor is connected to exactly one module, so an empty map is returned.

Definition at line 54 of file PixelDefectsEmulatorCondAlg.h.

                                                                                                                                                          {
         return std::unordered_multimap<unsigned int, unsigned int> ();
      }

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

std::string InDet::PixelDefectsEmulatorCondAlg::IDName ( )

inlinestaticprotected

The name of the PixelID identifier utility.

Definition at line 48 of file PixelDefectsEmulatorCondAlg.h.

48{ return std::string("PixelID"); }

◆ initialize()

StatusCode InDet::PixelDefectsEmulatorCondAlg::initialize ( )

finaloverridevirtual

Reimplemented from InDet::DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >.

Definition at line 10 of file PixelDefectsEmulatorCondAlg.cxx.

                                                    {
 
    m_groupDefectHistNames.clear();
    m_groupDefectHistNames.push_back("core-column");
    m_groupDefectHistNames.push_back("circuit");
    // set upper edge of the 1D number of group defects (core-column, circuit) histograms
    m_maxNGroupDefects.clear();
    m_maxNGroupDefects.push_back(10);
    m_maxNGroupDefects.push_back(4);
    return DefectsEmulatorCondAlgImpl<PixelDefectsEmulatorCondAlg>::initialize();
  }

◆ initializeBase()

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

protectedinherited

Definition at line 43 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 45 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 44 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() );
 
        // there should be one vector with fractions for each mask 0:cell, 1:1st group mask, ...
        for (unsigned int pattern_i=0; pattern_i< m_perPatternAndMaskFractions.size(); ++pattern_i) {
           m_perPatternAndMaskFractions[pattern_i].reserve( n_masks);
           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) {
                       ATH_MSG_ERROR("More fraction lists than number of masks: "
                                     << m_perPatternAndMaskFractions[pattern_i].size()+1 << " > " << (n_masks)
                                     << " 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);
              }
           }
           std::vector<std::string> defect_names;
           assert( 1+m_groupDefectHistNames.size() == n_masks);
           defect_names.resize( 1+m_groupDefectHistNames.size() );
           defect_names[0]="cell";
           std::copy(m_groupDefectHistNames.begin(), m_groupDefectHistNames.end(), defect_names.begin()+1);
 
           // mask_i:  0: cell, 1: first group,  ...
           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
                               << " (" << defect_names.at(mask_i) << ")");
                 return StatusCode::FAILURE;
              }
              ATH_MSG_DEBUG("Fractions for pattern " << pattern_i << " mask " << mask_i
                           << " (" << defect_names.at(mask_i) << "):"
                           << m_perPatternAndMaskFractions[pattern_i][mask_i]);
              assert( pattern_i < m_defectProbability.size() );
              assert( kCellDefectProb + mask_i < m_defectProbability[pattern_i].size() );
              if (mask_i>0) {
                 // only scale the fractions to the total probability to have at least one defect
                 // for group defects.
                 // For cell defects the fractions mean fractions for group sizes 1,2, ....
                 for (float &value : m_perPatternAndMaskFractions[pattern_i][mask_i] ) {
                    value *= m_defectProbability[pattern_i][kCellDefectProb+mask_i];
                 }
              }
              ATH_MSG_DEBUG("Probabilities for pattern " << pattern_i << " mask " << mask_i
                           << " (" << defect_names.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 ( ) const

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::PixelDefectsEmulatorCondAlg::isModuleDefect	(	const EventContext &	ctx,
		unsigned int	id_hash )

inlinestaticprotected

Provide alternative method to mark modules as defect.

For pixel there is no alternative method. So, no module is marked as defect by this method.

Definition at line 60 of file PixelDefectsEmulatorCondAlg.h.

                                                                                                                {
         return false;
      }

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

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.

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

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 178 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).empty());
           if (m_perPatternAndMaskFractions.at(match_i).at(mask_i).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).size();
           for (; n_mask_defects_idx-->0 && prob <= m_perPatternAndMaskFractions[match_i][mask_i][n_mask_defects_idx];);
           if (++n_mask_defects_idx < m_perPatternAndMaskFractions[match_i][mask_i].size()) {
              n_mask_defects[mask_i] =  n_mask_defects_idx+1;
              break;
           }
 
           prob -= m_perPatternAndMaskFractions[match_i][mask_i].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);
      }
    }
  }

◆ DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >

friend class DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >

friend

Definition at line 1 of file PixelDefectsEmulatorCondAlg.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

protectedinherited

Definition at line 80 of file DefectsEmulatorCondAlgBase.h.

81{this, "CheckerBoardDefects", false};

◆ m_cornerDefectNCornerFractionsPerPattern

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

protectedinherited

Definition at line 64 of file DefectsEmulatorCondAlgBase.h.

65 {this,"NCornerDefectFractionsPerPattern", {},

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

◆ m_cornerDefectParamsPerPattern

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

protectedinherited

Definition at line 60 of file DefectsEmulatorCondAlgBase.h.

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

◆ m_defectProbability

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

protectedinherited

Definition at line 53 of file DefectsEmulatorCondAlgBase.h.

54 {this,"DefectProbabilities", {},

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

◆ m_detEleCollKey

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

protectedinherited

Definition at line 51 of file DefectsEmulatorCondAlgImpl.h.

52{this, "DetEleCollKey", "", "Key of SiDetectorElementCollection"};

◆ 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

protectedinherited

Definition at line 90 of file DefectsEmulatorCondAlgBase.h.

91{this, "FillEtaPhiHistogramsPerPattern", false, "If true, histogram per eta, phi amd z, R are filled separately per pattern."};

◆ m_fillHistogramsPerPattern

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_fillHistogramsPerPattern

protectedinherited

Definition at line 88 of file DefectsEmulatorCondAlgBase.h.

89{this, "FillHistogramsPerPattern", false, "If true, histogram per module defects etc. separately per pattern."};

◆ 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

protectedinherited

Definition at line 86 of file DefectsEmulatorCondAlgBase.h.

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

◆ m_histogrammingEnabled

bool InDet::DefectsEmulatorCondAlgBase::m_histogrammingEnabled

protectedinherited

Definition at line 253 of file DefectsEmulatorCondAlgBase.h.

◆ m_histSvc

ServiceHandle<ITHistSvc> InDet::DefectsEmulatorCondAlgBase::m_histSvc

protectedinherited

Definition at line 85 of file DefectsEmulatorCondAlgBase.h.

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

◆ m_idHelper

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

protectedinherited

Definition at line 60 of file DefectsEmulatorCondAlgImpl.h.

◆ m_idName

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

protectedinherited

Definition at line 57 of file DefectsEmulatorCondAlgImpl.h.

58{this, "IDName", "", "Name of the ID tool to decode identifiers"};

◆ m_inputFiles

Gaudi::Property<std::vector<std::string> > InDet::DefectsEmulatorCondAlgBase::m_inputFiles

protectedinherited

Definition at line 95 of file DefectsEmulatorCondAlgBase.h.

96{this,"DefectsInputFiles",{}, "Empty or file name to write out conditions data (.json or .root)."};

◆ m_maxAttempts

Gaudi::Property<unsigned int> InDet::DefectsEmulatorCondAlgBase::m_maxAttempts

protectedinherited

Definition at line 82 of file DefectsEmulatorCondAlgBase.h.

83{this, "MaxRandomPositionAttempts", 10};

◆ 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

Definition at line 49 of file DefectsEmulatorCondAlgBase.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_modulesWithoutDefectParameters

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

mutableprotectedinherited

Definition at line 251 of file DefectsEmulatorCondAlgBase.h.

251{};

◆ m_nDefectFractionsPerPattern

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

protectedinherited

Definition at line 56 of file DefectsEmulatorCondAlgBase.h.

         {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." };

◆ m_oddColToggle

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_oddColToggle

protectedinherited

Definition at line 78 of file DefectsEmulatorCondAlgBase.h.

79{this, "OddColToggle", false};

◆ m_oddRowToggle

Gaudi::Property<bool> InDet::DefectsEmulatorCondAlgBase::m_oddRowToggle

protectedinherited

Definition at line 76 of file DefectsEmulatorCondAlgBase.h.

77{this, "OddRowToggle", false};

◆ m_outputFile

Gaudi::Property<std::string> InDet::DefectsEmulatorCondAlgBase::m_outputFile

protectedinherited

Definition at line 93 of file DefectsEmulatorCondAlgBase.h.

94{this,"DefectsOutputFile","", "Empty or file name to write out conditions data (.json or .root)."};

◆ 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

protectedinherited

Definition at line 47 of file DefectsEmulatorCondAlgBase.h.

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

◆ 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

protectedinherited

Definition at line 71 of file DefectsEmulatorCondAlgBase.h.

72{this, "RngPerDefectType", false, "One RNG per defect type to decorrelate randomness of defects."};

◆ 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< PixelDefectsEmulatorCondAlg >::m_writeKey

protectedinherited

Definition at line 54 of file DefectsEmulatorCondAlgImpl.h.

55{this, "WriteKey", "", "Key of output emulated defect conditions data"};

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

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

◆ declareProperty()

◆ DefectsEmulatorCondAlgBase()

◆ derived()

◆ detStore()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ fillPerModuleHistograms()

◆ filterPassed()

◆ finalize()

◆ findHist()

◆ getModuleConnectionMap()

◆ histogramDefectModule()

◆ IDName()

◆ initialize()

◆ initializeBase()

◆ initializeCornerDefects()

◆ initializeProbabilities()

◆ inputHandles()

◆ isClonable()

◆ isModuleDefect()

◆ makeCumulativeProbabilityDist()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ printSummaryOfDefectGeneration()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ throwNumberOfDefects()

◆ totalProbability()

◆ updateVHKA()

Friends And Related Symbol Documentation

◆ DefectsEmulatorCondAlgImpl< PixelDefectsEmulatorCondAlg >

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/7]

◆ ATLAS_THREAD_SAFE [2/7]

◆ ATLAS_THREAD_SAFE [3/7]

◆ ATLAS_THREAD_SAFE [4/7]

◆ ATLAS_THREAD_SAFE [5/7]

◆ ATLAS_THREAD_SAFE [6/7]

◆ ATLAS_THREAD_SAFE [7/7]

◆ m_checkerBoardToggle

◆ m_cornerDefectNCornerFractionsPerPattern

◆ m_cornerDefectParamsPerPattern

◆ m_defectProbability

◆ m_detEleCollKey