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

#include <LArCellMonAlg.h>

Inheritance diagram for LArCellMonAlg:
Collaboration diagram for LArCellMonAlg:

Classes

struct  threshold_t
 

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

 LArCellMonAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~LArCellMonAlg ()
 
virtual StatusCode initialize () override final
 initialize More...
 
virtual StatusCode fillHistograms (const EventContext &ctx) const override final
 adds event to the monitoring histograms More...
 
StatusCode checkFilters (bool &ifPass, bool &passBeamBackgroundRemoval, const std::string &MonGroupName, const EventContext &ctx) const
 
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::EventInfoGetEventInfo (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

 flags = initConfigFlags()
 
 Files
 
 HISTFileName
 
 enableLumiAccess
 
 useTrigger
 
 Environment
 
 cfg = MainServicesCfg(flags)
 
 f = open("LArCellMon.pkl","wb")
 

Protected Types

enum  LayerEnum {
  EMBPA =0, EMBPC, EMB1A, EMB1C,
  EMB2A, EMB2C, EMB3A, EMB3C,
  HEC0A, HEC0C, HEC1A, HEC1C,
  HEC2A, HEC2C, HEC3A, HEC3C,
  EMECPA, EMECPC, EMEC1A, EMEC1C,
  EMEC2A, EMEC2C, EMEC3A, EMEC3C,
  FCAL1A, FCAL1C, FCAL2A, FCAL2C,
  FCAL3A, FCAL3C, MAXLAYER
}
 
enum  LayerEnumNoSides {
  EMBPNS =0, EMB1NS, EMB2NS, EMB3NS,
  HEC0NS, HEC1NS, HEC2NS, HEC3NS,
  EMECPNS, EMEC1NS, EMEC2NS, EMEC3NS,
  FCAL1NS, FCAL2NS, FCAL3NS, MAXLYRNS
}
 

Protected Member Functions

void getHistoCoordinates (const CaloDetDescrElement *dde, float &celleta, float &cellphi, unsigned &iLyr, unsigned &iLyrNS) 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

const CaloCell_IDm_calo_id {nullptr}
 
const std::map< unsigned, LayerEnumNoSidesm_caloSamplingToLyrNS
 
ToolHandleArray< GenericMonitoringToolm_tools {this,"GMTools",{}}
 Array of Generic Monitoring Tools. More...
 
PublicToolHandle< Trig::TrigDecisionToolm_trigDecTool {this, "TrigDecisionTool",""}
 Tool to tell whether a specific trigger is passed. More...
 
ToolHandleArray< IDQFilterToolm_DQFilterTools {this,"FilterTools",{}}
 Array of Data Quality filter tools. More...
 
SG::ReadCondHandleKey< LuminosityCondDatam_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondDatam_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondDatam_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::EventInfom_EventInfoKey {this,"EventInfoKey","EventInfo"}
 Key for retrieving EventInfo from StoreGate. More...
 

Private Types

enum  Direction { OVER, UNDER, NONE, BOTH }
 
enum  TriggerType {
  RNDM, CALO, MINBIAS, MET,
  MISC, NOTA, MAXTRIGTYPE
}
 
enum  PartitionEnum {
  EMBA, EMBC, EMECA, EMECC,
  HECA, HECC, FCALA, FCALC,
  MAXPARTITIONS
}
 
typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode initThresh ()
 
void setLArCellBinning ()
 
StatusCode createPerJobHistograms (const CaloCellContainer *cellcont, const CaloNoise *noisep) const
 
void checkTriggerAndBeamBackground (bool passBeamBackgroundRemoval, std::vector< threshold_t > &thresholds) const
 
void sporadicNoiseCandidate (const CaloCell *cell, const LArCellMonAlg::LayerEnum iLyr, const float threshold, const LArOnOffIdMapping *cabling) const
 
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...
 

Static Private Member Functions

static bool isThrListed (const std::vector< std::string > &vec, const std::string &s)
 
static std::string strToLower (const std::string &input)
 

Private Attributes

SG::ReadHandleKey< CaloCellContainerm_cellContainerKey {this,"CaloCellContainer","AllCalo","SG key of the input cell container"}
 
Gaudi::Property< std::string > m_MonGroupName {this, "MonGroupName", "LArCellMonGroup"}
 
Gaudi::Property< std::string > m_MonGroupNamePerJob {this, "MonGroupName_perJob"}
 
Gaudi::Property< std::string > m_groupnameTotalOccupancyEtaPhi {this, "MonGroupName_OccupancyEtaPhi"}
 
Gaudi::Property< std::string > m_groupnamePercentageOccupancyEtaPhi {this, "MonGroupName_PercentageOccupancyEtaPhi"}
 
Gaudi::Property< std::string > m_groupnameOccupancyEta {this, "MonGroupName_OccupancyEta"}
 
Gaudi::Property< std::string > m_groupnameOccupancyPhi {this, "MonGroupName_OccupancyPhi"}
 
Gaudi::Property< std::string > m_groupnameTotEnergyEtaPhi {this, "MonGroupName_TotEnergyEtaPhi"}
 
Gaudi::Property< std::string > m_groupnameTotQualityEtaPhi {this, "MonGroupName_AvgQualityEtaPhi"}
 
Gaudi::Property< std::string > m_groupnameFractionOverQthEtaPhi {this, "MonGroupName_FractionOverQthEtaPhi"}
 
Gaudi::Property< std::string > m_groupnameTotTimeEtaPhi {this, "MonGroupName_AvgTimeEtaPhi"}
 
Gaudi::Property< std::string > m_groupnameFractionPastTthEtaPhi {this, "MonGroupName_FractionPastTthEtaPhi"}
 
SG::ReadCondHandleKey< CaloNoisem_noiseCDOKey {this,"CaloNoiseKey","totalNoise","SG Key of CaloNoise data object"}
 
std::map< std::string, std::map< std::string, int > > m_toolmapAll
 
FloatArrayProperty m_eCutForTiming
 
StringArrayProperty m_layerNames
 
IntegerArrayProperty m_layerNcells
 
StringArrayProperty m_partitionNames {this, "PartitionNames", {"EMBA","EMBC","EMECA","EMECC","HECA","HECC","FCALA","FCALC"}}
 
BooleanProperty m_useTrigger {this, "useTrigger", true}
 
StringProperty m_triggerNames [NOTA]
 
BooleanProperty m_ignoreKnownBadChannels {this, "MaskBadChannels", false, "Do not fill histograms with values from known bad channels"}
 
BooleanProperty m_maskNoCondChannels {this, "MaskNoCondChannels", false, "Do not fill histograms with values from cells reco'ed w/o conditions database"}
 
BooleanArrayProperty m_doBeamBackgroundRemovalProp {this, "DoBeamBackgroundRemoval"}
 
BooleanProperty m_doKnownBadChannelsVsEtaPhi {this, "doKnownBadChannelsVsEtaPhi", true}
 
BooleanProperty m_doDatabaseNoiseVsEtaPhi {this, "doDatabaseNoiseVsEtaPhi", true}
 
BooleanProperty m_doEnergyVsTime {this, "doEnergyVsTime", true}
 
BooleanProperty m_doUnnormalized1DEnergy {this, "doUnnormalized1DEnergy", false}
 
BooleanProperty m_sporadic_switch {this, "Sporadic_switch", false}
 
FloatProperty m_threshold_em_S0S1 {this, "Threshold_EM_S0S1", 5000.}
 
FloatProperty m_threshold_HECFCALEMS2S3 {this, "Threshold_HECFCALEMS2S3", 15000.}
 
UnsignedIntegerProperty m_sporadicPlotLimit {this, "NsporadicPlotLimit", 300}
 
UnsignedIntegerProperty m_sporadic_protc {this, "Sporadic_protection", 4000}
 
UnsignedIntegerProperty m_minSporadicNoiseEventsPerCell {this, "minSporadicEvents", 10}
 
StringArrayProperty m_thresholdNameProp {this, "ThresholdType", {},"Vector of threshold names"}
 
StringArrayProperty m_thresholdColumnType {this, "ThresholdColumnType",{}}
 
StringArrayProperty m_thresholdDirectionProp {this, "ThresholdDirection", {}, "Vector of threshold directions"}
 
StringArrayProperty m_triggersToIncludeProp {this, "TriggersToInclude", {}}
 
StringArrayProperty m_triggersToExcludeProp {this, "TriggersToExclude", {}}
 
StringArrayProperty m_thresholdTitleTemplates {this, "ThresholdTitleTemplates", {}}
 
FloatArrayProperty m_defaultThresholds {this, "DefaultThresholds", {}}
 
BooleanArrayProperty m_inSigNoise {this, "ThresholdinSigNoise", {}}
 
FloatArrayProperty m_timeThresholdProp {this, "TimeThreshold"}
 
FloatArrayProperty m_qualityFactorThresholdProp {this, "QualityFactorThreshold",{}}
 
StringArrayProperty m_doEtaPhiTotalOccupancyNames {this, "DoEtaPhiTotalOccupancyNames", {}}
 
StringArrayProperty m_doEtaPhiPercentageOccupancyNames {this, "DoEtaPhiPercentageOccupancyNames", {}}
 
StringArrayProperty m_doEtaOccupancyNames {this, "DoEtaOccupancyNames", {}}
 
StringArrayProperty m_doPhiOccupancyNames {this, "DoPhiOccupancyNames", {}}
 
StringArrayProperty m_doEtaPhiTotEnergyNames {this, "DoEtaPhiTotEnergyNames", {}}
 
StringArrayProperty m_doEtaPhiAvgQualityNames {this, "DoEtaPhiAvgQualityNames", {},"Turns on 'totQuality' and total 'Occupancy' plots. The ratio will be computed at post-processing stage"}
 
StringArrayProperty m_doEtaPhiFractionOverQthNames {this, "DoEtaPhiFractionOverQthNames", {}}
 
StringArrayProperty m_doEtaPhiAvgTimeNames {this, "DoEtaPhiAvgTimeNames", {},"Turns on 'totTime' and total 'Occupancy' plots. The ratio will be computed at post-processing stage"}
 
StringArrayProperty m_doEtaPhiFractionPastTthNames {this, "DoEtaPhiFractionPastTthNames", {}}
 
FloatArrayProperty m_thresholdsProp [MAXLYRNS]
 
const std::array< PartitionEnum, MAXLAYERm_layerEnumtoPartitionEnum
 
LArBadChannelMask m_bcMask
 
Gaudi::Property< std::vector< std::string > > m_problemsToMask {this,"ProblemsToMask",{}, "Bad-Channel categories to mask"}
 
std::vector< threshold_tm_thresholds
 
const LArOnlineIDm_LArOnlineIDHelper
 
SG::ReadCondHandleKey< LArOnOffIdMappingm_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArBadChannelContm_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}
 
std::array< CaloMonitoring::LArCellBinning, MAXLAYERm_binning
 
SG::ReadHandleKey< LArCollisionTimem_LArCollisionTimeKey {this,"LArCollisionTimeKey","LArCollisionTime"}
 
SG::ReadHandleKey< BeamBackgroundDatam_beamBackgroundKey {this,"BeamBackgroundKey","CSCBackgroundForCaloMon"}
 
bool m_useBadLBTool
 
ToolHandle< IDQFilterToolm_BadLBTool
 
bool m_useReadyFilterTool
 
ToolHandle< IDQFilterToolm_ReadyFilterTool
 
bool m_useLArNoisyAlg
 
bool m_useCollisionFilterTool
 
bool m_useBeamBackgroundRemoval
 
std::string m_name
 
std::unordered_map< std::string, size_t > m_toolLookupMap
 
const ToolHandle< GenericMonitoringToolm_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 41 of file LArCellMonAlg.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  };

◆ Direction

Enumerator
OVER 
UNDER 
NONE 
BOTH 

Definition at line 99 of file LArCellMonAlg.h.

99 {OVER,UNDER,NONE,BOTH};

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

◆ LayerEnum

enum CaloMonAlgBase::LayerEnum
protectedinherited
Enumerator
EMBPA 
EMBPC 
EMB1A 
EMB1C 
EMB2A 
EMB2C 
EMB3A 
EMB3C 
HEC0A 
HEC0C 
HEC1A 
HEC1C 
HEC2A 
HEC2C 
HEC3A 
HEC3C 
EMECPA 
EMECPC 
EMEC1A 
EMEC1C 
EMEC2A 
EMEC2C 
EMEC3A 
EMEC3C 
FCAL1A 
FCAL1C 
FCAL2A 
FCAL2C 
FCAL3A 
FCAL3C 
MAXLAYER 

Definition at line 48 of file CaloMonAlgBase.h.

◆ LayerEnumNoSides

enum CaloMonAlgBase::LayerEnumNoSides
protectedinherited
Enumerator
EMBPNS 
EMB1NS 
EMB2NS 
EMB3NS 
HEC0NS 
HEC1NS 
HEC2NS 
HEC3NS 
EMECPNS 
EMEC1NS 
EMEC2NS 
EMEC3NS 
FCAL1NS 
FCAL2NS 
FCAL3NS 
MAXLYRNS 

Definition at line 54 of file CaloMonAlgBase.h.

◆ PartitionEnum

Enumerator
EMBA 
EMBC 
EMECA 
EMECC 
HECA 
HECC 
FCALA 
FCALC 
MAXPARTITIONS 

Definition at line 152 of file LArCellMonAlg.h.

◆ TriggerType

Enumerator
RNDM 
CALO 
MINBIAS 
MET 
MISC 
NOTA 
MAXTRIGTYPE 

Definition at line 100 of file LArCellMonAlg.h.

Constructor & Destructor Documentation

◆ LArCellMonAlg()

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

Definition at line 32 of file LArCellMonAlg.cxx.

33  :CaloMonAlgBase(name, pSvcLocator),
34  m_LArOnlineIDHelper(nullptr)
35 {
36 
37  // Trigger Awareness:
38  declareProperty("rndmTriggerNames", m_triggerNames[RNDM]);
39  declareProperty("caloTriggerNames",m_triggerNames[CALO]);
40  declareProperty("minBiasTriggerNames",m_triggerNames[MINBIAS]);
41  declareProperty("metTriggerNames",m_triggerNames[MET]);
42  declareProperty("miscTriggerNames",m_triggerNames[MISC]);
43 
44  // LAr Thresholdsd
45  // Em Barrel
46  declareProperty("EMBP_Thresh",m_thresholdsProp[EMBPNS]);
47  declareProperty("EMB1_Thresh",m_thresholdsProp[EMB1NS]);
48  declareProperty("EMB2_Thresh",m_thresholdsProp[EMB2NS]);
49  declareProperty("EMB3_Thresh",m_thresholdsProp[EMB3NS]);
50  // EM Endcap
51  declareProperty("EMECP_Thresh",m_thresholdsProp[EMECPNS]);
52  declareProperty("EMEC1_Thresh",m_thresholdsProp[EMEC1NS]);
53  declareProperty("EMEC2_Thresh",m_thresholdsProp[EMEC2NS]);
54  declareProperty("EMEC3_Thresh",m_thresholdsProp[EMEC3NS]);
55  // Hadronic Endcap
56  declareProperty("HEC0_Thresh",m_thresholdsProp[HEC0NS]);
57  declareProperty("HEC1_Thresh",m_thresholdsProp[HEC1NS]);
58  declareProperty("HEC2_Thresh",m_thresholdsProp[HEC2NS]);
59  declareProperty("HEC3_Thresh",m_thresholdsProp[HEC3NS]);
60  // Forward Calorimeters
61  declareProperty("FCAL1_Thresh",m_thresholdsProp[FCAL1NS]);
62  declareProperty("FCAL2_Thresh",m_thresholdsProp[FCAL2NS]);
63  declareProperty("FCAL3_Thresh",m_thresholdsProp[FCAL3NS]);
64 }

◆ ~LArCellMonAlg()

LArCellMonAlg::~LArCellMonAlg ( )
default

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 }

◆ checkFilters()

StatusCode CaloMonAlgBase::checkFilters ( bool &  ifPass,
bool &  passBeamBackgroundRemoval,
const std::string &  MonGroupName,
const EventContext &  ctx 
) const
inherited

Definition at line 61 of file CaloMonAlgBase.cxx.

61  {
62 
63  ATH_MSG_DEBUG("CaloMonAlgBase:checkFilters() starts "<<MonGroupName);
64 
65  auto evtbin = Monitored::Scalar<int>("EvtBin",1);
66  fill(MonGroupName,evtbin);
67 
68  ifPass = 0;
70  if (m_ReadyFilterTool->accept()) {
71  ifPass = 1;
72  evtbin = 2;
73  fill(MonGroupName,evtbin); //All events with ATLAS Ready
74  }
75  }
76  else{
77  evtbin = 2;
78  fill(MonGroupName,evtbin); //ATLAS ready not activated
79  ifPass = 1;
80  }
81 
82  ATH_MSG_DEBUG("CaloMonAlgBase::checkFilters() ATLAS Ready done");
83 
85 
86  if (m_useBadLBTool) {
87  if (m_BadLBTool->accept()) {
88  ifPass = ifPass && 1;
89  if(ifPass) {evtbin=3; fill(MonGroupName,evtbin);} //All events with ATLAS Ready and Good LB
90  }
91  else {
92  ifPass = 0;
93  }
94  }
95  else{
96  if(ifPass) {evtbin=3; fill(MonGroupName,evtbin);}
97  }
98 
99  ATH_MSG_DEBUG("CaloMonAlgBase::checkFilters() BadLBTool done");
100 
101  // Filter the events identfied as collision by the LAr system
102  // Useful in CosmicCalo to reject collision candidates
105  if(!larTime.isValid()){
106  ATH_MSG_WARNING("Unable to retrieve LArCollisionTime event store");
107  if(ifPass) {evtbin=4; fill(MonGroupName,evtbin);}
108  }
109  else {
110  if (larTime->timeC()!=0 && larTime->timeA()!=0 && std::fabs(larTime->timeC() - larTime->timeA())<10) {
111  ifPass = 0;
112  }
113  else {
114  ifPass = ifPass && 1;
115  if(ifPass) {evtbin=4; fill(MonGroupName,evtbin);} //All events with ATLAS Ready and Good LB and Good LAr collision time
116  }
117  }
118  }
119  else{
120  if(ifPass) {evtbin=4; fill(MonGroupName,evtbin);}
121  }
122  ATH_MSG_DEBUG("CaloMonAlgBase::checkFilters() CollisionFilterTool done");
123 
124 
125  passBeamBackgroundRemoval=true;
128  if(!beamBackgroundData.isValid()){
129  ATH_MSG_WARNING("Unable to retrieve BeamBackgroundData");
130  }
131  else {
132  if( beamBackgroundData->GetNumSegment() > 0 ) {
133  passBeamBackgroundRemoval = false;
134  ifPass = 0;
135  ATH_MSG_DEBUG("Identified background event");
136  }
137  else {
138  passBeamBackgroundRemoval = true;
139  ifPass = ifPass && 1;
140  if(ifPass){evtbin=5; fill(MonGroupName,evtbin);} //All events with ATLAS Ready and Good LB and Good LAr collision time and not Beam Background
141  }
142  }
143  }
144  else { // Do not use BeamBackgroundRemoval
145  ifPass = ifPass && 1;
146  if(ifPass) {evtbin=5; fill(MonGroupName,evtbin);} //All events with ATLAS Ready and Good LB and Good LAr collision time and not Beam Background
147 
148  }
149  ATH_MSG_DEBUG("CaloMonAlgBase::checkFilters() m_useBeamBackgroundRemoval done");
150 
151  std::string TheTrigger;
152  if ( m_vTrigChainNames.empty()) {
153  TheTrigger="NoTrigSel";
154  ifPass = ifPass && 1; // No Trigger Filter check
155  if(ifPass) {evtbin=6; fill(MonGroupName,evtbin);} //All events with ATLAS Ready and Good LB and Good LAr collision time and not Beam Background and Trigger Filter pass
156  }
157  else {
158  TheTrigger = m_triggerChainString; // Trigger Filter not implemented ++ FIXME ==
159  if(ifPass) {evtbin=6; fill(MonGroupName,evtbin);}
160  }
161 
162  if(m_useLArNoisyAlg && (eventInfo->errorState(xAOD::EventInfo::LAr) == xAOD::EventInfo::Error)) {
163  ifPass = 0;
164  }
165  else {
166  ifPass = ifPass && 1;
167  if(ifPass) {evtbin=7; fill(MonGroupName,evtbin);} //All events with ATLAS Ready and Good LB and Good LAr collision time and not Beam Background and Trigger Filter pass and no Lar Error
168  }
169 
170  ATH_MSG_DEBUG("CaloMonAlgBase::checkFilters() is done");
171  return StatusCode::SUCCESS;
172 }

◆ checkTriggerAndBeamBackground()

void LArCellMonAlg::checkTriggerAndBeamBackground ( bool  passBeamBackgroundRemoval,
std::vector< threshold_t > &  thresholds 
) const
private

Definition at line 289 of file LArCellMonAlg.cxx.

289  {
290 
291  auto mon_trig = Monitored::Scalar<float>("trigType",-1);
292  mon_trig=0.5;
293  fill(m_MonGroupName,mon_trig);
294 
295  const ToolHandle<Trig::TrigDecisionTool>& trigTool = getTrigDecisionTool();
296  if (m_useTrigger && !trigTool.empty()) {
297  std::bitset<MAXTRIGTYPE> triggersPassed(0x1<<NOTA); //Last bit: NOTA, always passes
298  constexpr std::bitset<MAXTRIGTYPE> NOTAmask=~(0x1<<NOTA);
299 
300  for (unsigned i=0;i<NOTA;++i) {
301  const std::string& chainName=m_triggerNames[i];
302  if(!chainName.empty()) {
303  const Trig::ChainGroup* cg = trigTool->getChainGroup(chainName);
304  if(cg->isPassed()) {
305  triggersPassed.set(i);
306  mon_trig=0.5+i;
307  fill(m_MonGroupName,mon_trig);
308  }
309  }
310  }//end of loop over trigger types
311 
312  for (threshold_t& thr : thresholds) { //Loop over thresholds
313  thr.m_threshTriggerDecision=(thr.m_triggersToInclude & triggersPassed).any() && (thr.m_triggersToExclude & triggersPassed & NOTAmask).none();
314  }// end loop over thresholds
315 
316  } //end if trigger used
317  else {
318  mon_trig=6.5;
319  fill(m_MonGroupName,mon_trig);
320  }
321  //Note that thr.m_threshTriggerDecision remains in it's default state 'true' if trigger wasn't used
322 
323  //Check beam-background removal
324  for (const threshold_t& thr : thresholds) { //Loop over thresholds
325  if (thr.m_threshTriggerDecision && (passBeamBackgroundRemoval || !thr.m_doBeamBackgroundRemoval)) {
326  //The counter of events passing. Will be incremented even if neither trigger nor background removal is requested for this threshold
327  auto eventCounter = Monitored::Scalar<size_t>("eventCounter",thr.m_thrIndex);
328  fill(m_MonGroupName,eventCounter);
329  }
330  }//end loop over thresholds
331  }

◆ createPerJobHistograms()

StatusCode LArCellMonAlg::createPerJobHistograms ( const CaloCellContainer cellcont,
const CaloNoise noisep 
) const
private

Definition at line 629 of file LArCellMonAlg.cxx.

629  {
630 
631  ATH_MSG_INFO("Creating the once-per-job histograms");
632  //The following histograms can be considered constants for one job
633  //(in fact, they are constant for an entire run or even run-periode)
634  //ActiveCells in eta/phi (to normalize 1D occupancy plots)
635  //BadChannel word
636  //Database noise
637 
638  auto doDatabaseNoisePlot = Monitored::Scalar<bool>("doDatabaseNoisePlot",m_doDatabaseNoiseVsEtaPhi);
639  auto doCellsActiveEtaPlot = Monitored::Scalar<bool>("doCellsActiveEtaPlot",m_doEtaOccupancyNames.size()>0);
640  auto doCellsActivePhiPlot = Monitored::Scalar<bool>("doCellsActivePhiPlot",m_doPhiOccupancyNames.size()>0);
641 
642  if(!m_doKnownBadChannelsVsEtaPhi && !doDatabaseNoisePlot && !doCellsActiveEtaPlot && !doCellsActivePhiPlot) {
643  ATH_MSG_INFO("No once-per-job histogram requested");
644  return StatusCode::SUCCESS;
645  }
646 
648  const LArBadChannelCont *bcCont {*readHandle};
649  if(m_doKnownBadChannelsVsEtaPhi && !bcCont) {
650  ATH_MSG_WARNING( "Do not have Bad chan container !!!" );
651  return StatusCode::FAILURE;
652  }
653 
654  //filling:
655 
656  CaloCellContainer::const_iterator it = cellCont->begin();
657  CaloCellContainer::const_iterator it_e = cellCont->end();
658  for ( ; it!=it_e;++it) {
659  const CaloCell* cell = *it;
660  Identifier id = cell->ID();
661  bool is_lar=m_calo_id->is_lar(id);
662  if(!is_lar) continue;
663  const CaloDetDescrElement* caloDDEl=cell->caloDDE();
664  float celleta, cellphi;
665  unsigned iLyr, iLyrNS;
666  getHistoCoordinates(caloDDEl, celleta, cellphi, iLyr, iLyrNS);
667 
668  auto mon_eta = Monitored::Scalar<float>("celleta_"+m_layerNames[iLyr],celleta);
669  auto mon_phi = Monitored::Scalar<float>("cellphi_"+m_layerNames[iLyr],cellphi);
670 
671  const LArBadChannel larBadChannel = bcCont->offlineStatus(id);
672  auto fillBadChannelPlot = Monitored::Scalar<bool>("fillBadChannelPlot",(m_doKnownBadChannelsVsEtaPhi && (!larBadChannel.good())));
673  auto badCellWord = Monitored::Scalar<uint32_t>("badCellWord_"+m_layerNames[iLyr],larBadChannel.packedData());
674 
675  auto cellnoisedb = Monitored::Scalar<float>("cellnoisedb_"+m_layerNames[iLyr],noisep->getNoise(id,cell->gain()));
676 
677  fill(m_MonGroupNamePerJob,badCellWord,cellnoisedb,mon_eta,mon_phi,fillBadChannelPlot,doDatabaseNoisePlot,doCellsActiveEtaPlot,doCellsActivePhiPlot);
678  }//end loop over cells
679 
680  return StatusCode::SUCCESS;
681 }

◆ 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" ) {
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" ) {
156  } else { // otherwise, warn the user and return "userDefined"
157  ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
158  <<str<<", returning 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;
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" ) {
126  } else if( lowerCaseStr == "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.
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()) {
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ fillHistograms()

StatusCode LArCellMonAlg::fillHistograms ( const EventContext &  ctx) const
finaloverridevirtual

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 430 of file LArCellMonAlg.cxx.

430  {
431 
432  ATH_MSG_DEBUG("LArCellMonAlg::fillHistograms() starts");
433 
435  const LArOnOffIdMapping* cabling{*cablingHdl};
436  if(!cabling) {
437  ATH_MSG_ERROR( "Do not have cabling");
438  return StatusCode::FAILURE;
439  }
440 
441  const LArBadChannelCont* bcCont=nullptr;
444  bcCont=(*bcContHdl);
445  }
446 
448  const CaloCellContainer* cellCont = cellHdl.cptr();
449 
451  const CaloNoise *noisep = *noiseHdl;
452 
453  if (ctx.evt()==0) {
454  ATH_CHECK(createPerJobHistograms(cellCont, noisep));
455  }
456 
457  bool ifPass = true;
458  bool passBeamBackgroundRemoval = true;
459  ATH_CHECK(checkFilters(ifPass,passBeamBackgroundRemoval,m_MonGroupName,ctx)); //Check ATLAS-Ready, beam-background, etc from base class
460  if(!ifPass) return StatusCode::SUCCESS;
461 
462  std::vector<threshold_t> thresholds = m_thresholds;
463 
464  checkTriggerAndBeamBackground(passBeamBackgroundRemoval, thresholds);
465 
466  //get LB
467  auto lumiBlock = Monitored::Scalar<unsigned int>("lumiBlock",0);
468  lumiBlock = GetEventInfo(ctx)->lumiBlock();
469 
471  CaloCellContainer::const_iterator it_e = cellCont->end();
472  // loop over cells -------------
473 
474  std::vector<std::vector<std::vector<LArMonValues>>> monValueVec;
475  monValueVec.reserve(m_layerNames.size());
476  for (size_t ilayer = 0; ilayer < m_layerNames.size(); ++ilayer) {
477  monValueVec.emplace_back();
478  monValueVec[ilayer].reserve(thresholds.size());
479  for (size_t ithreshold = 0; ithreshold < thresholds.size(); ++ithreshold) {
480  monValueVec[ilayer].emplace_back();
481  // this could be more intelligent (this is the worst case for #cells in a layer, most are much less)
482  monValueVec[ilayer][ithreshold].reserve(m_layerNcells[ilayer]);
483  }
484  }
485 
486  std::vector<std::vector<float>> energies_nocut;
487  energies_nocut.reserve(m_layerNames.size());
488  for (size_t ilayer = 0; ilayer < m_layerNames.size(); ++ilayer) {
489  energies_nocut.emplace_back();
490  energies_nocut[ilayer].reserve(m_layerNcells[ilayer]);
491  }
492 
493  for ( ; it!=it_e;++it) {
494  // cell info
495  const CaloCell* cell = *it;
496  Identifier id = cell->ID();
497  bool is_lar=m_calo_id->is_lar(id);
498  const ULong64_t monCellID = id.get_compact();
499 
500  if(!is_lar) continue;
501 
502  const CaloDetDescrElement* caloDDEl=cell->caloDDE();
503  const IdentifierHash cellHash=caloDDEl->calo_hash();
504 
505  const CaloGain::CaloGain gain= cell->gain();
506  const float cellen = cell->energy();
507  const float celltime = cell->time();
508  const uint16_t cellquality = cell->quality();
509  const uint16_t cellprovenance = cell->provenance();
510  const bool celltqavailable = ( cellprovenance & 0x2000 );
511 
512  // No more filling if we encounter a bad channel ....
513  if (m_ignoreKnownBadChannels && m_bcMask.cellShouldBeMasked(bcCont,id)) continue;
514 
515  // ...or a channel w/o conditions
516  if (m_maskNoCondChannels && (cellprovenance & 0x00FF) != 0x00A5) continue; //FIXME, I think that cut is wrong
517 
518  float celleta,cellphi;
519  unsigned iLyr, iLyrNS;
520  getHistoCoordinates(caloDDEl, celleta, cellphi, iLyr, iLyrNS);
521 
522  //Start filling per-threshold histograms:
523  auto& lvaluemap = monValueVec[iLyr];
524  for (size_t ithr = 0; ithr < thresholds.size(); ++ithr) {
525  const auto& thr = thresholds[ithr];
526  // for (auto& thr : thresholds) {
527  //std::cout << "Threshold name " << thr.m_threshName << std::endl;
528  //Any of the conditons below means we do not fill the histogram:
529 
530  //Trigger passed?
531  if (m_useTrigger && !thr.m_threshTriggerDecision) continue;
532  //std::cout << " Trigger passed" << std::endl;
533 
534  //Beam background event?
535  if (thr.m_doBeamBackgroundRemoval && !passBeamBackgroundRemoval) continue;
536 
537  //std::cout << " Beam background passed" << std::endl;
538 
539  float thresholdVal=thr.m_threshValue[iLyrNS];
540  if (thresholdVal==0) {
541  ATH_MSG_WARNING("Got threshold 0 for type '" << thr.m_threshName << "'for cell in layer " << m_layerNames[iLyr]);
542  }
543 
544  if (thr.m_inSigNoise) thresholdVal*=noisep->getNoise(cellHash, gain);
545 
546 
547  bool passThrCut(true);
548  if (thr.m_threshDirection==OVER && cellen <= thresholdVal) passThrCut=false;
549  if (thr.m_threshDirection==UNDER && cellen > thresholdVal) passThrCut=false;
550  if (thr.m_threshDirection==BOTH && (cellen > -thresholdVal && cellen <= thresholdVal)) passThrCut=false;
551 
552 
553  bool pass_qual = (cellquality > thr.m_qualityFactorThreshold);
554  bool pass_time = (fabs(celltime) > thr.m_timeThreshold);
555 
556  lvaluemap[ithr].push_back({celleta, cellphi, cellen, celltime, cellquality, pass_qual, pass_time, passThrCut});
557 
558  if(!passThrCut) continue;
559 
560  }//end loop over thresholds
561 
562  //some additional monitored objects
563  auto en = Monitored::Scalar<float>("cellEnergy_"+m_layerNames[iLyr],cellen);
564  auto tim = Monitored::Scalar<float>("cellTime_"+m_layerNames[iLyr],celltime);
565  if(passBeamBackgroundRemoval) {
566  // 1D Energy distribution:
567  energies_nocut[iLyr].push_back(cellen);
568  //if (m_h_energy[iLyr]) m_h_energy[iLyr]->Fill(cellen);
569 
570  // Time vs Energy:
571  if (m_doEnergyVsTime && celltqavailable && cellquality<4000) {
572  bool passecut = (cellen>m_eCutForTiming[iLyrNS]);
573  auto eGTcut = Monitored::Scalar<float>("enGreaterThanCut_"+m_layerNames[iLyr],passecut);
574  fill(m_MonGroupName,en,tim,eGTcut);
575 
576  }
577 
578  //Checking for signs of sporadic noise
579  if(m_sporadic_switch) {
580  float energyThreshold;
581  //We have two energy thresholds for sporadic noise, one for EM samling 1 and 2 and one for the rest
582  if(iLyrNS==EMB1NS || iLyrNS==EMB2NS || iLyrNS==EMEC1NS || iLyrNS==EMEC2NS) {
583  energyThreshold=m_threshold_em_S0S1;
584  }
585  else {
586  energyThreshold = m_threshold_HECFCALEMS2S3;
587  }
588  if (cellen > energyThreshold) {
589  ATH_MSG_INFO( "Found sporadic noise candidate cell with id 0x" << std::hex << id.get_identifier32().get_compact() << std::dec << " in " << m_partitionNames[m_layerEnumtoPartitionEnum[iLyr]] );
590  auto sporadicCellE = Monitored::Scalar<float>("sporadicCellE",cellen);
591  auto sporadicCellTime = Monitored::Scalar<float>("sporadicCellTime",celltime);
592  auto sporadicCellQuality = Monitored::Scalar<uint16_t>("sporadicCellQuality",cellquality);
593  auto sporadicCellID = Monitored::Scalar<ULong64_t>("sporadicCellID",monCellID);
594  fill(m_MonGroupName,sporadicCellE,sporadicCellTime,sporadicCellQuality,sporadicCellID,lumiBlock);
595  }
596  }//end if m_sporadic_switch
597  } // end if m_passBeamBackgroundRemoval
598  }//end loop over cells
599 
600  for (size_t ilayer = 0; ilayer < energies_nocut.size(); ++ilayer) {
601  auto en0 = Monitored::Collection("cellEnergy_nocuts_"+m_layerNames[ilayer],
602  energies_nocut[ilayer]);
603  fill(m_MonGroupName, en0);
604  }
605 
606  // fill, for every layer/threshold
607  for (size_t ilayer = 0; ilayer < monValueVec.size(); ++ilayer) {
608  for (size_t ithreshold = 0; ithreshold < monValueVec[ilayer].size(); ++ithreshold) {
609  const auto& tool = monValueVec[ilayer][ithreshold];
610  auto mon_eta = Monitored::Collection("celleta",tool,[](const auto& v){return v.mon_eta;});
611  auto mon_phi = Monitored::Collection("cellphi",tool,[](const auto& v){return v.mon_phi;});
612  auto en = Monitored::Collection("cellEnergy",tool,[](const auto& v){return v.en;});
613  auto mon_qual = Monitored::Collection("cellQuality",tool,[](const auto& v){return v.mon_qual;});
614  auto pass_qual = Monitored::Collection("isPoorQuality",tool,[](const auto& v){return v.pass_qual;});
615  auto tim = Monitored::Collection("cellTime",tool,[](const auto& v){return v.time;});
616  auto pass_time = Monitored::Collection("isLateTime",tool,[](const auto& v){return v.pass_time;});
617  auto passThrCut = Monitored::Collection("passThrCut",tool,[](const auto& v){return v.passThrCut;});
618  fill(m_tools[m_toolmapAll.at(m_layerNames[ilayer]).at(thresholds[ithreshold].m_threshName)],
619  passThrCut, mon_eta, mon_phi, en, mon_qual,
620  pass_qual, tim, pass_time);
621  }
622  }
623 
624  ATH_MSG_DEBUG("LArCellMonAlg::fillLarHists() is done");
625  return StatusCode::SUCCESS;
626 }

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

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

◆ getHistoCoordinates()

void CaloMonAlgBase::getHistoCoordinates ( const CaloDetDescrElement dde,
float &  celleta,
float &  cellphi,
unsigned &  iLyr,
unsigned &  iLyrNS 
) const
protectedinherited

Definition at line 176 of file CaloMonAlgBase.cxx.

176  {
177 
178  celleta=dde->eta_raw();
179  cellphi=dde->phi_raw();
180 
181  int calosample=dde->getSampling();
182  if (dde->is_lar_em_endcap_inner()) calosample-=1; //Here, we consider the two layers of the EMEC IW as EME1 and EME2 instad of layer 2 and 3
183  iLyrNS=m_caloSamplingToLyrNS.at(calosample); //will throw if out of bounds
184  if ((iLyrNS==EMB1NS || iLyrNS==EMB2NS) && m_calo_id->region(dde->identify())==1) {
185  //We are in the awkward region 1 of the EM Barrel
186  //Looking at the image at http://atlas.web.cern.ch/Atlas/GROUPS/LIQARGEXT/TDR/figures6/figure6-17.eps
187  //may be useful to understand what's going on here.
188 
189  //In brief: Region 1, layer 1 is closer related ot the middle compartment (aka layer 2)
190  // and region 1, layer 2 closer related to the back compartment (aka layer 3)
191  iLyrNS+=1;
192 
193  //Layer 2: 0<eta<1.4 + 1.4<eta<1.475, deta = 0.025. 3 rows of cells from region 1
194  //Layer 3: 0<eta<1.35 (deta=0.050) + 1.4<eta<1.475 (deta = 0.075). 1 row of cell from region 1 with different dEta
195  }
196 
197  const unsigned side=(celleta>0) ? 0 : 1; //Value >0 means A-side
198  iLyr=iLyrNS*2+side;
199  }

◆ 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 LArCellMonAlg::initialize ( )
finaloverridevirtual

initialize

Returns
StatusCode

Reimplemented from CaloMonAlgBase.

Definition at line 71 of file LArCellMonAlg.cxx.

71  {
72 
73  ATH_MSG_DEBUG("LArCellMonAlg::initialize() start");
74 
75  // Initialize superclass
77 
78  //Identfier-helpers
79  ATH_CHECK( detStore()->retrieve(m_LArOnlineIDHelper, "LArOnlineID") );
80 
81  // Bad channel masker tool
84 
88 
89  //JobO consistency check:
90  if (m_useTrigger && std::all_of(std::begin(m_triggerNames),std::end(m_triggerNames),[](const std::string& trigName){return trigName.empty();})) {
91  ATH_MSG_WARNING("UseTrigger set to true but no trigger names given! Forcing useTrigger to false");
92  m_useTrigger=false;
93  }
94 
95  // FIXME check consistency between layer and partitions from jO to enums
96 
97  // Check that sizes of layer names and ncells is the same
98  if (m_layerNames.size() != m_layerNcells.size()) {
99  ATH_MSG_ERROR("LayerNames and LayerNcells not of the same length, aborting.....");
100  return StatusCode::FAILURE;
101  }
102 
103 
104  // Sets the threshold value arrays
106 
107  //Fill the LArCellBinning for each layer
108  //setLArCellBinning();
109 
110  m_toolmapAll = Monitored::buildToolMap<std::map<std::string,int>>(m_tools, "allMon", m_layerNames, m_thresholdNameProp);
111 
112  ATH_MSG_DEBUG("LArCellMonAlg::initialize() is done!");
113 
114  return StatusCode::SUCCESS;
115 }

◆ initThresh()

StatusCode LArCellMonAlg::initThresh ( )
private

Definition at line 119 of file LArCellMonAlg.cxx.

119  {
120 
121  //Interpret the jobO defining the per-threshold histograms
122  //and initialize vector<threshold_t> m_thresholds;
123 
124  const size_t nThr=m_thresholdNameProp.value().size();
125 
126  //Check uniqueness of threshold-type by filling a set
127  std::set<std::string> uniqunesCheck;
128  for (const std::string& s : m_thresholdNameProp.value()) {
129  auto r=uniqunesCheck.insert(s);
130  if (!r.second) {
131  ATH_MSG_ERROR( "Configuration error: Threshold type " << s << " appears more than once" );
132  return StatusCode::FAILURE;
133  }
134  }
135  uniqunesCheck.clear();
136 
137 
138  const std::map<const std::string, const Direction> stringToDirection {{"over",OVER},{"under",UNDER},{"both",BOTH},{"none",NONE}};
139  const std::map<const std::string, const TriggerType> stringToTrigType {{"nota",NOTA},{"rndm",RNDM},{"calo",CALO},{"minbias",MINBIAS},
140  {"met",MET},{"misc",MISC},{"none",NOTA},{"all",NOTA}};
141 
142  m_thresholds.resize(nThr);
143  for (size_t iThr=0;iThr<nThr;++iThr) {
145  threshold.m_threshName=m_thresholdNameProp.value()[iThr];
146  threshold.m_thrIndex=iThr;
147  threshold.m_threshTitleTemplate= m_thresholdTitleTemplates.value()[iThr];
148  std::fill(threshold.m_threshValue.begin(),threshold.m_threshValue.end(),m_defaultThresholds.value()[iThr]);
149  threshold.m_inSigNoise=m_inSigNoise.value()[iThr];
150 
151  auto itD=stringToDirection.find(strToLower(m_thresholdDirectionProp.value()[iThr]));
152  if (itD!=stringToDirection.end()) {
153  threshold.m_threshDirection=itD->second;
154  }
155  else {
156  ATH_MSG_ERROR( "Configuration problem. Unknown threshold direction '"
157  << m_thresholdDirectionProp.value()[iThr]
158  << "'given" );
159  return StatusCode::FAILURE;
160  }
161 
162  auto itT=stringToTrigType.find(strToLower(m_triggersToExcludeProp.value()[iThr]));
163  if (itT!=stringToTrigType.end()) {
164  threshold.m_triggersToExclude.set(itT->second);
165  if (itT->first=="all") {ATH_MSG_WARNING( "Setting TriggersToExclude to 'all' has no effect!" );}
166  }
167  else {
168  ATH_MSG_ERROR( "Configuration problem. Unknown trigger type '"
169  << m_triggersToExcludeProp.value()[iThr]
170  << "' given in propety 'TriggersToExlude'" );
171  return StatusCode::FAILURE;
172  }
173 
174  itT=stringToTrigType.find(strToLower(m_triggersToIncludeProp.value()[iThr]));
175  if (itT!=stringToTrigType.end()) {
176  threshold.m_triggersToInclude.set(itT->second);
177  if (itT->first=="none") {ATH_MSG_WARNING( "Setting TriggersToInclude to 'none' has no effect!" );}
178  }
179  else {
180  ATH_MSG_ERROR( "Configuration problem. Unknown trigger type '"
181  << m_triggersToIncludeProp.value()[iThr]
182  << "' given in propety 'TriggersToInclude'" );
183  return StatusCode::FAILURE;
184  }
185 
186  threshold.m_doPercentageOccupancy=isThrListed(m_doEtaPhiPercentageOccupancyNames.value(),threshold.m_threshName);
187  threshold.m_doEtaPhiOccupancy=isThrListed(m_doEtaPhiTotalOccupancyNames.value(),threshold.m_threshName);
188  threshold.m_doEtaOccupancy=isThrListed(m_doEtaOccupancyNames.value(),threshold.m_threshName);
189  threshold.m_doPhiOccupancy=isThrListed(m_doPhiOccupancyNames.value(),threshold.m_threshName);
190  threshold.m_doEtaPhiTotalEnergy=isThrListed(m_doEtaPhiTotEnergyNames.value(),threshold.m_threshName);
191  threshold.m_doEtaPhiAverageQuality=isThrListed(m_doEtaPhiAvgQualityNames.value(),threshold.m_threshName);
192  threshold.m_doEtaPhiFractionOverQth=isThrListed(m_doEtaPhiFractionOverQthNames.value(),threshold.m_threshName);
193  threshold.m_qualityFactorThreshold=m_qualityFactorThresholdProp.value()[iThr];
194  threshold.m_doEtaPhiAverageTime=isThrListed(m_doEtaPhiAvgTimeNames.value(),threshold.m_threshName);
195  threshold.m_doEtaPhiFractionPastTth=isThrListed(m_doEtaPhiFractionPastTthNames.value(),threshold.m_threshName);
196  threshold.m_timeThreshold=m_timeThresholdProp.value()[iThr];
197  threshold.m_doBeamBackgroundRemoval=m_doBeamBackgroundRemovalProp.value()[iThr];
198  }//end loop over threshold names
199 
200 
201  //Overwrite per-layer thresholds:
202  for (size_t iThrOvr=0;iThrOvr!= m_thresholdColumnType.value().size();++iThrOvr) {
203  const std::string& nameToOverwrite=m_thresholdColumnType.value()[iThrOvr];
204  auto it=std::find_if(m_thresholds.begin(),m_thresholds.end(),
205  [&](const threshold_t& x) {return (x.m_threshName==nameToOverwrite);}
206  );
207 
208  if (it==m_thresholds.end()) {
209  ATH_MSG_ERROR( "Configuration error reading 'ThresholdColumnType': Threshold type '" << nameToOverwrite << "' is not defined in 'ThresholdType'" );
210  return StatusCode::FAILURE;
211  }
212 
213  for (unsigned iLyr=0;iLyr<MAXLYRNS;++iLyr) {
214  if (m_thresholdsProp[iLyr].value().size()<iThrOvr) {
215  ATH_MSG_ERROR( "Configuration error: Not enough values in threshold vector for layer " << iLyr );
216  return StatusCode::FAILURE;
217  }
218 
219  it->m_threshValue[iLyr]=m_thresholdsProp[iLyr].value()[iThrOvr];
220  }
221  }//end loop over threshold types with per-layer thresholds
222 
223 
224  //Clean out thresholds with no histogram requested:
225  auto thrIt=m_thresholds.begin();
226  while (thrIt!=m_thresholds.end()) {
227  const threshold_t& thr=*thrIt;
228  if (!(thr.m_doEtaPhiOccupancy || thr.m_doPercentageOccupancy || thr.m_doEtaOccupancy || thr.m_doPhiOccupancy || thr.m_doEtaPhiTotalEnergy ||
229  thr.m_doEtaPhiAverageQuality || thr.m_doEtaPhiFractionOverQth || thr.m_doEtaPhiAverageTime || thr.m_doEtaPhiFractionPastTth)) {
230  ATH_MSG_INFO( "Config issue: Threshold type '" << thr.m_threshName << "' defined but no histograms requested. Deleting." );
231  thrIt=m_thresholds.erase(thrIt);
232  }
233  else {
234  ATH_MSG_INFO("Threshold histograms requested for threshold '" << thrIt->m_threshName << "'");
235  thrIt++;
236  }
237  }
238 
239 
240  //Fix up histogram titles
241  for (threshold_t& thr : m_thresholds) {
242  if (thr.m_threshDirection!=NONE &&
243  std::count(thr.m_threshTitleTemplate.begin(),thr.m_threshTitleTemplate.end(),'%')==1) {
244  const size_t maxTitleLenght=thr.m_threshTitleTemplate.size()+32;
245  std::unique_ptr<char[]> toBeFilled(new char[maxTitleLenght]);
246 
247  for (unsigned iLyrns=0;iLyrns<MAXLYRNS;++iLyrns) {
248  //Attempt to fill in theshold value
249  snprintf(toBeFilled.get(),maxTitleLenght,thr.m_threshTitleTemplate.c_str(),thr.m_threshValue[iLyrns]);
250  toBeFilled[maxTitleLenght-1]='\0'; //To be absolutely sure...
251  thr.m_threshTitles[iLyrns]=toBeFilled.get();
252  //std::cout << "Fixup result:" << thr.m_threshTitles[iLyrns] << std::endl;
253  } //end loop over thresholds
254  } //and if somthing to fix up
255  else {
256  //No threshold value to be set, keep as is
257  for (unsigned iLyrns=0;iLyrns<MAXLYRNS;++iLyrns) {
258  thr.m_threshTitles[iLyrns]=thr.m_threshTitleTemplate;
259  }
260  }
261  }
262 
263  return StatusCode::SUCCESS;
264 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

◆ isThrListed()

bool LArCellMonAlg::isThrListed ( const std::vector< std::string > &  vec,
const std::string &  s 
)
staticprivate

Definition at line 693 of file LArCellMonAlg.cxx.

693  {
694  return (std::find(vec.begin(),vec.end(),s)!=vec.end());
695  }

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

◆ setLArCellBinning()

void LArCellMonAlg::setLArCellBinning ( )
private

Definition at line 8 of file LArCellMonAlgSetBinning.cxx.

8  {
9 
10  //EMB Pre-sampler
11  const int embpaNEtaReg = 1;
12  double embpaEtaBreakPts[embpaNEtaReg+1]={0.,1.52};
13  int embpaEtaBins[embpaNEtaReg]={61};
14  m_binning[EMBPA].doEtaBinning(embpaNEtaReg,embpaEtaBreakPts,embpaEtaBins);
15  m_binning[EMBPA].doPhiBinning(64);
16  m_binning[EMBPC]= m_binning[EMBPA].etaMirror();
17 
18  // EMB Layer 1
19  const int emb1aNEtaReg = 1;
20  double emb1aEtaBreakPts[emb1aNEtaReg+1]={0.,1.4};
21  int emb1aEtaBins[emb1aNEtaReg]={448};
22  m_binning[EMB1A].doEtaBinning(emb1aNEtaReg,emb1aEtaBreakPts,emb1aEtaBins);
23  m_binning[EMB1A].doPhiBinning(64);
24  m_binning[EMB1C]=m_binning[EMB1A].etaMirror();
25 
26  // EMB Layer 2
27  const int emb2aNEtaReg = 1;
28  double emb2aEtaBreakPts[emb2aNEtaReg+1]={0.,1.475};
29  int emb2aEtaBins[emb2aNEtaReg]={59};
30  m_binning[EMB2A].doEtaBinning(emb2aNEtaReg,emb2aEtaBreakPts,emb2aEtaBins);
31  m_binning[EMB2A].doPhiBinning(256);
32  m_binning[EMB2C]=m_binning[EMB2A].etaMirror();
33 
34  // EMB Layer 3
35  const int emb3aNEtaReg = 2;
36  double emb3aEtaBreakPts[emb3aNEtaReg+1]={0.00,1.35,1.475};
37  int emb3aEtaBins[emb3aNEtaReg]={27,1};
38  m_binning[EMB3A].doEtaBinning(emb3aNEtaReg,emb3aEtaBreakPts,emb3aEtaBins);
39  m_binning[EMB3A].doPhiBinning(256);
40  m_binning[EMB3C]= m_binning[EMB3A].etaMirror();
41 
42  // HEC Layer 0
43  const int hec0aNEtaReg = 2;
44  double hec0aEtaBreakPts[hec0aNEtaReg+1]={1.5,2.5,3.3};
45  int hec0aEtaBins[hec0aNEtaReg]={10,4};
46  m_binning[HEC0A].doEtaBinning(hec0aNEtaReg,hec0aEtaBreakPts,hec0aEtaBins);
47  m_binning[HEC0A].doPhiBinning(64);
48  m_binning[HEC0C]=m_binning[HEC0A].etaMirror();
49 
50  // HEC Layer 1
51  const int hec1aNEtaReg = 2;
52  double hec1aEtaBreakPts[hec1aNEtaReg+1]={1.5,2.5,3.1};
53  int hec1aEtaBins[hec1aNEtaReg]={10,3};
54  m_binning[HEC1A].doEtaBinning(hec1aNEtaReg,hec1aEtaBreakPts,hec1aEtaBins);
55  m_binning[HEC1A].doPhiBinning(64);
56  m_binning[HEC1C]=m_binning[HEC1A].etaMirror();
57 
58  // HEC Layer 2
59  const int hec2aNEtaReg = 2;
60  double hec2aEtaBreakPts[hec2aNEtaReg+1]={1.6,2.5,3.1};
61  int hec2aEtaBins[hec2aNEtaReg]={9,3};
62  m_binning[HEC2A].doEtaBinning(hec2aNEtaReg,hec2aEtaBreakPts,hec2aEtaBins);
63  m_binning[HEC2A].doPhiBinning(64);
64  m_binning[HEC2C]=m_binning[HEC2A].etaMirror();
65 
66  // HEC Layer 3
67  const int hec3aNEtaReg = 2;
68  double hec3aEtaBreakPts[hec3aNEtaReg+1]={1.7,2.5,3.3};
69  int hec3aEtaBins[hec3aNEtaReg]={8,4};
70  m_binning[HEC3A].doEtaBinning(hec3aNEtaReg,hec3aEtaBreakPts,hec3aEtaBins);
71  m_binning[HEC3A].doPhiBinning(64);
72  m_binning[HEC3C]=m_binning[HEC3A].etaMirror();
73 
74  // EMEC Pre-sampler (Layer 0)
75  const int emecpaNEtaReg = 1;
76  double emecpaEtaBreakPts[emecpaNEtaReg+1]={1.5,1.8};
77  int emecpaEtaBins[emecpaNEtaReg]={12};
78  m_binning[EMECPA].doEtaBinning(emecpaNEtaReg,emecpaEtaBreakPts,emecpaEtaBins);
79  m_binning[EMECPA].doPhiBinning(64);
80  m_binning[EMECPC]=m_binning[EMECPA].etaMirror();
81 
82  // EMEC Layer 1
83  const int emec1aNEtaReg = 7;
84  double emec1aEtaBreakPts[emec1aNEtaReg+1]={1.375,1.425,1.5,1.8,2.0,2.4,2.5,3.2};
85  int emec1aEtaBins[emec1aNEtaReg]={1,3,96,48,64,4,7};
86  m_binning[EMEC1A].doEtaBinning(emec1aNEtaReg,emec1aEtaBreakPts,emec1aEtaBins);
87  m_binning[EMEC1A].doPhiBinning(64);
88  m_binning[EMEC1C]=m_binning[EMEC1A].etaMirror();
89 
90  // EMEC Layer 2
91  const int emec2aNEtaReg = 3;
92  double emec2aEtaBreakPts[emec2aNEtaReg+1]={1.375,1.425,2.5,3.2};
93  int emec2aEtaBins[emec2aNEtaReg]={1,43,7};
94  m_binning[EMEC2A].doEtaBinning(emec2aNEtaReg,emec2aEtaBreakPts,emec2aEtaBins);
95  m_binning[EMEC2A].doPhiBinning(256);
96  m_binning[EMEC2C]=m_binning[EMEC2A].etaMirror();
97 
98  // EMEC Layer 3
99  const int emec3aNEtaReg = 1;
100  double emec3aEtaBreakPts[emec3aNEtaReg+1]={1.5,2.5};
101  int emec3aEtaBins[emec3aNEtaReg]={20};
102  m_binning[EMEC3A].doEtaBinning(emec3aNEtaReg,emec3aEtaBreakPts,emec3aEtaBins);
103  m_binning[EMEC3A].doPhiBinning(256);
104  m_binning[EMEC3C]=m_binning[EMEC3A].etaMirror();
105 
106  // FCAL Layer 1 (0th layer in the code)
107  const int fcal1aNEtaReg = 4;
108  double fcal1aEtaBreakPts[fcal1aNEtaReg+1]={3.08,3.2,3.8,4.6,4.82};
109  int fcal1aEtaBins[fcal1aNEtaReg]={3,6,4,2};
110  m_binning[FCAL1A].doEtaBinning(fcal1aNEtaReg,fcal1aEtaBreakPts,fcal1aEtaBins);
111 
112  const int fcal1aNPhiReg = 95;
113  double fcal1aPhiBreakPts[fcal1aNPhiReg+1]=
114  {-M_PI,(-250.0/256)*M_PI,(-248.0/256)*M_PI,(-243.0/256)*M_PI,(-240.0/256)*M_PI,(-234.0/256)*M_PI,
115  (-230.0/256)*M_PI,(-225.0/256)*M_PI,(-219.0/256)*M_PI,(-195.0/256)*M_PI,(-190.0/256)*M_PI,(-186.0/256)*M_PI,
116  (-183.0/256)*M_PI,(-178.0/256)*M_PI,(-175.0/256)*M_PI,(-173.0/256)*M_PI,(-167.0/256)*M_PI,(-161.0/256)*M_PI,
117  (-159.0/256)*M_PI,(-156.0/256)*M_PI,(-151.0/256)*M_PI,(-148.0/256)*M_PI,(-146.0/256)*M_PI,(-141.0/256)*M_PI,
118  (-139.0/256)*M_PI,(-135.0/256)*M_PI,(-132.0/256)*M_PI,(-120.0/256)*M_PI,(-117.0/256)*M_PI,(-114.0/256)*M_PI,
119  (-110.0/256)*M_PI,(-105.0/256)*M_PI,(-97.0/256)*M_PI,(-94.0/256)*M_PI,(-86.0/256)*M_PI,(-78.0/256)*M_PI,
120  (-63.0/256)*M_PI,(-60.0/256)*M_PI,(-56.0/256)*M_PI,(-46.0/256)*M_PI,(-44.0/256)*M_PI,(-41.0/256)*M_PI,
121  (-32.0/256)*M_PI,(-28.0/256)*M_PI,(-22.0/256)*M_PI,(-10.0/256)*M_PI,(-7.0/256)*M_PI,(-3.0/256)*M_PI,
122  (6.0/256)*M_PI,(8.0/256)*M_PI,(13.0/256)*M_PI,(16.0/256)*M_PI,(22.0/256)*M_PI,(26.0/256)*M_PI,(31.0/256)*M_PI,
123  (37.0/256)*M_PI,(61.0/256)*M_PI,(66.0/256)*M_PI,(70.0/256)*M_PI,(73.0/256)*M_PI,(78.0/256)*M_PI,(81.0/256)*M_PI,
124  (83.0/256)*M_PI,(89.0/256)*M_PI,(95.0/256)*M_PI,(97.0/256)*M_PI,(100.0/256)*M_PI,(105.0/256)*M_PI,
125  (108.0/256)*M_PI,(110.0/256)*M_PI,(115.0/256)*M_PI,(117.0/256)*M_PI,(121.0/256)*M_PI,(124.0/256)*M_PI,
126  (136.0/256)*M_PI,(139.0/256)*M_PI,(142.0/256)*M_PI,(146.0/256)*M_PI,(151.0/256)*M_PI,(159.0/256)*M_PI,
127  (162.0/256)*M_PI,(170.0/256)*M_PI,(178.0/256)*M_PI,(193.0/256)*M_PI,(196.0/256)*M_PI,(200.0/256)*M_PI,
128  (210.0/256)*M_PI,(212.0/256)*M_PI,(215.0/256)*M_PI,(224.0/256)*M_PI,(228.0/256)*M_PI,(234.0/256)*M_PI,
129  (246.0/256)*M_PI,(249.0/256)*M_PI,(253.0/256)*M_PI,M_PI};
130  int fcal1aPhiBins[fcal1aNPhiReg+1] =
131  {2,1,1,1,1,1,1,2,6,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,3,1,1,2,1,2,1,2,4,3,1,1,2,1,1,3,1,2,2,1,2,3,
132  1,1,1,1,1,1,2,6,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,3,1,1,2,1,2,1,2,4,3,1,1,2,1,1,3,1,2,2,1,2,1};
133  m_binning[FCAL1A].doPhiBinning(fcal1aNPhiReg,fcal1aPhiBreakPts,fcal1aPhiBins);
134  m_binning[FCAL1C]=m_binning[FCAL1A].etaMirror();
135 
136  // FCAL Layer 2 (1st layer in the code);
137  const int fcal2aNEtaReg = 15;
138  double fcal2aEtaBreakPts[fcal2aNEtaReg+1]=
139  {3.192,3.1987,3.206,3.22,3.26,3.34,3.37,3.39,3.52,3.57,3.835,4.1,4.365,4.5,4.65,4.81};
140  int fcal2aEtaBins[fcal2aNEtaReg]={1,1,1,2,2,1,1,3,1,4,2,1,1,1,1};
141  m_binning[FCAL2A].doEtaBinning(fcal2aNEtaReg,fcal2aEtaBreakPts,fcal2aEtaBins);
142 
143  const int fcal2aNPhiReg = 32;
144  double fcal2aPhiBreakPts[fcal2aNPhiReg+1]=
145  {-M_PI,(-62.0/64)*M_PI,(-59.0/64)*M_PI,(-55.0/64)*M_PI,(-52.0/64)*M_PI,(-50.0/64)*M_PI,(-48.0/64)*M_PI,
146  (-45.0/64)*M_PI,(-41.0/64)*M_PI,(-38.0/64)*M_PI,(-22.0/64)*M_PI,(-18.0/64)*M_PI,(-12.0/64)*M_PI,
147  (-8.0/64)*M_PI,(-5.0/64)*M_PI,(-1.0/64)*M_PI,0,(2.0/64)*M_PI,(5.0/64)*M_PI,(9.0/64)*M_PI,(12.0/64)*M_PI,
148  (14.0/64)*M_PI,(16.0/64)*M_PI,(19.0/64)*M_PI,(23.0/64)*M_PI,(26.0/64)*M_PI,(42.0/64)*M_PI,(46.0/64)*M_PI,
149  (52.0/64)*M_PI,(56.0/64)*M_PI,(59.0/64)*M_PI,(63.0/64)*M_PI,M_PI};
150  int fcal2aPhiBins[fcal2aNPhiReg+1] =
151  {1,1,1,1,1,1,1,1,1,8,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,8,1,3,1,1,1,1};
152  m_binning[FCAL2A].doPhiBinning(fcal2aNPhiReg,fcal2aPhiBreakPts,fcal2aPhiBins);
153  m_binning[FCAL2C]=m_binning[FCAL2A].etaMirror();
154 
155  // FCAL Layer 3 (2nd layer in the code)
156  const int fcal3aNEtaReg = 5;
157  double fcal3aEtaBreakPts[fcal3aNEtaReg+1]={3.27,3.43,3.7,3.91,4.33,4.75};
158  int fcal3aEtaBins[fcal3aNEtaReg]={2,2,1,1,2};
159  m_binning[FCAL3A].doEtaBinning(fcal3aNEtaReg,fcal3aEtaBreakPts,fcal3aEtaBins);
160 
161  const int fcal3aNPhiReg = 22;
162  double fcal3aPhiBreakPts[fcal3aNPhiReg+1]=
163  {-M_PI,(-40.0/64)*M_PI,(-39.0/64)*M_PI,(-35.0/64)*M_PI,(-29.0/64)*M_PI,(-24.0/64)*M_PI,(-22.0/64)*M_PI,
164  (-16.0/64)*M_PI,(-11.0/64)*M_PI,(-9.0/64)*M_PI,(-6.0/64)*M_PI,0,(24.0/64)*M_PI,(25.0/64)*M_PI,
165  (29.0/64)*M_PI,(35.0/64)*M_PI,(40.0/64)*M_PI,(42.0/64)*M_PI,(48.0/64)*M_PI,(53.0/64)*M_PI,(55.0/64)*M_PI,
166  (58.0/64)*M_PI,M_PI};
167  int fcal3aPhiBins[fcal3aNPhiReg+1] = {10,1,1,4,2,1,2,2,1,1,2,10,1,1,4,2,1,2,2,1,1,2};
168  m_binning[FCAL3A].doPhiBinning(fcal3aNPhiReg,fcal3aPhiBreakPts,fcal3aPhiBins);
169  m_binning[FCAL3C]=m_binning[FCAL3A].etaMirror();
170 }

◆ sporadicNoiseCandidate()

void LArCellMonAlg::sporadicNoiseCandidate ( const CaloCell cell,
const LArCellMonAlg::LayerEnum  iLyr,
const float  threshold,
const LArOnOffIdMapping cabling 
) const
private

◆ strToLower()

std::string LArCellMonAlg::strToLower ( const std::string &  input)
staticprivate

Definition at line 685 of file LArCellMonAlg.cxx.

685  {
686  std::string output;
687  for (const auto& c : input) {
688  output.push_back(std::tolower(c));
689  }
690  return output;
691 }

◆ 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  {
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);
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

◆ cfg

LArCellMonAlg.cfg = MainServicesCfg(flags)

Definition at line 475 of file LArCellMonAlg.py.

◆ enableLumiAccess

LArCellMonAlg.enableLumiAccess

Definition at line 467 of file LArCellMonAlg.py.

◆ Environment

LArCellMonAlg.Environment

Definition at line 469 of file LArCellMonAlg.py.

◆ f

LArCellMonAlg.f = open("LArCellMon.pkl","wb")

Definition at line 487 of file LArCellMonAlg.py.

◆ Files

LArCellMonAlg.Files

Definition at line 462 of file LArCellMonAlg.py.

◆ flags

LArCellMonAlg.flags = initConfigFlags()

Definition at line 461 of file LArCellMonAlg.py.

◆ HISTFileName

LArCellMonAlg.HISTFileName

Definition at line 466 of file LArCellMonAlg.py.

◆ m_BadLBTool

ToolHandle<IDQFilterTool> CaloMonAlgBase::m_BadLBTool
privateinherited

Definition at line 31 of file CaloMonAlgBase.h.

◆ m_BCKey

SG::ReadCondHandleKey<LArBadChannelCont> LArCellMonAlg::m_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}
private

Definition at line 228 of file LArCellMonAlg.h.

◆ m_bcMask

LArBadChannelMask LArCellMonAlg::m_bcMask
private

Definition at line 218 of file LArCellMonAlg.h.

◆ m_beamBackgroundKey

SG::ReadHandleKey<BeamBackgroundData> CaloMonAlgBase::m_beamBackgroundKey {this,"BeamBackgroundKey","CSCBackgroundForCaloMon"}
privateinherited

Definition at line 27 of file CaloMonAlgBase.h.

◆ m_binning

std::array<CaloMonitoring::LArCellBinning,MAXLAYER> LArCellMonAlg::m_binning
private

Definition at line 230 of file LArCellMonAlg.h.

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCellMonAlg::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
private

Definition at line 227 of file LArCellMonAlg.h.

◆ m_calo_id

const CaloCell_ID* CaloMonAlgBase::m_calo_id {nullptr}
protectedinherited

Definition at line 43 of file CaloMonAlgBase.h.

◆ m_caloSamplingToLyrNS

const std::map<unsigned,LayerEnumNoSides> CaloMonAlgBase::m_caloSamplingToLyrNS
protectedinherited

◆ m_cellContainerKey

SG::ReadHandleKey<CaloCellContainer> LArCellMonAlg::m_cellContainerKey {this,"CaloCellContainer","AllCalo","SG key of the input cell container"}
private

Definition at line 55 of file LArCellMonAlg.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_defaultThresholds

FloatArrayProperty LArCellMonAlg::m_defaultThresholds {this, "DefaultThresholds", {}}
private

Definition at line 130 of file LArCellMonAlg.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_doBeamBackgroundRemovalProp

BooleanArrayProperty LArCellMonAlg::m_doBeamBackgroundRemovalProp {this, "DoBeamBackgroundRemoval"}
private

Definition at line 108 of file LArCellMonAlg.h.

◆ m_doDatabaseNoiseVsEtaPhi

BooleanProperty LArCellMonAlg::m_doDatabaseNoiseVsEtaPhi {this, "doDatabaseNoiseVsEtaPhi", true}
private

Definition at line 110 of file LArCellMonAlg.h.

◆ m_doEnergyVsTime

BooleanProperty LArCellMonAlg::m_doEnergyVsTime {this, "doEnergyVsTime", true}
private

Definition at line 112 of file LArCellMonAlg.h.

◆ m_doEtaOccupancyNames

StringArrayProperty LArCellMonAlg::m_doEtaOccupancyNames {this, "DoEtaOccupancyNames", {}}
private

Definition at line 138 of file LArCellMonAlg.h.

◆ m_doEtaPhiAvgQualityNames

StringArrayProperty LArCellMonAlg::m_doEtaPhiAvgQualityNames {this, "DoEtaPhiAvgQualityNames", {},"Turns on 'totQuality' and total 'Occupancy' plots. The ratio will be computed at post-processing stage"}
private

Definition at line 141 of file LArCellMonAlg.h.

◆ m_doEtaPhiAvgTimeNames

StringArrayProperty LArCellMonAlg::m_doEtaPhiAvgTimeNames {this, "DoEtaPhiAvgTimeNames", {},"Turns on 'totTime' and total 'Occupancy' plots. The ratio will be computed at post-processing stage"}
private

Definition at line 143 of file LArCellMonAlg.h.

◆ m_doEtaPhiFractionOverQthNames

StringArrayProperty LArCellMonAlg::m_doEtaPhiFractionOverQthNames {this, "DoEtaPhiFractionOverQthNames", {}}
private

Definition at line 142 of file LArCellMonAlg.h.

◆ m_doEtaPhiFractionPastTthNames

StringArrayProperty LArCellMonAlg::m_doEtaPhiFractionPastTthNames {this, "DoEtaPhiFractionPastTthNames", {}}
private

Definition at line 144 of file LArCellMonAlg.h.

◆ m_doEtaPhiPercentageOccupancyNames

StringArrayProperty LArCellMonAlg::m_doEtaPhiPercentageOccupancyNames {this, "DoEtaPhiPercentageOccupancyNames", {}}
private

Definition at line 137 of file LArCellMonAlg.h.

◆ m_doEtaPhiTotalOccupancyNames

StringArrayProperty LArCellMonAlg::m_doEtaPhiTotalOccupancyNames {this, "DoEtaPhiTotalOccupancyNames", {}}
private

Definition at line 136 of file LArCellMonAlg.h.

◆ m_doEtaPhiTotEnergyNames

StringArrayProperty LArCellMonAlg::m_doEtaPhiTotEnergyNames {this, "DoEtaPhiTotEnergyNames", {}}
private

Definition at line 140 of file LArCellMonAlg.h.

◆ m_doKnownBadChannelsVsEtaPhi

BooleanProperty LArCellMonAlg::m_doKnownBadChannelsVsEtaPhi {this, "doKnownBadChannelsVsEtaPhi", true}
private

Definition at line 109 of file LArCellMonAlg.h.

◆ m_doPhiOccupancyNames

StringArrayProperty LArCellMonAlg::m_doPhiOccupancyNames {this, "DoPhiOccupancyNames", {}}
private

Definition at line 139 of file LArCellMonAlg.h.

◆ m_doUnnormalized1DEnergy

BooleanProperty LArCellMonAlg::m_doUnnormalized1DEnergy {this, "doUnnormalized1DEnergy", false}
private

Definition at line 113 of file LArCellMonAlg.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_eCutForTiming

FloatArrayProperty LArCellMonAlg::m_eCutForTiming
private
Initial value:
{this, "EcutForTiming",
{1000., 1000., 3000., 1500., 3500., 3500., 3500., 3500., 1500., 3000., 3000., 2000., 10000., 10000., 10000.}
}

Definition at line 79 of file LArCellMonAlg.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_groupnameFractionOverQthEtaPhi

Gaudi::Property<std::string> LArCellMonAlg::m_groupnameFractionOverQthEtaPhi {this, "MonGroupName_FractionOverQthEtaPhi"}
private

Definition at line 65 of file LArCellMonAlg.h.

◆ m_groupnameFractionPastTthEtaPhi

Gaudi::Property<std::string> LArCellMonAlg::m_groupnameFractionPastTthEtaPhi {this, "MonGroupName_FractionPastTthEtaPhi"}
private

Definition at line 67 of file LArCellMonAlg.h.

◆ m_groupnameOccupancyEta

Gaudi::Property<std::string> LArCellMonAlg::m_groupnameOccupancyEta {this, "MonGroupName_OccupancyEta"}
private

Definition at line 61 of file LArCellMonAlg.h.

◆ m_groupnameOccupancyPhi

Gaudi::Property<std::string> LArCellMonAlg::m_groupnameOccupancyPhi {this, "MonGroupName_OccupancyPhi"}
private

Definition at line 62 of file LArCellMonAlg.h.

◆ m_groupnamePercentageOccupancyEtaPhi

Gaudi::Property<std::string> LArCellMonAlg::m_groupnamePercentageOccupancyEtaPhi {this, "MonGroupName_PercentageOccupancyEtaPhi"}
private

Definition at line 60 of file LArCellMonAlg.h.

◆ m_groupnameTotalOccupancyEtaPhi

Gaudi::Property<std::string> LArCellMonAlg::m_groupnameTotalOccupancyEtaPhi {this, "MonGroupName_OccupancyEtaPhi"}
private

Definition at line 59 of file LArCellMonAlg.h.

◆ m_groupnameTotEnergyEtaPhi

Gaudi::Property<std::string> LArCellMonAlg::m_groupnameTotEnergyEtaPhi {this, "MonGroupName_TotEnergyEtaPhi"}
private

Definition at line 63 of file LArCellMonAlg.h.

◆ m_groupnameTotQualityEtaPhi

Gaudi::Property<std::string> LArCellMonAlg::m_groupnameTotQualityEtaPhi {this, "MonGroupName_AvgQualityEtaPhi"}
private

Definition at line 64 of file LArCellMonAlg.h.

◆ m_groupnameTotTimeEtaPhi

Gaudi::Property<std::string> LArCellMonAlg::m_groupnameTotTimeEtaPhi {this, "MonGroupName_AvgTimeEtaPhi"}
private

Definition at line 66 of file LArCellMonAlg.h.

◆ m_ignoreKnownBadChannels

BooleanProperty LArCellMonAlg::m_ignoreKnownBadChannels {this, "MaskBadChannels", false, "Do not fill histograms with values from known bad channels"}
private

Definition at line 105 of file LArCellMonAlg.h.

◆ m_inSigNoise

BooleanArrayProperty LArCellMonAlg::m_inSigNoise {this, "ThresholdinSigNoise", {}}
private

Definition at line 131 of file LArCellMonAlg.h.

◆ m_LArCollisionTimeKey

SG::ReadHandleKey<LArCollisionTime> CaloMonAlgBase::m_LArCollisionTimeKey {this,"LArCollisionTimeKey","LArCollisionTime"}
privateinherited

Definition at line 26 of file CaloMonAlgBase.h.

◆ m_LArOnlineIDHelper

const LArOnlineID* LArCellMonAlg::m_LArOnlineIDHelper
private

Definition at line 225 of file LArCellMonAlg.h.

◆ m_layerEnumtoPartitionEnum

const std::array<PartitionEnum,MAXLAYER> LArCellMonAlg::m_layerEnumtoPartitionEnum
private
Initial value:

Definition at line 205 of file LArCellMonAlg.h.

◆ m_layerNames

StringArrayProperty LArCellMonAlg::m_layerNames
private
Initial value:
{this, "LayerNames", {"EMBPA", "EMBPC", "EMB1A", "EMB1C", "EMB2A", "EMB2C", "EMB3A", "EMB3C",
"HEC0A", "HEC0C", "HEC1A", "HEC1C", "HEC2A", "HEC2C", "HEC3A", "HEC3C",
"EMECPA", "EMECPC", "EMEC1A", "EMEC1C", "EMEC2A", "EMEC2C", "EMEC3A", "EMEC3C",
"FCAL1A", "FCAL1C", "FCAL2A", "FCAL2C", "FCAL3A", "FCAL3C"},
"Names of individual layers to monitor"}

Definition at line 84 of file LArCellMonAlg.h.

◆ m_layerNcells

IntegerArrayProperty LArCellMonAlg::m_layerNcells
private
Initial value:
{this,"LayerNcells",{ 3905, 3905, 29376, 29376, 14595, 14595, 6912, 6912,
768, 768, 736, 736, 672, 672, 640, 640,
768, 768, 14272, 14272, 11712, 11712, 5120, 5120,
1008, 1008, 500, 500, 254, 254},
"Number of expected cells per layer"}

Definition at line 89 of file LArCellMonAlg.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_maskNoCondChannels

BooleanProperty LArCellMonAlg::m_maskNoCondChannels {this, "MaskNoCondChannels", false, "Do not fill histograms with values from cells reco'ed w/o conditions database"}
private

Definition at line 106 of file LArCellMonAlg.h.

◆ m_minSporadicNoiseEventsPerCell

UnsignedIntegerProperty LArCellMonAlg::m_minSporadicNoiseEventsPerCell {this, "minSporadicEvents", 10}
private

Definition at line 121 of file LArCellMonAlg.h.

◆ m_MonGroupName

Gaudi::Property<std::string> LArCellMonAlg::m_MonGroupName {this, "MonGroupName", "LArCellMonGroup"}
private

Definition at line 57 of file LArCellMonAlg.h.

◆ m_MonGroupNamePerJob

Gaudi::Property<std::string> LArCellMonAlg::m_MonGroupNamePerJob {this, "MonGroupName_perJob"}
private

Definition at line 58 of file LArCellMonAlg.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_noiseCDOKey

SG::ReadCondHandleKey<CaloNoise> LArCellMonAlg::m_noiseCDOKey {this,"CaloNoiseKey","totalNoise","SG Key of CaloNoise data object"}
private

Definition at line 69 of file LArCellMonAlg.h.

◆ m_partitionNames

StringArrayProperty LArCellMonAlg::m_partitionNames {this, "PartitionNames", {"EMBA","EMBC","EMECA","EMECC","HECA","HECC","FCALA","FCALC"}}
private

Definition at line 95 of file LArCellMonAlg.h.

◆ m_problemsToMask

Gaudi::Property<std::vector<std::string> > LArCellMonAlg::m_problemsToMask {this,"ProblemsToMask",{}, "Bad-Channel categories to mask"}
private

Definition at line 219 of file LArCellMonAlg.h.

◆ m_qualityFactorThresholdProp

FloatArrayProperty LArCellMonAlg::m_qualityFactorThresholdProp {this, "QualityFactorThreshold",{}}
private

Definition at line 134 of file LArCellMonAlg.h.

◆ m_ReadyFilterTool

ToolHandle<IDQFilterTool> CaloMonAlgBase::m_ReadyFilterTool
privateinherited

Definition at line 33 of file CaloMonAlgBase.h.

◆ m_sporadic_protc

UnsignedIntegerProperty LArCellMonAlg::m_sporadic_protc {this, "Sporadic_protection", 4000}
private

Definition at line 120 of file LArCellMonAlg.h.

◆ m_sporadic_switch

BooleanProperty LArCellMonAlg::m_sporadic_switch {this, "Sporadic_switch", false}
private

Definition at line 116 of file LArCellMonAlg.h.

◆ m_sporadicPlotLimit

UnsignedIntegerProperty LArCellMonAlg::m_sporadicPlotLimit {this, "NsporadicPlotLimit", 300}
private

Definition at line 119 of file LArCellMonAlg.h.

◆ m_threshold_em_S0S1

FloatProperty LArCellMonAlg::m_threshold_em_S0S1 {this, "Threshold_EM_S0S1", 5000.}
private

Definition at line 117 of file LArCellMonAlg.h.

◆ m_threshold_HECFCALEMS2S3

FloatProperty LArCellMonAlg::m_threshold_HECFCALEMS2S3 {this, "Threshold_HECFCALEMS2S3", 15000.}
private

Definition at line 118 of file LArCellMonAlg.h.

◆ m_thresholdColumnType

StringArrayProperty LArCellMonAlg::m_thresholdColumnType {this, "ThresholdColumnType",{}}
private

Definition at line 125 of file LArCellMonAlg.h.

◆ m_thresholdDirectionProp

StringArrayProperty LArCellMonAlg::m_thresholdDirectionProp {this, "ThresholdDirection", {}, "Vector of threshold directions"}
private

Definition at line 126 of file LArCellMonAlg.h.

◆ m_thresholdNameProp

StringArrayProperty LArCellMonAlg::m_thresholdNameProp {this, "ThresholdType", {},"Vector of threshold names"}
private

Definition at line 124 of file LArCellMonAlg.h.

◆ m_thresholds

std::vector<threshold_t> LArCellMonAlg::m_thresholds
private

Definition at line 221 of file LArCellMonAlg.h.

◆ m_thresholdsProp

FloatArrayProperty LArCellMonAlg::m_thresholdsProp[MAXLYRNS]
private

Definition at line 149 of file LArCellMonAlg.h.

◆ m_thresholdTitleTemplates

StringArrayProperty LArCellMonAlg::m_thresholdTitleTemplates {this, "ThresholdTitleTemplates", {}}
private

Definition at line 129 of file LArCellMonAlg.h.

◆ m_timeThresholdProp

FloatArrayProperty LArCellMonAlg::m_timeThresholdProp {this, "TimeThreshold"}
private

Definition at line 133 of file LArCellMonAlg.h.

◆ m_toolLookupMap

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

Definition at line 367 of file AthMonitorAlgorithm.h.

◆ m_toolmapAll

std::map<std::string,std::map<std::string,int> > LArCellMonAlg::m_toolmapAll
private

Definition at line 72 of file LArCellMonAlg.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 338 of file AthMonitorAlgorithm.h.

◆ m_trigDecTool

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

Tool to tell whether a specific trigger is passed.

Definition at line 340 of file AthMonitorAlgorithm.h.

◆ m_triggerChainString

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

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

Definition at line 355 of file AthMonitorAlgorithm.h.

◆ m_triggerNames

StringProperty LArCellMonAlg::m_triggerNames[NOTA]
private

Definition at line 103 of file LArCellMonAlg.h.

◆ m_triggersToExcludeProp

StringArrayProperty LArCellMonAlg::m_triggersToExcludeProp {this, "TriggersToExclude", {}}
private

Definition at line 128 of file LArCellMonAlg.h.

◆ m_triggersToIncludeProp

StringArrayProperty LArCellMonAlg::m_triggersToIncludeProp {this, "TriggersToInclude", {}}
private

Definition at line 127 of file LArCellMonAlg.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_useBadLBTool

bool CaloMonAlgBase::m_useBadLBTool
privateinherited

Definition at line 30 of file CaloMonAlgBase.h.

◆ m_useBeamBackgroundRemoval

bool CaloMonAlgBase::m_useBeamBackgroundRemoval
privateinherited

Definition at line 38 of file CaloMonAlgBase.h.

◆ m_useCollisionFilterTool

bool CaloMonAlgBase::m_useCollisionFilterTool
privateinherited

Definition at line 37 of file CaloMonAlgBase.h.

◆ m_useLArNoisyAlg

bool CaloMonAlgBase::m_useLArNoisyAlg
privateinherited

Definition at line 35 of file CaloMonAlgBase.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_useReadyFilterTool

bool CaloMonAlgBase::m_useReadyFilterTool
privateinherited

Definition at line 32 of file CaloMonAlgBase.h.

◆ m_useTrigger

BooleanProperty LArCellMonAlg::m_useTrigger {this, "useTrigger", true}
private

Definition at line 102 of file LArCellMonAlg.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.

◆ useTrigger

LArCellMonAlg.useTrigger

Definition at line 468 of file LArCellMonAlg.py.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArCellMonAlg::m_thresholdTitleTemplates
StringArrayProperty m_thresholdTitleTemplates
Definition: LArCellMonAlg.h:129
LArCellMonAlg::NONE
@ NONE
Definition: LArCellMonAlg.h:99
LArCellMonAlg::MAXTRIGTYPE
@ MAXTRIGTYPE
Definition: LArCellMonAlg.h:100
CaloMonAlgBase::checkFilters
StatusCode checkFilters(bool &ifPass, bool &passBeamBackgroundRemoval, const std::string &MonGroupName, const EventContext &ctx) const
Definition: CaloMonAlgBase.cxx:61
beamspotman.r
def r
Definition: beamspotman.py:676
CaloMonAlgBase::EMB1A
@ EMB1A
Definition: CaloMonAlgBase.h:48
LArCellMonAlg::m_timeThresholdProp
FloatArrayProperty m_timeThresholdProp
Definition: LArCellMonAlg.h:133
LArCellMonAlg::m_doEtaPhiTotalOccupancyNames
StringArrayProperty m_doEtaPhiTotalOccupancyNames
Definition: LArCellMonAlg.h:136
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
LArCellMonAlg::EMBA
@ EMBA
Definition: LArCellMonAlg.h:152
CaloDetDescrElement::is_lar_em_endcap_inner
bool is_lar_em_endcap_inner() const
cell belongs to the inner wheel of EM end cap
Definition: CaloDetDescrElement.cxx:114
LArCellMonAlg::m_triggerNames
StringProperty m_triggerNames[NOTA]
Definition: LArCellMonAlg.h:103
LArCellMonAlg::MISC
@ MISC
Definition: LArCellMonAlg.h:100
CaloMonAlgBase::FCAL3C
@ FCAL3C
Definition: CaloMonAlgBase.h:51
LArCellMonAlg::m_doEtaPhiAvgQualityNames
StringArrayProperty m_doEtaPhiAvgQualityNames
Definition: LArCellMonAlg.h:141
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
LArBadChannel::good
bool good() const
Returns true if no problems at all (all bits at zero)
Definition: LArBadChannel.h:90
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
checkFileSG.line
line
Definition: checkFileSG.py:75
LArCellMonAlg::m_thresholdsProp
FloatArrayProperty m_thresholdsProp[MAXLYRNS]
Definition: LArCellMonAlg.h:149
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
LArCellMonAlg::HECC
@ HECC
Definition: LArCellMonAlg.h:152
get_generator_info.result
result
Definition: get_generator_info.py:21
CaloMonAlgBase::FCAL2A
@ FCAL2A
Definition: CaloMonAlgBase.h:51
CaloCell_Base_ID::region
int region(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
LArCellMonAlg::m_eCutForTiming
FloatArrayProperty m_eCutForTiming
Definition: LArCellMonAlg.h:79
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
LArCellMonAlg::m_threshold_em_S0S1
FloatProperty m_threshold_em_S0S1
Definition: LArCellMonAlg.h:117
CaloMonAlgBase::EMB2A
@ EMB2A
Definition: CaloMonAlgBase.h:48
LArCellMonAlg::UNDER
@ UNDER
Definition: LArCellMonAlg.h:99
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
LArCellMonAlg::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArCellMonAlg.h:228
CaloMonAlgBase::m_LArCollisionTimeKey
SG::ReadHandleKey< LArCollisionTime > m_LArCollisionTimeKey
Definition: CaloMonAlgBase.h:26
LArCellMonAlg::m_doEtaOccupancyNames
StringArrayProperty m_doEtaOccupancyNames
Definition: LArCellMonAlg.h:138
CaloMonAlgBase::MAXLAYER
@ MAXLAYER
Definition: CaloMonAlgBase.h:51
CaloMonAlgBase::HEC0A
@ HEC0A
Definition: CaloMonAlgBase.h:49
LArCellMonAlg::m_doEtaPhiPercentageOccupancyNames
StringArrayProperty m_doEtaPhiPercentageOccupancyNames
Definition: LArCellMonAlg.h:137
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
CaloMonAlgBase::HEC1NS
@ HEC1NS
Definition: CaloMonAlgBase.h:54
AtlasDetectorID::is_lar
bool is_lar(Identifier id) const
Definition: AtlasDetectorID.h:689
LArCellMonAlg::m_doBeamBackgroundRemovalProp
BooleanArrayProperty m_doBeamBackgroundRemovalProp
Definition: LArCellMonAlg.h:108
CaloMonAlgBase::FCAL1NS
@ FCAL1NS
Definition: CaloMonAlgBase.h:55
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LArCellMonAlg::m_doEtaPhiFractionOverQthNames
StringArrayProperty m_doEtaPhiFractionOverQthNames
Definition: LArCellMonAlg.h:142
LArBadXCont
Conditions-Data class holding LAr Bad Channel or Bad Feb information.
Definition: LArBadChannelCont.h:28
CaloMonAlgBase::EMBPA
@ EMBPA
Definition: CaloMonAlgBase.h:48
AthMonitorAlgorithm::m_triggerChainString
Gaudi::Property< std::string > m_triggerChainString
Trigger chain string pulled from the job option and parsed into a vector.
Definition: AthMonitorAlgorithm.h:355
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
CaloMonAlgBase::EMEC2NS
@ EMEC2NS
Definition: CaloMonAlgBase.h:55
LArCellMonAlg::CALO
@ CALO
Definition: LArCellMonAlg.h:100
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
CaloMonAlgBase::m_useCollisionFilterTool
bool m_useCollisionFilterTool
Definition: CaloMonAlgBase.h:37
CaloMonAlgBase::HEC1A
@ HEC1A
Definition: CaloMonAlgBase.h:49
LArCellMonAlg::m_doEnergyVsTime
BooleanProperty m_doEnergyVsTime
Definition: LArCellMonAlg.h:112
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
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
CaloMonAlgBase::EMEC1NS
@ EMEC1NS
Definition: CaloMonAlgBase.h:55
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
LArCellMonAlg::m_bcMask
LArBadChannelMask m_bcMask
Definition: LArCellMonAlg.h:218
skel.it
it
Definition: skel.GENtoEVGEN.py:396
CaloMonAlgBase::EMB1NS
@ EMB1NS
Definition: CaloMonAlgBase.h:54
AthMonitorAlgorithm::getTrigDecisionTool
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool() const
Get the trigger decision tool member.
Definition: AthMonitorAlgorithm.cxx:189
CaloMonAlgBase::m_useBeamBackgroundRemoval
bool m_useBeamBackgroundRemoval
Definition: CaloMonAlgBase.h:38
M_PI
#define M_PI
Definition: ActiveFraction.h:11
CaloCell_ID_FCS::FCAL1
@ FCAL1
Definition: FastCaloSim_CaloCell_ID.h:41
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
LArCellMonAlg::m_triggersToExcludeProp
StringArrayProperty m_triggersToExcludeProp
Definition: LArCellMonAlg.h:128
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
LArBadChannelMask::buildBitMask
StatusCode buildBitMask(const std::vector< std::string > &problemsToMask, MsgStream &msg)
Definition: LArBadChannelMask.cxx:10
LArCellMonAlg::strToLower
static std::string strToLower(const std::string &input)
Definition: LArCellMonAlg.cxx:685
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
CaloMonAlgBase::EMECPC
@ EMECPC
Definition: CaloMonAlgBase.h:50
CaloMonAlgBase::EMEC1C
@ EMEC1C
Definition: CaloMonAlgBase.h:50
CaloMonAlgBase::EMBPNS
@ EMBPNS
Definition: CaloMonAlgBase.h:54
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
LArCellMonAlg::BOTH
@ BOTH
Definition: LArCellMonAlg.h:99
CaloMonAlgBase::HEC1C
@ HEC1C
Definition: CaloMonAlgBase.h:49
athena.value
value
Definition: athena.py:124
CaloMonAlgBase::FCAL3A
@ FCAL3A
Definition: CaloMonAlgBase.h:51
LArCellMonAlg::m_useTrigger
BooleanProperty m_useTrigger
Definition: LArCellMonAlg.h:102
LArCellMonAlg::FCALA
@ FCALA
Definition: LArCellMonAlg.h:152
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
CaloMonAlgBase::EMECPNS
@ EMECPNS
Definition: CaloMonAlgBase.h:55
cosmics
Definition: cosmics.py:1
LArCellMonAlg::m_triggersToIncludeProp
StringArrayProperty m_triggersToIncludeProp
Definition: LArCellMonAlg.h:127
LArCellMonAlg::m_inSigNoise
BooleanArrayProperty m_inSigNoise
Definition: LArCellMonAlg.h:131
CaloCell_ID_FCS::HEC2
@ HEC2
Definition: FastCaloSim_CaloCell_ID.h:29
LArCellMonAlg::m_ignoreKnownBadChannels
BooleanProperty m_ignoreKnownBadChannels
Definition: LArCellMonAlg.h:105
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
CaloMonAlgBase::EMEC2A
@ EMEC2A
Definition: CaloMonAlgBase.h:50
CaloMonAlgBase::HEC2C
@ HEC2C
Definition: CaloMonAlgBase.h:49
CaloMonAlgBase::EMEC2C
@ EMEC2C
Definition: CaloMonAlgBase.h:50
CaloNoise::getNoise
float getNoise(const IdentifierHash h, const int gain) const
Accessor by IdentifierHash and gain.
Definition: CaloNoise.h:34
LArBadChannelMask::cellShouldBeMasked
bool cellShouldBeMasked(const LArBadChannelCont *bcCont, const HWIdentifier &hardwareId) const
Definition: LArBadChannelMask.h:42
CaloMonAlgBase::initialize
virtual StatusCode initialize()
initialize
Definition: CaloMonAlgBase.cxx:25
x
#define x
LArCellMonAlg::m_doEtaPhiFractionPastTthNames
StringArrayProperty m_doEtaPhiFractionPastTthNames
Definition: LArCellMonAlg.h:144
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition: EventInfo_v1.h:335
LArCellMonAlg::m_doPhiOccupancyNames
StringArrayProperty m_doPhiOccupancyNames
Definition: LArCellMonAlg.h:139
CaloMonAlgBase::m_caloSamplingToLyrNS
const std::map< unsigned, LayerEnumNoSides > m_caloSamplingToLyrNS
Definition: CaloMonAlgBase.h:60
LArCellMonAlg::m_doKnownBadChannelsVsEtaPhi
BooleanProperty m_doKnownBadChannelsVsEtaPhi
Definition: LArCellMonAlg.h:109
CaloMonAlgBase::EMEC3A
@ EMEC3A
Definition: CaloMonAlgBase.h:50
LArCellMonAlg::EMBC
@ EMBC
Definition: LArCellMonAlg.h:152
LArCellMonAlg::m_sporadic_switch
BooleanProperty m_sporadic_switch
Definition: LArCellMonAlg.h:116
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:194
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
AthMonitorAlgorithm::Environment_t::user
@ user
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CaloDetDescrElement::eta_raw
float eta_raw() const
cell eta_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:350
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
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
LArCellMonAlg::EMECC
@ EMECC
Definition: LArCellMonAlg.h:152
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
xAOD::EventInfo_v1::Error
@ Error
The sub-detector issued an error.
Definition: EventInfo_v1.h:349
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TRT::Hit::side
@ side
Definition: HitInfo.h:83
CaloMonAlgBase::HEC2NS
@ HEC2NS
Definition: CaloMonAlgBase.h:54
Run1::Channel::threshold_t
cool::Int16 threshold_t
Definition: openCoraCool.cxx:104
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
LArCellMonAlg::m_thresholdColumnType
StringArrayProperty m_thresholdColumnType
Definition: LArCellMonAlg.h:125
CaloMonAlgBase::EMECPA
@ EMECPA
Definition: CaloMonAlgBase.h:50
LArCellMonAlg::m_MonGroupNamePerJob
Gaudi::Property< std::string > m_MonGroupNamePerJob
Definition: LArCellMonAlg.h:58
LArCellMonAlg::m_doEtaPhiAvgTimeNames
StringArrayProperty m_doEtaPhiAvgTimeNames
Definition: LArCellMonAlg.h:143
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
LArCellMonAlg::m_problemsToMask
Gaudi::Property< std::vector< std::string > > m_problemsToMask
Definition: LArCellMonAlg.h:219
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:64
LArCellMonAlg::m_layerNcells
IntegerArrayProperty m_layerNcells
Definition: LArCellMonAlg.h:89
LArCellMonAlg::OVER
@ OVER
Definition: LArCellMonAlg.h:99
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
CaloDetDescrElement::calo_hash
IdentifierHash calo_hash() const
cell calo hash
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:412
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition: AthMonitorAlgorithm.h:341
CaloCell_ID_FCS::HEC1
@ HEC1
Definition: FastCaloSim_CaloCell_ID.h:28
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
CaloMonAlgBase::HEC0NS
@ HEC0NS
Definition: CaloMonAlgBase.h:54
LArCellMonAlg::MINBIAS
@ MINBIAS
Definition: LArCellMonAlg.h:100
LArCellMonAlg::m_thresholdNameProp
StringArrayProperty m_thresholdNameProp
Definition: LArCellMonAlg.h:124
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloMonAlgBase::CaloMonAlgBase
CaloMonAlgBase(const std::string &name, ISvcLocator *pSvcLocator)
Definition: CaloMonAlgBase.cxx:7
LArCellMonAlg::m_layerEnumtoPartitionEnum
const std::array< PartitionEnum, MAXLAYER > m_layerEnumtoPartitionEnum
Definition: LArCellMonAlg.h:205
CaloMonAlgBase::m_useBadLBTool
bool m_useBadLBTool
Definition: CaloMonAlgBase.h:30
LArCellMonAlg::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArCellMonAlg.h:227
LArCellMonAlg::m_MonGroupName
Gaudi::Property< std::string > m_MonGroupName
Definition: LArCellMonAlg.h:57
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloMonAlgBase::FCAL2C
@ FCAL2C
Definition: CaloMonAlgBase.h:51
LArCellMonAlg::m_defaultThresholds
FloatArrayProperty m_defaultThresholds
Definition: LArCellMonAlg.h:130
LArCellMonAlg::NOTA
@ NOTA
Definition: LArCellMonAlg.h:100
CaloMonAlgBase::HEC3A
@ HEC3A
Definition: CaloMonAlgBase.h:49
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
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
LArCellMonAlg::m_toolmapAll
std::map< std::string, std::map< std::string, int > > m_toolmapAll
Definition: LArCellMonAlg.h:72
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
LArBadChannel
Definition: LArBadChannel.h:10
constants.EME1
int EME1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:55
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LArCellMonAlg::m_cellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_cellContainerKey
Definition: LArCellMonAlg.h:55
CaloMonAlgBase::EMBPC
@ EMBPC
Definition: CaloMonAlgBase.h:48
InDetDD::none
@ none
Definition: InDetDD_Defs.h:19
CaloMonAlgBase::m_calo_id
const CaloCell_ID * m_calo_id
Definition: CaloMonAlgBase.h:43
CaloMonAlgBase::EMEC3C
@ EMEC3C
Definition: CaloMonAlgBase.h:50
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
CaloMonAlgBase::m_BadLBTool
ToolHandle< IDQFilterTool > m_BadLBTool
Definition: CaloMonAlgBase.h:31
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
CaloMonAlgBase::EMB3NS
@ EMB3NS
Definition: CaloMonAlgBase.h:54
LArCellMonAlg::m_qualityFactorThresholdProp
FloatArrayProperty m_qualityFactorThresholdProp
Definition: LArCellMonAlg.h:134
CaloMonAlgBase::EMEC3NS
@ EMEC3NS
Definition: CaloMonAlgBase.h:55
CaloMonAlgBase::getHistoCoordinates
void getHistoCoordinates(const CaloDetDescrElement *dde, float &celleta, float &cellphi, unsigned &iLyr, unsigned &iLyrNS) const
Definition: CaloMonAlgBase.cxx:176
LArCellMonAlg::EMECA
@ EMECA
Definition: LArCellMonAlg.h:152
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
WriteCellNoiseToCool.cellHash
cellHash
Definition: WriteCellNoiseToCool.py:433
CaloMonAlgBase::FCAL3NS
@ FCAL3NS
Definition: CaloMonAlgBase.h:55
CaloMonAlgBase::EMB1C
@ EMB1C
Definition: CaloMonAlgBase.h:48
LArCellMonAlg::MET
@ MET
Definition: LArCellMonAlg.h:100
CaloMonAlgBase::EMB2C
@ EMB2C
Definition: CaloMonAlgBase.h:48
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
LArCellMonAlg::RNDM
@ RNDM
Definition: LArCellMonAlg.h:100
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
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
fill
void fill(H5::Group &out_file, size_t iterations)
Definition: test-hdf5-writer.cxx:95
CaloNoise
Definition: CaloNoise.h:16
merge.output
output
Definition: merge.py:17
Trig::ChainGroup
Definition: ChainGroup.h:51
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
Trig::ChainGroup::isPassed
bool isPassed(unsigned int condition=TrigDefs::Physics) const
tells if chain group passed
Definition: ChainGroup.cxx:208
LArCellMonAlg::HECA
@ HECA
Definition: LArCellMonAlg.h:152
AthMonitorAlgorithm::Environment_t::online
@ online
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
CaloMonAlgBase::MAXLYRNS
@ MAXLYRNS
Definition: CaloMonAlgBase.h:55
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
MET
Definition: MET.py:1
CaloCell_ID_FCS::EME3
@ EME3
Definition: FastCaloSim_CaloCell_ID.h:26
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
PlotCalibFromCool.en
en
Definition: PlotCalibFromCool.py:399
LArCellMonAlg::FCALC
@ FCALC
Definition: LArCellMonAlg.h:152
threshold
Definition: chainparser.cxx:74
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
LArBadChannel::packedData
BitWord packedData() const
Definition: LArBadChannel.h:145
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
LArCellMonAlg::initThresh
StatusCode initThresh()
Definition: LArCellMonAlg.cxx:119
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:453
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
CaloMonAlgBase::HEC0C
@ HEC0C
Definition: CaloMonAlgBase.h:49
LArCellMonAlg::createPerJobHistograms
StatusCode createPerJobHistograms(const CaloCellContainer *cellcont, const CaloNoise *noisep) const
Definition: LArCellMonAlg.cxx:629
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
item
Definition: ItemListSvc.h:43
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
LArCellMonAlg::m_doEtaPhiTotEnergyNames
StringArrayProperty m_doEtaPhiTotEnergyNames
Definition: LArCellMonAlg.h:140
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
LArCellMonAlg::m_thresholdDirectionProp
StringArrayProperty m_thresholdDirectionProp
Definition: LArCellMonAlg.h:126
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
CaloCell_ID_FCS::HEC0
@ HEC0
Definition: FastCaloSim_CaloCell_ID.h:27
CaloMonAlgBase::m_useLArNoisyAlg
bool m_useLArNoisyAlg
Definition: CaloMonAlgBase.h:35
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
python.PyAthena.v
v
Definition: PyAthena.py:154
LArCellMonAlg::m_noiseCDOKey
SG::ReadCondHandleKey< CaloNoise > m_noiseCDOKey
Definition: LArCellMonAlg.h:69
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
LArCellMonAlg::m_LArOnlineIDHelper
const LArOnlineID * m_LArOnlineIDHelper
Definition: LArCellMonAlg.h:225
LArCellMonAlg::isThrListed
static bool isThrListed(const std::vector< std::string > &vec, const std::string &s)
Definition: LArCellMonAlg.cxx:693
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
LArCellMonAlg::m_binning
std::array< CaloMonitoring::LArCellBinning, MAXLAYER > m_binning
Definition: LArCellMonAlg.h:230
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
LArCellMonAlg::checkTriggerAndBeamBackground
void checkTriggerAndBeamBackground(bool passBeamBackgroundRemoval, std::vector< threshold_t > &thresholds) const
Definition: LArCellMonAlg.cxx:289
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:426
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CaloMonAlgBase::HEC3C
@ HEC3C
Definition: CaloMonAlgBase.h:49
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
CaloMonAlgBase::EMB3C
@ EMB3C
Definition: CaloMonAlgBase.h:48
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
CaloCell_ID_FCS::FCAL2
@ FCAL2
Definition: FastCaloSim_CaloCell_ID.h:42
CaloMonAlgBase::FCAL1A
@ FCAL1A
Definition: CaloMonAlgBase.h:51
CaloMonAlgBase::m_useReadyFilterTool
bool m_useReadyFilterTool
Definition: CaloMonAlgBase.h:32
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
CaloMonAlgBase::m_beamBackgroundKey
SG::ReadHandleKey< BeamBackgroundData > m_beamBackgroundKey
Definition: CaloMonAlgBase.h:27
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
CaloMonAlgBase::m_ReadyFilterTool
ToolHandle< IDQFilterTool > m_ReadyFilterTool
Definition: CaloMonAlgBase.h:33
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
CaloMonAlgBase::EMEC1A
@ EMEC1A
Definition: CaloMonAlgBase.h:50
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
LArCellMonAlg::m_doDatabaseNoiseVsEtaPhi
BooleanProperty m_doDatabaseNoiseVsEtaPhi
Definition: LArCellMonAlg.h:110
LArCellMonAlg::MAXPARTITIONS
@ MAXPARTITIONS
Definition: LArCellMonAlg.h:152
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
CaloCell_ID_FCS::HEC3
@ HEC3
Definition: FastCaloSim_CaloCell_ID.h:30
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:327
LArCellMonAlg::m_thresholds
std::vector< threshold_t > m_thresholds
Definition: LArCellMonAlg.h:221
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition: FastCaloSim_CaloCell_ID.h:40
CaloCell_ID_FCS::EMB3
@ EMB3
Definition: FastCaloSim_CaloCell_ID.h:22
CaloMonAlgBase::EMB2NS
@ EMB2NS
Definition: CaloMonAlgBase.h:54
python.compressB64.c
def c
Definition: compressB64.py:93
CaloMonAlgBase::FCAL1C
@ FCAL1C
Definition: CaloMonAlgBase.h:51
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LArCellMonAlg::m_maskNoCondChannels
BooleanProperty m_maskNoCondChannels
Definition: LArCellMonAlg.h:106
LArCellMonAlg::m_partitionNames
StringArrayProperty m_partitionNames
Definition: LArCellMonAlg.h:95
CaloMonAlgBase::FCAL2NS
@ FCAL2NS
Definition: CaloMonAlgBase.h:55
LArCellMonAlg::m_layerNames
StringArrayProperty m_layerNames
Definition: LArCellMonAlg.h:84
CaloMonAlgBase::EMB3A
@ EMB3A
Definition: CaloMonAlgBase.h:48
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
CaloMonAlgBase::HEC2A
@ HEC2A
Definition: CaloMonAlgBase.h:49
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
CaloMonAlgBase::HEC3NS
@ HEC3NS
Definition: CaloMonAlgBase.h:54
fitman.k
k
Definition: fitman.py:528
CaloDetDescrElement::phi_raw
float phi_raw() const
cell phi_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:352
LArCellMonAlg::m_threshold_HECFCALEMS2S3
FloatProperty m_threshold_HECFCALEMS2S3
Definition: LArCellMonAlg.h:118
ServiceHandle< ICondSvc >
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
collisions
Definition: collisions.py:1
Identifier
Definition: IdentifierFieldParser.cxx:14