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

#include <DefectsEmulatorCondAlgBase.h>

Inheritance diagram for InDet::DefectsEmulatorCondAlgBase:

Public Member Functions
	DefectsEmulatorCondAlgBase (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~DefectsEmulatorCondAlgBase () override=default
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 { 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 }

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

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

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

Detailed Description

Conditions algorithms for emulating ITK pixel defects.

The algorithm mask random pixels and core columns (group of 8 consecutive columns of a chip) as defect. This data can be used to reject hits associated to these pixels or core columns.

Definition at line 34 of file DefectsEmulatorCondAlgBase.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DefectTypes

enum InDet::DefectsEmulatorCondAlgBase::DefectTypes

protected

Enumerator
kModuleDefects
kCornerDefects
kMaskDefects

Definition at line 100 of file DefectsEmulatorCondAlgBase.h.

                       {
         kModuleDefects,
         kCornerDefects,
         kMaskDefects
      };

◆ ECornerDefectParams

enum InDet::DefectsEmulatorCondAlgBase::ECornerDefectParams

protected

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

protected

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

protected

Enumerator
kMatrixTypeId
kDefectModule
kDefectCell
kNPerModuleHistTypes

Definition at line 244 of file DefectsEmulatorCondAlgBase.h.

                              {
         kMatrixTypeId,
         kDefectModule,
         kDefectCell,
         kNPerModuleHistTypes
      };

◆ EPosHistType

enum InDet::DefectsEmulatorCondAlgBase::EPosHistType

protected

Enumerator
kDefectModulePos
kModulesWithDefectsPos
kNPosHists

Definition at line 236 of file DefectsEmulatorCondAlgBase.h.

                        {
         kDefectModulePos,
         kModulesWithDefectsPos,
         kNPosHists
      };

◆ EProbabilities

enum InDet::DefectsEmulatorCondAlgBase::EProbabilities

protected

Enumerator
kModuleDefectProb
kCellDefectProb
kNProb

Definition at line 106 of file DefectsEmulatorCondAlgBase.h.

                          {
         kModuleDefectProb,
         kCellDefectProb,
         kNProb
      };

Constructor & Destructor Documentation

◆ DefectsEmulatorCondAlgBase()

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

Definition at line 23 of file DefectsEmulatorCondAlgBase.cxx.

24 : AthReentrantAlgorithm(name, pSvcLocator)

25 {}

◆ ~DefectsEmulatorCondAlgBase()

virtual InDet::DefectsEmulatorCondAlgBase::~DefectsEmulatorCondAlgBase ( )

overridevirtualdefault

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

protected

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

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

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

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

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

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

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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

protected

Definition at line 519 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 ( )

overridevirtual

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

protected

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

◆ histogramDefectModule()

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

protected

Definition at line 504 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());
  }

◆ initializeBase()

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

protected

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

protected

Definition at line 457 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 )

protected

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() );
 
        // 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.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

◆ makeCumulativeProbabilityDist()

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

inlineprotected

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

protected

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 HypoBase, and InputMakerBase.

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

protected

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

inlineprotected

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

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/7]

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

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

Definition at line 242 of file DefectsEmulatorCondAlgBase.h.

◆ m_checkerBoardToggle

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

protected

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

protected

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.

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

protected

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.

         {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

protected

Initial value:

{this,"DefectProbabilities", {},

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

Definition at line 53 of file DefectsEmulatorCondAlgBase.h.

54 {this,"DefectProbabilities", {},

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

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

protected

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 {this, "FillHistogramsPerPattern", false, "If true, histogram per module defects etc. separately per pattern."}

protected

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

protected

Definition at line 225 of file DefectsEmulatorCondAlgBase.h.

◆ m_histMutex

std::mutex InDet::DefectsEmulatorCondAlgBase::m_histMutex

mutableprotected

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

protected

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

protected

Definition at line 253 of file DefectsEmulatorCondAlgBase.h.

◆ m_histSvc

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

protected

Definition at line 85 of file DefectsEmulatorCondAlgBase.h.

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

◆ 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)."}

protected

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 {this, "MaxRandomPositionAttempts", 10}

protected

Definition at line 82 of file DefectsEmulatorCondAlgBase.h.

83{this, "MaxRandomPositionAttempts", 10};

◆ m_maxNGroupDefects

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

protected

Definition at line 226 of file DefectsEmulatorCondAlgBase.h.

◆ m_modulePattern

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

protected

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.

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

mutableprotected

Definition at line 251 of file DefectsEmulatorCondAlgBase.h.

251{};

◆ m_nDefectFractionsPerPattern

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

protected

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.

         {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 {this, "OddColToggle", false}

protected

Definition at line 78 of file DefectsEmulatorCondAlgBase.h.

79{this, "OddColToggle", false};

◆ m_oddRowToggle

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

protected

Definition at line 76 of file DefectsEmulatorCondAlgBase.h.

77{this, "OddRowToggle", false};

◆ m_outputFile

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

protected

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

protected

Definition at line 68 of file DefectsEmulatorCondAlgBase.h.

◆ m_perPatternCornerDefectNCornerCummulativeProb

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

protected

Definition at line 69 of file DefectsEmulatorCondAlgBase.h.

◆ m_rndmSvc

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

protected

Definition at line 47 of file DefectsEmulatorCondAlgBase.h.

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

◆ m_rngName

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

protected

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

protected

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.

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

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ DefectTypes

◆ ECornerDefectParams

◆ ECounts

◆ EPerModuleHistType

◆ EPosHistType

◆ EProbabilities

Constructor & Destructor Documentation

◆ DefectsEmulatorCondAlgBase()

◆ ~DefectsEmulatorCondAlgBase()

Member Function Documentation

◆ cardinality()

◆ checkProbabilities()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ fillPerModuleHistograms()

◆ filterPassed()

◆ finalize()

◆ findHist()

◆ histogramDefectModule()

◆ initializeBase()

◆ initializeCornerDefects()

◆ initializeProbabilities()

◆ inputHandles()

◆ isClonable()

◆ makeCumulativeProbabilityDist()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ printSummaryOfDefectGeneration()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ throwNumberOfDefects()

◆ totalProbability()

◆ updateVHKA()

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_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_fillEtaPhiHistogramsPerPattern

◆ m_fillHistogramsPerPattern

◆ m_groupDefectHistNames

◆ m_histMutex

◆ m_histogramGroupName

◆ m_histogrammingEnabled

◆ m_histSvc

◆ m_inputFiles

◆ m_maxAttempts

◆ m_maxNGroupDefects

◆ m_modulePattern

◆ m_modulesWithoutDefectParameters