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

Algorithm to monitor L1Topo transmission and simulation errors for the (Run-3) L1Topo boards. More...

#include <L1TopoOnlineMonitor.h>

Inheritance diagram for L1TopoOnlineMonitor:
Collaboration diagram for L1TopoOnlineMonitor:

Classes

struct  DecisionBits
 Helper structure holding decision bitsets, passed between the monitoring methods. More...
 

Public Types

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

Public Member Functions

 L1TopoOnlineMonitor (const std::string &name, ISvcLocator *svcLoc)
 
virtual StatusCode initialize () override
 initialize More...
 
virtual StatusCode start () override
 
virtual StatusCode fillHistograms (const EventContext &ctx) const override
 adds event to the monitoring histograms 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, V, H > &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
 

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

StatusCode doSimMon (DecisionBits &decisionBits, std::vector< std::vector< unsigned >> &multWeights, const EventContext &ctx) const
 Monitor the simulated bits. More...
 
StatusCode doHwMonCTP (DecisionBits &decisionBits, const EventContext &ctx) const
 Monitor the Hw bits from CTP. More...
 
StatusCode doHwMon (DecisionBits &decisionBits, std::vector< std::vector< unsigned >> &multWeights, const EventContext &ctx) const
 Monitor the Hw bits from RAW data. More...
 
StatusCode doComp (DecisionBits &decisionBits, const EventContext &ctx) const
 Compare hardware and simulation. More...
 
StatusCode doMultComp (std::vector< std::vector< unsigned >> &multWeightsSim, std::vector< std::vector< unsigned >> &multWeightsHdw, const EventContext &ctx) const
 Compare hardware and simulation for the multiplicity algorithms. More...
 
std::vector< unsigned > getCtpIds (const TrigConf::L1Menu &l1menu)
 Get CTP ids from menu. More...
 
std::vector< std::vector< std::pair< unsigned, unsigned > > > getStartBits (const TrigConf::L1Menu &l1menu)
 
void resetFlags (xAOD::TrigComposite &errorFlags) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::vector< std::string > m_TopoAlgTriggerNames
 
std::vector< bool > m_TopoAlgTriggerNotVetoed
 
std::vector< std::string > m_TopoMultTriggerNames
 
std::vector< bool > m_TopoMultTriggerNotVetoed
 
std::unique_ptr< float[]> m_rateHdwNotSim
 
std::unique_ptr< float[]> m_rateSimNotHdw
 
std::unique_ptr< float[]> m_rateHdwAndSim
 
std::unique_ptr< float[]> m_rateHdwSim
 
std::unique_ptr< float[]> m_countHdwNotSim
 
std::unique_ptr< float[]> m_countSimNotHdw
 
std::unique_ptr< float[]> m_countHdwSim
 
std::unique_ptr< float[]> m_countHdw
 
std::unique_ptr< float[]> m_countSim
 
std::unique_ptr< float[]> m_countAny
 
std::unique_ptr< float[]> m_overflow_rateHdwNotSim
 
std::unique_ptr< float[]> m_overflow_rateSimNotHdw
 
std::unique_ptr< float[]> m_overflow_rateHdwAndSim
 
std::unique_ptr< float[]> m_overflow_rateHdwSim
 
std::unique_ptr< float[]> m_overflow_countHdwNotSim
 
std::unique_ptr< float[]> m_overflow_countSimNotHdw
 
std::unique_ptr< float[]> m_overflow_countHdwSim
 
std::unique_ptr< float[]> m_overflow_countHdw
 
std::unique_ptr< float[]> m_overflow_countSim
 
std::unique_ptr< float[]> m_overflow_countAny
 
std::unique_ptr< float[]> m_currentHdwBit
 
std::unique_ptr< float[]> m_currentSimBit
 
std::vector< unsigned > m_ctpIds
 
std::vector< std::vector< std::pair< unsigned, unsigned > > > m_startbit
 
ToolHandle< GenericMonitoringToolm_monTool
 
SG::WriteHandleKey< xAOD::TrigCompositeContainerm_errorFlagsKey
 
Gaudi::Property< bool > m_doSimMon
 
Gaudi::Property< bool > m_doHwMonCTP
 
Gaudi::Property< bool > m_doHwMon
 
Gaudi::Property< bool > m_doHwErrorMon
 
Gaudi::Property< bool > m_doComp
 
Gaudi::Property< bool > m_doMultComp
 
Gaudi::Property< bool > m_forceCTPasHdw
 
Gaudi::Property< std::vector< std::string > > m_AlgorithmVetoList
 
Gaudi::Property< std::vector< std::string > > m_MultiplicityVetoList
 
ServiceHandle< StoreGateSvcm_detStore { this, "DetectorStore", "StoreGateSvc/DetectorStore", "Detector store to get the menu" }
 
SG::ReadHandleKey< xAOD::L1TopoSimResultsContainerm_l1topoKey
 
SG::ReadHandleKey< xAOD::L1TopoRawDataContainerm_l1topoRawDataKey
 
SG::ReadHandleKey< CTP_RDOm_ctpRdoKey
 
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...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static constexpr size_t s_nTopoCTPOutputs {128}
 Number of CTP outputs, used for histogram ranges and loops. More...
 

Detailed Description

Algorithm to monitor L1Topo transmission and simulation errors for the (Run-3) L1Topo boards.

Author
Anil Sonay

This algorithm tend to catch L1Topo sim xAOD to record decision bits into online monitoring Decision bits are from phase1 simulations or hardware

Definition at line 37 of file L1TopoOnlineMonitor.h.

Member Typedef Documentation

◆ MonVarVec_t

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

Definition at line 365 of file AthMonitorAlgorithm.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataType_t

enum AthMonitorAlgorithm::DataType_t
stronginherited

Specifies what type of input data is being monitored.

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

Enumerator
userDefined 
monteCarlo 
collisions 
cosmics 
heavyIonCollisions 

Definition at line 191 of file AthMonitorAlgorithm.h.

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

◆ Environment_t

enum AthMonitorAlgorithm::Environment_t
stronginherited

Specifies the processing environment.

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

Enumerator
user 
online 
tier0 
tier0Raw 
tier0ESD 
AOD 
altprod 

Definition at line 172 of file AthMonitorAlgorithm.h.

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

Constructor & Destructor Documentation

◆ L1TopoOnlineMonitor()

L1TopoOnlineMonitor::L1TopoOnlineMonitor ( const std::string &  name,
ISvcLocator *  svcLoc 
)

Definition at line 37 of file L1TopoOnlineMonitor.cxx.

38  : AthMonitorAlgorithm(name, svcLoc),
39  m_ctpIds(0)
40 {}

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
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 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ 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, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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, V, H > &  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; }

◆ doComp()

StatusCode L1TopoOnlineMonitor::doComp ( DecisionBits decisionBits,
const EventContext &  ctx 
) const
private

Compare hardware and simulation.

Definition at line 581 of file L1TopoOnlineMonitor.cxx.

581  {
582  if (!decisionBits.triggerBitsSim.has_value()) {
583  ATH_MSG_DEBUG("Simulation bits not set. Skipping simulation to hardware comparison");
584  return StatusCode::FAILURE;
585  }
586 
587  std::bitset<s_nTopoCTPOutputs> triggerBitsSim = decisionBits.triggerBitsSim.value(); // Alias
588  std::bitset<s_nTopoCTPOutputs> triggerBitsHdw;
589 
590  if (decisionBits.triggerBits.has_value() && !m_forceCTPasHdw)
591  {triggerBitsHdw = decisionBits.triggerBits.value();}
592  else if (decisionBits.triggerBitsCtp.has_value())
593  {triggerBitsHdw = decisionBits.triggerBitsCtp.value();}
594  else {
595  ATH_MSG_DEBUG("Hardware bits not set. Skipping simulation to hardware comparison");
596  return StatusCode::FAILURE;
597  }
598 
599  std::bitset<s_nTopoCTPOutputs> triggerBitsSimNotHdw = triggerBitsSim & (~triggerBitsHdw);
600  std::bitset<s_nTopoCTPOutputs> triggerBitsHdwNotSim = triggerBitsHdw & (~triggerBitsSim);
601  std::bitset<s_nTopoCTPOutputs> triggerBitsHdwSim = triggerBitsHdw & triggerBitsSim;
602  std::bitset<s_nTopoCTPOutputs> triggerBitsAny = triggerBitsHdw | triggerBitsSim;
603 
604  std::bitset<s_nTopoCTPOutputs>& overflowBitsSim = decisionBits.overflowBitsSim.value();
605  std::bitset<s_nTopoCTPOutputs>& overflowBitsHdw = decisionBits.overflowBits.value();
606  std::bitset<s_nTopoCTPOutputs> overflowBitsSimNotHdw = overflowBitsSim & (~overflowBitsHdw);
607  std::bitset<s_nTopoCTPOutputs> overflowBitsHdwNotSim = overflowBitsHdw & (~overflowBitsSim);
608  std::bitset<s_nTopoCTPOutputs> overflowBitsHdwSim = overflowBitsHdw & overflowBitsSim;
609  std::bitset<s_nTopoCTPOutputs> overflowBitsAny = overflowBitsHdw | overflowBitsSim;
610 
611  std::bitset<s_nTopoCTPOutputs>& ambiguityBitsSim = decisionBits.ambiguityBitsSim.value();
612  std::bitset<s_nTopoCTPOutputs> ambiguitySimANDHdw = ambiguityBitsSim & triggerBitsHdwSim;
613  std::bitset<s_nTopoCTPOutputs> ambiguityMismatch = ambiguityBitsSim & (triggerBitsSimNotHdw | triggerBitsHdwNotSim);
614 
615  std::vector<size_t> triggerBitIndicesSimNotHdw = bitsetIndices(triggerBitsSimNotHdw);
616  std::vector<size_t> triggerBitIndicesHdwNotSim = bitsetIndices(triggerBitsHdwNotSim);
617  std::vector<size_t> ambiguitySimANDHdwBitIndices = bitsetIndices(ambiguitySimANDHdw);
618  std::vector<size_t> ambiguityMismatchBitIndices = bitsetIndices(ambiguityMismatch);
619  auto monSimNotHdw = Monitored::Collection("SimNotHdwL1TopoResult", triggerBitIndicesSimNotHdw);
620  auto monHdwNotSim = Monitored::Collection("HdwNotSimL1TopoResult", triggerBitIndicesHdwNotSim);
621  auto monAmbiguitySimANDHdw = Monitored::Collection("Ambiguity_SimANDHdwDecisions", ambiguitySimANDHdwBitIndices);
622  auto monAmbiguityMismatch = Monitored::Collection("Ambiguity_DecisionMismatches", ambiguityMismatchBitIndices);
623 
624  Monitored::Group(m_monTool, monSimNotHdw, monHdwNotSim, monAmbiguitySimANDHdw, monAmbiguityMismatch);
625 
626  float rate=0;
627  float rate_overflow=0;
628 
629  auto lbn = Monitored::Scalar<int>("LBN",GetEventInfo(ctx)->lumiBlock());
630  auto mon_trig_allboards = Monitored::Scalar<unsigned>("L1TopoAlgorithmAllBoards");
631  auto mon_matchVsLumi_DQ = Monitored::Scalar<unsigned>("L1TopoAlgorithmMissMatchVsLumi");
632 
633  for (size_t i=0;i<4;i++) {
634 
635  auto mon_trig = Monitored::Scalar<unsigned>("Phase1TopoTrigger_"+std::to_string(i));
636  auto mon_match = Monitored::Scalar<unsigned>("Phase1TopoMissMatch_"+std::to_string(i));
637  auto mon_match_DQ = Monitored::Scalar<unsigned>("L1TopoAlgorithmMissMatch_"+std::to_string(i));
638  auto mon_match_OF_DQ = Monitored::Scalar<unsigned>("L1TopoAlgorithmOverflowMissMatch_"+std::to_string(i));
639  auto mon_weight = Monitored::Scalar<float>("Phase1TopoWeight_"+std::to_string(i));
640  auto mon_OFweight = Monitored::Scalar<float>("Phase1TopoOFWeight_"+std::to_string(i));
641 
642  for (size_t j=0;j<32;j++) {
643 
644  if (ambiguityBitsSim[32*i+j] == 0) {
645  mon_trig = static_cast<unsigned>(j);
646  mon_trig_allboards = static_cast<unsigned>(32*i+j);
647  if (overflowBitsHdw[32*i+j] == 1 || overflowBitsSim[32*i+j] == 1) {
648  m_overflow_countHdwNotSim[32*i+j]+=overflowBitsHdwNotSim[32*i+j];
649  m_overflow_countSimNotHdw[32*i+j]+=overflowBitsSimNotHdw[32*i+j];
650  m_overflow_countHdwSim[32*i+j]+=overflowBitsHdwSim[32*i+j];
651  m_overflow_countHdw[32*i+j]+=overflowBitsHdw[32*i+j];
652  m_overflow_countSim[32*i+j]+=overflowBitsSim[32*i+j];
653  m_overflow_countAny[32*i+j]+=overflowBitsAny[32*i+j];
654  }
655  else {
656  m_countHdwNotSim[32*i+j]+=triggerBitsHdwNotSim[32*i+j];
657  m_countSimNotHdw[32*i+j]+=triggerBitsSimNotHdw[32*i+j];
658  m_countHdwSim[32*i+j]+=triggerBitsHdwSim[32*i+j];
659  m_countHdw[32*i+j]+=triggerBitsHdw[32*i+j];
660  m_countSim[32*i+j]+=triggerBitsSim[32*i+j];
661  m_countAny[32*i+j]+=triggerBitsAny[32*i+j];
662  m_currentHdwBit[32*i+j]=triggerBitsHdw[32*i+j];
663  m_currentSimBit[32*i+j]=triggerBitsSim[32*i+j];
664  }
665 
666  //Simplified plot for L1Calo DQ
667  if ( m_currentSimBit[32*i+j] < m_currentHdwBit[32*i+j] ){ mon_match_DQ = 0; mon_matchVsLumi_DQ = 1;}
668  if ( m_currentSimBit[32*i+j] > m_currentHdwBit[32*i+j] ){ mon_match_DQ = 1; mon_matchVsLumi_DQ = 1;}
669  if ( m_currentSimBit[32*i+j] == m_currentHdwBit[32*i+j] ){ mon_match_DQ = 2; mon_matchVsLumi_DQ = 0;}
670  if ( (m_currentSimBit[32*i+j] > 0 || m_currentHdwBit[32*i+j] > 0 ) && m_TopoAlgTriggerNotVetoed[32*i+j] ){
671  Monitored::Group(m_monTool, mon_trig, mon_match_DQ);
672  Monitored::Group(m_monTool, lbn, mon_trig_allboards, mon_matchVsLumi_DQ);
673  }
674 
675  if (m_overflow_countSim[32*i+j] <m_overflow_countHdw[32*i+j] ) mon_match_OF_DQ = 0;
676  if (m_overflow_countSim[32*i+j] >m_overflow_countHdw[32*i+j] ) mon_match_OF_DQ = 1;
677  if (m_overflow_countSim[32*i+j] ==m_overflow_countHdw[32*i+j] ) mon_match_OF_DQ = 2;
678  if ( (m_overflow_countSim[32*i+j] > 0 || m_overflow_countHdw[32*i+j] > 0 ) && m_TopoAlgTriggerNotVetoed[32*i+j] ) Monitored::Group(m_monTool, mon_trig, mon_match_OF_DQ);
679 
680  rate = m_countHdw[32*i+j]>0 ? m_countHdwNotSim[32*i+j]/m_countHdw[32*i+j] : 0;
681  if (rate != m_rateHdwNotSim[32*i+j]) {
682  mon_match = 0;
683  mon_weight = rate-m_rateHdwNotSim[32*i+j];
684  m_rateHdwNotSim[32*i+j] = rate;
685  Monitored::Group(m_monTool, mon_trig, mon_match, mon_weight);
686  }
687  rate_overflow = m_overflow_countHdw[32*i+j]>0 ? m_overflow_countHdwNotSim[32*i+j]/m_overflow_countHdw[32*i+j] : 0;
688  if (rate_overflow != m_overflow_rateHdwNotSim[32*i+j]) {
689  mon_match = 0;
690  mon_OFweight = rate_overflow-m_overflow_rateHdwNotSim[32*i+j];
691  m_overflow_rateHdwNotSim[32*i+j] = rate_overflow;
692  Monitored::Group(m_monTool, mon_trig, mon_match, mon_OFweight);
693  }
694  rate = m_countSim[32*i+j]>0 ? m_countSimNotHdw[32*i+j]/m_countSim[32*i+j] : 0;
695  if (rate != m_rateSimNotHdw[32*i+j]) {
696  mon_match = 1;
697  mon_weight = rate-m_rateSimNotHdw[32*i+j];
698  m_rateSimNotHdw[32*i+j] = rate;
699  Monitored::Group(m_monTool, mon_trig, mon_match, mon_weight);
700  }
701  rate_overflow = m_overflow_countSim[32*i+j]>0 ? m_overflow_countSimNotHdw[32*i+j]/m_overflow_countSim[32*i+j] : 0;
702  if (rate_overflow != m_overflow_rateSimNotHdw[32*i+j]) {
703  mon_match = 1;
704  mon_OFweight = rate_overflow-m_overflow_rateSimNotHdw[32*i+j];
705  m_overflow_rateSimNotHdw[32*i+j] = rate_overflow;
706  Monitored::Group(m_monTool, mon_trig, mon_match, mon_OFweight);
707  }
708  rate = m_countAny[32*i+j]>0 ? m_countHdwSim[32*i+j]/m_countAny[32*i+j] : 0;
709  if (rate != m_rateHdwAndSim[32*i+j]) {
710  mon_match = 2;
711  mon_weight = rate-m_rateHdwAndSim[32*i+j];
712  m_rateHdwAndSim[32*i+j] = rate;
713  Monitored::Group(m_monTool, mon_trig, mon_match, mon_weight);
714  }
715  rate_overflow = m_overflow_countAny[32*i+j]>0 ? m_overflow_countHdwSim[32*i+j]/m_overflow_countAny[32*i+j] : 0;
716  if (rate_overflow != m_overflow_rateHdwAndSim[32*i+j]) {
717  mon_match = 2;
718  mon_OFweight = rate_overflow-m_overflow_rateHdwAndSim[32*i+j];
719  m_overflow_rateHdwAndSim[32*i+j] = rate_overflow;
720  Monitored::Group(m_monTool, mon_trig, mon_match, mon_OFweight);
721  }
722  rate = m_countSim[32*i+j]>0 ? m_countHdw[32*i+j]/m_countSim[32*i+j] : 0;
723  if (rate != m_rateHdwSim[32*i+j]) {
724  mon_match = 3;
725  mon_weight = rate-m_rateHdwSim[32*i+j];
726  m_rateHdwSim[32*i+j] = rate;
727  Monitored::Group(m_monTool, mon_trig, mon_match, mon_weight);
728  }
729  rate_overflow = m_overflow_countSim[32*i+j]>0 ? m_overflow_countHdw[32*i+j]/m_overflow_countSim[32*i+j] : 0;
730  if (rate_overflow != m_overflow_rateHdwSim[32*i+j]) {
731  mon_match = 3;
732  mon_OFweight = rate_overflow-m_overflow_rateHdwSim[32*i+j];
733  m_overflow_rateHdwSim[32*i+j] = rate_overflow;
734  Monitored::Group(m_monTool, mon_trig, mon_match, mon_OFweight);
735  }
736  }
737  }
738  }
739  return StatusCode::SUCCESS;
740 }

◆ doHwMon()

StatusCode L1TopoOnlineMonitor::doHwMon ( DecisionBits decisionBits,
std::vector< std::vector< unsigned >> &  multWeights,
const EventContext &  ctx 
) const
private

Monitor the Hw bits from RAW data.

Definition at line 423 of file L1TopoOnlineMonitor.cxx.

423  {
424 
426  if(!cont.isValid()){
427  ATH_MSG_WARNING("Could not retrieve L1Topo RAW Data Container from the BS data.");
428  return StatusCode::FAILURE;
429  }
430 
431  ATH_MSG_DEBUG("----got L1Topo Raw Data container: " << cont.key());
432 
433  std::bitset<s_nTopoCTPOutputs>& triggerBits = DecisionBits::createBits(decisionBits.triggerBits);
434  std::bitset<s_nTopoCTPOutputs>& overflowBits = DecisionBits::createBits(decisionBits.overflowBits);
435 
436  std::unique_ptr<L1Topo::L1TopoResult> l1topoResult = std::make_unique<L1Topo::L1TopoResult>(*cont);
437  if (!l1topoResult->getStatus()) {
438  ATH_MSG_WARNING("Decoding L1Topo results failed!!");
439  return StatusCode::FAILURE;
440  }
441 
442  if (m_doHwErrorMon){
443  // Error monitoring ---------------------------------------------------------
444  enum class MonFunction : uint8_t {doRODct, doRODpc, doRODhc, doRODpe, doRODlm, doRODhm, doRODpt};
445  std::vector<uint8_t> rodErrors;
446  if (l1topoResult->getROD(0)->ct() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODct)); }
447  if (l1topoResult->getROD(0)->pc() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODpc)); }
448  if (l1topoResult->getROD(0)->hc() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODhc)); }
449  if (l1topoResult->getROD(0)->pe() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODpe)); }
450  if (l1topoResult->getROD(0)->lm() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODlm)); }
451  if (l1topoResult->getROD(0)->hm() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODhm)); }
452  if (l1topoResult->getROD(0)->pt() != 0) { rodErrors.push_back(static_cast<uint8_t>(MonFunction::doRODpt)); }
453  auto monErrorsROD = Monitored::Collection("ROD_Errors", rodErrors);
454  Monitored::Group(m_monTool, monErrorsROD);
455  }
456 
457  for (unsigned i=0;i<l1topoResult->getFPGASize();i++) {
458  unsigned topoNumber = l1topoResult->getFPGA(i)->topoNumber();
459  unsigned fpgaNumber = l1topoResult->getFPGA(i)->fpgaNumber();
460 
461  auto mon_fpga_error = Monitored::Scalar<unsigned>("FPGA_Errors");
462  auto mon_fpga_labels = Monitored::Scalar("FPGA_Labels", (topoNumber*2)-fpgaNumber-1);
463 
464  if (l1topoResult->getFPGA(i)->ct() != 0) {
465  mon_fpga_error = 0;
466  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
467  }
468  if (l1topoResult->getFPGA(i)->sm() != 0) {
469  mon_fpga_error = 1;
470  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
471  }
472  if (l1topoResult->getFPGA(i)->pe() != 0) {
473  mon_fpga_error = 2;
474  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
475  }
476  if (l1topoResult->getFPGA(i)->lm() != 0) {
477  mon_fpga_error = 3;
478  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
479  }
480  if (l1topoResult->getFPGA(i)->hm() != 0) {
481  mon_fpga_error = 4;
482  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
483  }
484  if (l1topoResult->getFPGA(i)->pt() != 0) {
485  mon_fpga_error = 5;
486  Monitored::Group(m_monTool, mon_fpga_error, mon_fpga_labels);
487  }
488  }
489 
490  // Multiplicities ---------------------------------------------------------
491  std::vector<unsigned> topo1Opt0,topo1Opt1,topo1Opt2,topo1Opt3;
492  std::vector<unsigned> topo1Opt0Indices,topo1Opt1Indices,topo1Opt2Indices,topo1Opt3Indices;
493 
494  unsigned indices=0;
495  for (auto startbit : m_startbit[0]) {
496  unsigned count = 0;
497  for (size_t i=0;i<startbit.second;i++){
498  if (l1topoResult->getTopo1Opt0()[startbit.first+i]) {
499  count += 1 * pow(2,i);
500  }
501  }
502  topo1Opt0.push_back(count);
503  topo1Opt0Indices.push_back(indices);
504  indices++;
505  }
506  indices=0;
507  for (auto startbit : m_startbit[1]) {
508  unsigned count = 0;
509  for (size_t i=0;i<startbit.second;i++){
510  if (l1topoResult->getTopo1Opt1()[startbit.first+i]) {
511  count += 1 * pow(2,i);
512  }
513  }
514  topo1Opt1.push_back(count);
515  topo1Opt1Indices.push_back(indices);
516  indices++;
517  }
518  indices=0;
519  for (auto startbit : m_startbit[2]) {
520  unsigned count = 0;
521  for (size_t i=0;i<startbit.second;i++){
522  if (l1topoResult->getTopo1Opt2()[startbit.first+i]) {
523  count += 1 * pow(2,i);
524  }
525  }
526  topo1Opt2.push_back(count);
527  topo1Opt2Indices.push_back(indices);
528  indices++;
529  }
530  indices=0;
531  for (auto startbit : m_startbit[3]) {
532  unsigned count = 0;
533  for (size_t i=0;i<startbit.second;i++){
534  if (l1topoResult->getTopo1Opt3()[startbit.first+i]) {
535  count += 1 * pow(2,i);
536  }
537  }
538  topo1Opt3.push_back(count);
539  topo1Opt3Indices.push_back(indices);
540  indices++;
541  }
542 
543  auto monTopo1Opt0 = Monitored::Collection("HdwTopo1Opt0", topo1Opt0Indices);
544  auto monTopo1Opt0Weight = Monitored::Collection("HdwTopo1Opt0_weight", topo1Opt0);
545  Monitored::Group(m_monTool, monTopo1Opt0, monTopo1Opt0Weight);
546  multWeights.push_back(topo1Opt0);
547 
548  auto monTopo1Opt1 = Monitored::Collection("HdwTopo1Opt1", topo1Opt1Indices);
549  auto monTopo1Opt1Weight = Monitored::Collection("HdwTopo1Opt1_weight", topo1Opt1);
550  Monitored::Group(m_monTool, monTopo1Opt1, monTopo1Opt1Weight);
551  multWeights.push_back(topo1Opt1);
552 
553  auto monTopo1Opt2 = Monitored::Collection("HdwTopo1Opt2", topo1Opt2Indices);
554  auto monTopo1Opt2Weight = Monitored::Collection("HdwTopo1Opt2_weight", topo1Opt2);
555  Monitored::Group(m_monTool, monTopo1Opt2, monTopo1Opt2Weight);
556  multWeights.push_back(topo1Opt2);
557 
558  auto monTopo1Opt3 = Monitored::Collection("HdwTopo1Opt3", topo1Opt3Indices);
559  auto monTopo1Opt3Weight = Monitored::Collection("HdwTopo1Opt3_weight", topo1Opt3);
560  Monitored::Group(m_monTool, monTopo1Opt3, monTopo1Opt3Weight);
561  multWeights.push_back(topo1Opt3);
562 
563  // Decisions ---------------------------------------------------------------
564  triggerBits = l1topoResult->getDecisions();
565  overflowBits = l1topoResult->getOverflows();
566 
567  const std::vector<size_t> triggerBitIndicesHdw = bitsetIndices(triggerBits);
568  const std::vector<size_t> overflowBitIndicesHdw = bitsetIndices(overflowBits);
569 
570  ATH_MSG_VERBOSE("trigger bits: " << triggerBits.to_string() );
571  ATH_MSG_VERBOSE("overflow bits: " << overflowBits.to_string() );
572 
573  auto monHdw = Monitored::Collection("HdwResults", triggerBitIndicesHdw);
574  auto monOverflow = Monitored::Collection("OverflowResults", overflowBitIndicesHdw);
575 
576  Monitored::Group(m_monTool, monHdw, monOverflow);
577 
578  return StatusCode::SUCCESS;
579 }

◆ doHwMonCTP()

StatusCode L1TopoOnlineMonitor::doHwMonCTP ( DecisionBits decisionBits,
const EventContext &  ctx 
) const
private

Monitor the Hw bits from CTP.

Definition at line 382 of file L1TopoOnlineMonitor.cxx.

382  {
383 
384  // Retrieve CTP DAQ data for comparison
386  if (!ctpRdo.isValid()) {
387  ATH_MSG_DEBUG("Failed to retrieve CTP_RDO object (converted from CTP DAQ ROB) with key \""
388  << m_ctpRdoKey.key() << "\". Skipping CTP hardware comparison");
389  return StatusCode::FAILURE;
390  }
391 
392  // CTP RDO contains 17 TBP words for a number of BCs, so use CTP_Decoder to access accepted BC
394  ctp.setRDO(ctpRdo.cptr());
395  const uint32_t l1aPos = ctpRdo->getL1AcceptBunchPosition();
396  if (l1aPos >= ctp.getBunchCrossings().size()) {
397  ATH_MSG_DEBUG("CTP_RDO gave invalid l1aPos. Skipping CTP hardware comparison");
398  return StatusCode::FAILURE;
399  }
400  ATH_MSG_DEBUG("CTP l1aPos, size: " << l1aPos << ", " << ctp.getBunchCrossings().size());
401  const CTP_BC& ctpL1a = ctp.getBunchCrossings().at(l1aPos);
402 
403  // Fill decision bits from CTP RDO
404  std::bitset<s_nTopoCTPOutputs>& triggerBitsCtp = DecisionBits::createBits(decisionBits.triggerBitsCtp);
405  static constexpr size_t ctpTBPSize{512};
406  const std::bitset<ctpTBPSize>& tbp = ctpL1a.getTBP();
407  ATH_MSG_VERBOSE("CTP TBP bits: " << tbp.to_string());
408 
409  for (size_t i=0; i<s_nTopoCTPOutputs; ++i) {
410  if (m_ctpIds[i] < 512)
411  {triggerBitsCtp[i] = tbp.test(m_ctpIds[i]);}
412  else
413  {triggerBitsCtp[i] = false;}
414  }
415 
416  std::vector<size_t> triggerBitIndicesCtp = bitsetIndices(triggerBitsCtp);
417  auto monTopoCtp = Monitored::Collection("TopoCTP", triggerBitIndicesCtp);
418  Monitored::Group(m_monTool,monTopoCtp);
419 
420  return StatusCode::SUCCESS;
421 }

◆ doMultComp()

StatusCode L1TopoOnlineMonitor::doMultComp ( std::vector< std::vector< unsigned >> &  multWeightsSim,
std::vector< std::vector< unsigned >> &  multWeightsHdw,
const EventContext &  ctx 
) const
private

Compare hardware and simulation for the multiplicity algorithms.

Definition at line 742 of file L1TopoOnlineMonitor.cxx.

742  {
743  if (multWeightsSim.size() == 0 or multWeightsHdw.size() == 0) {
744  ATH_MSG_DEBUG("Multiplicities not set, skipping multiplicities comparison");
745  return StatusCode::FAILURE;
746  }
747 
748  auto lbn = Monitored::Scalar<int>("LBN",GetEventInfo(ctx)->lumiBlock());
749  auto mon_multiplicity_allboards = Monitored::Scalar<unsigned>("MultiplicityAllBoards");
750  auto mon_multVsLumi_DQ = Monitored::Scalar<unsigned>("L1TopoMultiplicityMissMatchVsLumi");
751  int AccumulatedPosition=0;
752  for (size_t i=0;i<multWeightsSim.size();i++) {
753  auto mon_multiplicity = Monitored::Scalar<unsigned>("MultiplicityTopo1Opt" + std::to_string(i));
754  auto mon_mult = Monitored::Scalar<unsigned>("MultiplicityMatchTopo1Opt" + std::to_string(i));
755  for (size_t k=0;k<multWeightsSim[i].size();k++) {
756  std::string colName = "Topo1Opt" + std::to_string(i) + "_" + std::to_string(k);
757  auto monMultSim = Monitored::Scalar<unsigned>(colName+"_Sim", multWeightsSim[i][k]);
758  auto monMultHdw = Monitored::Scalar<unsigned>(colName+"_Hdw", multWeightsHdw[i][k]);
759  Monitored::Group(m_monTool, monMultSim, monMultHdw);
760  if (monMultSim < monMultHdw) {mon_mult = 0; mon_multVsLumi_DQ = 1;}
761  if (monMultSim > monMultHdw) {mon_mult = 1; mon_multVsLumi_DQ = 1;}
762  if (monMultSim == monMultHdw){mon_mult = 2; mon_multVsLumi_DQ = 0;}
763  mon_multiplicity = static_cast<unsigned>(k);
764  mon_multiplicity_allboards = static_cast<unsigned>(k+AccumulatedPosition);
765  if (( monMultSim > 0 || monMultHdw > 0) && m_TopoMultTriggerNotVetoed[k+AccumulatedPosition]) {
766  Monitored::Group(m_monTool, mon_multiplicity, mon_mult);
767  Monitored::Group(m_monTool, lbn, mon_multiplicity_allboards, mon_multVsLumi_DQ);
768  }
769  }
770  AccumulatedPosition=AccumulatedPosition+multWeightsSim[i].size();
771  }
772  return StatusCode::SUCCESS;
773 }

◆ doSimMon()

StatusCode L1TopoOnlineMonitor::doSimMon ( DecisionBits decisionBits,
std::vector< std::vector< unsigned >> &  multWeights,
const EventContext &  ctx 
) const
private

Monitor the simulated bits.

Definition at line 288 of file L1TopoOnlineMonitor.cxx.

288  {
289 
290 
292  if(!cont.isValid()){
293  ATH_MSG_FATAL("Could not retrieve L1Topo EDM Container from the Simulation.");
294  return StatusCode::FAILURE;
295  }
296 
297  ATH_MSG_DEBUG("----got L1Topo container: " << cont.key());
298 
299  std::bitset<s_nTopoCTPOutputs>& triggerBitsSim = DecisionBits::createBits(decisionBits.triggerBitsSim);
300  std::bitset<s_nTopoCTPOutputs>& overflowBitsSim = DecisionBits::createBits(decisionBits.overflowBitsSim);
301  std::bitset<s_nTopoCTPOutputs>& ambiguityBitsSim = DecisionBits::createBits(decisionBits.ambiguityBitsSim);
302  std::unordered_map<unsigned,std::bitset<s_nTopoCTPOutputs>> multWeightsMap;
303  for(const auto l1topo_dec : * cont){
304  ATH_MSG_DEBUG( "Reading L1Topo EDM:: Connection ID: " << l1topo_dec->connectionId() << " Clock: " << l1topo_dec->clock() << " Bit-length: " << l1topo_dec->bitWidth() << " Word: " << l1topo_dec->topoWord() << " Word64: " << l1topo_dec->topoWord64() );
305 
306  if (l1topo_dec->bitWidth() == 32) {
307  std::vector<unsigned> topoword;
308  std::vector<unsigned> topowordOverflow;
309  for(unsigned int i=0; i<32; ++i) {
310  uint32_t mask = 0x1; mask <<= i;
311  if ((l1topo_dec->topoWord() & mask) !=0) {
312  if (l1topo_dec->connectionId()==2 || l1topo_dec->connectionId()==3) { // TOPO2EL and TOPO3EL (L1TopoCommon/Types.h)
313  topoword.push_back(32*l1topo_dec->clock()+i);
314  uint32_t pos = 32*(l1topo_dec->clock()+(l1topo_dec->connectionId()==2 ? 0 : 2))+i;
315  triggerBitsSim[pos] = ((!decisionBits.triggerBits.has_value() || m_forceCTPasHdw) && m_ctpIds[pos]>=512) ? false : true;
316  }
317  if (l1topo_dec->connectionId()==22 || l1topo_dec->connectionId()==23) { // AMBIGUITYTOPO2EL and AMBIGUITYTOPO3EL
318  uint32_t pos_ambiguity = 32*(l1topo_dec->clock()+(l1topo_dec->connectionId()==22 ? 0 : 2))+i;
319  ambiguityBitsSim[pos_ambiguity] = ((!decisionBits.ambiguityBitsSim.has_value() || m_forceCTPasHdw) && m_ctpIds[pos_ambiguity]>=512) ? false : true;
320  }
321  }
322  if ((l1topo_dec->topoWordOverflow() & mask) !=0) {
323  topowordOverflow.push_back(32*l1topo_dec->clock()+i);
324  uint32_t pus = 32*(l1topo_dec->clock()+(l1topo_dec->connectionId()==12 ? 0 : 2))+i;
325  overflowBitsSim[pus] = ((!decisionBits.overflowBitsSim.has_value() || m_forceCTPasHdw) && m_ctpIds[pus]>=512) ? false : true;
326  }
327  }
328  std::string name = "CableElec_";
329  name += std::to_string(l1topo_dec->connectionId());
330  auto monTopoDec = Monitored::Collection(name, topoword);
331  Monitored::Group(m_monTool,monTopoDec);
332  }
333  else if (l1topo_dec->bitWidth() == 64) {
334  for (size_t i=0;i<64;i++) {
335  unsigned index = i+l1topo_dec->clock()*64;
336  uint64_t mask = 0x1; mask <<= i;
337  if ((l1topo_dec->topoWord64() & mask) !=0) {
338  multWeightsMap[static_cast<unsigned>(l1topo_dec->connectionId() - 4)].set(index);
339  }
340  }
341  }
342  else {
343  ATH_MSG_DEBUG( "Unknown Bit-length: " << l1topo_dec->bitWidth() );
344  return StatusCode::FAILURE;
345  }
346  }
347 
348  for (unsigned key=0;key<4;key++) {
349  std::vector<unsigned> vecCount, vecIndices;
350  unsigned indices = 0;
351  for (auto startbit : m_startbit[key]) {
352  unsigned count = 0;
353  for (size_t i=0;i<startbit.second;i++){
354  if (multWeightsMap[key][startbit.first+i]) {
355  count += 1 * pow(2,i);
356  }
357  }
358  vecCount.push_back(count);
359  vecIndices.push_back(indices);
360  indices++;
361  }
362  multWeights.push_back(vecCount);
363  std::string name = "CableOpti_"+std::to_string(key);
364  auto monMult = Monitored::Collection(name, vecIndices);
365  auto monMultWeight = Monitored::Collection(name+"_weight", vecCount);
366  Monitored::Group(m_monTool,monMult,monMultWeight);
367  }
368 
369  std::vector<size_t> triggerBitIndicesSim = bitsetIndices(triggerBitsSim);
370  std::vector<size_t> overflowBitIndicesSim = bitsetIndices(overflowBitsSim);
371  std::vector<size_t> ambiguityBitIndicesSim = bitsetIndices(ambiguityBitsSim);
372  auto monTopoSim = Monitored::Collection("TopoSim", triggerBitIndicesSim);
373  auto monTopoSimOverflow = Monitored::Collection("TopoSim_overflows", overflowBitIndicesSim);
374  auto monTopoSimAmbiguity = Monitored::Collection("TopoSim_ambiguity", ambiguityBitIndicesSim);
375  Monitored::Group(m_monTool,monTopoSim);
376  Monitored::Group(m_monTool,monTopoSimOverflow);
377  Monitored::Group(m_monTool,monTopoSimAmbiguity);
378 
379  return StatusCode::SUCCESS;
380 }

◆ 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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ fillHistograms()

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

adds event to the monitoring histograms

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

Parameters
ctxforwarded from execute
Returns
StatusCode

Implements AthMonitorAlgorithm.

Definition at line 221 of file L1TopoOnlineMonitor.cxx.

221  {
222 
223  // Create and record the ErrorFlags container
225  ATH_CHECK(errorFlagsCont.record(std::make_unique<xAOD::TrigCompositeContainer>(),
226  std::make_unique<xAOD::TrigCompositeAuxContainer>()));
227  ATH_MSG_DEBUG("Recorded TrigCompositeContainer with key " << m_errorFlagsKey.key());
228 
229  // Create the ErrorFlags object
230  errorFlagsCont->push_back(new xAOD::TrigComposite);
231  xAOD::TrigComposite& errorFlags = *(errorFlagsCont->back());
232  resetFlags(errorFlags);
233 
234 
235  DecisionBits decisionBits{};
236  enum class MonFunction : uint8_t {doSimMon=0, doHwMonCTP, doHwMon, doComp, doMultComp};
237  std::vector<uint8_t> failedMonFunctions;
238  std::vector<std::vector<unsigned>> multWeightsSim;
239  std::vector<std::vector<unsigned>> multWeightsHdw;
240 
241  if (m_doHwMon) {
242  StatusCode sc = doHwMon(decisionBits,multWeightsHdw,ctx);
243  ATH_MSG_DEBUG("Executed doHWMon: " << (sc.isFailure() ? "failed" : "ok"));
244  if (sc.isFailure()) {
245  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doHwMon));
246  }
247  }
248 
249  if (m_doHwMonCTP) {
250  StatusCode sc = doHwMonCTP(decisionBits,ctx);
251  ATH_MSG_DEBUG("Executed doHWMonCTP: " << (sc.isFailure() ? "failed" : "ok"));
252  if (sc.isFailure()) {
253  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doHwMonCTP));
254  }
255  }
256 
257  if (m_doSimMon) {
258  StatusCode sc = doSimMon(decisionBits,multWeightsSim,ctx);
259  ATH_MSG_DEBUG("Executed doSimMon: " << (sc.isFailure() ? "failed" : "ok"));
260  if (sc.isFailure()) {
261  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doSimMon));
262  }
263  }
264 
265  if (m_doComp) {
266  StatusCode sc = doComp(decisionBits,ctx);
267  ATH_MSG_DEBUG("Executed doComp: " << (sc.isFailure() ? "failed" : "ok"));
268  if (sc.isFailure()) {
269  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doComp));
270  }
271  }
272 
273  if (m_doMultComp) {
274  StatusCode sc = doMultComp(multWeightsSim,multWeightsHdw,ctx);
275  ATH_MSG_DEBUG("Executed doMultComp: " << (sc.isFailure() ? "failed" : "ok"));
276  if (sc.isFailure()) {
277  failedMonFunctions.push_back(static_cast<uint8_t>(MonFunction::doMultComp));
278  }
279  }
280 
281  auto monFailedMonFunctions = Monitored::Collection("MonitoringFailures", failedMonFunctions);
282  Monitored::Group(m_monTool, monFailedMonFunctions);
283 
284  return StatusCode::SUCCESS;
285 }

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ getCtpIds()

std::vector< unsigned > L1TopoOnlineMonitor::getCtpIds ( const TrigConf::L1Menu l1menu)
private

Get CTP ids from menu.

Definition at line 793 of file L1TopoOnlineMonitor.cxx.

793  {
794 
795  // Topo
796  std::vector<std::string> connNames = l1menu.connectorNames();
797  std::vector<std::string> labelsTopoEl(s_nTopoCTPOutputs);
798  for( const std::string connName : {"Topo2El", "Topo3El"}) {
799  if( find(connNames.begin(), connNames.end(), connName) == connNames.end() ) {
800  continue;
801  }
802  for(uint fpga : {0,1}) {
803  for(uint clock : {0,1}) {
804  for(auto & tl : l1menu.connector(connName).triggerLines(fpga,clock)) {
805  uint flatIndex = tl.flatindex() + 64 * (connName == "Topo3El");
806  labelsTopoEl[flatIndex] = tl.name();
807  }
808  }
809  }
810  }
811 
812  ATH_MSG_DEBUG("Obtaining CTPIds for Phase1 L1Topo Monitoring");
813  std::vector<unsigned> ctpIds(s_nTopoCTPOutputs,999);
814  for( const auto & item : l1menu ) {
815  std::string definition = item.definition();
816  if (definition.substr(0,5) == "TOPO_" &&
817  definition.find(' ') == std::string::npos) {
818  std::string trigger = definition.substr(0, definition.find('['));
819  auto pos = std::find(labelsTopoEl.begin(),labelsTopoEl.end(),trigger);
820  if (pos != labelsTopoEl.end()) {
821  ATH_MSG_DEBUG("Found one CTP; ,CTPId: " << item.ctpId() << " ,Name: " << item.name() << " ,Definition: " << definition);
822  unsigned index = std::distance(labelsTopoEl.begin(),pos);
823  ctpIds[index]=item.ctpId();
824  }
825  }
826  }
827 
828  return ctpIds;
829 }

◆ 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  // treat empty tool handle case as in Monitored::Group
172  if (m_toolLookupMap.empty()) {
173  return m_dummy;
174  }
175 
176  if (!isInitialized()) {
178  "It seems that the AthMonitorAlgorithm::initialize was not called "
179  "in derived class initialize method");
180  } else {
181  std::string available = std::accumulate(
182  m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
183  [](const std::string& s, auto h) { return s + "," + h.first; });
184  ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
185  << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
186  << "your python configuration and c++ filling code. Note: your available groups are {"
187  << available << "}.");
188  }
189  }
190  return m_dummy;
191 }

◆ getStartBits()

std::vector< std::vector< std::pair< unsigned, unsigned > > > L1TopoOnlineMonitor::getStartBits ( const TrigConf::L1Menu l1menu)
private

Definition at line 775 of file L1TopoOnlineMonitor.cxx.

775  {
776 
777  std::vector<std::vector<std::pair<unsigned,unsigned>>> startbit_vec;
778  std::vector<std::string> connNames = l1menu.connectorNames();
779  for( const std::string connName : {"Topo1Opt0", "Topo1Opt1", "Topo1Opt2", "Topo1Opt3"}) {
780  if( find(connNames.begin(), connNames.end(), connName) == connNames.end() ) {
781  continue;
782  }
783  std::vector<std::pair<unsigned,unsigned>> startbit;
784  for(auto & t1 : l1menu.connector(connName).triggerLines()) {
785  startbit.push_back(std::make_pair(t1.startbit(),t1.nbits()));
786  }
787  startbit_vec.push_back(startbit);
788  }
789  return startbit_vec;
790 }

◆ 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 194 of file AthMonitorAlgorithm.cxx.

194  {
195  return m_trigDecTool;
196 }

◆ initialize()

StatusCode L1TopoOnlineMonitor::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 45 of file L1TopoOnlineMonitor.cxx.

45  {
46 
47  m_rateHdwNotSim.reset(new float[s_nTopoCTPOutputs]);
48  m_rateSimNotHdw.reset(new float[s_nTopoCTPOutputs]);
49  m_rateHdwAndSim.reset(new float[s_nTopoCTPOutputs]);
50  m_rateHdwSim.reset(new float[s_nTopoCTPOutputs]);
51  m_countHdwNotSim.reset(new float[s_nTopoCTPOutputs]);
52  m_countSimNotHdw.reset(new float[s_nTopoCTPOutputs]);
53  m_countHdwSim.reset(new float[s_nTopoCTPOutputs]);
54  m_countHdw.reset(new float[s_nTopoCTPOutputs]);
55  m_countSim.reset(new float[s_nTopoCTPOutputs]);
56  m_countAny.reset(new float[s_nTopoCTPOutputs]);
60  m_overflow_rateHdwSim.reset(new float[s_nTopoCTPOutputs]);
63  m_overflow_countHdwSim.reset(new float[s_nTopoCTPOutputs]);
64  m_overflow_countHdw.reset(new float[s_nTopoCTPOutputs]);
65  m_overflow_countSim.reset(new float[s_nTopoCTPOutputs]);
66  m_overflow_countAny.reset(new float[s_nTopoCTPOutputs]);
67 
68  m_currentHdwBit.reset(new float[s_nTopoCTPOutputs]);
69  m_currentSimBit.reset(new float[s_nTopoCTPOutputs]);
70 
71  for (size_t i=0;i<s_nTopoCTPOutputs;i++){
72  m_rateHdwNotSim[i] = 0;
73  m_rateSimNotHdw[i] = 0;
74  m_rateHdwAndSim[i] = 0;
75  m_rateHdwSim[i] = 0;
76  m_countHdwNotSim[i] = 0;
77  m_countSimNotHdw[i] = 0;
78  m_countHdwSim[i] = 0;
79  m_countHdw[i] = 0;
80  m_countSim[i] = 0;
81  m_countAny[i] = 0;
92 
93  m_currentHdwBit[i] = 0;
94  m_currentSimBit[i] = 0;
95  }
96 
97  ATH_CHECK(m_l1topoKey.initialize());
100  ATH_CHECK(m_monTool.retrieve(DisableTool{m_monTool.name().empty()}));
101  ATH_CHECK(m_errorFlagsKey.initialize());
102 
103  const TrigConf::L1Menu * l1menu = nullptr;
104  ATH_CHECK( m_detStore->retrieve(l1menu) );
105 
106  auto & conn2EL = l1menu->connector("Topo2El");
107  auto & conn3EL = l1menu->connector("Topo3El");
108 
109  auto & connOpt0 = l1menu->connector("Topo1Opt0");
110  auto & connOpt1 = l1menu->connector("Topo1Opt1");
111  auto & connOpt2 = l1menu->connector("Topo1Opt2");
112  auto & connOpt3 = l1menu->connector("Topo1Opt3");
113 
114  m_TopoAlgTriggerNames.reserve(32*4);
115  m_TopoAlgTriggerNotVetoed.resize(32*4);
116  m_TopoMultTriggerNames.reserve(64*4);
117  m_TopoMultTriggerNotVetoed.resize(64*4);
118 
119  //TopoOpt
120  auto & tlopt0 = connOpt0.triggerLines();
121  auto & tlopt1 = connOpt1.triggerLines();
122  auto & tlopt2 = connOpt2.triggerLines();
123  auto & tlopt3 = connOpt3.triggerLines();
124 
125  long unsigned int size_tlopt0 = tlopt0.size();
126  long unsigned int size_tlopt1 = tlopt1.size();
127  long unsigned int size_tlopt2 = tlopt2.size();
128  long unsigned int size_tlopt3 = tlopt3.size();
129 
130  long unsigned int total_size_opt = size_tlopt0+size_tlopt1+size_tlopt2+size_tlopt3;
131 
132  for (size_t j = 0; j < size_tlopt0; ++j) m_TopoMultTriggerNames.push_back(tlopt0[j].name());
133  for (size_t j = 0; j < size_tlopt1; ++j) m_TopoMultTriggerNames.push_back(tlopt1[j].name());
134  for (size_t j = 0; j < size_tlopt2; ++j) m_TopoMultTriggerNames.push_back(tlopt2[j].name());
135  for (size_t j = 0; j < size_tlopt3; ++j) m_TopoMultTriggerNames.push_back(tlopt3[j].name());
136 
137  //Topo2a
138  auto & tl2a0 = conn2EL.triggerLines(0, 0); //clock 0
139  auto & tl2a1 = conn2EL.triggerLines(0, 1); //clock 1
140  long unsigned int size_tl2a0 = tl2a0.size();
141  long unsigned int size_tl2a1 = tl2a1.size();
142  //Topo2b
143  auto & tl2b0 = conn2EL.triggerLines(1, 0); //clock 0
144  auto & tl2b1 = conn2EL.triggerLines(1, 1); //clock 1
145  long unsigned int size_tl2b0 = tl2b0.size();
146  long unsigned int size_tl2b1 = tl2b1.size();
147  //Topo3a
148  auto & tl3a0 = conn3EL.triggerLines(0, 0); //clock 0
149  auto & tl3a1 = conn3EL.triggerLines(0, 1); //clock 1
150  long unsigned int size_tl3a0 = tl3a0.size();
151  long unsigned int size_tl3a1 = tl3a1.size();
152  //Topo3b
153  auto & tl3b0 = conn3EL.triggerLines(1, 0); //clock 0
154  auto & tl3b1 = conn3EL.triggerLines(1, 1); //clock 1
155  long unsigned int size_tl3b0 = tl3b0.size();
156  long unsigned int size_tl3b1 = tl3b1.size();
157 
158  for (size_t i = 0; i < 16; ++i) {
159  if (i < size_tl2a0) m_TopoAlgTriggerNames.push_back(tl2a0[i].name());
160  else m_TopoAlgTriggerNames.push_back("Empty");
161  if (i < size_tl2a1) m_TopoAlgTriggerNames.push_back(tl2a1[i].name());
162  else m_TopoAlgTriggerNames.push_back("Empty");
163  }
164 
165  for (size_t i = 0; i < 16; ++i) {
166  if (i < size_tl2b0) m_TopoAlgTriggerNames.push_back(tl2b0[i].name());
167  else m_TopoAlgTriggerNames.push_back("Empty");
168  if (i < size_tl2b1) m_TopoAlgTriggerNames.push_back(tl2b1[i].name());
169  else m_TopoAlgTriggerNames.push_back("Empty");
170  }
171 
172  for (size_t i = 0; i < 16; ++i) {
173  if (i < size_tl3a0) m_TopoAlgTriggerNames.push_back(tl3a0[i].name());
174  else m_TopoAlgTriggerNames.push_back("Empty");
175  if (i < size_tl3a1) m_TopoAlgTriggerNames.push_back(tl3a1[i].name());
176  else m_TopoAlgTriggerNames.push_back("Empty");
177  }
178 
179  for (size_t i = 0; i < 16; ++i) {
180  if (i < size_tl3b0) m_TopoAlgTriggerNames.push_back(tl3b0[i].name());
181  else m_TopoAlgTriggerNames.push_back("Empty");
182  if (i < size_tl3b1) m_TopoAlgTriggerNames.push_back(tl3b1[i].name());
183  else m_TopoAlgTriggerNames.push_back("Empty");
184  }
185 
186  //Fill Vector of booleans to fill corresponding triggers
187  //Only elements with a corresponding Veto are set to false
188 
189  for (size_t j = 0; j < total_size_opt; ++j) {
190  m_TopoMultTriggerNotVetoed[j] = true;
191  for (const std::string& VetoedElement : m_MultiplicityVetoList) {
192  if ( !m_TopoMultTriggerNotVetoed[j] || m_TopoMultTriggerNames[j].find(VetoedElement)!= std::string::npos) m_TopoMultTriggerNotVetoed[j] = false;
193  else m_TopoMultTriggerNotVetoed[j] = true;
194  }
195  }
196 
197  for (int j =0; j<128;j++){
198  m_TopoAlgTriggerNotVetoed[j] = true;
199  for (const std::string& VetoedElement : m_AlgorithmVetoList) {
200  if ( !m_TopoAlgTriggerNotVetoed[j] || m_TopoAlgTriggerNames[j].find(VetoedElement)!= std::string::npos) m_TopoAlgTriggerNotVetoed[j] = false;
201  else m_TopoAlgTriggerNotVetoed[j] = true;
202  }
203  }
204 
206 }

◆ 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ 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 341 of file AthMonitorAlgorithm.cxx.

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

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

◆ resetFlags()

void L1TopoOnlineMonitor::resetFlags ( xAOD::TrigComposite errorFlags) const
private

Definition at line 831 of file L1TopoOnlineMonitor.cxx.

831  {
832  errorFlags.setDetail("hasTrivialFlag", true);
833 }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ start()

StatusCode L1TopoOnlineMonitor::start ( )
overridevirtual

Definition at line 208 of file L1TopoOnlineMonitor.cxx.

208  {
209 
210  const TrigConf::L1Menu * l1menu = nullptr;
211  ATH_CHECK( m_detStore->retrieve(l1menu) );
212 
214 
216 
217  return StatusCode::SUCCESS;
218 }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ trigChainsArePassed()

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

Check whether triggers are passed.

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

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

Definition at line 199 of file AthMonitorAlgorithm.cxx.

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

◆ 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

◆ m_AlgorithmVetoList

Gaudi::Property<std::vector<std::string> > L1TopoOnlineMonitor::m_AlgorithmVetoList
private
Initial value:
{
this, "AlgorithmVetoList", {}, "List of L1Topo algorithm items Vetoed for monitoring in L1CaloDQ package due to known Sim/Hdw mismatches"}

Definition at line 121 of file L1TopoOnlineMonitor.h.

◆ m_countAny

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_countAny
private

Definition at line 80 of file L1TopoOnlineMonitor.h.

◆ m_countHdw

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_countHdw
private

Definition at line 78 of file L1TopoOnlineMonitor.h.

◆ m_countHdwNotSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_countHdwNotSim
private

Definition at line 75 of file L1TopoOnlineMonitor.h.

◆ m_countHdwSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_countHdwSim
private

Definition at line 77 of file L1TopoOnlineMonitor.h.

◆ m_countSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_countSim
private

Definition at line 79 of file L1TopoOnlineMonitor.h.

◆ m_countSimNotHdw

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_countSimNotHdw
private

Definition at line 76 of file L1TopoOnlineMonitor.h.

◆ m_ctpIds

std::vector<unsigned> L1TopoOnlineMonitor::m_ctpIds
private

Definition at line 95 of file L1TopoOnlineMonitor.h.

◆ m_ctpRdoKey

SG::ReadHandleKey<CTP_RDO> L1TopoOnlineMonitor::m_ctpRdoKey
private
Initial value:
{
this, "CTPRDOLocation", LVL1CTP::DEFAULT_RDOOutputLocation,
"Key of the CTP RDO object"}

Definition at line 136 of file L1TopoOnlineMonitor.h.

◆ m_currentHdwBit

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_currentHdwBit
private

Definition at line 92 of file L1TopoOnlineMonitor.h.

◆ m_currentSimBit

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_currentSimBit
private

Definition at line 93 of file L1TopoOnlineMonitor.h.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 351 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

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

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

Definition at line 353 of file AthMonitorAlgorithm.h.

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 360 of file AthMonitorAlgorithm.h.

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_detStore

ServiceHandle<StoreGateSvc> L1TopoOnlineMonitor::m_detStore { this, "DetectorStore", "StoreGateSvc/DetectorStore", "Detector store to get the menu" }
private

Definition at line 126 of file L1TopoOnlineMonitor.h.

◆ m_doComp

Gaudi::Property<bool> L1TopoOnlineMonitor::m_doComp
private
Initial value:
{
this, "doComp", true, "Enable L1Topo HW/Sim comparison"}

Definition at line 115 of file L1TopoOnlineMonitor.h.

◆ m_doHwErrorMon

Gaudi::Property<bool> L1TopoOnlineMonitor::m_doHwErrorMon
private
Initial value:
{
this, "doHwErrorMon", false, "Enable L1Topo HW Error monitoring"}

Definition at line 113 of file L1TopoOnlineMonitor.h.

◆ m_doHwMon

Gaudi::Property<bool> L1TopoOnlineMonitor::m_doHwMon
private
Initial value:
{
this, "doHwMon", true, "Enable L1Topo HW readout from RAW"}

Definition at line 111 of file L1TopoOnlineMonitor.h.

◆ m_doHwMonCTP

Gaudi::Property<bool> L1TopoOnlineMonitor::m_doHwMonCTP
private
Initial value:
{
this, "doHwMonCTP", true, "Enable L1Topo HW readout from CTP"}

Definition at line 109 of file L1TopoOnlineMonitor.h.

◆ m_doMultComp

Gaudi::Property<bool> L1TopoOnlineMonitor::m_doMultComp
private
Initial value:
{
this, "doMultComp", false, "Enable L1Topo Multiplicity HW/Sim comparison"}

Definition at line 117 of file L1TopoOnlineMonitor.h.

◆ m_doSimMon

Gaudi::Property<bool> L1TopoOnlineMonitor::m_doSimMon
private
Initial value:
{
this, "doSimMon", true, "Enable L1Topo simulation decision monitoring"}

Definition at line 107 of file L1TopoOnlineMonitor.h.

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_enforceExpressTriggers

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

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 350 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

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

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

Definition at line 352 of file AthMonitorAlgorithm.h.

◆ m_errorFlagsKey

SG::WriteHandleKey<xAOD::TrigCompositeContainer> L1TopoOnlineMonitor::m_errorFlagsKey
private
Initial value:
{
this, "ErrorFlagsKey", "L1TopoErrorFlags",
"Key of the output TrigCompositeContainer with L1Topo error flags"}

Definition at line 104 of file L1TopoOnlineMonitor.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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.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_forceCTPasHdw

Gaudi::Property<bool> L1TopoOnlineMonitor::m_forceCTPasHdw
private
Initial value:
{
this, "forceCTPasHdw", false, "Force to CTP monitoring as primary in Sim/Hdw comparison"}

Definition at line 119 of file L1TopoOnlineMonitor.h.

◆ m_l1topoKey

SG::ReadHandleKey<xAOD::L1TopoSimResultsContainer> L1TopoOnlineMonitor::m_l1topoKey
private
Initial value:
{
this, "L1_TopoKey", "L1_TopoSimResults", "l1topo EDM"}

Definition at line 129 of file L1TopoOnlineMonitor.h.

◆ m_l1topoRawDataKey

SG::ReadHandleKey<xAOD::L1TopoRawDataContainer> L1TopoOnlineMonitor::m_l1topoRawDataKey
private
Initial value:
{
this, "L1_TopoRawDataKey", "L1_Phase1L1TopoRAWData", "l1topo Raw Data"}

Definition at line 132 of file L1TopoOnlineMonitor.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_monTool

ToolHandle<GenericMonitoringTool> L1TopoOnlineMonitor::m_monTool
private
Initial value:
{
this, "MonTool", "" ,
"Monitoring tool to create online histograms"}

Definition at line 101 of file L1TopoOnlineMonitor.h.

◆ m_MultiplicityVetoList

Gaudi::Property<std::vector<std::string> > L1TopoOnlineMonitor::m_MultiplicityVetoList
private
Initial value:
{
this, "MultiplicityVetoList", {}, "List of multiplicity items Vetoed for monitoring in L1CaloDQ package due to known Sim/Hdw mismatches"}

Definition at line 123 of file L1TopoOnlineMonitor.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_overflow_countAny

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_countAny
private

Definition at line 90 of file L1TopoOnlineMonitor.h.

◆ m_overflow_countHdw

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_countHdw
private

Definition at line 88 of file L1TopoOnlineMonitor.h.

◆ m_overflow_countHdwNotSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_countHdwNotSim
private

Definition at line 85 of file L1TopoOnlineMonitor.h.

◆ m_overflow_countHdwSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_countHdwSim
private

Definition at line 87 of file L1TopoOnlineMonitor.h.

◆ m_overflow_countSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_countSim
private

Definition at line 89 of file L1TopoOnlineMonitor.h.

◆ m_overflow_countSimNotHdw

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_countSimNotHdw
private

Definition at line 86 of file L1TopoOnlineMonitor.h.

◆ m_overflow_rateHdwAndSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_rateHdwAndSim
private

Definition at line 83 of file L1TopoOnlineMonitor.h.

◆ m_overflow_rateHdwNotSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_rateHdwNotSim
private

Definition at line 81 of file L1TopoOnlineMonitor.h.

◆ m_overflow_rateHdwSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_rateHdwSim
private

Definition at line 84 of file L1TopoOnlineMonitor.h.

◆ m_overflow_rateSimNotHdw

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_overflow_rateSimNotHdw
private

Definition at line 82 of file L1TopoOnlineMonitor.h.

◆ m_rateHdwAndSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_rateHdwAndSim
private

Definition at line 73 of file L1TopoOnlineMonitor.h.

◆ m_rateHdwNotSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_rateHdwNotSim
private

Definition at line 71 of file L1TopoOnlineMonitor.h.

◆ m_rateHdwSim

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_rateHdwSim
private

Definition at line 74 of file L1TopoOnlineMonitor.h.

◆ m_rateSimNotHdw

std::unique_ptr<float[]> L1TopoOnlineMonitor::m_rateSimNotHdw
private

Definition at line 72 of file L1TopoOnlineMonitor.h.

◆ m_startbit

std::vector<std::vector<std::pair<unsigned,unsigned> > > L1TopoOnlineMonitor::m_startbit
private

Definition at line 97 of file L1TopoOnlineMonitor.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_TopoAlgTriggerNames

std::vector<std::string> L1TopoOnlineMonitor::m_TopoAlgTriggerNames
private

Definition at line 66 of file L1TopoOnlineMonitor.h.

◆ m_TopoAlgTriggerNotVetoed

std::vector<bool> L1TopoOnlineMonitor::m_TopoAlgTriggerNotVetoed
private

Definition at line 67 of file L1TopoOnlineMonitor.h.

◆ m_TopoMultTriggerNames

std::vector<std::string> L1TopoOnlineMonitor::m_TopoMultTriggerNames
private

Definition at line 68 of file L1TopoOnlineMonitor.h.

◆ m_TopoMultTriggerNotVetoed

std::vector<bool> L1TopoOnlineMonitor::m_TopoMultTriggerNotVetoed
private

Definition at line 69 of file L1TopoOnlineMonitor.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.

◆ s_nTopoCTPOutputs

constexpr size_t L1TopoOnlineMonitor::s_nTopoCTPOutputs {128}
staticconstexprprivate

Number of CTP outputs, used for histogram ranges and loops.

Definition at line 49 of file L1TopoOnlineMonitor.h.


The documentation for this class was generated from the following files:
L1TopoOnlineMonitor::m_l1topoKey
SG::ReadHandleKey< xAOD::L1TopoSimResultsContainer > m_l1topoKey
Definition: L1TopoOnlineMonitor.h:129
L1TopoOnlineMonitor::m_MultiplicityVetoList
Gaudi::Property< std::vector< std::string > > m_MultiplicityVetoList
Definition: L1TopoOnlineMonitor.h:123
L1TopoOnlineMonitor::doHwMonCTP
StatusCode doHwMonCTP(DecisionBits &decisionBits, const EventContext &ctx) const
Monitor the Hw bits from CTP.
Definition: L1TopoOnlineMonitor.cxx:382
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
xAOD::TrigComposite_v1::setDetail
bool setDetail(const std::string &name, const TYPE &value)
Set an TYPE detail on the object.
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
L1TopoOnlineMonitor::m_overflow_rateHdwNotSim
std::unique_ptr< float[]> m_overflow_rateHdwNotSim
Definition: L1TopoOnlineMonitor.h:81
get_generator_info.result
result
Definition: get_generator_info.py:21
L1TopoOnlineMonitor::m_countSimNotHdw
std::unique_ptr< float[]> m_countSimNotHdw
Definition: L1TopoOnlineMonitor.h:76
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
L1TopoOnlineMonitor::DecisionBits::createBits
static std::bitset< s_nTopoCTPOutputs > & createBits(std::optional< std::bitset< s_nTopoCTPOutputs >> &opt)
Helper method to create a new bitset and get a reference to it.
Definition: L1TopoOnlineMonitor.h:60
L1TopoOnlineMonitor::m_doHwMonCTP
Gaudi::Property< bool > m_doHwMonCTP
Definition: L1TopoOnlineMonitor.h:109
L1TopoOnlineMonitor::getStartBits
std::vector< std::vector< std::pair< unsigned, unsigned > > > getStartBits(const TrigConf::L1Menu &l1menu)
Definition: L1TopoOnlineMonitor.cxx:775
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
L1Topo::L1TopoResult::getFPGASize
unsigned getFPGASize()
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:53
L1TopoOnlineMonitor::m_AlgorithmVetoList
Gaudi::Property< std::vector< std::string > > m_AlgorithmVetoList
Definition: L1TopoOnlineMonitor.h:121
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
L1TopoOnlineMonitor::resetFlags
void resetFlags(xAOD::TrigComposite &errorFlags) const
Definition: L1TopoOnlineMonitor.cxx:831
L1TopoOnlineMonitor::m_doHwErrorMon
Gaudi::Property< bool > m_doHwErrorMon
Definition: L1TopoOnlineMonitor.h:113
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
L1Topo::L1TopoResult::getTopo1Opt0
const std::bitset< s_nTopoOutputs > & getTopo1Opt0() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:47
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
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
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
L1TopoOnlineMonitor::m_overflow_countHdwNotSim
std::unique_ptr< float[]> m_overflow_countHdwNotSim
Definition: L1TopoOnlineMonitor.h:85
ALFA_EventTPCnv_Dict::t1
std::vector< ALFA_RawDataCollection_p1 > t1
Definition: ALFA_EventTPCnvDict.h:43
L1TopoOnlineMonitor::m_doSimMon
Gaudi::Property< bool > m_doSimMon
Definition: L1TopoOnlineMonitor.h:107
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
L1TopoOnlineMonitor::m_startbit
std::vector< std::vector< std::pair< unsigned, unsigned > > > m_startbit
Definition: L1TopoOnlineMonitor.h:97
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
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
L1TopoOnlineMonitor::m_currentHdwBit
std::unique_ptr< float[]> m_currentHdwBit
Definition: L1TopoOnlineMonitor.h:92
TrigConf::L1Menu
L1 menu configuration.
Definition: L1Menu.h:28
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
L1TopoOnlineMonitor::m_overflow_countHdwSim
std::unique_ptr< float[]> m_overflow_countHdwSim
Definition: L1TopoOnlineMonitor.h:87
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:199
XMLtoHeader.count
count
Definition: XMLtoHeader.py:84
AthMonitorAlgorithm::Environment_t::user
@ user
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:459
L1TopoOnlineMonitor::m_countSim
std::unique_ptr< float[]> m_countSim
Definition: L1TopoOnlineMonitor.h:79
CTP_Decoder
Definition: CTP_Decoder.h:141
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
L1TopoOnlineMonitor::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: L1TopoOnlineMonitor.h:101
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
L1TopoOnlineMonitor::m_overflow_countHdw
std::unique_ptr< float[]> m_overflow_countHdw
Definition: L1TopoOnlineMonitor.h:88
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
L1TopoOnlineMonitor::m_rateHdwSim
std::unique_ptr< float[]> m_rateHdwSim
Definition: L1TopoOnlineMonitor.h:74
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition: AthMonitorAlgorithm.h:341
L1TopoOnlineMonitor::m_rateHdwAndSim
std::unique_ptr< float[]> m_rateHdwAndSim
Definition: L1TopoOnlineMonitor.h:73
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
L1TopoOnlineMonitor::m_countAny
std::unique_ptr< float[]> m_countAny
Definition: L1TopoOnlineMonitor.h:80
L1TopoOnlineMonitor::m_ctpIds
std::vector< unsigned > m_ctpIds
Definition: L1TopoOnlineMonitor.h:95
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:85
L1Topo::L1TopoResult::getTopo1Opt2
const std::bitset< s_nTopoOutputs > & getTopo1Opt2() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:49
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
L1TopoOnlineMonitor::m_rateSimNotHdw
std::unique_ptr< float[]> m_rateSimNotHdw
Definition: L1TopoOnlineMonitor.h:72
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
CTP_BC
Definition: CTP_Decoder.h:17
L1TopoOnlineMonitor::s_nTopoCTPOutputs
static constexpr size_t s_nTopoCTPOutputs
Number of CTP outputs, used for histogram ranges and loops.
Definition: L1TopoOnlineMonitor.h:49
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:108
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
L1TopoOnlineMonitor::m_overflow_rateSimNotHdw
std::unique_ptr< float[]> m_overflow_rateSimNotHdw
Definition: L1TopoOnlineMonitor.h:82
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
L1TopoOnlineMonitor::doHwMon
StatusCode doHwMon(DecisionBits &decisionBits, std::vector< std::vector< unsigned >> &multWeights, const EventContext &ctx) const
Monitor the Hw bits from RAW data.
Definition: L1TopoOnlineMonitor.cxx:423
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
L1TopoOnlineMonitor::m_doMultComp
Gaudi::Property< bool > m_doMultComp
Definition: L1TopoOnlineMonitor.h:117
L1TopoOnlineMonitor::m_rateHdwNotSim
std::unique_ptr< float[]> m_rateHdwNotSim
Definition: L1TopoOnlineMonitor.h:71
L1TopoOnlineMonitor::doSimMon
StatusCode doSimMon(DecisionBits &decisionBits, std::vector< std::vector< unsigned >> &multWeights, const EventContext &ctx) const
Monitor the simulated bits.
Definition: L1TopoOnlineMonitor.cxx:288
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:545
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
L1TopoOnlineMonitor::m_countHdwNotSim
std::unique_ptr< float[]> m_countHdwNotSim
Definition: L1TopoOnlineMonitor.h:75
L1TopoOnlineMonitor::m_detStore
ServiceHandle< StoreGateSvc > m_detStore
Definition: L1TopoOnlineMonitor.h:126
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
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
L1TopoOnlineMonitor::doComp
StatusCode doComp(DecisionBits &decisionBits, const EventContext &ctx) const
Compare hardware and simulation.
Definition: L1TopoOnlineMonitor.cxx:581
L1Topo::L1TopoResult::getDecisions
const std::bitset< s_nTopoOutputs > & getDecisions() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:45
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
L1Topo::L1TopoResult::getOverflows
const std::bitset< s_nTopoOutputs > & getOverflows() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:46
CxxUtils::set
constexpr std::enable_if_t< is_bitmask_v< E >, E & > set(E &lhs, E rhs)
Convenience function to set bits in a class enum bitmask.
Definition: bitmask.h:232
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
L1Topo::L1TopoResult::getTopo1Opt1
const std::bitset< s_nTopoOutputs > & getTopo1Opt1() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:48
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
L1TopoOnlineMonitor::m_overflow_countSim
std::unique_ptr< float[]> m_overflow_countSim
Definition: L1TopoOnlineMonitor.h:89
L1TopoOnlineMonitor::m_overflow_countSimNotHdw
std::unique_ptr< float[]> m_overflow_countSimNotHdw
Definition: L1TopoOnlineMonitor.h:86
AthMonitorAlgorithm::Environment_t::online
@ online
L1TopoOnlineMonitor::m_currentSimBit
std::unique_ptr< float[]> m_currentSimBit
Definition: L1TopoOnlineMonitor.h:93
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
CTP_BC::getTBP
const std::bitset< 512 > & getTBP() const
get bitset of TBP words
Definition: CTP_Decoder.h:92
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
L1Topo::L1TopoResult::getFPGA
const std::shared_ptr< L1Topo::L1TopoFPGA > & getFPGA(unsigned index) const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:44
item
Definition: ItemListSvc.h:43
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
L1TopoOnlineMonitor::m_overflow_rateHdwAndSim
std::unique_ptr< float[]> m_overflow_rateHdwAndSim
Definition: L1TopoOnlineMonitor.h:83
L1TopoOnlineMonitor::m_forceCTPasHdw
Gaudi::Property< bool > m_forceCTPasHdw
Definition: L1TopoOnlineMonitor.h:119
TriggerTest.ctp
ctp
Retrieve trigger EDM objects.
Definition: TriggerTest.py:14
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
L1TopoOnlineMonitor::m_doComp
Gaudi::Property< bool > m_doComp
Definition: L1TopoOnlineMonitor.h:115
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
DeMoScan.index
string index
Definition: DeMoScan.py:362
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:60
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
L1TopoOnlineMonitor::m_TopoMultTriggerNames
std::vector< std::string > m_TopoMultTriggerNames
Definition: L1TopoOnlineMonitor.h:68
L1TopoOnlineMonitor::m_overflow_countAny
std::unique_ptr< float[]> m_overflow_countAny
Definition: L1TopoOnlineMonitor.h:90
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
L1TopoOnlineMonitor::m_TopoAlgTriggerNotVetoed
std::vector< bool > m_TopoAlgTriggerNotVetoed
Definition: L1TopoOnlineMonitor.h:67
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
L1TopoOnlineMonitor::m_TopoMultTriggerNotVetoed
std::vector< bool > m_TopoMultTriggerNotVetoed
Definition: L1TopoOnlineMonitor.h:69
L1TopoOnlineMonitor::m_TopoAlgTriggerNames
std::vector< std::string > m_TopoAlgTriggerNames
Definition: L1TopoOnlineMonitor.h:66
python.XMLReader.l1menu
l1menu
Definition: XMLReader.py:73
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: AthMonitorAlgorithm.cxx:7
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
L1Topo::L1TopoResult::getStatus
bool getStatus()
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:51
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
L1Topo::L1TopoResult::getROD
const std::shared_ptr< L1Topo::L1TopoROD > & getROD(unsigned index) const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:43
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
dqt_zlumi_alleff_HIST.tl
tl
Definition: dqt_zlumi_alleff_HIST.py:73
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
L1TopoOnlineMonitor::getCtpIds
std::vector< unsigned > getCtpIds(const TrigConf::L1Menu &l1menu)
Get CTP ids from menu.
Definition: L1TopoOnlineMonitor.cxx:793
L1TopoOnlineMonitor::m_ctpRdoKey
SG::ReadHandleKey< CTP_RDO > m_ctpRdoKey
Definition: L1TopoOnlineMonitor.h:136
L1TopoOnlineMonitor::m_l1topoRawDataKey
SG::ReadHandleKey< xAOD::L1TopoRawDataContainer > m_l1topoRawDataKey
Definition: L1TopoOnlineMonitor.h:132
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:328
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
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
L1TopoOnlineMonitor::m_countHdw
std::unique_ptr< float[]> m_countHdw
Definition: L1TopoOnlineMonitor.h:78
L1Topo::L1TopoResult::getTopo1Opt3
const std::bitset< s_nTopoOutputs > & getTopo1Opt3() const
Definition: L1Topo/L1TopoRDO/L1TopoRDO/L1TopoResult.h:50
L1TopoOnlineMonitor::doMultComp
StatusCode doMultComp(std::vector< std::vector< unsigned >> &multWeightsSim, std::vector< std::vector< unsigned >> &multWeightsHdw, const EventContext &ctx) const
Compare hardware and simulation for the multiplicity algorithms.
Definition: L1TopoOnlineMonitor.cxx:742
L1TopoOnlineMonitor::m_doHwMon
Gaudi::Property< bool > m_doHwMon
Definition: L1TopoOnlineMonitor.h:111
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
L1TopoOnlineMonitor::m_countHdwSim
std::unique_ptr< float[]> m_countHdwSim
Definition: L1TopoOnlineMonitor.h:77
fitman.k
k
Definition: fitman.py:528
L1TopoOnlineMonitor::m_overflow_rateHdwSim
std::unique_ptr< float[]> m_overflow_rateHdwSim
Definition: L1TopoOnlineMonitor.h:84
ServiceHandle< ICondSvc >
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
collisions
Definition: collisions.py:1
L1TopoOnlineMonitor::m_errorFlagsKey
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_errorFlagsKey
Definition: L1TopoOnlineMonitor.h:104