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 StavesL00
 
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
 
ToolHandle< InDet::IInDetTestPixelLayerTool > m_testPixelLayerTool { this,"TestPixelLayerTool","","" }
 tool to calculate expected hit information in innermost layers More...
 
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 22 of file PixelAthClusterMonAlg.cxx.

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

◆ ~PixelAthClusterMonAlg()

PixelAthClusterMonAlg::~PixelAthClusterMonAlg ( )
virtual

Definition at line 39 of file PixelAthClusterMonAlg.cxx.

39 {}

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 54 of file PixelAthClusterMonAlg.cxx.

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

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

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

◆ 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, InDet::SiSPGNNTrackMaker, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, 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 250 of file PixelAthMonitoringBase.py.

◆ ErrCatLabelsNorm

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

Definition at line 258 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 233 of file PixelAthMonitoringBase.py.

◆ ErrCatRODModLabelsNorm

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

Definition at line 243 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 184 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 203 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 171 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 153 of file PixelAthMonitoringBase.py.

◆ layergroups

dictionary PixelAthMonitoringBase.layergroups = {}
inherited

Definition at line 272 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 62 of file PixelAthClusterMonAlg.h.

◆ m_doHeavyIonMon

bool PixelAthClusterMonAlg::m_doHeavyIonMon {}
private

Definition at line 61 of file PixelAthClusterMonAlg.h.

◆ m_doHighOccupancy

bool PixelAthClusterMonAlg::m_doHighOccupancy {}
private

Definition at line 60 of file PixelAthClusterMonAlg.h.

◆ m_doLowOccupancy

bool PixelAthClusterMonAlg::m_doLowOccupancy {}
private

Definition at line 59 of file PixelAthClusterMonAlg.h.

◆ m_doLumiBlock

bool PixelAthClusterMonAlg::m_doLumiBlock {}
private

Definition at line 58 of file PixelAthClusterMonAlg.h.

◆ m_doOnline

bool PixelAthClusterMonAlg::m_doOnline {}
private

Definition at line 57 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_testPixelLayerTool

ToolHandle<InDet::IInDetTestPixelLayerTool> PixelAthClusterMonAlg::m_testPixelLayerTool { this,"TestPixelLayerTool","","" }
private

tool to calculate expected hit information in innermost layers

Definition at line 55 of file PixelAthClusterMonAlg.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 156 of file PixelAthMonitoringBase.py.

◆ ModulesFEECC

list PixelAthMonitoringBase.ModulesFEECC = []
inherited

Definition at line 159 of file PixelAthMonitoringBase.py.

◆ ModulesHead

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

Definition at line 182 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 179 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 174 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 266 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 162 of file PixelAthMonitoringBase.py.

◆ StavesFEL1

list PixelAthMonitoringBase.StavesFEL1 = []
inherited

Definition at line 165 of file PixelAthMonitoringBase.py.

◆ StavesFEL2

list PixelAthMonitoringBase.StavesFEL2 = []
inherited

Definition at line 168 of file PixelAthMonitoringBase.py.

◆ StavesIBL

list PixelAthMonitoringBase.StavesIBL
inherited
Initial value:
= [
"S01(0.33)", "S02(0.78)", "S03(1.23)", "S04(1.68)", "S05(2.12)", "S06(2.57)", "S07(3.02)",
"S08(-2.81)", "S09(-2.36)", "S10(-1.91)", "S11(-1.47)", "S12(-1.02)", "S13(-0.57)","S14(-0.12)"]

Definition at line 149 of file PixelAthMonitoringBase.py.

◆ StavesL0

list PixelAthMonitoringBase.StavesL0
inherited
Initial value:
= [
"B11_S2(-0.29)", "B01_S1(0.0)", "B01_S2(0.29)", "B02_S1(0.57)", "B02_S2(0.87)", "B03_S1(1.14)", "B03_S2(1.43)",
"B04_S1(1.71)", "B04_S2(2.0)", "B05_S1(2.28)", "B05_S2(2.57)", "B06_S1(2.86)", "B06_S2(3.14)", "B07_S1(-2.86)",
"B07_S2(-2.57)", "B08_S1(2.28)", "B08_S2(-2.0)", "B09_S1(-1.71)", "B09_S2(-1.43)", "B10_S1(-1.14)",
"B10_S2(-0.86)", "B11_S1(-0.57)"]

Definition at line 125 of file PixelAthMonitoringBase.py.

◆ StavesL00

list PixelAthMonitoringBase.StavesL00
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 131 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 139 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:27
Trk::Surface::associatedDetectorElement
const TrkDetElementBase * associatedDetectorElement() const
return associated Detector Element
get_generator_info.result
result
Definition: get_generator_info.py:21
PixelID::wafer_end
const_id_iterator wafer_end(void) const
Definition: PixelID.cxx:844
Trk::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 1st pixel layer
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:53
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:37
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:38
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:62
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
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
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:396
PixelID::wafer_begin
const_id_iterator wafer_begin(void) const
Iterators over full set of ids. Wafer iterator is sorted.
Definition: PixelID.cxx:840
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
Trk::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the pixel hits, including the b-layer
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:55
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:61
PixelAthClusterMonAlg::m_doOnline
bool m_doOnline
Definition: PixelAthClusterMonAlg.h:57
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:560
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.
IDTPM::nPixelHits
float nPixelHits(const U &p)
Definition: TrackParametersHelper.h:354
AmgSymMatrix
#define AmgSymMatrix(dim)
Definition: EventPrimitives.h:50
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:805
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
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
PixelAthClusterMonAlgCfg.clusterGroup
dictionary clusterGroup
begin cluster timing
Definition: PixelAthClusterMonAlgCfg.py:211
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:270
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
python.PyAthena.module
module
Definition: PyAthena.py:131
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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.
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:85
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
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:111
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:524
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
PixelAthClusterMonAlg::m_testPixelLayerTool
ToolHandle< InDet::IInDetTestPixelLayerTool > m_testPixelLayerTool
tool to calculate expected hit information in innermost layers
Definition: PixelAthClusterMonAlg.h:55
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
Trk::TrackSummary
A summary of the information contained by a track.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
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
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
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:59
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
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
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
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
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:623
PixMon::kNumStavesIBL
const unsigned int kNumStavesIBL
Definition: PixelAthMonitoringBase.h:50
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:798
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
Trk::TrackSummary::get
int get(const SummaryType &type) const
returns the summary information for the passed SummaryType.
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
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
PixelAthClusterMonAlgCfg.trackGroup
trackGroup
Definition: PixelAthClusterMonAlgCfg.py:124
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:60
PixLayers::kECA
@ kECA
Definition: PixelAthMonitoringBase.h:24
geometry_dat_to_json.ld
ld
Definition: geometry_dat_to_json.py:32
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:58
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
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Fri Jan 10 2025 21:38:03 for ATLAS Offline Software by   doxygen 1.8.18