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
PixelAthClusterMonAlg Class Reference

#include <PixelAthClusterMonAlg.h>

Inheritance diagram for PixelAthClusterMonAlg:
Collaboration diagram for PixelAthClusterMonAlg:

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

 PixelAthClusterMonAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~PixelAthClusterMonAlg ()
 
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
 
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

ToolHandle< Trk::ITrackHoleSearchTool > m_holeSearchTool
 
ToolHandle< InDet::IInDetTrackSelectionTool > m_trackSelTool
 
const AtlasDetectorID * m_atlasid {}
 
SG::ReadHandleKey< InDet::PixelClusterContainer > m_clustersKey
 
SG::ReadHandleKey< TrackCollection > m_tracksKey
 
bool m_doOnline {}
 
bool m_doLumiBlock {}
 
bool m_doLowOccupancy {}
 
bool m_doHighOccupancy {}
 
bool m_doHeavyIonMon {}
 
bool m_doFEPlots {}
 
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 33 of file PixelAthClusterMonAlg.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

◆ PixelAthClusterMonAlg()

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

Definition at line 20 of file PixelAthClusterMonAlg.cxx.

20  :
21  AthMonitorAlgorithm(name, pSvcLocator),
22  m_holeSearchTool("InDet::InDetTrackHoleSearchTool/InDetHoleSearchTool", this),
23  m_trackSelTool("InDet::InDetTrackSelectionTool/TrackSelectionTool", this),
24  m_atlasid(nullptr)
25 {
26  declareProperty("HoleSearchTool", m_holeSearchTool);
27  declareProperty("TrackSelectionTool", m_trackSelTool);
28 
29  declareProperty("doOnline", m_doOnline = false);
30  declareProperty("doLumiBlock", m_doLumiBlock = false);
31  declareProperty("doLowOccupancy", m_doLowOccupancy = false);
32  declareProperty("doHighOccupancy", m_doHighOccupancy = true);
33  declareProperty("doHeavyIonMon", m_doHeavyIonMon = false);
34  declareProperty("doFEPlots", m_doFEPlots = false);
35 }

◆ ~PixelAthClusterMonAlg()

PixelAthClusterMonAlg::~PixelAthClusterMonAlg ( )
virtual

Definition at line 37 of file PixelAthClusterMonAlg.cxx.

37 {}

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 }

◆ 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 PixelAthClusterMonAlg::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 51 of file PixelAthClusterMonAlg.cxx.

51  {
52  using namespace Monitored;
53 
54  int lb = GetEventInfo(ctx)->lumiBlock();
55 
56  //*******************************************************************************
57  //************************** Begin of filling Status Histograms ******************
58  //*******************************************************************************
59 
60 
61  ATH_MSG_DEBUG("Filling Status Monitoring Histograms");
62  float index = 1.0;
63  float nBadMod[PixLayers::COUNT] = {
64  0.
65  };
66  float nDisabledMod[PixLayers::COUNT] = {
67  0.
68  };
69  float nBadAndDisabledMod[PixLayers::COUNT] = {
70  0.
71  };
72  int phiMod(-99);
73  int etaMod(-99);
74  bool copyFEval(false);
75  AccumulatorArrays clusPerEventArray = {{{0}}, {{0}}, {{0}}, {{0}}, {{0}}, {{0}}};
76  VecAccumulator2DMap Map_Of_Modules_Status(*this, "MapOfModulesStatus", true);
77 
78  VecAccumulator2DMap Map_Of_FEs_Status(*this, "MapOfFEsStatus");
79 
80  SG::ReadHandle<InDet::SiDetectorElementStatus> pixel_active = getPixelDetElStatus(m_pixelDetElStatusActiveOnly,ctx);
81  SG::ReadHandle<InDet::SiDetectorElementStatus> pixel_status = getPixelDetElStatus(m_pixelDetElStatus,ctx);
82  for (auto idIt = m_pixelid->wafer_begin(); idIt != m_pixelid->wafer_end(); ++idIt) {
83  Identifier waferID = *idIt;
84  IdentifierHash id_hash = m_pixelid->wafer_hash(waferID);
85 
86  int pixlayer = getPixLayersID(m_pixelid->barrel_ec(waferID), m_pixelid->layer_disk(waferID));
87  if (pixlayer == 99) continue;
88  getPhiEtaMod(waferID, phiMod, etaMod, copyFEval);
89 
90  if (isActive( !m_pixelDetElStatusActiveOnly.empty() ? pixel_active.cptr() : nullptr, id_hash) )
91  {
92  if (isGood( !m_pixelDetElStatus.empty() ? pixel_status.cptr() : nullptr, id_hash) ) index = 0;
93  else {
94  index = 1; // active but bad modules
95  if (pixlayer == PixLayers::kIBL) {
96  int iblsublayer = (m_pixelid->eta_module(waferID) > -7 && m_pixelid->eta_module(waferID) < 6) ? PixLayers::kIBL2D : PixLayers::kIBL3D;
97  nBadMod[iblsublayer] += inv_nmod_per_layer[iblsublayer];
98  } else nBadMod[pixlayer] += inv_nmod_per_layer[pixlayer];
99  }
100  }
101  else {
102  index = 2; // inactive (disabled) modules
103  if (pixlayer == PixLayers::kIBL) {
104  int iblsublayer = (m_pixelid->eta_module(waferID) > -7 && m_pixelid->eta_module(waferID) < 6) ? PixLayers::kIBL2D : PixLayers::kIBL3D;
105  nDisabledMod[iblsublayer] += inv_nmod_per_layer[iblsublayer];
106  } else nDisabledMod[pixlayer] += inv_nmod_per_layer[pixlayer];
107  switch (pixlayer) {
108  case PixLayers::kECA:
109  clusPerEventArray.DA[phiMod][etaMod] = -1;
110  break;
111 
112  case PixLayers::kECC:
113  clusPerEventArray.DC[phiMod][etaMod] = -1;
114  break;
115 
116  case PixLayers::kBLayer:
117  clusPerEventArray.B0[phiMod][etaMod] = -1;
118  break;
119 
120  case PixLayers::kLayer1:
121  clusPerEventArray.B1[phiMod][etaMod] = -1;
122  break;
123 
124  case PixLayers::kLayer2:
125  clusPerEventArray.B2[phiMod][etaMod] = -1;
126  break;
127 
128  case PixLayers::kIBL:
129  clusPerEventArray.IBL[phiMod][etaMod] = -1;
130  if (copyFEval) clusPerEventArray.IBL[phiMod][++etaMod] = -1;
131  break;
132  }
133  }
134 
135  Map_Of_Modules_Status.add(pixlayer, waferID, index);
136 
137  // Per FE Status
138  //
139  if (m_doFEPlots) {
140  int nFE = getNumberOfFEs(pixlayer, m_pixelid->eta_module(waferID));
141  for (int iFE = 0; iFE < nFE; iFE++) {
142  Identifier pixelID = m_pixelReadout->getPixelIdfromHash(id_hash, iFE, 1, 1);
143  if (not pixelID.is_valid()) continue;
144  auto [is_active,is_good ] =isChipGood( !m_pixelDetElStatusActiveOnly.empty() ? pixel_active.cptr() : nullptr,
145  !m_pixelDetElStatus.empty() ? pixel_status.cptr() : nullptr,
146  id_hash,
147  iFE);
148  if (is_active)
149  {
150  if (is_good) index = 0;
151  else index = 1;
152  }
153  else index = 2;
154  Map_Of_FEs_Status.add(pixlayer, waferID, iFE, index);
155  }
156  }
157  } // end of pixelid wafer loop
158 
159  fill2DProfLayerAccum(Map_Of_Modules_Status);
160  fill1DProfLumiLayers("BadModulesPerLumi", lb, nBadMod);
161  fill1DProfLumiLayers("DisabledModulesPerLumi", lb, nDisabledMod);
162 
163  for (unsigned int ii = 0; ii < PixLayers::COUNT; ii++) nBadAndDisabledMod[ii] = nBadMod[ii]+nDisabledMod[ii];
164  fill1DProfLumiLayers("BadAndDisabledModulesPerLumi", lb, nBadAndDisabledMod);
165 
166  if (m_doFEPlots) fill2DProfLayerAccum(Map_Of_FEs_Status);
167 
168  //*******************************************************************************
169  //*************************** End of filling Status Histograms ******************
170  //*******************************************************************************
171 
172 
173  //*******************************************************************************
174  //************************** Begin of filling Track Histograms ******************
175  //*******************************************************************************
176 
177 
178  ATH_MSG_DEBUG("Filling Track Monitoring Histograms");
179 
180  VecAccumulator2DMap TSOS_Outlier(*this, "TSOSOutlier");
181  VecAccumulator2DMap TSOS_Outlier_FE(*this, "TSOSOutlierFE");
182  VecAccumulator2DMap TSOS_Hole(*this, "TSOSHole");
183  VecAccumulator2DMap TSOS_Hole_FE(*this, "TSOSHoleFE");
184  VecAccumulator2DMap TSOS_Measurement(*this, "TSOSMeasurement");
185  VecAccumulator2DMap TSOS_Measurement_FE(*this, "TSOSMeasurementFE");
186  VecAccumulator2DMap HolesRatio(*this, "HolesRatio");
187  VecAccumulator2DMap MissHitsRatio(*this, "MissHitsRatio");
188  auto trackGroup = getGroup("Track");
189 
190  auto tracks = SG::makeHandle(m_tracksKey, ctx);
191 
192  if (!(tracks.isValid())) {
193  ATH_MSG_ERROR("PixelMonitoring: Track container " << m_tracksKey.key() << " could not be found.");
194  auto dataread_err = Monitored::Scalar<int>("trkdataread_err", DataReadErrors::ContainerInvalid);
195  fill(trackGroup, dataread_err);
196  return StatusCode::RECOVERABLE;
197  } else {
198  ATH_MSG_DEBUG("PixelMonitoring: Track container " << tracks.name() << " is found.");
199  }
200 
201  int ntracksPerEvent = 0;
202  bool havePixelHits(false);
203  std::vector<std::pair<Identifier, double> > ClusterIDs;
204 
205  auto lbval = Monitored::Scalar<int>("pixclusmontool_lb", lb);
206 
207  for (auto track: *tracks) {
208  if (track == nullptr || track->perigeeParameters() == nullptr || track->trackSummary() == nullptr ||
209  track->trackSummary()->get(Trk::numberOfPixelHits) == 0) {
210  ATH_MSG_DEBUG("PixelMonitoring: Track either invalid or it does not contain pixel hits, continuing...");
211  continue;
212  }
213 
214  int nPixelHits = 0;
215  const Trk::Perigee* measPerigee = static_cast<const Trk::Perigee*>(track->perigeeParameters());
216  bool passJOTrkTightCut = static_cast<bool>(m_trackSelTool->accept(*track));
217  bool pass1hole1GeVptTightCut = (passJOTrkTightCut && (measPerigee->pT() / 1000.0 > 1.0)); // misshit ratios
218  bool pass1hole5GeVptTightCut = (passJOTrkTightCut && (measPerigee->pT() / 1000.0 > 5.0)); // eff vs lumi
219 
220  const Trk::Track* trackWithHoles(track);
221  std::unique_ptr<const Trk::Track> trackWithHolesUnique = nullptr;
222  if (track->trackSummary()->get(Trk::numberOfPixelHoles) > 0) {
223  trackWithHolesUnique.reset(m_holeSearchTool->getTrackWithHoles(*track));
224  trackWithHoles = trackWithHolesUnique.get();
225  }
226  const Trk::TrackStates* trackStates = trackWithHoles->trackStateOnSurfaces();
227  for (auto trackStateOnSurface: *trackStates) {
228  const Trk::MeasurementBase* mesBase = trackStateOnSurface->measurementOnTrack();
229 
230  const Trk::RIO_OnTrack* RIOOnTrack = nullptr;
231  if (mesBase && mesBase->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
232  RIOOnTrack = static_cast<const Trk::RIO_OnTrack*>(mesBase);
233  }
234 
235  if (mesBase && !RIOOnTrack) continue; // skip pseudomeasurements
236  // but not hits, holes,
237  // outliers
238 
239  const Trk::TrackParameters* trkParameters = trackStateOnSurface->trackParameters();
240  Identifier surfaceID;
241  if (mesBase && mesBase->associatedSurface().associatedDetectorElement()) {
242  surfaceID = mesBase->associatedSurface().associatedDetectorElement()->identify();
243  } else { // holes, perigee
244  if (trkParameters) {
245  surfaceID = trkParameters->associatedSurface().associatedDetectorElementIdentifier();
246  } else {
247  ATH_MSG_INFO("PixelMonitoring: pointer of TSOS to track parameters or associated surface is null");
248  continue;
249  }
250  }
251  if (!m_atlasid->is_pixel(surfaceID)) continue;
252  int pixlayer = getPixLayersID(m_pixelid->barrel_ec(surfaceID), m_pixelid->layer_disk(surfaceID));
253  if (pixlayer == 99) continue;
254 
255  float nOutlier = 0.;
256  float nHole = 0.;
257  auto effval = Monitored::Scalar<float>("HitEffAll_val", 0.);
258  auto efflb = Monitored::Scalar<float>("HitEffAll_lb", lb);
259  const InDetDD::SiDetectorElement *sde = dynamic_cast<const InDetDD::SiDetectorElement *>(trkParameters->associatedSurface().associatedDetectorElement());
260  const InDetDD::SiLocalPosition trkLocalPos = trkParameters->localPosition();
261  Identifier locPosID;
262 
263  if (trackStateOnSurface->type(Trk::TrackStateOnSurface::Outlier))
264  {
265  nOutlier = 1.0;
266  const InDet::SiClusterOnTrack *siclus = dynamic_cast<const InDet::SiClusterOnTrack *>(mesBase);
267  if ( mesBase && siclus) {
268  locPosID = siclus->identify();
269  if ( !(locPosID.is_valid()) ) {
270  ATH_MSG_INFO("Pixel Monitoring: got invalid track local position on surface for an outlier.");
271  continue;
272  }
273  TSOS_Outlier.add(pixlayer, locPosID, 1.0);
274  if (!m_doOnline) {
275  TSOS_Outlier_FE.add(pixlayer, locPosID, m_pixelReadout->getFE(locPosID, locPosID), 1.0);
276  }
277  }
278  }
279  else if (trackStateOnSurface->type(Trk::TrackStateOnSurface::Hole))
280  {
281  nHole = 1.0;
282  locPosID = sde->identifierOfPosition(trkLocalPos);
283  if ( !(locPosID.is_valid()) ) {
284  ATH_MSG_INFO("Pixel Monitoring: got invalid track local position on surface for a hole.");
285  continue;
286  }
287  TSOS_Hole.add(pixlayer, locPosID, 1.0);
288  if (!m_doOnline) {
289  TSOS_Hole_FE.add(pixlayer, locPosID, m_pixelReadout->getFE(locPosID, locPosID), 1.0);
290  }
291  }
292  else if (trackStateOnSurface->type(Trk::TrackStateOnSurface::Measurement))
293  {
294  if (not mesBase) continue;
295  const InDetDD::SiDetectorElement* side =
296  dynamic_cast<const InDetDD::SiDetectorElement*>(mesBase->associatedSurface().associatedDetectorElement());
297  const InDet::SiClusterOnTrack* clus = dynamic_cast<const InDet::SiClusterOnTrack*>(mesBase);
298  if (!side || !clus) continue;
299  const InDet::SiCluster* RawDataClus = dynamic_cast<const InDet::SiCluster*>(clus->prepRawData());
300  if (!RawDataClus || !RawDataClus->detectorElement()->isPixel()) continue;
301 
302  nPixelHits++;
303 
304  locPosID = clus->identify();
305  if ( !(locPosID.is_valid()) ) {
306  ATH_MSG_INFO("Pixel Monitoring: got invalid cluster on track ID.");
307  continue;
308  }
309  TSOS_Measurement.add(pixlayer, locPosID, 1.0);
310  if (!m_doOnline) {
311  TSOS_Measurement_FE.add(pixlayer, locPosID, m_pixelReadout->getFE(locPosID, locPosID), 1.0);
312  }
313  effval = 1.;
314 
315  const Trk::AtaPlane* trackAtPlane = dynamic_cast<const Trk::AtaPlane*>(trkParameters);
316  if (trackAtPlane) {
317  const Amg::Vector2D localpos = trackAtPlane->localPosition();
318 
319  // Get local error matrix for hit and track and calc pull
320  const AmgSymMatrix(5) trackErrMat = (*trackAtPlane->covariance());
321  const Amg::MatrixX clusErrMat = clus->localCovariance();
322 
323  double error_sum =
324  sqrt(pow(Amg::error(trackErrMat, Trk::locX), 2) + pow(Amg::error(clusErrMat, Trk::locX), 2));
325  auto resPhi = Monitored::Scalar<float>("res_phi", clus->localParameters()[Trk::locX] - localpos[0]);
326  fill(trackGroup, resPhi);
327  if (error_sum != 0) {
328  auto pullPhi = Monitored::Scalar<float>("pull_phi", resPhi / error_sum);
329  fill(trackGroup, pullPhi);
330  }
331 
332  error_sum = sqrt(pow(Amg::error(trackErrMat, Trk::locY), 2) + pow(Amg::error(clusErrMat, Trk::locY), 2));
333  auto resEta = Monitored::Scalar<float>("res_eta", clus->localParameters()[Trk::locY] - localpos[1]);
334  fill(trackGroup, resEta);
335  if (error_sum != 0) {
336  auto pullEta = Monitored::Scalar<float>("pull_eta", resEta / error_sum);
337  fill(trackGroup, pullEta);
338  }
339  // Filling containers, which hold id's of hits and clusters on track
340  // _and_ incident angle information for later normalization
341 
342  Amg::Vector3D mynormal = side->normal();
343  Amg::Vector3D mytrack = trackAtPlane->momentum();
344  double trknormcomp = mytrack.dot(mynormal);
345 
346  double mytrack_mag = mytrack.mag();
347  double cosalpha = 0.;
348  if (mytrack_mag != 0) cosalpha = std::abs(trknormcomp / mytrack_mag);
349  ClusterIDs.emplace_back(clus->identify(), cosalpha);
350  }
351  } // end of measurement case
352  else continue;
353 
354  if (pass1hole5GeVptTightCut) {
355  if (pixlayer == PixLayers::kIBL) {
356  int iblsublayer = (m_pixelid->eta_module(surfaceID) > -7 && m_pixelid->eta_module(surfaceID) < 6) ? PixLayers::kIBL2D : PixLayers::kIBL3D;
357  fill(pixLayersLabel[iblsublayer], efflb, effval);
358  } else fill(pixLayersLabel[pixlayer], efflb, effval);
359  }
360 
361  if (pass1hole1GeVptTightCut && locPosID.is_valid()) {
362  HolesRatio.add(pixlayer, locPosID, nHole);
363  MissHitsRatio.add(pixlayer, locPosID, nOutlier + nHole);
364  }
365  } // end of TSOS loop
366 
367  ntracksPerEvent++;
368  auto nph = Monitored::Scalar<int>("npixhits_per_track", nPixelHits);
369  auto nphwgt = Monitored::Scalar<float>("npixhits_per_track_wgt", 1.0);
370  fill(trackGroup, lbval, nph, nphwgt);
371 
372  int trkfitndf = track->fitQuality()->numberDoF();
373  double trkfitchi2 = track->fitQuality()->chiSquared();
374  if (trkfitndf != 0) {
375  auto trkChiN = Monitored::Scalar<float>("fit_chi2byndf", trkfitchi2 / trkfitndf);
376  fill(trackGroup, trkChiN);
377  }
378  havePixelHits = havePixelHits || (nPixelHits > 0);
379  } // end of track loop
380 
381  if (!havePixelHits) {
382  auto dataread_err = Monitored::Scalar<int>("trkdataread_err", DataReadErrors::EmptyContainer);
383  fill(trackGroup, dataread_err);
384  }
385 
386  fill2DProfLayerAccum(HolesRatio);
387  fill2DProfLayerAccum(MissHitsRatio);
388  fill2DProfLayerAccum(TSOS_Outlier);
389  fill2DProfLayerAccum(TSOS_Hole);
390  fill2DProfLayerAccum(TSOS_Measurement);
391  if (!m_doOnline) {
392  fill2DProfLayerAccum(TSOS_Outlier_FE);
393  fill2DProfLayerAccum(TSOS_Hole_FE);
394  fill2DProfLayerAccum(TSOS_Measurement_FE);
395  }
396 
397  sort(ClusterIDs.begin(), ClusterIDs.end(),
398  [](const std::pair<Identifier, double>& left, const std::pair<Identifier, double>& right) {
399  return left.first < right.first;
400  });
401 
402  auto nTrks = Monitored::Scalar<int>("ntrks_per_event", ntracksPerEvent);
403  fill(trackGroup, lbval, nTrks);
404 
405  //*******************************************************************************
406  //**************************** End of filling Track Histograms ******************
407  //*******************************************************************************
408 
409  //*******************************************************************************
410  //************************ Begin of filling Cluster Histograms ******************
411  //*******************************************************************************
412 
413  ATH_MSG_DEBUG("Filling Cluster Monitoring Histograms");
414 
415 
416  auto clToTcosAlphaLB = Monitored::Scalar<float>("ClusterToTxCosAlphaOnTrack_lb", lb);
417 
418  VecAccumulator2DMap Cluster_LVL1A_Mod(*this, "ClusterLVL1AMod");
419  VecAccumulator2DMap Cluster_LVL1A_SizeCut(*this, "ClusterLVL1ASizeCut");
420  VecAccumulator2DMap Cluster_LVL1A_Mod_OnTrack(*this, "ClusterLVL1AModOnTrack");
421  VecAccumulator2DMap Cluster_LVL1A_SizeCut_OnTrack(*this, "ClusterLVL1ASizeCutOnTrack");
422  VecAccumulator2DMap ClusterMap_Mon(*this, "ClusterMapMon");
423  VecAccumulator2DMap ClusterMap_Mon_OnTrack(*this, "ClusterMapMonOnTrack");
424  VecAccumulator2DMap Cluster_Size_Map_OnTrack(*this, "ClusterSizeMapOnTrack");
425  VecAccumulator2DMap Cluster_Occupancy(*this, "ClusterOccupancy");
426  VecAccumulator2DMap Cluster_Occupancy_OnTrack(*this, "ClusterOccupancyOnTrack");
427  VecAccumulator2DMap Clus_Occ_SizeCut(*this, "ClusOccSizeCut");
428  VecAccumulator2DMap Clus_Occ_SizeCut_OnTrack(*this, "ClusOccSizeCutOnTrack");
429  VecAccumulator2DMap Cluster_FE_Occupancy(*this, "ClusterFEOccupancy");
430  VecAccumulator2DMap Cluster_FE_Occupancy_OnTrack(*this, "ClusterFEOccupancyOnTrack");
431 
432  auto clusterGroup = getGroup("Cluster");
433  auto clusterGroup_OnTrack = getGroup("Cluster_OnTrack");
434 
435  auto pixel_clcontainer = SG::makeHandle(m_clustersKey, ctx);
436 
437  if (!(pixel_clcontainer.isValid())) {
438  ATH_MSG_ERROR("Pixel Monitoring: Pixel Cluster container " << m_clustersKey.key() << " could not be found.");
439  auto dataread_err = Monitored::Scalar<int>("clsdataread_err", DataReadErrors::ContainerInvalid);
440  fill(clusterGroup, dataread_err);
441  return StatusCode::RECOVERABLE;
442  } else {
443  ATH_MSG_DEBUG("Pixel Monitoring: Pixel Cluster container " << pixel_clcontainer.name() << " is found.");
444  }
445 
446  int nclusters = 0;
447  int nclusters_ontrack = 0;
448  float nclusters_mod[PixLayers::COUNT] = {
449  0.
450  };
451  float nclusters_ontrack_mod[PixLayers::COUNT] = {
452  0.
453  };
454 
455  Identifier clusID;
456  for (auto colNext: *pixel_clcontainer) {
457  const InDet::PixelClusterCollection* ClusterCollection(colNext);
458  if (!ClusterCollection) {
459  ATH_MSG_DEBUG("Pixel Monitoring: Pixel Cluster container is empty.");
460  auto dataread_err = Monitored::Scalar<int>("clsdataread_err", DataReadErrors::CollectionInvalid);
461  fill(clusterGroup, dataread_err);
462  continue;
463  }
464 
465  for (auto p_clus: *ClusterCollection) {
466  clusID = p_clus->identify();
467  int pixlayer = getPixLayersID(m_pixelid->barrel_ec(clusID), m_pixelid->layer_disk(clusID));
468  if (pixlayer == 99) continue;
469  getPhiEtaMod(clusID, phiMod, etaMod, copyFEval);
470 
471  const InDet::PixelCluster& cluster = *p_clus;
472  nclusters++;
473 
474  // begin timing histos
475  //
476  auto clLVL1A = Monitored::Scalar<float>("Cluster_LVL1A_lvl1a", cluster.LVL1A());
477  fill(clusterGroup, clLVL1A);
478  Cluster_LVL1A_Mod.add(pixlayer, clusID, cluster.LVL1A() + 0.00001);
479  if (cluster.rdoList().size() > 1) Cluster_LVL1A_SizeCut.add(pixlayer, clusID, cluster.LVL1A() + 0.00001);
480  if (pixlayer == PixLayers::kIBL) {
481  int iblsublayer = (m_pixelid->eta_module(clusID) > -7 && m_pixelid->eta_module(clusID) < 6) ? PixLayers::kIBL2D : PixLayers::kIBL3D;
482  if (cluster.totalToT() > clusterToTMinCut[iblsublayer]) fill("ClusterLVL1AToTCut_" + pixLayersLabel[iblsublayer], clLVL1A);
483  nclusters_mod[iblsublayer]++;
484  } else {
485  if (cluster.totalToT() > clusterToTMinCut[pixlayer]) fill("ClusterLVL1AToTCut_" + pixLayersLabel[pixlayer], clLVL1A);
486  nclusters_mod[pixlayer]++;
487  }
488  //
489  // end timing histos
490  // begin cluster rate
491  //
492  if (m_doOnline) ClusterMap_Mon.add(pixlayer, clusID);
493  //
494  // end cluster rate
495  // begin cluster occupancy
496  //
497  Cluster_Occupancy.add(pixlayer, clusID);
498  if (m_doFEPlots) {
499  Cluster_FE_Occupancy.add(pixlayer, clusID, m_pixelReadout->getFE(clusID, clusID), 1.0);
500  }
501  if (cluster.rdoList().size() > 1) Clus_Occ_SizeCut.add(pixlayer, clusID);
502  // end cluster occupancy
503 
504  double cosalpha(0.);
505  if (isClusterOnTrack(clusID, ClusterIDs, cosalpha)) {
506  nclusters_ontrack++;
507  switch (pixlayer) {
508  case PixLayers::kECA:
509  clusPerEventArray.DA[phiMod][etaMod]++;
510  break;
511 
512  case PixLayers::kECC:
513  clusPerEventArray.DC[phiMod][etaMod]++;
514  break;
515 
516  case PixLayers::kBLayer:
517  clusPerEventArray.B0[phiMod][etaMod]++;
518  break;
519 
520  case PixLayers::kLayer1:
521  clusPerEventArray.B1[phiMod][etaMod]++;
522  break;
523 
524  case PixLayers::kLayer2:
525  clusPerEventArray.B2[phiMod][etaMod]++;
526  break;
527 
528  case PixLayers::kIBL:
529  clusPerEventArray.IBL[phiMod][etaMod]++;
530  break;
531  }
532  // begin timing histos
533  //
534  clLVL1A = cluster.LVL1A();
535  fill(clusterGroup_OnTrack, clLVL1A);
536  Cluster_LVL1A_Mod_OnTrack.add(pixlayer, clusID, cluster.LVL1A() + 0.00001);
537  if (cluster.rdoList().size() > 1) Cluster_LVL1A_SizeCut_OnTrack.add(pixlayer, clusID,
538  cluster.LVL1A() + 0.00001);
539  //
540  // end timing histos
541  // begin cluster sizes
542  //
543  auto clSize = Monitored::Scalar<float>("ClusterSizeOnTrack_clsize", cluster.rdoList().size());
544  auto clSizeEtaModule = Monitored::Scalar<float>("ClusterSizeOnTrack_em", m_pixelid->eta_module(clusID));
545  if (abs(m_pixelid->barrel_ec(clusID)) != 0) clSizeEtaModule = m_pixelid->layer_disk(clusID) + 1;
546  fill("ClusterGroupsizeVsEtaOnTrack_" + pixBaseLayersLabel[pixlayer], clSizeEtaModule, clSize);
547 
548  Cluster_Size_Map_OnTrack.add(pixlayer, clusID, cluster.rdoList().size());
549  //
550  // end cluster sizes
551  // begin cluster rate
552  //
553  if (m_doOnline) ClusterMap_Mon_OnTrack.add(pixlayer, clusID);
554  //
555  // end cluster rate
556  // begin cluster occupancy
557  //
558  Cluster_Occupancy_OnTrack.add(pixlayer, clusID);
559  if (m_doFEPlots) {
560  Cluster_FE_Occupancy_OnTrack.add(pixlayer, clusID, m_pixelReadout->getFE(clusID, clusID), 1.0);
561  }
562  if (cluster.rdoList().size() > 1) Clus_Occ_SizeCut_OnTrack.add(pixlayer, clusID);
563  //
564  // end cluster occupancy
565  // begin cluster ToT, 1D timing, charge
566  //
567  if (pixlayer == PixLayers::kIBL)
568  {
569  pixlayer = (m_pixelid->eta_module(clusID) > -7 && m_pixelid->eta_module(clusID) < 6) ? PixLayers::kIBL2D : PixLayers::kIBL3D;
570  }
571  if (cluster.totalToT() > clusterToTMinCut[pixlayer]) fill("ClusterLVL1AToTCutOnTrack_" + pixLayersLabel[pixlayer], clLVL1A);
572 
573  auto clToTcosAlpha = Monitored::Scalar<float>("ClusterToTxCosAlphaOnTrack_val", cluster.totalToT() * cosalpha);
574  fill(pixLayersLabel[pixlayer], clToTcosAlphaLB, clToTcosAlpha);
575 
576  if (!m_doOnline) {
577  auto clQcosAlpha = Monitored::Scalar<float>("ClusterQxCosAlphaOnTrack_val", cluster.totalCharge() * cosalpha);
578  fill(pixLayersLabel[pixlayer], clQcosAlpha);
579  }
580  nclusters_ontrack_mod[pixlayer]++;
581  //
582  // end cluster ToT, 1D timing, charge
583  } // end on track
584  } // end cluster collection
585  }
586  fill2DProfLayerAccum(Cluster_LVL1A_Mod);
587  fill2DProfLayerAccum(Cluster_LVL1A_SizeCut);
588  fill2DProfLayerAccum(Cluster_LVL1A_Mod_OnTrack);
589  fill2DProfLayerAccum(Cluster_LVL1A_SizeCut_OnTrack);
590  if (m_doOnline) {
591  fill2DProfLayerAccum(ClusterMap_Mon);
592  fill2DProfLayerAccum(ClusterMap_Mon_OnTrack);
593  }
594  fill2DProfLayerAccum(Cluster_Size_Map_OnTrack);
595  fill2DProfLayerAccum(Cluster_Occupancy);
596  fill2DProfLayerAccum(Cluster_Occupancy_OnTrack);
597  fill2DProfLayerAccum(Clus_Occ_SizeCut);
598  fill2DProfLayerAccum(Clus_Occ_SizeCut_OnTrack);
599  if (m_doFEPlots) {
600  fill2DProfLayerAccum(Cluster_FE_Occupancy);
601  fill2DProfLayerAccum(Cluster_FE_Occupancy_OnTrack);
602  }
603  // begin cluster rates
604  //
605  auto nCls = Monitored::Scalar<int>("ClustersPerEvent_val", nclusters);
606  fill(clusterGroup, lbval, nCls);
607  auto nClsOnTrk = Monitored::Scalar<int>("ClustersPerEventOnTrack_val", nclusters_ontrack);
608  fill(clusterGroup_OnTrack, lbval, nClsOnTrk);
609  for (unsigned int ii = 0; ii < PixLayers::COUNT; ii++) {
610  auto vals = Monitored::Scalar<float>("ClustersPerEvent_val", nclusters_mod[ii]);
611  auto vals_ontrack = Monitored::Scalar<float>("ClustersPerEventOnTrack_val", nclusters_ontrack_mod[ii]);
612  fill(pixLayersLabel[ii], vals, vals_ontrack);
613  }
614 
615  if (nclusters > 0) {
616  auto clsFracOnTrack = Monitored::Scalar<float>("cls_frac_ontrack", (float) nclusters_ontrack / nclusters);
617  fill(clusterGroup_OnTrack, lbval, clsFracOnTrack);
618  } else {
619  auto dataread_err = Monitored::Scalar<int>("clsdataread_err", DataReadErrors::EmptyContainer);
620  fill(clusterGroup, dataread_err);
621  }
622 
623  fill1DProfLumiLayers("ClustersPerLumi", lb, nclusters_mod);
624  fill1DProfLumiLayers("ClustersPerLumiOnTrack", lb, nclusters_ontrack_mod);
625 
626  fillFromArrays("ClusterOccupancyPP0OnTrack", clusPerEventArray);
627 
628  if (ntracksPerEvent > 0) {
629  for (unsigned int ii = 0; ii < PixLayers::COUNT; ii++) nclusters_ontrack_mod[ii] /= ntracksPerEvent;
630  fill1DProfLumiLayers("NumClustersPerTrackPerLumi", lb, nclusters_ontrack_mod);
631  }
632  //
633  // end cluster rate
634  ClusterIDs.clear();
635 
636  //*******************************************************************************
637  //************************** End of filling Cluster Histograms ******************
638  //*******************************************************************************
639 
640  return StatusCode::SUCCESS;
641 }

◆ 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 PixelAthClusterMonAlg::findComponentString ( int  bec,
int  ld 
) const

◆ 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 PixelAthClusterMonAlg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from PixelAthMonitoringBase.

Definition at line 40 of file PixelAthClusterMonAlg.cxx.

40  {
41  ATH_CHECK( PixelAthMonitoringBase::initialize());
42  ATH_CHECK(detStore()->retrieve(m_atlasid, "AtlasID"));
43  if (!m_holeSearchTool.empty()) ATH_CHECK(m_holeSearchTool.retrieve());
44  if (!m_trackSelTool.empty()) ATH_CHECK(m_trackSelTool.retrieve());
45 
46  ATH_CHECK(m_tracksKey.initialize());
47  ATH_CHECK(m_clustersKey.initialize());
48  return StatusCode::SUCCESS;
49 }

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

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

const AtlasDetectorID* PixelAthClusterMonAlg::m_atlasid {}
private

Definition at line 45 of file PixelAthClusterMonAlg.h.

◆ m_clustersKey

SG::ReadHandleKey<InDet::PixelClusterContainer> PixelAthClusterMonAlg::m_clustersKey
private
Initial value:
{
this, "ClusterName", "PixelClusters", "pixel cluster data key"
}

Definition at line 47 of file PixelAthClusterMonAlg.h.

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

bool PixelAthClusterMonAlg::m_doFEPlots {}
private

Definition at line 59 of file PixelAthClusterMonAlg.h.

◆ m_doHeavyIonMon

bool PixelAthClusterMonAlg::m_doHeavyIonMon {}
private

Definition at line 58 of file PixelAthClusterMonAlg.h.

◆ m_doHighOccupancy

bool PixelAthClusterMonAlg::m_doHighOccupancy {}
private

Definition at line 57 of file PixelAthClusterMonAlg.h.

◆ m_doLowOccupancy

bool PixelAthClusterMonAlg::m_doLowOccupancy {}
private

Definition at line 56 of file PixelAthClusterMonAlg.h.

◆ m_doLumiBlock

bool PixelAthClusterMonAlg::m_doLumiBlock {}
private

Definition at line 55 of file PixelAthClusterMonAlg.h.

◆ m_doOnline

bool PixelAthClusterMonAlg::m_doOnline {}
private

Definition at line 54 of file PixelAthClusterMonAlg.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_holeSearchTool

ToolHandle<Trk::ITrackHoleSearchTool> PixelAthClusterMonAlg::m_holeSearchTool
private

Definition at line 42 of file PixelAthClusterMonAlg.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_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_trackSelTool

ToolHandle<InDet::IInDetTrackSelectionTool> PixelAthClusterMonAlg::m_trackSelTool
private

Definition at line 43 of file PixelAthClusterMonAlg.h.

◆ m_tracksKey

SG::ReadHandleKey<TrackCollection> PixelAthClusterMonAlg::m_tracksKey
private
Initial value:
{
this, "TrackName", "CombinedInDetTracks", "track data key"
}

Definition at line 50 of file PixelAthClusterMonAlg.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_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:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AtlasDetectorID::is_pixel
bool is_pixel(Identifier id) const
Definition: AtlasDetectorID.h:760
InDetDD::SolidStateDetectorElementBase::identifierOfPosition
Identifier identifierOfPosition(const Amg::Vector2D &localPos) const
Full identifier of the cell for a given position: assumes a raw local position (no Lorentz shift)
Definition: SolidStateDetectorElementBase.cxx:217
Trk::numberOfPixelHits
@ numberOfPixelHits
number of pixel layers on track with absence of hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:57
beamspotman.r
def r
Definition: beamspotman.py:676
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
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
PixelAthClusterMonAlg::m_atlasid
const AtlasDetectorID * m_atlasid
Definition: PixelAthClusterMonAlg.h:45
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
Amg::MatrixX
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixX
Dynamic Matrix - dynamic allocation.
Definition: EventPrimitives.h:29
Trk::Surface::associatedDetectorElement
const TrkDetElementBase * associatedDetectorElement() const
return associated Detector Element
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
PixelID::wafer_end
const_id_iterator wafer_end(void) const
Definition: PixelID.cxx:925
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::locX
@ locX
Definition: ParamDefs.h:43
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
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:44
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
python.MagFieldUtils.lumiblock
lumiblock
Definition: MagFieldUtils.py:188
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
PixelAthClusterMonAlg::m_doFEPlots
bool m_doFEPlots
Definition: PixelAthClusterMonAlg.h:59
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
TauGNNUtils::Variables::Track::nPixelHits
bool nPixelHits(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:542
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
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
PixLayers::NFEI3LAYERS
@ NFEI3LAYERS
Definition: PixelAthMonitoringBase.h:24
index
Definition: index.py:1
Trk::ParametersBase::associatedSurface
virtual const Surface & associatedSurface() const override=0
Access to the Surface associated to the Parameters.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
AmbiguityProcessor::nCategories
@ nCategories
Definition: AmbiguityProcessorUtility.h:24
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
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
Trk::Surface::associatedDetectorElementIdentifier
Identifier associatedDetectorElementIdentifier() const
return Identifier of the associated Detector Element
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
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
PixelID::wafer_begin
const_id_iterator wafer_begin(void) const
Iterators over full set of ids. Wafer iterator is sorted.
Definition: PixelID.cxx:921
PixelAthMonitoringBase::m_pixelDetElStatus
SG::ReadHandleKey< InDet::SiDetectorElementStatus > m_pixelDetElStatus
Optional read handle to get status data to test whether a pixel detector element is good.
Definition: PixelAthMonitoringBase.h:149
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
PixLayers::NBASELAYERS
@ NBASELAYERS
Definition: PixelAthMonitoringBase.h:24
Trk::PrepRawData::rdoList
const std::vector< Identifier > & rdoList() const
return the List of rdo identifiers (pointers)
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
PixelAthClusterMonAlg::m_tracksKey
SG::ReadHandleKey< TrackCollection > m_tracksKey
Definition: PixelAthClusterMonAlg.h:50
DataReadErrors::CollectionInvalid
@ CollectionInvalid
Definition: PixelAthMonitoringBase.h:30
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
PixelAthMonitoringBase::m_pixelReadout
ServiceHandle< InDetDD::IPixelReadoutManager > m_pixelReadout
Definition: PixelAthMonitoringBase.h:139
PixelAthClusterMonAlg::m_doHeavyIonMon
bool m_doHeavyIonMon
Definition: PixelAthClusterMonAlg.h:58
PixelAthClusterMonAlg::m_doOnline
bool m_doOnline
Definition: PixelAthClusterMonAlg.h:54
PixMon::kNumModulesDisk
const unsigned int kNumModulesDisk
Definition: PixelAthMonitoringBase.h:68
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Trk::TrkDetElementBase::identify
virtual Identifier identify() const =0
Identifier.
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
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:562
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:52
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:554
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:194
PixelAthMonitoringBase::getPixelDetElStatus
SG::ReadHandle< InDet::SiDetectorElementStatus > getPixelDetElStatus(const SG::ReadHandleKey< InDet::SiDetectorElementStatus > &key, const EventContext &ctx) const
Definition: PixelAthMonitoringBase.h:158
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
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
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
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
TRT::Hit::side
@ side
Definition: HitInfo.h:83
PixelAthClusterMonAlgCfg.clusterGroup
dictionary clusterGroup
begin cluster timing
Definition: PixelAthClusterMonAlgCfg.py:196
PixelAthMonitoringBase::fill2DProfLayerAccum
void fill2DProfLayerAccum(const VecAccumulator2DMap &accumulator) const
take VecAccumulator2DMap and fill the corresponding group
Definition: PixelAthMonitoringBase.cxx:119
InDetDD::SiLocalPosition
Definition: SiLocalPosition.h:31
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
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
DataReadErrors::EmptyContainer
@ EmptyContainer
Definition: PixelAthMonitoringBase.h:30
PixelID::wafer_hash
IdentifierHash wafer_hash(Identifier wafer_id) const
wafer hash from id
Definition: PixelID.h:387
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
PixelAthClusterMonAlg::m_trackSelTool
ToolHandle< InDet::IInDetTrackSelectionTool > m_trackSelTool
Definition: PixelAthClusterMonAlg.h:43
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
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition: TrackStateOnSurface.h:128
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
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
InDet::PixelCluster::totalToT
int totalToT() const
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:205
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
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
PixelAthClusterMonAlg::m_clustersKey
SG::ReadHandleKey< InDet::PixelClusterContainer > m_clustersKey
Definition: PixelAthClusterMonAlg.h:47
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
InDet::PixelCluster::LVL1A
int LVL1A() const
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:269
PixMon::kNumStavesL2
const unsigned int kNumStavesL2
Definition: PixelAthMonitoringBase.h:59
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::MeasurementBase::type
virtual bool type(MeasurementBaseType::Type type) const =0
Interface method checking the type.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
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
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
DataVector< const Trk::TrackStateOnSurface >
inv_nmod_per_layer
const float inv_nmod_per_layer[PixLayers::COUNT]
Definition: PixelAthMonitoringBase.h:39
InDet::SiCluster::detectorElement
virtual const InDetDD::SiDetectorElement * detectorElement() const override final
return the detector element corresponding to this PRD The pointer will be zero if the det el is not d...
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
Trk::numberOfPixelHoles
@ numberOfPixelHoles
number of pixels which have a ganged ambiguity.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:59
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
InDetDD::SiDetectorElement::isPixel
bool isPixel() const
Trk::MeasurementBase
Definition: MeasurementBase.h:58
PixelAthMonitoringBase::isClusterOnTrack
bool isClusterOnTrack(Identifier id, std::vector< std::pair< Identifier, double > > const &ClusterIDs) const
checks if cluster is on track
Definition: PixelAthMonitoringBase.cxx:431
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
Trk::ParametersCommon::localPosition
Amg::Vector2D localPosition() const
Access method for the local coordinates, local parameter definitions differ for each surface type.
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:626
DataReadErrors::ContainerInvalid
@ ContainerInvalid
Definition: PixelAthMonitoringBase.h:30
Trk
Ensure that the ATLAS eigen extensions are properly loaded.
Definition: FakeTrackBuilder.h:9
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
Amg
Definition of ATLAS Math & Geometry primitives (Amg)
Definition: AmgStringHelpers.h:19
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Trk::MeasurementBase::associatedSurface
virtual const Surface & associatedSurface() const =0
Interface method to get the associated Surface.
PixLayers::kIBL
@ kIBL
Definition: PixelAthMonitoringBase.h:24
PixMon::kNumStavesL0
const unsigned int kNumStavesL0
Definition: PixelAthMonitoringBase.h:53
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
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
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
item
Definition: ItemListSvc.h:43
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::RIO_OnTrack::prepRawData
virtual const Trk::PrepRawData * prepRawData() const =0
returns the PrepRawData (also known as RIO) object to which this RIO_OnTrack is associated.
Trk::MeasurementBaseType::RIO_OnTrack
@ RIO_OnTrack
Definition: MeasurementBase.h:49
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
InDet::PixelCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:49
PixelAthClusterMonAlg::m_holeSearchTool
ToolHandle< Trk::ITrackHoleSearchTool > m_holeSearchTool
Definition: PixelAthClusterMonAlg.h:42
PixelAthMonitoringBase::isChipActive
bool isChipActive(const IdentifierHash &module_hash, unsigned int chip_i) const
Definition: PixelAthMonitoringBase.h:198
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
PixelAthClusterMonAlg::m_doLowOccupancy
bool m_doLowOccupancy
Definition: PixelAthClusterMonAlg.h:56
a
TList * a
Definition: liststreamerinfos.cxx:10
PixelAthMonitoringBase::getPhiEtaMod
void getPhiEtaMod(Identifier &id, int &phiMod, int &etaMod, bool &copyFE) const
helper function to get eta phi coordinates of per-layer arrays
Definition: PixelAthMonitoringBase.cxx:388
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
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
PixelAthMonitoringBase::fillFromArrays
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",...
Definition: PixelAthMonitoringBase.cxx:209
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
PixelAthMonitoringBase::isGood
bool isGood(const InDet::SiDetectorElementStatus *element_status, const IdentifierHash &module_hash) const
Definition: PixelAthMonitoringBase.h:177
InDet::PixelCluster::totalCharge
float totalCharge() const
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:213
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
Trk::RIO_OnTrack::identify
virtual Identifier identify() const final
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:155
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:569
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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
PixMon::kNumStavesIBL
const unsigned int kNumStavesIBL
Definition: PixelAthMonitoringBase.h:50
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
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
PixelAthMonitoringBase::getNumberOfFEs
int getNumberOfFEs(int pixlayer, int etaMod) const
helper function to get number of FEs per module
Definition: PixelAthMonitoringBase.cxx:372
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
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
clusterToTMinCut
const int clusterToTMinCut[PixLayers::COUNT]
Definition: PixelAthMonitoringBase.h:42
PixelID::phi_module
int phi_module(const Identifier &id) const
Definition: PixelID.h:644
PixelAthClusterMonAlgCfg.trackGroup
trackGroup
Definition: PixelAthClusterMonAlgCfg.py:116
error
Definition: IImpactPoint3dEstimator.h:70
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
PixelAthClusterMonAlg::m_doHighOccupancy
bool m_doHighOccupancy
Definition: PixelAthClusterMonAlg.h:57
PixLayers::kECA
@ kECA
Definition: PixelAthMonitoringBase.h:24
geometry_dat_to_json.ld
ld
Definition: geometry_dat_to_json.py:14
InDet::SiCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/SiCluster.h:40
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
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
InDet::PixelClusterCollection
Trk::PrepRawDataCollection< PixelCluster > PixelClusterCollection
Definition: PixelClusterCollection.h:26
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
PixelAthClusterMonAlg::m_doLumiBlock
bool m_doLumiBlock
Definition: PixelAthClusterMonAlg.h:55
fitman.k
k
Definition: fitman.py:528
PixMon::kNumStavesL1
const unsigned int kNumStavesL1
Definition: PixelAthMonitoringBase.h:56
InDet::SiClusterOnTrack
Definition: SiClusterOnTrack.h:39
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
PlotCalibFromCool.vals
vals
Definition: PlotCalibFromCool.py:474
collisions
Definition: collisions.py:1
Generated on Tue Jul 2 2024 21:55:54 for ATLAS Offline Software by   doxygen 1.8.18