ATLAS Offline Software
Public Types | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
PixelAthErrorMonAlg Class Reference

#include <PixelAthErrorMonAlg.h>

Inheritance diagram for PixelAthErrorMonAlg:
Collaboration diagram for PixelAthErrorMonAlg:

Public Types

enum  Environment_t {
  Environment_t::user = 0, Environment_t::online, Environment_t::tier0, Environment_t::tier0Raw,
  Environment_t::tier0ESD, Environment_t::AOD, Environment_t::altprod
}
 Specifies the processing environment. More...
 
enum  DataType_t {
  DataType_t::userDefined = 0, DataType_t::monteCarlo, DataType_t::collisions, DataType_t::cosmics,
  DataType_t::heavyIonCollisions
}
 Specifies what type of input data is being monitored. More...
 

Public Member Functions

 PixelAthErrorMonAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~PixelAthErrorMonAlg ()
 
virtual StatusCode initialize () override
 initialize More...
 
virtual StatusCode fillHistograms (const EventContext &ctx) const override
 adds event to the monitoring histograms More...
 
std::string findComponentString (int bec, int ld) const
 
int getErrorCategory (int error_cat_rodmod) const
 
std::bitset< kNumErrorStatesFEI3 > getErrorStateFEI3Mod (uint64_t errorword) const
 
std::bitset< kNumErrorStatesFEI3 > getErrorStateFE (uint64_t errorword, bool isibl) const
 
void fillErrorCatRODmod (uint64_t mod_errorword, int(&nerrors_cat_rodmod)[ErrorCategoryRODMOD::COUNT][nFEIBL2D]) const
 
void fillErrorCatRODmod (uint64_t fe_errorword, bool is_fei4, int(&nerrors_cat_rodmod)[ErrorCategoryRODMOD::COUNT][nFEIBL2D], int ife) const
 
void fillErrorCatRODmod (int servicecode, int payload, int(&nerrors_cat_rodmod)[ErrorCategoryRODMOD::COUNT][nFEIBL2D], int ife) const
 
bool isPerFEI3State (const std::string &state) const
 
void fill1DProfLumiLayers (const std::string &prof1Dname, int lb, float *weights, int nlayers=PixLayers::COUNT) const
 filling 1DProf per-lumi per-layer histograms ["ECA","ECC","BLayer","Layer1","Layer2","IBL","IBL2D","IBL3D"] More...
 
void fill2DProfLumiLayers (const std::string &prof2Dname, int lb, float(*weights)[PixLayers::COUNT], const int *nCategories) const
 filling 2DProf per-lumi per-layer histograms ["ECA","ECC","BLayer","Layer1","Layer2","IBL2D","IBL3D"] More...
 
int getPixLayersID (int ec, int ld) const
 helper function to get layers ID More...
 
bool isIBL2D (int hashID) const
 helper function to check if module is IBL planar based on pixel hash ID More...
 
bool isIBL3D (int hashID) const
 helper function to check if module is IBL 3D based on pixel hash ID More...
 
int getNumberOfFEs (int pixlayer, int etaMod) const
 helper function to get number of FEs per module More...
 
void getPhiEtaMod (Identifier &id, int &phiMod, int &etaMod, bool &copyFE) const
 helper function to get eta phi coordinates of per-layer arrays More...
 
bool isHitOnTrack (Identifier id, std::vector< Identifier > const &RDOIDs) const
 checks if hit is on track More...
 
bool isClusterOnTrack (Identifier id, std::vector< std::pair< Identifier, double > > const &ClusterIDs) const
 checks if cluster is on track More...
 
bool isClusterOnTrack (Identifier id, std::vector< std::pair< Identifier, double > > const &ClusterIDs, double &cosalpha) const
 checks if cluster is on track and returns its cosalpha More...
 
void fill2DProfLayerAccum (const VecAccumulator2DMap &accumulator) const
 take VecAccumulator2DMap and fill the corresponding group More...
 
void fill1DModProfAccum (const VecAccumulator2DMap &accumulator, int lumiblock) const
 take VecAccumulator2DMap and fill 3D arrays [layer, pm, em] with its values and lumiblock More...
 
void fillFromArrays (const std::string &namePP0, AccumulatorArrays &pixarrays, const std::string &name2DMap="") const
 filling 1DProfile per-pp0(ROD) histograms for ["ECA","ECC","BLayer","Layer1","Layer2","IBLA","IBLC"] More...
 
virtual StatusCode execute (const EventContext &ctx) const override
 Applies filters and trigger requirements. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by reference. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by reference. More...
 
template<typename... T>
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, T &&... variables) const
 Fills a variadic list of variables to a group by reference. More...
 
void fill (const std::string &groupName, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by name. More...
 
void fill (const std::string &groupName, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by name. More...
 
template<typename... T>
void fill (const std::string &groupName, T &&... variables) const
 Fills a variadic list of variables to a group by name. More...
 
Environment_t environment () const
 Accessor functions for the environment. More...
 
Environment_t envStringToEnum (const std::string &str) const
 Convert the environment string from the python configuration to an enum object. More...
 
DataType_t dataType () const
 Accessor functions for the data type. More...
 
DataType_t dataTypeStringToEnum (const std::string &str) const
 Convert the data type string from the python configuration to an enum object. More...
 
const ToolHandle< GenericMonitoringTool > & getGroup (const std::string &name) const
 Get a specific monitoring tool from the tool handle array. More...
 
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool () const
 Get the trigger decision tool member. More...
 
bool trigChainsArePassed (const std::vector< std::string > &vTrigNames) const
 Check whether triggers are passed. More...
 
SG::ReadHandle< xAOD::EventInfo > GetEventInfo (const EventContext &) const
 Return a ReadHandle for an EventInfo object (get run/event numbers, etc.) More...
 
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average mu, i.e. More...
 
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate instantaneous number of interactions, i.e. More...
 
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1). More...
 
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the instantaneous luminosity per bunch crossing. More...
 
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the duration of the luminosity block (in seconds) More...
 
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average luminosity livefraction. More...
 
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the live fraction per bunch crossing ID. More...
 
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average integrated luminosity multiplied by the live fraction. More...
 
virtual StatusCode parseList (const std::string &line, std::vector< std::string > &result) const
 Parse a string into a vector. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Public Attributes

string runtext = ''
 
int NumLayersDisk = 3
 
int NumStavesIBL = 14
 
int NumStavesL0 = 22
 
int NumStavesL1 = 38
 
int NumStavesL2 = 52
 
int NumModulesBarrel = 13
 
int NumModulesDisk = 48
 
int NumPP0sEC = 24
 
string btxt = ";eta index of module"
 
string sbtxt = ";shifted eta index of module"
 
string ditxt = ";disk number"
 
list layers = ["ECA","ECC","BLayer","Layer1","Layer2","IBL2D","IBL3D"]
 
list baselayers = ["ECA","ECC","BLayer","Layer1","Layer2","IBL"]
 
list xbinsl = [ 3, 3, 13, 13, 13, 32]
 
list xminsl = [ -0.5, -0.5,-6.5,-6.5,-6.5,-16.5]
 
list ybinsl = [ 48, 48, 22, 38, 52, 14]
 
list etatxt = [ditxt,ditxt,btxt,btxt,btxt,sbtxt]
 
string phitext = ";phi index of module"
 
list xbinsfel = [ 24, 24, 104, 104, 104, 32]
 
list xminsfel = [ -0.5, -0.5, -52, -52, -52,-16.5]
 
list ybinsfel = [ 96, 96, 44, 76, 104, 14]
 
list totcuts = [ 15, 15, 15, 15, 15, 4, 4]
 
list xbinsem = [ 3, 3, 13, 13, 13, 20]
 
list xminsem = [ 0.5, 0.5,-6.5,-6.5,-6.5, -10]
 
list xbinstotz = [ 3, 3, 13, 13, 13, 20]
 
list xminstotz = [ -0.5, -0.5,-0.5,-0.5,-0.5, -0.5]
 
list ztotbinsy = [ 20, 20, 20, 20, 20, 20, 20]
 
list ztotminsy = [ 19.5, 19.5, 7.5,19.5,19.5, -0.5, -0.5]
 
list errbbinsy = [ 17, 17, 17, 17, 17, 27, 27]
 
list errbminsy = [ 0, 0, 0, 0, 0, 0, 0]
 
list errbbsizy = [ 1, 1, 1, 1, 1, 1, 1]
 
list errtbinsy = [ 7, 7, 7, 7, 7, 7, 7]
 
list pp0layers = ["ECA","ECC","BLayer","Layer1","Layer2","IBLA","IBLC"]
 
list pp0xbins = [ 24, 24, 22, 38, 52, 14, 14]
 
list fei3layers = ["ECA","ECC","BLayer","Layer1","Layer2"]
 
list fei4layers = ["IBL2D","IBL3D"]
 
string lumitext = ";lumi block"
 
int lumibinsx = 3000
 
int bcidbinsx = 3600
 
list LayersDisk = ["Disk 1", "Disk 2", "Disk 3"]
 
list ModulesBarrel
 
list ModulesIBL
 
list LabelX = [LayersDisk, LayersDisk, ModulesBarrel, ModulesBarrel, ModulesBarrel, ModulesIBL]
 
list LayersDiskFE
 
list ModulesBarrelFE
 
list LabelFEX = [LayersDiskFE, LayersDiskFE, ModulesBarrelFE, ModulesBarrelFE, ModulesBarrelFE, ModulesIBL]
 
list ModulesECA
 
list ModulesECC
 
list StavesL0
 
list StavesL1
 
list StavesL2
 
list StavesIBL
 
list LabelY = [ModulesECA, ModulesECC, StavesL0, StavesL1, StavesL2, StavesIBL]
 
list ModulesFEECA = []
 
list ModulesFEECC = []
 
list StavesFEL0 = []
 
list StavesFEL1 = []
 
list StavesFEL2 = []
 
list LabelFEY = [ModulesFEECA, ModulesFEECC, StavesFEL0, StavesFEL1, StavesFEL2, StavesIBL]
 
list PP0sEC
 
list PP0LabelX = [PP0sEC, PP0sEC, StavesL0, StavesL1, StavesL2, StavesIBL, StavesIBL]
 
list ModulesHead = ["D", "D", "L0", "L1", "L2", "LI"]
 
list ErrStateLabelsFEI3
 
list ErrStateLabelsFEI4
 
list ErrCatRODModLabels
 
list ErrCatRODModLabelsNorm
 
list ErrCatLabels
 
list ErrCatLabelsNorm
 
list ReadingDataErrLabels
 
dictionary layergroups = {}
 

Protected Member Functions

SG::ReadHandle< InDet::SiDetectorElementStatus > getPixelDetElStatus (const SG::ReadHandleKey< InDet::SiDetectorElementStatus > &key, const EventContext &ctx) const
 
bool isActive (const InDet::SiDetectorElementStatus *element_status, const IdentifierHash &module_hash) const
 
bool isGood (const InDet::SiDetectorElementStatus *element_status, const IdentifierHash &module_hash) const
 
std::tuple< bool, bool > isChipGood (const IdentifierHash &module_hash, unsigned int chip_i) const
 
std::tuple< bool, bool > isChipGood (const InDet::SiDetectorElementStatus &element_active, const InDet::SiDetectorElementStatus &element_status, const IdentifierHash &module_hash, unsigned int chip_i) const
 
std::tuple< bool, bool > isChipGood (const InDet::SiDetectorElementStatus *element_active, const InDet::SiDetectorElementStatus *element_status, const IdentifierHash &module_hash, unsigned int chip_i) const
 
bool isChipActive (const IdentifierHash &module_hash, unsigned int chip_i) const
 
bool isChipActive (const InDet::SiDetectorElementStatus *element_active, const IdentifierHash &module_hash, unsigned int chip_i) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

ToolHandle< IInDetConditionsTool > m_pixelCondSummaryTool
 
ServiceHandle< InDetDD::IPixelReadoutManager > m_pixelReadout
 
const PixelID * m_pixelid {}
 
std::vector< int > m_modData [PixLayers::NBASELAYERS]
 
SG::ReadHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatus {this, "PixelDetElStatus", "", "Key of SiDetectorElementStatus for Pixel"}
 Optional read handle to get status data to test whether a pixel detector element is good. More...
 
SG::ReadHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusActiveOnly {this, "PixelDetElStatusActiveOnly", "", "Key of SiDetectorElementStatus for Pixel which reflects only whether modules or chips are active rather than delivering good data"}
 Optional read handle to get status data to test whether a pixel detector element is active. More...
 
ToolHandleArray< GenericMonitoringTool > m_tools {this,"GMTools",{}}
 Array of Generic Monitoring Tools. More...
 
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool {this, "TrigDecisionTool",""}
 Tool to tell whether a specific trigger is passed. More...
 
ToolHandleArray< IDQFilterTool > m_DQFilterTools {this,"FilterTools",{}}
 Array of Data Quality filter tools. More...
 
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}
 
AthMonitorAlgorithm::Environment_t m_environment
 Instance of the Environment_t enum. More...
 
AthMonitorAlgorithm::DataType_t m_dataType
 Instance of the DataType_t enum. More...
 
Gaudi::Property< std::string > m_environmentStr {this,"Environment","user"}
 Environment string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_dataTypeStr {this,"DataType","userDefined"}
 DataType string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_triggerChainString {this,"TriggerChain",""}
 Trigger chain string pulled from the job option and parsed into a vector. More...
 
std::vector< std::string > m_vTrigChainNames
 Vector of trigger chain names parsed from trigger chain string. More...
 
Gaudi::Property< std::string > m_fileKey {this,"FileKey",""}
 Internal Athena name for file. More...
 
Gaudi::Property< bool > m_useLumi {this,"EnableLumi",false}
 Allows use of various luminosity functions. More...
 
Gaudi::Property< float > m_defaultLBDuration {this,"DefaultLBDuration",60.}
 Default duration of one lumi block. More...
 
Gaudi::Property< int > m_detailLevel {this,"DetailLevel",0}
 Sets the level of detail used in the monitoring. More...
 
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey {this,"EventInfoKey","EventInfo"}
 Key for retrieving EventInfo from StoreGate. More...
 

Private Types

typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

Private Attributes

SG::ReadHandleKey< IDCInDetBSErrContainer > m_idcErrContKey {this, "PixelByteStreamErrs", "PixelByteStreamErrs", "PixelByteStreamErrs container key"}
 
Gaudi::Property< bool > m_useByteStreamFEI4 {this, "UseByteStreamFEI4", false, "Switch of the ByteStream error for FEI4"}
 
Gaudi::Property< bool > m_useByteStreamFEI3 {this, "UseByteStreamFEI3", false, "Switch of the ByteStream error for FEI3"}
 
Gaudi::Property< bool > m_useByteStreamRD53 {this, "UseByteStreamRD53", false, "Switch of the ByteStream error for RD53"}
 
unsigned int m_readoutTechnologyMask {}
 
bool m_doOnline {}
 
bool m_doLumiBlock {}
 
bool m_doLowOccupancy {}
 
bool m_doHighOccupancy {}
 
bool m_doHeavyIonMon {}
 
std::string m_name
 
std::unordered_map< std::string, size_t > m_toolLookupMap
 
const ToolHandle< GenericMonitoringTool > m_dummy
 
Gaudi::Property< bool > m_enforceExpressTriggers
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 141 of file PixelAthErrorMonAlg.h.

Member Typedef Documentation

◆ MonVarVec_t

typedef std::vector<std::reference_wrapper<Monitored::IMonitoredVariable> > AthMonitorAlgorithm::MonVarVec_t
privateinherited

Definition at line 365 of file AthMonitorAlgorithm.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataType_t

enum AthMonitorAlgorithm::DataType_t
stronginherited

Specifies what type of input data is being monitored.

An enumeration of the different types of data the monitoring application may be running over. This can be used to select which histograms to produce, e.g. to prevent the production of colliding-beam histograms when running on cosmic-ray data. Strings of the same names may be given as jobOptions.

Enumerator
userDefined 
monteCarlo 
collisions 
cosmics 
heavyIonCollisions 

Definition at line 191 of file AthMonitorAlgorithm.h.

191  {
192  userDefined = 0,
193  monteCarlo,
194  collisions,
195  cosmics,
196  heavyIonCollisions,
197  };

◆ Environment_t

enum AthMonitorAlgorithm::Environment_t
stronginherited

Specifies the processing environment.

The running environment may be used to select which histograms are produced, and where they are located in the output. For example, the output paths of the histograms are different for the "user", "online" and the various offline flags. Strings of the same names may be given as jobOptions.

Enumerator
user 
online 
tier0 
tier0Raw 
tier0ESD 
AOD 
altprod 

Definition at line 172 of file AthMonitorAlgorithm.h.

172  {
173  user = 0,
174  online,
175  tier0,
176  tier0Raw,
177  tier0ESD,
178  AOD,
179  altprod,
180  };

Constructor & Destructor Documentation

◆ PixelAthErrorMonAlg()

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

Definition at line 12 of file PixelAthErrorMonAlg.cxx.

12  :
13  AthMonitorAlgorithm(name, pSvcLocator)
14 {
15  // jo flags
16  declareProperty("doOnline", m_doOnline = false);
17  declareProperty("doLumiBlock", m_doLumiBlock = false);
18  declareProperty("doLowOccupancy", m_doLowOccupancy = false);
19  declareProperty("doHighOccupancy", m_doHighOccupancy = false);
20  declareProperty("doHeavyIonMon", m_doHeavyIonMon = false);
21 }

◆ ~PixelAthErrorMonAlg()

PixelAthErrorMonAlg::~PixelAthErrorMonAlg ( )
virtual

Definition at line 23 of file PixelAthErrorMonAlg.cxx.

23 {}

Member Function Documentation

◆ cardinality()

unsigned int AthReentrantAlgorithm::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.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

Returns
the current value of the class's DataType_t instance.

Definition at line 221 of file AthMonitorAlgorithm.h.

221 { return m_dataType; }

◆ dataTypeStringToEnum()

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::dataTypeStringToEnum ( const std::string &  str) const
inherited

Convert the data type string from the python configuration to an enum object.

Returns
a value in the DataType_t enumeration which matches the input string.

Definition at line 140 of file AthMonitorAlgorithm.cxx.

140  {
141  // convert the string to all lowercase
142  std::string lowerCaseStr = str;
143  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
144 
145  // check if it matches one of the enum choices
146  if( lowerCaseStr == "userdefined" ) {
147  return DataType_t::userDefined;
148  } else if( lowerCaseStr == "montecarlo" ) {
149  return DataType_t::monteCarlo;
150  } else if( lowerCaseStr == "collisions" ) {
151  return DataType_t::collisions;
152  } else if( lowerCaseStr == "cosmics" ) {
153  return DataType_t::cosmics;
154  } else if( lowerCaseStr == "heavyioncollisions" ) {
155  return DataType_t::heavyIonCollisions;
156  } else { // otherwise, warn the user and return "userDefined"
157  ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
158  <<str<<", returning userDefined.");
159  return DataType_t::userDefined;
160  }
161 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

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

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

Returns
the current value of the class's Environment_t instance.

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::envStringToEnum ( const std::string &  str) const
inherited

Convert the environment string from the python configuration to an enum object.

Returns
a value in the Environment_t enumeration which matches the input string.

Definition at line 112 of file AthMonitorAlgorithm.cxx.

112  {
113  // convert the string to all lowercase
114  std::string lowerCaseStr = str;
115  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
116 
117  // check if it matches one of the enum choices
118  if( lowerCaseStr == "user" ) {
119  return Environment_t::user;
120  } else if( lowerCaseStr == "online" ) {
121  return Environment_t::online;
122  } else if( lowerCaseStr == "tier0" ) {
123  return Environment_t::tier0;
124  } else if( lowerCaseStr == "tier0raw" ) {
125  return Environment_t::tier0Raw;
126  } else if( lowerCaseStr == "tier0esd" ) {
127  return Environment_t::tier0ESD;
128  } else if( lowerCaseStr == "aod" ) {
129  return Environment_t::AOD;
130  } else if( lowerCaseStr == "altprod" ) {
131  return Environment_t::altprod;
132  } else { // otherwise, warn the user and return "user"
133  ATH_MSG_WARNING("AthMonitorAlgorithm::envStringToEnum(): Unknown environment "
134  <<str<<", returning user.");
135  return Environment_t::user;
136  }
137 }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode AthMonitorAlgorithm::execute ( const EventContext &  ctx) const
overridevirtualinherited

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

73  {
74 
75  // Checks that all of the DQ filters are passed. If any one of the filters
76  // fails, return SUCCESS code and do not fill the histograms with the event.
77  for ( const auto& filterItr : m_DQFilterTools ) {
78  if (!filterItr->accept()) {
79  ATH_MSG_DEBUG("Event rejected due to filter tool.");
80  return StatusCode::SUCCESS;
81  }
82  }
83 
84  // Trigger: If there is a decision tool and the chains fail, skip the event.
85  if ( !m_trigDecTool.empty() && !trigChainsArePassed(m_vTrigChainNames) ) {
86  ATH_MSG_DEBUG("Event rejected due to trigger filter.");
87  return StatusCode::SUCCESS;
88  }
89 
90  ATH_MSG_DEBUG("Event accepted!");
91  return fillHistograms(ctx);
92 }

◆ 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 & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
84  return m_extendedExtraObjects;
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ fill1DModProfAccum()

void PixelAthMonitoringBase::fill1DModProfAccum ( const VecAccumulator2DMap &  accumulator,
int  lumiblock 
) const
inherited

take VecAccumulator2DMap and fill 3D arrays [layer, pm, em] with its values and lumiblock

Definition at line 135 of file PixelAthMonitoringBase.cxx.

135  {
136  auto lb = Monitored::Scalar<int>("pixmvamontool_lb", lumiblock);
137  const int em_offsets[PixLayers::NBASELAYERS] = { 0, 0, 6, 6, 6, 16};
138  // iterate over all actually filled layers
139  //
140  for (const auto& itr : accumulator.m_pm) {
141  int layer = itr.first;
142  auto pm_v = accumulator.m_pm.at(layer);
143  auto em_v = accumulator.m_em.at(layer);
144  auto val_v = accumulator.m_val.at(layer);
145  auto pi = pm_v.begin();
146  auto ei = em_v.begin();
147  auto vi = val_v.begin();
148  while (pi!=pm_v.end() and ei!=em_v.end() and vi!=val_v.end() )
149  {
150  auto pm = *pi++;
151  auto em = em_offsets[layer] + *ei++;
152  pm += em*PixMon::pixPhiSteps[layer];
153  auto val = Monitored::Scalar<float>(accumulator.m_prof2Dname + "_val", *vi++);
154  fill( m_tools[m_modData[layer].at(pm)], lb, val);
155  }
156  }
157 }

◆ fill1DProfLumiLayers()

void PixelAthMonitoringBase::fill1DProfLumiLayers ( const std::string &  prof1Dname,
int  lb,
float *  weights,
int  nlayers = PixLayers::COUNT 
) const
inherited

filling 1DProf per-lumi per-layer histograms ["ECA","ECC","BLayer","Layer1","Layer2","IBL","IBL2D","IBL3D"]

Definition at line 163 of file PixelAthMonitoringBase.cxx.

164  {
165  ATH_MSG_VERBOSE("in fill1DProfLumiLayers()");
166 
167  // Define the monitored variables
168  auto lb = Monitored::Scalar<int>(prof1Dname + "_lb", lumiblock);
169  auto val = Monitored::Scalar<float>(prof1Dname + "_val", 1.0);
170 
171  int i_start = 0;
172  int i_end = PixLayers::COUNT;
173  if (nlayers == PixLayers::NFEI3LAYERS) i_end = nlayers;
174  if (nlayers == PixLayers::COUNT - PixLayers::NFEI3LAYERS) i_start = PixLayers::NFEI3LAYERS;
175  for (int i = i_start; i < i_end; i++) {
176  val = values[i];
177  fill(pixLayersLabel[i], lb, val);
178  }
179 }

◆ fill2DProfLayerAccum()

void PixelAthMonitoringBase::fill2DProfLayerAccum ( const VecAccumulator2DMap &  accumulator) const
inherited

take VecAccumulator2DMap and fill the corresponding group

Definition at line 119 of file PixelAthMonitoringBase.cxx.

119  {
120  // iterate over all actually filled layers
121  for (const auto& itr : accumulator.m_pm) {
122  // Define the monitored variables
123  int layer = itr.first;
124  auto pm = Monitored::Collection(accumulator.m_prof2Dname + "_pm", accumulator.m_pm.at(layer));
125  auto val = Monitored::Collection(accumulator.m_prof2Dname + "_val", accumulator.m_val.at(layer));
126  auto em = Monitored::Collection(accumulator.m_prof2Dname + "_em", accumulator.m_em.at(layer));
127  fill(pixBaseLayersLabel[layer], pm, em, val);
128  }
129 }

◆ fill2DProfLumiLayers()

void PixelAthMonitoringBase::fill2DProfLumiLayers ( const std::string &  prof2Dname,
int  lb,
float(*)  weights[PixLayers::COUNT],
const int *  nCategories 
) const
inherited

filling 2DProf per-lumi per-layer histograms ["ECA","ECC","BLayer","Layer1","Layer2","IBL2D","IBL3D"]

Definition at line 186 of file PixelAthMonitoringBase.cxx.

187  {
188  ATH_MSG_VERBOSE("in fill2DProfLumiLayers()");
189 
190  // Define the monitored variables
191  auto lb = Monitored::Scalar<int>(prof2Dname + "_lb", lumiblock);
192  auto val = Monitored::Scalar<float>(prof2Dname + "_val", 1.0);
193  auto cat = Monitored::Scalar<int>(prof2Dname + "_cat");
194 
195  for (int i = 0; i < PixLayers::COUNT; i++) {
196  for (cat = 0; cat < nCategories[i]; cat++) {
197  val = values[cat][i];
198  fill(pixLayersLabel[i], lb, cat, val);
199  }
200  }
201 }

◆ fillErrorCatRODmod() [1/3]

void PixelAthErrorMonAlg::fillErrorCatRODmod ( int  servicecode,
int  payload,
int(&)  nerrors_cat_rodmod[ErrorCategoryRODMOD::COUNT][nFEIBL2D],
int  ife 
) const

Definition at line 493 of file PixelAthErrorMonAlg.cxx.

495  {
496  if (sc == 0) nerrors_cat_rodmod[0][ife] += payload;// synchronization error (SR0:BCID counter)
497  if (sc == 16) nerrors_cat_rodmod[2][ife] += payload;// truncation error (SR16:Truncated event)
498  if (sc == 1 || sc == 2 || // (SR1:Hamming code 0, SR2:Hamming code 1,
499  sc == 3 || sc == 24 || // SR3:Hamming code 2, SR24:Triple redundant CNFGMEM,
500  sc == 28 || sc == 29 || // SR28:Bit flip in CMD, SR29:Triple redundant CMD,
501  sc == 31) // SR31:Triple redundant EFUSE)
502  nerrors_cat_rodmod[5][ife] += payload;// SEU error
503 }

◆ fillErrorCatRODmod() [2/3]

void PixelAthErrorMonAlg::fillErrorCatRODmod ( uint64_t  fe_errorword,
bool  is_fei4,
int(&)  nerrors_cat_rodmod[ErrorCategoryRODMOD::COUNT][nFEIBL2D],
int  ife 
) const

Definition at line 467 of file PixelAthErrorMonAlg.cxx.

469  {
470  if (!is_fei4) {
471  if (PixelByteStreamErrors::hasError(errorword,
472  PixelByteStreamErrors::MCCLVL1IDEoECheck)) nerrors_cat_rodmod[0][0]++;// module synchronization
473  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCBCIDEoECheck)) nerrors_cat_rodmod[0][0]++; // ---
474  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCLVL1IDCheck)) nerrors_cat_rodmod[0][0]++; // ---
475  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCEoEOverflow)) nerrors_cat_rodmod[2][0]++;// module truncation
476  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCHitOverflow)) nerrors_cat_rodmod[2][0]++; // ---
477  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FEEoCOverflow)) nerrors_cat_rodmod[2][0]++;// ---
478  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FEHitParity)) nerrors_cat_rodmod[5][0]++;// SEU (single event upset)
479  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FERegisterParity)) nerrors_cat_rodmod[5][0]++;
480  // ---
481  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FEHammingCode)) nerrors_cat_rodmod[5][0]++;// ---
482  } else {
483  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::TimeOut)) nerrors_cat_rodmod[6][ife]++;// timeout errors
484  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::BCID)) nerrors_cat_rodmod[1][ife]++;// ROD synchronization
485  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::LVL1ID)) nerrors_cat_rodmod[1][ife]++;// ROD synchronization
486  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Preamble)) nerrors_cat_rodmod[4][ife]++;// optical errors
487  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Trailer)) nerrors_cat_rodmod[6][ife]++;// timeout errors
488  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Invalid)) nerrors_cat_rodmod[3][ife]++;// ROD truncation
489  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Limit)) nerrors_cat_rodmod[3][ife]++;// ROD truncation
490  }
491 }

◆ fillErrorCatRODmod() [3/3]

void PixelAthErrorMonAlg::fillErrorCatRODmod ( uint64_t  mod_errorword,
int(&)  nerrors_cat_rodmod[ErrorCategoryRODMOD::COUNT][nFEIBL2D] 
) const

Definition at line 457 of file PixelAthErrorMonAlg.cxx.

458  {
459  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::TimeOut)) nerrors_cat_rodmod[6][0]++;// timeout errors
460  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::BCID)) nerrors_cat_rodmod[1][0]++;// ROD synchronization
461  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::LVL1ID)) nerrors_cat_rodmod[1][0]++;// ROD synchronization
462  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Preamble)) nerrors_cat_rodmod[4][0]++;// optical errors
463  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::RODHeaderLimit)) nerrors_cat_rodmod[3][0]++;// ROD truncation
464  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::RODDataOVerflow)) nerrors_cat_rodmod[3][0]++;// ROD truncation
465 }

◆ fillFromArrays()

void PixelAthMonitoringBase::fillFromArrays ( const std::string &  namePP0,
AccumulatorArrays &  pixarrays,
const std::string &  name2DMap = "" 
) const
inherited

filling 1DProfile per-pp0(ROD) histograms for ["ECA","ECC","BLayer","Layer1","Layer2","IBLA","IBLC"]

Definition at line 209 of file PixelAthMonitoringBase.cxx.

210  {
211  ATH_MSG_VERBOSE("in fillFromArrays()");
212 
213  const float weightPix = 1.0 / 46080.0;
214  const float weightIBL = 1.0 / 26880.0;
215 
216  bool fillPP0only(name2DMap == "");
217  std::string pospp0varx = namePP0 + "_pospp0x";
218  std::string valvarp = namePP0 + "_val";
219  std::string posvarx = name2DMap + "_em";
220  std::string posvary = name2DMap + "_pm";
221  std::string valvarm = name2DMap + "_val";
222 
223  for (unsigned int a = 0; a < PixMon::kNumModulesDisk; ++a) {
224  auto posy = Monitored::Scalar<int>(posvary, a);
225  for (unsigned int b = 0; b < PixMon::kNumLayersDisk; ++b) {
226  // to find out (and fill together into one PP0-histogram bin)
227  // array content of the modules belonging to the same sector (or PP0)
228  // the translation (a-1)/6 is used
229  // to show PP0 values from other disks of the same endcap
230  // in the same plot
231  // the shift (b-1)*8 applies per disk counter b
232  // (there are in total 8 sectors/disk)
233  auto pospp0x = Monitored::Scalar<int>(pospp0varx, a / 6 + b * 8);
234  auto posx = Monitored::Scalar<int>(posvarx, b);
235  auto valp = Monitored::Scalar<float>(valvarp, pixarrays.DA[a][b]);
236  auto valm = Monitored::Scalar<float>(valvarm, pixarrays.DA[a][b] * weightPix);
237  if (pixarrays.DA[a][b] > -1) {
238  fill("ECA", pospp0x, valp);
239  if (!fillPP0only) fill("ECA", posx, posy, valm);
240  }
241  valp = pixarrays.DC[a][b];
242  valm = pixarrays.DC[a][b] * weightPix;
243  if (pixarrays.DC[a][b] > -1) {
244  fill("ECC", pospp0x, valp);
245  if (!fillPP0only) fill("ECC", posx, posy, valm);
246  }
247  }
248  }
249 
250  for (unsigned int b = 0; b < PixMon::kNumModulesBarrel; ++b) {
251  // translating array index into old Pixel module eta on a stave
252  // i.e. 0..12 into -6..6 so that standard per-layer histograms
253  // declared by define2DProfHist method can be filled
254  auto posx = Monitored::Scalar<int>(posvarx, b - 6);
255 
256  for (unsigned int a = 0; a < PixMon::kNumStavesL0; ++a) {
257  auto posy = Monitored::Scalar<int>(posvary, a);
258  auto pospp0x = Monitored::Scalar<int>(pospp0varx, a);
259  auto valp = Monitored::Scalar<float>(valvarp, pixarrays.B0[a][b]);
260  auto valm = Monitored::Scalar<float>(valvarm, pixarrays.B0[a][b] * weightPix);
261  if (pixarrays.B0[a][b] > -1) {
262  fill("BLayer", pospp0x, valp);
263  if (!fillPP0only) fill("BLayer", posx, posy, valm);
264  }
265  }
266  for (unsigned int a = 0; a < PixMon::kNumStavesL1; ++a) {
267  auto posy = Monitored::Scalar<int>(posvary, a);
268  auto pospp0x = Monitored::Scalar<int>(pospp0varx, a);
269  auto valp = Monitored::Scalar<float>(valvarp, pixarrays.B1[a][b]);
270  auto valm = Monitored::Scalar<float>(valvarm, pixarrays.B1[a][b] * weightPix);
271  if (pixarrays.B1[a][b] > -1) {
272  fill("Layer1", pospp0x, valp);
273  if (!fillPP0only) fill("Layer1", posx, posy, valm);
274  }
275  }
276  for (unsigned int a = 0; a < PixMon::kNumStavesL2; ++a) {
277  auto posy = Monitored::Scalar<int>(posvary, a);
278  auto pospp0x = Monitored::Scalar<int>(pospp0varx, a);
279  auto valp = Monitored::Scalar<float>(valvarp, pixarrays.B2[a][b]);
280  auto valm = Monitored::Scalar<float>(valvarm, pixarrays.B2[a][b] * weightPix);
281  if (pixarrays.B2[a][b] > -1) {
282  fill("Layer2", pospp0x, valp);
283  if (!fillPP0only) fill("Layer2", posx, posy, valm);
284  }
285  }
286  }
287  unsigned int nbina = PixMon::kNumStavesIBL;
288  unsigned int nbinb = PixMon::kNumFEsIBL;
289  for (unsigned int a = 0; a < nbina; ++a) {
290  auto posy = Monitored::Scalar<int>(posvary, a);
291  auto pospp0x = Monitored::Scalar<int>(pospp0varx, a);
292  for (unsigned int b = 0; b < nbinb; ++b) {
293  // translating array index into IBL frontend eta on a stave
294  // i.e. 0..31 into -16..15 so that standard per-layer histograms
295  // declared by define2DProfHist method can be filled
296  auto posx = Monitored::Scalar<int>(posvarx, b - 16);
297  auto valp = Monitored::Scalar<float>(valvarp, pixarrays.IBL[a][b]);
298  auto valm = Monitored::Scalar<float>(valvarm, pixarrays.IBL[a][b] * weightIBL);
299  if (pixarrays.IBL[a][b] > -1) {
300  if (b > (0.5 * nbinb - 1)) {
301  fill("IBLA", pospp0x, valp);
302  } else {
303  fill("IBLC", pospp0x, valp);
304  }
305  if (!fillPP0only) fill("IBL", posx, posy, valm);
306  }
307  }
308  }
309 }

◆ fillHistograms()

StatusCode PixelAthErrorMonAlg::fillHistograms ( const EventContext &  ctx) const
overridevirtual

adds event to the monitoring histograms

User will overwrite this function. Histogram booking is no longer done in C++. This function is called in execute once the filters are all passed.

Parameters
ctxforwarded from execute
Returns
StatusCode

Implements AthMonitorAlgorithm.

Definition at line 35 of file PixelAthErrorMonAlg.cxx.

35  {
36  using namespace Monitored;
37 
38  int lb = GetEventInfo(ctx)->lumiBlock();
39  auto errorGroup = getGroup("Error");
40 
41  ATH_MSG_DEBUG("Filling Error Monitoring Histograms");
42 
43  // Generate a vector of error maps for all different error states.
44  std::vector<VecAccumulator2DMap> error_maps_per_state;
45  error_maps_per_state.reserve(kNumErrorStatesFEI3 + kNumErrorStatesFEI4);
46  std::vector<VecAccumulator2DMap> fe_error_maps_per_state;
47  fe_error_maps_per_state.reserve(kNumErrorStatesPerFE);
48  for (const auto& state : error_names_stateFEI3) {
49  error_maps_per_state.emplace_back(*this, state + std::string("Map"));
50  if (isPerFEI3State(state))
51  {
52  fe_error_maps_per_state.emplace_back(*this, state + std::string("FEMap"));
53  }
54  }
55  for (const auto& state : error_names_stateFEI4) {
56  error_maps_per_state.emplace_back(*this, state + std::string("Map"));
57  }
58  if (error_maps_per_state.size()!=(kNumErrorStatesFEI3 + kNumErrorStatesFEI4) ||
59  fe_error_maps_per_state.size()!=kNumErrorStatesPerFE) {
60  ATH_MSG_ERROR("PixelMonitoring: Mismatch in the definition of the number of error states.");
61  return StatusCode::RECOVERABLE;
62  }
63  std::vector<VecAccumulator2DMap> error_maps_per_cat_rodmod;
64  // only first four rodmod histos are unique, others are covered by
65  // the overall, rod/mod-agnostic categories below
66  for (unsigned int cat = 0; cat < ErrorCategoryRODMOD::kTruncROD + 1; ++cat) {
67  error_maps_per_cat_rodmod.emplace_back(*this, error_names_cat_rodmod[cat]);
68  }
69  std::vector<VecAccumulator2DMap> error_maps_per_cat;
70  for (unsigned int cat = 0; cat < ErrorCategory::COUNT; ++cat) {
71  error_maps_per_cat.emplace_back(*this, error_names_cat[cat]);
72  }
73 
74  // containers to keep IBL service records info
75  std::vector<int> flagged_ibl_error_bits;
76  std::vector<unsigned int> weights_of_flagged_ibl_error_bits;
77 
78  int nActive_layer[PixLayers::COUNT] = {
79  0
80  };
81 
82  // Array to count number of errors occurring in all layers.
83  float num_errors[PixLayers::COUNT] = {
84  0
85  };
86  float num_errors_per_state[std::max(kNumErrorStatesFEI3, kNumErrorStatesFEI4)][PixLayers::COUNT] = {{0}};
87 
88  // Counters for erroneous modules in a layer, per
89  // error category, w/ and w/o ROD/MOD distinction.
90  float num_errormodules_per_cat[ErrorCategory::COUNT][PixLayers::COUNT] = {{0}};
91  float num_errormodules_per_cat_rodmod[ErrorCategoryRODMOD::COUNT][PixLayers::COUNT] = {{0}};
92 
93  // Generate femcc_errwords, ROB error and per LB maps.
94  VecAccumulator2DMap femcc_errwords_maps(*this, "FEMCCErrorwords");
95  VecAccumulator2DMap trunc_rob_errors_maps(*this, "TruncatedROBErrors", true);
96  VecAccumulator2DMap masked_rob_errors_maps(*this, "MaskedROBErrors", true);
97  VecAccumulator2DMap all_errors_maps(*this, "ErrorsLB");
98  VecAccumulator2DMap modsync_errors_maps(*this, "ErrorsModSyncLB");
99  VecAccumulator2DMap rodsync_errors_maps(*this, "ErrorsRODSyncLB");
100 
101  //====================================================================================
102  // This is an example how to read the Error informaiton.
103  //
104  // The Error word is defined in
105  // InDetConditions/PixelConditionsData/PixelConditionsData/PixelByteStreamErrors.h
106  //
107  // The IDCInDetBSErrContainer can be accessed through
108  // m_pixelCondSummaryTool->getBSErrorWord(i,ctx)
109  // where
110  // i= [ 0, 2047] : module error
111  // ( [0, 11] - DBMC, [12, 155] - ECC, [156, 435] - IBL,
112  // [436, 721] - B0, [722, 1215] - B1, [1216, 1891] - B2,
113  // [1892, 2035] - ECA, [2036, 2047] - DBMA )
114  //
115  // for PIXEL(FEI3):
116  // = [ 2048, 4095] : FE-0 error
117  // = [ 4096, 6143] : FE-1 error
118  // = [ 6144, 8191] : FE-2 error
119  // ... ... ...
120  // ... ... ...
121  // = [30720, 32767] : FE-14 error
122  // = [32768, 34815] : FE-15 error
123  //
124  // for IBL(FEI4):
125  // = [ 2048, 4095] : FE-0 error
126  // = [ 4096, 6143] : FE-1 error
127  // = [34816, 35375] : Error counter in bit#=0 from ServiceRecords (shift: modHash*nFE+iFE)
128  // = [35376, 35935] : Error counter in bit#=1 from ServiceRecords
129  // ... ... ...
130  // ... ... ...
131  // = [52176, 52735] : Error counter in bit#=31 from ServiceRecords
132  //
133  //====================================================================================
134  //
135 
136  const int maxHash = m_pixelid->wafer_hash_max(); // 2048
137 
138  SG::ReadHandle<InDet::SiDetectorElementStatus> pixel_active = getPixelDetElStatus(m_pixelDetElStatusActiveOnly, ctx);
139  SG::ReadHandle<IDCInDetBSErrContainer> idcErrCont;
140  if (m_readoutTechnologyMask) {
141  idcErrCont =SG::ReadHandle<IDCInDetBSErrContainer> ( m_idcErrContKey, ctx);
142  if (!idcErrCont.isValid()) {
143  ATH_MSG_FATAL("Faled to get BS error container" << m_idcErrContKey.key() );
144  }
145  }
146  // Loop over modules except DBM, s.a.
147  for (int modHash = 12; modHash < maxHash - 12; modHash++) {
148  Identifier waferID = m_pixelid->wafer_id(modHash);
149  int pixlayer = getPixLayersID(m_pixelid->barrel_ec(waferID), m_pixelid->layer_disk(waferID));
150  int nFE(0);
151  bool is_fei4(false); // FEI4 readout architecture (IBL, DBM)
152  int iblsublayer(pixlayer);
153  if (pixlayer == PixLayers::kIBL) {
154  if (m_pixelid->eta_module(waferID) > -7 && m_pixelid->eta_module(waferID) < 6) { // IBL Planar
155  nFE = 2;
156  iblsublayer = PixLayers::kIBL2D;
157  } else { // IBL 3D
158  nFE = 1;
159  iblsublayer = PixLayers::kIBL3D;
160  }
161  is_fei4 = true;
162  } else { // for fei3 Pixel layers
163  nFE = 16;
164  is_fei4 = false;
165  }
166  // flagging/counting categorized errors per module.
167  bool has_err_cat[ErrorCategory::COUNT][nFEIBL2D] = {{false}};
168  int nerrors_cat_rodmod[ErrorCategoryRODMOD::COUNT][nFEIBL2D] = {{0}};
169 
170  // count number of words w/ MCC/FE flags per module
171  unsigned int num_femcc_errwords = 0;
172 
173  uint64_t mod_errorword = (!m_pixelDetElStatusActiveOnly.empty() && m_readoutTechnologyMask
174  ? InDet::getBSErrorWord( *pixel_active,
175  *idcErrCont,
176  modHash,
177  modHash,
178  m_readoutTechnologyMask)
179  : m_pixelCondSummaryTool->getBSErrorWord(modHash, ctx) );
180  VALIDATE_STATUS_ARRAY(!m_pixelDetElStatusActiveOnly.empty() && m_readoutTechnologyMask, InDet::getBSErrorWord( *pixel_active,*idcErrCont,modHash,modHash,m_readoutTechnologyMask) ,m_pixelCondSummaryTool->getBSErrorWord(modHash, ctx) );
181 
182  // extracting ROB error information
183  //
184  if (PixelByteStreamErrors::hasError(mod_errorword, PixelByteStreamErrors::TruncatedROB)) {
185  trunc_rob_errors_maps.add(pixlayer, waferID, 1.0);
186  }
187  if (PixelByteStreamErrors::hasError(mod_errorword, PixelByteStreamErrors::MaskedROB)) {
188  masked_rob_errors_maps.add(pixlayer, waferID, 1.0);
189  }
190  // getting module_error information (only fei3 layers)
191  //
192  if (!is_fei4) {
193  std::bitset<kNumErrorStatesFEI3> stateFEI3 = getErrorStateFEI3Mod(mod_errorword);
194  num_errors[pixlayer] += stateFEI3.count();
195  for (unsigned int state = 0; state < stateFEI3.size(); ++state) {
196  if (stateFEI3[state]) {
197  num_errors_per_state[state][pixlayer]++;
198  error_maps_per_state[state].add(pixlayer, waferID, 1.0);
199  }
200  }
201  fillErrorCatRODmod(mod_errorword, nerrors_cat_rodmod);
202  }
203 
204  // getting fe_error information (all pixel layers)
205  //
206  for (int iFE = 0; iFE < nFE; iFE++) {
207 
208  int offsetFE = (1 + iFE) * maxHash + modHash; // (FE index+1)*2048 + moduleHash
209  uint64_t fe_errorword = (!m_pixelDetElStatusActiveOnly.empty() && m_readoutTechnologyMask
210  ? InDet::getBSErrorWord( *pixel_active,
211  *idcErrCont,
212  modHash,
213  offsetFE,
214  m_readoutTechnologyMask)
215  : m_pixelCondSummaryTool->getBSErrorWord(modHash, offsetFE, ctx) );
216  VALIDATE_STATUS_ARRAY(!m_pixelDetElStatusActiveOnly.empty() && m_readoutTechnologyMask, InDet::getBSErrorWord( *pixel_active,*idcErrCont,modHash,offsetFE,m_readoutTechnologyMask) ,m_pixelCondSummaryTool->getBSErrorWord(modHash, offsetFE, ctx) );
217 
218 
219  fillErrorCatRODmod(fe_errorword, is_fei4, nerrors_cat_rodmod, iFE);
220 
221  if (!is_fei4) {
222  std::bitset<kNumErrorStatesFEI3> stateFEI3 = getErrorStateFE(fe_errorword, is_fei4);
223  num_errors[pixlayer] += stateFEI3.count();
224  if (stateFEI3.any()) num_femcc_errwords++;
225  int perFEI3state(-1);
226  for (unsigned int state = 0; state < stateFEI3.size(); ++state) {
227  if (isPerFEI3State(error_names_stateFEI3[state])) perFEI3state++;
228  if (stateFEI3[state]) {
229  num_errors_per_state[state][pixlayer]++;
230  if (perFEI3state>=0 && perFEI3state<kNumErrorStatesPerFE) {
231  fe_error_maps_per_state[perFEI3state].add(pixlayer, waferID, iFE, 1.0);
232  } else {
233  error_maps_per_state[state].add(pixlayer, waferID, 1.0);
234  }
235  }
236  }
237  } else {
238  std::bitset<kNumErrorStatesFEI3> stateFEI4 = getErrorStateFE(fe_errorword, is_fei4);
239  num_errors[iblsublayer] += stateFEI4.count();
240  Identifier pixelIDperFEI4 = m_pixelReadout->getPixelIdfromHash(modHash, iFE, 1, 1);
241  for (unsigned int state = 0; state < stateFEI4.size(); ++state) {
242  if (stateFEI4[state]) {
243  num_errors_per_state[state][iblsublayer]++;
244  error_maps_per_state[state + kNumErrorStatesFEI3].add(pixlayer, pixelIDperFEI4, 1.0);
245  }
246  }
247  }
248  } // FE loop
249  if (!is_fei4) femcc_errwords_maps.add(pixlayer, waferID, num_femcc_errwords);
250 
251  // getting error information from service records (only IBL)
252  //
253  int state_offset(8); // serviceCode part starts from state 8 of kNumErrorStatesFEI4
254  const int serviceRecordFieldOffset = 17 * maxHash;
255  if (pixlayer == PixLayers::kIBL) {
256  int moduleOffset = (modHash - 156) * 2;
257  for (int serviceCode = 0; serviceCode < 32; serviceCode++) {
258  // skip irrelevant SR's (as in rel21)
259  if ((serviceCode >= 9 && serviceCode <= 14) || (serviceCode >= 17 && serviceCode <= 23)) {
260  state_offset--;
261  continue;
262  }
263  int serviceCodeOffset = serviceCode * 280 * 2;
264  for (int iFE = 0; iFE < nFE; iFE++) {
265  Identifier pixelIDperFEI4 = m_pixelReadout->getPixelIdfromHash(modHash, iFE, 1, 1);
266  // index = offset + (serviceCode)*(#IBL*nFEmax) + (moduleHash-156)*nFEmax + iFE
267  int serviceCodeCounterIndex = serviceRecordFieldOffset + serviceCodeOffset + moduleOffset + iFE;
268  uint64_t serviceCodeCounter = (!m_pixelDetElStatusActiveOnly.empty() && m_readoutTechnologyMask
269  ? InDet::getBSErrorWord( *pixel_active,
270  *idcErrCont,
271  modHash,
272  serviceCodeCounterIndex,
273  m_readoutTechnologyMask)
274  : m_pixelCondSummaryTool->getBSErrorWord(modHash, serviceCodeCounterIndex, ctx) );
275  VALIDATE_STATUS_ARRAY(!m_pixelDetElStatusActiveOnly.empty() && m_readoutTechnologyMask, InDet::getBSErrorWord( *pixel_active,*idcErrCont,modHash,serviceCodeCounterIndex,m_readoutTechnologyMask) ,m_pixelCondSummaryTool->getBSErrorWord(modHash, serviceCodeCounterIndex, ctx) );
276 
277  if (serviceCodeCounter > 0) {
278  float payload = serviceCodeCounter; // NB: + 1, as in rel 21, is now added upstream
279  flagged_ibl_error_bits.push_back(serviceCode);
280  weights_of_flagged_ibl_error_bits.push_back(payload);
281 
282  int state = serviceCode + state_offset;
283  num_errors[iblsublayer] += payload;
284  num_errors_per_state[state][iblsublayer] += payload;
285  error_maps_per_state[state + kNumErrorStatesFEI3].add(pixlayer, pixelIDperFEI4, payload);
286 
287  fillErrorCatRODmod(serviceCode, payload, nerrors_cat_rodmod, iFE);
288  }
289  } // over FE
290  } //over service codes
291  } // IBL modules
292 
293  // access categorized error information per module (for IBL - FE)
294  // it is only flagged - the actual number of errors per category is not tracked
295  for (int iFE = 0; iFE < nFE; iFE++) {
296  if (pixlayer != PixLayers::kIBL && iFE > 0) continue;
297  Identifier pixID = waferID;
298  if (pixlayer == PixLayers::kIBL) {
299  pixID = m_pixelReadout->getPixelIdfromHash(modHash, iFE, 1, 1);
300  }
301  if (pixID.is_valid()) {
302  for (int i = 0; i < ErrorCategoryRODMOD::COUNT; i++) {
303  if (nerrors_cat_rodmod[i][iFE]) {
304  if (getErrorCategory(i + 1) != 99) has_err_cat[getErrorCategory(i + 1)][iFE] = true;
305  if (pixlayer == PixLayers::kIBL) num_errormodules_per_cat_rodmod[i][iblsublayer]++;
306  else num_errormodules_per_cat_rodmod[i][pixlayer]++;
307  if (!m_doOnline) {
308  all_errors_maps.add(pixlayer, pixID, nerrors_cat_rodmod[i][iFE]);
309  if (i < ErrorCategoryRODMOD::kTruncROD + 1) {
310  error_maps_per_cat_rodmod[i].add(pixlayer, pixID, 1.0);
311  if (i == 0) modsync_errors_maps.add(pixlayer, pixID, 1.0);
312  if (i == 1) rodsync_errors_maps.add(pixlayer, pixID, 1.0);
313  }
314  }
315  }
316  }
317  for (int i = 0; i < ErrorCategory::COUNT; i++) {
318  if (has_err_cat[i][iFE]) {
319  if (pixlayer == PixLayers::kIBL) num_errormodules_per_cat[i][iblsublayer]++;
320  else num_errormodules_per_cat[i][pixlayer]++;
321  if (!m_doOnline) {
322  error_maps_per_cat[i].add(pixlayer, pixID, 1.0);
323  }
324  }
325  }
326 
327  // filling nActive modules per layer for later normalization
328  // for IBL normalization is done by number of FEI4
329  if ((pixlayer != PixLayers::kIBL && isActive(!m_pixelDetElStatusActiveOnly.empty() ? pixel_active.cptr() : nullptr, modHash) == true) ||
330  (pixlayer == PixLayers::kIBL && isChipActive(!m_pixelDetElStatusActiveOnly.empty() ? pixel_active.cptr() : nullptr, modHash, iFE) == true)) {
331  if (pixlayer == PixLayers::kIBL) nActive_layer[iblsublayer]++;
332  else nActive_layer[pixlayer]++;
333  }
334  } else {
335  ATH_MSG_ERROR("PixelMonitoring: got invalid pixID " << pixID);
336  }
337  } // loop over FEs
338  } // loop over modules
339 
340  // normalization by active modules (or FE's in IBL case)
341  //
342  for (int i = 0; i < PixLayers::COUNT; i++) {
343  if (nActive_layer[i] > 0) {
344  for (int state = 0; state < numErrorStatesLayer[i]; state++) {
345  num_errors_per_state[state][i] /= nActive_layer[i];
346  }
347  for (int cat = 0; cat < ErrorCategoryRODMOD::COUNT; cat++) {
348  num_errormodules_per_cat_rodmod[cat][i] /= nActive_layer[i];
349  }
350  for (int cat = 0; cat < ErrorCategory::COUNT; cat++) {
351  num_errormodules_per_cat[cat][i] /= nActive_layer[i];
352  }
353  }
354  }
355  int perFEI3state(0);
356  for (unsigned int state = 0; state < kNumErrorStatesFEI3 + kNumErrorStatesFEI4; state++) {
357  if (state < kNumErrorStatesFEI3) {
358  if (isPerFEI3State(error_names_stateFEI3[state]) && perFEI3state<kNumErrorStatesPerFE)
359  fill2DProfLayerAccum(fe_error_maps_per_state[perFEI3state++]);
360  else fill2DProfLayerAccum(error_maps_per_state[state]);
361  fill1DProfLumiLayers(error_names_stateFEI3[state] + std::string(
362  "PerLumi"), lb, num_errors_per_state[state], PixLayers::NFEI3LAYERS);
363  } else {
364  fill2DProfLayerAccum(error_maps_per_state[state]);
365  fill1DProfLumiLayers(error_names_stateFEI4[state - kNumErrorStatesFEI3] + std::string(
366  "PerLumi"), lb, num_errors_per_state[state - kNumErrorStatesFEI3],
367  PixLayers::COUNT - PixLayers::NFEI3LAYERS);
368  }
369  }
370  // Fill the accumulated maps
371  fill2DProfLayerAccum(femcc_errwords_maps);
372  fill2DProfLayerAccum(trunc_rob_errors_maps);
373  fill2DProfLayerAccum(masked_rob_errors_maps);
374  fill2DProfLayerAccum(all_errors_maps);
375  fill2DProfLayerAccum(modsync_errors_maps);
376  fill2DProfLayerAccum(rodsync_errors_maps);
377 
378  if (!m_doOnline) {
379  for (unsigned int cat = 0; cat < ErrorCategoryRODMOD::kTruncROD + 1; ++cat) {
380  fill2DProfLayerAccum(error_maps_per_cat_rodmod[cat]);
381  }
382  for (unsigned int cat = 0; cat < ErrorCategory::COUNT; ++cat) {
383  fill2DProfLayerAccum(error_maps_per_cat[cat]);
384  }
385  }
386  // Fill the luminosity error profiles for all layers.
387  fill1DProfLumiLayers("ErrorsPerLumi", lb, num_errors);
388 
389  auto vals = Monitored::Collection("ServiceRecord_val", flagged_ibl_error_bits);
390  auto wgts = Monitored::Collection("ServiceRecord_wgt", weights_of_flagged_ibl_error_bits);
391  fill(errorGroup, vals, wgts);
392 
393  // Fill 2D luminosity error profiles per error bit and cat split by ROD/MOD for all layers.
394  fill2DProfLumiLayers("ErrorStatePerLumi", lb, num_errors_per_state, numErrorStatesLayer);
395  fill2DProfLumiLayers("ErrorCatRODModPerLumi", lb, num_errormodules_per_cat_rodmod, numErrorCatRODModsLayer);
396 
397  // Fill 1D luminosity error profiles for error catergory for all layers.
398  for (unsigned int cat = 0; cat < error_names_cat_rodmod_norm.size(); ++cat) {
399  fill1DProfLumiLayers(error_names_cat_rodmod_norm[cat], lb, num_errormodules_per_cat_rodmod[cat]);
400  }
401  for (unsigned int cat = 0; cat < ErrorCategory::COUNT; ++cat) {
402  fill1DProfLumiLayers(error_names_cat_norm[cat], lb, num_errormodules_per_cat[cat]);
403  }
404 
405  return StatusCode::SUCCESS;
406 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ findComponentString()

std::string PixelAthErrorMonAlg::findComponentString ( int  bec,
int  ld 
) const

◆ getErrorCategory()

int PixelAthErrorMonAlg::getErrorCategory ( int  error_cat_rodmod) const

Definition at line 408 of file PixelAthErrorMonAlg.cxx.

408  {
409  int error_cat = 99;
410 
411  if (error_cat_rodmod == 1 || error_cat_rodmod == 2) error_cat = ErrorCategory::kSync;
412  if (error_cat_rodmod == 3 || error_cat_rodmod == 4) error_cat = ErrorCategory::kTrunc;
413  if (error_cat_rodmod == 5) error_cat = ErrorCategory::kOpt;
414  if (error_cat_rodmod == 6) error_cat = ErrorCategory::kSeu;
415  if (error_cat_rodmod == 7) error_cat = ErrorCategory::kTout;
416  return error_cat;
417 }

◆ getErrorStateFE()

std::bitset< kNumErrorStatesFEI3 > PixelAthErrorMonAlg::getErrorStateFE ( uint64_t  errorword,
bool  isibl 
) const

Definition at line 431 of file PixelAthErrorMonAlg.cxx.

431  {
432  std::bitset<kNumErrorStatesFEI3> result(0);
433  if (!is_fei4) {
434  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCLVL1IDEoECheck)) result |= 1 << 4;
435  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCBCIDEoECheck)) result |= 1 << 5;
436  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCLVL1IDCheck)) result |= 1 << 6;
437  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCEoEOverflow)) result |= 1 << 7;
438  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::MCCHitOverflow)) result |= 1 << 8;
439  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FEWarning)) result |= 1 << 9;
440  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FEHitParity)) result |= 1 << 10;
441  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FERegisterParity)) result |= 1 << 11;
442  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FEHammingCode)) result |= 1 << 12;
443  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::FEEoCOverflow)) result |= 1 << 13;
444  } else {
445  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::TimeOut)) result |= 1;
446  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::BCID)) result |= 1 << 1;
447  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::LVL1ID)) result |= 1 << 2;
448  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Preamble)) result |= 1 << 3;
449  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Trailer)) result |= 1 << 4;
450  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Invalid)) result |= 1 << 5;
451  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::LinkMaskedByPPC)) result |= 1 << 6;
452  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Limit)) result |= 1 << 7;
453  }
454  return result;
455 }

◆ getErrorStateFEI3Mod()

std::bitset< kNumErrorStatesFEI3 > PixelAthErrorMonAlg::getErrorStateFEI3Mod ( uint64_t  errorword) const

Definition at line 419 of file PixelAthErrorMonAlg.cxx.

419  {
420  std::bitset<kNumErrorStatesFEI3> result(0);
421  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::TimeOut)) result |= 1;
422  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::BCID)) result |= 1 << 1;
423  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::LVL1ID)) result |= 1 << 2;
424  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::Preamble)) result |= 1 << 3;
425  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::RODTrailerBitError)) result |= 1 << 14;
426  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::RODHeaderLimit)) result |= 1 << 15;
427  if (PixelByteStreamErrors::hasError(errorword, PixelByteStreamErrors::RODDataOVerflow)) result |= 1 << 16;
428  return result;
429 }

◆ GetEventInfo()

SG::ReadHandle< xAOD::EventInfo > AthMonitorAlgorithm::GetEventInfo ( const EventContext &  ctx) const
inherited

Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)

Parameters
ctxEventContext for the event
Returns
a SG::ReadHandle<xAOD::EventInfo>

Definition at line 107 of file AthMonitorAlgorithm.cxx.

107  {
108  return SG::ReadHandle<xAOD::EventInfo>(m_EventInfoKey, ctx);
109 }

◆ getGroup()

const ToolHandle< GenericMonitoringTool > & AthMonitorAlgorithm::getGroup ( const std::string &  name) const
inherited

Get a specific monitoring tool from the tool handle array.

Finds a specific GenericMonitoringTool instance from the list of monitoring tools (a ToolHandleArray). Throws a FATAL warning if the object found is empty.

Parameters
namestring name of the desired tool
Returns
reference to the desired monitoring tool

Definition at line 164 of file AthMonitorAlgorithm.cxx.

164  {
165  // get the pointer to the tool, and check that it exists
166  auto idx = m_toolLookupMap.find(name);
167  if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
168  return m_tools[idx->second];
169  }
170  else {
171  if (!isInitialized()) {
172  ATH_MSG_FATAL(
173  "It seems that the AthMonitorAlgorithm::initialize was not called "
174  "in derived class initialize method");
175  } else {
176  std::string available = std::accumulate(
177  m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
178  [](const std::string& s, auto h) { return s + "," + h.first; });
179  ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
180  << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
181  << "your python configuration and c++ filling code. Note: your available groups are {"
182  << available << "}.");
183  }
184  }
185  return m_dummy;
186 }

◆ getNumberOfFEs()

int PixelAthMonitoringBase::getNumberOfFEs ( int  pixlayer,
int  etaMod 
) const
inherited

helper function to get number of FEs per module

Definition at line 372 of file PixelAthMonitoringBase.cxx.

372  {
373  int nFE(16);
374 
375  if (pixlayer == PixLayers::kIBL) {
376  nFE = 1; // IBL 3D
377  if (etaMod > -7 && etaMod < 6) nFE = 2; // IBL Planar
378  }
379  return nFE;
380 }

◆ getPhiEtaMod()

void PixelAthMonitoringBase::getPhiEtaMod ( Identifier &  id,
int &  phiMod,
int &  etaMod,
bool &  copyFE 
) const
inherited

helper function to get eta phi coordinates of per-layer arrays

Definition at line 388 of file PixelAthMonitoringBase.cxx.

389  {
390  phiMod = m_pixelid->phi_module(id);
391 
392  int layerDisk = m_pixelid->layer_disk(id);
393  etaMod = layerDisk;
394  copyFE = false;
395  if (m_pixelid->barrel_ec(id) == 0) {
396  etaMod = m_pixelid->eta_module(id);
397  if (layerDisk == 0) {
398  if (etaMod < -6) {
399  etaMod = etaMod - 6;
400  } else if (etaMod > -7 && etaMod < 6) {
401  int feid = 0;
402  if (m_pixelid->eta_index(id) >= 80) feid = 1;
403  etaMod = 2 * etaMod + feid;
404  copyFE = true;
405  } else {
406  etaMod = etaMod + 6;
407  }
408  etaMod = etaMod + 16;
409  } else etaMod = etaMod + 6;
410  }
411 }

◆ getPixelDetElStatus()

SG::ReadHandle<InDet::SiDetectorElementStatus> PixelAthMonitoringBase::getPixelDetElStatus ( const SG::ReadHandleKey< InDet::SiDetectorElementStatus > &  key,
const EventContext &  ctx 
) const
inlineprotectedinherited

Definition at line 158 of file PixelAthMonitoringBase.h.

158  {
159  SG::ReadHandle<InDet::SiDetectorElementStatus> pixelDetElStatus;
160  if (!key.empty()) {
161  pixelDetElStatus = SG::ReadHandle<InDet::SiDetectorElementStatus>(key, ctx);
162  if (!pixelDetElStatus.isValid()) {
163  std::stringstream msg;
164  msg << "Failed to get " << key.key() << " from StoreGate in " << name();
165  throw std::runtime_error(msg.str());
166  }
167  }
168  return pixelDetElStatus;
169  }

◆ getPixLayersID()

int PixelAthMonitoringBase::getPixLayersID ( int  ec,
int  ld 
) const
inherited

helper function to get layers ID

Definition at line 317 of file PixelAthMonitoringBase.cxx.

317  {
318  int layer = 99;
319 
320  if (ec == 2) {
321  layer = PixLayers::kECA;
322  } else if (ec == -2) {
323  layer = PixLayers::kECC;
324  } else if (ec == 0) {
325  if (ld == 0) layer = PixLayers::kIBL;
326  if (ld == 1) layer = PixLayers::kBLayer;
327  if (ld == 2) layer = PixLayers::kLayer1;
328  if (ld == 3) layer = PixLayers::kLayer2;
329  }
330  return layer;
331 }

◆ getTrigDecisionTool()

const ToolHandle< Trig::TrigDecisionTool > & AthMonitorAlgorithm::getTrigDecisionTool ( ) const
inherited

Get the trigger decision tool member.

The trigger decision tool is used to check whether a specific trigger is passed by an event.

Returns
m_trigDecTool

Definition at line 189 of file AthMonitorAlgorithm.cxx.

189  {
190  return m_trigDecTool;
191 }

◆ initialize()

StatusCode PixelAthErrorMonAlg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from PixelAthMonitoringBase.

Definition at line 26 of file PixelAthErrorMonAlg.cxx.

26  {
27  ATH_CHECK( PixelAthMonitoringBase::initialize() );
28  m_readoutTechnologyMask = Pixel::makeReadoutTechnologyBit( InDetDD::PixelReadoutTechnology::FEI4, m_useByteStreamFEI4)
29  | Pixel::makeReadoutTechnologyBit( InDetDD::PixelReadoutTechnology::FEI3, m_useByteStreamFEI3)
30  | Pixel::makeReadoutTechnologyBit( InDetDD::PixelReadoutTechnology::RD53, m_useByteStreamRD53);
31  ATH_CHECK( m_idcErrContKey.initialize(m_readoutTechnologyMask) );
32  return StatusCode::SUCCESS;
33 }

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

◆ isActive()

bool PixelAthMonitoringBase::isActive ( const InDet::SiDetectorElementStatus *  element_status,
const IdentifierHash &  module_hash 
) const
inlineprotectedinherited

Definition at line 170 of file PixelAthMonitoringBase.h.

171  {
172  const EventContext& ctx{Gaudi::Hive::currentContext()};
173  bool ret { element_status ? element_status->isGood(module_hash) : m_pixelCondSummaryTool->isActive(module_hash, ctx) };
174  VALIDATE_STATUS_ARRAY(element_status, element_status->isGood(module_hash), m_pixelCondSummaryTool->isActive(module_hash, ctx) );
175  return ret;
176  }

◆ isChipActive() [1/2]

bool PixelAthMonitoringBase::isChipActive ( const IdentifierHash &  module_hash,
unsigned int  chip_i 
) const
inlineprotectedinherited

Definition at line 198 of file PixelAthMonitoringBase.h.

199  {
200  bool is_active=false;
201  Identifier pixelID = m_pixelReadout->getPixelIdfromHash(module_hash, chip_i, 1, 1);
202  if (pixelID.is_valid()) {
203  const EventContext& ctx{Gaudi::Hive::currentContext()};
204  is_active = m_pixelCondSummaryTool->isActive(module_hash,pixelID, ctx);
205  }
206  return is_active;
207  }

◆ isChipActive() [2/2]

bool PixelAthMonitoringBase::isChipActive ( const InDet::SiDetectorElementStatus *  element_active,
const IdentifierHash &  module_hash,
unsigned int  chip_i 
) const
inlineprotectedinherited

Definition at line 229 of file PixelAthMonitoringBase.h.

231  {
232  bool ret( element_active
233  ? element_active->isChipGood(module_hash, chip_i)
234  : isChipActive( module_hash, chip_i) );
235 #ifdef DO_VALIDATE_STATUS_ARRAY
236  const EventContext& ctx{Gaudi::Hive::currentContext()};
237  Identifier pixelID = m_pixelReadout->getPixelIdfromHash(module_hash, chip_i, 1, 1);
238  VALIDATE_STATUS_ARRAY(element_active, element_active->isChipGood(module_hash, chip_i), m_pixelCondSummaryTool->isActive(module_hash,pixelID, ctx) );
239 #endif
240  return ret;
241  }

◆ isChipGood() [1/3]

std::tuple<bool,bool> PixelAthMonitoringBase::isChipGood ( const IdentifierHash &  module_hash,
unsigned int  chip_i 
) const
inlineprotectedinherited

Definition at line 184 of file PixelAthMonitoringBase.h.

185  {
186  bool is_active=false;
187  bool is_good=false;
188  Identifier pixelID = m_pixelReadout->getPixelIdfromHash(module_hash, chip_i, 1, 1);
189  if (pixelID.is_valid()) {
190  const EventContext& ctx{Gaudi::Hive::currentContext()};
191  is_active = m_pixelCondSummaryTool->isActive(module_hash,pixelID, ctx);
192  if (is_active) {
193  is_good = m_pixelCondSummaryTool->isGood(module_hash, pixelID, ctx);
194  }
195  }
196  return std::make_tuple(is_active,is_good);
197  }

◆ isChipGood() [2/3]

std::tuple<bool,bool> PixelAthMonitoringBase::isChipGood ( const InDet::SiDetectorElementStatus &  element_active,
const InDet::SiDetectorElementStatus &  element_status,
const IdentifierHash &  module_hash,
unsigned int  chip_i 
) const
inlineprotectedinherited

Definition at line 208 of file PixelAthMonitoringBase.h.

211  {
212  return std::make_tuple(element_active.isChipGood(module_hash, chip_i), element_status.isChipGood(module_hash, chip_i) );
213  }

◆ isChipGood() [3/3]

std::tuple<bool,bool> PixelAthMonitoringBase::isChipGood ( const InDet::SiDetectorElementStatus *  element_active,
const InDet::SiDetectorElementStatus *  element_status,
const IdentifierHash &  module_hash,
unsigned int  chip_i 
) const
inlineprotectedinherited

Definition at line 214 of file PixelAthMonitoringBase.h.

217  {
218  std::tuple<bool,bool> ret( element_active && element_status
219  ? isChipGood( *element_active, *element_status, module_hash, chip_i)
220  : isChipGood( module_hash, chip_i) );
221 #ifdef DO_VALIDATE_STATUS_ARRAY
222  Identifier pixelID = m_pixelReadout->getPixelIdfromHash(module_hash, chip_i, 1, 1);
223  const EventContext& ctx{Gaudi::Hive::currentContext()};
224  VALIDATE_STATUS_ARRAY(element_active, element_active->isChipGood(module_hash, chip_i), m_pixelCondSummaryTool->isActive(module_hash,pixelID, ctx) );
225  VALIDATE_STATUS_ARRAY(element_status, element_status->isChipGood(module_hash, chip_i), m_pixelCondSummaryTool->isGood(module_hash,pixelID, ctx) );
226 #endif
227  return ret;
228  }

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 44 of file AthReentrantAlgorithm.cxx.

45 {
46  // Reentrant algorithms are clonable.
47  return true;
48 }

◆ isClusterOnTrack() [1/2]

bool PixelAthMonitoringBase::isClusterOnTrack ( Identifier  id,
std::vector< std::pair< Identifier, double > > const &  ClusterIDs 
) const
inherited

checks if cluster is on track

Definition at line 431 of file PixelAthMonitoringBase.cxx.

432  {
433  bool onTrack = false;
434 
435  std::pair<Identifier, double> searchVal = std::make_pair(id, -1.0);
436  onTrack = std::binary_search(ClusterIDs.begin(), ClusterIDs.end(), searchVal,
437  [](std::pair<Identifier, double> l, std::pair<Identifier, double> r) -> bool {
438  return l.first < r.first;
439  });
440  return onTrack;
441 }

◆ isClusterOnTrack() [2/2]

bool PixelAthMonitoringBase::isClusterOnTrack ( Identifier  id,
std::vector< std::pair< Identifier, double > > const &  ClusterIDs,
double &  cosalpha 
) const
inherited

checks if cluster is on track and returns its cosalpha

Definition at line 448 of file PixelAthMonitoringBase.cxx.

450  {
451  bool onTrack(false);
452 
453  std::pair<Identifier, double> searchVal = std::make_pair(id, -1.0);
454  auto it = std::lower_bound(ClusterIDs.begin(), ClusterIDs.end(), searchVal,
455  [](std::pair<Identifier, double> l, std::pair<Identifier, double> r) -> bool {
456  return l.first < r.first;
457  });
458 
459  if (it != ClusterIDs.end() && !(id < (*it).first)) {
460  onTrack = true;
461  cosalpha = (*it).second;
462  }
463  return onTrack;
464 }

◆ isGood()

bool PixelAthMonitoringBase::isGood ( const InDet::SiDetectorElementStatus *  element_status,
const IdentifierHash &  module_hash 
) const
inlineprotectedinherited

Definition at line 177 of file PixelAthMonitoringBase.h.

178  {
179  const EventContext& ctx{Gaudi::Hive::currentContext()};
180  bool ret ( element_status ? element_status->isGood(module_hash) : m_pixelCondSummaryTool->isGood(module_hash, ctx));
181  VALIDATE_STATUS_ARRAY(element_status, element_status->isGood(module_hash), m_pixelCondSummaryTool->isGood(module_hash, ctx) );
182  return ret;
183  }

◆ isHitOnTrack()

bool PixelAthMonitoringBase::isHitOnTrack ( Identifier  id,
std::vector< Identifier > const &  RDOIDs 
) const
inherited

checks if hit is on track

Definition at line 418 of file PixelAthMonitoringBase.cxx.

418  {
419  return binary_search(RDOIDs.begin(), RDOIDs.end(), id);
420 
421  ;
422 }

◆ isIBL2D()

bool PixelAthMonitoringBase::isIBL2D ( int  hashID) const
inherited

helper function to check if module is IBL planar based on pixel hash ID

Definition at line 336 of file PixelAthMonitoringBase.cxx.

336  {
337  bool result(false);
338  if ( hashID>=156 && hashID<=435 ) // IBL
339  {
340  int module = (hashID-156) % 20;
341  if (module>3 && module<16)
342  {
343  result = true;
344  }
345  }
346  return result;
347 }

◆ isIBL3D()

bool PixelAthMonitoringBase::isIBL3D ( int  hashID) const
inherited

helper function to check if module is IBL 3D based on pixel hash ID

Definition at line 354 of file PixelAthMonitoringBase.cxx.

354  {
355  bool result(false);
356  if ( hashID>=156 && hashID<=435 ) // IBL
357  {
358  int module = (hashID-156) % 20;
359  if (module<4 || module>15)
360  {
361  result = true;
362  }
363  }
364  return result;
365 }

◆ isPerFEI3State()

bool PixelAthErrorMonAlg::isPerFEI3State ( const std::string &  state) const

Definition at line 505 of file PixelAthErrorMonAlg.cxx.

505  {
506  return (state.find("SEU") != std::string::npos ||
507  state.find("EOC") != std::string::npos ||
508  state.find("Warning") != std::string::npos);
509 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

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

◆ parseList()

StatusCode AthMonitorAlgorithm::parseList ( const std::string &  line,
std::vector< std::string > &  result 
) const
virtualinherited

Parse a string into a vector.

The input string is a single long string of all of the trigger names. It parses this string and turns it into a vector, where each element is one trigger or trigger category.

Parameters
lineThe input string.
resultThe parsed output vector of strings.
Returns
StatusCode

Definition at line 336 of file AthMonitorAlgorithm.cxx.

336  {
337  std::string item;
338  std::stringstream ss(line);
339 
340  ATH_MSG_DEBUG( "AthMonitorAlgorithm::parseList()" );
341 
342  while ( std::getline(ss, item, ',') ) {
343  std::stringstream iss(item); // remove whitespace
344  iss >> item;
345  result.push_back(item);
346  }
347 
348  return StatusCode::SUCCESS;
349 }

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

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

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::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 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
97  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

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

◆ trigChainsArePassed()

bool AthMonitorAlgorithm::trigChainsArePassed ( const std::vector< std::string > &  vTrigNames) const
inherited

Check whether triggers are passed.

For the event, use the trigger decision tool to check that at least one of the triggers listed in the supplied vector is passed.

Parameters
vTrigNamesList of trigger names.
Returns
If empty input, default to true. If at least one trigger is specified, returns whether at least one trigger was passed.

Definition at line 194 of file AthMonitorAlgorithm.cxx.

194  {
195 
196 
197  // If no triggers were given, return true.
198  if (vTrigNames.empty()) return true;
199 
200 
201  // Trigger: Check if this Algorithm is being run as an Express Stream job.
202  // Events are entering the express stream are chosen randomly, and by chain,
203  // Hence an additional check should be aplied to see if the chain(s)
204  // monitored here are responsible for the event being selected for
205  // the express stream.
206 
207  const auto group = m_trigDecTool->getChainGroup(vTrigNames);
208  if (m_enforceExpressTriggers){
209  const auto passedBits = m_trigDecTool->isPassedBits(group);
210  bool expressPass = passedBits & TrigDefs::Express_passed; //bitwise AND
211  if(!expressPass) {
212  return false;
213  }
214  }
215 
216  // monitor the event if any of the chains in the chain group passes the event.
217  return group->isPassed();
218 
219 }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ baselayers

list PixelAthMonitoringBase.baselayers = ["ECA","ECC","BLayer","Layer1","Layer2","IBL"]
inherited

Definition at line 25 of file PixelAthMonitoringBase.py.

◆ bcidbinsx

int PixelAthMonitoringBase.bcidbinsx = 3600
inherited

Definition at line 56 of file PixelAthMonitoringBase.py.

◆ btxt

string PixelAthMonitoringBase.btxt = ";eta index of module"
inherited

Definition at line 21 of file PixelAthMonitoringBase.py.

◆ ditxt

string PixelAthMonitoringBase.ditxt = ";disk number"
inherited

Definition at line 23 of file PixelAthMonitoringBase.py.

◆ errbbinsy

list PixelAthMonitoringBase.errbbinsy = [ 17, 17, 17, 17, 17, 27, 27]
inherited

Definition at line 42 of file PixelAthMonitoringBase.py.

◆ errbbsizy

list PixelAthMonitoringBase.errbbsizy = [ 1, 1, 1, 1, 1, 1, 1]
inherited

Definition at line 44 of file PixelAthMonitoringBase.py.

◆ errbminsy

list PixelAthMonitoringBase.errbminsy = [ 0, 0, 0, 0, 0, 0, 0]
inherited

Definition at line 43 of file PixelAthMonitoringBase.py.

◆ ErrCatLabels

list PixelAthMonitoringBase.ErrCatLabels
inherited
Initial value:
= [
("SyncErrors", "Sync Errors (FE/MCC & ROD)"),
("TruncErrors", "Trunc Errors (FE/MCC & ROD)"),
("OpticalErrors", "Preamble/Header Errors"),
("SEUErrors", "SEU Errors"),
("TimeoutErrors", "Timeout Errors")
]

Definition at line 245 of file PixelAthMonitoringBase.py.

◆ ErrCatLabelsNorm

list PixelAthMonitoringBase.ErrCatLabelsNorm
inherited
Initial value:
= [
"SyncErrorsFracPerEvent",
"TruncationErrorsFracPerEvent",
"OpticalErrorsFracPerEvent",
"SEUErrorsFracPerEvent",
"TimeoutErrorsFracPerEvent"
]

Definition at line 253 of file PixelAthMonitoringBase.py.

◆ ErrCatRODModLabels

list PixelAthMonitoringBase.ErrCatRODModLabels
inherited
Initial value:
= [
("SyncErrorsMod", "FE/MCC Sync Errors"),
("SyncErrorsROD", "ROD Sync Errors"),
("TruncErrorsMod", "FE/MCC Trunc Errors"),
("TruncErrorsROD", "ROD Trunc Errors"),
("OpticalErrorsRODMod", "Preamble/Header Errors"),
("SEUErrorsRODMod", "SEU Errors"),
("TimeoutErrorsRODMod", "Timeout Errors")
]

Definition at line 228 of file PixelAthMonitoringBase.py.

◆ ErrCatRODModLabelsNorm

list PixelAthMonitoringBase.ErrCatRODModLabelsNorm
inherited
Initial value:
= [
"SyncErrorsModFracPerEvent",
"SyncErrorsRODFracPerEvent",
"TruncErrorsModFracPerEvent",
"TruncErrorsRODFracPerEvent"
]

Definition at line 238 of file PixelAthMonitoringBase.py.

◆ ErrStateLabelsFEI3

list PixelAthMonitoringBase.ErrStateLabelsFEI3
inherited
Initial value:
= [
("RODTimeout", "ROD Formatter Timeout"),
("RODSyncBCIDErrors", "ROD BCID Sync"),
("RODSyncLVL1IDErrors", "ROD LVL1ID Sync"),
("OpticalErrors", "Preamble/Header"),
("ModSyncLVL1IDErrors", "FE/MCC LVL1ID Sync"),
("ModSyncBCID2Errors", "FE/MCC BCID2 Sync"),
("ModSyncBCID1Errors", "FE/MCC BCID1 Sync"),
("ModTruncEoEOverflowErrors", "FE/MCC EoE Overflow Trunc"),
("ModTruncHitOverflowErrors", "FE/MCC Hit Overflow Trunc"),
("FEWarning", "FE Warning"),
("SEUHitParity", "SEU Hit Parity"),
("SEURegisterParity", "SEU Register Parity"),
("SEUHamming", "SEU Hamming Code"),
("ModTruncEOCErrors", "FE/MCC EoC Trunc"),
("RODTrailerBitErrors", "ROD Trailer Bit"),
("RODTruncHTLimitErrors", "ROD H/T Limit Trunc"),
("RODTruncRODOFErrors", "ROD Overflow Trunc")
]

Definition at line 179 of file PixelAthMonitoringBase.py.

◆ ErrStateLabelsFEI4

list PixelAthMonitoringBase.ErrStateLabelsFEI4
inherited
Initial value:
= [
("RODTimeoutErrors", "ROD Timeout"),
("RODBCIDErrors", "ROD BCID synchronization"),
("RODLVL1IDErrors", "ROD LVL1ID synchronization"),
("RODPreambleErrors", "ROD Preamble"),
("RODTrailerErrors", "ROD Trailer"),
("RODRowColumnErrors", "ROD row-column"),
("RODMaskedLink", "ROD Masked link"),
("RODLimitErrors", "ROD Header Trailer limit"),
("SR0BCIDCounterErrors", "SR0 BCID counter"),
("SR1HammingCode0Errors", "SR1 Hamming code in word 0"),
("SR2HammingCode1Errors", "SR2 Hamming code in word 1"),
("SR3HammingCode2Errors", "SR3 Hamming code in word 2"),
("SR4L1InCounterErrors", "SR4 L1 in counter"),
("SR5L1RequestCounterErrors", "SR5 L1 request counter"),
("SR6L1RegisterErrors", "SR6 L1 register"),
("SR7L1TriggerIDErrors", "SR7 L1 trigger ID"),
("SR8FEReadoutProcessErrors", "SR8 FE readout process"),
("SR15SkipppedTrigCountErrors", "SR15 Skipped trigger counter"),
("SR16TruncatedEventFlagErrors", "SR16 Truncated event"),
("SR24TripleRedundantErrorsCNFGMEM", "SR24 Triple redundant CNFGMEM"),
("SR25WriteRegDataErrors", "SR25 Write register data"),
("SR26AddressErrors", "SR26 Address"),
("SR27OtherCMDDecoderErrors", "SR27 CMD decoder"),
("SR28CMDDecoderBitflipErrors", "SR28 CMD decoder bit flip"),
("SR29TripleRedundantErrorsCMD", "SR29 Triple redundant CMD"),
("SR30DataBusAddressErrors", "SR30 Data bus address"),
("SR31TripleRedundantErrorsEFUSE", "SR31 Triple redundant EFUSE")
]

Definition at line 198 of file PixelAthMonitoringBase.py.

◆ errtbinsy

list PixelAthMonitoringBase.errtbinsy = [ 7, 7, 7, 7, 7, 7, 7]
inherited

Definition at line 45 of file PixelAthMonitoringBase.py.

◆ etatxt

list PixelAthMonitoringBase.etatxt = [ditxt,ditxt,btxt,btxt,btxt,sbtxt]
inherited

Definition at line 29 of file PixelAthMonitoringBase.py.

◆ fei3layers

list PixelAthMonitoringBase.fei3layers = ["ECA","ECC","BLayer","Layer1","Layer2"]
inherited

Definition at line 50 of file PixelAthMonitoringBase.py.

◆ fei4layers

list PixelAthMonitoringBase.fei4layers = ["IBL2D","IBL3D"]
inherited

Definition at line 51 of file PixelAthMonitoringBase.py.

◆ LabelFEX

list PixelAthMonitoringBase.LabelFEX = [LayersDiskFE, LayersDiskFE, ModulesBarrelFE, ModulesBarrelFE, ModulesBarrelFE, ModulesIBL]
inherited

Definition at line 92 of file PixelAthMonitoringBase.py.

◆ LabelFEY

list PixelAthMonitoringBase.LabelFEY = [ModulesFEECA, ModulesFEECC, StavesFEL0, StavesFEL1, StavesFEL2, StavesIBL]
inherited

Definition at line 166 of file PixelAthMonitoringBase.py.

◆ LabelX

list PixelAthMonitoringBase.LabelX = [LayersDisk, LayersDisk, ModulesBarrel, ModulesBarrel, ModulesBarrel, ModulesIBL]
inherited

Definition at line 70 of file PixelAthMonitoringBase.py.

◆ LabelY

list PixelAthMonitoringBase.LabelY = [ModulesECA, ModulesECC, StavesL0, StavesL1, StavesL2, StavesIBL]
inherited

Definition at line 148 of file PixelAthMonitoringBase.py.

◆ layergroups

dictionary PixelAthMonitoringBase.layergroups = {}
inherited

Definition at line 267 of file PixelAthMonitoringBase.py.

◆ layers

list PixelAthMonitoringBase.layers = ["ECA","ECC","BLayer","Layer1","Layer2","IBL2D","IBL3D"]
inherited

Definition at line 24 of file PixelAthMonitoringBase.py.

◆ LayersDisk

list PixelAthMonitoringBase.LayersDisk = ["Disk 1", "Disk 2", "Disk 3"]
inherited

Definition at line 59 of file PixelAthMonitoringBase.py.

◆ LayersDiskFE

list PixelAthMonitoringBase.LayersDiskFE
inherited
Initial value:
= ["Disk1_FE_8_7","Disk1_FE_9_6","Disk1_FE_10_5","Disk1_FE_11_4","Disk1_FE_12_3","Disk1_FE_13_2","Disk1_FE_14_1","Disk1_FE_15_0",
"Disk2_FE_7_8","Disk2_FE_6_9","Disk2_FE_5_10","Disk2_FE_4_11","Disk2_FE_3_12","Disk2_FE_2_13","Disk2_FE_1_14","Disk2_FE_0_15",
"Disk3_FE_8_7","Disk3_FE_9_6","Disk3_FE_10_5","Disk3_FE_11_4","Disk3_FE_12_3","Disk3_FE_13_2","Disk3_FE_14_1","Disk3_FE_15_0"]

Definition at line 73 of file PixelAthMonitoringBase.py.

◆ lumibinsx

int PixelAthMonitoringBase.lumibinsx = 3000
inherited

Definition at line 54 of file PixelAthMonitoringBase.py.

◆ lumitext

string PixelAthMonitoringBase.lumitext = ";lumi block"
inherited

Definition at line 53 of file PixelAthMonitoringBase.py.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 351 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

Gaudi::Property<std::string> AthMonitorAlgorithm::m_dataTypeStr {this,"DataType","userDefined"}
protectedinherited

DataType string pulled from the job option and converted to enum.

Definition at line 353 of file AthMonitorAlgorithm.h.

◆ m_defaultLBDuration

Gaudi::Property<float> AthMonitorAlgorithm::m_defaultLBDuration {this,"DefaultLBDuration",60.}
protectedinherited

Default duration of one lumi block.

Definition at line 360 of file AthMonitorAlgorithm.h.

◆ m_detailLevel

Gaudi::Property<int> AthMonitorAlgorithm::m_detailLevel {this,"DetailLevel",0}
protectedinherited

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doHeavyIonMon

bool PixelAthErrorMonAlg::m_doHeavyIonMon {}
private

Definition at line 173 of file PixelAthErrorMonAlg.h.

◆ m_doHighOccupancy

bool PixelAthErrorMonAlg::m_doHighOccupancy {}
private

Definition at line 172 of file PixelAthErrorMonAlg.h.

◆ m_doLowOccupancy

bool PixelAthErrorMonAlg::m_doLowOccupancy {}
private

Definition at line 171 of file PixelAthErrorMonAlg.h.

◆ m_doLumiBlock

bool PixelAthErrorMonAlg::m_doLumiBlock {}
private

Definition at line 170 of file PixelAthErrorMonAlg.h.

◆ m_doOnline

bool PixelAthErrorMonAlg::m_doOnline {}
private

Definition at line 169 of file PixelAthErrorMonAlg.h.

◆ m_DQFilterTools

ToolHandleArray<IDQFilterTool> AthMonitorAlgorithm::m_DQFilterTools {this,"FilterTools",{}}
protectedinherited

Array of Data Quality filter tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_enforceExpressTriggers

Gaudi::Property<bool> AthMonitorAlgorithm::m_enforceExpressTriggers
privateinherited
Initial value:
{this,
"EnforceExpressTriggers", false,
"Requires that matched triggers made the event enter the express stream"}

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 350 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

Gaudi::Property<std::string> AthMonitorAlgorithm::m_environmentStr {this,"Environment","user"}
protectedinherited

Environment string pulled from the job option and converted to enum.

Definition at line 352 of file AthMonitorAlgorithm.h.

◆ m_EventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> AthMonitorAlgorithm::m_EventInfoKey {this,"EventInfoKey","EventInfo"}
protectedinherited

Key for retrieving EventInfo from StoreGate.

Definition at line 362 of file AthMonitorAlgorithm.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 AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_fileKey

Gaudi::Property<std::string> AthMonitorAlgorithm::m_fileKey {this,"FileKey",""}
protectedinherited

Internal Athena name for file.

Definition at line 358 of file AthMonitorAlgorithm.h.

◆ m_idcErrContKey

SG::ReadHandleKey<IDCInDetBSErrContainer> PixelAthErrorMonAlg::m_idcErrContKey {this, "PixelByteStreamErrs", "PixelByteStreamErrs", "PixelByteStreamErrs container key"}
private

Definition at line 159 of file PixelAthErrorMonAlg.h.

◆ m_lbDurationDataKey

SG::ReadCondHandleKey<LBDurationCondData> AthMonitorAlgorithm::m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
protectedinherited

Definition at line 345 of file AthMonitorAlgorithm.h.

◆ m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> AthMonitorAlgorithm::m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
protectedinherited

Definition at line 343 of file AthMonitorAlgorithm.h.

◆ m_modData

std::vector<int> PixelAthMonitoringBase::m_modData[PixLayers::NBASELAYERS]
protectedinherited

Definition at line 143 of file PixelAthMonitoringBase.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_pixelCondSummaryTool

ToolHandle<IInDetConditionsTool> PixelAthMonitoringBase::m_pixelCondSummaryTool
protectedinherited
Initial value:
{
this, "PixelConditionsSummaryTool", "PixelConditionsSummaryTool", "Tool to retrieve Pixel Conditions summary"
}

Definition at line 135 of file PixelAthMonitoringBase.h.

◆ m_pixelDetElStatus

SG::ReadHandleKey<InDet::SiDetectorElementStatus> PixelAthMonitoringBase::m_pixelDetElStatus {this, "PixelDetElStatus", "", "Key of SiDetectorElementStatus for Pixel"}
protectedinherited

Optional read handle to get status data to test whether a pixel detector element is good.

If set to e.g. PixelDetectorElementStatus the event data will be used instead of the pixel conditions summary tool.

Definition at line 148 of file PixelAthMonitoringBase.h.

◆ m_pixelDetElStatusActiveOnly

SG::ReadHandleKey<InDet::SiDetectorElementStatus> PixelAthMonitoringBase::m_pixelDetElStatusActiveOnly {this, "PixelDetElStatusActiveOnly", "", "Key of SiDetectorElementStatus for Pixel which reflects only whether modules or chips are active rather than delivering good data"}
protectedinherited

Optional read handle to get status data to test whether a pixel detector element is active.

The optional event data is used to test whether a pixel detector element is active but not necessarily good. If set to e.g. PixelDetectorElementStatusActiveOnly the event data will be used instead of the pixel conditions summary tool.

Definition at line 155 of file PixelAthMonitoringBase.h.

◆ m_pixelid

const PixelID* PixelAthMonitoringBase::m_pixelid {}
protectedinherited

Definition at line 142 of file PixelAthMonitoringBase.h.

◆ m_pixelReadout

ServiceHandle<InDetDD::IPixelReadoutManager> PixelAthMonitoringBase::m_pixelReadout
protectedinherited
Initial value:
{
this, "PixelReadoutManager", "PixelReadoutManager", "Pixel readout manager"
}

Definition at line 138 of file PixelAthMonitoringBase.h.

◆ m_readoutTechnologyMask

unsigned int PixelAthErrorMonAlg::m_readoutTechnologyMask {}
private

Definition at line 168 of file PixelAthErrorMonAlg.h.

◆ m_toolLookupMap

std::unordered_map<std::string, size_t> AthMonitorAlgorithm::m_toolLookupMap
privateinherited

Definition at line 367 of file AthMonitorAlgorithm.h.

◆ m_tools

ToolHandleArray<GenericMonitoringTool> AthMonitorAlgorithm::m_tools {this,"GMTools",{}}
protectedinherited

Array of Generic Monitoring Tools.

Definition at line 338 of file AthMonitorAlgorithm.h.

◆ m_trigDecTool

PublicToolHandle<Trig::TrigDecisionTool> AthMonitorAlgorithm::m_trigDecTool {this, "TrigDecisionTool",""}
protectedinherited

Tool to tell whether a specific trigger is passed.

Definition at line 340 of file AthMonitorAlgorithm.h.

◆ m_triggerChainString

Gaudi::Property<std::string> AthMonitorAlgorithm::m_triggerChainString {this,"TriggerChain",""}
protectedinherited

Trigger chain string pulled from the job option and parsed into a vector.

Definition at line 355 of file AthMonitorAlgorithm.h.

◆ m_trigLiveFractionDataKey

SG::ReadCondHandleKey<TrigLiveFractionCondData> AthMonitorAlgorithm::m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}
protectedinherited

Definition at line 347 of file AthMonitorAlgorithm.h.

◆ m_useByteStreamFEI3

Gaudi::Property<bool> PixelAthErrorMonAlg::m_useByteStreamFEI3 {this, "UseByteStreamFEI3", false, "Switch of the ByteStream error for FEI3"}
private

Definition at line 163 of file PixelAthErrorMonAlg.h.

◆ m_useByteStreamFEI4

Gaudi::Property<bool> PixelAthErrorMonAlg::m_useByteStreamFEI4 {this, "UseByteStreamFEI4", false, "Switch of the ByteStream error for FEI4"}
private

Definition at line 161 of file PixelAthErrorMonAlg.h.

◆ m_useByteStreamRD53

Gaudi::Property<bool> PixelAthErrorMonAlg::m_useByteStreamRD53 {this, "UseByteStreamRD53", false, "Switch of the ByteStream error for RD53"}
private

Definition at line 165 of file PixelAthErrorMonAlg.h.

◆ m_useLumi

Gaudi::Property<bool> AthMonitorAlgorithm::m_useLumi {this,"EnableLumi",false}
protectedinherited

Allows use of various luminosity functions.

Definition at line 359 of file AthMonitorAlgorithm.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

std::vector<std::string> AthMonitorAlgorithm::m_vTrigChainNames
protectedinherited

Vector of trigger chain names parsed from trigger chain string.

Definition at line 356 of file AthMonitorAlgorithm.h.

◆ ModulesBarrel

list PixelAthMonitoringBase.ModulesBarrel
inherited
Initial value:
= [
"M6C", "M5C", "M4C", "M3C", "M2C", "M1C", "M0","M1A", "M2A", "M3A", "M4A",
"M5A", "M6A"]

Definition at line 61 of file PixelAthMonitoringBase.py.

◆ ModulesBarrelFE

list PixelAthMonitoringBase.ModulesBarrelFE
inherited
Initial value:
= [
"M6C_FE_8_7","M6C_FE_9_6","M6C_FE_10_5","M6C_FE_11_4","M6C_FE_12_3","M6C_FE_13_2","M6C_FE_14_1","M6C_FE_15_0",
"M5C_FE_8_7","M5C_FE_9_6","M5C_FE_10_5","M5C_FE_11_4","M5C_FE_12_3","M5C_FE_13_2","M5C_FE_14_1","M5C_FE_15_0",
"M4C_FE_8_7","M4C_FE_9_6","M4C_FE_10_5","M4C_FE_11_4","M4C_FE_12_3","M4C_FE_13_2","M4C_FE_14_1","M4C_FE_15_0",
"M3C_FE_8_7","M3C_FE_9_6","M3C_FE_10_5","M3C_FE_11_4","M3C_FE_12_3","M3C_FE_13_2","M3C_FE_14_1","M3C_FE_15_0",
"M2C_FE_8_7","M2C_FE_9_6","M2C_FE_10_5","M2C_FE_11_4","M2C_FE_12_3","M2C_FE_13_2","M2C_FE_14_1","M2C_FE_15_0",
"M1C_FE_8_7","M1C_FE_9_6","M1C_FE_10_5","M1C_FE_11_4","M1C_FE_12_3","M1C_FE_13_2","M1C_FE_14_1","M1C_FE_15_0",
"M0_FE_8_7","M0_FE_9_6","M0_FE_10_5","M0_FE_11_4","M0_FE_12_3","M0_FE_13_2","M0_FE_14_1","M0_FE_15_0",
"M1A_FE_8_7","M1A_FE_9_6","M1A_FE_10_5","M1A_FE_11_4","M1A_FE_12_3","M1A_FE_13_2","M1A_FE_14_1","M1A_FE_15_0",
"M2A_FE_8_7","M2A_FE_9_6","M2A_FE_10_5","M2A_FE_11_4","M2A_FE_12_3","M2A_FE_13_2","M2A_FE_14_1","M2A_FE_15_0",
"M3A_FE_8_7","M3A_FE_9_6","M3A_FE_10_5","M3A_FE_11_4","M3A_FE_12_3","M3A_FE_13_2","M3A_FE_14_1","M3A_FE_15_0",
"M4A_FE_8_7","M4A_FE_9_6","M4A_FE_10_5","M4A_FE_11_4","M4A_FE_12_3","M4A_FE_13_2","M4A_FE_14_1","M4A_FE_15_0",
"M5A_FE_8_7","M5A_FE_9_6","M5A_FE_10_5","M5A_FE_11_4","M5A_FE_12_3","M5A_FE_13_2","M5A_FE_14_1","M5A_FE_15_0",
"M6A_FE_8_7","M6A_FE_9_6","M6A_FE_10_5","M6A_FE_11_4","M6A_FE_12_3","M6A_FE_13_2","M6A_FE_14_1","M6A_FE_15_0"]

Definition at line 77 of file PixelAthMonitoringBase.py.

◆ ModulesECA

list PixelAthMonitoringBase.ModulesECA
inherited
Initial value:
= [
"B01_S2_M1", "B01_S2_M6", "B01_S2_M2", "B01_S2_M5", "B01_S2_M3",
"B01_S2_M4", "B02_S1_M1", "B02_S1_M6", "B02_S1_M2", "B02_S1_M5",
"B02_S1_M3", "B02_S1_M4", "B02_S2_M1", "B02_S2_M6", "B02_S2_M2",
"B02_S2_M5", "B02_S2_M3", "B02_S2_M4", "B03_S1_M1", "B03_S1_M6",
"B03_S1_M2", "B03_S1_M5", "B03_S1_M3", "B03_S1_M4", "B03_S2_M1",
"B03_S2_M6", "B03_S2_M2", "B03_S2_M5", "B03_S2_M3", "B03_S2_M4",
"B04_S1_M1", "B04_S1_M6", "B04_S1_M2", "B04_S1_M5", "B04_S1_M3",
"B04_S1_M4", "B04_S2_M1", "B04_S2_M6", "B04_S2_M2", "B04_S2_M5",
"B04_S2_M3", "B04_S2_M4", "B01_S1_M1", "B01_S1_M6", "B01_S1_M2",
"B01_S1_M5", "B01_S1_M3", "B01_S1_M4"]

Definition at line 94 of file PixelAthMonitoringBase.py.

◆ ModulesECC

list PixelAthMonitoringBase.ModulesECC
inherited
Initial value:
= [
"B01_S2_M4", "B01_S2_M3", "B01_S2_M5", "B01_S2_M2", "B01_S2_M6",
"B01_S2_M1", "B02_S1_M4", "B02_S1_M3", "B02_S1_M5", "B02_S1_M2",
"B02_S1_M6", "B02_S1_M1", "B02_S2_M4", "B02_S2_M3", "B02_S2_M5",
"B02_S2_M2", "B02_S2_M6", "B02_S2_M1", "B03_S1_M4", "B03_S1_M3",
"B03_S1_M5", "B03_S1_M2", "B03_S1_M6", "B03_S1_M1", "B03_S2_M4",
"B03_S2_M3", "B03_S2_M5", "B03_S2_M2", "B03_S2_M6", "B03_S2_M1",
"B04_S1_M4", "B04_S1_M3", "B04_S1_M5", "B04_S1_M2", "B04_S1_M6",
"B04_S1_M1", "B04_S2_M4", "B04_S2_M3", "B04_S2_M5", "B04_S2_M2",
"B04_S2_M6", "B04_S2_M1", "B01_S1_M4", "B01_S1_M3", "B01_S1_M5",
"B01_S1_M2", "B01_S1_M6", "B01_S1_M1"]

Definition at line 105 of file PixelAthMonitoringBase.py.

◆ ModulesFEECA

list PixelAthMonitoringBase.ModulesFEECA = []
inherited

Definition at line 151 of file PixelAthMonitoringBase.py.

◆ ModulesFEECC

list PixelAthMonitoringBase.ModulesFEECC = []
inherited

Definition at line 154 of file PixelAthMonitoringBase.py.

◆ ModulesHead

list PixelAthMonitoringBase.ModulesHead = ["D", "D", "L0", "L1", "L2", "LI"]
inherited

Definition at line 177 of file PixelAthMonitoringBase.py.

◆ ModulesIBL

list PixelAthMonitoringBase.ModulesIBL
inherited
Initial value:
= [
"C8_0", "C8_1", "C7_0", "C7_1", "C6_0", "C6_1", "C5_0", "C5_1", "C4_0", "C4_1", "C3_0", "C3_1", "C2_0", "C2_1",
"C1_0", "C1_1", "A1_0", "A1_1", "A2_0", "A2_1", "A3_0", "A3_1", "A4_0", "A4_1", "A5_0", "A5_1", "A6_0", "A6_1",
"A7_0", "A7_1", "A8_0", "A8_1"]

Definition at line 65 of file PixelAthMonitoringBase.py.

◆ NumLayersDisk

int PixelAthMonitoringBase.NumLayersDisk = 3
inherited

Definition at line 11 of file PixelAthMonitoringBase.py.

◆ NumModulesBarrel

int PixelAthMonitoringBase.NumModulesBarrel = 13
inherited

Definition at line 17 of file PixelAthMonitoringBase.py.

◆ NumModulesDisk

int PixelAthMonitoringBase.NumModulesDisk = 48
inherited

Definition at line 18 of file PixelAthMonitoringBase.py.

◆ NumPP0sEC

int PixelAthMonitoringBase.NumPP0sEC = 24
inherited

Definition at line 19 of file PixelAthMonitoringBase.py.

◆ NumStavesIBL

int PixelAthMonitoringBase.NumStavesIBL = 14
inherited

Definition at line 12 of file PixelAthMonitoringBase.py.

◆ NumStavesL0

int PixelAthMonitoringBase.NumStavesL0 = 22
inherited

Definition at line 13 of file PixelAthMonitoringBase.py.

◆ NumStavesL1

int PixelAthMonitoringBase.NumStavesL1 = 38
inherited

Definition at line 14 of file PixelAthMonitoringBase.py.

◆ NumStavesL2

int PixelAthMonitoringBase.NumStavesL2 = 52
inherited

Definition at line 15 of file PixelAthMonitoringBase.py.

◆ phitext

string PixelAthMonitoringBase.phitext = ";phi index of module"
inherited

Definition at line 30 of file PixelAthMonitoringBase.py.

◆ PP0LabelX

list PixelAthMonitoringBase.PP0LabelX = [PP0sEC, PP0sEC, StavesL0, StavesL1, StavesL2, StavesIBL, StavesIBL]
inherited

Definition at line 174 of file PixelAthMonitoringBase.py.

◆ pp0layers

list PixelAthMonitoringBase.pp0layers = ["ECA","ECC","BLayer","Layer1","Layer2","IBLA","IBLC"]
inherited

Definition at line 47 of file PixelAthMonitoringBase.py.

◆ PP0sEC

list PixelAthMonitoringBase.PP0sEC
inherited
Initial value:
= [
"D1_B01_S2", "D1_B02_S1", "D1_B02_S2", "D1_B03_S1", "D1_B03_S2", "D1_B04_S1", "D1_B04_S2", "D1_B01_S1",
"D2_B01_S2", "D2_B02_S1", "D2_B02_S2", "D2_B03_S1", "D2_B03_S2", "D2_B04_S1", "D2_B04_S2", "D2_B01_S1",
"D3_B01_S2", "D3_B02_S1", "D3_B02_S2", "D3_B03_S1", "D3_B03_S2", "D3_B04_S1", "D3_B04_S2", "D3_B01_S1"]

Definition at line 169 of file PixelAthMonitoringBase.py.

◆ pp0xbins

list PixelAthMonitoringBase.pp0xbins = [ 24, 24, 22, 38, 52, 14, 14]
inherited

Definition at line 48 of file PixelAthMonitoringBase.py.

◆ ReadingDataErrLabels

list PixelAthMonitoringBase.ReadingDataErrLabels
inherited
Initial value:
= [
"Invalid container",
"Invalid collection",
"Container empty"
]

Definition at line 261 of file PixelAthMonitoringBase.py.

◆ runtext

string PixelAthMonitoringBase.runtext = ''
inherited

Definition at line 9 of file PixelAthMonitoringBase.py.

◆ sbtxt

string PixelAthMonitoringBase.sbtxt = ";shifted eta index of module"
inherited

Definition at line 22 of file PixelAthMonitoringBase.py.

◆ StavesFEL0

list PixelAthMonitoringBase.StavesFEL0 = []
inherited

Definition at line 157 of file PixelAthMonitoringBase.py.

◆ StavesFEL1

list PixelAthMonitoringBase.StavesFEL1 = []
inherited

Definition at line 160 of file PixelAthMonitoringBase.py.

◆ StavesFEL2

list PixelAthMonitoringBase.StavesFEL2 = []
inherited

Definition at line 163 of file PixelAthMonitoringBase.py.

◆ StavesIBL

list PixelAthMonitoringBase.StavesIBL
inherited
Initial value:
= [
"S01", "S02", "S03", "S04", "S05", "S06", "S07", "S08", "S09", "S10", "S11",
"S12", "S13","S14"]

Definition at line 144 of file PixelAthMonitoringBase.py.

◆ StavesL0

list PixelAthMonitoringBase.StavesL0
inherited
Initial value:
= [
"B11_S2", "B01_S1", "B01_S2", "B02_S1", "B02_S2", "B03_S1", "B03_S2",
"B04_S1", "B04_S2", "B05_S1", "B05_S2", "B06_S1", "B06_S2", "B07_S1",
"B07_S2", "B08_S1", "B08_S2", "B09_S1", "B09_S2", "B10_S1", "B10_S2",
"B11_S1"]

Definition at line 119 of file PixelAthMonitoringBase.py.

◆ StavesL1

list PixelAthMonitoringBase.StavesL1
inherited
Initial value:
= [
"B01_S1", "B01_S2", "B02_S1", "B02_S2", "B03_S1", "B03_S2", "B04_S1",
"B04_S2", "B05_S1", "B05_S2", "B06_S1", "B06_S2", "B07_S1", "B07_S2",
"B08_S1", "B08_S2", "B09_S1", "B09_S2", "B10_S1", "B10_S2", "B11_S1",
"B11_S2", "B12_S1", "B12_S2", "B13_S1", "B13_S2", "B14_S1", "B14_S2",
"B15_S1", "B15_S2", "B16_S1", "B16_S2", "B17_S1", "B17_S2", "B18_S1",
"B18_S2", "B19_S1", "B19_S2"]

Definition at line 126 of file PixelAthMonitoringBase.py.

◆ StavesL2

list PixelAthMonitoringBase.StavesL2
inherited
Initial value:
= [
"B01_S2", "B02_S1", "B02_S2", "B03_S1", "B03_S2", "B04_S1", "B04_S2",
"B05_S1", "B05_S2", "B06_S1", "B06_S2", "B07_S1", "B07_S2", "B08_S1",
"B08_S2", "B09_S1", "B09_S2", "B10_S1", "B10_S2", "B11_S1", "B11_S2",
"B12_S1", "B12_S2", "B13_S1", "B13_S2", "B14_S1", "B14_S2", "B15_S1",
"B15_S2", "B16_S1", "B16_S2", "B17_S1", "B17_S2", "B18_S1", "B18_S2",
"B19_S1", "B19_S2", "B20_S1", "B20_S2", "B21_S1", "B21_S2", "B22_S1",
"B22_S2", "B23_S1", "B23_S2", "B24_S1", "B24_S2", "B25_S1", "B25_S2",
"B26_S1", "B26_S2", "B01_S1"]

Definition at line 134 of file PixelAthMonitoringBase.py.

◆ totcuts

list PixelAthMonitoringBase.totcuts = [ 15, 15, 15, 15, 15, 4, 4]
inherited

Definition at line 35 of file PixelAthMonitoringBase.py.

◆ xbinsem

list PixelAthMonitoringBase.xbinsem = [ 3, 3, 13, 13, 13, 20]
inherited

Definition at line 36 of file PixelAthMonitoringBase.py.

◆ xbinsfel

list PixelAthMonitoringBase.xbinsfel = [ 24, 24, 104, 104, 104, 32]
inherited

Definition at line 31 of file PixelAthMonitoringBase.py.

◆ xbinsl

list PixelAthMonitoringBase.xbinsl = [ 3, 3, 13, 13, 13, 32]
inherited

Definition at line 26 of file PixelAthMonitoringBase.py.

◆ xbinstotz

list PixelAthMonitoringBase.xbinstotz = [ 3, 3, 13, 13, 13, 20]
inherited

Definition at line 38 of file PixelAthMonitoringBase.py.

◆ xminsem

list PixelAthMonitoringBase.xminsem = [ 0.5, 0.5,-6.5,-6.5,-6.5, -10]
inherited

Definition at line 37 of file PixelAthMonitoringBase.py.

◆ xminsfel

list PixelAthMonitoringBase.xminsfel = [ -0.5, -0.5, -52, -52, -52,-16.5]
inherited

Definition at line 32 of file PixelAthMonitoringBase.py.

◆ xminsl

list PixelAthMonitoringBase.xminsl = [ -0.5, -0.5,-6.5,-6.5,-6.5,-16.5]
inherited

Definition at line 27 of file PixelAthMonitoringBase.py.

◆ xminstotz

list PixelAthMonitoringBase.xminstotz = [ -0.5, -0.5,-0.5,-0.5,-0.5, -0.5]
inherited

Definition at line 39 of file PixelAthMonitoringBase.py.

◆ ybinsfel

list PixelAthMonitoringBase.ybinsfel = [ 96, 96, 44, 76, 104, 14]
inherited

Definition at line 33 of file PixelAthMonitoringBase.py.

◆ ybinsl

list PixelAthMonitoringBase.ybinsl = [ 48, 48, 22, 38, 52, 14]
inherited

Definition at line 28 of file PixelAthMonitoringBase.py.

◆ ztotbinsy

list PixelAthMonitoringBase.ztotbinsy = [ 20, 20, 20, 20, 20, 20, 20]
inherited

Definition at line 40 of file PixelAthMonitoringBase.py.

◆ ztotminsy

list PixelAthMonitoringBase.ztotminsy = [ 19.5, 19.5, 7.5,19.5,19.5, -0.5, -0.5]
inherited

Definition at line 41 of file PixelAthMonitoringBase.py.

The documentation for this class was generated from the following files:
PixelByteStreamErrors::FEHammingCode
@ FEHammingCode
Definition: PixelByteStreamErrors.h:16
beamspotman.r
def r
Definition: beamspotman.py:676
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
PixelAthErrorMonAlg::m_doOnline
bool m_doOnline
Definition: PixelAthErrorMonAlg.h:169
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
checkFileSG.line
line
Definition: checkFileSG.py:75
PixelAthMonitoringBase::getPixLayersID
int getPixLayersID(int ec, int ld) const
helper function to get layers ID
Definition: PixelAthMonitoringBase.cxx:317
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
PixelAthErrorMonAlg::getErrorStateFE
std::bitset< kNumErrorStatesFEI3 > getErrorStateFE(uint64_t errorword, bool isibl) const
Definition: PixelAthErrorMonAlg.cxx:431
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
PixelAthMonitoringBase::m_pixelid
const PixelID * m_pixelid
Definition: PixelAthMonitoringBase.h:142
PixLayers::kBLayer
@ kBLayer
Definition: PixelAthMonitoringBase.h:24
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
python.MagFieldUtils.lumiblock
lumiblock
Definition: MagFieldUtils.py:188
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
PixelByteStreamErrors::LinkMaskedByPPC
@ LinkMaskedByPPC
Definition: PixelByteStreamErrors.h:14
PixelAthErrorMonAlg::isPerFEI3State
bool isPerFEI3State(const std::string &state) const
Definition: PixelAthErrorMonAlg.cxx:505
InDet::SiDetectorElementStatus::isChipGood
bool isChipGood(IdentifierHash hash, unsigned int chip) const
Definition: SiDetectorElementStatus.h:100
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:619
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
PixLayers::NFEI3LAYERS
@ NFEI3LAYERS
Definition: PixelAthMonitoringBase.h:24
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
PixelByteStreamErrors::RODDataOVerflow
@ RODDataOVerflow
Definition: PixelByteStreamErrors.h:17
AmbiguityProcessor::nCategories
@ nCategories
Definition: AmbiguityProcessorUtility.h:24
PixelAthErrorMonAlg::m_useByteStreamFEI3
Gaudi::Property< bool > m_useByteStreamFEI3
Definition: PixelAthErrorMonAlg.h:164
PixelAthMonitoringBase::m_pixelDetElStatusActiveOnly
SG::ReadHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatusActiveOnly
Optional read handle to get status data to test whether a pixel detector element is active.
Definition: PixelAthMonitoringBase.h:156
pixLayersLabel
const std::string pixLayersLabel[PixLayers::COUNT]
Definition: PixelAthMonitoringBase.h:33
PixelAthMonitoringBase::m_pixelCondSummaryTool
ToolHandle< IInDetConditionsTool > m_pixelCondSummaryTool
Definition: PixelAthMonitoringBase.h:135
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
PixMon::kNumFEsIBL
const unsigned int kNumFEsIBL
Definition: PixelAthMonitoringBase.h:62
PixLayers::kLayer2
@ kLayer2
Definition: PixelAthMonitoringBase.h:24
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
PixelAthMonitoringBase::initialize
virtual StatusCode initialize() override
initialize
Definition: PixelAthMonitoringBase.cxx:103
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
skel.it
it
Definition: skel.GENtoEVGEN.py:423
Pixel::makeReadoutTechnologyBit
unsigned int makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology technology, unsigned int bit_val=1)
Create a word with a bit representing the given readout technology to the given value.
Definition: PixelFEUtils.h:60
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
PixelByteStreamErrors::FEWarning
@ FEWarning
Definition: PixelByteStreamErrors.h:16
PixLayers::NBASELAYERS
@ NBASELAYERS
Definition: PixelAthMonitoringBase.h:24
ErrorCategory::kTrunc
@ kTrunc
Definition: PixelAthErrorMonAlg.h:19
PixelByteStreamErrors::MCCBCIDEoECheck
@ MCCBCIDEoECheck
Definition: PixelByteStreamErrors.h:15
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
InDetDD::PixelReadoutTechnology::FEI3
@ FEI3
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
PixelAthMonitoringBase::m_pixelReadout
ServiceHandle< InDetDD::IPixelReadoutManager > m_pixelReadout
Definition: PixelAthMonitoringBase.h:139
PixMon::kNumModulesDisk
const unsigned int kNumModulesDisk
Definition: PixelAthMonitoringBase.h:68
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
PixelAthErrorMonAlg::m_doHeavyIonMon
bool m_doHeavyIonMon
Definition: PixelAthErrorMonAlg.h:173
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
PixelAthErrorMonAlg::m_doLowOccupancy
bool m_doLowOccupancy
Definition: PixelAthErrorMonAlg.h:171
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
InDet::getBSErrorWord
unsigned int getBSErrorWord(const InDet::SiDetectorElementStatus &elementStatus, const IDCInDetBSErrContainer &bsErrorContainer, const IdentifierHash &moduleIdHash, unsigned int index, unsigned int readOutTechnologyMask=(Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI4)|(Pixel::makeReadoutTechnologyBit(InDetDD::PixelReadoutTechnology::FEI3))))
Retrieve the bytestream error word for the given module if the readout technology of the module is co...
Definition: PixelBSUtils.h:16
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:194
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:364
PixelAthMonitoringBase::getPixelDetElStatus
SG::ReadHandle< InDet::SiDetectorElementStatus > getPixelDetElStatus(const SG::ReadHandleKey< InDet::SiDetectorElementStatus > &key, const EventContext &ctx) const
Definition: PixelAthMonitoringBase.h:158
PixelByteStreamErrors::TimeOut
@ TimeOut
Definition: PixelByteStreamErrors.h:13
AthMonitorAlgorithm::Environment_t::user
@ user
pi
#define pi
Definition: TileMuonFitter.cxx:65
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
python.Bindings.values
values
Definition: Control/AthenaPython/python/Bindings.py:797
ErrorCategory::kSeu
@ kSeu
Definition: PixelAthErrorMonAlg.h:19
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
InDetDD::PixelReadoutTechnology::RD53
@ RD53
PixelByteStreamErrors::RODTrailerBitError
@ RODTrailerBitError
Definition: PixelByteStreamErrors.h:17
PixelAthMonitoringBase::fill2DProfLayerAccum
void fill2DProfLayerAccum(const VecAccumulator2DMap &accumulator) const
take VecAccumulator2DMap and fill the corresponding group
Definition: PixelAthMonitoringBase.cxx:119
PixelByteStreamErrors::BCID
@ BCID
Definition: PixelByteStreamErrors.h:13
PixelAthErrorMonAlg::m_readoutTechnologyMask
unsigned int m_readoutTechnologyMask
Definition: PixelAthErrorMonAlg.h:168
PixelByteStreamErrors::RODHeaderLimit
@ RODHeaderLimit
Definition: PixelByteStreamErrors.h:17
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
python.PyAthena.module
module
Definition: PyAthena.py:134
PixelAthMonitoringBase::isChipGood
std::tuple< bool, bool > isChipGood(const IdentifierHash &module_hash, unsigned int chip_i) const
Definition: PixelAthMonitoringBase.h:184
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition: AthMonitorAlgorithm.h:341
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:88
PixelByteStreamErrors::FEEoCOverflow
@ FEEoCOverflow
Definition: PixelByteStreamErrors.h:16
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
sim_rttUpdate.user
def user
Definition: sim_rttUpdate.py:662
VALIDATE_STATUS_ARRAY
#define VALIDATE_STATUS_ARRAY(use_info, info_val, summary_val)
Definition: SiDetectorElementStatus.h:51
lumiFormat.i
int i
Definition: lumiFormat.py:92
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
ret
T ret(T t)
Definition: rootspy.cxx:260
PixelByteStreamErrors::Preamble
@ Preamble
Definition: PixelByteStreamErrors.h:13
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:113
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
PixelByteStreamErrors::Invalid
@ Invalid
Definition: PixelByteStreamErrors.h:14
PixelAthErrorMonAlg::fillErrorCatRODmod
void fillErrorCatRODmod(uint64_t mod_errorword, int(&nerrors_cat_rodmod)[ErrorCategoryRODMOD::COUNT][nFEIBL2D]) const
Definition: PixelAthErrorMonAlg.cxx:457
PixelByteStreamErrors::MCCLVL1IDEoECheck
@ MCCLVL1IDEoECheck
Definition: PixelByteStreamErrors.h:15
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
PixelAthMonitoringBase::isActive
bool isActive(const InDet::SiDetectorElementStatus *element_status, const IdentifierHash &module_hash) const
Definition: PixelAthMonitoringBase.h:170
PixLayers::kLayer1
@ kLayer1
Definition: PixelAthMonitoringBase.h:24
PixLayers::kECC
@ kECC
Definition: PixelAthMonitoringBase.h:24
PixelID::eta_index
int eta_index(const Identifier &id) const
Definition: PixelID.h:664
PixMon::kNumStavesL2
const unsigned int kNumStavesL2
Definition: PixelAthMonitoringBase.h:59
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:472
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
PixelAthMonitoringBase::fill2DProfLumiLayers
void fill2DProfLumiLayers(const std::string &prof2Dname, int lb, float(*weights)[PixLayers::COUNT], const int *nCategories) const
filling 2DProf per-lumi per-layer histograms ["ECA","ECC","BLayer","Layer1","Layer2",...
Definition: PixelAthMonitoringBase.cxx:186
ErrorCategoryRODMOD::COUNT
@ COUNT
Definition: PixelAthErrorMonAlg.h:26
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
PixelByteStreamErrors::MaskedROB
@ MaskedROB
Definition: PixelByteStreamErrors.h:14
ErrorCategory::kSync
@ kSync
Definition: PixelAthErrorMonAlg.h:19
PixLayers::kIBL2D
@ kIBL2D
Definition: PixelAthMonitoringBase.h:24
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
PixelAthMonitoringBase::fill1DProfLumiLayers
void fill1DProfLumiLayers(const std::string &prof1Dname, int lb, float *weights, int nlayers=PixLayers::COUNT) const
filling 1DProf per-lumi per-layer histograms ["ECA","ECC","BLayer","Layer1","Layer2",...
Definition: PixelAthMonitoringBase.cxx:163
PixMon::pixPhiSteps
const int pixPhiSteps[PixLayers::NBASELAYERS]
Definition: PixelAthMonitoringBase.h:74
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
AthMonitorAlgorithm::DataType_t::cosmics
@ cosmics
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
PixelByteStreamErrors::MCCHitOverflow
@ MCCHitOverflow
Definition: PixelByteStreamErrors.h:15
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:626
PixelByteStreamErrors::MCCLVL1IDCheck
@ MCCLVL1IDCheck
Definition: PixelByteStreamErrors.h:15
PixelID::eta_module
int eta_module(const Identifier &id) const
Definition: PixelID.h:651
AthMonitorAlgorithm::Environment_t::online
@ online
PixLayers::kIBL3D
@ kIBL3D
Definition: PixelAthMonitoringBase.h:24
PixLayers::COUNT
@ COUNT
Definition: PixelAthMonitoringBase.h:24
InDet::SiDetectorElementStatus::isGood
bool isGood(IdentifierHash hash) const
Definition: SiDetectorElementStatus.h:97
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
PixLayers::kIBL
@ kIBL
Definition: PixelAthMonitoringBase.h:24
PixelByteStreamErrors::MCCEoEOverflow
@ MCCEoEOverflow
Definition: PixelByteStreamErrors.h:15
PixMon::kNumStavesL0
const unsigned int kNumStavesL0
Definition: PixelAthMonitoringBase.h:53
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
PixMon::kNumModulesBarrel
const unsigned int kNumModulesBarrel
Definition: PixelAthMonitoringBase.h:65
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
PixelAthErrorMonAlg::m_idcErrContKey
SG::ReadHandleKey< IDCInDetBSErrContainer > m_idcErrContKey
Definition: PixelAthErrorMonAlg.h:160
PixelAthErrorMonAlg::m_doHighOccupancy
bool m_doHighOccupancy
Definition: PixelAthErrorMonAlg.h:172
PixelID::wafer_hash_max
size_type wafer_hash_max(void) const
Definition: PixelID.cxx:912
InDetDD::PixelReadoutTechnology::FEI4
@ FEI4
item
Definition: ItemListSvc.h:43
PixelModuleFeMask_create_db.payload
string payload
Definition: PixelModuleFeMask_create_db.py:69
ErrorCategory::kTout
@ kTout
Definition: PixelAthErrorMonAlg.h:19
PixelAthMonitoringBase::isChipActive
bool isChipActive(const IdentifierHash &module_hash, unsigned int chip_i) const
Definition: PixelAthMonitoringBase.h:198
PixelByteStreamErrors::FEHitParity
@ FEHitParity
Definition: PixelByteStreamErrors.h:16
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
ErrorCategory::COUNT
@ COUNT
Definition: PixelAthErrorMonAlg.h:19
h
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
pixBaseLayersLabel
const std::string pixBaseLayersLabel[PixLayers::NBASELAYERS]
Definition: PixelAthMonitoringBase.h:36
PixelAthErrorMonAlg::m_useByteStreamFEI4
Gaudi::Property< bool > m_useByteStreamFEI4
Definition: PixelAthErrorMonAlg.h:162
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: AthMonitorAlgorithm.cxx:7
PixelAthErrorMonAlg::m_doLumiBlock
bool m_doLumiBlock
Definition: PixelAthErrorMonAlg.h:170
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
PixelByteStreamErrors::FERegisterParity
@ FERegisterParity
Definition: PixelByteStreamErrors.h:16
PixMon::kNumStavesIBL
const unsigned int kNumStavesIBL
Definition: PixelAthMonitoringBase.h:50
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
PixelAthErrorMonAlg::getErrorStateFEI3Mod
std::bitset< kNumErrorStatesFEI3 > getErrorStateFEI3Mod(uint64_t errorword) const
Definition: PixelAthErrorMonAlg.cxx:419
PixelAthErrorMonAlg::getErrorCategory
int getErrorCategory(int error_cat_rodmod) const
Definition: PixelAthErrorMonAlg.cxx:408
PixelAthMonitoringBase::m_modData
std::vector< int > m_modData[PixLayers::NBASELAYERS]
Definition: PixelAthMonitoringBase.h:143
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
PixMon::kNumLayersDisk
const unsigned int kNumLayersDisk
Definition: PixelAthMonitoringBase.h:47
fillSCTHists.etaMod
etaMod
Definition: fillSCTHists.py:23
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:644
PixelByteStreamErrors::Limit
@ Limit
Definition: PixelByteStreamErrors.h:14
PixelAthErrorMonAlg::m_useByteStreamRD53
Gaudi::Property< bool > m_useByteStreamRD53
Definition: PixelAthErrorMonAlg.h:166
ErrorCategoryRODMOD::kTruncROD
@ kTruncROD
Definition: PixelAthErrorMonAlg.h:26
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
PixLayers::kECA
@ kECA
Definition: PixelAthMonitoringBase.h:24
geometry_dat_to_json.ld
ld
Definition: geometry_dat_to_json.py:14
PixelByteStreamErrors::TruncatedROB
@ TruncatedROB
Definition: PixelByteStreamErrors.h:14
PixelByteStreamErrors::Trailer
@ Trailer
Definition: PixelByteStreamErrors.h:13
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition: AthMonitorAlgorithm.cxx:164
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
ErrorCategory::kOpt
@ kOpt
Definition: PixelAthErrorMonAlg.h:19
fitman.k
k
Definition: fitman.py:528
PixMon::kNumStavesL1
const unsigned int kNumStavesL1
Definition: PixelAthMonitoringBase.h:56
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
PlotCalibFromCool.vals
vals
Definition: PlotCalibFromCool.py:474
collisions
Definition: collisions.py:1
PixelByteStreamErrors::LVL1ID
@ LVL1ID
Definition: PixelByteStreamErrors.h:13
Generated on Tue Jul 2 2024 21:55:54 for ATLAS Offline Software by   doxygen 1.8.18