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

Class for Tile Cell based monitoring. More...

#include <TileCellMonitorAlgorithm.h>

Inheritance diagram for TileCellMonitorAlgorithm:
Collaboration diagram for TileCellMonitorAlgorithm:

Public Types

enum  L1TriggerTypeBit {
  BIT0_RNDM, BIT1_ZEROBIAS, BIT2_L1CAL, BIT3_MUON,
  BIT4_RPC, BIT5_FTK, BIT6_CTP, BIT7_CALIB,
  ANY_PHYSICS
}
 Describes L1 trigger type bits. More...
 
enum  AuxiliarySampling { SAMP_ALL = 4, MAX_SAMP = 5 }
 Describes Tile auxiliary sampling. More...
 
enum  Partition {
  PART_LBA, PART_LBC, PART_EBA, PART_EBC,
  PART_ALL, MAX_PART
}
 Describes Tile partitions (ROS - 1) More...
 
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

virtual ~TileCellMonitorAlgorithm ()=default
 
virtual StatusCode initialize () override
 initialize More...
 
virtual StatusCode fillHistograms (const EventContext &ctx) const override
 adds event to the monitoring histograms More...
 
 TileMonitorAlgorithm (const std::string &name, ISvcLocator *svcLocator)
 
std::vector< int > getL1TriggerIndices (uint32_t lvl1TriggerType) const
 Return indices of histograms to be filled according fired L1 trigger type. More...
 
L1TriggerTypeBit getL1TriggerTypeBit (int lvl1TriggerIdx) const
 Return Level1 Trigger type bit according trigger index. More...
 
int getNumberOfL1Triggers (void) const
 Return number of L1 triggers for which histograms should be filled. More...
 
bool isPhysicsEvent (uint32_t lvl1TriggerType) const
 Return true if it is physics event or false for calibration event. More...
 
Partition getPartition (const CaloCell *cell, const TileID *tileID) const
 Return Partition for Tile cell or MAX_PART otherwise. More...
 
Partition getPartition (Identifier id, const TileID *tileID) const
 Return Partition for Tile cell identifier or MAX_PART otherwise. More...
 
Partition getPartition (IdentifierHash hash, const TileID *tileID) const
 Return Partition for Tile cell identifier hash or MAX_PART otherwise. More...
 
 AthMonitorAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 Constructor. More...
 
virtual StatusCode execute (const EventContext &ctx) const override
 Applies filters and trigger requirements. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by reference. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by reference. More...
 
template<typename... T>
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, T &&... variables) const
 Fills a variadic list of variables to a group by reference. More...
 
void fill (const std::string &groupName, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by name. More...
 
void fill (const std::string &groupName, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by name. More...
 
template<typename... T>
void fill (const std::string &groupName, T &&... variables) const
 Fills a variadic list of variables to a group by name. More...
 
Environment_t environment () const
 Accessor functions for the environment. More...
 
Environment_t envStringToEnum (const std::string &str) const
 Convert the environment string from the python configuration to an enum object. More...
 
DataType_t dataType () const
 Accessor functions for the data type. More...
 
DataType_t dataTypeStringToEnum (const std::string &str) const
 Convert the data type string from the python configuration to an enum object. More...
 
const ToolHandle< GenericMonitoringTool > & getGroup (const std::string &name) const
 Get a specific monitoring tool from the tool handle array. More...
 
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool () const
 Get the trigger decision tool member. More...
 
bool trigChainsArePassed (const std::vector< std::string > &vTrigNames) const
 Check whether triggers are passed. More...
 
SG::ReadHandle< xAOD::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
 
 Files
 
 HISTFileName
 
 useTrigger
 
 enableLumiAccess
 
 MaxEvents
 
 cfg
 
 l1Triggers
 
 fillHistogramsForL1Triggers
 
 fillTimeAndEnergyDiffHistograms
 
 withDetails
 
 True
 
 summariseProps
 
 sc
 

Protected Member Functions

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

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

typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

int getDigitizer (int channel) const
 
void fillMaskedInDB (const TileBadChannels *badChannels) const
 
void fillSynchronization (const std::vector< const CaloCell * > &cells, const std::vector< int > &l1TriggersIndices) const
 
L1TriggerTypeBit getL1TriggerTypeBitFromName (const std::string &triggerBitName) 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...
 

Private Attributes

Gaudi::Property< float > m_energyThreshold
 
Gaudi::Property< float > m_negativeEnergyThreshold
 
Gaudi::Property< float > m_energyThresholdForTime
 
Gaudi::Property< float > m_energyLimitForTime
 
Gaudi::Property< float > m_energyBalanceThreshold
 
Gaudi::Property< float > m_timeBalanceThreshold
 
Gaudi::Property< float > m_energyThresholdForGapScint
 
Gaudi::Property< bool > m_fillTimeHistograms
 
Gaudi::Property< bool > m_fillChannelTimeHistograms
 
Gaudi::Property< bool > m_fillGapScintHistograms
 
Gaudi::Property< bool > m_fillTimeAndEnergyDiffHistograms
 
Gaudi::Property< std::vector< float > > m_energyRangeForMuon
 
Gaudi::Property< std::vector< float > > m_timeRangeForMuon
 
Gaudi::Property< std::vector< float > > m_energyThresholdForGain
 
ServiceHandle< TileCablingSvcm_cablingSvc
 Name of Tile cabling service. More...
 
SG::ReadHandleKey< TileDQstatusm_DQstatusKey
 
SG::ReadCondHandleKey< TileBadChannelsm_badChannelsKey
 Name of TileBadChannels in condition store. More...
 
SG::ReadHandleKey< CaloCellContainerm_caloCellContainerKey
 
const TileIDm_tileID {nullptr}
 
const TileHWIDm_tileHWID {nullptr}
 
const TileCablingServicem_cabling {nullptr}
 
std::vector< int > m_energyBalModPartGroups
 
std::vector< int > m_timeBalModPartGroups
 
std::vector< int > m_cellSynchGroups
 
std::vector< int > m_maskedOnFlyGroups
 
std::vector< int > m_maskedDueDQGroups
 
std::vector< int > m_maskedCellsDueDQGroups
 
std::vector< int > m_maskedOnFlyLBGroups
 
std::vector< int > m_maskedCellsLBGroups
 
std::vector< std::vector< int > > m_maskedGroups
 
std::vector< std::vector< int > > m_energySampEGroups
 
std::vector< std::vector< int > > m_moduleCorrGroups
 
std::vector< std::vector< int > > m_chanTimeGroups
 
std::vector< std::vector< int > > m_digiTimeGroups
 
std::vector< std::vector< int > > m_nCellsGroups
 
std::vector< std::vector< int > > m_nCellsOverThrGroups
 
std::vector< std::vector< int > > m_detailOccupGroups
 
std::vector< std::vector< int > > m_overThrOccupGroups
 
std::vector< std::vector< int > > m_overThr30GeVOccupGroups
 
std::vector< std::vector< int > > m_overThr300GeVOccupGroups
 
std::vector< std::vector< int > > m_eneDiffChanModGroups
 
std::vector< std::vector< std::vector< int > > > m_overThrOccupGainGroups
 
std::vector< std::vector< std::vector< int > > > m_detailOccupGainGroups
 
std::vector< std::vector< std::vector< int > > > m_energyGapScintGroups
 
std::vector< std::vector< std::vector< int > > > m_chanTimeSampGroups
 
std::vector< std::vector< std::vector< int > > > m_eneDiffSampGroups
 
std::vector< std::vector< std::vector< int > > > m_timeDiffSampGroups
 
std::vector< std::vector< int > > m_eneEtaPhiGroups
 
std::vector< std::vector< int > > m_overThrEtaPhiGroups
 
std::vector< int > m_negOccupGroups
 
std::vector< int > m_timeBalGroups
 
std::vector< int > m_energyBalGroups
 
Gaudi::Property< std::vector< std::string > > m_fillHistogramsForL1Triggers
 
std::vector< L1TriggerTypeBitm_l1Triggers
 
std::vector< int > m_l1TriggerIndices
 
std::vector< std::string > m_l1TriggerBitNames
 
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

Class for Tile Cell based monitoring.

Definition at line 29 of file TileCellMonitorAlgorithm.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

◆ AuxiliarySampling

Describes Tile auxiliary sampling.

Enumerator
SAMP_ALL 
MAX_SAMP 

Definition at line 40 of file TileMonitorAlgorithm.h.

40 {SAMP_ALL = 4, MAX_SAMP = 5};

◆ DataType_t

enum AthMonitorAlgorithm::DataType_t
stronginherited

Specifies what type of input data is being monitored.

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

Enumerator
userDefined 
monteCarlo 
collisions 
cosmics 
heavyIonCollisions 

Definition at line 191 of file AthMonitorAlgorithm.h.

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

◆ Environment_t

enum AthMonitorAlgorithm::Environment_t
stronginherited

Specifies the processing environment.

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

Enumerator
user 
online 
tier0 
tier0Raw 
tier0ESD 
AOD 
altprod 

Definition at line 172 of file AthMonitorAlgorithm.h.

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

◆ L1TriggerTypeBit

Describes L1 trigger type bits.

Enumerator
BIT0_RNDM 
BIT1_ZEROBIAS 
BIT2_L1CAL 
BIT3_MUON 
BIT4_RPC 
BIT5_FTK 
BIT6_CTP 
BIT7_CALIB 
ANY_PHYSICS 

Definition at line 33 of file TileMonitorAlgorithm.h.

◆ Partition

Describes Tile partitions (ROS - 1)

Enumerator
PART_LBA 
PART_LBC 
PART_EBA 
PART_EBC 
PART_ALL 
MAX_PART 

Definition at line 46 of file TileMonitorAlgorithm.h.

47  PART_EBC, PART_ALL, MAX_PART}; // ROS - 1

Constructor & Destructor Documentation

◆ ~TileCellMonitorAlgorithm()

virtual TileCellMonitorAlgorithm::~TileCellMonitorAlgorithm ( )
virtualdefault

Member Function Documentation

◆ AthMonitorAlgorithm()

AthMonitorAlgorithm::AthMonitorAlgorithm
inherited

Constructor.

Definition at line 42 of file AthMonitorAlgorithm.cxx.

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

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

Definition at line 221 of file AthMonitorAlgorithm.h.

221 { return m_dataType; }

◆ dataTypeStringToEnum()

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

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

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

Definition at line 140 of file AthMonitorAlgorithm.cxx.

140  {
141  // convert the string to all lowercase
142  std::string lowerCaseStr = str;
143  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
144 
145  // check if it matches one of the enum choices
146  if( lowerCaseStr == "userdefined" ) {
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 TileCellMonitorAlgorithm::fillHistograms ( const EventContext &  ctx) const
overridevirtual

adds event to the monitoring histograms

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

Parameters
ctxforwarded from execute
Returns
StatusCode

Implements TileMonitorAlgorithm.

Definition at line 122 of file TileCellMonitorAlgorithm.cxx.

122  {
123 
124  using Tile = TileCalibUtils;
125 
126  // In case you want to measure the execution time
127  auto timer = Monitored::Timer("TIME_execute");
128 
129  const xAOD::EventInfo* eventInfo = GetEventInfo(ctx).get();
130 
131  const TileDQstatus* dqStatus = SG::makeHandle(m_DQstatusKey, ctx).get();
132  auto lumiBlock = Monitored::Scalar<int>("lumiBlock", eventInfo->lumiBlock());
133 
134 
135  if (msgLvl(MSG::DEBUG)) {
136  msg(MSG::DEBUG) << "Run = " << eventInfo->runNumber()
137  << " LB = " << eventInfo->lumiBlock()
138  << " Evt = " << eventInfo->eventNumber()
139  << " BCID = " << eventInfo->bcid()
140  << " lvl1 = 0x" << std::hex << eventInfo->level1TriggerType() << std::dec;
141 
142  const std::vector<xAOD::EventInfo::StreamTag>& eventStreamTags = eventInfo->streamTags();
143  if (!eventStreamTags.empty()) {
144  msg(MSG::DEBUG) << " stream name/type:";
145  for (const auto& eventStreamTag : eventStreamTags) {
146  msg(MSG::DEBUG) << " " << eventStreamTag.name() << "/" << eventStreamTag.type();
147  }
148  }
149 
150  msg(MSG::DEBUG) << endmsg;
151  }
152 
153  // Weights for E-cells, only towers 10..15
154  static const float energyWeight[6] = {1.f/3.f, 1.f/6.f, 1.f/11.f, 1.f/11.f, 1.f/28.f, 1.f/28.f};
155  static const int gapScintIndex[6] = {0, 1, 2, 2, 3, 3};
156 
157  std::vector<const CaloCell*> muonCells;
158 
159  std::vector<int> energyBalModPartModule;
160  std::vector<int> energyBalModPartPartition;
161 
162  std::vector<int> timeBalModPartModule;
163  std::vector<int> timeBalModPartPartition;
164 
165  double energySample[MAX_PART][MAX_SAMP] = {{0.}};
166  int nCells[MAX_PART] = {0};
167  int nBadCells[MAX_PART] = {0};
168 
169  // Arrays for BCID plots
170  int nCellsOverThreshold[MAX_PART] = {0};
171 
172  // Number of channels masked on the fly
173  int nBadChannelsOnFly[MAX_PART] = {0};
174 
175  // Number of channels masked on the fly due to bad DQ status
176  unsigned int nMaskedChannelsDueDQ[MAX_PART] = { 0 };
177 
178  // Number of cells masked on the fly due to bad DQ status
179  unsigned int nMaskedCellsDueDQ[MAX_PART] = { 0 };
180 
181  std::vector<int> negOccupModule[Tile::MAX_ROS - 1];
182  std::vector<int> negOccupChannel[Tile::MAX_ROS - 1];
183 
184  std::vector<float> timeBal[Tile::MAX_ROS - 1];
185  std::vector<int> timeBalModule[Tile::MAX_ROS - 1];
186 
187  std::vector<float> energyBal[Tile::MAX_ROS - 1];
188  std::vector<int> energyBalModule[Tile::MAX_ROS - 1];
189 
190  std::vector<int> detailOccupModule[Tile::MAX_ROS - 1];
191  std::vector<int> detailOccupChannel[Tile::MAX_ROS - 1];
192  std::vector<float> detailOccupEnergies[Tile::MAX_ROS - 1];
193 
194  std::vector<int> detailOccupGainModule[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
195  std::vector<int> detailOccupGainChannel[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
196  std::vector<float> detailOccupGainEnergies[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
197 
198  std::vector<int> overThrOccupModule[Tile::MAX_ROS - 1];
199  std::vector<int> overThrOccupChannel[Tile::MAX_ROS - 1];
200  std::vector<float> overThrOccupWeight[Tile::MAX_ROS - 1];
201 
202  std::vector<int> overThrOccupGainModule[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
203  std::vector<int> overThrOccupGainChannel[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
204  std::vector<float> overThrOccupGainWeight[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
205 
206  std::vector<int> overThr30GeVOccupModule[Tile::MAX_ROS - 1];
207  std::vector<int> overThr30GeVOccupChannel[Tile::MAX_ROS - 1];
208 
209  std::vector<int> overThr300GeVOccupModule[Tile::MAX_ROS - 1];
210  std::vector<int> overThr300GeVOccupChannel[Tile::MAX_ROS - 1];
211 
212  std::vector<int> eneDiff[Tile::MAX_ROS - 1];
213  std::vector<int> eneDiffChannel[Tile::MAX_ROS - 1];
214  std::vector<int> eneDiffModule[Tile::MAX_ROS - 1];
215 
216  std::vector<int> maskedOnFlyDrawers[Tile::MAX_ROS - 1];
217  std::vector<int> maskedOnFlyChannel[Tile::MAX_ROS - 1];
218 
219  std::vector<int> chanTime[Tile::MAX_ROS - 1];
220  std::vector<int> chanTimeDrawer[Tile::MAX_ROS - 1];
221  std::vector<int> chanTimeChannel[Tile::MAX_ROS - 1];
222  std::vector<int> chanTimeDigitizer[Tile::MAX_ROS - 1];
223 
224  int nChannelsInPartition = 2880; // LB
225  for (unsigned int partition = 0; partition < Tile::MAX_ROS - 1; ++partition) {
226  if (partition > 1) nChannelsInPartition = 2048; // EB
227  detailOccupModule[partition].reserve(nChannelsInPartition);
228  detailOccupChannel[partition].reserve(nChannelsInPartition);
229  detailOccupEnergies[partition].reserve(nChannelsInPartition);
230  }
231 
232  std::vector<float> occupEta[SAMP_ALL];
233  std::vector<float> occupPhi[SAMP_ALL];
234  std::vector<float> occupEnergy[SAMP_ALL];
235 
236  std::vector<float> overThrOccupEta[SAMP_ALL];
237  std::vector<float> overThrOccupPhi[SAMP_ALL];
238 
239  std::vector<float> sampChanTime[Tile::MAX_ROS - 1][SAMP_ALL];
240  std::vector<float> sampEnergyDiff[Tile::MAX_ROS - 1][SAMP_ALL];
241  std::vector<float> sampTimeDiff[Tile::MAX_ROS - 1][SAMP_ALL];
242 
243  PairBuilder moduleCorr[MAX_PART];
244 
245  // Indices of L1 trigger histograms to be filled in the current event
246  std::vector<int> l1TriggersIndices = getL1TriggerIndices(eventInfo->level1TriggerType());
247 
249  const TileBadChannels* badChannels(badChannelsHandle.cptr());
250 
251  fillMaskedInDB(badChannels);
252 
253  bool isCollision = true;
254 
256  ATH_CHECK( caloCellContainer.isValid() );
257 
258 
259  for (const CaloCell* cell : *caloCellContainer) {
260  Identifier id = cell->ID();
261  if (m_tileID->is_tile(id)) {
262 
263  const TileCell* tile_cell = dynamic_cast<const TileCell*>(cell);
264  if (tile_cell == 0) continue;
265 
266  int drawer = 0; // Drawer number, range 0-63, the same for both channels
267  int channel1 = -1; // Channel number, range 0-47 or -1 for unknown
268  int channel2 = -1; // Channel number, range 0-47 or -1 for unknown
269 
270  int ros1 = -1;
271  int ros2 = -1;
272 
273  int partition1 = -1;
274  int partition2 = -1;
275 
276  bool isMaskedChannel1 = false;
277  bool isMaskedAdc1 = false;
278  bool isMaskedAdc2 = false;
279 
280  int gain1 = tile_cell->gain1(); // Gain of first PMT
281  int gain2 = tile_cell->gain2(); // Gain of second PMT
282 
283  const CaloDetDescrElement* caloDDE = tile_cell->caloDDE();
284 
285  IdentifierHash hash1 = caloDDE->onl1();
286  if (hash1 != TileHWID::NOT_VALID_HASH) {
287  HWIdentifier channel1_id = m_tileHWID->channel_id(hash1);
288  channel1 = m_tileHWID->channel(channel1_id);
289  drawer = m_tileHWID->drawer(channel1_id);
290  ros1 = m_tileHWID->ros(channel1_id);
291  partition1 = ros1 - 1;
292  }
293 
294  IdentifierHash hash2 = caloDDE->onl2();
295  if (hash2 != TileHWID::NOT_VALID_HASH) {
296  HWIdentifier channel2_id = m_tileHWID->channel_id(hash2);
297  channel2 = m_tileHWID->channel(channel2_id);
298  drawer = m_tileHWID->drawer(channel2_id);
299  ros2 = m_tileHWID->ros(channel2_id);
300  partition2 = ros2 - 1;
301  }
302 
303  // Note that drawer from HWID and module from ID are different for E3 cells near MBTS
304  int module = m_tileID->module(id); // Range from 0-63
305 
306  // int samp = std::min(m_tileID->sample(id),(int)AllSamp);
307  int sample = m_tileID->sample(id);
308 
309  bool single_PMT_scin = (sample == TileID::SAMP_E);
310  bool single_PMT_C10 = (m_tileID->section(id) == TileID::GAPDET
311  && sample == TileID::SAMP_C
312  && (!m_cabling->C10_connected(module)));
313 
314  // Distinguish cells with one or two PMTs
315  bool single_PMT = single_PMT_C10 || single_PMT_scin;
316 
317  // Distinguish normal cells and fantoms (e.g. non-existing D4 in EBA15, EBC18
318  // or non-existing E3/E4 - they might appear in CaloCellContainer)
319  bool realCell = single_PMT_C10 || m_cabling->TileGap_connected(id);
320 
321  // Note that in single PMT cell both badch1() and badch2() are changed together
322  bool isBadChannel1 = tile_cell->badch1();
323  bool isBadChannel2 = tile_cell->badch2();
324 
325  int isCellGood = !tile_cell->badcell();
326 
327  bool isOkChannel1 = (channel1 > -1 && gain1 != CaloGain::INVALIDGAIN);
328  bool isOkChannel2 = (channel2 > -1 && gain2 != CaloGain::INVALIDGAIN);
329 
330  // Get the cell energy, time and position info
331  double energy = cell->energy();
332  double time = cell->time();
333  double eta = cell->eta();
334  double phi = cell->phi();
335  double energy1 = tile_cell->ene1();
336  double energy2 = tile_cell->ene2();
337  double energyDiff = (single_PMT) ? 0.0 : tile_cell->eneDiff();
338  double energyRatio = (energy != 0.0) ? energyDiff/energy : 0.0;
339  double time1 = tile_cell->time1();
340  double time2 = tile_cell->time2();
341  double timeDiff = (single_PMT) ? 0.0 : 2. * tile_cell->timeDiff(); // Attention! factor of 2 is needed here
342 
343  double weight = 1.;
344  if (single_PMT_scin) {
345  int tower = m_tileID->tower(id);
346  if (tower > 9 && tower < 16) {
347  weight = energyWeight[tower - 10];
348  }
351  int gapScintIdx = gapScintIndex[tower - 10];
352  unsigned int partition = (ros1 > 0) ? ros1 - 3 : ros2 - 3;
353  auto monEnergy = Monitored::Scalar<float>("energy", energy);
354  fill(m_tools[m_energyGapScintGroups[partition][drawer][gapScintIdx]], monEnergy);
355  }
356  }
357  }
358 
359  if (msgLvl(MSG::VERBOSE)) {
360 
361  msg(MSG::VERBOSE) << "Identifier: " << id << " " << m_tileID->to_string(id,-2) << endmsg;
362  msg(MSG::VERBOSE) << " region: " << m_tileID->region(id)
363  << " system: " << m_tileID->system(id)
364  << " section: "<< m_tileID->section(id)
365  << " side: " << m_tileID->side(id)
366  << " module: " << m_tileID->module(id)
367  << " tower: " << m_tileID->tower(id)
368  << " sample: " << m_tileID->sample(id) << endmsg;
369 
370  msg(MSG::VERBOSE) << "1st PMT ROS: " << ros1
371  << " drawer: " << drawer
372  << " ch1: " << channel1
373  << " gain1: " << gain1
374  << " qual1: " << (int)tile_cell->qual1()
375  << " qbit1: " << (int)tile_cell->qbit1()
376  << ((drawer != module) ? " drawer != module":" ") << endmsg;
377 
378  msg(MSG::VERBOSE) << "2nd PMT ROS: " << ros2
379  << " drawer: " << drawer
380  << " ch2: " << channel2
381  << " gain2: " << gain2
382  << " qual2: " << (int)tile_cell->qual2()
383  << " qbit2: " << (int)tile_cell->qbit2()
384  << ((ros1 != ros2) ? " ros1 != ros2" : " ") << endmsg;
385 
386  msg(MSG::VERBOSE) << "Bad status: " << !isCellGood
387  << " bad1: " << isBadChannel1
388  << " bad2: " << isBadChannel2
389  << ((single_PMT_scin && isBadChannel1 && !isMaskedChannel1)
390  ? " NEW BAD E-cell" : " ") << endmsg ;
391 
392  msg(MSG::VERBOSE) << " real_cell: " << ((realCell) ? "true" : "false")
393  << " E-cell: " << ((single_PMT_scin) ? "true" : "false")
394  << " specC10: " << ((single_PMT_C10) ? "true" : "false") << endmsg;
395 
396  msg(MSG::VERBOSE) << "Energy= " << energy << " = " << energy1 << " + " << energy2
397  << " ediff= " << energyDiff
398  << " eratio= " << energyRatio
399  << "\t Energy[GeV]= " << energy/GeV << endmsg ;
400 
401  msg(MSG::VERBOSE) << "Time= " << time << " = (" << time1 << " + " << time2 << ")/2 "
402  << "tdiff= " << timeDiff
403  << "\t time[ns]= " << time/ns << endmsg ;
404  }
405 
406 
407  if (realCell) {
408 
409  int dbGain1 = gain1;
410  int dbGain2 = gain2;
411  // When only one channel is bad, it might be that gain of masked channel is not correct
412  // If two qualities are not identical, then gains are not the same (new feature introduced in rel 17.2)
413  int quality1 = (int)tile_cell->qual1();
414  int quality2 = (int)tile_cell->qual2();
415  if (isBadChannel1 != isBadChannel2 && quality1 != quality2
416  && quality1 < 255 && quality2 < 255) {
417  if (isBadChannel1 && isOkChannel1) dbGain1 = 1 - gain1;
418  if (isBadChannel2 && isOkChannel2) dbGain2 = 1 - gain2;
419  }
420 
421  if (hash1 != TileHWID::NOT_VALID_HASH) {
422  HWIdentifier adc1_id = m_tileHWID->adc_id(hash1, dbGain1);
423  isMaskedAdc1 = badChannels->getAdcStatus(adc1_id).isBad();
424  }
425 
426  if (hash2 != TileHWID::NOT_VALID_HASH) {
427  HWIdentifier adc2_id = m_tileHWID->adc_id(hash2, dbGain2);
428  isMaskedAdc2 = badChannels->getAdcStatus(adc2_id).isBad();
429  }
430 
431  bool channel1MaskedDueDQ(false);
432  if (isBadChannel1 && isOkChannel1 && !(single_PMT_C10 && channel1 == 4)) {
433  if (!isMaskedAdc1) {
434  ++nBadChannelsOnFly[partition1];
435  maskedOnFlyDrawers[partition1].push_back(drawer);
436  maskedOnFlyChannel[partition1].push_back(channel1);
437 
438  if (!dqStatus->isAdcDQgood(ros1, drawer, channel1, gain1)) {
439  channel1MaskedDueDQ = true;
440  ++nMaskedChannelsDueDQ[partition1];
441  }
442  }
443  }
444 
445  bool channel2MaskedDueDQ(false);
446  if (isBadChannel2 && isOkChannel2 && !(single_PMT_C10 && channel2 == 4)) {
447  if (!isMaskedAdc2) {
448  ++nBadChannelsOnFly[partition2];
449  maskedOnFlyDrawers[partition2].push_back(drawer);
450  maskedOnFlyChannel[partition2].push_back(channel2);
451 
452  if (!dqStatus->isAdcDQgood(ros2, drawer, channel2, gain2)) {
453  channel2MaskedDueDQ = true;
454  ++nMaskedChannelsDueDQ[partition2];
455  }
456  }
457  }
458 
459  if (isCellGood) {
460 
462  && (time > m_timeRangeForMuon[0]) && (time < m_timeRangeForMuon[1])
463  && (time != 0)) { // Cell has reconstructed time
464  muonCells.push_back(cell);
465  }
466 
467  occupEta[sample].push_back(eta);
468  occupPhi[sample].push_back(phi);
469  occupEnergy[sample].push_back(energy);
470 
471  if (isOkChannel1) {
472  detailOccupModule[partition1].push_back(module);
473  detailOccupChannel[partition1].push_back(channel1);
474  detailOccupEnergies[partition1].push_back(energy1 * weight);
475 
476  detailOccupGainModule[partition1][gain1].push_back(module);
477  detailOccupGainChannel[partition1][gain1].push_back(channel1);
478  detailOccupGainEnergies[partition1][gain1].push_back(energy1 * weight);
479  }
480 
481  if (isOkChannel2) {
482  detailOccupModule[partition2].push_back(module);
483  detailOccupChannel[partition2].push_back(channel2);
484  detailOccupEnergies[partition2].push_back(energy2);
485 
486  detailOccupGainModule[partition2][gain2].push_back(module);
487  detailOccupGainChannel[partition2][gain2].push_back(channel2);
488  detailOccupGainEnergies[partition2][gain2].push_back(energy2);
489  }
490 
491  } else {
492  ++nBadCells[partition1];
493  if (channel1MaskedDueDQ || channel2MaskedDueDQ) {
494  ++nMaskedCellsDueDQ[partition1];
495  }
496  }
497 
498  // Check if energy is below negative threshold
499  if (isOkChannel1 && energy1 < m_negativeEnergyThreshold && (!isMaskedAdc1)) {
500  negOccupModule[partition1].push_back(module);
501  negOccupChannel[partition1].push_back(channel1);
502  }
503 
504  if (isOkChannel2 && energy2 < m_negativeEnergyThreshold && (!isMaskedAdc2)) {
505  negOccupModule[partition2].push_back(module);
506  negOccupChannel[partition2].push_back(channel2);
507  }
508 
509  if (energy > m_energyThreshold) {
510 
511  // Fill channel timing histograms.
512  if (isCollision || m_fillTimeHistograms) {
513  if (isOkChannel1 && energy1 > m_energyThresholdForTime && energy1 < m_energyLimitForTime) {
514  if ((gain1 == 0) && (energy1 < 1000.)) {
515  ATH_MSG_DEBUG("Low energy in LG for time monitoring: " << Tile::getDrawerString(ros1, drawer)
516  << ", channel = " << channel1 << ", energy = " << energy1 << ", time = " << time1);
517  } else {
518  chanTime[partition1].push_back(time1);
519  chanTimeDrawer[partition1].push_back(drawer);
520  chanTimeChannel[partition1].push_back(channel1);
521  chanTimeDigitizer[partition1].push_back(getDigitizer(channel1));
523  sampChanTime[partition1][sample].push_back(time1);
524  }
525  }
526  }
527 
528  if (isOkChannel2 && energy2 > m_energyThresholdForTime && energy2 < m_energyLimitForTime) {
529  if ((gain2 == 0) && (energy2 < 1000.)) {
530  ATH_MSG_DEBUG("Low energy in LG for time monitoring: " << Tile::getDrawerString(ros2, drawer)
531  << ", channel = " << channel2 << ", energy = " << energy2 << ", time = " << time2);
532  } else {
533  chanTime[partition2].push_back(time2);
534  chanTimeDrawer[partition2].push_back(drawer);
535  chanTimeChannel[partition2].push_back(channel2);
536  chanTimeDigitizer[partition2].push_back(getDigitizer(channel2));
538  sampChanTime[partition2][sample].push_back(time2);
539  }
540  }
541  }
542  }
543 
544  overThrOccupEta[sample].push_back(eta);
545  overThrOccupPhi[sample].push_back(phi);
546 
547  if (isOkChannel1 && energy1 > m_energyThreshold && (!isBadChannel1)) {
548  overThrOccupModule[partition1].push_back(module);
549  overThrOccupChannel[partition1].push_back(channel1);
550  overThrOccupWeight[partition1].push_back(weight);
551 
552  if (energy1 > m_energyThresholdForGain[gain1]) {
553  overThrOccupGainModule[partition1][gain1].push_back(module);
554  overThrOccupGainChannel[partition1][gain1].push_back(channel1);
555  overThrOccupGainWeight[partition1][gain1].push_back(weight);
556  }
557 
558  if (energy1 > 30000.) {
559  overThr30GeVOccupModule[partition1].push_back(module);
560  overThr30GeVOccupChannel[partition1].push_back(channel1);
561 
562  if (energy1 > 300000.) {
563  overThr300GeVOccupModule[partition1].push_back(module);
564  overThr300GeVOccupChannel[partition1].push_back(channel1);
565  }
566  }
567  }
568 
569  if (isOkChannel2 && energy2 > m_energyThreshold && (!isBadChannel2)) {
570  overThrOccupModule[partition2].push_back(module);
571  overThrOccupChannel[partition2].push_back(channel2);
572  overThrOccupWeight[partition2].push_back(1.0F);
573 
574  if (energy2 > m_energyThresholdForGain[gain2]) {
575  overThrOccupGainModule[partition2][gain2].push_back(module);
576  overThrOccupGainChannel[partition2][gain2].push_back(channel2);
577  overThrOccupGainWeight[partition2][gain2].push_back(1.0F);
578  }
579 
580  if (energy2 > 30000.) {
581  overThr30GeVOccupModule[partition2].push_back(module);
582  overThr30GeVOccupChannel[partition2].push_back(channel2);
583 
584  if (energy2 > 300000.) {
585  overThr300GeVOccupModule[partition2].push_back(module);
586  overThr300GeVOccupChannel[partition2].push_back(channel2);
587  }
588  }
589  }
590 
591  bool fillEneAndTimeDiff(m_fillTimeAndEnergyDiffHistograms);
592 
593  // avoid double peak structure in energy and time balance histograms
594  if ((gain1 == 0 && gain2 == 1 && (energy1 < 2000 || energy2 < 10 || std::abs(energy1 / energy2) > 5))
595  || (gain1 == 1 && gain2 == 0 && (energy2 < 2000 || energy1 < 10 || std::abs(energy2 / energy1) > 5))) {
596 
597  fillEneAndTimeDiff = false;
598  }
599 
600  // Fill these histograms only if the both PMTs are good
601  if (!(isBadChannel1 || isBadChannel2 || single_PMT)) {
602 
603  if (std::abs(energyRatio) > m_energyBalanceThreshold) {
604  energyBalModPartModule.push_back(module);
605  energyBalModPartPartition.push_back(partition1);
606  }
607 
608  if (std::abs(timeDiff) > m_timeBalanceThreshold
609  && (energy1 > m_energyThresholdForTime || energy2 > m_energyThresholdForTime)
610  && (isCollision || m_fillTimeHistograms)) {
611  timeBalModPartModule.push_back(module);
612  timeBalModPartPartition.push_back(partition1);
613  }
614 
615  energyBal[partition1].push_back(energyRatio);
616  energyBalModule[partition1].push_back(module);
617 
618  eneDiff[partition1].push_back(energyDiff);
619  eneDiffChannel[partition1].push_back(channel1);
620  eneDiffModule[partition1].push_back(module);
621 
622  eneDiff[partition2].push_back(-1.0 * energyDiff);
623  eneDiffChannel[partition2].push_back(channel2);
624  eneDiffModule[partition2].push_back(module);
625 
626  if (fillEneAndTimeDiff) {
627  sampEnergyDiff[partition1][sample].push_back(energyDiff);
628  }
629 
630  if ((energy1 > m_energyThresholdForTime || energy2 > m_energyThresholdForTime)
631  && (isCollision || m_fillTimeHistograms)) {
632 
633  timeBal[partition1].push_back(timeDiff);
634  timeBalModule[partition1].push_back(module);
635 
636  if (fillEneAndTimeDiff) {
637  sampTimeDiff[partition1][sample].push_back(timeDiff);
638  }
639  }
640 
641  moduleCorr[partition1].inputxy(module);
642  moduleCorr[PART_ALL].inputxy(module);
643  }
644 
645  // Store info for BCID plots.
646  // Count the number of cells over threshold per partition
647  ++nCellsOverThreshold[partition1];
648  }
649  }
650 
651  // Count total number of cells in a partition
652  ++nCells[partition1];
653 
654  // Accumulate total energy per sample per partition
655  energySample[partition1][sample] += energy;
656  }
657  }
658 
659  // Calculate totals for all samples and all partitions
660  for (int partition = 0; partition < PART_ALL; ++partition) {
661 
663  nBadCells[PART_ALL] += nBadCells[partition];
664 
665  nBadChannelsOnFly[PART_ALL] += nBadChannelsOnFly[partition];
666  nCellsOverThreshold[PART_ALL] += nCellsOverThreshold[partition];
667 
668  nMaskedChannelsDueDQ[PART_ALL] += nMaskedChannelsDueDQ[partition];
669  nMaskedCellsDueDQ[PART_ALL] += nMaskedCellsDueDQ[partition];
670 
671  for (int sample = 0; sample < SAMP_ALL; ++sample) {
672  energySample[partition][SAMP_ALL] += energySample[partition][sample];
673  energySample[PART_ALL][sample] += energySample[partition][sample];
674  }
675 
676  energySample[PART_ALL][SAMP_ALL] += energySample[partition][SAMP_ALL];
677  }
678 
679  if (msgLvl(MSG::DEBUG)) {
680 
681  msg(MSG::DEBUG) << "N Cells: "
682  << " " << nCells[PART_LBA]
683  << " " << nCells[PART_LBC]
684  << " " << nCells[PART_EBA]
685  << " " << nCells[PART_EBC]
686  << " " << nCells[PART_ALL] << endmsg;
687 
688  if (nCells[PART_ALL] > 0) {
689 
690  msg(MSG::DEBUG) << "AboveThr: "
691  << " " << nCellsOverThreshold[PART_LBA]
692  << " " << nCellsOverThreshold[PART_LBC]
693  << " " << nCellsOverThreshold[PART_EBA]
694  << " " << nCellsOverThreshold[PART_EBC]
695  << " " << nCellsOverThreshold[PART_ALL] << endmsg;
696 
697  msg(MSG::DEBUG) << "MaskOnFly:"
698  << " " << nBadChannelsOnFly[PART_LBA]
699  << " " << nBadChannelsOnFly[PART_LBC]
700  << " " << nBadChannelsOnFly[PART_EBA]
701  << " " << nBadChannelsOnFly[PART_EBC]
702  << " " << nBadChannelsOnFly[PART_ALL] << endmsg;
703 
704  msg(MSG::DEBUG) << "EneSampA:"
705  << " " << energySample[PART_LBA][TileID::SAMP_A]
706  << " " << energySample[PART_LBC][TileID::SAMP_A]
707  << " " << energySample[PART_EBA][TileID::SAMP_A]
708  << " " << energySample[PART_EBC][TileID::SAMP_A]
709  << " " << energySample[PART_ALL][TileID::SAMP_A] << endmsg;
710 
711  msg(MSG::DEBUG) << "EneSampB:"
712  << " " << energySample[PART_LBA][TileID::SAMP_B]
713  << " " << energySample[PART_LBC][TileID::SAMP_B]
714  << " " << energySample[PART_EBA][TileID::SAMP_B]
715  << " " << energySample[PART_EBC][TileID::SAMP_B]
716  << " " << energySample[PART_ALL][TileID::SAMP_B] << endmsg;
717 
718  msg(MSG::DEBUG) << "EneSampD:"
719  << " " << energySample[PART_LBA][TileID::SAMP_D]
720  << " " << energySample[PART_LBC][TileID::SAMP_D]
721  << " " << energySample[PART_EBA][TileID::SAMP_D]
722  << " " << energySample[PART_EBC][TileID::SAMP_D]
723  << " " << energySample[PART_ALL][TileID::SAMP_D] << endmsg;
724 
725  msg(MSG::DEBUG) << "EneSampE:"
726  << " " << energySample[PART_LBA][TileID::SAMP_E]
727  << " " << energySample[PART_LBC][TileID::SAMP_E]
728  << " " << energySample[PART_EBA][TileID::SAMP_E]
729  << " " << energySample[PART_EBC][TileID::SAMP_E]
730  << " " << energySample[PART_ALL][TileID::SAMP_E] << endmsg;
731 
732  msg(MSG::DEBUG) << "EneTotal:"
733  << " " << energySample[PART_LBA][SAMP_ALL]
734  << " " << energySample[PART_LBC][SAMP_ALL]
735  << " " << energySample[PART_EBA][SAMP_ALL]
736  << " " << energySample[PART_EBC][SAMP_ALL]
737  << " " << energySample[PART_ALL][SAMP_ALL] << endmsg;
738 
739  }
740  }
741 
742  std::vector<int> partitions(Tile::MAX_ROS);
743  std::iota(partitions.begin(), partitions.end(), 0);
744 
745  auto monPartition = Monitored::Collection("Partition", partitions);
746  auto monBadCells = Monitored::Collection("nBadCells", nBadCells);
747  fill("TileBadCell", monPartition, monBadCells);
748 
749  fillSynchronization(muonCells, l1TriggersIndices);
750 
751  if (!energyBalModPartPartition.empty()) {
752  for (int l1TriggerIdx : l1TriggersIndices) {
753  auto monModule = Monitored::Collection("module", energyBalModPartModule);
754  auto monPartion = Monitored::Collection("partition", energyBalModPartPartition);
755  fill(m_tools[m_energyBalModPartGroups[l1TriggerIdx]], monModule, monPartion);
756  }
757  }
758 
759  if (!timeBalModPartPartition.empty()) {
760  for (int l1TriggerIdx : l1TriggersIndices) {
761  auto monModule = Monitored::Collection("module", timeBalModPartModule);
762  auto monPartion = Monitored::Collection("partition", timeBalModPartPartition);
763  fill(m_tools[m_timeBalModPartGroups[l1TriggerIdx]], monModule, monPartion);
764  }
765  }
766 
767  unsigned int bcid = eventInfo->bcid();
768 
769  for (unsigned int partition = 0; partition < Tile::MAX_ROS - 1; ++partition) {
770 
771  if (!maskedOnFlyDrawers[partition].empty()) {
772  auto monModule = Monitored::Collection("module", maskedOnFlyDrawers[partition]);
773  auto monChannel = Monitored::Collection("channel", maskedOnFlyChannel[partition]);
774  fill(m_tools[m_maskedOnFlyGroups[partition]], monModule, monChannel);
775  }
776 
777  if (!negOccupModule[partition].empty()) {
778  auto monModule = Monitored::Collection("module", negOccupModule[partition]);
779  auto monChannel = Monitored::Collection("channel", negOccupChannel[partition]);
780  fill(m_tools[m_negOccupGroups[partition]], monModule, monChannel);
781  }
782 
783  if (!energyBalModule[partition].empty()) {
784  auto monModule = Monitored::Collection("module", energyBalModule[partition]);
785  auto monEnergyBal = Monitored::Collection("energyBalance", energyBal[partition]);
786  fill(m_tools[m_energyBalGroups[partition]], monModule, monEnergyBal);
787  }
788 
789  if (!timeBalModule[partition].empty()) {
790  auto monModule = Monitored::Collection("module", timeBalModule[partition]);
791  auto monTimeBal = Monitored::Collection("timeBalance", timeBal[partition]);
792  fill(m_tools[m_timeBalGroups[partition]], monModule, monTimeBal);
793  }
794 
795  if (!chanTimeDrawer[partition].empty()) {
796  auto monTime = Monitored::Collection("time", chanTime[partition]);
797  auto monModule = Monitored::Collection("module", chanTimeDrawer[partition]);
798  auto monChannel = Monitored::Collection("channel", chanTimeChannel[partition]);
799  auto monDigitizer = Monitored::Collection("digitizer", chanTimeDigitizer[partition]);
800  for (int l1TriggerIdx : l1TriggersIndices) {
801  fill(m_tools[m_chanTimeGroups[partition][l1TriggerIdx]], monModule, monChannel, monTime);
802  fill(m_tools[m_digiTimeGroups[partition][l1TriggerIdx]], monModule, monDigitizer, monTime);
803  }
804  }
805 
806  if (!detailOccupModule[partition].empty()) {
807  auto monModule = Monitored::Collection("module", detailOccupModule[partition]);
808  auto monChannel = Monitored::Collection("channel", detailOccupChannel[partition]);
809  auto monEnergies = Monitored::Collection("energy", detailOccupEnergies[partition]);
810  for (int l1TriggerIdx : l1TriggersIndices) {
811  fill(m_tools[m_detailOccupGroups[partition][l1TriggerIdx]], monModule, monChannel, monEnergies);
812  }
813  }
814 
815  if (!overThrOccupModule[partition].empty()) {
816  auto monModule = Monitored::Collection("module", overThrOccupModule[partition]);
817  auto monChannel = Monitored::Collection("channel", overThrOccupChannel[partition]);
818  auto monWeight = Monitored::Collection("weight", overThrOccupWeight[partition]);
819  for (int l1TriggerIdx : l1TriggersIndices) {
820  fill(m_tools[m_overThrOccupGroups[partition][l1TriggerIdx]], monModule, monChannel, monWeight);
821  }
822  }
823 
824  if (!overThr30GeVOccupModule[partition].empty()) {
825  auto monModule = Monitored::Collection("module", overThr30GeVOccupModule[partition]);
826  auto monChannel = Monitored::Collection("channel", overThr30GeVOccupChannel[partition]);
827  for (int l1TriggerIdx : l1TriggersIndices) {
828  fill(m_tools[m_overThr30GeVOccupGroups[partition][l1TriggerIdx]], monModule, monChannel);
829  }
830  }
831 
832  if (!overThr300GeVOccupModule[partition].empty()) {
833  auto monModule = Monitored::Collection("module", overThr300GeVOccupModule[partition]);
834  auto monChannel = Monitored::Collection("channel", overThr300GeVOccupChannel[partition]);
835  for (int l1TriggerIdx : l1TriggersIndices) {
836  fill(m_tools[m_overThr300GeVOccupGroups[partition][l1TriggerIdx]], monModule, monChannel);
837  }
838  }
839 
840  if (!eneDiff[partition].empty()) {
841  auto monEnergyDiff = Monitored::Collection("energyDiff", eneDiff[partition]);
842  auto monModule = Monitored::Collection("module", eneDiffModule[partition]);
843  auto monChannel = Monitored::Collection("channel", eneDiffChannel[partition]);
844  for (int l1TriggerIdx : l1TriggersIndices) {
845  fill(m_tools[m_eneDiffChanModGroups[partition][l1TriggerIdx]], monModule, monChannel, monEnergyDiff);
846  }
847  }
848 
849  for (unsigned int gain = 0; gain < Tile::MAX_GAIN; ++gain) {
850  if (!overThrOccupGainModule[partition][gain].empty()) {
851  auto monModule = Monitored::Collection("module", overThrOccupGainModule[partition][gain]);
852  auto monChannel = Monitored::Collection("channel", overThrOccupGainChannel[partition][gain]);
853  auto monWeight = Monitored::Collection("weight", overThrOccupGainWeight[partition][gain]);
854  for (int l1TriggerIdx : l1TriggersIndices) {
855  fill(m_tools[m_overThrOccupGainGroups[partition][gain][l1TriggerIdx]], monModule, monChannel, monWeight);
856  }
857  }
858 
859  if (!detailOccupGainModule[partition][gain].empty()) {
860  auto monModule = Monitored::Collection("module", detailOccupGainModule[partition][gain]);
861  auto monChannel = Monitored::Collection("channel", detailOccupGainChannel[partition][gain]);
862  auto monEnergies = Monitored::Collection("energy", detailOccupGainEnergies[partition][gain]);
863  for (int l1TriggerIdx : l1TriggersIndices) {
864  fill(m_tools[m_detailOccupGainGroups[partition][gain][l1TriggerIdx]], monModule, monChannel, monEnergies);
865  }
866  }
867  }
868 
870  for (unsigned int sample = 0; sample < SAMP_ALL; ++sample) {
871  if (!sampChanTime[partition][sample].empty()) {
872  auto monChanTime = Monitored::Collection("time", sampChanTime[partition][sample]);
873  for (int l1TriggerIdx : l1TriggersIndices) {
874  fill(m_tools[m_chanTimeSampGroups[partition][sample][l1TriggerIdx]], monChanTime);
875  fill(m_tools[m_chanTimeSampGroups[partition][SAMP_ALL][l1TriggerIdx]], monChanTime);
876  }
877  }
878  }
879  }
880 
882  for (unsigned int sample = 0; sample < SAMP_ALL; ++sample) {
883  if (!sampEnergyDiff[partition][sample].empty()) {
884  auto monEneDiff = Monitored::Collection("energyDiff", sampEnergyDiff[partition][sample]);
885  for (int l1TriggerIdx : l1TriggersIndices) {
886  fill(m_tools[m_eneDiffSampGroups[partition][sample][l1TriggerIdx]], monEneDiff);
887  fill(m_tools[m_eneDiffSampGroups[partition][SAMP_ALL][l1TriggerIdx]], monEneDiff);
888  }
889  }
890 
891  if (!sampTimeDiff[partition][sample].empty()) {
892  auto monTimeDiff = Monitored::Collection("timeDiff", sampTimeDiff[partition][sample]);
893  for (int l1TriggerIdx : l1TriggersIndices) {
894  fill(m_tools[m_timeDiffSampGroups[partition][sample][l1TriggerIdx]], monTimeDiff);
895  fill(m_tools[m_timeDiffSampGroups[partition][SAMP_ALL][l1TriggerIdx]], monTimeDiff);
896  }
897  }
898  }
899  }
900 
901  }
902 
903  for (int partition = 0; partition < MAX_PART; ++partition) {
904  auto monMaskedDueDQ = Monitored::Scalar<int>("nMaskedChannelsDueDQ", nMaskedChannelsDueDQ[partition]);
905  fill(m_tools[m_maskedDueDQGroups[partition]], lumiBlock, monMaskedDueDQ);
906 
907  auto monMaskedCellsDueDQ = Monitored::Scalar<int>("nMaskedCellsDueDQ", nMaskedCellsDueDQ[partition]);
908  fill(m_tools[m_maskedCellsDueDQGroups[partition]], lumiBlock, monMaskedCellsDueDQ);
909 
910  auto monMaskedOnFly = Monitored::Scalar<int>("nMaskedChannelsOnFly", nBadChannelsOnFly[partition]);
912 
913  auto monMaskedCellsOnFly = Monitored::Scalar<int>("nMaskedCells", nBadCells[partition]);
914  fill(m_tools[m_maskedCellsLBGroups[partition]], lumiBlock, monMaskedCellsOnFly);
915 
916 
917  if (moduleCorr[partition].numberOfPairs() > 0) {
918  const PairBuilder::PairVector pairs = moduleCorr[partition].pairs();
919  auto monModule1 = Monitored::Collection("firstModule", pairs, [] (const PairBuilder::XYPair& p) {return (double) p.first;});
920  auto monModule2 = Monitored::Collection("secondModule", pairs, [] (const PairBuilder::XYPair& p) {return (double) p.second;});
921  std::vector<float> weight(moduleCorr[partition].numberOfPairs(), moduleCorr[partition].weight());
922  auto monWeight = Monitored::Collection("weight", weight);
923  for (int l1TriggerIdx : l1TriggersIndices) {
924  fill(m_tools[m_moduleCorrGroups[partition][l1TriggerIdx]], monModule1, monModule2, monWeight);
925  }
926  }
927 
928  for (int l1TriggerIdx : l1TriggersIndices) {
929  auto monCellsNumber = Monitored::Scalar<float>("nCells", nCells[partition]);
930  fill(m_tools[m_nCellsGroups[partition][l1TriggerIdx]], lumiBlock, monCellsNumber);
931 
932  auto monBCID = Monitored::Scalar<unsigned int>("BCID", bcid);
933  auto monCellsNumberOvThr = Monitored::Scalar<float>("nCells", nCellsOverThreshold[partition]);
934  fill(m_tools[m_nCellsOverThrGroups[partition][l1TriggerIdx]], monBCID, monCellsNumberOvThr);
935  }
936 
937  if (partition > 1) { // Fill SampE energy for EB
938  for (int l1TriggerIdx : l1TriggersIndices) {
939  auto monEnergy = Monitored::Scalar<float>("energy", energySample[partition][TileID::SAMP_E]);
940  fill(m_tools[m_energySampEGroups[partition][l1TriggerIdx]], monEnergy);
941  }
942  }
943  }
944 
945  for (unsigned int sample = 0; sample < SAMP_ALL; ++sample) {
946  if (!occupEnergy[sample].empty()) {
947  auto monEta = Monitored::Collection("eta", occupEta[sample]);
948  auto monPhi = Monitored::Collection("phi", occupPhi[sample]);
949  auto monEnergy = Monitored::Collection("energy", occupEnergy[sample]);
950  for (int l1TriggerIdx : l1TriggersIndices) {
951  fill(m_tools[m_eneEtaPhiGroups[sample][l1TriggerIdx]], monEta, monPhi, monEnergy);
952  fill(m_tools[m_eneEtaPhiGroups[SAMP_ALL][l1TriggerIdx]], monEta, monPhi, monEnergy);
953  }
954  }
955 
956  if (!overThrOccupEta[sample].empty()) {
957  auto monEta = Monitored::Collection("eta", overThrOccupEta[sample]);
958  auto monPhi = Monitored::Collection("phi", overThrOccupPhi[sample]);
959  for (int l1TriggerIdx : l1TriggersIndices) {
960  fill(m_tools[m_overThrEtaPhiGroups[sample][l1TriggerIdx]], monEta, monPhi);
961  fill(m_tools[m_overThrEtaPhiGroups[SAMP_ALL][l1TriggerIdx]], monEta, monPhi);
962  }
963  }
964  }
965 
966 
967 
968  fill("TileCellMonExecuteTime", timer);
969 
970  return StatusCode::SUCCESS;
971 }

◆ fillMaskedInDB()

void TileCellMonitorAlgorithm::fillMaskedInDB ( const TileBadChannels badChannels) const
private

Definition at line 974 of file TileCellMonitorAlgorithm.cxx.

974  {
975 
976  using Tile = TileCalibUtils;
977 
978  std::vector<HWIdentifier>::const_iterator adc_it = m_tileHWID->adc_begin();
979  std::vector<HWIdentifier>::const_iterator adc_end = m_tileHWID->adc_end();
980 
981  std::vector<int> drawers[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
982  std::vector<int> channels[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
983 
984  for (; adc_it != adc_end; ++adc_it) {
985  HWIdentifier adc_id(*adc_it);
986 
987  if (badChannels->getAdcStatus(adc_id).isBad()) {
988 
989  unsigned int partition = m_tileHWID->ros(adc_id) - 1; // ROS - 1
990  unsigned int drawer = m_tileHWID->drawer(adc_id);
991  unsigned int channel = m_tileHWID->channel(adc_id);
992  unsigned int adc = m_tileHWID->adc(adc_id);
993 
994  drawers[partition][adc].push_back(drawer);
995  channels[partition][adc].push_back(channel);
996 
997  }
998  }
999 
1000  for (unsigned int partition = 0; partition < Tile::MAX_ROS - 1; ++partition) {
1001  for (unsigned int gain = 0; gain < Tile::MAX_GAIN; ++gain) {
1002  if (!drawers[partition][gain].empty()) {
1003 
1004  auto monModule = Monitored::Collection("module", drawers[partition][gain]);
1005  auto monChannel = Monitored::Collection("channel", channels[partition][gain]);
1006  fill(m_tools[m_maskedGroups[partition][gain]], monModule, monChannel);
1007 
1008  }
1009  }
1010  }
1011 }

◆ fillSynchronization()

void TileCellMonitorAlgorithm::fillSynchronization ( const std::vector< const CaloCell * > &  cells,
const std::vector< int > &  l1TriggersIndices 
) const
private

Definition at line 1014 of file TileCellMonitorAlgorithm.cxx.

1015  {
1016 
1017  std::vector<float> timeDifference;
1018 
1019  int size = cells.size();
1020  if (size > 1) {
1021  for (int i = 1; i < size; ++i) {
1022  float x1 = cells[i]->x();
1023  float y1 = cells[i]->y();
1024  float z1 = cells[i]->z();
1025  float time1 = cells[i]->time();
1026 
1027  for (int j = 0; j < i; ++j) {
1028  float x2 = cells[j]->x();
1029  float y2 = cells[j]->y();
1030  float z2 = cells[j]->z();
1031  float time2 = cells[j]->time();
1032 
1033  float timeMeasured = (y2 > y1) ? time1 - time2 : time2 - time1;
1034 
1035  float distance = sqrt( (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2));
1036  float timeExpected = distance / 300.;
1037 
1038  timeDifference.push_back(timeExpected - timeMeasured);
1039  }
1040  }
1041 
1042  auto monTimeDifference = Monitored::Collection("timeDifference", timeDifference);
1043  for (int l1TriggerIdx : l1TriggersIndices) {
1044  fill(m_tools[m_cellSynchGroups[l1TriggerIdx]], monTimeDifference);
1045  }
1046  }
1047 }

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

◆ getDigitizer()

int TileCellMonitorAlgorithm::getDigitizer ( int  channel) const
private

Definition at line 1049 of file TileCellMonitorAlgorithm.cxx.

1049  {
1050 
1051  // Conversion from channel number to digitizer number
1052  static const int channel2digitizer[48] = {8, 8, 8, 8, 8, 8,
1053  7, 7, 7, 7, 7, 7,
1054  6, 6, 6, 6, 6, 6,
1055  5, 5, 5, 5, 5, 5,
1056  4, 4, 4, 4, 4, 4,
1057  3, 3, 3, 3, 3, 3,
1058  2, 2, 2, 2, 2, 2,
1059  1, 1, 1, 1, 1, 1};
1060 
1061  return channel2digitizer[channel];
1062 }

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

◆ getL1TriggerIndices()

std::vector< int > TileMonitorAlgorithm::getL1TriggerIndices ( uint32_t  lvl1TriggerType) const
inherited

Return indices of histograms to be filled according fired L1 trigger type.

Parameters
lvl1TriggerTypeLevel1 Trigger Type
Returns
vector of indices of histograms to be filled

Definition at line 67 of file TileMonitorAlgorithm.cxx.

67  {
68 
69  std::vector<int> triggerIndices;
70  int triggerIdx{-1};
71 
72  if (lvl1TriggerType != 0) {
73  // First bit tells if physics (=1) or calibration (=0) event
74  if ((lvl1TriggerType >> BIT7_CALIB) & 1) { // format is 0x1AAAAAAA
75  // Always try store at least AnyPhysTrig (=8)
76  triggerIdx = m_l1TriggerIndices[ANY_PHYSICS];
77  if (triggerIdx >= 0) triggerIndices.push_back(triggerIdx);
78  // Adding the phys triggers one by one
79  for (int bitTrigger = 0; bitTrigger < BIT7_CALIB; ++bitTrigger) {
80  if ((lvl1TriggerType >> bitTrigger) & 1) {
81  triggerIdx = m_l1TriggerIndices[bitTrigger];
82  if (triggerIdx >= 0) triggerIndices.push_back(triggerIdx);
83  }
84  }
85  } else { // Calibration event foramt is 0x0AAAAAAA
86  triggerIdx = m_l1TriggerIndices[BIT7_CALIB];
87  if (triggerIdx >= 0) triggerIndices.push_back(triggerIdx);
88  }
89  } else {
90  // Always try store at least AnyPhysTrig (=8)
91  triggerIdx = m_l1TriggerIndices[ANY_PHYSICS];
92  if (triggerIdx >= 0) triggerIndices.push_back(triggerIdx);
93  }
94 
95  return triggerIndices;
96 }

◆ getL1TriggerTypeBit()

TileMonitorAlgorithm::L1TriggerTypeBit TileMonitorAlgorithm::getL1TriggerTypeBit ( int  lvl1TriggerIdx) const
inherited

Return Level1 Trigger type bit according trigger index.

Parameters
lvl1TriggerIdxLevel1 Trigger index
Returns
level1 trigger type bit according trigger index

Definition at line 104 of file TileMonitorAlgorithm.cxx.

104  {
105  return m_l1Triggers.at(lvl1TriggerIdx);
106 }

◆ getL1TriggerTypeBitFromName()

TileMonitorAlgorithm::L1TriggerTypeBit TileMonitorAlgorithm::getL1TriggerTypeBitFromName ( const std::string &  triggerBitName) const
privateinherited

Definition at line 35 of file TileMonitorAlgorithm.cxx.

35  {
36 
37  // Convert the triger name to lower case
38  std::string loCaseTriggerBitName = triggerBitName;
39  std::transform(triggerBitName.begin(), triggerBitName.end(), loCaseTriggerBitName.begin(), ::tolower);
40 
41  if( loCaseTriggerBitName == "bit0_rndm" ) {
42  return L1TriggerTypeBit::BIT0_RNDM;
43  } else if( loCaseTriggerBitName == "bit1_zerobias" ) {
44  return L1TriggerTypeBit::BIT1_ZEROBIAS;
45  } else if( loCaseTriggerBitName == "bit2_l1cal" ) {
46  return L1TriggerTypeBit::BIT2_L1CAL;
47  } else if( loCaseTriggerBitName == "bit3_muon" ) {
48  return L1TriggerTypeBit::BIT3_MUON;
49  } else if( loCaseTriggerBitName == "bit4_rpc" ) {
50  return L1TriggerTypeBit::BIT4_RPC;
51  } else if( loCaseTriggerBitName == "bit5_ftk" ) {
52  return L1TriggerTypeBit::BIT5_FTK;
53  } else if( loCaseTriggerBitName == "bit6_ctp" ) {
54  return L1TriggerTypeBit::BIT6_CTP;
55  } else if( loCaseTriggerBitName == "bit7_calib" ) {
56  return L1TriggerTypeBit::BIT7_CALIB;
57  } else if( loCaseTriggerBitName == "anyphystrig" ) {
58  return L1TriggerTypeBit::ANY_PHYSICS;
59  } else { // Otherwise, warn the user and return "AnyPhysTrig"
60  ATH_MSG_WARNING("::getL1TriggerTypeBitFromName(): Unknown L1 trigger type bit name: "
61  << triggerBitName << ", returning AnyPhysTrig.");
62  return L1TriggerTypeBit::ANY_PHYSICS;
63  }
64 }

◆ getNumberOfL1Triggers()

int TileMonitorAlgorithm::getNumberOfL1Triggers ( void  ) const
inlineinherited

Return number of L1 triggers for which histograms should be filled.

Definition at line 66 of file TileMonitorAlgorithm.h.

66 {return m_fillHistogramsForL1Triggers.size();};

◆ getPartition() [1/3]

TileMonitorAlgorithm::Partition TileMonitorAlgorithm::getPartition ( const CaloCell cell,
const TileID tileID 
) const
inherited

Return Partition for Tile cell or MAX_PART otherwise.

Parameters
cellCalo cell

Definition at line 109 of file TileMonitorAlgorithm.cxx.

109  {
110  return cell ? getPartition(cell->ID(), tileID) : MAX_PART;
111 }

◆ getPartition() [2/3]

TileMonitorAlgorithm::Partition TileMonitorAlgorithm::getPartition ( Identifier  id,
const TileID tileID 
) const
inherited

Return Partition for Tile cell identifier or MAX_PART otherwise.

Parameters
idCalo cell identifier

Definition at line 120 of file TileMonitorAlgorithm.cxx.

120  {
121 
122  Partition partition = MAX_PART; // by default for non Tile cell
123 
124  if (tileID->is_tile(id)) {
125  int section = tileID->section(id);
126  int side = tileID->side(id);
127 
128  if (section == 1) {
129  partition = (side == 1) ? PART_LBA : PART_LBC;
130  } else if (section == 2 || section == 3) {
131  partition = (side == 1) ? PART_EBA : PART_EBC;
132  }
133  }
134 
135  return partition;
136 }

◆ getPartition() [3/3]

TileMonitorAlgorithm::Partition TileMonitorAlgorithm::getPartition ( IdentifierHash  hash,
const TileID tileID 
) const
inherited

Return Partition for Tile cell identifier hash or MAX_PART otherwise.

Parameters
hashCalo cell identifier hash

Definition at line 114 of file TileMonitorAlgorithm.cxx.

114  {
115  return getPartition(tileID->cell_id(hash), tileID);
116 }

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

initialize

Returns
StatusCode

Reimplemented from TileMonitorAlgorithm.

Definition at line 20 of file TileCellMonitorAlgorithm.cxx.

20  {
21 
22  ATH_MSG_INFO("in initialize()");
23 
26 
27  ATH_CHECK( m_cablingSvc.retrieve() );
28  m_cabling = m_cablingSvc->cablingService();
29 
33 
34  using Tile = TileCalibUtils;
35  using namespace Monitored;
36 
37  int nL1Triggers = getNumberOfL1Triggers();
38 
39  m_cellSynchGroups = buildToolMap<int>(m_tools, "TileCellSynch", nL1Triggers);
40  m_energyBalModPartGroups = buildToolMap<int>(m_tools, "TileCellEneBalModPart", nL1Triggers);
41  m_timeBalModPartGroups = buildToolMap<int>(m_tools, "TileCellTimeBalModPart", nL1Triggers);
42  m_maskedOnFlyGroups = buildToolMap<int>(m_tools, "TileCellStatusOnFly", Tile::MAX_ROS - 1);
43  m_maskedDueDQGroups = buildToolMap<int>(m_tools, "TileMaskChannelDueDQvsLB", MAX_PART);
44  m_maskedCellsDueDQGroups = buildToolMap<int>(m_tools, "TileMaskedCellDueDQvsLB", MAX_PART);
45 
46  m_maskedOnFlyLBGroups = buildToolMap<int>(m_tools, "TileMaskChannelOnFlyLB", MAX_PART);
47  m_maskedCellsLBGroups = buildToolMap<int>(m_tools, "TileMaskCellLB", MAX_PART);
48 
49  m_maskedGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellStatusInDB",
50  Tile::MAX_ROS - 1, Tile::MAX_GAIN);
51 
52  m_energySampEGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellEventEnergy_SampE",
53  Tile::MAX_ROS, nL1Triggers);
54 
55  m_moduleCorrGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellModuleCorrelation",
56  Tile::MAX_ROS, nL1Triggers);
57 
58  m_chanTimeGroups = buildToolMap<std::vector<int>>(m_tools, "TileChanPartTime",
59  Tile::MAX_ROS - 1, nL1Triggers);
60 
61  m_digiTimeGroups = buildToolMap<std::vector<int>>(m_tools, "TileDigiPartTime",
62  Tile::MAX_ROS - 1, nL1Triggers);
63 
64  m_detailOccupGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellDetailOccMap",
65  Tile::MAX_ROS - 1, nL1Triggers);
66 
67  m_overThrOccupGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellDetailOccMapOvThr",
68  Tile::MAX_ROS - 1, nL1Triggers);
69 
70  m_overThr30GeVOccupGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellDetailOccMapOvThr30GeV",
71  Tile::MAX_ROS - 1, nL1Triggers);
72 
73  m_overThr300GeVOccupGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellDetailOccMapOvThr300GeV",
74  Tile::MAX_ROS - 1, nL1Triggers);
75 
76  m_eneDiffChanModGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellEneDiffChanMod",
77  Tile::MAX_ROS - 1, nL1Triggers);
78 
79  m_overThrOccupGainGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileCellDetailOccMapOvThrGain",
80  Tile::MAX_ROS - 1, Tile::MAX_GAIN, nL1Triggers);
81 
82  m_detailOccupGainGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileCellDetailOccMapGain",
83  Tile::MAX_ROS - 1, Tile::MAX_GAIN, nL1Triggers);
84 
86  m_energyGapScintGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileGapScintilatorEnergy", 2 /* EBA and EBC */,
87  Tile::MAX_DRAWER, 4 /* E1-E4 */);
88  }
89 
90  m_nCellsGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellsNumberLB",
91  Tile::MAX_ROS, nL1Triggers);
92 
93  m_nCellsOverThrGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellOccOvThrBCID",
94  Tile::MAX_ROS, nL1Triggers);
95 
96  m_eneEtaPhiGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellEneEtaPhi",
97  MAX_SAMP, nL1Triggers);
98 
99  m_overThrEtaPhiGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellEtaPhiOvThr",
100  MAX_SAMP, nL1Triggers);
101 
103  m_chanTimeSampGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileChannelTime",
104  Tile::MAX_ROS - 1, MAX_SAMP, nL1Triggers);
105  }
106 
107  m_eneDiffSampGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileCellEneDiff",
108  Tile::MAX_ROS - 1, MAX_SAMP, nL1Triggers);
109 
110  m_timeDiffSampGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileCellTimeDiff",
111  Tile::MAX_ROS - 1, MAX_SAMP, nL1Triggers);
112 
113  m_negOccupGroups = buildToolMap<int>(m_tools, "TileCellDetailNegOccMap", Tile::MAX_ROS - 1);
114  m_timeBalGroups = buildToolMap<int>(m_tools, "TileCellTimeBalance", Tile::MAX_ROS - 1);
115  m_energyBalGroups = buildToolMap<int>(m_tools, "TileCellEnergyBalance", Tile::MAX_ROS - 1);
116 
117 
119 }

◆ 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

◆ isPhysicsEvent()

bool TileMonitorAlgorithm::isPhysicsEvent ( uint32_t  lvl1TriggerType) const
inherited

Return true if it is physics event or false for calibration event.

Parameters
lvl1TriggerTypeLevel1 Trigger Type
Returns
true if it is physics event according L1 trigger type

Definition at line 98 of file TileMonitorAlgorithm.cxx.

98  {
99  // First bit tells if physics (=1) or calibration (=0) event
100  return (lvl1TriggerType == 0) || (((lvl1TriggerType >> BIT7_CALIB) & 1) == 1);
101 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ parseList()

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

Parse a string into a vector.

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

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

Definition at line 336 of file AthMonitorAlgorithm.cxx.

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

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

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

Definition at line 139 of file AthReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

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

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

96  {
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.

◆ TileMonitorAlgorithm()

TileMonitorAlgorithm::TileMonitorAlgorithm
inline

Definition at line 21 of file TileMonitorAlgorithm.h.

22  :AthMonitorAlgorithm(name, svcLocator), m_l1TriggerIndices(9, -1) {}

◆ 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

TileCellMonitorAlgorithm.cfg

Definition at line 363 of file TileCellMonitorAlgorithm.py.

◆ enableLumiAccess

TileCellMonitorAlgorithm.enableLumiAccess

Definition at line 355 of file TileCellMonitorAlgorithm.py.

◆ Files

TileCellMonitorAlgorithm.Files

Definition at line 352 of file TileCellMonitorAlgorithm.py.

◆ fillHistogramsForL1Triggers

TileCellMonitorAlgorithm.fillHistogramsForL1Triggers

Definition at line 370 of file TileCellMonitorAlgorithm.py.

◆ fillTimeAndEnergyDiffHistograms

TileCellMonitorAlgorithm.fillTimeAndEnergyDiffHistograms

Definition at line 371 of file TileCellMonitorAlgorithm.py.

◆ flags

TileCellMonitorAlgorithm.flags

Definition at line 351 of file TileCellMonitorAlgorithm.py.

◆ HISTFileName

TileCellMonitorAlgorithm.HISTFileName

Definition at line 353 of file TileCellMonitorAlgorithm.py.

◆ l1Triggers

TileCellMonitorAlgorithm.l1Triggers

Definition at line 366 of file TileCellMonitorAlgorithm.py.

◆ m_badChannelsKey

SG::ReadCondHandleKey<TileBadChannels> TileCellMonitorAlgorithm::m_badChannelsKey
private
Initial value:
{this,
"TileBadChannels", "TileBadChannels", "Input Tile bad channel status"}

Name of TileBadChannels in condition store.

Definition at line 98 of file TileCellMonitorAlgorithm.h.

◆ m_cabling

const TileCablingService* TileCellMonitorAlgorithm::m_cabling {nullptr}
private

Definition at line 106 of file TileCellMonitorAlgorithm.h.

◆ m_cablingSvc

ServiceHandle<TileCablingSvc> TileCellMonitorAlgorithm::m_cablingSvc
private
Initial value:
{ this,
"TileCablingSvc", "TileCablingSvc", "Tile cabling service"}

Name of Tile cabling service.

Definition at line 89 of file TileCellMonitorAlgorithm.h.

◆ m_caloCellContainerKey

SG::ReadHandleKey<CaloCellContainer> TileCellMonitorAlgorithm::m_caloCellContainerKey
private
Initial value:
{this,
"CaloCellContainer", "AllCalo", "Calo cell container name"}

Definition at line 101 of file TileCellMonitorAlgorithm.h.

◆ m_cellSynchGroups

std::vector<int> TileCellMonitorAlgorithm::m_cellSynchGroups
private

Definition at line 110 of file TileCellMonitorAlgorithm.h.

◆ m_chanTimeGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_chanTimeGroups
private

Definition at line 120 of file TileCellMonitorAlgorithm.h.

◆ m_chanTimeSampGroups

std::vector<std::vector<std::vector<int> > > TileCellMonitorAlgorithm::m_chanTimeSampGroups
private

Definition at line 133 of file TileCellMonitorAlgorithm.h.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 351 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

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

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

Definition at line 353 of file AthMonitorAlgorithm.h.

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 360 of file AthMonitorAlgorithm.h.

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_detailOccupGainGroups

std::vector<std::vector<std::vector<int> > > TileCellMonitorAlgorithm::m_detailOccupGainGroups
private

Definition at line 130 of file TileCellMonitorAlgorithm.h.

◆ m_detailOccupGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_detailOccupGroups
private

Definition at line 124 of file TileCellMonitorAlgorithm.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_digiTimeGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_digiTimeGroups
private

Definition at line 121 of file TileCellMonitorAlgorithm.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_DQstatusKey

SG::ReadHandleKey<TileDQstatus> TileCellMonitorAlgorithm::m_DQstatusKey
private
Initial value:
{this,
"TileDQstatus", "TileDQstatus", "Tile DQ status name"}

Definition at line 92 of file TileCellMonitorAlgorithm.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_eneDiffChanModGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_eneDiffChanModGroups
private

Definition at line 128 of file TileCellMonitorAlgorithm.h.

◆ m_eneDiffSampGroups

std::vector<std::vector<std::vector<int> > > TileCellMonitorAlgorithm::m_eneDiffSampGroups
private

Definition at line 134 of file TileCellMonitorAlgorithm.h.

◆ m_eneEtaPhiGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_eneEtaPhiGroups
private

Definition at line 137 of file TileCellMonitorAlgorithm.h.

◆ m_energyBalanceThreshold

Gaudi::Property<float> TileCellMonitorAlgorithm::m_energyBalanceThreshold
private
Initial value:
{this,
"EnergyBalanceThreshold", 3.0F, "Energy ratio threshold"}

Definition at line 56 of file TileCellMonitorAlgorithm.h.

◆ m_energyBalGroups

std::vector<int> TileCellMonitorAlgorithm::m_energyBalGroups
private

Definition at line 142 of file TileCellMonitorAlgorithm.h.

◆ m_energyBalModPartGroups

std::vector<int> TileCellMonitorAlgorithm::m_energyBalModPartGroups
private

Definition at line 108 of file TileCellMonitorAlgorithm.h.

◆ m_energyGapScintGroups

std::vector<std::vector<std::vector<int> > > TileCellMonitorAlgorithm::m_energyGapScintGroups
private

Definition at line 131 of file TileCellMonitorAlgorithm.h.

◆ m_energyLimitForTime

Gaudi::Property<float> TileCellMonitorAlgorithm::m_energyLimitForTime
private
Initial value:
{this,
"EnergyLimitForTime", 1000000.0F, "Energy limit for timing in MeV"}

Definition at line 53 of file TileCellMonitorAlgorithm.h.

◆ m_energyRangeForMuon

Gaudi::Property<std::vector<float> > TileCellMonitorAlgorithm::m_energyRangeForMuon
private
Initial value:
{this,
"EnergyRangeForMuon", {300.0F, 2000.F}, "Cell energy range for muon in MeV"}

Definition at line 77 of file TileCellMonitorAlgorithm.h.

◆ m_energySampEGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_energySampEGroups
private

Definition at line 118 of file TileCellMonitorAlgorithm.h.

◆ m_energyThreshold

Gaudi::Property<float> TileCellMonitorAlgorithm::m_energyThreshold
private
Initial value:
{this,
"EnergyThreshold", 300.0F, "Energy threshold in MeV"}

Definition at line 44 of file TileCellMonitorAlgorithm.h.

◆ m_energyThresholdForGain

Gaudi::Property<std::vector<float> > TileCellMonitorAlgorithm::m_energyThresholdForGain
private
Initial value:
{this,
"EnergyThresholdForGain", {10000.0F, 300.F}, "Channel energy threshold per gain for over thershold occupnacy maps"}

Definition at line 83 of file TileCellMonitorAlgorithm.h.

◆ m_energyThresholdForGapScint

Gaudi::Property<float> TileCellMonitorAlgorithm::m_energyThresholdForGapScint
private
Initial value:
{this,
"EnergyThresholdForGapScintilator", 0.0F, "Energy threshold for Gap Scintilator (E1-E4) in MeV"}

Definition at line 62 of file TileCellMonitorAlgorithm.h.

◆ m_energyThresholdForTime

Gaudi::Property<float> TileCellMonitorAlgorithm::m_energyThresholdForTime
private
Initial value:
{this,
"EnergyThresholdForTime", 500.0F, "Energy threshold for timing in MeV"}

Definition at line 50 of file TileCellMonitorAlgorithm.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_fillChannelTimeHistograms

Gaudi::Property<bool> TileCellMonitorAlgorithm::m_fillChannelTimeHistograms
private
Initial value:
{this,
"fillChannelTimeHistograms", true, "Fill histograms with channel time per sample"}

Definition at line 68 of file TileCellMonitorAlgorithm.h.

◆ m_fillGapScintHistograms

Gaudi::Property<bool> TileCellMonitorAlgorithm::m_fillGapScintHistograms
private
Initial value:
{this,
"fillGapScintilatorHistograms", false, "Fill histograms for indvidual Gap scintilators (E1-E4 cells)"}

Definition at line 71 of file TileCellMonitorAlgorithm.h.

◆ m_fillHistogramsForL1Triggers

Gaudi::Property<std::vector<std::string> > TileMonitorAlgorithm::m_fillHistogramsForL1Triggers
privateinherited
Initial value:
{this,
"fillHistogramsForL1Triggers", {}, "Fill histograms per given L1 trigger types"}

Definition at line 98 of file TileMonitorAlgorithm.h.

◆ m_fillTimeAndEnergyDiffHistograms

Gaudi::Property<bool> TileCellMonitorAlgorithm::m_fillTimeAndEnergyDiffHistograms
private
Initial value:
{this, "fillTimeAndEnergyDiffHistograms", true,
"Fill histograms with time and energy difference between two PMTs of the same Cell"}

Definition at line 74 of file TileCellMonitorAlgorithm.h.

◆ m_fillTimeHistograms

Gaudi::Property<bool> TileCellMonitorAlgorithm::m_fillTimeHistograms
private
Initial value:
{this,
"fillTimeHistograms", false, "Force filling timing histograms"}

Definition at line 65 of file TileCellMonitorAlgorithm.h.

◆ m_l1TriggerBitNames

std::vector<std::string> TileMonitorAlgorithm::m_l1TriggerBitNames
privateinherited
Initial value:
{"bit0_RNDM", "bit1_ZeroBias", "bit2_L1CAL", "bit3_MUON",
"bit4_RPC", "bit5_FTK", "bti6_CTP", "bit7_Calib", "AnyPhysTrig"}

Definition at line 103 of file TileMonitorAlgorithm.h.

◆ m_l1TriggerIndices

std::vector<int> TileMonitorAlgorithm::m_l1TriggerIndices
privateinherited

Definition at line 102 of file TileMonitorAlgorithm.h.

◆ m_l1Triggers

std::vector<L1TriggerTypeBit> TileMonitorAlgorithm::m_l1Triggers
privateinherited

Definition at line 101 of file TileMonitorAlgorithm.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_maskedCellsDueDQGroups

std::vector<int> TileCellMonitorAlgorithm::m_maskedCellsDueDQGroups
private

Definition at line 113 of file TileCellMonitorAlgorithm.h.

◆ m_maskedCellsLBGroups

std::vector<int> TileCellMonitorAlgorithm::m_maskedCellsLBGroups
private

Definition at line 115 of file TileCellMonitorAlgorithm.h.

◆ m_maskedDueDQGroups

std::vector<int> TileCellMonitorAlgorithm::m_maskedDueDQGroups
private

Definition at line 112 of file TileCellMonitorAlgorithm.h.

◆ m_maskedGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_maskedGroups
private

Definition at line 116 of file TileCellMonitorAlgorithm.h.

◆ m_maskedOnFlyGroups

std::vector<int> TileCellMonitorAlgorithm::m_maskedOnFlyGroups
private

Definition at line 111 of file TileCellMonitorAlgorithm.h.

◆ m_maskedOnFlyLBGroups

std::vector<int> TileCellMonitorAlgorithm::m_maskedOnFlyLBGroups
private

Definition at line 114 of file TileCellMonitorAlgorithm.h.

◆ m_moduleCorrGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_moduleCorrGroups
private

Definition at line 119 of file TileCellMonitorAlgorithm.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_nCellsGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_nCellsGroups
private

Definition at line 122 of file TileCellMonitorAlgorithm.h.

◆ m_nCellsOverThrGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_nCellsOverThrGroups
private

Definition at line 123 of file TileCellMonitorAlgorithm.h.

◆ m_negativeEnergyThreshold

Gaudi::Property<float> TileCellMonitorAlgorithm::m_negativeEnergyThreshold
private
Initial value:
{this,
"NegativeEnergyThreshold", -2000.0F, "Negative energy threshold in MeV"}

Definition at line 47 of file TileCellMonitorAlgorithm.h.

◆ m_negOccupGroups

std::vector<int> TileCellMonitorAlgorithm::m_negOccupGroups
private

Definition at line 140 of file TileCellMonitorAlgorithm.h.

◆ m_overThr300GeVOccupGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_overThr300GeVOccupGroups
private

Definition at line 127 of file TileCellMonitorAlgorithm.h.

◆ m_overThr30GeVOccupGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_overThr30GeVOccupGroups
private

Definition at line 126 of file TileCellMonitorAlgorithm.h.

◆ m_overThrEtaPhiGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_overThrEtaPhiGroups
private

Definition at line 138 of file TileCellMonitorAlgorithm.h.

◆ m_overThrOccupGainGroups

std::vector<std::vector<std::vector<int> > > TileCellMonitorAlgorithm::m_overThrOccupGainGroups
private

Definition at line 129 of file TileCellMonitorAlgorithm.h.

◆ m_overThrOccupGroups

std::vector<std::vector<int> > TileCellMonitorAlgorithm::m_overThrOccupGroups
private

Definition at line 125 of file TileCellMonitorAlgorithm.h.

◆ m_tileHWID

const TileHWID* TileCellMonitorAlgorithm::m_tileHWID {nullptr}
private

Definition at line 105 of file TileCellMonitorAlgorithm.h.

◆ m_tileID

const TileID* TileCellMonitorAlgorithm::m_tileID {nullptr}
private

Definition at line 104 of file TileCellMonitorAlgorithm.h.

◆ m_timeBalanceThreshold

Gaudi::Property<float> TileCellMonitorAlgorithm::m_timeBalanceThreshold
private
Initial value:
{this,
"TimeBalanceThreshold", 25.0F, "Time threshold in ns"}

Definition at line 59 of file TileCellMonitorAlgorithm.h.

◆ m_timeBalGroups

std::vector<int> TileCellMonitorAlgorithm::m_timeBalGroups
private

Definition at line 141 of file TileCellMonitorAlgorithm.h.

◆ m_timeBalModPartGroups

std::vector<int> TileCellMonitorAlgorithm::m_timeBalModPartGroups
private

Definition at line 109 of file TileCellMonitorAlgorithm.h.

◆ m_timeDiffSampGroups

std::vector<std::vector<std::vector<int> > > TileCellMonitorAlgorithm::m_timeDiffSampGroups
private

Definition at line 135 of file TileCellMonitorAlgorithm.h.

◆ m_timeRangeForMuon

Gaudi::Property<std::vector<float> > TileCellMonitorAlgorithm::m_timeRangeForMuon
private
Initial value:
{this,
"TimeRangeForMuon", {-60.0F, 60.F}, "Cell time range for muon in ns"}

Definition at line 80 of file TileCellMonitorAlgorithm.h.

◆ m_toolLookupMap

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

Definition at line 367 of file AthMonitorAlgorithm.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 338 of file AthMonitorAlgorithm.h.

◆ m_trigDecTool

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

Tool to tell whether a specific trigger is passed.

Definition at line 340 of file AthMonitorAlgorithm.h.

◆ m_triggerChainString

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

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

Definition at line 355 of file AthMonitorAlgorithm.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 347 of file AthMonitorAlgorithm.h.

◆ m_useLumi

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

Allows use of various luminosity functions.

Definition at line 359 of file AthMonitorAlgorithm.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

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

Vector of trigger chain names parsed from trigger chain string.

Definition at line 356 of file AthMonitorAlgorithm.h.

◆ MaxEvents

TileCellMonitorAlgorithm.MaxEvents

Definition at line 356 of file TileCellMonitorAlgorithm.py.

◆ sc

TileCellMonitorAlgorithm.sc

Definition at line 378 of file TileCellMonitorAlgorithm.py.

◆ summariseProps

TileCellMonitorAlgorithm.summariseProps

Definition at line 373 of file TileCellMonitorAlgorithm.py.

◆ True

TileCellMonitorAlgorithm.True

Definition at line 373 of file TileCellMonitorAlgorithm.py.

◆ useTrigger

TileCellMonitorAlgorithm.useTrigger

Definition at line 354 of file TileCellMonitorAlgorithm.py.

◆ withDetails

TileCellMonitorAlgorithm.withDetails

Definition at line 373 of file TileCellMonitorAlgorithm.py.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileCellMonitorAlgorithm::m_overThrOccupGainGroups
std::vector< std::vector< std::vector< int > > > m_overThrOccupGainGroups
Definition: TileCellMonitorAlgorithm.h:129
TileCell::badcell
virtual bool badcell(void) const override final
check if whole cell is bad (i.e.
Definition: TileCell.h:220
TileCell
Definition: TileCell.h:57
TileCellMonitorAlgorithm::m_cellSynchGroups
std::vector< int > m_cellSynchGroups
Definition: TileCellMonitorAlgorithm.h:110
TileCellMonitorAlgorithm::m_energyRangeForMuon
Gaudi::Property< std::vector< float > > m_energyRangeForMuon
Definition: TileCellMonitorAlgorithm.h:77
PairBuilder::PairVector
std::vector< XYPair > PairVector
Definition: PairBuilder.h:36
CaloDetDescrElement::onl2
IdentifierHash onl2() const
cell online identifier 2
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:408
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:271
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
TileMonitorAlgorithm::getL1TriggerIndices
std::vector< int > getL1TriggerIndices(uint32_t lvl1TriggerType) const
Return indices of histograms to be filled according fired L1 trigger type.
Definition: TileMonitorAlgorithm.cxx:67
TileCell::time1
float time1(void) const
get time of first PMT
Definition: TileCell.h:198
TileCablingService::TileGap_connected
bool TileGap_connected(const Identifier &id) const
Definition: TileCablingService.cxx:1756
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
TileMonitorAlgorithm::BIT2_L1CAL
@ BIT2_L1CAL
Definition: TileMonitorAlgorithm.h:33
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
TileMonitorAlgorithm::BIT4_RPC
@ BIT4_RPC
Definition: TileMonitorAlgorithm.h:34
checkFileSG.line
line
Definition: checkFileSG.py:75
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
Tile_Base_ID::SAMP_B
@ SAMP_B
Definition: Tile_Base_ID.h:54
get_generator_info.result
result
Definition: get_generator_info.py:21
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TileCellMonitorAlgorithm::m_timeBalanceThreshold
Gaudi::Property< float > m_timeBalanceThreshold
Definition: TileCellMonitorAlgorithm.h:59
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
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
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
TileMonitorAlgorithm::PART_EBA
@ PART_EBA
Definition: TileMonitorAlgorithm.h:46
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TileCellMonitorAlgorithm::m_detailOccupGroups
std::vector< std::vector< int > > m_detailOccupGroups
Definition: TileCellMonitorAlgorithm.h:124
TileMonitorAlgorithm::PART_EBC
@ PART_EBC
Definition: TileMonitorAlgorithm.h:47
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
TileCellMonitorAlgorithm::m_badChannelsKey
SG::ReadCondHandleKey< TileBadChannels > m_badChannelsKey
Name of TileBadChannels in condition store.
Definition: TileCellMonitorAlgorithm.h:98
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
TileCell::time2
float time2(void) const
get time of second PMT
Definition: TileCell.h:200
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
TileMonitorAlgorithm::ANY_PHYSICS
@ ANY_PHYSICS
Definition: TileMonitorAlgorithm.h:34
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileCellMonitorAlgorithm::getDigitizer
int getDigitizer(int channel) const
Definition: TileCellMonitorAlgorithm.cxx:1049
TileMonitorAlgorithm::BIT3_MUON
@ BIT3_MUON
Definition: TileMonitorAlgorithm.h:33
TileCellMonitorAlgorithm::m_energyThresholdForGapScint
Gaudi::Property< float > m_energyThresholdForGapScint
Definition: TileCellMonitorAlgorithm.h:62
Tile_Base_ID::SAMP_A
@ SAMP_A
Definition: Tile_Base_ID.h:53
TileCell::ene1
float ene1(void) const
get energy of first PMT
Definition: TileCell.h:193
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
TileCell::badch1
bool badch1(void) const
check if first PMT is in bad channel list and masked
Definition: TileCell.h:215
PairBuilder::pairs
const PairVector & pairs() const
Return the pairs as a vector of pairs of integers.
Definition: PairBuilder.cxx:42
TileCellMonitorAlgorithm::m_fillTimeHistograms
Gaudi::Property< bool > m_fillTimeHistograms
Definition: TileCellMonitorAlgorithm.h:65
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
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
CaloTime_fillDB.gain2
gain2
Definition: CaloTime_fillDB.py:357
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
TileCellMonitorAlgorithm::m_chanTimeGroups
std::vector< std::vector< int > > m_chanTimeGroups
Definition: TileCellMonitorAlgorithm.h:120
Tile_Base_ID::side
int side(const Identifier &id) const
Definition: Tile_Base_ID.cxx:153
TileMonitorAlgorithm::m_l1Triggers
std::vector< L1TriggerTypeBit > m_l1Triggers
Definition: TileMonitorAlgorithm.h:101
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
PairBuilder
Class to build pairs of XY values.
Definition: PairBuilder.h:30
TileCellMonitorAlgorithm::m_digiTimeGroups
std::vector< std::vector< int > > m_digiTimeGroups
Definition: TileCellMonitorAlgorithm.h:121
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
TileHWID::adc_begin
std::vector< HWIdentifier >::const_iterator adc_begin(void) const
begin iterator for ADC Identifiers
Definition: TileHWID.h:308
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileCellMonitorAlgorithm::m_energyLimitForTime
Gaudi::Property< float > m_energyLimitForTime
Definition: TileCellMonitorAlgorithm.h:53
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
PairBuilder::XYPair
std::pair< int, int > XYPair
Definition: PairBuilder.h:35
Tile_Base_ID::GAPDET
@ GAPDET
Definition: Tile_Base_ID.h:48
TileCellMonitorAlgorithm::m_nCellsGroups
std::vector< std::vector< int > > m_nCellsGroups
Definition: TileCellMonitorAlgorithm.h:122
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
cosmics
Definition: cosmics.py:1
TileMonitorAlgorithm::m_fillHistogramsForL1Triggers
Gaudi::Property< std::vector< std::string > > m_fillHistogramsForL1Triggers
Definition: TileMonitorAlgorithm.h:98
TileCellMonitorAlgorithm::m_maskedCellsLBGroups
std::vector< int > m_maskedCellsLBGroups
Definition: TileCellMonitorAlgorithm.h:115
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Tile_Base_ID::SAMP_E
@ SAMP_E
Definition: Tile_Base_ID.h:55
TileMonitorAlgorithm::MAX_SAMP
@ MAX_SAMP
Definition: TileMonitorAlgorithm.h:40
Tile_Base_ID::system
int system(const Identifier &id) const
Definition: Tile_Base_ID.cxx:141
TileCellMonitorAlgorithm::m_negativeEnergyThreshold
Gaudi::Property< float > m_negativeEnergyThreshold
Definition: TileCellMonitorAlgorithm.h:47
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:194
TileCellMonitorAlgorithm::m_maskedOnFlyGroups
std::vector< int > m_maskedOnFlyGroups
Definition: TileCellMonitorAlgorithm.h:111
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
TileMonitorAlgorithm::BIT5_FTK
@ BIT5_FTK
Definition: TileMonitorAlgorithm.h:34
makeTRTBarrelCans.y1
tuple y1
Definition: makeTRTBarrelCans.py:15
AthMonitorAlgorithm::Environment_t::user
@ user
TileCellMonitorAlgorithm::m_maskedGroups
std::vector< std::vector< int > > m_maskedGroups
Definition: TileCellMonitorAlgorithm.h:116
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
Tile_Base_ID::region
int region(int section, int side) const
Definition: Tile_Base_ID.cxx:119
python.utils.AtlRunQueryTimer.timer
def timer(name, disabled=False)
Definition: AtlRunQueryTimer.py:86
TileCellMonitorAlgorithm::fillSynchronization
void fillSynchronization(const std::vector< const CaloCell * > &cells, const std::vector< int > &l1TriggersIndices) const
Definition: TileCellMonitorAlgorithm.cxx:1014
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
dq_defect_copy_defect_database.channels
def channels
Definition: dq_defect_copy_defect_database.py:56
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
Tile_Base_ID::SAMP_C
@ SAMP_C
Definition: Tile_Base_ID.h:54
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
python.CreateTierZeroArgdict.pairs
pairs
Definition: CreateTierZeroArgdict.py:201
TileMonitorAlgorithm::BIT6_CTP
@ BIT6_CTP
Definition: TileMonitorAlgorithm.h:34
TileCellMonitorAlgorithm::m_overThrEtaPhiGroups
std::vector< std::vector< int > > m_overThrEtaPhiGroups
Definition: TileCellMonitorAlgorithm.h:138
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:200
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TileMonitorAlgorithm::SAMP_ALL
@ SAMP_ALL
Definition: TileMonitorAlgorithm.h:40
TileCellMonitorAlgorithm::m_fillTimeAndEnergyDiffHistograms
Gaudi::Property< bool > m_fillTimeAndEnergyDiffHistograms
Definition: TileCellMonitorAlgorithm.h:74
TileMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TileMonitorAlgorithm.cxx:10
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
CaloDetDescrElement::onl1
IdentifierHash onl1() const
cell online identifier 1
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:404
CaloGain::INVALIDGAIN
@ INVALIDGAIN
Definition: CaloGain.h:18
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
python.PyAthena.module
module
Definition: PyAthena.py:134
TileCell::timeDiff
float timeDiff(void) const
get time diff for two PMTs (data member)
Definition: TileCell.h:190
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileCell::qual2
uint8_t qual2(void) const
get quality of second PMT (data member)
Definition: TileCell.h:206
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
Tile
Definition: TileVolumeBuilder.h:43
TileCellMonitorAlgorithm::m_timeRangeForMuon
Gaudi::Property< std::vector< float > > m_timeRangeForMuon
Definition: TileCellMonitorAlgorithm.h:80
TileCellMonitorAlgorithm::fillMaskedInDB
void fillMaskedInDB(const TileBadChannels *badChannels) const
Definition: TileCellMonitorAlgorithm.cxx:974
TileCellMonitorAlgorithm::m_energyBalanceThreshold
Gaudi::Property< float > m_energyBalanceThreshold
Definition: TileCellMonitorAlgorithm.h:56
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition: AthMonitorAlgorithm.h:341
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileCellMonitorAlgorithm::m_energyThreshold
Gaudi::Property< float > m_energyThreshold
Definition: TileCellMonitorAlgorithm.h:44
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
Tile_Base_ID::module
int module(const Identifier &id) const
Definition: Tile_Base_ID.cxx:159
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:100
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
sim_rttUpdate.user
def user
Definition: sim_rttUpdate.py:662
xAOD::nCells
setRawEt setRawPhi nCells
Definition: TrigCaloCluster_v1.cxx:33
lumiFormat.i
int i
Definition: lumiFormat.py:92
TileCellMonitorAlgorithm::m_timeDiffSampGroups
std::vector< std::vector< std::vector< int > > > m_timeDiffSampGroups
Definition: TileCellMonitorAlgorithm.h:135
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
TileCellMonitorAlgorithm::m_overThr30GeVOccupGroups
std::vector< std::vector< int > > m_overThr30GeVOccupGroups
Definition: TileCellMonitorAlgorithm.h:126
TileMonitorAlgorithm::BIT7_CALIB
@ BIT7_CALIB
Definition: TileMonitorAlgorithm.h:34
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
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
TileCellMonitorAlgorithm::m_maskedCellsDueDQGroups
std::vector< int > m_maskedCellsDueDQGroups
Definition: TileCellMonitorAlgorithm.h:113
TileMonitorAlgorithm::BIT0_RNDM
@ BIT0_RNDM
Definition: TileMonitorAlgorithm.h:33
TileMonitorAlgorithm::Partition
Partition
Describes Tile partitions (ROS - 1)
Definition: TileMonitorAlgorithm.h:46
CaloCell::caloDDE
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition: CaloCell.h:305
makeTRTBarrelCans.y2
tuple y2
Definition: makeTRTBarrelCans.py:18
TileCell::badch2
bool badch2(void) const
check if second PMT is in bad channel list and masked
Definition: TileCell.h:218
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:113
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
TileCellMonitorAlgorithm::m_overThr300GeVOccupGroups
std::vector< std::vector< int > > m_overThr300GeVOccupGroups
Definition: TileCellMonitorAlgorithm.h:127
TileCellMonitorAlgorithm::m_caloCellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_caloCellContainerKey
Definition: TileCellMonitorAlgorithm.h:101
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
TileMonitorAlgorithm::PART_ALL
@ PART_ALL
Definition: TileMonitorAlgorithm.h:47
TileCellMonitorAlgorithm::m_timeBalGroups
std::vector< int > m_timeBalGroups
Definition: TileCellMonitorAlgorithm.h:141
TileMonitorAlgorithm::PART_LBC
@ PART_LBC
Definition: TileMonitorAlgorithm.h:46
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
TileCell::qbit1
uint8_t qbit1(void) const
get quality bits of first PMT (data member)
Definition: TileCell.h:209
TileCellMonitorAlgorithm::m_nCellsOverThrGroups
std::vector< std::vector< int > > m_nCellsOverThrGroups
Definition: TileCellMonitorAlgorithm.h:123
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.
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
TileCell::gain1
int gain1(void) const
get gain of first PMT
Definition: TileCell.cxx:182
TileCellMonitorAlgorithm::m_energyBalModPartGroups
std::vector< int > m_energyBalModPartGroups
Definition: TileCellMonitorAlgorithm.h:108
DeMoScan.partitions
dictionary partitions
Definition: DeMoScan.py:67
TileCell::eneDiff
float eneDiff(void) const
all get methods
Definition: TileCell.h:188
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
TileCellMonitorAlgorithm::m_energyThresholdForGain
Gaudi::Property< std::vector< float > > m_energyThresholdForGain
Definition: TileCellMonitorAlgorithm.h:83
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
TileDQstatus::isAdcDQgood
bool isAdcDQgood(int partition, int drawer, int ch, int gain) const
returns status of single ADC returns False if there are any errors
Definition: TileDQstatus.cxx:178
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
CaloTime_fillDB.gain1
gain1
Definition: CaloTime_fillDB.py:356
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
AthMonitorAlgorithm::Environment_t::online
@ online
TileCellMonitorAlgorithm::m_energySampEGroups
std::vector< std::vector< int > > m_energySampEGroups
Definition: TileCellMonitorAlgorithm.h:118
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
TileBadChannels
Condition object to keep Tile channel and ADC status.
Definition: TileBadChannels.h:24
TileHWID::channel_id
HWIdentifier channel_id(int ros, int drawer, int channel) const
channel HWIdentifer
Definition: TileHWID.cxx:198
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
TileMonitorAlgorithm::m_l1TriggerIndices
std::vector< int > m_l1TriggerIndices
Definition: TileMonitorAlgorithm.h:102
item
Definition: ItemListSvc.h:43
TileCellMonitorAlgorithm::m_detailOccupGainGroups
std::vector< std::vector< std::vector< int > > > m_detailOccupGainGroups
Definition: TileCellMonitorAlgorithm.h:130
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TileBadChannels::getAdcStatus
const TileBchStatus & getAdcStatus(const HWIdentifier adc_id) const
Return Tile ADC status.
Definition: TileBadChannels.cxx:24
xAOD::EventInfo_v1::streamTags
const std::vector< StreamTag > & streamTags() const
Get the streams that the event was put in.
Definition: EventInfo_v1.cxx:283
TileCellMonitorAlgorithm::m_eneDiffSampGroups
std::vector< std::vector< std::vector< int > > > m_eneDiffSampGroups
Definition: TileCellMonitorAlgorithm.h:134
TileHWID::adc_id
HWIdentifier adc_id(int ros, int drawer, int channel, int adc) const
adc HWIdentifer
Definition: TileHWID.cxx:228
TileCellMonitorAlgorithm::m_eneDiffChanModGroups
std::vector< std::vector< int > > m_eneDiffChanModGroups
Definition: TileCellMonitorAlgorithm.h:128
TileCell::qbit2
uint8_t qbit2(void) const
get quality bits of second PMT (data member)
Definition: TileCell.h:212
Tile_Base_ID::SAMP_D
@ SAMP_D
Definition: Tile_Base_ID.h:55
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
TileCell::gain2
int gain2(void) const
get gain of second PMT
Definition: TileCell.cxx:189
TileCell::ene2
float ene2(void) const
get energy of second PMT
Definition: TileCell.h:195
TileHWID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: TileHWID.h:314
TileCellMonitorAlgorithm::m_maskedOnFlyLBGroups
std::vector< int > m_maskedOnFlyLBGroups
Definition: TileCellMonitorAlgorithm.h:114
TileCablingService::C10_connected
static bool C10_connected(int module)
Definition: TileCablingService.cxx:1779
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
TileMonitorAlgorithm::getNumberOfL1Triggers
int getNumberOfL1Triggers(void) const
Return number of L1 triggers for which histograms should be filled.
Definition: TileMonitorAlgorithm.h:66
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
TileCellMonitorAlgorithm::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileCellMonitorAlgorithm.h:105
TileCellMonitorAlgorithm::m_moduleCorrGroups
std::vector< std::vector< int > > m_moduleCorrGroups
Definition: TileCellMonitorAlgorithm.h:119
Tile_Base_ID::to_string
std::string to_string(const Identifier &id, int level=0) const
Definition: Tile_Base_ID.cxx:52
TileMonitorAlgorithm::MAX_PART
@ MAX_PART
Definition: TileMonitorAlgorithm.h:47
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
PairBuilder::inputxy
void inputxy(const int ystrip)
Input a new y value.
Definition: PairBuilder.cxx:31
TileMonitorAlgorithm::BIT1_ZEROBIAS
@ BIT1_ZEROBIAS
Definition: TileMonitorAlgorithm.h:33
DEBUG
#define DEBUG
Definition: page_access.h:11
python.Classes.TileCalibUtils
TileCalibUtils
Definition: TileCalib/TileCalibBlobObjs/python/Classes.py:5
TileCellMonitorAlgorithm::m_energyThresholdForTime
Gaudi::Property< float > m_energyThresholdForTime
Definition: TileCellMonitorAlgorithm.h:50
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
StateLessPT_NewConfig.partition
partition
Definition: StateLessPT_NewConfig.py:49
TileCellMonitorAlgorithm::m_fillChannelTimeHistograms
Gaudi::Property< bool > m_fillChannelTimeHistograms
Definition: TileCellMonitorAlgorithm.h:68
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: AthMonitorAlgorithm.cxx:7
xAOD::EventInfo_v1::level1TriggerType
uint16_t level1TriggerType() const
The Level-1 trigger type.
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
TileCellMonitorAlgorithm::m_maskedDueDQGroups
std::vector< int > m_maskedDueDQGroups
Definition: TileCellMonitorAlgorithm.h:112
TileCell::qual1
uint8_t qual1(void) const
get quality of first PMT (data member)
Definition: TileCell.h:203
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
python.SystemOfUnits.ns
int ns
Definition: SystemOfUnits.py:130
TileCellMonitorAlgorithm::m_negOccupGroups
std::vector< int > m_negOccupGroups
Definition: TileCellMonitorAlgorithm.h:140
TileCellMonitorAlgorithm::m_chanTimeSampGroups
std::vector< std::vector< std::vector< int > > > m_chanTimeSampGroups
Definition: TileCellMonitorAlgorithm.h:133
TileCellMonitorAlgorithm::m_eneEtaPhiGroups
std::vector< std::vector< int > > m_eneEtaPhiGroups
Definition: TileCellMonitorAlgorithm.h:137
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
TileCellMonitorAlgorithm::m_cabling
const TileCablingService * m_cabling
Definition: TileCellMonitorAlgorithm.h:106
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
TileCellMonitorAlgorithm::m_energyBalGroups
std::vector< int > m_energyBalGroups
Definition: TileCellMonitorAlgorithm.h:142
TileCellMonitorAlgorithm::m_overThrOccupGroups
std::vector< std::vector< int > > m_overThrOccupGroups
Definition: TileCellMonitorAlgorithm.h:125
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
Tile_Base_ID::section
int section(const Identifier &id) const
Definition: Tile_Base_ID.cxx:147
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
section
void section(const std::string &sec)
Definition: TestTriggerMenuAccess.cxx:22
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
TileCellMonitorAlgorithm::m_tileID
const TileID * m_tileID
Definition: TileCellMonitorAlgorithm.h:104
Tile_Base_ID::cell_id
Identifier cell_id(const Identifier &any_id) const
Definition: Tile_Base_ID.cxx:581
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:327
TileCellMonitorAlgorithm::m_cablingSvc
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.
Definition: TileCellMonitorAlgorithm.h:89
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
TileCellMonitorAlgorithm::m_fillGapScintHistograms
Gaudi::Property< bool > m_fillGapScintHistograms
Definition: TileCellMonitorAlgorithm.h:71
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileHWID::adc_end
std::vector< HWIdentifier >::const_iterator adc_end(void) const
end iterator for ADC Identifiers
Definition: TileHWID.h:312
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
TileCellMonitorAlgorithm::m_timeBalModPartGroups
std::vector< int > m_timeBalModPartGroups
Definition: TileCellMonitorAlgorithm.h:109
TileMonitorAlgorithm::getPartition
Partition getPartition(const CaloCell *cell, const TileID *tileID) const
Return Partition for Tile cell or MAX_PART otherwise.
Definition: TileMonitorAlgorithm.cxx:109
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
fitman.k
k
Definition: fitman.py:528
TileMonitorAlgorithm::PART_LBA
@ PART_LBA
Definition: TileMonitorAlgorithm.h:46
TileCellMonitorAlgorithm::m_DQstatusKey
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
Definition: TileCellMonitorAlgorithm.h:92
ServiceHandle< ICondSvc >
TileCellMonitorAlgorithm::m_energyGapScintGroups
std::vector< std::vector< std::vector< int > > > m_energyGapScintGroups
Definition: TileCellMonitorAlgorithm.h:131
collisions
Definition: collisions.py:1