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

#include <TrigBjetMonitorAlgorithm.h>

Inheritance diagram for TrigBjetMonitorAlgorithm:
Collaboration diagram for TrigBjetMonitorAlgorithm:

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

 TrigBjetMonitorAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TrigBjetMonitorAlgorithm ()
 
virtual StatusCode initialize () override
 initialize More...
 
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::EventInfo > GetEventInfo (const EventContext &) const
 Return a ReadHandle for an EventInfo object (get run/event numbers, etc.) More...
 
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average mu, i.e. More...
 
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate instantaneous number of interactions, i.e. More...
 
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1). More...
 
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the instantaneous luminosity per bunch crossing. More...
 
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the duration of the luminosity block (in seconds) More...
 
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average luminosity livefraction. More...
 
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the live fraction per bunch crossing ID. More...
 
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average integrated luminosity multiplied by the live fraction. More...
 
virtual StatusCode parseList (const std::string &line, std::vector< std::string > &result) const
 Parse a string into a vector. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, 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< GenericMonitoringTool > m_tools {this,"GMTools",{}}
 Array of Generic Monitoring Tools. More...
 
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool {this, "TrigDecisionTool",""}
 Tool to tell whether a specific trigger is passed. More...
 
ToolHandleArray< IDQFilterTool > m_DQFilterTools {this,"FilterTools",{}}
 Array of Data Quality filter tools. More...
 
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}
 
AthMonitorAlgorithm::Environment_t m_environment
 Instance of the Environment_t enum. More...
 
AthMonitorAlgorithm::DataType_t m_dataType
 Instance of the DataType_t enum. More...
 
Gaudi::Property< std::string > m_environmentStr {this,"Environment","user"}
 Environment string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_dataTypeStr {this,"DataType","userDefined"}
 DataType string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_triggerChainString {this,"TriggerChain",""}
 Trigger chain string pulled from the job option and parsed into a vector. More...
 
std::vector< std::string > m_vTrigChainNames
 Vector of trigger chain names parsed from trigger chain string. More...
 
Gaudi::Property< std::string > m_fileKey {this,"FileKey",""}
 Internal Athena name for file. More...
 
Gaudi::Property< bool > m_useLumi {this,"EnableLumi",false}
 Allows use of various luminosity functions. More...
 
Gaudi::Property< float > m_defaultLBDuration {this,"DefaultLBDuration",60.}
 Default duration of one lumi block. More...
 
Gaudi::Property< int > m_detailLevel {this,"DetailLevel",0}
 Sets the level of detail used in the monitoring. More...
 
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey {this,"EventInfoKey","EventInfo"}
 Key for retrieving EventInfo from StoreGate. More...
 

Private Types

typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, 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

Gaudi::Property< bool > m_collisionRun {this, "CollisionRun", true}
 
Gaudi::Property< std::string > m_btaggingLinkName {this, "BtaggingLinkName", "btag"}
 
Gaudi::Property< bool > m_expressStreamFlag {this, "ExpressStreamFlag", false}
 
Gaudi::Property< std::vector< std::string > > m_allChains {this,"AllChains",{}}
 
SG::ReadHandleKey< xAOD::MuonContainer > m_muonContainerKey {this, "MuonContainerName", "Muons", "Muon Container Name"}
 
SG::ReadHandleKey< xAOD::VertexContainer > m_offlineVertexContainerKey {this, "OfflineVertexContainerName", "PrimaryVertices", "Key of offline primary vertexes"}
 
SG::ReadHandleKey< xAOD::VertexContainer > m_onlineVertexContainerKey {this, "OnlineVertexContainerName", "HLT_IDVertex_FS", "Key of online bjet primary vertexes"}
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_onlineTrackContainerKey {this, "OnlineTrackContainerName", "HLT_IDTrack_Bjet_IDTrig", "Key of online tracks of bjets"}
 
SG::ReadHandleKey< xAOD::JetContainer > m_onlineEMPFlowBJetContainerKey {this, "OnlineEMPFlowBJetContainerKey", "HLT_AntiKt4EMPFlowJets_subresjesgscIS_ftf_bJets", "Key of online EMPFlow bjets"}
 
SG::ReadHandleKey< xAOD::JetContainer > m_onlineEMTopoBJetContainerKey {this, "OnlineEMTopoBJetContainerKey", "HLT_AntiKt4EMTopoJets_subresjesgscIS_ftf_bJets", "Key of online EMTopo bjets"}
 
std::string m_name
 
std::unordered_map< std::string, size_t > m_toolLookupMap
 
const ToolHandle< GenericMonitoringTool > m_dummy
 
Gaudi::Property< bool > m_enforceExpressTriggers
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 15 of file TrigBjetMonitorAlgorithm.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

◆ TrigBjetMonitorAlgorithm()

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

Definition at line 13 of file TrigBjetMonitorAlgorithm.cxx.

14  : AthMonitorAlgorithm(name,pSvcLocator)
15 {}

◆ ~TrigBjetMonitorAlgorithm()

TrigBjetMonitorAlgorithm::~TrigBjetMonitorAlgorithm ( )
virtual

Definition at line 17 of file TrigBjetMonitorAlgorithm.cxx.

17 {}

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" ) {
147  return DataType_t::userDefined;
148  } else if( lowerCaseStr == "montecarlo" ) {
149  return DataType_t::monteCarlo;
150  } else if( lowerCaseStr == "collisions" ) {
151  return DataType_t::collisions;
152  } else if( lowerCaseStr == "cosmics" ) {
153  return DataType_t::cosmics;
154  } else if( lowerCaseStr == "heavyioncollisions" ) {
155  return DataType_t::heavyIonCollisions;
156  } else { // otherwise, warn the user and return "userDefined"
157  ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
158  <<str<<", returning userDefined.");
159  return DataType_t::userDefined;
160  }
161 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, 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;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

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

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::envStringToEnum ( const std::string &  str) const
inherited

Convert the environment string from the python configuration to an enum object.

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

Definition at line 112 of file AthMonitorAlgorithm.cxx.

112  {
113  // convert the string to all lowercase
114  std::string lowerCaseStr = str;
115  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
116 
117  // check if it matches one of the enum choices
118  if( lowerCaseStr == "user" ) {
119  return Environment_t::user;
120  } else if( lowerCaseStr == "online" ) {
121  return Environment_t::online;
122  } else if( lowerCaseStr == "tier0" ) {
123  return Environment_t::tier0;
124  } else if( lowerCaseStr == "tier0raw" ) {
125  return Environment_t::tier0Raw;
126  } else if( lowerCaseStr == "tier0esd" ) {
127  return Environment_t::tier0ESD;
128  } else if( lowerCaseStr == "aod" ) {
129  return Environment_t::AOD;
130  } else if( lowerCaseStr == "altprod" ) {
131  return Environment_t::altprod;
132  } else { // otherwise, warn the user and return "user"
133  ATH_MSG_WARNING("AthMonitorAlgorithm::envStringToEnum(): Unknown environment "
134  <<str<<", returning user.");
135  return Environment_t::user;
136  }
137 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode AthMonitorAlgorithm::execute ( const EventContext &  ctx) const
overridevirtualinherited

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

73  {
74 
75  // Checks that all of the DQ filters are passed. If any one of the filters
76  // fails, return SUCCESS code and do not fill the histograms with the event.
77  for ( const auto& filterItr : m_DQFilterTools ) {
78  if (!filterItr->accept()) {
79  ATH_MSG_DEBUG("Event rejected due to filter tool.");
80  return StatusCode::SUCCESS;
81  }
82  }
83 
84  // Trigger: If there is a decision tool and the chains fail, skip the event.
85  if ( !m_trigDecTool.empty() && !trigChainsArePassed(m_vTrigChainNames) ) {
86  ATH_MSG_DEBUG("Event rejected due to trigger filter.");
87  return StatusCode::SUCCESS;
88  }
89 
90  ATH_MSG_DEBUG("Event accepted!");
91  return fillHistograms(ctx);
92 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & 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()) {
94  return m_extendedExtraObjects;
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ fillHistograms()

StatusCode TrigBjetMonitorAlgorithm::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 101 of file TrigBjetMonitorAlgorithm.cxx.

101  {
102  using namespace Monitored;
103 
104  if(m_trigDecTool->ExperimentalAndExpertMethods().isHLTTruncated()) {
105  ATH_MSG_WARNING("HLTResult truncated, skip trigger analysis");
106  return StatusCode::SUCCESS;
107  } // ATR-31454
108 
109 
110  // Read off-line PV's and fill histograms
111 
112  bool Eofflinepv(false);
113  float offlinepvz(-1.e6);
114  float offlinepvx(-1.e6);
115  float offlinepvy(-1.e6);
116 
117  if (m_collisionRun) {
118  auto OffNVtx = Monitored::Scalar<int>("Off_NVtx",0);
119  auto OffxVtx = Monitored::Scalar<float>("Off_xVtx",0.0);
120  auto OffyVtx = Monitored::Scalar<float>("Off_yVtx",0.0);
121  auto OffzVtx = Monitored::Scalar<float>("Off_zVtx",0.0);
122 
123  SG::ReadHandle<xAOD::VertexContainer> offlinepv = SG::makeHandle( m_offlineVertexContainerKey, ctx );
124  if (! offlinepv.isValid() ) {
125  ATH_MSG_ERROR("evtStore() does not contain VertexContainer Collection with name "<< m_offlineVertexContainerKey);
126  return StatusCode::FAILURE;
127  }
128  ATH_MSG_DEBUG(" Size of the Off-line PV container: " << offlinepv->size() );
129  if ( offlinepv->size() ) {
130  Eofflinepv = true;
131  offlinepvz = offlinepv->front()->z();
132  offlinepvx = offlinepv->front()->x();
133  offlinepvy = offlinepv->front()->y();
134  OffNVtx = offlinepv->size() ;
135  for (unsigned int j = 0; j<offlinepv->size(); j++) {
136  if ( (*(offlinepv))[j]->nTrackParticles()==0 ) continue; // MS 9/7/2025
137  if ( (*(offlinepv))[j]->vertexType()==0 ) continue; // MS 9/7/2025
138  OffxVtx = (*(offlinepv))[j]->x();
139  OffyVtx = (*(offlinepv))[j]->y();
140  OffzVtx = (*(offlinepv))[j]->z();
141  fill("TrigBjetMonitor",OffxVtx,OffyVtx,OffzVtx);
142  }
143  fill("TrigBjetMonitor",OffNVtx);
144  } // if size
145  } // if m_collisionRun
146 
147  // print the trigger chain names
148 
149  std::string chainName;
150 
151  int size_AllChains = m_allChains.size();
152  ATH_MSG_DEBUG(" Size of the AllChains trigger container: " << size_AllChains );
153  for (int i =0; i<size_AllChains; i++) {
154  chainName = m_allChains[i];
155  ATH_MSG_DEBUG(" Chain number: " << i << " AllChains Chain Name: " << chainName );
156  }
157 
158  // Verifiy if the trigger chain was fired and if yes, fill the corresponding histogram
159 
160  bool mujetChain(false);
161  bool bjetChain(true);
162  bool L2bjetChain(false);
163 
164 
165  for ( auto& trigName : m_allChains ) {
166 
167 
168  if ( m_trigDecTool->isPassed(trigName) ) {
169  ATH_MSG_DEBUG(" Trigger chain from AllChains list: " << trigName << " has fired !!! " );
170 
171  // Verify if the chain was in the Express Stream if the job was an express job
172 
173  const unsigned int passBits = m_trigDecTool->isPassedBits(trigName);
174  const bool expressPass = passBits & TrigDefs::Express_passed;
175 
176  ATH_MSG_DEBUG( " Express Stream Test: Chain: " << trigName<< " m_expressStreamFlag: " << m_expressStreamFlag << " expressPass: " << expressPass );
177 
178  if ( !m_expressStreamFlag || (m_expressStreamFlag && expressPass) ) {
179 
180 
181  // bjet vs mujet vs L2bjetChain
182  mujetChain = false;
183  L2bjetChain = false;
184  bjetChain = false;
185  std::size_t found = trigName.find("HLT_mu");
186  if (found!=std::string::npos) mujetChain = true;
187  else {
188  found = trigName.find("a10sd_cssk");
189  if (found!=std::string::npos) L2bjetChain = true;
190  else bjetChain = true;
191  }
192 
193  ATH_MSG_DEBUG(" ===> Run 3 access to Trigger Item: " << trigName );
194  ATH_MSG_DEBUG(" bjetChain: " << bjetChain << " mujetChain: " << mujetChain << " L2bjetChain: " << L2bjetChain );
195 
196 
197  // online track container
198  SG::ReadHandle<xAOD::TrackParticleContainer> theTracks(m_onlineTrackContainerKey, ctx);
199  // verify the content
200  for ( const xAOD::TrackParticle* track : *theTracks ) {
201  ATH_MSG_DEBUG( " Pt of track in TrackParticleContainer: " << track->pt() );
202  }
203 
204  float zPrmVtx = 0.; // used for muon-jets
205 
206  // Online Primary Vertex from SG
207 
208  if (m_collisionRun) {
209  SG::ReadHandle<xAOD::VertexContainer> vtxContainer = SG::makeHandle( m_onlineVertexContainerKey, ctx );
210  int nPV = 0;
211  for (const xAOD::Vertex* vtx : *vtxContainer) {
212  if (vtx->vertexType() == xAOD::VxType::PriVtx) {
213  nPV++;
214  std::string NameH = "PVz_tr_"+trigName;
215  ATH_MSG_DEBUG( " NameH: " << NameH );
216  auto PVz_tr = Monitored::Scalar<float>(NameH,0.0);
217  PVz_tr = vtx->z();
218  zPrmVtx = PVz_tr;
219  ATH_MSG_DEBUG(" PVz_tr: " << PVz_tr);
220  fill("TrigBjetMonitor",PVz_tr);
221  if (Eofflinepv) {
222  NameH = "DiffOnOffPVz_tr_"+trigName;
223  ATH_MSG_DEBUG( " NameH: " << NameH );
224  auto DiffOnOffPVz_tr = Monitored::Scalar<float>(NameH,0.0);
225  DiffOnOffPVz_tr = vtx->z()-offlinepvz;
226  ATH_MSG_DEBUG(" DiffOnOffPVz_tr: " << DiffOnOffPVz_tr);
227  fill("TrigBjetMonitor",DiffOnOffPVz_tr);
228  } // if Eofflinepv
229  NameH = "PVx_tr_"+trigName;
230  ATH_MSG_DEBUG( " NameH: " << NameH );
231  auto PVx_tr = Monitored::Scalar<float>(NameH,0.0);
232  PVx_tr = vtx->x();
233  ATH_MSG_DEBUG(" PVx_tr: " << PVx_tr);
234  fill("TrigBjetMonitor",PVx_tr);
235  if (Eofflinepv) {
236  NameH = "DiffOnOffPVx_tr_"+trigName;
237  ATH_MSG_DEBUG( " NameH: " << NameH );
238  auto DiffOnOffPVx_tr = Monitored::Scalar<float>(NameH,0.0);
239  DiffOnOffPVx_tr = vtx->x()-offlinepvx;
240  ATH_MSG_DEBUG(" DiffOnOffPVx_tr: " << DiffOnOffPVx_tr);
241  fill("TrigBjetMonitor",DiffOnOffPVx_tr);
242  } // if Eofflinepv
243  NameH = "PVy_tr_"+trigName;
244  ATH_MSG_DEBUG( " NameH: " << NameH );
245  auto PVy_tr = Monitored::Scalar<float>(NameH,0.0);
246  PVy_tr = vtx->y();
247  ATH_MSG_DEBUG(" PVy_tr: " << PVy_tr);
248  fill("TrigBjetMonitor",PVy_tr);
249  if (Eofflinepv) {
250  NameH = "DiffOnOffPVy_tr_"+trigName;
251  ATH_MSG_DEBUG( " NameH: " << NameH );
252  auto DiffOnOffPVy_tr = Monitored::Scalar<float>(NameH,0.0);
253  DiffOnOffPVy_tr = vtx->y()-offlinepvy;
254  ATH_MSG_DEBUG(" DiffOnOffPVy_tr: " << DiffOnOffPVy_tr);
255  fill("TrigBjetMonitor",DiffOnOffPVy_tr);
256  } // if Eofflinepv
257  } // if vtx type
258  } // loop on vtxContainer
259  std::string NpvH = "nPV_tr_"+trigName;
260  ATH_MSG_DEBUG( " NpvH: " << NpvH );
261  auto nPV_tr = Monitored::Scalar<int>(NpvH,0.0);
262  nPV_tr = nPV;
263  fill("TrigBjetMonitor",nPV_tr);
264  } // if m_collisionRun
265 
266  // L2bjetChain
267 
268 
269  if (L2bjetChain) {
270  std::vector< TrigCompositeUtils::LinkInfo<xAOD::JetContainer> > onlinejets = m_trigDecTool->features<xAOD::JetContainer>(trigName, TrigDefs::Physics);
271 
272  std::string nJetH = "LargeR_nJet_"+trigName;
273  auto nJet = Monitored::Scalar<int>(nJetH,0.0);
274  nJet = onlinejets.size();
275  ATH_MSG_DEBUG(" nJet: " << nJet);
276  fill("TrigBjetMonitor",nJet);
277  for(const auto& jetLinkInfo : onlinejets) {
278  const xAOD::Jet* jet = *(jetLinkInfo.link);
279 
280 
281  bool theLLRW(false);
282 
283  // GN2XTrig
284 
285  std::string NameH = "GN2XTrig_pqcd_tr_"+trigName;
286  ATH_MSG_DEBUG( " NameH: " << NameH );
287  auto GN2XTrig_pqcd = Monitored::Scalar<float>(NameH,0.0);
288  const SG::AuxElement::ConstAccessor<float> pqcd_accessor("GN2XTrig_pqcd"); // DG 03-03-2025
289  GN2XTrig_pqcd = pqcd_accessor(*jet); // DG 03-03-2025
290  ATH_MSG_DEBUG(" GN2XTrig_pqcd: " << GN2XTrig_pqcd);
291  fill("TrigBjetMonitor",GN2XTrig_pqcd);
292 
293  NameH = "GN2XTrig_ptop_tr_"+trigName;
294  ATH_MSG_DEBUG( " NameH: " << NameH );
295  auto GN2XTrig_ptop = Monitored::Scalar<float>(NameH,0.0);
296  const SG::AuxElement::ConstAccessor<float> ptop_accessor("GN2XTrig_ptop"); // DG 03-03-2025
297  GN2XTrig_ptop = ptop_accessor(*jet); // DG 03-03-2025
298  ATH_MSG_DEBUG(" GN2XTrig_ptop: " << GN2XTrig_ptop);
299  fill("TrigBjetMonitor",GN2XTrig_ptop);
300 
301  NameH = "GN2XTrig_phbb_tr_"+trigName;
302  ATH_MSG_DEBUG( " NameH: " << NameH );
303  auto GN2XTrig_phbb = Monitored::Scalar<float>(NameH,0.0);
304  const SG::AuxElement::ConstAccessor<float> phbb_accessor("GN2XTrig_phbb"); // DG 03-03-2025
305  GN2XTrig_phbb = phbb_accessor(*jet); // DG 03-03-2025
306  ATH_MSG_DEBUG(" GN2XTrig_phbb: " << GN2XTrig_phbb);
307  fill("TrigBjetMonitor",GN2XTrig_phbb);
308 
309  NameH = "GN2XTrig_mv_tr_"+trigName;
310  ATH_MSG_DEBUG( " NameH: " << NameH );
311  auto GN2XTrig_mv = Monitored::Scalar<float>(NameH,0.0);
312  ATH_MSG_DEBUG(" GN2XTrig_pqcd: " << GN2XTrig_pqcd << " GN2XTrig_ptop: " << GN2XTrig_ptop << " GN2XTrig_phbb: " << GN2XTrig_phbb );
313  theLLRW = LLRW (GN2XTrig_pqcd, GN2XTrig_ptop, GN2XTrig_phbb, GN2XTrig_mv);
314  ATH_MSG_DEBUG(" GN2XTrig_mv: " << GN2XTrig_mv << " LLRW: " << theLLRW);
315  if ( theLLRW ) fill("TrigBjetMonitor",GN2XTrig_mv);
316 
317 
318  // jetPt
319  NameH = "LargeR_jetPt_"+trigName;
320  ATH_MSG_DEBUG( " NameH: " << NameH );
321  auto LargeR_jetPt = Monitored::Scalar<float>(NameH,0.0);
322  LargeR_jetPt = (jet->pt())*1.e-3;
323  ATH_MSG_DEBUG(" LargeR_jetPt: " << LargeR_jetPt);
324  fill("TrigBjetMonitor",LargeR_jetPt);
325 
326  // jetEta
327  NameH = "LargeR_jetEta_"+trigName;
328  ATH_MSG_DEBUG( " NameH: " << NameH );
329  auto LargeR_jetEta = Monitored::Scalar<float>(NameH,0.0);
330  LargeR_jetEta = jet->eta();
331 
332  // jetPhi
333  NameH = "LargeR_jetPhi_"+trigName;
334  ATH_MSG_DEBUG( " NameH: " << NameH );
335  auto LargeR_jetPhi = Monitored::Scalar<float>(NameH,0.0);
336  LargeR_jetPhi = jet->phi();
337  ATH_MSG_DEBUG(" LargeR_jetEta: " << LargeR_jetEta << " LargeR_jetPhi : " << LargeR_jetPhi);
338  fill("TrigBjetMonitor",LargeR_jetEta,LargeR_jetPhi);
339 
340  // jetMass
341  NameH = "LargeR_jetMass_"+trigName;
342  ATH_MSG_DEBUG( " NameH: " << NameH );
343  auto LargeR_jetMass = Monitored::Scalar<float>(NameH,0.0);
344  LargeR_jetMass = (jet->m())*1.e-3;
345  ATH_MSG_DEBUG(" LargeR_jetMass: " << LargeR_jetMass);
346  fill("TrigBjetMonitor",LargeR_jetMass);
347 
348  // GN2Xv01
349 
350  NameH = "GN2Xv01_pqcd_tr_"+trigName;
351  ATH_MSG_DEBUG( " NameH: " << NameH );
352  auto GN2Xv01_pqcd = Monitored::Scalar<float>(NameH,0.0);
353  const SG::AuxElement::ConstAccessor<float> pqcd_accessor0("GN2Xv01_pqcd"); // DG 03-03-2025
354  GN2Xv01_pqcd = pqcd_accessor0(*jet); // DG 03-03-2025
355  ATH_MSG_DEBUG(" GN2Xv01_pqcd: " << GN2Xv01_pqcd);
356  fill("TrigBjetMonitor",GN2Xv01_pqcd);
357 
358  NameH = "GN2Xv01_ptop_tr_"+trigName;
359  ATH_MSG_DEBUG( " NameH: " << NameH );
360  auto GN2Xv01_ptop = Monitored::Scalar<float>(NameH,0.0);
361  const SG::AuxElement::ConstAccessor<float> ptop_accessor0("GN2Xv01_ptop"); // DG 03-03-2025
362  GN2Xv01_ptop = ptop_accessor0(*jet); // DG 03-03-2025
363  ATH_MSG_DEBUG(" GN2Xv01_ptop: " << GN2Xv01_ptop);
364  fill("TrigBjetMonitor",GN2Xv01_ptop);
365 
366  NameH = "GN2Xv01_phbb_tr_"+trigName;
367  ATH_MSG_DEBUG( " NameH: " << NameH );
368  auto GN2Xv01_phbb = Monitored::Scalar<float>(NameH,0.0);
369  const SG::AuxElement::ConstAccessor<float> phbb_accessor0("GN2Xv01_phbb"); // DG 03-03-2025
370  GN2Xv01_phbb = phbb_accessor0(*jet); // DG 03-03-2025
371  ATH_MSG_DEBUG(" GN2Xv01_phbb: " << GN2Xv01_phbb);
372  fill("TrigBjetMonitor",GN2Xv01_phbb);
373 
374  NameH = "GN2Xv01_mv_tr_"+trigName;
375  ATH_MSG_DEBUG( " NameH: " << NameH );
376  auto GN2Xv01_mv = Monitored::Scalar<float>(NameH,0.0);
377  ATH_MSG_DEBUG(" GN2Xv01_pqcd: " << GN2Xv01_pqcd << " GN2Xv01_ptop: " << GN2Xv01_ptop << " GN2Xv01_phbb: " << GN2Xv01_phbb );
378  theLLRW = LLRW (GN2Xv01_pqcd, GN2Xv01_ptop, GN2Xv01_phbb, GN2Xv01_mv);
379  ATH_MSG_DEBUG(" GN2Xv01_mv: " << GN2Xv01_mv << " LLRW: " << theLLRW);
380  if ( theLLRW ) fill("TrigBjetMonitor",GN2Xv01_mv);
381 
382 
383 
384  } // for jetLinkInfo
385 
386  } // if (L2bjetChain)
387 
388 
389  if (mujetChain) {
390  std::vector< TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> > onlinemuons = m_trigDecTool->features<xAOD::MuonContainer>(trigName, TrigDefs::Physics); // TM 2022-05-16
391  int imuon = 0;
392  std::string nMuonH = "nMuon_"+trigName;
393  auto nMuon = Monitored::Scalar<int>(nMuonH,0.0);
394  nMuon = onlinemuons.size();
395  fill("TrigBjetMonitor",nMuon);
396 
397  std::vector< TrigCompositeUtils::LinkInfo<xAOD::JetContainer> > onlinejets = m_trigDecTool->features<xAOD::JetContainer>(trigName, TrigDefs::Physics); // TM 2021-10-30
398  int ijet = 0;
399  std::string nJetH = "nJet_"+trigName;
400  auto nJet = Monitored::Scalar<int>(nJetH,0.0);
401  nJet = onlinejets.size();
402  fill("TrigBjetMonitor",nJet);
403 
404  if (nMuon*nJet > 0) {
405 
406  float muonPt1(0.), muonEta1(0.), muonPhi1(0.), muonZ1(0.), jetPt1(0.), jetEta1(0.), jetPhi1(0.), jetZ1(0.), muonZ(0.);
407  double GN1_mv(0.), GN2_mv(0.);
408  bool theLLR(false), theLLR_GN1(false), theLLR_GN2(false);
409  bool plotDeltaZ(false);
410 
411  for(const auto& muonLinkInfo : onlinemuons) {
412  const xAOD::Muon* muon = *(muonLinkInfo.link);
413  // muonPt
414  std::string NameH = "muonPt_"+trigName;
415  ATH_MSG_DEBUG( " NameH: " << NameH );
416  auto muonPt = Monitored::Scalar<float>(NameH,0.0);
417  muonPt = (muon->pt())*1.e-3;
418  ATH_MSG_DEBUG(" muonPt: " << muonPt);
419  fill("TrigBjetMonitor",muonPt);
420  // muonEta
421  NameH = "muonEta_"+trigName;
422  ATH_MSG_DEBUG( " NameH: " << NameH );
423  auto muonEta = Monitored::Scalar<float>(NameH,0.0);
424  muonEta = muon->eta();
425  ATH_MSG_DEBUG(" muonEta: " << muonEta);
426  fill("TrigBjetMonitor",muonEta);
427  // muonPhi
428  NameH = "muonPhi_"+trigName;
429  ATH_MSG_DEBUG( " NameH: " << NameH );
430  auto muonPhi = Monitored::Scalar<float>(NameH,0.0);
431  muonPhi = muon->phi();
432  ATH_MSG_DEBUG(" muonPhi : " << muonPhi);
433  // muonZ
434  auto link = muon->combinedTrackParticleLink(); // TM and DG 18/06/22
435  if (link.isValid()) {
436  plotDeltaZ = true;
437  const xAOD::TrackParticle* track = *link;
438  muonZ = track->z0() + track->vz();
439  } else {
440  plotDeltaZ = false;
441  muonZ = 0.;
442  }
443 
444  if (imuon == 0) {
445  //store the parameter for the 1st muon
446  muonPt1 = muonPt;
447  muonEta1 = muonEta;
448  muonPhi1 = muonPhi;
449  muonZ1 = muonZ;
450  }// if imuon==0
451 
452  // The associated jet loop
453  for(const auto& jetLinkInfo : onlinejets) {
454  const xAOD::Jet* jet = *(jetLinkInfo.link);
455  // jetPt
456  NameH = "jetPt_"+trigName;
457  ATH_MSG_DEBUG( " NameH: " << NameH );
458  auto jetPt = Monitored::Scalar<float>(NameH,0.0);
459  jetPt = (jet->pt())*1.e-3;
460  ATH_MSG_DEBUG(" jetPt: " << jetPt);
461  fill("TrigBjetMonitor",jetPt);
462  // jetEta
463  NameH = "jetEta_"+trigName;
464  ATH_MSG_DEBUG( " NameH: " << NameH );
465  auto jetEta = Monitored::Scalar<float>(NameH,0.0);
466  jetEta = jet->eta();
467  ATH_MSG_DEBUG(" jetEta : " << jetEta);
468  fill("TrigBjetMonitor",jetEta);
469  // jetPhi
470  NameH = "jetPhi_"+trigName;
471  ATH_MSG_DEBUG( " NameH: " << NameH );
472  auto jetPhi = Monitored::Scalar<float>(NameH,0.0);
473  jetPhi = jet->phi();
474  ATH_MSG_DEBUG(" jetPhi : " << jetPhi);
475 
476  // Take the b-tagging info from the first jet
477  if (ijet == 0) {
478  //store the parameter for the 1st jet
479  jetPt1 = jetPt;
480  jetEta1 = jetEta;
481  jetPhi1 = jetPhi;
482  jetZ1 = zPrmVtx;
483 
484  auto btaggingLinkInfo = TrigCompositeUtils::findLink<xAOD::BTaggingContainer>(jetLinkInfo.source, m_btaggingLinkName); // TM 2021-10-30
485  const SG::AuxElement* obj_storing_btag = nullptr;
486  if ( btaggingLinkInfo.isValid() ) {
487  obj_storing_btag = *(btaggingLinkInfo.link);
488  }
489  else {
490  obj_storing_btag = *(jetLinkInfo.link);
491  }
492 
493  static const SG::AuxElement::ConstAccessor<float> GN1pu_accessor("GN120220813_pu");
494  static const SG::AuxElement::ConstAccessor<float> GN1pc_accessor("GN120220813_pc");
495  static const SG::AuxElement::ConstAccessor<float> GN1pb_accessor("GN120220813_pb");
496 
497  static const SG::AuxElement::ConstAccessor<float> GN2pu_accessor("GN220240122_pu");
498  static const SG::AuxElement::ConstAccessor<float> GN2pc_accessor("GN220240122_pc");
499  static const SG::AuxElement::ConstAccessor<float> GN2pb_accessor("GN220240122_pb");
500 
501  // checking just pu is enough
502  if (GN1pu_accessor.isAvailable(*obj_storing_btag)) {
503  double GN1_pu(0.), GN1_pc(0.), GN1_pb(0.);
504  GN1_pu = GN1pu_accessor(*obj_storing_btag);
505  ATH_MSG_DEBUG(" GN1_pu: " << GN1_pu);
506  GN1_pc = GN1pc_accessor(*obj_storing_btag);
507  ATH_MSG_DEBUG(" GN1_pc: " << GN1_pc);
508  GN1_pb = GN1pb_accessor(*obj_storing_btag);
509  ATH_MSG_DEBUG(" GN1_pb: " << GN1_pb);
510  theLLR = LLR (GN1_pu, GN1_pc, GN1_pb, GN1_mv);
511  theLLR_GN1 = theLLR;
512  if ( !theLLR ) GN1_mv=-100.;
513  ATH_MSG_DEBUG(" GN1_mv: " << GN1_mv << " LLR: " << theLLR);
514  }
515  if (GN2pu_accessor.isAvailable(*obj_storing_btag)) {
516  double GN2_pu(0.), GN2_pc(0.), GN2_pb(0.);
517  GN2_pu = GN2pu_accessor(*obj_storing_btag);
518  ATH_MSG_DEBUG(" GN2_pu: " << GN2_pu);
519  GN2_pc = GN2pc_accessor(*obj_storing_btag);
520  ATH_MSG_DEBUG(" GN2_pc: " << GN2_pc);
521  GN2_pb = GN2pb_accessor(*obj_storing_btag);
522  ATH_MSG_DEBUG(" GN2_pb: " << GN2_pb);
523  theLLR = LLR (GN2_pu, GN2_pc, GN2_pb, GN2_mv);
524  theLLR_GN2 = theLLR;
525  if ( !theLLR ) GN2_mv=-100.;
526  ATH_MSG_DEBUG(" GN2_mv: " << GN2_mv << " LLR: " << theLLR);
527  }
528  }// if ijet==0
529 
530  ijet++;
531 
532  }// for onlinejets
533 
534  imuon++;
535 
536  }// for onlinemuons
537 
538  // muon vs jet histograms
539 
540  // Delta R(muon,jet)
541  std::string DeltaRH = "DeltaR_"+trigName;
542  ATH_MSG_DEBUG( " DeltaRH: " << DeltaRH );
543  auto DeltaR = Monitored::Scalar<float>(DeltaRH,0.0);
544  float DeltaEta = muonEta1 - jetEta1;
545  float DeltaPhi = phiCorr( phiCorr(muonPhi1) - phiCorr(jetPhi1) );
546  DeltaR = sqrt( DeltaEta*DeltaEta + DeltaPhi*DeltaPhi );
547  ATH_MSG_DEBUG(" Delta R : " << DeltaR);
548  fill("TrigBjetMonitor",DeltaR);
549 
550  // Delta Z(muon,jet)
551  std::string DeltaZH = "DeltaZ_"+trigName;
552  ATH_MSG_DEBUG( " DeltaZH: " << DeltaZH );
553  auto DeltaZ = Monitored::Scalar<float>(DeltaZH,0.0);
554  DeltaZ = std::abs(muonZ1-jetZ1);
555  ATH_MSG_DEBUG(" Delta Z : " << DeltaZ);
556  if (plotDeltaZ) fill("TrigBjetMonitor",DeltaZ);
557 
558  // muonPt/jetPt
559  std::string RatioPtH = "RatioPt_"+trigName;
560  ATH_MSG_DEBUG( " RatioPtH: " << RatioPtH );
561  auto RatioPt = Monitored::Scalar<float>(RatioPtH,0.0);
562  RatioPt = -100.;
563  if (jetPt1 > 0.) RatioPt = muonPt1/jetPt1;
564  ATH_MSG_DEBUG(" RatioPt : " << RatioPt);
565  if (RatioPt > 0.) fill("TrigBjetMonitor",RatioPt);
566 
567  // muonPt relative to jet direction
568  std::string RelPtH = "RelPt_"+trigName;
569  ATH_MSG_DEBUG( " RelPtH: " << RelPtH );
570  auto RelPt = Monitored::Scalar<float>(RelPtH,0.0);
571  RelPt = 1.e10;
572  bool calc_relpt = CalcRelPt (muonPt1, muonEta1, muonPhi1, jetPt1, jetEta1, jetPhi1, RelPt);
573  ATH_MSG_DEBUG(" RelPt : " << RelPt);
574 
575  // wGN1
576  std::string wGN1H = "wGN1_"+trigName;
577  ATH_MSG_DEBUG( " NameH: " << wGN1H );
578  auto wGN1 = Monitored::Scalar<float>(wGN1H,0.0);
579  wGN1 = float(GN1_mv);
580  ATH_MSG_DEBUG(" wGN1: " << wGN1 << " RelPt : " << RelPt);
581  if (calc_relpt && theLLR_GN1) fill("TrigBjetMonitor",wGN1,RelPt);
582 
583  // wGN2
584  std::string wGN2H = "wGN2_"+trigName;
585  ATH_MSG_DEBUG( " NameH: " << wGN2H );
586  auto wGN2 = Monitored::Scalar<float>(wGN2H,0.0);
587  wGN2 = float(GN2_mv);
588  ATH_MSG_DEBUG(" wGN2: " << wGN2 << " RelPt : " << RelPt);
589  if (calc_relpt && theLLR_GN2) fill("TrigBjetMonitor",wGN2,RelPt);
590 
591  } // if (nMuon*nJet > 0)
592 
593  }// if mujetChain
594 
595  // bjet chains
596  if (bjetChain) {
597 
598  // Jets and PV and tracks through jet link
599 
600  std::vector< TrigCompositeUtils::LinkInfo<xAOD::JetContainer> > onlinejets = m_trigDecTool->features<xAOD::JetContainer>(trigName, TrigDefs::Physics); // TM 2021-10-30
601 
602  int ijet = 0;
603  int itrack = 0;
604  std::string nJetH = "nJet_"+trigName;
605  auto nJet = Monitored::Scalar<int>(nJetH,0.0);
606  nJet = onlinejets.size();
607  fill("TrigBjetMonitor",nJet);
608 
609  if (nJet > 0) {
610 
611  for(const auto& jetLinkInfo : onlinejets) {
612  const xAOD::Jet* jet = *(jetLinkInfo.link);
613  // jetPt
614  std::string NameH = "jetPt_"+trigName;
615  ATH_MSG_DEBUG( " NameH: " << NameH );
616  auto jetPt = Monitored::Scalar<float>(NameH,0.0);
617  jetPt = (jet->pt())*1.e-3;
618  ATH_MSG_DEBUG(" jetPt: " << jetPt);
619  fill("TrigBjetMonitor",jetPt);
620  // jetEta
621  NameH = "jetEta_"+trigName;
622  ATH_MSG_DEBUG( " NameH: " << NameH );
623  auto jetEta = Monitored::Scalar<float>(NameH,0.0);
624  jetEta = jet->eta();
625  // jetPhi
626  NameH = "jetPhi_"+trigName;
627  ATH_MSG_DEBUG( " NameH: " << NameH );
628  auto jetPhi = Monitored::Scalar<float>(NameH,0.0);
629  jetPhi = jet->phi();
630  ATH_MSG_DEBUG(" jetEta: " << jetEta << " jetPhi : " << jetPhi);
631  fill("TrigBjetMonitor",jetEta,jetPhi);
632 
633  // zPV associated to the jets in the same event: they are the same for every jet in the same event so only the first zPV should be plotted
634  if (ijet == 0) {
635 
636  // Fetch and plot PV
637 
638  std::string vtxname = m_onlineVertexContainerKey.key();
639  if ( vtxname.compare(0, 4, "HLT_")==0 ) vtxname.erase(0,4);
640  auto vertexLinkInfo = TrigCompositeUtils::findLink<xAOD::VertexContainer>(jetLinkInfo.source, vtxname ); // CV 200120 & MS 290620
641  ATH_CHECK( vertexLinkInfo.isValid() ) ; // TM 200120
642  const xAOD::Vertex* vtx = *(vertexLinkInfo.link);
643  NameH = "PVz_jet_"+trigName;
644  ATH_MSG_DEBUG( " NameH: " << NameH );
645  auto PVz_jet = Monitored::Scalar<float>(NameH,0.0);
646  PVz_jet = vtx->z();
647  ATH_MSG_DEBUG(" PVz_jet: " << PVz_jet);
648  fill("TrigBjetMonitor",PVz_jet);
649  NameH = "PVx_jet_"+trigName;
650  ATH_MSG_DEBUG( " NameH: " << NameH );
651  auto PVx_jet = Monitored::Scalar<float>(NameH,0.0);
652  PVx_jet = vtx->x();
653  ATH_MSG_DEBUG(" PVx_jet: " << PVx_jet);
654  fill("TrigBjetMonitor",PVx_jet);
655  NameH = "PVy_jet_"+trigName;
656  ATH_MSG_DEBUG( " NameH: " << NameH );
657  auto PVy_jet = Monitored::Scalar<float>(NameH,0.0);
658  PVy_jet = vtx->y();
659  ATH_MSG_DEBUG(" PVy_jet: " << PVy_jet);
660  fill("TrigBjetMonitor",PVy_jet);
661 
662 
663  } // if (ijet == 0)
664 
665  ijet++;
666 
667  // Fetch and plot BTagging information
668  const SG::AuxElement* obj_storing_btag = nullptr;
669  auto btaggingLinkInfo = TrigCompositeUtils::findLink<xAOD::BTaggingContainer>(jetLinkInfo.source, m_btaggingLinkName); // TM 2021-10-30
670  if ( btaggingLinkInfo.isValid() ) {
671  obj_storing_btag = *(btaggingLinkInfo.link);
672  }
673  else {
674  obj_storing_btag = *(jetLinkInfo.link);
675  }
676 
677  bool theLLR(false);
678  static const SG::AuxElement::ConstAccessor<float> GN1pu_accessor("GN120220813_pu");
679  static const SG::AuxElement::ConstAccessor<float> GN1pc_accessor("GN120220813_pc");
680  static const SG::AuxElement::ConstAccessor<float> GN1pb_accessor("GN120220813_pb");
681  static const SG::AuxElement::ConstAccessor<float> GN2pu_accessor("GN220240122_pu");
682  static const SG::AuxElement::ConstAccessor<float> GN2pc_accessor("GN220240122_pc");
683  static const SG::AuxElement::ConstAccessor<float> GN2pb_accessor("GN220240122_pb");
684  // checking only pu should be sufficient
685  bool GN1_available = GN1pu_accessor.isAvailable(*obj_storing_btag);
686  bool GN2_available = GN2pu_accessor.isAvailable(*obj_storing_btag);
687  NameH = "GN1_pu_tr_"+trigName;
688  ATH_MSG_DEBUG( " NameH: " << NameH );
689  auto GN1_pu = Monitored::Scalar<double>(NameH,0.0);
690  GN1_pu = GN1_available ? GN1pu_accessor(*obj_storing_btag) : 0.0;
691  ATH_MSG_DEBUG(" GN1_pu: " << GN1_pu);
692  fill("TrigBjetMonitor",GN1_pu);
693 
694  NameH = "GN1_pc_tr_"+trigName;
695  ATH_MSG_DEBUG( " NameH: " << NameH );
696  auto GN1_pc = Monitored::Scalar<double>(NameH,0.0);
697  GN1_pc = GN1_available ? GN1pc_accessor(*obj_storing_btag) : 0.0;
698  ATH_MSG_DEBUG(" GN1_pc: " << GN1_pc);
699  fill("TrigBjetMonitor",GN1_pc);
700 
701  NameH = "GN1_pb_tr_"+trigName;
702  ATH_MSG_DEBUG( " NameH: " << NameH );
703  auto GN1_pb = Monitored::Scalar<double>(NameH,0.0);
704  GN1_pb = GN1_available ? GN1pb_accessor(*obj_storing_btag) : 0.0;
705  ATH_MSG_DEBUG(" GN1_pb: " << GN1_pb);
706  fill("TrigBjetMonitor",GN1_pb);
707 
708  NameH = "GN1_mv_tr_"+trigName;
709  ATH_MSG_DEBUG( " NameH: " << NameH );
710  auto GN1_mv = Monitored::Scalar<double>(NameH,0.0);
711  theLLR = LLR (GN1_pu, GN1_pc, GN1_pb, GN1_mv);
712  if ( theLLR ) fill("TrigBjetMonitor",GN1_mv);
713  ATH_MSG_DEBUG(" GN1_mv: " << GN1_mv << " LLR: " << theLLR);
714 
715 
716  NameH = "GN2_pu_tr_"+trigName;
717  ATH_MSG_DEBUG( " NameH: " << NameH );
718  auto GN2_pu = Monitored::Scalar<double>(NameH,0.0);
719  GN2_pu = GN2_available ? GN2pu_accessor(*obj_storing_btag) : 0.0;
720  ATH_MSG_DEBUG(" GN2_pu: " << GN2_pu);
721  fill("TrigBjetMonitor",GN2_pu);
722 
723  NameH = "GN2_pc_tr_"+trigName;
724  ATH_MSG_DEBUG( " NameH: " << NameH );
725  auto GN2_pc = Monitored::Scalar<double>(NameH,0.0);
726  GN2_pc = GN2_available ? GN2pc_accessor(*obj_storing_btag) : 0.0;
727  ATH_MSG_DEBUG(" GN2_pc: " << GN2_pc);
728  fill("TrigBjetMonitor",GN2_pc);
729 
730  NameH = "GN2_pb_tr_"+trigName;
731  ATH_MSG_DEBUG( " NameH: " << NameH );
732  auto GN2_pb = Monitored::Scalar<double>(NameH,0.0);
733  GN2_pb = GN2_available ? GN2pb_accessor(*obj_storing_btag) : 0.0;
734  ATH_MSG_DEBUG(" GN2_pb: " << GN2_pb);
735  fill("TrigBjetMonitor",GN2_pb);
736 
737  NameH = "GN2_mv_tr_"+trigName;
738  ATH_MSG_DEBUG( " NameH: " << NameH );
739  auto GN2_mv = Monitored::Scalar<double>(NameH,0.0);
740  theLLR = LLR (GN2_pu, GN2_pc, GN2_pb, GN2_mv);
741  if ( theLLR ) fill("TrigBjetMonitor",GN2_mv);
742  ATH_MSG_DEBUG(" GN2_mv: " << GN2_mv << " LLR: " << theLLR);
743 
744 
745  // Tracks associated to triggered jets ( featurs = onlinejets ) courtesy of Tim Martin on 12/05/2020
746  const auto track_it_pair = m_trigDecTool->associateToEventView(theTracks, jetLinkInfo.source, "roi");
747  const xAOD::TrackParticleContainer::const_iterator start_it = track_it_pair.first;
748  const xAOD::TrackParticleContainer::const_iterator end_it = track_it_pair.second;
749 
750  int count = 0;
751  for ( xAOD::TrackParticleContainer::const_iterator it = start_it; it != end_it; ++it) {
752  count++;
753  ATH_MSG_DEBUG( " Track " << count << " with pT " << (*it)->pt() <<" from BJet with pT " << (*jetLinkInfo.link)->pt() );
754  ATH_MSG_DEBUG( " Track " << count << " with pT/eta/phi " << (*it)->pt() << "/" << (*it)->eta() << "/" << (*it)->phi() );
755  ATH_MSG_DEBUG( " Track " << count << " with d0/sigd0 " << (*it)->d0() << "/" << Amg::error((*it)->definingParametersCovMatrix(), 0) );
756  ATH_MSG_DEBUG( " Track " << count << " with z0/sigz0 " << (*it)->z0() << "/" << Amg::error((*it)->definingParametersCovMatrix(), 1) );
757  std::string NameH = "trkPt_"+trigName;
758  ATH_MSG_DEBUG( " NameH: " << NameH );
759  auto trkPt = Monitored::Scalar<float>(NameH,0.0);
760  trkPt = ((*it)->pt())*1.e-3;
761  ATH_MSG_DEBUG(" trkPt: " << trkPt);
762  fill("TrigBjetMonitor",trkPt);
763  NameH = "trkEta_"+trigName;
764  ATH_MSG_DEBUG( " NameH: " << NameH );
765  auto trkEta = Monitored::Scalar<float>(NameH,0.0);
766  trkEta = (*it)->eta();
767  NameH = "trkPhi_"+trigName;
768  ATH_MSG_DEBUG( " NameH: " << NameH );
769  auto trkPhi = Monitored::Scalar<float>(NameH,0.0);
770  trkPhi = (*it)->phi();
771  ATH_MSG_DEBUG(" trkEta: " << trkEta << " trkPhi : " << trkPhi);
772  fill("TrigBjetMonitor",trkEta,trkPhi);
773  NameH = "d0_"+trigName;
774  ATH_MSG_DEBUG( " NameH: " << NameH );
775  auto d0 = Monitored::Scalar<float>(NameH,0.0);
776  d0 = (*it)->d0();
777  ATH_MSG_DEBUG(" d0: " << d0);
778  fill("TrigBjetMonitor",d0);
779  NameH = "z0_"+trigName;
780  ATH_MSG_DEBUG( " NameH: " << NameH );
781  auto z0 = Monitored::Scalar<float>(NameH,0.0);
782  z0 = (*it)->z0();
783  ATH_MSG_DEBUG(" z0: " << z0);
784  fill("TrigBjetMonitor",z0);
785  NameH = "ed0_"+trigName;
786  ATH_MSG_DEBUG( " NameH: " << NameH );
787  auto ed0 = Monitored::Scalar<float>(NameH,0.0);
788  ed0 = Amg::error((*it)->definingParametersCovMatrix(), 0);
789  ATH_MSG_DEBUG(" ed0: " << ed0);
790  fill("TrigBjetMonitor",ed0);
791  NameH = "sd0_"+trigName;
792  ATH_MSG_DEBUG( " NameH: " << NameH );
793  auto sd0 = Monitored::Scalar<float>(NameH,0.0);
794  sd0 = -10.;
795  if (ed0 > 0.) sd0 = std::abs(d0)/ed0;
796  ATH_MSG_DEBUG(" sd0: " << sd0);
797  fill("TrigBjetMonitor",sd0);
798  NameH = "ez0_"+trigName;
799  ATH_MSG_DEBUG( " NameH: " << NameH );
800  auto ez0 = Monitored::Scalar<float>(NameH,0.0);
801  ez0 = Amg::error((*it)->definingParametersCovMatrix(), 1);
802  ATH_MSG_DEBUG(" ez0: " << ez0);
803  fill("TrigBjetMonitor",ez0);
804  } // it on tracks
805  ATH_MSG_DEBUG( " Number of tracks: " << count );
806  itrack += count;
807 
808  } // jetLinkInfo from onlinejets
809 
810  ATH_MSG_DEBUG(" Total number of triggered b-jets: " << ijet << " nJet : " << nJet);
811  ATH_MSG_DEBUG(" Total number of triggered tracks associated to the b-jets: " << itrack);
812  std::string nTrackH = "nTrack_"+trigName;
813  auto nTrack = Monitored::Scalar<int>(nTrackH,0.0);
814  nTrack = itrack;
815  fill("TrigBjetMonitor",nTrack);
816 
817  } // if (nJet > 0)
818 
819  } //if bjetChain
820 
821  } else {
822  ATH_MSG_DEBUG(" Chain " << trigName << " is declared for the Express Stream but it is NOT in the Express Stream in an Express Job");
823  } // if m_expressStreamFlag
824 
825  } else {
826  ATH_MSG_DEBUG( " Trigger chain from AllChains list: " << trigName << " has not fired " );
827  } // trigger not fired
828 
829 
830  } // for AllChains
831 
832  return StatusCode::SUCCESS;
833 }

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

◆ GetEventInfo()

SG::ReadHandle< xAOD::EventInfo > AthMonitorAlgorithm::GetEventInfo ( const EventContext &  ctx) const
inherited

Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)

Parameters
ctxEventContext for the event
Returns
a SG::ReadHandle<xAOD::EventInfo>

Definition at line 107 of file AthMonitorAlgorithm.cxx.

107  {
108  return SG::ReadHandle<xAOD::EventInfo>(m_EventInfoKey, ctx);
109 }

◆ getGroup()

const ToolHandle< GenericMonitoringTool > & AthMonitorAlgorithm::getGroup ( const std::string &  name) const
inherited

Get a specific monitoring tool from the tool handle array.

Finds a specific GenericMonitoringTool instance from the list of monitoring tools (a ToolHandleArray). Throws a FATAL warning if the object found is empty.

Parameters
namestring name of the desired tool
Returns
reference to the desired monitoring tool

Definition at line 164 of file AthMonitorAlgorithm.cxx.

164  {
165  // get the pointer to the tool, and check that it exists
166  auto idx = m_toolLookupMap.find(name);
167  if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
168  return m_tools[idx->second];
169  }
170  else {
171  // treat empty tool handle case as in Monitored::Group
172  if (m_toolLookupMap.empty()) {
173  return m_dummy;
174  }
175 
176  if (!isInitialized()) {
177  ATH_MSG_FATAL(
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 }

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

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 20 of file TrigBjetMonitorAlgorithm.cxx.

20  {
21  ATH_CHECK( m_muonContainerKey.initialize() );
22 
23  ATH_CHECK( m_offlineVertexContainerKey.initialize(m_collisionRun) );
24  ATH_CHECK( m_onlineVertexContainerKey.initialize(m_collisionRun) );
25  ATH_CHECK( m_onlineTrackContainerKey.initialize() );
26  ATH_CHECK( m_onlineEMPFlowBJetContainerKey.initialize() );
27  ATH_CHECK( m_onlineEMTopoBJetContainerKey.initialize() );
28  ATH_CHECK( m_trigDecTool.retrieve() );
29 
30  return AthMonitorAlgorithm::initialize();
31 }

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

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

◆ 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  {
108  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
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);
213  if (m_enforceExpressTriggers){
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_allChains

Gaudi::Property<std::vector<std::string> > TrigBjetMonitorAlgorithm::m_allChains {this,"AllChains",{}}
private

Definition at line 28 of file TrigBjetMonitorAlgorithm.h.

◆ m_btaggingLinkName

Gaudi::Property<std::string> TrigBjetMonitorAlgorithm::m_btaggingLinkName {this, "BtaggingLinkName", "btag"}
private

Definition at line 25 of file TrigBjetMonitorAlgorithm.h.

◆ m_collisionRun

Gaudi::Property<bool> TrigBjetMonitorAlgorithm::m_collisionRun {this, "CollisionRun", true}
private

Definition at line 23 of file TrigBjetMonitorAlgorithm.h.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 351 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

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

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

Definition at line 353 of file AthMonitorAlgorithm.h.

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 360 of file AthMonitorAlgorithm.h.

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_enforceExpressTriggers

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

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 350 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

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

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

Definition at line 352 of file AthMonitorAlgorithm.h.

◆ m_EventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> AthMonitorAlgorithm::m_EventInfoKey {this,"EventInfoKey","EventInfo"}
protectedinherited

Key for retrieving EventInfo from StoreGate.

Definition at line 362 of file AthMonitorAlgorithm.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_expressStreamFlag

Gaudi::Property<bool> TrigBjetMonitorAlgorithm::m_expressStreamFlag {this, "ExpressStreamFlag", false}
private

Definition at line 26 of file TrigBjetMonitorAlgorithm.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_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_muonContainerKey

SG::ReadHandleKey<xAOD::MuonContainer> TrigBjetMonitorAlgorithm::m_muonContainerKey {this, "MuonContainerName", "Muons", "Muon Container Name"}
private

Definition at line 30 of file TrigBjetMonitorAlgorithm.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_offlineVertexContainerKey

SG::ReadHandleKey<xAOD::VertexContainer> TrigBjetMonitorAlgorithm::m_offlineVertexContainerKey {this, "OfflineVertexContainerName", "PrimaryVertices", "Key of offline primary vertexes"}
private

Definition at line 31 of file TrigBjetMonitorAlgorithm.h.

◆ m_onlineEMPFlowBJetContainerKey

SG::ReadHandleKey<xAOD::JetContainer> TrigBjetMonitorAlgorithm::m_onlineEMPFlowBJetContainerKey {this, "OnlineEMPFlowBJetContainerKey", "HLT_AntiKt4EMPFlowJets_subresjesgscIS_ftf_bJets", "Key of online EMPFlow bjets"}
private

Definition at line 34 of file TrigBjetMonitorAlgorithm.h.

◆ m_onlineEMTopoBJetContainerKey

SG::ReadHandleKey<xAOD::JetContainer> TrigBjetMonitorAlgorithm::m_onlineEMTopoBJetContainerKey {this, "OnlineEMTopoBJetContainerKey", "HLT_AntiKt4EMTopoJets_subresjesgscIS_ftf_bJets", "Key of online EMTopo bjets"}
private

Definition at line 35 of file TrigBjetMonitorAlgorithm.h.

◆ m_onlineTrackContainerKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> TrigBjetMonitorAlgorithm::m_onlineTrackContainerKey {this, "OnlineTrackContainerName", "HLT_IDTrack_Bjet_IDTrig", "Key of online tracks of bjets"}
private

Definition at line 33 of file TrigBjetMonitorAlgorithm.h.

◆ m_onlineVertexContainerKey

SG::ReadHandleKey<xAOD::VertexContainer> TrigBjetMonitorAlgorithm::m_onlineVertexContainerKey {this, "OnlineVertexContainerName", "HLT_IDVertex_FS", "Key of online bjet primary vertexes"}
private

Definition at line 32 of file TrigBjetMonitorAlgorithm.h.

◆ m_toolLookupMap

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

Definition at line 367 of file AthMonitorAlgorithm.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 338 of file AthMonitorAlgorithm.h.

◆ m_trigDecTool

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

Tool to tell whether a specific trigger is passed.

Definition at line 340 of file AthMonitorAlgorithm.h.

◆ m_triggerChainString

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

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

Definition at line 355 of file AthMonitorAlgorithm.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 347 of file AthMonitorAlgorithm.h.

◆ m_useLumi

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

Allows use of various luminosity functions.

Definition at line 359 of file AthMonitorAlgorithm.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

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

Vector of trigger chain names parsed from trigger chain string.

Definition at line 356 of file AthMonitorAlgorithm.h.

The documentation for this class was generated from the following files:
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::Vertex_v1::x
float x() const
Returns the x position.
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
get_generator_info.result
result
Definition: get_generator_info.py:21
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
SG::AuxElement
Base class for elements of a container that can have aux data.
Definition: AuxElement.h:483
met::DeltaR
@ DeltaR
Definition: METRecoCommon.h:11
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
skel.it
it
Definition: skel.GENtoEVGEN.py:407
xAOD::passBits
passBits
Definition: TrigPassBits_v1.cxx:115
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
cosmics
Definition: cosmics.py:1
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
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
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
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
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition: AthMonitorAlgorithm.h:341
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
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
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:28
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
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
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
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
DataVector::front
const T * front() const
Access the first element in the collection as an rvalue.
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LLRW
bool LLRW(float pqcd, float ptop, float phbb, float &w)
Definition: TrigBjetMonitorAlgorithm.cxx:48
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::Vertex_v1::z
float z() const
Returns the z position.
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
phiCorr
float phiCorr(float phi)
Definition: TrigBjetMonitorAlgorithm.cxx:94
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
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
CalcRelPt
bool CalcRelPt(float muonPt, float muonEta, float muonPhi, float jetPt, float jetEta, float jetPhi, float &RelPt)
Definition: TrigBjetMonitorAlgorithm.cxx:64
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
TrigBjetMonitorAlgorithm::m_btaggingLinkName
Gaudi::Property< std::string > m_btaggingLinkName
Definition: TrigBjetMonitorAlgorithm.h:25
TrigBjetMonitorAlgorithm::m_onlineTrackContainerKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_onlineTrackContainerKey
Definition: TrigBjetMonitorAlgorithm.h:33
TrigBjetMonitorAlgorithm::m_muonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_muonContainerKey
Definition: TrigBjetMonitorAlgorithm.h:30
AthMonitorAlgorithm::Environment_t::online
@ online
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Amg::error
double error(const Amg::MatrixX &mat, int index)
return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in ...
Definition: EventPrimitivesHelpers.h:40
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
xAOD::vertexType
vertexType
Definition: Vertex_v1.cxx:166
checkTriggerxAOD.found
found
Definition: checkTriggerxAOD.py:328
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
TrigBjetMonitorAlgorithm::m_onlineVertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_onlineVertexContainerKey
Definition: TrigBjetMonitorAlgorithm.h:32
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:107
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigBjetMonitorAlgorithm::m_collisionRun
Gaudi::Property< bool > m_collisionRun
Definition: TrigBjetMonitorAlgorithm.h:23
TrigBjetMonitorAlgorithm::m_onlineEMTopoBJetContainerKey
SG::ReadHandleKey< xAOD::JetContainer > m_onlineEMTopoBJetContainerKey
Definition: TrigBjetMonitorAlgorithm.h:35
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
LLR
bool LLR(double pu, double pc, double pb, double &w)
Definition: TrigBjetMonitorAlgorithm.cxx:33
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:426
xAOD::Vertex_v1::y
float y() const
Returns the y position.
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
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
TrigBjetMonitorAlgorithm::m_allChains
Gaudi::Property< std::vector< std::string > > m_allChains
Definition: TrigBjetMonitorAlgorithm.h:28
TrigBjetMonitorAlgorithm::m_offlineVertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_offlineVertexContainerKey
Definition: TrigBjetMonitorAlgorithm.h:31
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
TrigBjetMonitorAlgorithm::m_expressStreamFlag
Gaudi::Property< bool > m_expressStreamFlag
Definition: TrigBjetMonitorAlgorithm.h:26
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrigBjetMonitorAlgorithm::m_onlineEMPFlowBJetContainerKey
SG::ReadHandleKey< xAOD::JetContainer > m_onlineEMPFlowBJetContainerKey
Definition: TrigBjetMonitorAlgorithm.h:34
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
fitman.k
k
Definition: fitman.py:528
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
ServiceHandle< ICondSvc >
collisions
Definition: collisions.py:1
Generated on Mon Sep 29 2025 21:52:17 for ATLAS Offline Software by   doxygen 1.8.18