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
MuonTrackMonitorAlgorithm Class Reference

#include <MuonTrackMonitorAlgorithm.h>

Inheritance diagram for MuonTrackMonitorAlgorithm:
Collaboration diagram for MuonTrackMonitorAlgorithm:

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

 MuonTrackMonitorAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~MuonTrackMonitorAlgorithm ()
 
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::EventInfoGetEventInfo (const EventContext &) const
 Return a ReadHandle for an EventInfo object (get run/event numbers, etc.) More...
 
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average mu, i.e. More...
 
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate instantaneous number of interactions, i.e. More...
 
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1). More...
 
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the instantaneous luminosity per bunch crossing. More...
 
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the duration of the luminosity block (in seconds) More...
 
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average luminosity livefraction. More...
 
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the live fraction per bunch crossing ID. More...
 
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average integrated luminosity multiplied by the live fraction. More...
 
virtual StatusCode parseList (const std::string &line, std::vector< std::string > &result) const
 Parse a string into a vector. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Public Attributes

 title
 Muons. More...
 
 type
 
 path
 
 xbins
 
 xmin
 
 xmax
 
 ybins
 
 ymin
 
 ymax
 
 opt
 
 ylabels
 
 merge
 
list TestFiles = ['/eos/atlas/atlascerngroupdisk/det-rpc/data/DESDM_MCP/data18_13TeV.00358615.physics_Main.merge.DESDM_MCP.f961_m2024/data18_13TeV.00358615.physics_Main.merge.DESDM_MCP.f961_m2024._0084.1']
 
 flags = initConfigFlags()
 
 Files
 
 HISTFileName
 
 cfg = MainServicesCfg(flags)
 
def acc = MuonTrackConfig(flags)
 
 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< GenericMonitoringToolm_tools {this,"GMTools",{}}
 Array of Generic Monitoring Tools. More...
 
PublicToolHandle< Trig::TrigDecisionToolm_trigDecTool {this, "TrigDecisionTool",""}
 Tool to tell whether a specific trigger is passed. More...
 
ToolHandleArray< IDQFilterToolm_DQFilterTools {this,"FilterTools",{}}
 Array of Data Quality filter tools. More...
 
SG::ReadCondHandleKey< LuminosityCondDatam_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondDatam_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondDatam_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}
 
AthMonitorAlgorithm::Environment_t m_environment
 Instance of the Environment_t enum. More...
 
AthMonitorAlgorithm::DataType_t m_dataType
 Instance of the DataType_t enum. More...
 
Gaudi::Property< std::string > m_environmentStr {this,"Environment","user"}
 Environment string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_dataTypeStr {this,"DataType","userDefined"}
 DataType string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_triggerChainString {this,"TriggerChain",""}
 Trigger chain string pulled from the job option and parsed into a vector. More...
 
std::vector< std::string > m_vTrigChainNames
 Vector of trigger chain names parsed from trigger chain string. More...
 
Gaudi::Property< std::string > m_fileKey {this,"FileKey",""}
 Internal Athena name for file. More...
 
Gaudi::Property< bool > m_useLumi {this,"EnableLumi",false}
 Allows use of various luminosity functions. More...
 
Gaudi::Property< float > m_defaultLBDuration {this,"DefaultLBDuration",60.}
 Default duration of one lumi block. More...
 
Gaudi::Property< int > m_detailLevel {this,"DetailLevel",0}
 Sets the level of detail used in the monitoring. More...
 
SG::ReadHandleKey< xAOD::EventInfom_EventInfoKey {this,"EventInfoKey","EventInfo"}
 Key for retrieving EventInfo from StoreGate. More...
 

Private Types

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

Private Member Functions

StatusCode FillMuonInformation (const std::string &sIdentifier, std::vector< const xAOD::Muon * > &vecMuons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
 Fills data-quality information (e.g. More...
 
StatusCode FillTrackInformation (const std::string &sIdentifier, const xAOD::Muon *muon, const xAOD::Vertex *pvtx, const std::string &sTrack, const xAOD::EventInfo &evt) const
 Function to fill low level Track information. More...
 
StatusCode analyseLowLevelMuonFeatures (const std::string &sIdentifier, std::vector< const xAOD::Muon * > &Muons, const xAOD::EventInfo &evt) const
 Function to create performance plots for muon standalone tracks with some detailed informatiom. More...
 
StatusCode analyseCombinedTracks (const xAOD::MuonContainer &Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
 Function to create performance plots for all combined muons. More...
 
const xAOD::VertexgetPrimaryVertex (const xAOD::VertexContainer &Vertices) const
 Function to get the primary vertex. More...
 
int getTrackCategoryID (const std::string &sIdentifier) const
 Function to get the track category ID for the given identifier. More...
 
StatusCode analyseResonanceCandidates (const xAOD::MuonContainer &Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
 Function to create performance plots for all combined muons that lead to a Z Boson Candidate event. More...
 
StatusCode plotResonanceCandidates (const std::string &resonanceName, std::vector< const xAOD::Muon * > &muonCandidates, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
 Function to create performance plots for all combined muons that lead to a Jpsi Meson Candidate event. More...
 
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

SG::ReadHandleKey< xAOD::MuonContainerm_MuonContainerKey {this, "MuonContainerKey", "Muons", "Key for Muon Containers" }
 
SG::ReadDecorHandleKey< xAOD::MuonContainerm_MuonIsoDecorKey {this, "MuonIsoDecorKey", "Muons.ptcone30" }
 
SG::ReadHandleKey< xAOD::VertexContainerm_VertexContainerKey {this, "PrimaryVerticesKey", "PrimaryVertices", "Key for primary VertexContainers"}
 
SG::ReadHandleKey< xAOD::EventInfom_derEventInfoKey {this, "EventInfo", "EventInfo", ""}
 
SG::ReadDecorHandleKeyArray< xAOD::EventInfom_beamSpotKey {this, "BeamSpotKeys" ,{}, "Add the scheduler dependencies on the beamspot information"}
 
Gaudi::Property< bool > m_useBeamSpot {this, "RequireBeamSpot", true, "Ensure that the dependency on the beamspot variables is established."}
 
Gaudi::Property< std::vector< std::string > > m_hltchainList { this, "HLTTriggerList", {"HLT_2mu14_L12MU8F", "HLT_mu24_ivarmedium_L1MU14FCH"}, "High-level triggers used" }
 
Gaudi::Property< float > m_CBmuons_minPt { this, "CBmuons_minPt", 20000., "Minimal muon pt used for CB muons" }
 
Gaudi::Property< float > m_ZBosonSelection_minPt { this, "ZBosonSelection_minPt", 20000., "Minimal muon pt used for Z analysis" }
 
Gaudi::Property< float > m_ZBosonSelection_maxEta { this, "ZBosonSelection_maxEta", 2.5, "Maximal muon eta used for Z analysis" }
 
Gaudi::Property< float > m_ZBosonSelection_trkIsolation { this, "ZBosonSelection_trkIsolation", 0.2, "Track DeltaR isolation criteria" }
 
Gaudi::Property< float > m_ZBosonSelection_D0Cut { this, "ZBosonSelection_D0Cut", 100., "D0 cut applied for Z boson analysis" }
 
Gaudi::Property< float > m_ZBosonSelection_Z0Cut { this, "ZBosonSelection_Z0Cut", 100., "Z0 cut applied for Z boson analysis" }
 
Gaudi::Property< float > m_ZBosonSelection_minMass { this, "ZBosonSelection_minMass", 76000., "Minimal accepted Z boson mass" }
 
Gaudi::Property< float > m_ZBosonSelection_maxMass { this, "ZBosonSelection_maxMass", 106000., "Maximal accepted Z boson mass" }
 
Gaudi::Property< float > m_JpsiSelection_minPt { this, "JpsiSelection_minPt", 4000., "Minimal muon pt used for Jpsi analysis" }
 
Gaudi::Property< float > m_JpsiSelection_maxEta { this, "JpsiSelection_maxEta", 2.5, "Maximal muon eta used for Jpsi analysis" }
 
Gaudi::Property< float > m_JpsiSelection_trkIsolation { this, "JpsiSelection_trkIsolation", 1.0, "Jpsi track DeltaR isolation criteria" }
 
Gaudi::Property< float > m_JpsiSelection_D0Cut { this, "JpsiSelection_D0Cut", 100., "D0 cut applied for Jpsi analysis" }
 
Gaudi::Property< float > m_JpsiSelection_Z0Cut { this, "JpsiSelection_Z0Cut", 100., "Z0 cut applied for Jpsi analysis" }
 
Gaudi::Property< float > m_JpsiSelection_minMass { this, "JpsiSelection_minMass", 2600, "Minimal accepted Jpsi mass" }
 
Gaudi::Property< float > m_JpsiSelection_maxMass { this, "JpsiSelection_maxMass", 3600, "Maximal accepted Jpsi mass" }
 
std::string m_name
 
std::unordered_map< std::string, size_t > m_toolLookupMap
 
const ToolHandle< GenericMonitoringToolm_dummy
 
Gaudi::Property< bool > m_enforceExpressTriggers
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 21 of file MuonTrackMonitorAlgorithm.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

◆ MuonTrackMonitorAlgorithm()

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

Definition at line 16 of file MuonTrackMonitorAlgorithm.cxx.

17  :AthMonitorAlgorithm(name,pSvcLocator){}

◆ ~MuonTrackMonitorAlgorithm()

virtual MuonTrackMonitorAlgorithm::~MuonTrackMonitorAlgorithm ( )
inlinevirtual

Definition at line 28 of file MuonTrackMonitorAlgorithm.h.

28 {};

Member Function Documentation

◆ analyseCombinedTracks()

StatusCode MuonTrackMonitorAlgorithm::analyseCombinedTracks ( const xAOD::MuonContainer Muons,
const xAOD::Vertex pvtx,
const xAOD::EventInfo evt 
) const
private

Function to create performance plots for all combined muons.

Declaring all variables that are initialized via Python will be plotted

Select Combined Muons

Select not Combined Muons

Fill MS Track information

Fill low level Muon Information for each Muon

Fill the relevant Muon Information for each Muon

Definition at line 396 of file MuonTrackMonitorAlgorithm.cxx.

396  {
397  using namespace Monitored;
398 
400  auto tool = getGroup("MuonTrackMonitorAlgorithm");
401  auto MuonPrefix = Monitored::Scalar<const char*>("MuonPrefix", "");
402  auto NMuons = Monitored::Scalar<int>("NMuons", 0);
403  auto NMuonsTrig = Monitored::Scalar<int>("NMuonsTrig", 0);
404  auto NMuonsTrigCB = Monitored::Scalar<int>("NMuonsTrigCB", 0);
405  auto NMuonsTrigNonCB = Monitored::Scalar<int>("NMuonsTrigNonCB", 0);
406  auto NMuonsNoTrigCB = Monitored::Scalar<int>("NMuonsNoTrigCB", 0);
407  auto NMuonsNoTrigNonCB = Monitored::Scalar<int>("NMuonsNoTrigNonCB", 0);
408  auto LumiBlockNumberOfMuonTracks = Monitored::Scalar<float>("MSLumiBlockNumberOfMuonTracks", 0);
409  auto LumiBlockNumberOfSegments = Monitored::Scalar<float>("MSLumiBlockNumberOfSegments", 0);
410 
412  std::vector<const xAOD::Muon*> vecAllCombinedMuons;
413  std::vector<const xAOD::Muon*> vecCombinedMuons;
414  std::vector<const xAOD::Muon*> vecNoTrigCombinedMuons;
415 
417  std::vector<const xAOD::Muon*> vecAllNonCombinedMuons;
418  std::vector<const xAOD::Muon*> vecNonCombinedMuons;
419  std::vector<const xAOD::Muon*> vecNoTrigNonCombinedMuons;
420 
421  uint32_t n_muons = 0;
422  uint32_t n_muons_trig = 0;
423  uint32_t n_muons_trig_cb = 0;
424  uint32_t n_muons_trig_noncb = 0;
425  uint32_t n_muons_no_trig_cb = 0;
426  uint32_t n_muons_no_trig_noncb = 0;
427  for(const auto muon : Muons) {
428  n_muons++;
429  bool isTriggered = false;
430  for(const auto& chain : m_hltchainList){
431  if(!getTrigDecisionTool().empty() && getTrigDecisionTool()->isPassed( chain ) ){
432  isTriggered = true;
433  }
434  }
435 
437  if (isTriggered) {
438  ATH_CHECK ( FillTrackInformation("Container", muon, pvtx, "MS", evt) );
439  }
440  else {
441  ATH_CHECK ( FillTrackInformation("ContainerNoTrig", muon, pvtx, "MS", evt) );
442  }
443 
444  xAOD::Muon::MuonType muonType = muon->muonType();
445  if (muonType==xAOD::Muon::Combined) {
446  vecAllCombinedMuons.push_back(muon);
447  if (isTriggered) {
448  vecCombinedMuons.push_back(muon);
449  n_muons_trig++;
450  n_muons_trig_cb++;
451  MuonPrefix = "TrigCB";
452  }
453  else {
454  vecNoTrigCombinedMuons.push_back(muon);
455  MuonPrefix = "NoTrigCB";
456  n_muons_no_trig_cb++;
457  }
458  }
459  else {
460  vecAllNonCombinedMuons.push_back(muon);
461  if (isTriggered) {
462  vecNonCombinedMuons.push_back(muon);
463  n_muons_trig++;
464  n_muons_trig_noncb++;
465  MuonPrefix = "TrigNonCB";
466  }
467  else {
468  vecNoTrigNonCombinedMuons.push_back(muon);
469  MuonPrefix = "NoTrigNonCB";
470  n_muons_no_trig_noncb++;
471  }
472  }
473  fill(tool, MuonPrefix);
474  for (size_t nSeg=0; nSeg < muon->nMuonSegments(); nSeg++) {
475  LumiBlockNumberOfSegments = evt.lumiBlock();
476  fill(tool, LumiBlockNumberOfSegments);
477  }
478  }
479  NMuons = n_muons;
480  NMuonsTrig = n_muons_trig;
481  NMuonsTrigCB = n_muons_trig_cb;
482  NMuonsTrigNonCB = n_muons_trig_noncb;
483  NMuonsNoTrigCB = n_muons_no_trig_cb;
484  NMuonsNoTrigNonCB = n_muons_no_trig_noncb;
485  fill(tool, NMuons, NMuonsTrig, NMuonsTrigCB, NMuonsTrigNonCB, NMuonsNoTrigCB, NMuonsNoTrigNonCB);
486 
487  LumiBlockNumberOfMuonTracks = evt.lumiBlock();
488  fill(tool, LumiBlockNumberOfMuonTracks);
489 
491  ATH_CHECK (analyseLowLevelMuonFeatures("AllCB", vecAllCombinedMuons, evt) );
492  ATH_CHECK (analyseLowLevelMuonFeatures("AllNonCB", vecAllNonCombinedMuons, evt) );
493  ATH_CHECK (analyseLowLevelMuonFeatures("CB", vecCombinedMuons, evt) );
494  ATH_CHECK (analyseLowLevelMuonFeatures("NonCB", vecNonCombinedMuons, evt) );
495  ATH_CHECK (analyseLowLevelMuonFeatures("NoTrigCB", vecNoTrigCombinedMuons, evt) );
496  ATH_CHECK (analyseLowLevelMuonFeatures("NoTrigNonCB", vecNoTrigNonCombinedMuons, evt) );
497 
499  ATH_CHECK (FillMuonInformation("AllCB", vecAllCombinedMuons, pvtx, evt) );
500  ATH_CHECK (FillMuonInformation("AllNonCB", vecAllNonCombinedMuons, pvtx, evt) );
501  ATH_CHECK (FillMuonInformation("CB", vecCombinedMuons, pvtx, evt) );
502  ATH_CHECK (FillMuonInformation("NonCB", vecNonCombinedMuons, pvtx, evt) );
503  ATH_CHECK (FillMuonInformation("NoTrigCB", vecNoTrigCombinedMuons, pvtx, evt) );
504  ATH_CHECK (FillMuonInformation("NoTrigNonCB", vecNoTrigNonCombinedMuons, pvtx, evt) );
505 
506  return StatusCode::SUCCESS;
507 }

◆ analyseLowLevelMuonFeatures()

StatusCode MuonTrackMonitorAlgorithm::analyseLowLevelMuonFeatures ( const std::string &  sIdentifier,
std::vector< const xAOD::Muon * > &  Muons,
const xAOD::EventInfo evt 
) const
private

Function to create performance plots for muon standalone tracks with some detailed informatiom.

Declaring all variables that are initialized via Python will be plotted

Loop over all muons

General Muon Control Plots

Do Muon Segments and Sector Plots

Definition at line 304 of file MuonTrackMonitorAlgorithm.cxx.

305 {
306  uint32_t lumiBlockID = evt.lumiBlock();
307 
308  using namespace Monitored;
309 
311  auto tool = getGroup("MuonTrackMonitorAlgorithm");
312  auto MuonAuthor = Monitored::Scalar<float>((sIdentifier+"MuonAuthor").c_str(), 0);
313  auto MuonQuality = Monitored::Scalar<float>((sIdentifier+"MuonQuality").c_str(), 0);
314  auto MuonType = Monitored::Scalar<float>((sIdentifier+"MuonType").c_str(), 0);
315  auto MuonLargeSectorR = Monitored::Scalar<float>((sIdentifier+"MuonLargeSectorR").c_str(), 0);
316  auto MuonLargeSectorZ = Monitored::Scalar<float>((sIdentifier+"MuonLargeSectorZ").c_str(), 0);
317  auto MuonSmallSectorR = Monitored::Scalar<float>((sIdentifier+"MuonSmallSectorR").c_str(), 0);
318  auto MuonSmallSectorZ = Monitored::Scalar<float>((sIdentifier+"MuonSmallSectorZ").c_str(), 0);
319  auto MuonEta = Monitored::Scalar<float>((sIdentifier+"MuonEta").c_str(), 0);
320  auto MuonPhi = Monitored::Scalar<float>((sIdentifier+"MuonPhi").c_str(), 0);
321  auto MuonPt = Monitored::Scalar<float>((sIdentifier+"MuonPt").c_str(), 0);
322  auto MuonEtaHi = Monitored::Scalar<float>((sIdentifier+"MuonEtaHi").c_str(), 0);
323  auto MuonPhiHi = Monitored::Scalar<float>((sIdentifier+"MuonPhiHi").c_str(), 0);
324  auto MuonPtHi = Monitored::Scalar<float>((sIdentifier+"MuonPtHi").c_str(), 0);
325  auto MuonSector = Monitored::Scalar<float>((sIdentifier+"MuonSector").c_str(), 0);
326  auto MuonCIndex = Monitored::Scalar<float>((sIdentifier+"MuonCIndex").c_str(), 0);
327  auto MuonEta1 = Monitored::Scalar<float>((sIdentifier+"MuonEta1All").c_str(), 0);
328  auto MuonPhi1 = Monitored::Scalar<float>((sIdentifier+"MuonPhi1All").c_str(), 0);
329  auto MuonLumiBlock = Monitored::Scalar<float>((sIdentifier+"MuonLumiBlock").c_str(), 0);
330  auto SegmentXPosBarrel = Monitored::Scalar<float>((sIdentifier+"SegmentXPosBarrel").c_str(), 0);
331  auto SegmentYPosBarrel = Monitored::Scalar<float>((sIdentifier+"SegmentYPosBarrel").c_str(), 0);
332  auto SegmentXPosEndcap = Monitored::Scalar<float>((sIdentifier+"SegmentXPosEndcap").c_str(), 0);
333  auto SegmentYPosEndcap = Monitored::Scalar<float>((sIdentifier+"SegmentYPosEndcap").c_str(), 0);
334 
336  for(const auto muon : Muons) {
337  xAOD::Muon::Quality muonQuality = muon->quality();
338  xAOD::Muon::MuonType muonType = muon->muonType();
339  xAOD::Muon::Author muonAuthor = muon->author();
340  MuonLumiBlock = lumiBlockID;
341  fill(tool, MuonLumiBlock);
342 
344  MuonAuthor = muonAuthor;
345  MuonQuality = muonQuality;
346  MuonType = muonType;
347  MuonEta = muon->eta();
348  MuonPhi = muon->phi();
349  MuonPt = muon->pt() * MeVtoGeV;
350  fill(tool, MuonAuthor, MuonQuality, MuonType, MuonEta, MuonPhi, MuonPt);
351 
352  // Fill high pT plots
353  if (muon->pt() > m_CBmuons_minPt) {
354  MuonEtaHi = muon->eta();
355  MuonPhiHi = muon->phi();
356  MuonPtHi = muon->pt() * MeVtoGeV;
357  fill(tool, MuonEtaHi, MuonPhiHi, MuonPtHi);
358  }
359 
361  for (size_t nSeg=0; nSeg < muon->nMuonSegments(); nSeg++) {
362  const xAOD::MuonSegment* muonSegment = muon->muonSegment(nSeg);
363  if (!muonSegment) {
364  continue;
365  }
366  using namespace Muon::MuonStationIndex;
367  MuonSmallSectorR = MuonLargeSectorR = std::hypot(muonSegment->x(), muonSegment->y());
368  MuonSmallSectorZ = MuonLargeSectorZ = muonSegment->z();
369  MuonSector = muonSegment->sector();
370  MuonCIndex = toInt(muonSegment->chamberIndex());
371  int sector = muonSegment->sector();
372  if(sector % 2 == 0) {
373  fill(tool, MuonLargeSectorZ, MuonLargeSectorR, MuonSector, MuonCIndex);
374  } else {
375  fill(tool, MuonSmallSectorZ, MuonSmallSectorR, MuonSector, MuonCIndex);
376  }
377  const double muonSegmentEta = Amg::Vector3D(muonSegment->px(), muonSegment->py(), muonSegment->pz()).eta();
378  if (std::abs(muonSegmentEta) > 1.05) {
379  SegmentXPosEndcap = muonSegment->x();
380  SegmentYPosEndcap = muonSegment->y();
381  fill(tool, SegmentXPosEndcap, SegmentYPosEndcap);
382  } else {
383  SegmentXPosBarrel = muonSegment->x();
384  SegmentYPosBarrel = muonSegment->y();
385  fill(tool, SegmentXPosBarrel, SegmentYPosBarrel);
386  }
387  }
388  }
389 
390  return StatusCode::SUCCESS;
391 }

◆ analyseResonanceCandidates()

StatusCode MuonTrackMonitorAlgorithm::analyseResonanceCandidates ( const xAOD::MuonContainer Muons,
const xAOD::Vertex pvtx,
const xAOD::EventInfo evt 
) const
private

Function to create performance plots for all combined muons that lead to a Z Boson Candidate event.

Select Muons Relevant for Z

Select Z Boson and Jpsi

Definition at line 663 of file MuonTrackMonitorAlgorithm.cxx.

663  {
664 
665  std::vector<const xAOD::Muon*> vecMuons_ZBoson_Candidates;
666  std::vector<const xAOD::Muon*> vecMuons_Jpsi_Candidates;
667 
669  for(const auto muon : Muons) {
670  xAOD::Muon::MuonType muonType = muon->muonType();
671  if (muonType==xAOD::Muon::Combined) {
672  const xAOD::TrackParticle *cbtp = nullptr;
673  ElementLink<xAOD::TrackParticleContainer> cbtpLink = muon->combinedTrackParticleLink();
674  if (cbtpLink.isValid()) cbtp = *cbtpLink;
675 
677  if (cbtp) {
678  float trkiso = muon->isolation(xAOD::Iso::ptcone30)/muon->pt();
679  if (muonType==xAOD::Muon::Combined &&
680  cbtp &&
682  std::abs(muon->eta())<m_ZBosonSelection_maxEta &&
684  std::abs(cbtp->z0())<m_ZBosonSelection_Z0Cut &&
685  std::abs(cbtp->d0())<m_ZBosonSelection_D0Cut )
686  vecMuons_ZBoson_Candidates.push_back(muon);
687  if (muonType==xAOD::Muon::Combined &&
688  cbtp &&
689  muon->pt()>m_JpsiSelection_minPt &&
690  std::abs(muon->eta())<m_JpsiSelection_maxEta &&
692  std::abs(cbtp->z0())<m_JpsiSelection_Z0Cut &&
693  std::abs(cbtp->d0())<m_JpsiSelection_D0Cut )
694  vecMuons_Jpsi_Candidates.push_back(muon);
695  }
696  }
697  }
698 
699  ATH_CHECK( plotResonanceCandidates("Z", vecMuons_ZBoson_Candidates, pvtx, evt) );
700  ATH_CHECK( plotResonanceCandidates("Jpsi", vecMuons_Jpsi_Candidates, pvtx, evt) );
701 
702  return StatusCode::SUCCESS;
703 }

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

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

Definition at line 221 of file AthMonitorAlgorithm.h.

221 { return m_dataType; }

◆ dataTypeStringToEnum()

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

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

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

Definition at line 140 of file AthMonitorAlgorithm.cxx.

140  {
141  // convert the string to all lowercase
142  std::string lowerCaseStr = str;
143  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
144 
145  // check if it matches one of the enum choices
146  if( lowerCaseStr == "userdefined" ) {
148  } else if( lowerCaseStr == "montecarlo" ) {
149  return DataType_t::monteCarlo;
150  } else if( lowerCaseStr == "collisions" ) {
151  return DataType_t::collisions;
152  } else if( lowerCaseStr == "cosmics" ) {
153  return DataType_t::cosmics;
154  } else if( lowerCaseStr == "heavyioncollisions" ) {
156  } else { // otherwise, warn the user and return "userDefined"
157  ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
158  <<str<<", returning userDefined.");
160  }
161 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyArrayType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

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

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

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

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

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

Definition at line 112 of file AthMonitorAlgorithm.cxx.

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

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

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

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

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

◆ fillHistograms()

StatusCode MuonTrackMonitorAlgorithm::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

Get the EventInfo

Implements AthMonitorAlgorithm.

Definition at line 707 of file MuonTrackMonitorAlgorithm.cxx.

708 {
709  using namespace Monitored;
710 
712  if ((!m_derEventInfoKey.empty()) && (!m_MuonContainerKey.empty()) && (!m_VertexContainerKey.empty())) {
714  if (ATH_UNLIKELY(! EventInfo.isValid())) {
715  ATH_MSG_ERROR("Unable to retrieve Event Info " << m_MuonContainerKey);
716  return StatusCode::FAILURE;
717  }
718 
719  const xAOD::Vertex *pvtx = nullptr;
721  if (!Vertices.isValid()) {
722  ATH_MSG_ERROR("Unable to retrieve Vertex container" << m_VertexContainerKey);
723  return StatusCode::FAILURE;
724  }
725  else {
726  pvtx = getPrimaryVertex(*Vertices);
727  }
728 
730  if (ATH_UNLIKELY(! Muons.isValid())) {
731  ATH_MSG_ERROR("Unable to retrieve muon container " << m_MuonContainerKey);
732  return StatusCode::FAILURE;
733  }
734 
737 
738  }
739 
740  return StatusCode::SUCCESS;
741 }

◆ FillMuonInformation()

StatusCode MuonTrackMonitorAlgorithm::FillMuonInformation ( const std::string &  sIdentifier,
std::vector< const xAOD::Muon * > &  vecMuons,
const xAOD::Vertex pvtx,
const xAOD::EventInfo evt 
) const
private

Fills data-quality information (e.g.

pt, eta, phi..) to histograms for given selection of muons std::string sIdentifier = "CB","ZBoson","Jpsi": String which is used to match the histogramming variables that are defined by the Python script std::vector<const xAOD::Muon*> &vecMuons: Vector of muons for which performance plots should be created

Declaring all variables that are initialized via Python will be plotted

Loop over all Muons

Fill ME Track information

Basic kinematic Information

Hit Information of the ID

Hit Information per layer

Save Eta/Phi Information for medium and tight muons, to be used for lates efficiency studies

Momentum Resolution and chi2 studies of MS and ID only tracks

Momentum Resolution and chi2 studies of MS and ID only tracks

Count ID, ME and MS muons in LumiBlocks

Definition at line 94 of file MuonTrackMonitorAlgorithm.cxx.

95 {
97  using namespace Monitored;
98  auto tool = getGroup("MuonTrackMonitorAlgorithm");
99  auto MuonEta = Monitored::Scalar<float>((sIdentifier+"MuonEta").c_str(), 0);
100  auto MuonPhi = Monitored::Scalar<float>((sIdentifier+"MuonPhi").c_str(), 0);
101  auto MuonEtaTight = Monitored::Scalar<float>((sIdentifier+"MuonEtaTight").c_str(), 0);
102  auto MuonPhiTight = Monitored::Scalar<float>((sIdentifier+"MuonPhiTight").c_str(), 0);
103  auto MuonEtaMedium = Monitored::Scalar<float>((sIdentifier+"MuonEtaMedium").c_str(), 0);
104  auto MuonPhiMedium = Monitored::Scalar<float>((sIdentifier+"MuonPhiMedium").c_str(), 0);
105  auto MuonD0 = Monitored::Scalar<float>((sIdentifier+"MuonD0").c_str(), 0);
106  auto MuonZ0 = Monitored::Scalar<float>((sIdentifier+"MuonZ0").c_str(), 0);
107  auto MuonPt = Monitored::Scalar<float>((sIdentifier+"MuonPt").c_str(), 0);
108  auto MuonDPTIDME = Monitored::Scalar<float>((sIdentifier+"MuonDPTIDME").c_str(), 0);
109  auto MuonDPTIDMS = Monitored::Scalar<float>((sIdentifier+"MuonDPTIDMS").c_str(), 0);
110  auto MuonDPTIDMECB = Monitored::Scalar<float>((sIdentifier+"MuonDPTIDMECB").c_str(), 0);
111  auto MuonDPTCBME = Monitored::Scalar<float>((sIdentifier+"MuonDPTCBME").c_str(), 0);
112  auto MuonsNBHits = Monitored::Scalar<float>((sIdentifier+"MuonNBHits").c_str(), 0);
113  auto MuonsNPixHits = Monitored::Scalar<float>((sIdentifier+"MuonNPixHits").c_str(), 0);
114  auto MuonsNSCTHits = Monitored::Scalar<float>((sIdentifier+"MuonNSCTHits").c_str(), 0);
115  auto MuonsNTRTHits = Monitored::Scalar<float>((sIdentifier+"MuonNTRTHits").c_str(), 0);
116  auto MuonsNBHitsAvg = Monitored::Scalar<float>((sIdentifier+"MuonNBHitsAvg").c_str(), 0);
117  auto MuonsNPixHitsAvg = Monitored::Scalar<float>((sIdentifier+"MuonNPixHitsAvg").c_str(), 0);
118  auto MuonsNSCTHitsAvg = Monitored::Scalar<float>((sIdentifier+"MuonNSCTHitsAvg").c_str(), 0);
119  auto MuonsNTRTHitsAvg = Monitored::Scalar<float>((sIdentifier+"MuonNTRTHitsAvg").c_str(), 0);
120  auto MuonsIDchi2ndof = Monitored::Scalar<float>((sIdentifier+"MuonIDchi2ndof").c_str(), 0);
121  auto MuonsMEchi2ndof = Monitored::Scalar<float>((sIdentifier+"MuonMEchi2ndof").c_str(), 0);
122  auto MuonsEtaHitsLayer1 = Monitored::Scalar<float>((sIdentifier+"MuonsEtaHitsLayer1").c_str(), 0);
123  auto MuonsEtaHitsLayer2 = Monitored::Scalar<float>((sIdentifier+"MuonsEtaHitsLayer2").c_str(), 0);
124  auto MuonsEtaHitsLayer3 = Monitored::Scalar<float>((sIdentifier+"MuonsEtaHitsLayer3").c_str(), 0);
125  auto MuonsEtaHitsLayer4 = Monitored::Scalar<float>((sIdentifier+"MuonsEtaHitsLayer4").c_str(), 0);
126  auto MuonsPhiHitsLayer1 = Monitored::Scalar<float>((sIdentifier+"MuonsPhiHitsLayer1").c_str(), 0);
127  auto MuonsPhiHitsLayer2 = Monitored::Scalar<float>((sIdentifier+"MuonsPhiHitsLayer2").c_str(), 0);
128  auto MuonsPhiHitsLayer3 = Monitored::Scalar<float>((sIdentifier+"MuonsPhiHitsLayer3").c_str(), 0);
129  auto MuonsPhiHitsLayer4 = Monitored::Scalar<float>((sIdentifier+"MuonsPhiHitsLayer4").c_str(), 0);
130 
131  auto LumiBlock = Monitored::Scalar<float>("LumiBlock", 0);
132  auto LumiBlockTrackCategory = Monitored::Scalar<float>("LumiBlockTrackCategory", 0);
133 
134  uint32_t lumiBlockID = evt.lumiBlock();
135  LumiBlock = lumiBlockID;
136  LumiBlockTrackCategory = getTrackCategoryID(sIdentifier);
137 
139  for(unsigned int n=0; n<vecMuons.size(); n++) {
140  const xAOD::Muon* muon = vecMuons[n];
141  xAOD::Muon::MuonType muonType = muon->muonType();
142  xAOD::Muon::Quality muonQuality = muon->quality();
143 
145  ATH_CHECK ( FillTrackInformation(sIdentifier, muon, pvtx, "ME", evt) );
146 
148  MuonEta = muon->eta();
149  MuonPhi = muon->phi();
150  MuonPt = muon->pt() * MeVtoGeV;
151 
152  const xAOD::TrackParticle *metp = muon->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
153  const xAOD::TrackParticle *idtp = muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
154  const xAOD::TrackParticle *mstp = muon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
155 
156  fill(tool, LumiBlock, LumiBlockTrackCategory);
157 
158  if (muonType==xAOD::Muon::Combined) {
159  const xAOD::TrackParticle *cbtp = muon->trackParticle(xAOD::Muon::CombinedTrackParticle);
160 
161  if (cbtp) {
162  uint8_t hitval_numberOfBLayerHits, hitval_numberOfPixelHits, hitval_numberOfSCTHits, hitval_numberOfTRTHits;
163  cbtp->summaryValue(hitval_numberOfBLayerHits, xAOD::SummaryType::numberOfInnermostPixelLayerHits);
164  cbtp->summaryValue(hitval_numberOfPixelHits, xAOD::SummaryType::numberOfPixelHits);
165  cbtp->summaryValue(hitval_numberOfSCTHits, xAOD::SummaryType::numberOfSCTHits);
166  cbtp->summaryValue(hitval_numberOfTRTHits, xAOD::SummaryType::numberOfTRTHits);
167 
168  MuonZ0 = cbtp->z0();
169  MuonD0 = cbtp->d0();
170 
171  fill(tool, MuonEta, MuonPhi, MuonPt, MuonZ0, MuonD0);
172 
174  MuonsNBHits = static_cast<unsigned int>(hitval_numberOfBLayerHits);
175  MuonsNPixHits = static_cast<unsigned int>(hitval_numberOfPixelHits);
176  MuonsNSCTHits = static_cast<unsigned int>(hitval_numberOfSCTHits);
177  MuonsNTRTHits = static_cast<unsigned int>(hitval_numberOfTRTHits);
178  fill(tool, MuonsNBHits, MuonsNPixHits, MuonsNSCTHits, MuonsNTRTHits);
179  MuonsNBHitsAvg = hitval_numberOfBLayerHits / vecMuons.size();
180  MuonsNPixHitsAvg = hitval_numberOfPixelHits / vecMuons.size();
181  MuonsNSCTHitsAvg = hitval_numberOfSCTHits / vecMuons.size();
182  MuonsNTRTHitsAvg = hitval_numberOfTRTHits / vecMuons.size();
183  fill(tool, MuonsNBHitsAvg, MuonsNPixHitsAvg, MuonsNSCTHitsAvg, MuonsNTRTHitsAvg);
184 
186  uint8_t hitval_nEtaLayer1{0}, hitval_nEtaLayer2{0}, hitval_nEtaLayer3{0}, hitval_nEtaLayer4{0};
187  uint8_t hitval_nPhiLayer1{0}, hitval_nPhiLayer2{0}, hitval_nPhiLayer3{0}, hitval_nPhiLayer4{0};
188  muon->summaryValue(hitval_nEtaLayer1, xAOD::MuonSummaryType::etaLayer1Hits);
189  muon->summaryValue(hitval_nEtaLayer2, xAOD::MuonSummaryType::etaLayer2Hits);
190  muon->summaryValue(hitval_nEtaLayer3, xAOD::MuonSummaryType::etaLayer3Hits);
191  muon->summaryValue(hitval_nEtaLayer4, xAOD::MuonSummaryType::etaLayer4Hits);
192  muon->summaryValue(hitval_nPhiLayer1, xAOD::MuonSummaryType::phiLayer1Hits);
193  muon->summaryValue(hitval_nPhiLayer2, xAOD::MuonSummaryType::phiLayer2Hits);
194  muon->summaryValue(hitval_nPhiLayer3, xAOD::MuonSummaryType::phiLayer3Hits);
195  muon->summaryValue(hitval_nPhiLayer4, xAOD::MuonSummaryType::phiLayer4Hits);
196  MuonsEtaHitsLayer1 = static_cast<unsigned int>(hitval_nEtaLayer1);
197  MuonsEtaHitsLayer2 = static_cast<unsigned int>(hitval_nEtaLayer2);
198  MuonsEtaHitsLayer3 = static_cast<unsigned int>(hitval_nEtaLayer3);
199  MuonsEtaHitsLayer4 = static_cast<unsigned int>(hitval_nEtaLayer4);
200  MuonsPhiHitsLayer1 = static_cast<unsigned int>(hitval_nPhiLayer1);
201  MuonsPhiHitsLayer2 = static_cast<unsigned int>(hitval_nPhiLayer2);
202  MuonsPhiHitsLayer3 = static_cast<unsigned int>(hitval_nPhiLayer3);
203  MuonsPhiHitsLayer4 = static_cast<unsigned int>(hitval_nPhiLayer4);
204  fill(tool, MuonsEtaHitsLayer1, MuonsEtaHitsLayer2, MuonsEtaHitsLayer3, MuonsEtaHitsLayer4, MuonsPhiHitsLayer1, MuonsPhiHitsLayer2, MuonsPhiHitsLayer3, MuonsPhiHitsLayer4);
205 
208  if (muonQuality==xAOD::Muon::Medium) {
209  MuonEtaMedium = cbtp->eta();
210  MuonPhiMedium = cbtp->phi();
211  fill(tool, MuonEtaMedium, MuonPhiMedium);
212  }
213  if (muonQuality==xAOD::Muon::Tight) {
214  MuonEtaTight = cbtp->eta();
215  MuonPhiTight = cbtp->phi();
216  fill(tool, MuonEtaTight, MuonPhiTight);
217  }
219  if (idtp && metp) {
220  MuonDPTIDME = (idtp->pt() - metp->pt()) / idtp->pt();
221  MuonDPTCBME = (cbtp->pt() - metp->pt()) / cbtp->pt();
222  MuonDPTIDMECB = (idtp->pt() - metp->pt()) / cbtp->pt();
223  MuonsIDchi2ndof = idtp->chiSquared()/std::max(1.f,idtp->numberDoF());
224  MuonsMEchi2ndof = metp->chiSquared()/std::max(1.f,metp->numberDoF());
225  fill(tool, MuonDPTIDME, MuonsIDchi2ndof, MuonsMEchi2ndof);
226  }
227  }
228  }
229  else {
230  const xAOD::TrackParticle *ptp = muon->primaryTrackParticle();
231  if (ptp) {
232  MuonZ0 = ptp->z0();
233  MuonD0 = ptp->d0();
234 
235  fill(tool, MuonEta, MuonPhi, MuonPt, MuonZ0, MuonD0);
236 
237  // Information on hits in each layer
238  uint8_t hitval_numberOfBLayerHits{0}, hitval_numberOfPixelHits{0}, hitval_numberOfSCTHits{0}, hitval_numberOfTRTHits{0};
239  ptp->summaryValue(hitval_numberOfBLayerHits, xAOD::SummaryType::numberOfInnermostPixelLayerHits);
240  ptp->summaryValue(hitval_numberOfPixelHits, xAOD::SummaryType::numberOfPixelHits);
241  ptp->summaryValue(hitval_numberOfSCTHits, xAOD::SummaryType::numberOfSCTHits);
242  ptp->summaryValue(hitval_numberOfTRTHits, xAOD::SummaryType::numberOfTRTHits);
243  MuonsNBHits = static_cast<unsigned int>(hitval_numberOfBLayerHits);
244  MuonsNPixHits = static_cast<unsigned int>(hitval_numberOfPixelHits);
245  MuonsNSCTHits = static_cast<unsigned int>(hitval_numberOfSCTHits);
246  MuonsNTRTHits = static_cast<unsigned int>(hitval_numberOfTRTHits);
247  fill(tool, MuonsNBHits, MuonsNPixHits, MuonsNSCTHits, MuonsNTRTHits);
248 
250  if (idtp && metp) {
251  MuonDPTIDME = (idtp->pt() - metp->pt()) / idtp->pt();
252  MuonsIDchi2ndof = idtp->chiSquared()/idtp->numberDoF();
253  MuonsMEchi2ndof = metp->chiSquared()/metp->numberDoF();
254  fill(tool, MuonDPTIDME, MuonsIDchi2ndof, MuonsMEchi2ndof);
255  }
256  }
257  }
258 
260  auto muonEta = muon->eta();
261  if (mstp) {
262  if (muonEta > 1.05) {
263  LumiBlockTrackCategory = getTrackCategoryID("MS_EA");
264  } else if (muonEta > 0) {
265  LumiBlockTrackCategory = getTrackCategoryID("MS_BA");
266  } else if (muonEta > -1.05) {
267  LumiBlockTrackCategory = getTrackCategoryID("MS_BC");
268  } else if (muonEta <= -1.05) {
269  LumiBlockTrackCategory = getTrackCategoryID("MS_EC");
270  }
271  fill(tool, LumiBlock, LumiBlockTrackCategory);
272  }
273  if (idtp) {
274  auto muonEta = muon->eta();
275  if (muonEta > 1.05) {
276  LumiBlockTrackCategory = getTrackCategoryID("ID_EA");
277  } else if (muonEta > 0) {
278  LumiBlockTrackCategory = getTrackCategoryID("ID_BA");
279  } else if (muonEta > -1.05) {
280  LumiBlockTrackCategory = getTrackCategoryID("ID_BC");
281  } else if (muonEta <= -1.05) {
282  LumiBlockTrackCategory = getTrackCategoryID("ID_EC");
283  }
284  fill(tool, LumiBlock, LumiBlockTrackCategory);
285  }
286  if (metp) {
287  auto muonEta = muon->eta();
288  if (muonEta > 1.05) {
289  LumiBlockTrackCategory = getTrackCategoryID("ME_EA");
290  } else if (muonEta > 0) {
291  LumiBlockTrackCategory = getTrackCategoryID("ME_BA");
292  } else if (muonEta > -1.05) {
293  LumiBlockTrackCategory = getTrackCategoryID("ME_BC");
294  } else if (muonEta <= -1.05) {
295  LumiBlockTrackCategory = getTrackCategoryID("ME_EC");
296  }
297  fill(tool, LumiBlock, LumiBlockTrackCategory);
298  }
299  }
300  return StatusCode::SUCCESS;
301 }

◆ FillTrackInformation()

StatusCode MuonTrackMonitorAlgorithm::FillTrackInformation ( const std::string &  sIdentifier,
const xAOD::Muon muon,
const xAOD::Vertex pvtx,
const std::string &  sTrack,
const xAOD::EventInfo evt 
) const
private

Function to fill low level Track information.

Declaring all track variables

Definition at line 38 of file MuonTrackMonitorAlgorithm.cxx.

39 {
40 
41 
42  const double beamPosSigmaX = m_useBeamSpot ? evt.beamPosSigmaX() : -1.;
43  const double beamPosSigmaY = m_useBeamSpot ? evt.beamPosSigmaY() : -1.;
44  const double beamPosSigmaXY = m_useBeamSpot ? evt.beamPosSigmaXY() : -1.;
45 
47  using namespace Monitored;
48  auto tool = getGroup("MuonTrackMonitorAlgorithm");
49  auto Author = Monitored::Scalar<float>((sIdentifier+sTrack+"Author").c_str(), -1);
50  auto Quality = Monitored::Scalar<float>((sIdentifier+sTrack+"Quality").c_str(), -1);
51  auto Type = Monitored::Scalar<float>((sIdentifier+sTrack+"Quality").c_str(), -1);
52  auto Eta = Monitored::Scalar<float>((sIdentifier+sTrack+"Eta").c_str(), -9);
53  auto Phi = Monitored::Scalar<float>((sIdentifier+sTrack+"Phi").c_str(), -9);
54  auto Pt = Monitored::Scalar<float>((sIdentifier+sTrack+"Pt").c_str(), -9);
55  auto D0 = Monitored::Scalar<float>((sIdentifier+sTrack+"D0").c_str(), -9);
56  auto Z0 = Monitored::Scalar<float>((sIdentifier+sTrack+"Z0").c_str(), -9);
57  auto deltaZ0 = Monitored::Scalar<float>((sIdentifier+sTrack+"deltaZ0").c_str(), -9);
58  auto D0sig = Monitored::Scalar<float>((sIdentifier+sTrack+"D0sig").c_str(), -9);
59  auto chi2ndof = Monitored::Scalar<float>((sIdentifier+sTrack+"chi2ndof").c_str(), -9);
60 
61  Author = muon->author();
62  Quality = muon->quality();
63  Type = muon->type();
64 
65  // fill track particle hists
66  const xAOD::TrackParticle *tp = nullptr;
67  if (sTrack == "ME") {
68  tp = muon->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
69  }
70  if (sTrack == "MS") {
71  tp = muon->trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
72  }
73  if (tp) {
74  Eta = tp->eta();
75  Phi = tp->phi();
76  Pt = tp->pt() * MeVtoGeV;
77  D0 = tp->d0();
78  Z0 = tp->z0();
79  chi2ndof = tp->chiSquared()/std::max(1.f,tp->numberDoF());
80 
81  if (pvtx) {
82  deltaZ0 = tp->z0() + tp->vz() - pvtx->z();
83  }
84 
85  D0sig = m_useBeamSpot ? xAOD::TrackingHelpers::d0significance( tp, beamPosSigmaX, beamPosSigmaY, beamPosSigmaXY ) : -1.;
86 
87  fill(tool, Author, Quality, Type, Eta, Phi, Pt, D0, Z0, chi2ndof, deltaZ0, D0sig);
88  }
89  return StatusCode::SUCCESS;
90 }

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

◆ getGroup()

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

Get a specific monitoring tool from the tool handle array.

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

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

Definition at line 164 of file AthMonitorAlgorithm.cxx.

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

◆ getPrimaryVertex()

const xAOD::Vertex * MuonTrackMonitorAlgorithm::getPrimaryVertex ( const xAOD::VertexContainer Vertices) const
private

Function to get the primary vertex.

Definition at line 745 of file MuonTrackMonitorAlgorithm.cxx.

746 {
747  const xAOD::Vertex *pvtx = nullptr;
748  for(const auto vertex : Vertices){
749  if (vertex->vertexType() == xAOD::VxType::PriVtx) {
750  pvtx = vertex;
751  }
752  }
753  return pvtx;
754 }

◆ getTrackCategoryID()

int MuonTrackMonitorAlgorithm::getTrackCategoryID ( const std::string &  sIdentifier) const
private

Function to get the track category ID for the given identifier.

Definition at line 757 of file MuonTrackMonitorAlgorithm.cxx.

758 {
759  int trackCategoryID = -1;
760 
761  if (sIdentifier == "NoTrigNonCB") trackCategoryID = 1;
762  else if (sIdentifier == "NoTrigCB") trackCategoryID = 2;
763  else if (sIdentifier == "NonCB") trackCategoryID = 3;
764  else if (sIdentifier == "CB") trackCategoryID = 4;
765  else if (sIdentifier == "AllNonCB") trackCategoryID = 5;
766  else if (sIdentifier == "AllCB") trackCategoryID = 6;
767  // --------------------
768  else if (sIdentifier == "Z") trackCategoryID = 8;
769  else if (sIdentifier == "Jpsi") trackCategoryID = 9;
770  // --------------------
771  else if (sIdentifier == "ME_EC") trackCategoryID = 11;
772  else if (sIdentifier == "ME_BC") trackCategoryID = 12;
773  else if (sIdentifier == "ME_BA") trackCategoryID = 13;
774  else if (sIdentifier == "ME_EA") trackCategoryID = 14;
775  // --------------------
776  else if (sIdentifier == "MS_EC") trackCategoryID = 16;
777  else if (sIdentifier == "MS_BC") trackCategoryID = 17;
778  else if (sIdentifier == "MS_BA") trackCategoryID = 18;
779  else if (sIdentifier == "MS_EA") trackCategoryID = 19;
780  // --------------------
781  else if (sIdentifier == "ID_EC") trackCategoryID = 21;
782  else if (sIdentifier == "ID_BC") trackCategoryID = 22;
783  else if (sIdentifier == "ID_BA") trackCategoryID = 23;
784  else if (sIdentifier == "ID_EA") trackCategoryID = 24;
785 
786  return trackCategoryID;
787 }

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

initialize

Returns
StatusCode

https://gitlab.cern.ch/atlas/athena/-/blob/master/Event/xAOD/xAODEventInfoCnv/src/EventInfoBeamSpotDecoratorAlg.h#L64-78

Reimplemented from AthMonitorAlgorithm.

Definition at line 20 of file MuonTrackMonitorAlgorithm.cxx.

21 {
24  ATH_CHECK(m_MuonIsoDecorKey.initialize());
28 
29  for (const std::string beam : {"beamPosSigmaX", "beamPosSigmaY", "beamPosSigmaZ", "beamPosSigmaXY"}) {
30  m_beamSpotKey.emplace_back(m_derEventInfoKey.key() + "."+beam);
31  }
33  return StatusCode::SUCCESS;
34 }

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

◆ plotResonanceCandidates()

StatusCode MuonTrackMonitorAlgorithm::plotResonanceCandidates ( const std::string &  resonanceName,
std::vector< const xAOD::Muon * > &  muonCandidates,
const xAOD::Vertex pvtx,
const xAOD::EventInfo evt 
) const
private

Function to create performance plots for all combined muons that lead to a Jpsi Meson Candidate event.

Declaring all variables that are initialized via Python will be plotted

Z Boson related plots

Fill the relevant Muon Information for each Z Boson Candidate Muon

Definition at line 511 of file MuonTrackMonitorAlgorithm.cxx.

511  {
512 
513  uint32_t lumiBlockID = evt.lumiBlock();
514 
515  using namespace Monitored;
516 
518  auto tool = getGroup("MuonTrackMonitorAlgorithm");
519  auto Eta = Monitored::Scalar<float>((resonanceName+"Eta").c_str(), 0);
520  auto Mass = Monitored::Scalar<float>((resonanceName+"Mass").c_str(), 0);
521  auto MuonLumiBlock = Monitored::Scalar<float>((resonanceName+"MuonLumiBlock").c_str(), 0);
522  auto muMinusEta = Monitored::Scalar<float>((resonanceName+"muMinusEta").c_str(), -9);
523  auto muPlusEta = Monitored::Scalar<float>((resonanceName+"muPlusEta").c_str(), -9);
524  auto Eta2D = Monitored::Scalar<const char*>((resonanceName+"Eta2D").c_str(), "outside");
525  auto Eta2 = Monitored::Scalar<int>((resonanceName+"Eta2").c_str(), -8);
526 
528  std::map<int, int> mapTagged_Resonance;
529  std::vector<const xAOD::Muon*> vecMuons;
530  for (unsigned int n=0; n<muonCandidates.size(); n++)
531  mapTagged_Resonance[n]=0;
532  for (unsigned int n=0; n<muonCandidates.size(); n++){
533  const TLorentzVector& tVec1 = muonCandidates[n]->p4();
534  for (unsigned int m=n+1; m<muonCandidates.size(); m++) {
535  const TLorentzVector& tVec2 = muonCandidates[m]->p4();
536  const TLorentzVector candidate = tVec1 + tVec2;
537  const float resonance_Mass = candidate.M() * MeVtoGeV;
538  const float resonance_Eta = candidate.Eta();
539  if (muonCandidates[n]->charge()==muonCandidates[m]->charge()) continue;
540  if ((candidate.M() < m_ZBosonSelection_minMass)&&(resonanceName=="Z")) continue;
541  if ((candidate.M() > m_ZBosonSelection_maxMass)&&(resonanceName=="Z")) continue;
542  if ((candidate.M() < m_JpsiSelection_minMass)&&(resonanceName=="Jpsi")) continue;
543  if ((candidate.M() > m_JpsiSelection_maxMass)&&(resonanceName=="Jpsi")) continue;
544 
545  if (mapTagged_Resonance[n]!=1) vecMuons.push_back(muonCandidates[n]);
546  mapTagged_Resonance[n]=1;
547  if (mapTagged_Resonance[m]!=1) vecMuons.push_back(muonCandidates[m]);
548  mapTagged_Resonance[m]=1;
549 
550  if (muonCandidates[n]->charge()<0){
551  muMinusEta = tVec1.Eta();
552  muPlusEta = tVec2.Eta();
553  }
554  else{
555  muMinusEta = tVec2.Eta();
556  muPlusEta = tVec1.Eta();
557  }
558  const char* EtaReg = "";
559  int EtaRegio = -9;
560  if ((muMinusEta>1.05)&&(muPlusEta>1.05)){
561  EtaReg = "EA_EA";
562  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
563  Mass2D = resonance_Mass;
564  fill(tool, Mass2D);
565  } else if ((muMinusEta>1.05)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
566  EtaReg = "EA_BA";
567  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
568  Mass2D = resonance_Mass;
569  fill(tool, Mass2D);
570  } else if ((muMinusEta>1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
571  EtaReg = "EA_BC";
572  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
573  Mass2D = resonance_Mass;
574  fill(tool, Mass2D);
575  } else if ((muMinusEta>1.05)&&(muPlusEta<-1.05)){
576  EtaReg = "EA_EC";
577  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
578  Mass2D = resonance_Mass;
579  fill(tool, Mass2D);
580  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>1.05)){
581  EtaReg = "BA_EA";
582  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
583  Mass2D = resonance_Mass;
584  fill(tool, Mass2D);
585  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
586  EtaReg = "BA_BA";
587  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
588  Mass2D = resonance_Mass;
589  fill(tool, Mass2D);
590  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
591  EtaReg = "BA_BC";
592  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
593  Mass2D = resonance_Mass;
594  fill(tool, Mass2D);
595  } else if ((muMinusEta>0.)&&(muMinusEta<1.05)&&(muPlusEta<-1.05)){
596  EtaReg = "BA_EC";
597  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
598  Mass2D = resonance_Mass;
599  fill(tool, Mass2D);
600  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>1.05)){
601  EtaReg = "BC_EA";
602  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
603  Mass2D = resonance_Mass;
604  fill(tool, Mass2D);
605  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
606  EtaReg = "BC_BA";
607  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
608  Mass2D = resonance_Mass;
609  fill(tool, Mass2D);
610  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
611  EtaReg = "BC_BC";
612  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
613  Mass2D = resonance_Mass;
614  fill(tool, Mass2D);
615  } else if ((muMinusEta>-1.05)&&(muMinusEta<0.)&&(muPlusEta<-1.05)){
616  EtaReg = "BC_EC";
617  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
618  Mass2D = resonance_Mass;
619  fill(tool, Mass2D);
620  } else if ((muMinusEta<-1.05)&&(muPlusEta>1.05)){
621  EtaReg = "EC_EA";
622  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
623  Mass2D = resonance_Mass;
624  fill(tool, Mass2D);
625  } else if ((muMinusEta<-1.05)&&(muPlusEta>0.)&&(muPlusEta<1.05)){
626  EtaReg = "EC_BA";
627  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
628  Mass2D = resonance_Mass;
629  fill(tool, Mass2D);
630  } else if ((muMinusEta<-1.05)&&(muPlusEta>-1.05)&&(muPlusEta<0.)){
631  EtaReg = "EC_BC";
632  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
633  Mass2D = resonance_Mass;
634  fill(tool, Mass2D);
635  } else if ((muMinusEta<-1.05)&&(muPlusEta<-1.05)){
636  EtaReg = "EC_EC";
637  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
638  Mass2D = resonance_Mass;
639  fill(tool, Mass2D);
640  } else {
641  EtaReg = "out";
642  auto Mass2D = Monitored::Scalar<float>((resonanceName+"Mass_"+EtaReg).c_str(), 0);
643  }
644  Mass = resonance_Mass;
645  Eta = resonance_Eta;
646  Eta2D = EtaReg;
647  Eta2 = EtaRegio;
648  fill(tool, Mass, Eta, Eta2, Eta2D, muMinusEta, muPlusEta);
649 
650  MuonLumiBlock = lumiBlockID;
651  fill(tool, MuonLumiBlock);
652  }
653  }
654 
656  ATH_CHECK( FillMuonInformation(resonanceName, vecMuons, pvtx, evt) );
657 
658  return StatusCode::SUCCESS;
659 }

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

◆ sysStart()

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

Handle START transition.

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

◆ trigChainsArePassed()

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

Check whether triggers are passed.

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

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

Definition at line 199 of file AthMonitorAlgorithm.cxx.

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

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ acc

def MuonTrackMonitorAlgorithm.acc = MuonTrackConfig(flags)

Definition at line 1968 of file MuonTrackMonitorAlgorithm.py.

◆ cfg

MuonTrackMonitorAlgorithm.cfg = MainServicesCfg(flags)

Definition at line 1966 of file MuonTrackMonitorAlgorithm.py.

◆ Files

MuonTrackMonitorAlgorithm.Files

Definition at line 1960 of file MuonTrackMonitorAlgorithm.py.

◆ flags

MuonTrackMonitorAlgorithm.flags = initConfigFlags()

Definition at line 1959 of file MuonTrackMonitorAlgorithm.py.

◆ HISTFileName

MuonTrackMonitorAlgorithm.HISTFileName

Definition at line 1961 of file MuonTrackMonitorAlgorithm.py.

◆ m_beamSpotKey

SG::ReadDecorHandleKeyArray<xAOD::EventInfo> MuonTrackMonitorAlgorithm::m_beamSpotKey {this, "BeamSpotKeys" ,{}, "Add the scheduler dependencies on the beamspot information"}
private

Definition at line 38 of file MuonTrackMonitorAlgorithm.h.

◆ m_CBmuons_minPt

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_CBmuons_minPt { this, "CBmuons_minPt", 20000., "Minimal muon pt used for CB muons" }
private

Definition at line 73 of file MuonTrackMonitorAlgorithm.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_derEventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> MuonTrackMonitorAlgorithm::m_derEventInfoKey {this, "EventInfo", "EventInfo", ""}
private

Definition at line 37 of file MuonTrackMonitorAlgorithm.h.

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_enforceExpressTriggers

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

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 350 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

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

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

Definition at line 352 of file AthMonitorAlgorithm.h.

◆ m_EventInfoKey

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

Key for retrieving EventInfo from StoreGate.

Definition at line 362 of file AthMonitorAlgorithm.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_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_hltchainList

Gaudi::Property< std::vector<std::string> > MuonTrackMonitorAlgorithm::m_hltchainList { this, "HLTTriggerList", {"HLT_2mu14_L12MU8F", "HLT_mu24_ivarmedium_L1MU14FCH"}, "High-level triggers used" }
private

Definition at line 71 of file MuonTrackMonitorAlgorithm.h.

◆ m_JpsiSelection_D0Cut

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_JpsiSelection_D0Cut { this, "JpsiSelection_D0Cut", 100., "D0 cut applied for Jpsi analysis" }
private

Definition at line 86 of file MuonTrackMonitorAlgorithm.h.

◆ m_JpsiSelection_maxEta

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_JpsiSelection_maxEta { this, "JpsiSelection_maxEta", 2.5, "Maximal muon eta used for Jpsi analysis" }
private

Definition at line 84 of file MuonTrackMonitorAlgorithm.h.

◆ m_JpsiSelection_maxMass

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_JpsiSelection_maxMass { this, "JpsiSelection_maxMass", 3600, "Maximal accepted Jpsi mass" }
private

Definition at line 89 of file MuonTrackMonitorAlgorithm.h.

◆ m_JpsiSelection_minMass

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_JpsiSelection_minMass { this, "JpsiSelection_minMass", 2600, "Minimal accepted Jpsi mass" }
private

Definition at line 88 of file MuonTrackMonitorAlgorithm.h.

◆ m_JpsiSelection_minPt

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_JpsiSelection_minPt { this, "JpsiSelection_minPt", 4000., "Minimal muon pt used for Jpsi analysis" }
private

Definition at line 83 of file MuonTrackMonitorAlgorithm.h.

◆ m_JpsiSelection_trkIsolation

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_JpsiSelection_trkIsolation { this, "JpsiSelection_trkIsolation", 1.0, "Jpsi track DeltaR isolation criteria" }
private

Definition at line 85 of file MuonTrackMonitorAlgorithm.h.

◆ m_JpsiSelection_Z0Cut

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_JpsiSelection_Z0Cut { this, "JpsiSelection_Z0Cut", 100., "Z0 cut applied for Jpsi analysis" }
private

Definition at line 87 of file MuonTrackMonitorAlgorithm.h.

◆ m_lbDurationDataKey

SG::ReadCondHandleKey<LBDurationCondData> AthMonitorAlgorithm::m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
protectedinherited

Definition at line 345 of file AthMonitorAlgorithm.h.

◆ m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> AthMonitorAlgorithm::m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
protectedinherited

Definition at line 343 of file AthMonitorAlgorithm.h.

◆ m_MuonContainerKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonTrackMonitorAlgorithm::m_MuonContainerKey {this, "MuonContainerKey", "Muons", "Key for Muon Containers" }
private

Definition at line 34 of file MuonTrackMonitorAlgorithm.h.

◆ m_MuonIsoDecorKey

SG::ReadDecorHandleKey<xAOD::MuonContainer> MuonTrackMonitorAlgorithm::m_MuonIsoDecorKey {this, "MuonIsoDecorKey", "Muons.ptcone30" }
private

Definition at line 35 of file MuonTrackMonitorAlgorithm.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.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_useBeamSpot

Gaudi::Property<bool> MuonTrackMonitorAlgorithm::m_useBeamSpot {this, "RequireBeamSpot", true, "Ensure that the dependency on the beamspot variables is established."}
private

Definition at line 40 of file MuonTrackMonitorAlgorithm.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_VertexContainerKey

SG::ReadHandleKey<xAOD::VertexContainer> MuonTrackMonitorAlgorithm::m_VertexContainerKey {this, "PrimaryVerticesKey", "PrimaryVertices", "Key for primary VertexContainers"}
private

Definition at line 36 of file MuonTrackMonitorAlgorithm.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.

◆ m_ZBosonSelection_D0Cut

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_ZBosonSelection_D0Cut { this, "ZBosonSelection_D0Cut", 100., "D0 cut applied for Z boson analysis" }
private

Definition at line 78 of file MuonTrackMonitorAlgorithm.h.

◆ m_ZBosonSelection_maxEta

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_ZBosonSelection_maxEta { this, "ZBosonSelection_maxEta", 2.5, "Maximal muon eta used for Z analysis" }
private

Definition at line 76 of file MuonTrackMonitorAlgorithm.h.

◆ m_ZBosonSelection_maxMass

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_ZBosonSelection_maxMass { this, "ZBosonSelection_maxMass", 106000., "Maximal accepted Z boson mass" }
private

Definition at line 81 of file MuonTrackMonitorAlgorithm.h.

◆ m_ZBosonSelection_minMass

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_ZBosonSelection_minMass { this, "ZBosonSelection_minMass", 76000., "Minimal accepted Z boson mass" }
private

Definition at line 80 of file MuonTrackMonitorAlgorithm.h.

◆ m_ZBosonSelection_minPt

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_ZBosonSelection_minPt { this, "ZBosonSelection_minPt", 20000., "Minimal muon pt used for Z analysis" }
private

Definition at line 75 of file MuonTrackMonitorAlgorithm.h.

◆ m_ZBosonSelection_trkIsolation

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_ZBosonSelection_trkIsolation { this, "ZBosonSelection_trkIsolation", 0.2, "Track DeltaR isolation criteria" }
private

Definition at line 77 of file MuonTrackMonitorAlgorithm.h.

◆ m_ZBosonSelection_Z0Cut

Gaudi::Property< float > MuonTrackMonitorAlgorithm::m_ZBosonSelection_Z0Cut { this, "ZBosonSelection_Z0Cut", 100., "Z0 cut applied for Z boson analysis" }
private

Definition at line 79 of file MuonTrackMonitorAlgorithm.h.

◆ merge

MuonTrackMonitorAlgorithm.merge

Definition at line 1471 of file MuonTrackMonitorAlgorithm.py.

◆ opt

MuonTrackMonitorAlgorithm.opt

Definition at line 33 of file MuonTrackMonitorAlgorithm.py.

◆ path

MuonTrackMonitorAlgorithm.path

Definition at line 32 of file MuonTrackMonitorAlgorithm.py.

◆ TestFiles

list MuonTrackMonitorAlgorithm.TestFiles = ['/eos/atlas/atlascerngroupdisk/det-rpc/data/DESDM_MCP/data18_13TeV.00358615.physics_Main.merge.DESDM_MCP.f961_m2024/data18_13TeV.00358615.physics_Main.merge.DESDM_MCP.f961_m2024._0084.1']

Definition at line 1958 of file MuonTrackMonitorAlgorithm.py.

◆ title

MuonTrackMonitorAlgorithm.title

Muons.

TracksMS.

Segments.

MuonTrkPhys.

TracksME.

TracksID.

Overview.

Definition at line 31 of file MuonTrackMonitorAlgorithm.py.

◆ type

MuonTrackMonitorAlgorithm.type

Definition at line 32 of file MuonTrackMonitorAlgorithm.py.

◆ withDetails

MuonTrackMonitorAlgorithm.withDetails

Definition at line 1970 of file MuonTrackMonitorAlgorithm.py.

◆ xbins

MuonTrackMonitorAlgorithm.xbins

Definition at line 33 of file MuonTrackMonitorAlgorithm.py.

◆ xmax

MuonTrackMonitorAlgorithm.xmax

Definition at line 33 of file MuonTrackMonitorAlgorithm.py.

◆ xmin

MuonTrackMonitorAlgorithm.xmin

Definition at line 33 of file MuonTrackMonitorAlgorithm.py.

◆ ybins

MuonTrackMonitorAlgorithm.ybins

Definition at line 33 of file MuonTrackMonitorAlgorithm.py.

◆ ylabels

MuonTrackMonitorAlgorithm.ylabels

Definition at line 790 of file MuonTrackMonitorAlgorithm.py.

◆ ymax

MuonTrackMonitorAlgorithm.ymax

Definition at line 33 of file MuonTrackMonitorAlgorithm.py.

◆ ymin

MuonTrackMonitorAlgorithm.ymin

Definition at line 33 of file MuonTrackMonitorAlgorithm.py.


The documentation for this class was generated from the following files:
xAOD::phiLayer1Hits
@ phiLayer1Hits
number of phi hits in the first trigger layer (BML1 ot T4)
Definition: TrackingPrimitives.h:349
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:74
MuonTrackMonitorAlgorithm::m_MuonIsoDecorKey
SG::ReadDecorHandleKey< xAOD::MuonContainer > m_MuonIsoDecorKey
Definition: MuonTrackMonitorAlgorithm.h:35
LArL1Calo_ComputeHVCorr.LumiBlock
LumiBlock
Definition: LArL1Calo_ComputeHVCorr.py:38
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
xAOD::etaLayer1Hits
@ etaLayer1Hits
number of eta hits in the first trigger layer (BML1 ot T4)
Definition: TrackingPrimitives.h:354
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::MuonSegment_v1::x
float x() const
get_generator_info.result
result
Definition: get_generator_info.py:21
xAOD::phiLayer3Hits
@ phiLayer3Hits
number of phi hits in the third trigger layer (BOL1 ot T2)
Definition: TrackingPrimitives.h:351
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
xAOD::phiLayer4Hits
@ phiLayer4Hits
number of phi hits in the fourth trigger layer (T3)
Definition: TrackingPrimitives.h:352
MuonTrackMonitorAlgorithm::m_JpsiSelection_minMass
Gaudi::Property< float > m_JpsiSelection_minMass
Definition: MuonTrackMonitorAlgorithm.h:88
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
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
Muon::MuonStationIndex
Definition: MuonStationIndex.h:13
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
MuonTrackMonitorAlgorithm::analyseCombinedTracks
StatusCode analyseCombinedTracks(const xAOD::MuonContainer &Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
Function to create performance plots for all combined muons.
Definition: MuonTrackMonitorAlgorithm.cxx:396
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:78
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:737
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
MuonTrackMonitorAlgorithm::m_ZBosonSelection_minPt
Gaudi::Property< float > m_ZBosonSelection_minPt
Definition: MuonTrackMonitorAlgorithm.h:75
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
xAOD::TrackingHelpers::d0significance
double d0significance(const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
Definition: TrackParticlexAODHelpers.cxx:42
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
MuonTrackMonitorAlgorithm::m_MuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_MuonContainerKey
Definition: MuonTrackMonitorAlgorithm.h:34
AthMonitorAlgorithm::getTrigDecisionTool
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool() const
Get the trigger decision tool member.
Definition: AthMonitorAlgorithm.cxx:194
MuonTrackMonitorAlgorithm::m_JpsiSelection_trkIsolation
Gaudi::Property< float > m_JpsiSelection_trkIsolation
Definition: MuonTrackMonitorAlgorithm.h:85
xAOD::Iso::ptcone30
@ ptcone30
Definition: IsolationType.h:41
CP::MeVtoGeV
constexpr float MeVtoGeV
Definition: IsolationCloseByCorrectionTool.cxx:38
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::TrackParticle_v1::chiSquared
float chiSquared() const
Returns the of the overall track fit.
MuonTrackMonitorAlgorithm::m_JpsiSelection_maxMass
Gaudi::Property< float > m_JpsiSelection_maxMass
Definition: MuonTrackMonitorAlgorithm.h:89
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::MuonSegment_v1
Class describing a MuonSegment.
Definition: MuonSegment_v1.h:33
ParticleTest.tp
tp
Definition: ParticleTest.py:25
xAOD::MuonSegment_v1::pz
float pz() const
Returns the pz.
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
xAOD::MuonSegment_v1::px
float px() const
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
Phi
@ Phi
Definition: RPCdef.h:8
ATH_UNLIKELY
#define ATH_UNLIKELY(x)
Definition: AthUnlikelyMacros.h:17
MuonTrackMonitorAlgorithm::analyseResonanceCandidates
StatusCode analyseResonanceCandidates(const xAOD::MuonContainer &Muons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
Function to create performance plots for all combined muons that lead to a Z Boson Candidate event.
Definition: MuonTrackMonitorAlgorithm.cxx:663
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
MuonPt
float MuonPt(0)
cosmics
Definition: cosmics.py:1
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
MuonTrackMonitorAlgorithm::getTrackCategoryID
int getTrackCategoryID(const std::string &sIdentifier) const
Function to get the track category ID for the given identifier.
Definition: MuonTrackMonitorAlgorithm.cxx:757
Trk::Z0
@ Z0
Definition: ParameterType.h:18
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:199
xAOD::TrackParticle_v1::d0
float d0() const
Returns the parameter.
MuonEta
float MuonEta(0)
AthMonitorAlgorithm::Environment_t::user
@ user
MuonTrackMonitorAlgorithm::m_VertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_VertexContainerKey
Definition: MuonTrackMonitorAlgorithm.h:36
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
xAOD::etaLayer3Hits
@ etaLayer3Hits
number of eta hits in the third trigger layer (BOL1 ot T2)
Definition: TrackingPrimitives.h:356
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
MuonTrackMonitorAlgorithm::m_ZBosonSelection_maxMass
Gaudi::Property< float > m_ZBosonSelection_maxMass
Definition: MuonTrackMonitorAlgorithm.h:81
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
xAOD::phiLayer2Hits
@ phiLayer2Hits
number of phi hits in the second trigger layer (BML2 ot T1)
Definition: TrackingPrimitives.h:350
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
MuonTrackMonitorAlgorithm::getPrimaryVertex
const xAOD::Vertex * getPrimaryVertex(const xAOD::VertexContainer &Vertices) const
Function to get the primary vertex.
Definition: MuonTrackMonitorAlgorithm.cxx:745
xAOD::etaLayer2Hits
@ etaLayer2Hits
number of eta hits in the second trigger layer (BML2 ot T1)
Definition: TrackingPrimitives.h:355
MuonTrackMonitorAlgorithm::m_beamSpotKey
SG::ReadDecorHandleKeyArray< xAOD::EventInfo > m_beamSpotKey
Definition: MuonTrackMonitorAlgorithm.h:38
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
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
beamspotman.n
n
Definition: beamspotman.py:729
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:108
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
xAOD::MuonSegment_v1::py
float py() const
Returns the py.
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
MuonTrackMonitorAlgorithm::m_JpsiSelection_minPt
Gaudi::Property< float > m_JpsiSelection_minPt
Definition: MuonTrackMonitorAlgorithm.h:83
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
hist_file_dump.f
f
Definition: hist_file_dump.py:140
jet::CompScaleVar::Mass
@ Mass
Definition: UncertaintyEnum.h:98
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::Vertex_v1::z
float z() const
Returns the z position.
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAODType
Definition: ObjectType.h:13
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
MuonTrackMonitorAlgorithm::m_JpsiSelection_maxEta
Gaudi::Property< float > m_JpsiSelection_maxEta
Definition: MuonTrackMonitorAlgorithm.h:84
MuonTrackMonitorAlgorithm::m_JpsiSelection_D0Cut
Gaudi::Property< float > m_JpsiSelection_D0Cut
Definition: MuonTrackMonitorAlgorithm.h:86
jobOptions.beam
beam
Definition: jobOptions.SuperChic_ALP2.py:16
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
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
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
MuonTrackMonitorAlgorithm::m_ZBosonSelection_maxEta
Gaudi::Property< float > m_ZBosonSelection_maxEta
Definition: MuonTrackMonitorAlgorithm.h:76
AthMonitorAlgorithm::Environment_t::online
@ online
MuonTrackMonitorAlgorithm::m_ZBosonSelection_trkIsolation
Gaudi::Property< float > m_ZBosonSelection_trkIsolation
Definition: MuonTrackMonitorAlgorithm.h:77
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
MuonTrackMonitorAlgorithm::plotResonanceCandidates
StatusCode plotResonanceCandidates(const std::string &resonanceName, std::vector< const xAOD::Muon * > &muonCandidates, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
Function to create performance plots for all combined muons that lead to a Jpsi Meson Candidate event...
Definition: MuonTrackMonitorAlgorithm.cxx:511
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
MuonR4::SegmentFit::toInt
constexpr int toInt(const ParamDefs p)
Definition: MuonHoughDefs.h:42
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
EventInfo
This class provides general information about an event. Event information is provided by the accessor...
Definition: EventInfo/EventInfo/EventInfo.h:43
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
MuonTrackMonitorAlgorithm::m_ZBosonSelection_Z0Cut
Gaudi::Property< float > m_ZBosonSelection_Z0Cut
Definition: MuonTrackMonitorAlgorithm.h:79
charge
double charge(const T &p)
Definition: AtlasPID.h:986
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
item
Definition: ItemListSvc.h:43
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::D0
@ D0
Definition: ParameterType.h:18
MuonTrackMonitorAlgorithm::FillMuonInformation
StatusCode FillMuonInformation(const std::string &sIdentifier, std::vector< const xAOD::Muon * > &vecMuons, const xAOD::Vertex *pvtx, const xAOD::EventInfo &evt) const
Fills data-quality information (e.g.
Definition: MuonTrackMonitorAlgorithm.cxx:94
xAOD::MuonSegment_v1::z
float z() const
Returns the y position.
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:60
Prompt::Def::Pt
@ Pt
Definition: VarHolder.h:76
a
TList * a
Definition: liststreamerinfos.cxx:10
columnar::empty
bool empty() const noexcept
Definition: ObjectRange.h:163
xAOD::MuonSegment_v1::sector
int sector() const
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
xAOD::MuonSegment_v1::y
float y() const
Returns the x position.
Muons
Definition: Muons.py:1
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
MuonTrackMonitorAlgorithm::m_ZBosonSelection_D0Cut
Gaudi::Property< float > m_ZBosonSelection_D0Cut
Definition: MuonTrackMonitorAlgorithm.h:78
MuonTrackMonitorAlgorithm::m_JpsiSelection_Z0Cut
Gaudi::Property< float > m_JpsiSelection_Z0Cut
Definition: MuonTrackMonitorAlgorithm.h:87
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
MuonTrackMonitorAlgorithm::m_useBeamSpot
Gaudi::Property< bool > m_useBeamSpot
Definition: MuonTrackMonitorAlgorithm.h:40
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
xAOD::TrackParticle_v1::numberDoF
float numberDoF() const
Returns the number of degrees of freedom of the overall track or vertex fit as float.
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
MuonTrackMonitorAlgorithm::m_derEventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_derEventInfoKey
Definition: MuonTrackMonitorAlgorithm.h:37
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
MuonTrackMonitorAlgorithm::analyseLowLevelMuonFeatures
StatusCode analyseLowLevelMuonFeatures(const std::string &sIdentifier, std::vector< const xAOD::Muon * > &Muons, const xAOD::EventInfo &evt) const
Function to create performance plots for muon standalone tracks with some detailed informatiom.
Definition: MuonTrackMonitorAlgorithm.cxx:304
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
ParticleJetParams::Author
Author
Definition: ParticleJetParamDefs.h:33
NSWL1::Vertices
std::vector< Vertex > Vertices
Definition: GeoUtils.h:19
xAOD::MuonSegment_v1::chamberIndex
::Muon::MuonStationIndex::ChIndex chamberIndex() const
Returns the chamber index.
MuonTrackMonitorAlgorithm::m_CBmuons_minPt
Gaudi::Property< float > m_CBmuons_minPt
Definition: MuonTrackMonitorAlgorithm.h:73
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::etaLayer4Hits
@ etaLayer4Hits
number of eta hits in the fourth trigger layer (T3)
Definition: TrackingPrimitives.h:357
Eta
@ Eta
Definition: RPCdef.h:8
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:238
MuonTrackMonitorAlgorithm::m_hltchainList
Gaudi::Property< std::vector< std::string > > m_hltchainList
Definition: MuonTrackMonitorAlgorithm.h:71
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
ServiceHandle< ICondSvc >
MuonTrackMonitorAlgorithm::m_ZBosonSelection_minMass
Gaudi::Property< float > m_ZBosonSelection_minMass
Definition: MuonTrackMonitorAlgorithm.h:80
MuonTrackMonitorAlgorithm::FillTrackInformation
StatusCode FillTrackInformation(const std::string &sIdentifier, const xAOD::Muon *muon, const xAOD::Vertex *pvtx, const std::string &sTrack, const xAOD::EventInfo &evt) const
Function to fill low level Track information.
Definition: MuonTrackMonitorAlgorithm.cxx:38
collisions
Definition: collisions.py:1