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

#include <tauMonitorAlgorithm.h>

Inheritance diagram for tauMonitorAlgorithm:
Collaboration diagram for tauMonitorAlgorithm:

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

 tauMonitorAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~tauMonitorAlgorithm ()
 
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
 

Public Attributes

 flags = initConfigFlags()
 
string nightly = '/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/CommonInputs/'
 
string file = 'data16_13TeV.00311321.physics_Main.recon.AOD.r9264/AOD.11038520._000001.pool.root.1'
 
 Files
 
 isMC
 
 HISTFileName
 
 cfg = MainServicesCfg(flags)
 
def exampleMonitorAcc = tauMonitoringConfig(flags)
 
 OutputLevel
 
 withDetails
 

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

std::vector< int > m_abGroups1
 
std::vector< std::vector< int > > m_abGroups2
 
std::map< std::string, int > m_cGroups1
 
std::map< std::string, std::map< std::string, int > > m_cGroups2
 
SG::ReadHandleKey< xAOD::TauJetContainer > m_TauContainerKey {this, "TauRecContainer", "TauJets"}
 
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauScoreDecorKey {this, "OfflineGNTauScoreDecorKey", "GNTauScore_v0prune", "Offline GNTau Score decoration key"}
 
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauTransScoreDecorKey {this, "OfflineGNTauTransScoreDecorKey", "GNTauScoreSigTrans_v0prune", "Offline GNTau Trans Score decoration key"}
 
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauLooseWPDecorKey {this, "OfflineGNTauLooseWPDecorKey", "GNTauL_v0prune", "Offline GNTau Loose WP decoration key"}
 
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauMediumWPDecorKey {this, "OfflineGNTauMediumWPDecorKey", "GNTauM_v0prune", "Offline GNTau Medium WP decoration key"}
 
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauTightWPDecorKey {this, "OfflineGNTauTightWPDecorKey", "GNTauT_v0prune", "Offline GNTau Tight WP decoration key"}
 
Gaudi::Property< float > m_etaMin {this, "etaMin", -1.}
 
Gaudi::Property< float > m_etaMax {this, "etaMax", 3.0}
 
Gaudi::Property< std::string > m_kinGroupName {this, "kinGroupName", "tauMonKinGroupBA"}
 
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 18 of file tauMonitorAlgorithm.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

◆ tauMonitorAlgorithm()

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

Definition at line 15 of file tauMonitorAlgorithm.cxx.

17  : AthMonitorAlgorithm(name, pSvcLocator)
18 {}

◆ ~tauMonitorAlgorithm()

tauMonitorAlgorithm::~tauMonitorAlgorithm ( )
virtual

Definition at line 20 of file tauMonitorAlgorithm.cxx.

20 {}

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 tauMonitorAlgorithm::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 44 of file tauMonitorAlgorithm.cxx.

44  {
45 
46  SG::ReadHandle<xAOD::TauJetContainer> taus(m_TauContainerKey, ctx);
47 
48  if (!taus.isValid()) {
49  ATH_MSG_ERROR("evtStore() does not contain tau Collection with name "
50  << m_TauContainerKey);
51  return StatusCode::FAILURE;
52  }
53 
54  auto shallowCopy = xAOD::shallowCopyContainer(*taus);
55  std::unique_ptr<xAOD::TauJetContainer> shallowTaus(shallowCopy.first);
56  std::unique_ptr<xAOD::ShallowAuxContainer> shallowTausAux(shallowCopy.second);
57 
58  const int lowerEtThreshold = 15;
59  const int higherEtThreshold = 75;
60  auto tool = getGroup(m_kinGroupName);
61 
62  auto tauEta = Monitored::Scalar<float>("tauEta", 0.0);
63 
64  auto tauPhi = Monitored::Scalar<float>("tauPhi", 0.0);
65  auto tauEt = Monitored::Scalar<float>("tauEt", 0.0);
66 
67  std::string tauid = "";
68  if(m_TauContainerKey.key().find("TMTauJets") != std::string::npos)
69  {
70  tauid = "GNTau";
71  } else {
72  tauid = "RNN";
73  }
74 
75  auto tauEtEt15Loose = Monitored::Scalar<float>("tauEtEt15"+tauid+"Loose", 0.0);
76  auto panModeEt15Loose =
77  Monitored::Scalar<float>("panModeEt15"+tauid+"Loose", 0.0);
78  auto panModeSubstructure =
79  Monitored::Scalar<float>("panModeSubstructure", 0.0);
80 
81  auto tauPhiEt15 = Monitored::Scalar<float>("tauPhiEt15", 0.0);
82  auto tauEtaEt15 = Monitored::Scalar<float>("tauEtaEt15", 0.0);
83 
84  auto tauPhiEt15Loose = Monitored::Scalar<float>("tauPhiEt15"+tauid+"Loose", 0.0);
85  auto tauEtaEt15Loose = Monitored::Scalar<float>("tauEtaEt15"+tauid+"Loose", 0.0);
86 
87  auto tauCharge = Monitored::Scalar<int>("tauCharge", 0.0);
88  auto JetScore = Monitored::Scalar<float>(tauid+"JetScore", 0.0);
89  auto JetScoreSigTrans =
90  Monitored::Scalar<float>(tauid+"JetScoreSigTrans", 0.0);
91 
92  auto RNNEleScore = Monitored::Scalar<float>("RNNEleScore", 0.0);
93  auto RNNEleScoreSigTrans =
94  Monitored::Scalar<float>("RNNEleScoreSigTrans", 0.0);
95 
96  auto NumTracks = Monitored::Scalar<int>("NumTracks", 0.0);
97  auto NumTracksEt15Loose =
98  Monitored::Scalar<int>("NumTracksEt15"+tauid+"Loose", 0.0);
99 
100  auto nTauCandidates = Monitored::Scalar<int>("nTauCandidates", 0.0);
101  auto nHighPtTauCandidates =
102  Monitored::Scalar<int>("nHighPtTauCandidates", 0.0);
103  auto nClusters = Monitored::Scalar<int>("nClusters", 0.0);
104  auto nClustersEt15Loose =
105  Monitored::Scalar<int>("nClustersEt15"+tauid+"Loose", 0.0);
106 
107  auto tauEtLoose = Monitored::Scalar<float>("tauEt"+tauid+"Loose", 0.0);
108  auto tauEtaLoose = Monitored::Scalar<float>("tauEta"+tauid+"Loose", 0.0);
109  auto tauPhiLoose = Monitored::Scalar<float>("tauPhi"+tauid+"Loose", 0.0);
110  auto NumTracksLoose = Monitored::Scalar<float>("NumTracks"+tauid+"Loose", 0.0);
111 
112  auto tauEtMedium = Monitored::Scalar<float>("tauEt"+tauid+"Medium", 0.0);
113  auto tauEtaMedium = Monitored::Scalar<float>("tauEta"+tauid+"Medium", 0.0);
114  auto tauPhiMedium = Monitored::Scalar<float>("tauPhi"+tauid+"Medium", 0.0);
115  auto NumTracksMedium = Monitored::Scalar<float>("NumTracks"+tauid+"Medium", 0.0);
116 
117  auto tauEtTight = Monitored::Scalar<float>("tauEt"+tauid+"Tight", 0.0);
118  auto tauEtaTight = Monitored::Scalar<float>("tauEta"+tauid+"Tight", 0.0);
119  auto tauPhiTight = Monitored::Scalar<float>("tauPhi"+tauid+"Tight", 0.0);
120  auto NumTracksTight = Monitored::Scalar<float>("NumTracks"+tauid+"Tight", 0.0);
121 
122  auto LB = Monitored::Scalar<int>("LB", 0.0);
123 
124  auto EMRadius = Monitored::Scalar<float>("EMRadius", 0.0);
125  auto hadRadius = Monitored::Scalar<float>("hadRadius", 0.0);
126  auto isolFrac = Monitored::Scalar<float>("isolFrac", 0.0);
127  auto stripWidth2 = Monitored::Scalar<float>("stripWidth2", 0.0);
128  auto nStrip = Monitored::Scalar<float>("nStrip", 0.0);
129  auto etEMAtEMScale = Monitored::Scalar<float>("etEMAtEMScale", 0.0);
130 
131  auto etHadAtEMScale = Monitored::Scalar<float>("etHadAtEMScale", 0.0);
132  auto centFrac = Monitored::Scalar<float>("centFrac", 0.0);
133  auto jetSeedEta = Monitored::Scalar<float>("jetSeedEta", 0.0);
134  auto jetSeedPhi = Monitored::Scalar<float>("jetSeedPhi", 0.0);
135  auto jetSeedPt = Monitored::Scalar<float>("jetSeedPt", 0.0);
136 
137  auto muonVeto = Monitored::Scalar<float>("muonVeto", 0.0);
138 
139  auto tauLoose = Monitored::Scalar<float>("tau"+tauid+"Loose", 0.0);
140  auto tauMedium = Monitored::Scalar<float>("tau"+tauid+"Medium", 0.0);
141  auto tauTight = Monitored::Scalar<float>("tau"+tauid+"Tight", 0.0);
142 
143  auto PSSFrac = Monitored::Scalar<float>("PSSFrac", 0.0);
144  auto EMFrac = Monitored::Scalar<float>("EMFrac", 0.0);
145 
146  auto EMFracTrk = Monitored::Scalar<float>("EMFracTrk", 0.0);
147  auto EfracL2EffCluster = Monitored::Scalar<float>("EfracL2EffCluster", 0.0);
148  auto EisoEffCluster = Monitored::Scalar<float>("EisoEffCluster", 0.0);
149  auto InvMassEffClusters = Monitored::Scalar<float>("InvMassEffClusters", 0.0);
150  auto nNeutPFO = Monitored::Scalar<float>("nNeutPFO", 0.0);
151  auto nShot = Monitored::Scalar<float>("nShot", 0.0);
152  auto pt3 = Monitored::Scalar<float>("pt3", -9.0);
153 
154  auto BDTScoreAsP0 = Monitored::Scalar<float>("BDTScoreAsP0", 0.0);
155  auto dRmax = Monitored::Scalar<float>("dRmax", 0.0);
156 
157  auto ipSigLeadTrk = Monitored::Scalar<float>("ipSigLeadTrk", 0.0);
158  auto massTrkSys = Monitored::Scalar<float>("massTrkSys", 0.0);
159  auto etOverPtLeadTrack = Monitored::Scalar<float>("etOverPtLeadTrack", 0.0);
160  auto ptRatioEflowApprox = Monitored::Scalar<float>("ptRatioEflowApprox", 0.0);
161  auto trFlightPathSig = Monitored::Scalar<float>("trFlightPathSig", 0.0);
162  auto trkAvgDist = Monitored::Scalar<float>("trkAvgDist", 0.0);
163 
164  auto panEta = Monitored::Scalar<float>("panEta", 0.0);
165  auto panPhi = Monitored::Scalar<float>("panPhi", 0.0);
166  auto panPt = Monitored::Scalar<float>("panPt", 0.0);
167  auto d0 = Monitored::Scalar<float>("d0", 0.0);
168  auto dRJetSeedAxis = Monitored::Scalar<float>("dRJetSeedAxis", 0.0);
169  auto z0 = Monitored::Scalar<float>("z0", 0.0);
170 
171  auto etaTrack = Monitored::Scalar<float>("etaTrack", 0.0);
172  auto ptTrack = Monitored::Scalar<float>("ptTrack", 0.0);
173  auto phiTrack = Monitored::Scalar<float>("phiTrack", 0.0);
174  auto leadTrkPt = Monitored::Scalar<float>("leadTrkPt", 0.0);
175  auto nHighPtTaus = Monitored::Scalar<float>("nHighPtTaus", 0.0);
176  auto numberOfTRTHighThresholdHits =
177  Monitored::Scalar<float>("numberOfTRTHighThresholdHits", 0.0);
178  auto numberOfTRTHighThresholdOutliers =
179  Monitored::Scalar<float>("numberOfTRTHighThresholdOutliers", 0.0);
180  auto numberOfTRTHits = Monitored::Scalar<float>("numberOfTRTHits", 0.0);
181  auto numberOfTRTOutliers =
182  Monitored::Scalar<float>("numberOfTRTOutliers", 0.0);
183  auto trkWidth2 = Monitored::Scalar<float>("trkWidth2", 0.0);
184  auto ipZ0SinThetaSigLeadTrk =
185  Monitored::Scalar<float>("ipZ0SinThetaSigLeadTrk", 0.0);
186  auto numberOfPixelHits = Monitored::Scalar<float>("numberOfPixelHits", 0.0);
187  auto numberOfPixelSharedHits =
188  Monitored::Scalar<float>("numberOfPixelSharedHits", 0.0);
189  auto numberOfSCTHits = Monitored::Scalar<float>("numberOfSCTHits", 0.0);
190  auto numberOfSCTSharedHits =
191  Monitored::Scalar<float>("numberOfSCTSharedHits", 0.0);
192  auto rConv = Monitored::Scalar<float>("rConv", 0.0);
193  auto rConvII = Monitored::Scalar<float>("rConvII", 0.0);
194 
195  // trackLogSeedJetPt
196  auto trackLogSeedJetPt = Monitored::Scalar<float>("trackLogSeedJetPt", 0.0);
197  auto trackLogPt = Monitored::Scalar<float>("trackLogPt", 0.0);
198  auto trackEta = Monitored::Scalar<float>("trackEta", 0.0);
199  auto trackd0TJVA = Monitored::Scalar<float>("trackd0TJVA", 0.0);
200  auto trackZ0SinthetaTJVA =
201  Monitored::Scalar<float>("trackZ0SinthetaTJVA", 0.0);
202  auto trackD0SigTJVA = Monitored::Scalar<float>("trackD0SigTJVA", 0.0);
203  auto trackZ0sinthetaSigTJVA =
204  Monitored::Scalar<float>("trackZ0sinthetaSigTJVA", 0.0);
205  auto trackCharge = Monitored::Scalar<float>("trackCharge", 0.0);
206  auto trackqOverP = Monitored::Scalar<float>("trackqOverP", 0.0);
207  auto trackLogRConv = Monitored::Scalar<float>("trackLogRConv", 0.0);
208  auto trackTanhRConvII = Monitored::Scalar<float>("trackTanhRConvII", 0.0);
209  auto trackPtRatioSeedJet =
210  Monitored::Scalar<float>("trackPtRatioSeedJet", 0.0);
211  auto trackdRJetSeedAxis = Monitored::Scalar<float>("trackdRJetSeedAxis", 0.0);
212  auto trackNInnermostPixHits =
213  Monitored::Scalar<float>("trackNInnermostPixHits", 0.0);
214  auto trackNPixHits = Monitored::Scalar<float>("trackNPixHits", 0.0);
215  auto trackNSiHits = Monitored::Scalar<float>("trackNSiHits", 0.0);
216  auto trackeProbabilityHT =
217  Monitored::Scalar<float>("trackeProbabilityHT", 0.0);
218  auto trackeProbabilityNN =
219  Monitored::Scalar<float>("trackeProbabilityNN", 0.0);
220  auto trackeProbabilityHTorNN =
221  Monitored::Scalar<float>("trackeProbabilityHTorNN", 0.0);
222  auto trackIdScoreCharged = Monitored::Scalar<float>("track", 0.0);
223  auto trackIdScoreIso = Monitored::Scalar<float>("track", 0.0);
224  auto trackIdScoreConv = Monitored::Scalar<float>("track", 0.0);
225  auto trackIdScoreFake = Monitored::Scalar<float>("track", 0.0);
226 
227  auto clusterLogEt = Monitored::Scalar<float>("clusterLogEt", 0.0);
228  auto clusterEta = Monitored::Scalar<float>("clusterEta", 0.0);
229  auto clusterPhi = Monitored::Scalar<float>("clusterPhi", 0.0);
230  auto clusterSecondR = Monitored::Scalar<float>("clusterSecondR", 0.0);
231  auto clusterSecondLambda =
232  Monitored::Scalar<float>("clusterSecondLambda", 0.0);
233  auto clusterCenterLambda =
234  Monitored::Scalar<float>("clusterCenterLambda", 0.0);
235  auto clusterFirstEngDens =
236  Monitored::Scalar<float>("clusterFirstEngDens", 0.0);
237  auto clusterEMproba = Monitored::Scalar<float>("clusterEMproba", 0.0);
238  auto clustersMeanCenterLambda =
239  Monitored::Scalar<float>("clustersMeanCenterLambda", 0.0);
240  auto clustersMeanFirstEngDens =
241  Monitored::Scalar<float>("clustersMeanFirstEngDens", 0.0);
242  auto clustersMeanEMProbability =
243  Monitored::Scalar<float>("clustersMeanEMProbability", 0.0);
244  auto clustersMeanSecondLambda =
245  Monitored::Scalar<float>("clustersMeanSecondLambda", 0.0);
246  auto clustersMeanPresamplerFrac =
247  Monitored::Scalar<float>("clustersMeanPresamplerFrac", 0.0);
248  auto clustersPFOEngRelDiff =
249  Monitored::Scalar<float>("clustersPFOEngRelDiff", 0.0);
250 
251  nTauCandidates = 0;
252 
253  static const SG::ConstAccessor<char> passThinningAcc("passThinning");
254 
255  for (const auto tau : *shallowTaus) {
256 
257  if (!passThinningAcc.withDefault(*tau, true)) continue;
258 
259  tauEta = tau->eta();
260  tauPhi = tau->phi();
261  tauEt = tau->pt() / GeV;
262  tauCharge = tau->charge();
263  NumTracks = tau->nTracks();
264  nClusters = tau->detail<int>(xAOD::TauJetParameters::numTopoClusters);
265  LB = GetEventInfo(ctx)->lumiBlock();
266 
267  // calo
268  EMRadius = tau->detail<float>(xAOD::TauJetParameters::EMRadius);
269  hadRadius = tau->detail<float>(xAOD::TauJetParameters::hadRadius);
270  isolFrac = tau->detail<float>(xAOD::TauJetParameters::isolFrac);
271  stripWidth2 = tau->detail<float>(xAOD::TauJetParameters::stripWidth2);
272  nStrip = tau->detail<int>(xAOD::TauJetParameters::nStrip);
273  etEMAtEMScale = tau->detail<float>(xAOD::TauJetParameters::etEMAtEMScale);
274  etHadAtEMScale = tau->detail<float>(xAOD::TauJetParameters::etHadAtEMScale);
275 
276  centFrac = tau->detail<float>(xAOD::TauJetParameters::centFrac);
277  jetSeedEta = tau->etaJetSeed();
278  jetSeedPhi = tau->phiJetSeed();
279  jetSeedPt = tau->ptJetSeed() / GeV;
280 
281  RNNEleScore = tau->discriminant(xAOD::TauJetParameters::TauID::RNNEleScore);
282  RNNEleScoreSigTrans =
283  tau->discriminant(xAOD::TauJetParameters::TauID::RNNEleScoreSigTrans);
284 
285  muonVeto = tau->isTau(xAOD::TauJetParameters::MuonVeto);
286 
287  // check to understand which TauID we can use
288  SG::ReadDecorHandle<xAOD::TauJetContainer, float> trans_score{m_offlineGNTauTransScoreDecorKey, ctx};
289  if( trans_score.isAvailable()) {
290 
291  // we are using a special container decorated with GNTau
292  SG::ReadDecorHandle<xAOD::TauJetContainer, float> score{m_offlineGNTauScoreDecorKey, ctx};
293  JetScore = score.isAvailable() ? score(*tau) : -1234;
294 
295  JetScoreSigTrans = trans_score(*tau);
296 
297  SG::ReadDecorHandle<xAOD::TauJetContainer, char> tauid_loose{m_offlineGNTauLooseWPDecorKey, ctx};
298  tauLoose = tauid_loose.isAvailable() ? tauid_loose(*tau) : -1234;
299 
300  SG::ReadDecorHandle<xAOD::TauJetContainer, char> tauid_medium{m_offlineGNTauMediumWPDecorKey, ctx};
301  tauMedium = tauid_medium.isAvailable() ? tauid_medium(*tau) : -1234;
302 
303  SG::ReadDecorHandle<xAOD::TauJetContainer, char> tauid_tight{m_offlineGNTauTightWPDecorKey, ctx};
304  tauTight = tauid_tight.isAvailable() ? tauid_tight(*tau) : -1234;
305 
306  } else{
307  // GNTau is not present -> use RNN based TauID
308  JetScore = tau->discriminant(xAOD::TauJetParameters::TauID::RNNJetScore);
309  JetScoreSigTrans =
310  tau->discriminant(xAOD::TauJetParameters::TauID::RNNJetScoreSigTrans);
311 
312  tauLoose = tau->isTau(xAOD::TauJetParameters::JetRNNSigLoose);
313  tauMedium = tau->isTau(xAOD::TauJetParameters::JetRNNSigMedium);
314  tauTight = tau->isTau(xAOD::TauJetParameters::JetRNNSigTight);
315  }
316 
317  dRmax = tau->detail<float>(xAOD::TauJetParameters::dRmax);
318  ptRatioEflowApprox =
319  tau->detail<float>(xAOD::TauJetParameters::ptRatioEflowApprox);
320  trkAvgDist = tau->detail<float>(xAOD::TauJetParameters::trkAvgDist);
321 
322  panEta = tau->etaPanTauCellBased();
323  panPhi = tau->phiPanTauCellBased();
324  panPt = tau->ptPanTauCellBased() / GeV; // GeV ;
325 
326  // TauB/Identification/EleVetoBDTinputs
327  PSSFrac = tau->detail<float>(xAOD::TauJetParameters::PSSFraction);
328  static const SG::ConstAccessor<float> EMFracFixedAcc("EMFracFixed");
329  EMFrac = EMFracFixedAcc(*tau);
330 
331  // TauB/SubStructure
332  EMFracTrk = tau->detail<float>(xAOD::TauJetParameters::ChPiEMEOverCaloEME);
333  EfracL2EffCluster = tau->detail<float>(
334  xAOD::TauJetParameters::lead2ClusterEOverAllClusterE);
335  EisoEffCluster =
336  tau->detail<float>(xAOD::TauJetParameters::caloIsoCorrected) / GeV;
337  InvMassEffClusters =
338  tau->detail<float>(xAOD::TauJetParameters::effTopoInvMass) /
339  GeV; // puts it in GeV
340  nNeutPFO = tau->nProtoNeutralPFOs();
341  nShot = tau->nShotPFOs();
342 
343  int panModeDummy = -1;
344  int panModeSubstructureDummy = -1;
345 
346  if (m_etaMin < std::abs(tauEta) && std::abs(tauEta) < m_etaMax) {
347 
348  if( tauEt > lowerEtThreshold) {
349  nTauCandidates += 1;
350  }
351 
352  if (tauEt > higherEtThreshold) {
353  nHighPtTauCandidates += 1;
354  nHighPtTaus += 1;
355  }
356 
357  if (m_kinGroupName != "tauMonKinGroupGlobal" &&
358  tauEt > lowerEtThreshold && tauLoose) {
359 
360  tauPhiEt15Loose = tau->phi();
361  tauEtaEt15Loose = tau->eta();
362  tauEtEt15Loose = tau->pt() / GeV;
363  nClustersEt15Loose =
364  tau->detail<int>(xAOD::TauJetParameters::numTopoClusters);
365  NumTracksEt15Loose = tau->nTracks();
366 
367  tau->panTauDetail(xAOD::TauJetParameters::PanTau_DecayMode,
368  panModeDummy);
369  panModeEt15Loose = panModeDummy;
370  fill(tool, tauPhiEt15Loose, tauEtaEt15Loose,
371  nClustersEt15Loose, NumTracksEt15Loose, tauEtEt15Loose,
372  panModeEt15Loose);
373  }
374 
375  if (m_kinGroupName != "tauMonKinGroupGlobal" && tauLoose) {
376  tauPhiLoose = tau->phi();
377  tauEtaLoose = tau->eta();
378  tauEtLoose = tau->pt() / GeV;
379  NumTracksLoose = tau->nTracks();
380 
381  fill(tool, tauPhiLoose, tauEtaLoose, NumTracksLoose,
382  tauEtLoose);
383  }
384 
385  if (m_kinGroupName != "tauMonKinGroupGlobal" && tauMedium) {
386  tauPhiMedium = tau->phi();
387  tauEtaMedium = tau->eta();
388  tauEtMedium = tau->pt() / GeV;
389  NumTracksMedium = tau->nTracks();
390 
391  fill(tool, tauPhiMedium, tauEtaMedium, NumTracksMedium,
392  tauEtMedium);
393  }
394 
395  if (m_kinGroupName != "tauMonKinGroupGlobal" && tauTight) {
396  tauPhiTight = tau->phi();
397  tauEtaTight = tau->eta();
398  tauEtTight = tau->pt() / GeV;
399  NumTracksTight = tau->nTracks();
400 
401  fill(tool, tauPhiTight, tauEtaTight, NumTracksTight,
402  tauEtTight);
403  }
404 
405 
406  // tracks - old
407  if (tau->nTracks() != 0) {
408 
409  massTrkSys =
410  tau->detail<float>(xAOD::TauJetParameters::massTrkSys) / GeV; // GeV
411  trkWidth2 = tau->detail<float>(xAOD::TauJetParameters::trkWidth2);
412  trFlightPathSig =
413  tau->detail<float>(xAOD::TauJetParameters::trFlightPathSig);
414 
415  static const SG::ConstAccessor<float> d0SigTJVAAcc("d0SigTJVA");
416  if (d0SigTJVAAcc.isAvailable(*tau->track(0))) {
417  ipSigLeadTrk = tau->track(0)->d0SigTJVA();
418  }
419  else {
420  ipSigLeadTrk = tau->detail<float>(xAOD::TauJetParameters::ipSigLeadTrk);
421  }
422 
423  static const SG::ConstAccessor<float> z0sinthetaSigTJVAAcc("z0sinthetaSigTJVA");
424  if (z0sinthetaSigTJVAAcc.isAvailable(*tau->track(0))) {
425  ipZ0SinThetaSigLeadTrk = tau->track(0)->z0sinthetaSigTJVA();
426  }
427  else {
428  ipZ0SinThetaSigLeadTrk = tau->detail<float>(xAOD::TauJetParameters::ipZ0SinThetaSigLeadTrk);
429  }
430 
431  etOverPtLeadTrack =
432  tau->detail<float>(xAOD::TauJetParameters::etOverPtLeadTrk);
433  leadTrkPt = tau->detail<float>(xAOD::TauJetParameters::leadTrkPt) / GeV;
434 
435  fill(tool, massTrkSys, etOverPtLeadTrack, trkWidth2, trFlightPathSig,
436  ipSigLeadTrk, ipZ0SinThetaSigLeadTrk, leadTrkPt);
437 
438  if (environment() != Environment_t::AOD) {
439  const xAOD::TrackParticle *track = tau->track(0)->track();
440  const Trk::Perigee perigee = track->perigeeParameters();
441 
442  uint8_t dummy(0);
443 
444  if (track->summaryValue(dummy, xAOD::numberOfSCTSharedHits)) {
445  numberOfSCTSharedHits = dummy;
446  fill(tool, numberOfSCTSharedHits);
447  }
448 
449  if (track->summaryValue(dummy, xAOD::numberOfSCTHits)) {
450  numberOfSCTHits = dummy;
451  fill(tool, numberOfSCTHits);
452  }
453 
454  if (track->summaryValue(dummy, xAOD::numberOfPixelSharedHits)) {
455  numberOfPixelSharedHits = dummy;
456  fill(tool, numberOfPixelSharedHits);
457  }
458 
459  if (track->summaryValue(dummy, xAOD::numberOfPixelHits)) {
460  numberOfPixelHits = dummy;
461  fill(tool, numberOfPixelHits);
462  }
463  if (track->summaryValue(dummy, xAOD::numberOfTRTHighThresholdHits)) {
464  numberOfTRTHighThresholdHits = dummy;
465  fill(tool, numberOfTRTHighThresholdHits);
466  }
467  if (track->summaryValue(dummy,
468  xAOD::numberOfTRTHighThresholdOutliers)) {
469  numberOfTRTHighThresholdOutliers = dummy;
470  fill(tool, numberOfTRTHighThresholdOutliers);
471  }
472  if (track->summaryValue(dummy, xAOD::numberOfTRTHits)) {
473  numberOfTRTHits = dummy;
474  fill(tool, numberOfTRTHits);
475  }
476  if (track->summaryValue(dummy, xAOD::numberOfTRTOutliers)) {
477  numberOfTRTOutliers = dummy;
478  fill(tool, numberOfTRTOutliers);
479  }
480 
481  d0 = perigee.parameters()[Trk::d0];
482  z0 = perigee.parameters()[Trk::z0];
483 
484  phiTrack = perigee.parameters()[Trk::phi];
485  etaTrack = perigee.eta();
486  ptTrack = perigee.pT() / GeV;
487 
488  fill(tool, d0, z0, phiTrack, etaTrack, ptTrack);
489  }
490  }
491  // this else can be removed, but it sets any track variable to 0 if
492  // there are no tracks this solution makes entry numbers match calo which
493  // is desired but there are too many zeros.
494  else {
495  leadTrkPt = 0;
496  fill(tool, leadTrkPt);
497  }
498 
499  // Code for All Tracks and Mean track variables.
500 
501  // pre loop variables:
502  double tauSeedPt = tau->ptJetSeed();
503  double logTauSeedPt = std::log(tauSeedPt);
504  trackLogSeedJetPt = logTauSeedPt;
505 
506  fill(tool, trackLogSeedJetPt);
507 
508  static const SG::ConstAccessor<float> acc_trackScoreCharged("rnn_chargedScore");
509  static const SG::ConstAccessor<float> acc_trackScoreIso("rnn_isolationScore");
510  static const SG::ConstAccessor<float> acc_trackScoreConv("rnn_conversionScore");
511  // rnn_fakeScore may not be available (it is not provided by the TauJets smart slimming list), it can be obtained from unitarity
512 
513  for (const xAOD::TauTrack *track : tau->allTracks()) {
514 
515  static const SG::Accessor<
516  xAOD::TauTrack::TrackParticleLinks_t>
517  trackAcc("trackLinks");
518  if (!trackAcc(*track)[0]) {
519  continue;
520  }
521 
522  const xAOD::TrackParticle *trackParticle = track->track();
523 
524  float d0TJVA = track->track()->d0();
525  trackZ0SinthetaTJVA = track->z0sinThetaTJVA(*tau);
526  trackD0SigTJVA = 999.;
527  trackZ0sinthetaSigTJVA = 999.;
528  float rConv = 999.;
529  float rConvII = 999.;
530  static const SG::ConstAccessor<float> z0sinthetaTJVAAcc("z0sinthetaTJVA");
531  if (z0sinthetaTJVAAcc.isAvailable(*track)) {
532  d0TJVA = track->d0TJVA();
533  trackZ0SinthetaTJVA = track->z0sinthetaTJVA();
534  trackD0SigTJVA = track->d0SigTJVA();
535  trackZ0sinthetaSigTJVA = track->z0sinthetaSigTJVA();
536  rConv = track->rConv();
537  rConvII = track->rConvII();
538  }
539  trackdRJetSeedAxis =
540  track->p4().DeltaR(tau->p4(xAOD::TauJetParameters::JetSeed));
541  double qOverP = trackParticle->qOverP();
542  double trackPt = trackParticle->pt();
543  uint8_t nInnermostPixelLayerHits = 0;
544  trackParticle->summaryValue(nInnermostPixelLayerHits,
545  xAOD::numberOfInnermostPixelLayerHits);
546  uint8_t nPixelHits = 0;
547  trackParticle->summaryValue(nPixelHits, xAOD::numberOfPixelHits);
548  uint8_t nPixelDeadSensors = 0;
549  trackParticle->summaryValue(nPixelDeadSensors,
550  xAOD::numberOfPixelDeadSensors);
551  uint8_t nSCTHits = 0;
552  trackParticle->summaryValue(nSCTHits, xAOD::numberOfSCTHits);
553  uint8_t nSCTDeadSensors = 0;
554  trackParticle->summaryValue(nSCTDeadSensors,
555  xAOD::numberOfSCTDeadSensors);
556  uint8_t nTRTHighThresholdHits = 0;
557  trackParticle->summaryValue(nTRTHighThresholdHits,
558  xAOD::numberOfTRTHighThresholdHits);
559  uint8_t numberOfPixelHoles = 0;
560  trackParticle->summaryValue(numberOfPixelHoles,
561  xAOD::numberOfPixelHoles);
562  uint8_t numberOfSCTHoles = 0;
563  trackParticle->summaryValue(numberOfSCTHoles, xAOD::numberOfSCTHoles);
564  float eProbabilityHT = 0.;
565  trackParticle->summaryValue(eProbabilityHT, xAOD::eProbabilityHT);
566  static const SG::ConstAccessor<float> eProbabilityNNAcc("eProbabilityNN");
567  float eProbabilityNN = eProbabilityNNAcc.withDefault(*trackParticle, -1);
568  // hybrid variable (eProbabilityNN is not computed for tracks with pt
569  // < 2 GeV)
570  trackeProbabilityHTorNN =
571  (trackPt > 2000.) ? eProbabilityNN : eProbabilityHT;
572 
573  trackeProbabilityNN = eProbabilityNN;
574  trackeProbabilityHT = eProbabilityHT;
575  trackLogPt = std::log(trackPt);
576  trackEta = track->eta();
577  trackd0TJVA = std::tanh(d0TJVA / 10.);
578  trackCharge = trackParticle->charge();
579  trackqOverP = qOverP * 1000.;
580  trackLogRConv = std::log(rConv);
581  trackTanhRConvII = std::tanh(rConvII / 500.0);
582  trackPtRatioSeedJet = trackPt / tauSeedPt;
583  trackNInnermostPixHits = nInnermostPixelLayerHits;
584  trackNPixHits = nPixelHits + nPixelDeadSensors;
585  trackNSiHits =
586  nPixelHits + nPixelDeadSensors + nSCTHits + nSCTDeadSensors;
587 
588  fill(tool, trackLogPt, trackEta, trackd0TJVA, trackZ0SinthetaTJVA,
589  trackD0SigTJVA, trackZ0sinthetaSigTJVA, trackCharge, trackqOverP,
590  trackLogRConv, trackTanhRConvII, trackPtRatioSeedJet,
591  trackdRJetSeedAxis, trackNInnermostPixHits,
592  trackNPixHits,
593  trackNSiHits,
594  trackeProbabilityHT, trackeProbabilityNN, trackeProbabilityHTorNN);
595 
596  if (acc_trackScoreCharged.isAvailable(*track)) {
597  float chargedScore = acc_trackScoreCharged(*track);
598  float isolationScore = acc_trackScoreIso(*track);
599  float conversionScore = acc_trackScoreConv(*track);
600  float fakeScore = 1. - chargedScore - isolationScore - conversionScore;
601  // ensure the probability is within [0.,1.]
602  fakeScore = std::max(0.f, fakeScore);
603  fakeScore = std::min(1.f, fakeScore);
604 
605  trackIdScoreCharged = chargedScore;
606  trackIdScoreIso = isolationScore;
607  trackIdScoreConv = conversionScore;
608  trackIdScoreFake = fakeScore;
609 
610  fill(tool, trackIdScoreCharged, trackIdScoreIso, trackIdScoreConv,
611  trackIdScoreFake);
612  }
613  }
614 
615  // clusters
616  std::vector<const xAOD::IParticle *> particleList = tau->clusters();
617  std::vector<xAOD::CaloVertexedTopoCluster> clusters;
618  const xAOD::Vertex *vertex = nullptr;
619  if (tau->vertexLink().isValid())
620  vertex = tau->vertex();
621 
622  for (const xAOD::IParticle *particle : particleList) {
623  const xAOD::CaloCluster *cluster =
624  static_cast<const xAOD::CaloCluster *>(particle);
625  if (vertex) {
626  clusters.emplace_back(*cluster, xAOD::CaloCluster::State::CALIBRATED,
627  vertex->position());
628  } else {
629  clusters.emplace_back(*cluster, xAOD::CaloCluster::State::CALIBRATED);
630  }
631  }
632 
633  // sort by decreasing Et
634  auto et_cmp = [](const xAOD::CaloVertexedTopoCluster &lhs,
635  const xAOD::CaloVertexedTopoCluster &rhs) {
636  return lhs.p4().Et() > rhs.p4().Et();
637  };
638  std::sort(clusters.begin(), clusters.end(), et_cmp);
639 
640  // keep first 6 leading clusters as in RNN ID
641  if (clusters.size() > 6) {
642  clusters.resize(6, clusters[0]);
643  }
644 
645  double moment;
646  for (const auto& vertexedCluster : clusters) {
647  const xAOD::CaloCluster &cluster = vertexedCluster.clust();
648 
649  clusterLogEt = std::log10(vertexedCluster.p4().Et());
650  clusterEta = vertexedCluster.eta();
651  clusterPhi = vertexedCluster.phi();
652 
653  cluster.retrieveMoment(xAOD::CaloCluster::MomentType::SECOND_R, moment);
654  clusterSecondR = std::log10(moment + 0.1);
655 
656  cluster.retrieveMoment(xAOD::CaloCluster::MomentType::SECOND_LAMBDA,
657  moment);
658  clusterSecondLambda = std::log10(moment + 0.1);
659 
660  cluster.retrieveMoment(xAOD::CaloCluster::MomentType::CENTER_LAMBDA,
661  moment);
662  clusterCenterLambda = std::log10(moment + 1e-6);
663 
664  cluster.retrieveMoment(xAOD::CaloCluster::MomentType::FIRST_ENG_DENS,
665  moment);
666  if (moment != 0.)
667  moment = std::log10(std::abs(moment));
668  clusterFirstEngDens = moment;
669 
670  cluster.retrieveMoment(xAOD::CaloCluster::MomentType::EM_PROBABILITY,
671  moment);
672  clusterEMproba = moment;
673 
674  fill(tool, clusterLogEt, clusterEta, clusterPhi, clusterSecondR,
675  clusterSecondLambda, clusterCenterLambda, clusterFirstEngDens,
676  clusterEMproba);
677  }
678 
679  // Et-weighted average of cluster moments (MVA TES)
680  float avariable = 0.;
681  bool test = tau->detail(xAOD::TauJetParameters::ClustersMeanCenterLambda,
682  avariable);
683  if (test)
684  clustersMeanCenterLambda = avariable;
685 
686  test = tau->detail(xAOD::TauJetParameters::ClustersMeanFirstEngDens,
687  avariable);
688  if (test)
689  clustersMeanFirstEngDens = avariable;
690 
691  test = tau->detail(xAOD::TauJetParameters::ClustersMeanEMProbability,
692  avariable);
693  if (test)
694  clustersMeanEMProbability = avariable;
695 
696  test = tau->detail(xAOD::TauJetParameters::ClustersMeanSecondLambda,
697  avariable);
698  if (test)
699  clustersMeanSecondLambda = avariable;
700 
701  test = tau->detail(xAOD::TauJetParameters::ClustersMeanPresamplerFrac,
702  avariable);
703  if (test)
704  clustersMeanPresamplerFrac = avariable;
705 
706  test = tau->detail(xAOD::TauJetParameters::PFOEngRelDiff, avariable);
707  if (test)
708  clustersPFOEngRelDiff = avariable;
709 
710  fill(tool, clustersMeanCenterLambda, clustersMeanFirstEngDens,
711  clustersMeanEMProbability, clustersMeanSecondLambda,
712  clustersMeanPresamplerFrac, clustersPFOEngRelDiff);
713 
714  for (int s = 0; s < nShot; s++) {
715  const xAOD::PFO *shot = tau->shotPFO(s);
716  if (shot != nullptr) {
717  float pt3Temp = -9.0;
718  shot->attribute(xAOD::PFODetails::PFOAttributes::tauShots_pt3,
719  pt3Temp);
720  pt3 = pt3Temp / GeV; // GeV
721  fill(tool, pt3);
722  }
723  }
724 
725  for (unsigned int np = 0; np < nNeutPFO; np++) {
726  const xAOD::PFO *npfo = tau->protoNeutralPFO(np);
727  BDTScoreAsP0 = npfo->bdtPi0Score();
728  fill(tool, BDTScoreAsP0);
729  }
730 
731  if (tauEt > lowerEtThreshold) {
732  tauPhiEt15 = tau->phi();
733  tauEtaEt15 = tau->eta();
734  fill(tool, tauPhiEt15, tauEtaEt15);
735  }
736 
737  fill(tool, tauPhi, tauEta, LB, tauEt, centFrac, isolFrac, EMRadius,
738  hadRadius, stripWidth2, nStrip, etEMAtEMScale, etHadAtEMScale,
739  tauCharge, JetScore, JetScoreSigTrans, RNNEleScore, RNNEleScoreSigTrans,
740  muonVeto, tauLoose, tauMedium, tauTight, PSSFrac, EMFrac, EMFracTrk,
741  EfracL2EffCluster, EisoEffCluster, InvMassEffClusters, nNeutPFO,
742  nShot, NumTracks, nClusters, jetSeedEta, jetSeedPhi, jetSeedPt,
743  dRmax, ptRatioEflowApprox, trkAvgDist);
744 
745  tau->panTauDetail(xAOD::TauJetParameters::PanTau_DecayMode,
746  panModeSubstructureDummy);
747  panModeSubstructure = panModeSubstructureDummy;
748 
749  fill(tool, panModeSubstructure);
750  if (panPhi > -100) {
751  fill(tool, panEta, panPhi, panPt);
752  }
753  }
754  }
755 
756  fill(tool, nHighPtTauCandidates, nTauCandidates, nHighPtTaus);
757 
758  return StatusCode::SUCCESS;
759 }

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

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 22 of file tauMonitorAlgorithm.cxx.

22  {
23 
24  ATH_CHECK(m_TauContainerKey.initialize());
25 
26  m_offlineGNTauScoreDecorKey = m_TauContainerKey.key() + "." + m_offlineGNTauScoreDecorKey.key();
27  ATH_CHECK(m_offlineGNTauScoreDecorKey.initialize());
28 
29  m_offlineGNTauTransScoreDecorKey = m_TauContainerKey.key() + "." + m_offlineGNTauTransScoreDecorKey.key();
30  ATH_CHECK(m_offlineGNTauTransScoreDecorKey.initialize());
31 
32  m_offlineGNTauLooseWPDecorKey = m_TauContainerKey.key() + "." + m_offlineGNTauLooseWPDecorKey.key();
33  ATH_CHECK(m_offlineGNTauLooseWPDecorKey.initialize());
34 
35  m_offlineGNTauMediumWPDecorKey = m_TauContainerKey.key() + "." + m_offlineGNTauMediumWPDecorKey.key();
36  ATH_CHECK(m_offlineGNTauMediumWPDecorKey.initialize());
37 
38  m_offlineGNTauTightWPDecorKey = m_TauContainerKey.key() + "." + m_offlineGNTauTightWPDecorKey.key();
39  ATH_CHECK(m_offlineGNTauTightWPDecorKey.initialize());
40 
41  return AthMonitorAlgorithm::initialize();
42 }

◆ 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

◆ cfg

tauMonitorAlgorithm.cfg = MainServicesCfg(flags)

Definition at line 665 of file tauMonitorAlgorithm.py.

◆ exampleMonitorAcc

def tauMonitorAlgorithm.exampleMonitorAcc = tauMonitoringConfig(flags)

Definition at line 668 of file tauMonitorAlgorithm.py.

◆ file

string tauMonitorAlgorithm.file = 'data16_13TeV.00311321.physics_Main.recon.AOD.r9264/AOD.11038520._000001.pool.root.1'

Definition at line 654 of file tauMonitorAlgorithm.py.

◆ Files

tauMonitorAlgorithm.Files

Definition at line 655 of file tauMonitorAlgorithm.py.

◆ flags

tauMonitorAlgorithm.flags = initConfigFlags()

Definition at line 651 of file tauMonitorAlgorithm.py.

◆ HISTFileName

tauMonitorAlgorithm.HISTFileName

Definition at line 658 of file tauMonitorAlgorithm.py.

◆ isMC

tauMonitorAlgorithm.isMC

Definition at line 657 of file tauMonitorAlgorithm.py.

◆ m_abGroups1

std::vector<int> tauMonitorAlgorithm::m_abGroups1
private

Definition at line 25 of file tauMonitorAlgorithm.h.

◆ m_abGroups2

std::vector<std::vector<int> > tauMonitorAlgorithm::m_abGroups2
private

Definition at line 26 of file tauMonitorAlgorithm.h.

◆ m_cGroups1

std::map<std::string,int> tauMonitorAlgorithm::m_cGroups1
private

Definition at line 27 of file tauMonitorAlgorithm.h.

◆ m_cGroups2

std::map<std::string,std::map<std::string,int> > tauMonitorAlgorithm::m_cGroups2
private

Definition at line 28 of file tauMonitorAlgorithm.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_etaMax

Gaudi::Property<float> tauMonitorAlgorithm::m_etaMax {this, "etaMax", 3.0}
private

Definition at line 38 of file tauMonitorAlgorithm.h.

◆ m_etaMin

Gaudi::Property<float> tauMonitorAlgorithm::m_etaMin {this, "etaMin", -1.}
private

Definition at line 37 of file tauMonitorAlgorithm.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_kinGroupName

Gaudi::Property<std::string> tauMonitorAlgorithm::m_kinGroupName {this, "kinGroupName", "tauMonKinGroupBA"}
private

Definition at line 40 of file tauMonitorAlgorithm.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_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_offlineGNTauLooseWPDecorKey

SG::ReadDecorHandleKey<xAOD::TauJetContainer> tauMonitorAlgorithm::m_offlineGNTauLooseWPDecorKey {this, "OfflineGNTauLooseWPDecorKey", "GNTauL_v0prune", "Offline GNTau Loose WP decoration key"}
private

Definition at line 33 of file tauMonitorAlgorithm.h.

◆ m_offlineGNTauMediumWPDecorKey

SG::ReadDecorHandleKey<xAOD::TauJetContainer> tauMonitorAlgorithm::m_offlineGNTauMediumWPDecorKey {this, "OfflineGNTauMediumWPDecorKey", "GNTauM_v0prune", "Offline GNTau Medium WP decoration key"}
private

Definition at line 34 of file tauMonitorAlgorithm.h.

◆ m_offlineGNTauScoreDecorKey

SG::ReadDecorHandleKey<xAOD::TauJetContainer> tauMonitorAlgorithm::m_offlineGNTauScoreDecorKey {this, "OfflineGNTauScoreDecorKey", "GNTauScore_v0prune", "Offline GNTau Score decoration key"}
private

Definition at line 31 of file tauMonitorAlgorithm.h.

◆ m_offlineGNTauTightWPDecorKey

SG::ReadDecorHandleKey<xAOD::TauJetContainer> tauMonitorAlgorithm::m_offlineGNTauTightWPDecorKey {this, "OfflineGNTauTightWPDecorKey", "GNTauT_v0prune", "Offline GNTau Tight WP decoration key"}
private

Definition at line 35 of file tauMonitorAlgorithm.h.

◆ m_offlineGNTauTransScoreDecorKey

SG::ReadDecorHandleKey<xAOD::TauJetContainer> tauMonitorAlgorithm::m_offlineGNTauTransScoreDecorKey {this, "OfflineGNTauTransScoreDecorKey", "GNTauScoreSigTrans_v0prune", "Offline GNTau Trans Score decoration key"}
private

Definition at line 32 of file tauMonitorAlgorithm.h.

◆ m_TauContainerKey

SG::ReadHandleKey<xAOD::TauJetContainer> tauMonitorAlgorithm::m_TauContainerKey {this, "TauRecContainer", "TauJets"}
private

Definition at line 30 of file tauMonitorAlgorithm.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.

◆ nightly

string tauMonitorAlgorithm.nightly = '/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/CommonInputs/'

Definition at line 653 of file tauMonitorAlgorithm.py.

◆ OutputLevel

tauMonitorAlgorithm.OutputLevel

Definition at line 672 of file tauMonitorAlgorithm.py.

◆ withDetails

tauMonitorAlgorithm.withDetails

Definition at line 687 of file tauMonitorAlgorithm.py.

The documentation for this class was generated from the following files:
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:74
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:262
xAOD::TauJetParameters::PanTau_DecayMode
@ PanTau_DecayMode
Definition: TauDefs.h:360
tauMonitorAlgorithm::m_offlineGNTauScoreDecorKey
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauScoreDecorKey
Definition: tauMonitorAlgorithm.h:31
xAOD::TauJetParameters::RNNJetScoreSigTrans
@ RNNJetScoreSigTrans
RNN score which is signal transformed/flattened.
Definition: TauDefs.h:92
AthMonitorAlgorithm::environment
Environment_t environment() const
Accessor functions for the environment.
Definition: AthMonitorAlgorithm.h:205
TauGNNUtils::Variables::Cluster::CENTER_LAMBDA
bool CENTER_LAMBDA(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:851
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
xAOD::TauJetParameters::PFOEngRelDiff
@ PFOEngRelDiff
Definition: TauDefs.h:318
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:18
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::CaloVertexedClusterBase::p4
virtual FourMom_t p4() const final
The full 4-momentum of the particle.
Definition: Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloVertexedClusterBase.h:88
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:79
xAOD::TauJetParameters::RNNEleScoreSigTrans
@ RNNEleScoreSigTrans
RNN score which is signal transformed/flattened.
Definition: TauDefs.h:96
xAOD::TauJetParameters::trkWidth2
@ trkWidth2
Definition: TauDefs.h:162
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:273
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
TauAnalysisTools::tauEta
double tauEta(const xAOD::TauJet &xTau)
return tau eta
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:100
CaloCellTimeCorrFiller.LB
LB
Definition: CaloCellTimeCorrFiller.py:36
xAOD::TauJetParameters::trFlightPathSig
@ trFlightPathSig
Definition: TauDefs.h:163
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
TauGNNUtils::Variables::Cluster::EM_PROBABILITY
bool EM_PROBABILITY(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:920
xAOD::TauJetParameters::lead2ClusterEOverAllClusterE
@ lead2ClusterEOverAllClusterE
Get sum of 2 leading cluster energy over all cluster energy.
Definition: TauDefs.h:218
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:151
xAOD::TauJetParameters::ClustersMeanSecondLambda
@ ClustersMeanSecondLambda
Definition: TauDefs.h:315
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:737
xAOD::PFO_v1::attribute
bool attribute(PFODetails::PFOAttributes AttributeType, T &anAttribute) const
get a PFO Variable via enum
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
tauMonitorAlgorithm::m_offlineGNTauLooseWPDecorKey
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauLooseWPDecorKey
Definition: tauMonitorAlgorithm.h:33
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
tauMonitorAlgorithm::m_etaMin
Gaudi::Property< float > m_etaMin
Definition: tauMonitorAlgorithm.h:37
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
xAOD::TauJetParameters::ClustersMeanPresamplerFrac
@ ClustersMeanPresamplerFrac
Definition: TauDefs.h:316
Trk::z0
@ z0
Definition: ParamDefs.h:64
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:276
SG::ConstAccessor< char >
cosmics
Definition: cosmics.py:1
TrigInDetValidation_Base.test
test
Definition: TrigInDetValidation_Base.py:142
xAOD::PFODetails::tauShots_pt3
@ tauShots_pt3
Definition: Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h:145
xAOD::TauTrack_v1::TrackParticleLinks_t
std::vector< ElementLink< xAOD::TrackParticleContainer > > TrackParticleLinks_t
Definition: TauTrack_v1.h:91
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
InDetAccessor::qOverP
@ qOverP
perigee
Definition: InDetAccessor.h:35
PlotPulseshapeFromCool.np
np
Definition: PlotPulseshapeFromCool.py:64
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
xAOD::TauJetParameters::ptRatioEflowApprox
@ ptRatioEflowApprox
Definition: TauDefs.h:293
IDTPM::nPixelHits
float nPixelHits(const U &p)
Definition: TrackParametersHelper.h:354
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
xAOD::TauJetParameters::hadRadius
@ hadRadius
Get hadron calorimeter radius.
Definition: TauDefs.h:192
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:199
xAOD::TauJetParameters::ipSigLeadTrk
@ ipSigLeadTrk
Definition: TauDefs.h:160
AthMonitorAlgorithm::Environment_t::user
@ user
tauMonitorAlgorithm::m_TauContainerKey
SG::ReadHandleKey< xAOD::TauJetContainer > m_TauContainerKey
Definition: tauMonitorAlgorithm.h:30
xAOD::TauJetParameters::JetSeed
@ JetSeed
Definition: TauDefs.h:336
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
xAOD::numberOfTRTHighThresholdHits
@ numberOfTRTHighThresholdHits
number of TRT hits which pass the high threshold (only xenon counted) [unit8_t].
Definition: TrackingPrimitives.h:279
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
xAOD::TauJetParameters::stripWidth2
@ stripWidth2
Get strip width ^2.
Definition: TauDefs.h:202
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
xAOD::TauJetParameters::centFrac
@ centFrac
Get centrality fraction.
Definition: TauDefs.h:200
xAOD::TauJetParameters::dRmax
@ dRmax
Get maximal dR of tracks associated to calo-seeded tau.
Definition: TauDefs.h:226
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
xAOD::numberOfTRTHighThresholdOutliers
@ numberOfTRTHighThresholdOutliers
number of TRT high threshold outliers (only xenon counted) [unit8_t].
Definition: TrackingPrimitives.h:282
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:263
xAOD::TauJetParameters::etHadAtEMScale
@ etHadAtEMScale
Get Hadronic energy at EM scale.
Definition: TauDefs.h:196
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
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
tauMonitorAlgorithm::m_etaMax
Gaudi::Property< float > m_etaMax
Definition: tauMonitorAlgorithm.h:38
IDTPM::nSCTHits
float nSCTHits(const U &p)
Definition: TrackParametersHelper.h:393
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
xAOD::TauJetParameters::trkAvgDist
@ trkAvgDist
Get calibrated EM transverse energy (DEPRECATED since r19)
Definition: TauDefs.h:214
Trk::eProbabilityNN
@ eProbabilityNN
Electron probability from NN.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:217
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
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
tauMonitorAlgorithm::m_kinGroupName
Gaudi::Property< std::string > m_kinGroupName
Definition: tauMonitorAlgorithm.h:40
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::TauJetParameters::etOverPtLeadTrk
@ etOverPtLeadTrk
Definition: TauDefs.h:158
xAOD::TauJetParameters::caloIsoCorrected
@ caloIsoCorrected
Get sum of transvers energy of clusters around jet seed within 0.2 < dR < 0.4 (pile up corrected)
Definition: TauDefs.h:224
hist_file_dump.f
f
Definition: hist_file_dump.py:140
xAOD::CaloCluster_v1::retrieveMoment
bool retrieveMoment(MomentType type, double &value) const
Retrieve individual moment.
Definition: CaloCluster_v1.cxx:692
tauMonitorAlgorithm::m_offlineGNTauTransScoreDecorKey
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauTransScoreDecorKey
Definition: tauMonitorAlgorithm.h:32
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
TauGNNUtils::Variables::Cluster::SECOND_LAMBDA
bool SECOND_LAMBDA(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:846
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:271
xAOD::PFO_v1::bdtPi0Score
float bdtPi0Score() const
get BDT Score used to classify clusters as Pi0 like or not
xAOD::TauJetParameters::numTopoClusters
@ numTopoClusters
get number of topocluster constituents of jet associated to tau candidate
Definition: TauDefs.h:173
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
xAOD::TauJetParameters::massTrkSys
@ massTrkSys
Definition: TauDefs.h:161
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
TauGNNUtils::Variables::Track::trackPt
bool trackPt(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:483
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
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
AthMonitorAlgorithm::Environment_t::online
@ online
xAOD::TrackParticle_v1::qOverP
float qOverP() const
Returns the parameter.
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
xAOD::TauJetParameters::JetRNNSigTight
@ JetRNNSigTight
Definition: TauDefs.h:148
xAOD::PFO_v1
Class describing a particle flow object.
Definition: PFO_v1.h:35
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Trk::d0
@ d0
Definition: ParamDefs.h:63
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
xAOD::TauJetParameters::ClustersMeanEMProbability
@ ClustersMeanEMProbability
Definition: TauDefs.h:313
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
xAOD::TauJetParameters::ClustersMeanCenterLambda
@ ClustersMeanCenterLambda
Definition: TauDefs.h:312
TauGNNUtils::Variables::Cluster::SECOND_R
bool SECOND_R(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:841
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
xAOD::TauJetParameters::nStrip
@ nStrip
Get number of strips.
Definition: TauDefs.h:204
item
Definition: ItemListSvc.h:43
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
xAOD::shallowCopyContainer
std::pair< std::unique_ptr< T >, std::unique_ptr< ShallowAuxContainer > > shallowCopyContainer(const T &cont, [[maybe_unused]] const EventContext &ctx)
Function making a shallow copy of a constant container.
Definition: ShallowCopy.h:110
tauMonitorAlgorithm::m_offlineGNTauMediumWPDecorKey
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauMediumWPDecorKey
Definition: tauMonitorAlgorithm.h:34
xAOD::TauJetParameters::RNNJetScore
@ RNNJetScore
RNN score for Jet rejection (not transformed)
Definition: TauDefs.h:90
xAOD::score
@ score
Definition: TrackingPrimitives.h:514
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
xAOD::numberOfTRTOutliers
@ numberOfTRTOutliers
number of TRT outliers [unit8_t].
Definition: TrackingPrimitives.h:277
xAOD::TauJetParameters::JetRNNSigMedium
@ JetRNNSigMedium
Definition: TauDefs.h:147
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
xAOD::TauJetParameters::MuonVeto
@ MuonVeto
Definition: TauDefs.h:121
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:60
xAOD::TauJetParameters::ipZ0SinThetaSigLeadTrk
@ ipZ0SinThetaSigLeadTrk
Definition: TauDefs.h:157
a
TList * a
Definition: liststreamerinfos.cxx:10
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::TauJetParameters::ChPiEMEOverCaloEME
@ ChPiEMEOverCaloEME
Definition: TauDefs.h:278
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:274
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
xAOD::TauTrack_v1
Definition: TauTrack_v1.h:27
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: AthMonitorAlgorithm.cxx:7
xAOD::TauJetParameters::effTopoInvMass
@ effTopoInvMass
get invariant mass from effective topoclusters of jet associated to tau candidate
Definition: TauDefs.h:179
TauGNNUtils::Variables::Cluster::FIRST_ENG_DENS
bool FIRST_ENG_DENS(const xAOD::TauJet &, const xAOD::CaloVertexedTopoCluster &cluster, double &out)
Definition: TauGNNUtils.cxx:913
xAOD::TauJetParameters::ClustersMeanFirstEngDens
@ ClustersMeanFirstEngDens
Definition: TauDefs.h:314
xAOD::eProbabilityHT
@ eProbabilityHT
Electron probability from High Threshold (HT) information [float].
Definition: TrackingPrimitives.h:302
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
xAOD::TauJetParameters::isolFrac
@ isolFrac
Get isolation fraction.
Definition: TauDefs.h:198
xAOD::TauJetParameters::RNNEleScore
@ RNNEleScore
RNN score for Ele rejection (not transformed)
Definition: TauDefs.h:94
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
Trk::phi
@ phi
Definition: ParamDefs.h:75
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
tauMonitorAlgorithm::m_offlineGNTauTightWPDecorKey
SG::ReadDecorHandleKey< xAOD::TauJetContainer > m_offlineGNTauTightWPDecorKey
Definition: tauMonitorAlgorithm.h:35
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:267
TauGNNUtils::Variables::Track::d0TJVA
bool d0TJVA(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:528
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
IDTPM::nTRTHighThresholdHits
float nTRTHighThresholdHits(const U &p)
Definition: TrackParametersHelper.h:477
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
xAOD::CaloVertexedTopoCluster
Evaluate cluster kinematics with a different vertex / signal state.
Definition: Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloVertexedTopoCluster.h:38
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
xAOD::TauJetParameters::PSSFraction
@ PSSFraction
Definition: TauDefs.h:277
xAOD::TauJetParameters::EMRadius
@ EMRadius
Get E_T radius.
Definition: TauDefs.h:190
xAOD::TauJetParameters::JetRNNSigLoose
@ JetRNNSigLoose
Definition: TauDefs.h:146
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition: AthMonitorAlgorithm.cxx:164
xAOD::TauJetParameters::etEMAtEMScale
@ etEMAtEMScale
Get EM energy at EM scale.
Definition: TauDefs.h:194
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
TauGNNUtils::Variables::Track::trackEta
bool trackEta(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:488
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:238
ServiceHandle< ICondSvc >
collisions
Definition: collisions.py:1
xAOD::TauJetParameters::leadTrkPt
@ leadTrkPt
Definition: TauDefs.h:159
Generated on Sun Aug 31 2025 21:46:25 for ATLAS Offline Software by   doxygen 1.8.18