Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
DQTGlobalWZFinderAlg Class Reference

#include <DQTGlobalWZFinderAlg.h>

Inheritance diagram for DQTGlobalWZFinderAlg:
Collaboration diagram for DQTGlobalWZFinderAlg:

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

 DQTGlobalWZFinderAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~DQTGlobalWZFinderAlg ()=default
 
virtual StatusCode initialize () override
 initialize More...
 
virtual StatusCode fillHistograms (const EventContext &ctx) const override
 adds event to the monitoring histograms More...
 
virtual StatusCode execute (const EventContext &ctx) const override
 Applies filters and trigger requirements. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by reference. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by reference. More...
 
template<typename... T>
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, T &&... variables) const
 Fills a variadic list of variables to a group by reference. More...
 
void fill (const std::string &groupName, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by name. More...
 
void fill (const std::string &groupName, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by name. More...
 
template<typename... T>
void fill (const std::string &groupName, T &&... variables) const
 Fills a variadic list of variables to a group by name. More...
 
Environment_t environment () const
 Accessor functions for the environment. More...
 
Environment_t envStringToEnum (const std::string &str) const
 Convert the environment string from the python configuration to an enum object. More...
 
DataType_t dataType () const
 Accessor functions for the data type. More...
 
DataType_t dataTypeStringToEnum (const std::string &str) const
 Convert the data type string from the python configuration to an enum object. More...
 
const ToolHandle< GenericMonitoringTool > & getGroup (const std::string &name) const
 Get a specific monitoring tool from the tool handle array. More...
 
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool () const
 Get the trigger decision tool member. More...
 
bool trigChainsArePassed (const std::vector< std::string > &vTrigNames) const
 Check whether triggers are passed. More...
 
SG::ReadHandle< xAOD::EventInfo > GetEventInfo (const EventContext &) const
 Return a ReadHandle for an EventInfo object (get run/event numbers, etc.) More...
 
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average mu, i.e. More...
 
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate instantaneous number of interactions, i.e. More...
 
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1). More...
 
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the instantaneous luminosity per bunch crossing. More...
 
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the duration of the luminosity block (in seconds) More...
 
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average luminosity livefraction. More...
 
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the live fraction per bunch crossing ID. More...
 
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average integrated luminosity multiplied by the live fraction. More...
 
virtual StatusCode parseList (const std::string &line, std::vector< std::string > &result) const
 Parse a string into a vector. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

ToolHandleArray< GenericMonitoringTool > m_tools {this,"GMTools",{}}
 Array of Generic Monitoring Tools. More...
 
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool {this, "TrigDecisionTool",""}
 Tool to tell whether a specific trigger is passed. More...
 
ToolHandleArray< IDQFilterTool > m_DQFilterTools {this,"FilterTools",{}}
 Array of Data Quality filter tools. More...
 
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}
 
AthMonitorAlgorithm::Environment_t m_environment
 Instance of the Environment_t enum. More...
 
AthMonitorAlgorithm::DataType_t m_dataType
 Instance of the DataType_t enum. More...
 
Gaudi::Property< std::string > m_environmentStr {this,"Environment","user"}
 Environment string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_dataTypeStr {this,"DataType","userDefined"}
 DataType string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_triggerChainString {this,"TriggerChain",""}
 Trigger chain string pulled from the job option and parsed into a vector. More...
 
std::vector< std::string > m_vTrigChainNames
 Vector of trigger chain names parsed from trigger chain string. More...
 
Gaudi::Property< std::string > m_fileKey {this,"FileKey",""}
 Internal Athena name for file. More...
 
Gaudi::Property< bool > m_useLumi {this,"EnableLumi",false}
 Allows use of various luminosity functions. More...
 
Gaudi::Property< float > m_defaultLBDuration {this,"DefaultLBDuration",60.}
 Default duration of one lumi block. More...
 
Gaudi::Property< int > m_detailLevel {this,"DetailLevel",0}
 Sets the level of detail used in the monitoring. More...
 
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey {this,"EventInfoKey","EventInfo"}
 Key for retrieving EventInfo from StoreGate. More...
 

Private Types

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

Private Member Functions

bool kinematicCuts (const xAOD::Egamma *particle) const
 
bool goodElectrons (const xAOD::Electron *electron_itr, const xAOD::Vertex *pVtx, const EventContext &ctx) const
 
bool antiGoodElectrons (const xAOD::Electron *electron_itr, const xAOD::Vertex *pVtx, const EventContext &ctx) const
 
void fillEleEffHistos (bool tag_good, bool probe_good, bool probe_anti_good, bool os, double el_mass) const
 
void doEleTriggerTP (const xAOD::Electron *el1, const xAOD::Electron *el2, const EventContext &ctx, bool writeTTrees, const float evtWeight, bool osel, bool ssel) const
 
void doEleTP (const xAOD::Electron *leadingAllEle, const xAOD::Electron *subleadingAllEle, const xAOD::Vertex *pVtx, const EventContext &ctx, bool writeTTrees, bool isSimulation, const float evtWeight) const
 
void doEleContainerTP (std::vector< const xAOD::Electron * > &allElectrons, std::vector< const xAOD::Electron * > &goodelectrons, const EventContext &ctx) const
 
void doMuonTriggerTP (const xAOD::Muon *mu1, const xAOD::Muon *mu2, const EventContext &ctx, bool isSimulation, bool writeTTrees, const float evtWeight) const
 
void doMuonTruthEff (std::vector< const xAOD::Muon * > &goodmuonsZ, const EventContext &ctx) const
 
void doMuonLooseTP (std::vector< const xAOD::Muon * > &goodmuonsZ, const xAOD::Vertex *pVtx, const EventContext &ctx, bool isSimulation, bool writeTTrees, const float evtWeight) const
 
void doMuonInDetTP (std::vector< const xAOD::Muon * > &goodmuonsZ, const xAOD::Vertex *pVtx, const EventContext &ctx, bool isSimulation, bool writeTTrees, const float evtWeight) const
 
bool checkTruthElectron (const xAOD::Electron *electron) const
 
bool checkTruthMuon (const xAOD::Muon *muon) const
 
bool checkTruthTrack (const xAOD::TrackParticle *trk) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

Gaudi::Property< float_t > m_electronEtCut {this, "electronEtCut", 27}
 
Gaudi::Property< float_t > m_muonPtCut {this, "muonPtCut", 27}
 
Gaudi::Property< float_t > m_zCutLow {this, "zCutLow", 66.0}
 
Gaudi::Property< float_t > m_zCutHigh {this, "zCutHigh", 116.0}
 
Gaudi::Property< float_t > m_muonMaxEta {this, "muonMaxEta", 2.4}
 
Gaudi::Property< std::vector< std::string > > m_Z_ee_trigger {this, "Z_ee_trigger", {"HLT_e26_lhtight_ivarloose_L1EM22VHI", "HLT_e60_lhmedium_L1EM22VHI"}}
 
Gaudi::Property< std::vector< std::string > > m_Z_mm_trigger {this, "Z_mm_trigger", {"HLT_mu24_ivarmedium_L1MU14FCH", "HLT_mu50_L1MU14FCH"}}
 
BooleanProperty m_doRunBeam {this, "doRunBeam", true}
 
BooleanProperty m_doTrigger {this, "doTrigger", false}
 
BooleanProperty m_do_BCID {this, "do_BCID", false}
 
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool {this,"MuonSelectionTool","CP::MuonSelectionTool/MuonSelectionTool","MuonSelectionTool"}
 
ToolHandle< Trig::R3MatchingTool > m_r3MatchingTool {this, "R3MatchingTool", "Trig::R3MatchingTool", "R3MatchingTool"}
 
ToolHandle< IMCTruthClassifier > m_truthClassifier {this, "MCTruthClassifier", "MCTruthClassifier/MCTruthClassifier", "MCTruthClassifier"}
 
SG::ReadHandleKey< xAOD::ElectronContainer > m_ElectronContainerKey { this, "ElectronContainerName", "Electrons", "" }
 
SG::ReadHandleKey< xAOD::MuonContainer > m_MuonContainerKey { this, "MuonContainerName", "Muons", "" }
 
SG::ReadHandleKey< xAOD::PhotonContainer > m_PhotonContainerKey { this, "PhotonContainerName", "Photons", ""}
 
SG::ReadHandleKey< xAOD::VertexContainer > m_VertexContainerKey { this, "PrimaryVertexContainerName", "PrimaryVertices" }
 
SG::ReadHandleKey< xAOD::TruthParticleContainer > m_TruthParticleContainerKey {this, "TruthParticleContainerName", "TruthParticles", "" }
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_idTrackParticleContainerKey {this, "MuonInDetTrackParticleContainerName", "InDetTrackParticles", ""}
 
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_msTrackParticleContainerKey {this, "MuonExtrapolatedTrackParticleContainerName", "ExtrapolatedMuonTrackParticles", ""}
 
SG::ReadDecorHandleKeyArray< xAOD::MuonContainer > m_isoMuonContainerKey {this, "IsoMuonVariableNames", {"Muons.ptcone20"}, "Isolation decoration for muon container"}
 
SG::ReadDecorHandleKeyArray< xAOD::ElectronContainer > m_isoElectronContainerKey {this, "IsoElectronVariableNames", {"Electrons.ptcone20"}, "Isolation decoration for electron container"}
 
std::string m_name
 
std::unordered_map< std::string, size_t > m_toolLookupMap
 
const ToolHandle< GenericMonitoringTool > m_dummy
 
Gaudi::Property< bool > m_enforceExpressTriggers
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 39 of file DQTGlobalWZFinderAlg.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

◆ DQTGlobalWZFinderAlg()

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

Definition at line 38 of file DQTGlobalWZFinderAlg.cxx.

40  : AthMonitorAlgorithm(name, pSvcLocator)
41 //----------------------------------------------------------------------------------
42 {
43 }

◆ ~DQTGlobalWZFinderAlg()

virtual DQTGlobalWZFinderAlg::~DQTGlobalWZFinderAlg ( )
virtualdefault

Member Function Documentation

◆ antiGoodElectrons()

bool DQTGlobalWZFinderAlg::antiGoodElectrons ( const xAOD::Electron *  electron_itr,
const xAOD::Vertex *  pVtx,
const EventContext &  ctx 
) const
private

Definition at line 729 of file DQTGlobalWZFinderAlg.cxx.

729  {
730 
731  using namespace Monitored;
732 
733  SG::ReadHandle<xAOD::EventInfo> thisEventInfo { GetEventInfo(ctx) };
734 
735  bool antiGood = false;
736 
737  static const SG::AuxElement::Accessor<float> aptc20("ptcone20");
738  float ptcone20 = 0;
739  if (! aptc20.isAvailable(*electron_itr)) {
740  ATH_MSG_WARNING("aptc20 is not available - antiGoodElectron");
741  } else {
742  ptcone20 = aptc20(*electron_itr);
743  }
744 
745  float eleIso = 0.0;
746  if ((electron_itr)->pt() != 0.0){
747  eleIso = ptcone20/((electron_itr)->pt());
748  }
749 
750  bool passID = electron_itr->passSelection("LHLoose");
751  bool passIso = false;
752  if(eleIso < 0.1) passIso = true;
753  auto elTrk = (electron_itr)->trackParticle();
754 
755  if (!elTrk) {
756  return false;
757  }
758  float d0sig;
759  try {
760  d0sig = xAOD::TrackingHelpers::d0significance(elTrk, thisEventInfo->beamPosSigmaX(), thisEventInfo->beamPosSigmaY(), thisEventInfo->beamPosSigmaXY());
761  } catch (...) {
762  ATH_MSG_DEBUG("Invalid beamspot - electron");
763  try {
764  d0sig = xAOD::TrackingHelpers::d0significance(elTrk);
765  } catch (...) {
766  ATH_MSG_WARNING("Ridiculous exception thrown - electron");
767  return false;
768  }
769  }
770 
771  // pass basic selection, except ID+Isolation
772  if (((electron_itr)->pt() > m_electronEtCut*GeV) &&
773  std::abs(electron_itr->caloCluster()->etaBE(2)) < 2.4 &&
774  std::abs(d0sig) < 5 &&
775  pVtx &&
776  std::abs((elTrk->z0()+elTrk->vz()-pVtx->z())*std::sin(elTrk->theta())) < 0.5*mm)
777  {
778  if(std::abs((electron_itr)->caloCluster()->etaBE(2)) > 1.37 && std::abs((electron_itr)->caloCluster()->etaBE(2)) < 1.52){
779  antiGood = false;
780 
781  }else{
782  if(!passID && !passIso) antiGood = true;
783  }
784  }
785 
786  return antiGood;
787 }

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

◆ checkTruthElectron()

bool DQTGlobalWZFinderAlg::checkTruthElectron ( const xAOD::Electron *  electron) const
private

Definition at line 1126 of file DQTGlobalWZFinderAlg.cxx.

1126  {
1127 
1128  using namespace MCTruthPartClassifier;
1129 
1130  // Check if input electron originates from a ZBoson, following EGamma recipe
1131  bool truthMatched = false;
1132 
1133  std::pair<unsigned int, unsigned int> res;
1134 
1135  const xAOD::TruthParticle* lastElTruth = xAOD::EgammaHelpers::getBkgElectronMother(elec);
1136  if( lastElTruth ){
1137  res=m_truthClassifier->particleTruthClassifier(lastElTruth);
1138 
1139  unsigned int iTypeOfPart = res.first;
1140  unsigned int iPartOrig = res.second;
1141 
1142  if((iTypeOfPart == MCTruthPartClassifier::IsoElectron && iPartOrig == MCTruthPartClassifier::ZBoson) || (iPartOrig == MCTruthPartClassifier::FSRPhot)){
1143  truthMatched = true;
1144  }
1145  }
1146 
1147  return truthMatched;
1148 
1149 }

◆ checkTruthMuon()

bool DQTGlobalWZFinderAlg::checkTruthMuon ( const xAOD::Muon *  muon) const
private

Definition at line 1151 of file DQTGlobalWZFinderAlg.cxx.

1151  {
1152 
1153  using namespace MCTruthPartClassifier;
1154 
1155  // Check if input muon originates from a ZBoson
1156  bool truthMatched = false;
1157 
1158  std::pair<unsigned int, unsigned int> res;
1159  ParticleDef partDef;
1160 
1161  res=m_truthClassifier->particleTruthClassifier(muon);
1162 
1163  unsigned int iTypeOfPart = res.first;
1164  unsigned int iPartOrig = res.second;
1165 
1166  auto muTrk = muon->primaryTrackParticle();
1167 
1168  const auto* thePart = m_truthClassifier->getGenPart(muTrk);
1169 
1170  if(thePart){
1171  if(iTypeOfPart == MCTruthPartClassifier::IsoMuon && iPartOrig == MCTruthPartClassifier::ZBoson){
1172  truthMatched = true;
1173  }
1174  }
1175 
1176  return truthMatched;
1177 
1178 }

◆ checkTruthTrack()

bool DQTGlobalWZFinderAlg::checkTruthTrack ( const xAOD::TrackParticle *  trk) const
private

Definition at line 1180 of file DQTGlobalWZFinderAlg.cxx.

1180  {
1181 
1182  using namespace MCTruthPartClassifier;
1183 
1184  // Check if input track originates from a Z boson
1185  bool truthMatched = false;
1186 
1187  std::pair<unsigned int, unsigned int> res;
1188  ParticleDef partDef;
1189 
1190  res=m_truthClassifier->particleTruthClassifier(trk);
1191 
1192  unsigned int iTypeOfPart = res.first;
1193  unsigned int iPartOrig = res.second;
1194 
1195  const auto* thePart = m_truthClassifier->getGenPart(trk);
1196 
1197  if(thePart){
1198  if(iTypeOfPart == MCTruthPartClassifier::IsoMuon && iPartOrig == MCTruthPartClassifier::ZBoson){
1199  truthMatched = true;
1200  }
1201  }
1202 
1203  return truthMatched;
1204 
1205 }

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

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

Definition at line 221 of file AthMonitorAlgorithm.h.

221 { return m_dataType; }

◆ dataTypeStringToEnum()

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

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

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

Definition at line 140 of file AthMonitorAlgorithm.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ doEleContainerTP()

void DQTGlobalWZFinderAlg::doEleContainerTP ( std::vector< const xAOD::Electron * > &  allElectrons,
std::vector< const xAOD::Electron * > &  goodelectrons,
const EventContext &  ctx 
) const
private

Definition at line 588 of file DQTGlobalWZFinderAlg.cxx.

588  {
589 
590  using namespace Monitored;
591 
592  auto group_EleContainerTP = getGroup("EleContainerTP");
593  auto pass_kine = Scalar<bool>("pass_kine", false);
594  auto container_nomatch = Scalar<bool>("container_nomatch", false);
595 
596  SG::ReadHandle<xAOD::PhotonContainer> photons(m_PhotonContainerKey, ctx);
597  if ( ! photons.isValid() ) {
598  ATH_MSG_ERROR("No photon container" << m_PhotonContainerKey << "found in evtStore");
599  return;
600  }
601 
602  ATH_MSG_DEBUG("PhotonContainer successfully retrieved");
603 
604  for (const auto& tagEl : goodelectrons) {
605  bool matched = false;
606  for (const auto &chain: m_Z_ee_trigger) {
607  if (m_r3MatchingTool->match(*tagEl, chain, 0.1, false) || ! m_doTrigger) {
608  matched=true;
609  break;
610  }
611  }
612 
613  if (!matched) continue;
614  auto tagElp4(tagEl->p4());
615 
616  if (tagEl->passSelection("LHTight")){
617  for (const auto& el2 : allElectrons){
618  if (el2 != tagEl && kinematicCuts(el2)){
619  auto probeElp4(el2->p4());
620  auto mass = Scalar("mass", (tagElp4+probeElp4).M());
621  pass_kine = true;
622  fill(group_EleContainerTP, mass, pass_kine);
623  break;
624  }
625  }
626  }
627 
628  for (const xAOD::Photon* photon : *photons) {
629  auto photonp4(photon->p4());
630  auto mass = Scalar("mass", (tagElp4+photonp4).M());
631 
632  if (!kinematicCuts(photon))
633  continue;
634 
635  for (const auto& el2 : allElectrons){
636  // slightly relax pT cut for probe electron
637  bool passKinematics = true;
638  if (el2->pt() < (m_electronEtCut-2)*GeV)
639  passKinematics = false;
640  if (std::abs(el2->caloCluster()->etaBE(2)) > 2.4)
641  passKinematics = false;
642  if (std::abs(el2->caloCluster()->etaBE(2)) > 1.37 && std::abs(el2->caloCluster()->etaBE(2)) < 1.52)
643  passKinematics = false;
644 
645  double deltaR = (el2->p4()).DeltaR(photon->p4());
646  if (!passKinematics || tagEl == el2 || deltaR < 0.1)
647  continue;
648 
649  container_nomatch = true;
650  fill(group_EleContainerTP, mass, container_nomatch);
651  break;
652  }
653  }
654  }
655 }

◆ doEleTP()

void DQTGlobalWZFinderAlg::doEleTP ( const xAOD::Electron *  leadingAllEle,
const xAOD::Electron *  subleadingAllEle,
const xAOD::Vertex *  pVtx,
const EventContext &  ctx,
bool  writeTTrees,
bool  isSimulation,
const float  evtWeight 
) const
private

Definition at line 466 of file DQTGlobalWZFinderAlg.cxx.

466  {
467 
468  using namespace Monitored;
469 
470  SG::ReadHandle<xAOD::EventInfo> thisEventInfo { GetEventInfo(ctx) };
471 
472  auto group_EleTP = getGroup("EleTP");
473 
474  // first check we have both electrons
475  if(leadingAllEle && subleadingAllEle){
476 
477  // Truth matching
478  if (isSimulation) {
479  if (!(checkTruthElectron(leadingAllEle) && checkTruthElectron(subleadingAllEle))) return;
480  }
481 
482  // then get all the parameters we will need ready
483  auto Zeecharge = Scalar("Zeecharge", (leadingAllEle->charge() + subleadingAllEle->charge()));
484  auto p1(leadingAllEle->p4());
485  auto p2(subleadingAllEle->p4());
486  auto mass = Scalar("mass", (p1+p2).M());
487 
488  bool leadingPassKinematics = kinematicCuts(leadingAllEle);
489  bool subleadPassKinematics = kinematicCuts(subleadingAllEle);
490 
491  if(!leadingPassKinematics || !subleadPassKinematics) return;
492 
493  bool leading_good = goodElectrons(leadingAllEle, pVtx, ctx);
494  bool subleading_good = goodElectrons(subleadingAllEle, pVtx, ctx);
495 
496  bool leading_antigood = antiGoodElectrons(leadingAllEle, pVtx, ctx);
497  bool subleading_antigood = antiGoodElectrons(subleadingAllEle, pVtx, ctx);
498 
499  // do trigger matching
500  bool leading_trig = false;
501  for (const auto &chain: m_Z_ee_trigger) {
502  if (m_r3MatchingTool->match(*leadingAllEle, chain, 0.1, false)){
503  leading_trig = true;
504  break;
505  }
506  }
507 
508  bool subleading_trig = false;
509  for (const auto &chain: m_Z_ee_trigger) {
510  if (m_r3MatchingTool->match(*subleadingAllEle, chain, 0.1, false)){
511  subleading_trig = true;
512  break;
513  }
514  }
515 
516  bool opp_sign = (Zeecharge==0);
517 
518  bool tag_good1 = (leadingAllEle->passSelection("LHTight") && leading_trig && leading_good);
519  bool tag_good2 = (subleadingAllEle->passSelection("LHTight") && subleading_trig && subleading_good);
520 
521  fillEleEffHistos(tag_good1, subleading_good, subleading_antigood, opp_sign, mass);
522  fillEleEffHistos(tag_good2, leading_good, leading_antigood, opp_sign, mass);
523 
524  if (!writeTTrees)
525  return;
526 
527  auto pT = Scalar("pT", -1000.0);
528  auto phi = Scalar("phi", -1000.0);
529  auto eta = Scalar("eta", -1000.0);
530  auto weight = Scalar("weight", -1000.0);
531  auto runNumber = Scalar("runNumber", -1000);
532  auto eventNumber = Scalar("eventNumber", -1000);
533  auto LB = Scalar("LB", -1000);
534  auto mtype = Scalar("mtype", -1000);
535 
536  // now fill the trees
537  if(tag_good1){
538  pT = subleadingAllEle->pt();
539  phi = subleadingAllEle->phi();
540  eta = subleadingAllEle->caloCluster()->etaBE(2);
541  weight = evtWeight;
542  runNumber = thisEventInfo->runNumber();
543  eventNumber = thisEventInfo->eventNumber();
544  LB = thisEventInfo->lumiBlock();
545 
546  if(opp_sign){
547  mtype = subleading_good ? 0 : 2;
548  if(subleading_antigood)
549  mtype = 4;
550  }else{
551  mtype = subleading_good ? 1 : 3;
552  if(subleading_antigood)
553  mtype = 5;
554  }
555 
556  fill(group_EleTP, pT, phi, eta, mass, runNumber, eventNumber, LB, mtype, weight);
557  }
558 
559  if(tag_good2){
560  pT = leadingAllEle->pt();
561  phi = leadingAllEle->phi();
562  eta = leadingAllEle->caloCluster()->etaBE(2);
563  weight = evtWeight;
564  runNumber = thisEventInfo->runNumber();
565  eventNumber = thisEventInfo->eventNumber();
566  LB = thisEventInfo->lumiBlock();
567 
568  if(opp_sign){
569  if(leading_good)
570  mtype = 0;
571  if(!leading_good)
572  mtype = 2;
573  if(leading_antigood)
574  mtype = 4;
575  }else{
576  if(leading_good)
577  mtype = 1;
578  if(!leading_good)
579  mtype = 3;
580  if(leading_antigood)
581  mtype = 5;
582  }
583  }
584  fill(group_EleTP, pT, phi, eta, mass, runNumber, eventNumber, LB, mtype, weight);
585  }
586 }

◆ doEleTriggerTP()

void DQTGlobalWZFinderAlg::doEleTriggerTP ( const xAOD::Electron *  el1,
const xAOD::Electron *  el2,
const EventContext &  ctx,
bool  writeTTrees,
const float  evtWeight,
bool  osel,
bool  ssel 
) const
private

Definition at line 387 of file DQTGlobalWZFinderAlg.cxx.

387  {
388 
389  using namespace Monitored;
390 
391  SG::ReadHandle<xAOD::EventInfo> thisEventInfo { GetEventInfo(ctx) };
392 
393  auto group_EleTrigTP = getGroup("EleTrigTP");
394  auto matched = Scalar("matched", 0);
395  auto weight = Scalar("weight", evtWeight);
396  auto os = Scalar<bool>("os", osel);
397  auto ss = Scalar<bool>("ss", ssel);
398 
399  std::vector<const xAOD::Electron*> electrons{el1, el2};
400 
401  for (const auto el: electrons) {
402  for (const auto &chain: m_Z_ee_trigger) {
403  if (m_r3MatchingTool->match(*el, chain, 0.1, false)) {
404  matched++;
405  break;
406  }
407  }
408  }
409 
410  fill(group_EleTrigTP, matched, weight, os, ss);
411 
412  if (!writeTTrees){
413  return;
414  }
415 
416  for (const auto& tagel : electrons) {
417  bool matched_tag = false;
418  for (const auto &chain: m_Z_ee_trigger) {
419  if (m_r3MatchingTool->match(*tagel, chain, 0.1, false)) {
420  matched_tag = true;
421  break;
422  }
423  }
424 
425 
426  auto tagelp4(tagel->p4());
427  if (!matched_tag) continue;
428  for (const auto& probeel : electrons) {
429  if (tagel == probeel) {
430  continue;
431  }
432  auto probeelp4(probeel->p4());
433  auto mass = Scalar("mass", (tagelp4+probeelp4).M());
434  bool matched_probe = false;
435  if (mass < m_zCutLow*GeV || mass > m_zCutHigh*GeV) continue;
436 
437  auto pT = Scalar("pT", probeel->pt());
438  auto phi = Scalar("phi", probeel->phi());
439  auto eta = Scalar("eta", probeel->caloCluster()->etaBE(2));
440  auto runNumber = Scalar("runNumber", thisEventInfo->runNumber());
441  auto eventNumber = Scalar("eventNumber", thisEventInfo->eventNumber());
442  auto LB = Scalar("LB", thisEventInfo->lumiBlock());
443  auto mtype = Scalar("mtype", -1000);
444 
445  for (const auto &chain: m_Z_ee_trigger){
446  if (m_r3MatchingTool->match(*probeel, chain, 0.1, false)) {
447  matched_probe = true;
448  break;
449  }
450  }
451 
452  if (matched_probe) {
453  mtype = osel ? 0 : 1;
454  }
455  else if (!matched_probe) {
456  mtype = osel ? 2 : 3;
457  }
458 
459  if (writeTTrees){
460  fill(group_EleTrigTP, pT, phi, eta, mass, runNumber, eventNumber, LB, mtype, weight);
461  }
462  }
463  }
464 }

◆ doMuonInDetTP()

void DQTGlobalWZFinderAlg::doMuonInDetTP ( std::vector< const xAOD::Muon * > &  goodmuonsZ,
const xAOD::Vertex *  pVtx,
const EventContext &  ctx,
bool  isSimulation,
bool  writeTTrees,
const float  evtWeight 
) const
private

Definition at line 1024 of file DQTGlobalWZFinderAlg.cxx.

1024  {
1025 
1026  using namespace Monitored;
1027 
1028  if (isSimulation) {
1029  int truthMatched = 0;
1030  for (const auto mu: goodmuonsZ) {
1031  if (checkTruthMuon(mu) == true) {
1032  truthMatched++;
1033  }
1034  }
1035  if (truthMatched < 2) return;
1036  }
1037 
1038  auto group_MuonInDetTP = getGroup("MuonInDetTP");
1039  auto osmatch = Scalar<bool>("osmatch", false);
1040  auto ssmatch = Scalar<bool>("ssmatch", false);
1041  auto osnomatch = Scalar<bool>("osnomatch", false);
1042  auto ssnomatch = Scalar<bool>("ssnomatch", false);
1043 
1044  SG::ReadHandle<xAOD::EventInfo> thisEventInfo { GetEventInfo(ctx) };
1045 
1046  SG::ReadHandle<xAOD::TrackParticleContainer> idTracks_container_handle(m_idTrackParticleContainerKey, ctx);
1047  SG::ReadHandle<xAOD::TrackParticleContainer> msTracks_container_handle(m_msTrackParticleContainerKey, ctx);
1048 
1049  const xAOD::TrackParticleContainer* idTracks = idTracks_container_handle.cptr();
1050  const xAOD::TrackParticleContainer* msTracks = msTracks_container_handle.cptr();
1051 
1052  if (not idTracks) {
1053  ATH_MSG_FATAL("Unable to retrieve ID tracks to do muon T&P");
1054  }
1055  if (not msTracks) {
1056  ATH_MSG_FATAL("Unable to retrieve MS tracks to do muon T&P");
1057  }
1058 
1059  for (const auto& tagmu : goodmuonsZ) {
1060 
1061  bool matched = false;
1062  for (const auto &chain: m_Z_mm_trigger) {
1063  if (m_r3MatchingTool->match(*tagmu, chain, 0.1, false) || ! m_doTrigger) {
1064  matched=true;
1065  break;
1066  }
1067  }
1068  if (!matched) continue;
1069  auto tagmup4(tagmu->p4());
1070  // For Every MS track....
1071  for (const xAOD::TrackParticle* trk : *msTracks) {
1072  if (trk->pt() < m_muonPtCut*GeV || std::abs(trk->eta()) > m_muonMaxEta)
1073  continue;
1074  if (std::abs((trk->z0()+trk->vz()-pVtx->z())*std::sin(trk->theta())) > 2*mm)
1075  continue;
1076  auto trkp4(trk->p4());
1077  auto mass = Scalar("mass", (tagmup4+trkp4).M());
1078  bool matched = false;
1079 
1080  if (mass < m_zCutLow*GeV || mass > m_zCutHigh*GeV) continue;
1081 
1082  auto pT = Scalar("pT", trk->pt());
1083  auto phi = Scalar("phi", trk->phi());
1084  auto eta = Scalar("eta", trk->eta());
1085  auto isTruth = Scalar("isTruth", checkTruthTrack(trk));
1086  auto mtype = Scalar("mtype", -1000);
1087  auto runNumber = Scalar("runNumber", thisEventInfo->runNumber());
1088  auto eventNumber = Scalar("eventNumber", thisEventInfo->eventNumber());
1089  auto weight = Scalar("weight", evtWeight);
1090  auto LB = Scalar("LB", thisEventInfo->lumiBlock());
1091 
1092  // for all ID tracks
1093  for (const xAOD::TrackParticle* mu2 : *idTracks) {
1094  auto idtrkp4(mu2->p4());
1095  auto mstrkp4(trk->p4());
1096 
1097  auto dR = Scalar("dR", idtrkp4.DeltaR(mstrkp4));
1098  auto dPT = Scalar("dPT", mstrkp4.Pt() - idtrkp4.Pt());
1099 
1100  //Currently using magic numbers tuned by eye, may want to fix in the future...
1101  if (std::abs(dPT) < 10000 && dR < 0.05){
1102  matched = true;
1103  break;
1104  }
1105  }
1106 
1107  if (matched){
1108  (trk->charge() != tagmu->charge()) ? osmatch = true : ssmatch = true;
1109  mtype = (trk->charge() != tagmu->charge()) ? 0 : 1;
1110  if (writeTTrees) {
1111  fill(group_MuonInDetTP, pT, eta, phi, mass, mtype, isTruth, runNumber, LB, eventNumber, weight);
1112  }
1113  fill(group_MuonInDetTP, mass, osmatch, ssmatch);
1114  } else {
1115  (trk->charge() != tagmu->charge()) ? osnomatch = true : ssnomatch = true;
1116  mtype = (trk->charge() != tagmu->charge()) ? 2 : 3;
1117  if (writeTTrees) {
1118  fill(group_MuonInDetTP, pT, eta, phi, mass, mtype, isTruth, runNumber, LB, eventNumber, weight);
1119  }
1120  fill(group_MuonInDetTP, mass, osnomatch, ssnomatch);
1121  }
1122  }
1123  }
1124 }

◆ doMuonLooseTP()

void DQTGlobalWZFinderAlg::doMuonLooseTP ( std::vector< const xAOD::Muon * > &  goodmuonsZ,
const xAOD::Vertex *  pVtx,
const EventContext &  ctx,
bool  isSimulation,
bool  writeTTrees,
const float  evtWeight 
) const
private

Definition at line 920 of file DQTGlobalWZFinderAlg.cxx.

920  {
921 
922  using namespace Monitored;
923 
924  auto group_MuonLooseTP = getGroup("MuonLooseTP");
925  auto osmatch = Scalar<bool>("osmatch", false);
926  auto ssmatch = Scalar<bool>("ssmatch", false);
927  auto osnomatch = Scalar<bool>("osnomatch", false);
928  auto ssnomatch = Scalar<bool>("ssnomatch", false);
929 
930  SG::ReadHandle<xAOD::EventInfo> thisEventInfo { GetEventInfo(ctx) };
931 
932  SG::ReadHandle<xAOD::TrackParticleContainer> idTracks_container_handle(m_idTrackParticleContainerKey, ctx);
933 
934  const xAOD::TrackParticleContainer* idTracks = idTracks_container_handle.cptr();
935 
936  if (not idTracks) {
937  ATH_MSG_FATAL("Unable to retrieve ID tacks to do muon T&P");
938  return;
939  }
940 
941  for (const auto& tagmu : goodmuonsTP) {
942 
943  // Truth matching
944  if (isSimulation) {
945  if (!checkTruthMuon(tagmu)) continue;
946  }
947 
948  // only consider trigger-matched tags to avoid bias on probes
949  bool matched = false;
950  for (const auto &chain: m_Z_mm_trigger) {
951  if (m_r3MatchingTool->match(*tagmu, chain, 0.1, false) || ! m_doTrigger) {
952  matched=true;
953  break;
954  }
955  }
956  if (!matched) continue;
957  auto tagmup4(tagmu->p4());
958  for (const auto* trk : *idTracks) {
959 
960  // Truth matching
961  if (isSimulation) {
962  if (!checkTruthTrack(trk)) continue;
963  }
964 
965  if (trk->pt() < m_muonPtCut*GeV || std::abs(trk->eta()) > m_muonMaxEta)
966  continue;
967  if (std::abs((trk->z0()+trk->vz()-pVtx->z())*std::sin(trk->theta())) > 2*mm) continue;
968 
969  auto trkp4(trk->p4());
970  auto mass = Scalar("mass", (tagmup4+trkp4).M());
971  if (mass < m_zCutLow*GeV || mass > m_zCutHigh*GeV) continue;
972  auto pT = Scalar("pT", trk->pt());
973  auto phi = Scalar("phi", trk->phi());
974  auto eta = Scalar("eta", trk->eta());
975  auto isTruth = Scalar("isTruth", checkTruthTrack(trk));
976  auto runNumber = Scalar<int>("runNumber", thisEventInfo->runNumber());
977  auto eventNumber = Scalar("eventNumber", thisEventInfo->eventNumber());
978  auto mtype = Scalar("mtype", -1000);
979  auto LB = Scalar("LB", thisEventInfo->lumiBlock());
980  auto weight = Scalar("weight", evtWeight);
981 
982  bool opp_sign = (trk->charge() != tagmu->charge());
983  bool matched = false;
984  for (const auto& mu2: goodmuonsTP) {
985  if (tagmu == mu2) continue;
986  auto dR = Scalar("dR", trkp4.DeltaR(mu2->p4()));
987  auto dPT = Scalar("dPT", ((mu2->p4()).Pt() - trkp4.Pt()));
988 
989  if (std::abs(dPT) < 10000 && dR < 0.05) {
990  matched = true;
991  break;
992  }
993  }
994 
995  osmatch = false;
996  ssmatch = false;
997  osnomatch = false;
998  ssnomatch = false;
999 
1000  if (matched){
1001  mtype = (trk->charge() != tagmu->charge()) ? 0 : 1;
1002  if (opp_sign) {
1003  osmatch = true;
1004  } else {
1005  ssmatch = true;
1006  }
1007  }
1008  else {
1009  mtype = (trk->charge() != tagmu->charge()) ? 2 : 3;
1010  if (opp_sign) {
1011  osnomatch = true;
1012  } else {
1013  ssnomatch = true;
1014  }
1015  }
1016  if (writeTTrees){
1017  fill(group_MuonLooseTP, pT, phi, eta, mass, isTruth, runNumber, LB, eventNumber, mtype, weight);
1018  }
1019  fill(group_MuonLooseTP, mass, osmatch, ssmatch, osnomatch, ssnomatch);
1020  }
1021  }
1022 }

◆ doMuonTriggerTP()

void DQTGlobalWZFinderAlg::doMuonTriggerTP ( const xAOD::Muon *  mu1,
const xAOD::Muon *  mu2,
const EventContext &  ctx,
bool  isSimulation,
bool  writeTTrees,
const float  evtWeight 
) const
private

Definition at line 791 of file DQTGlobalWZFinderAlg.cxx.

791  {
792  //algorithm: plot # events with zero, one or two SL triggers
793  //zero triggers for MC closure checks
794 
795  using namespace Monitored;
796 
797  SG::ReadHandle<xAOD::EventInfo> thisEventInfo { GetEventInfo(ctx) };
798 
799  auto group_MuonTriggerTP = getGroup("MuonTriggerTP");
800  auto do_BCID = Scalar("do_BCID", false);
801  auto isOS = Scalar("isOS", false);
802  auto matched = Scalar("matched", 0);
803  auto weight = Scalar("weight", evtWeight);
804  std::vector<const xAOD::Muon*> muons{mu1, mu2};
805 
806  //Truth matching
807  if (isSimulation) {
808  int truthMatching = 0;
809  for (const auto mu: muons) {
810  if (checkTruthMuon(mu)) {
811  truthMatching++;
812  }
813  }
814  if (truthMatching < 2) return;
815  }
816 
817  for (const auto mu: muons) {
818  for (const auto &chain: m_Z_mm_trigger) {
819  if (m_r3MatchingTool->match(*mu, chain, 0.1, false)) {
820  matched++;
821  break;
822  }
823  }
824  }
825  fill(group_MuonTriggerTP, matched, weight);
826 
827  for (const auto& tagmu : muons) {
828  bool matched_tag = false;
829  for (const auto &chain: m_Z_mm_trigger) {
830  if (m_r3MatchingTool->match(*tagmu, chain, 0.1, false)) {
831  matched_tag=true;
832  break;
833  }
834  }
835  auto tagmup4(tagmu->p4());
836  if (!matched_tag) continue;
837 
838  for (const auto& probemu : muons) {
839  if (tagmu == probemu) {
840  continue;
841  }
842  auto probemup4(probemu->p4());
843  auto mass = Scalar("mass", (tagmup4+probemup4).M());
844  bool matched_probe = false;
845  if (mass < m_zCutLow*GeV || mass > m_zCutHigh*GeV) continue;
846 
847  auto pT = Scalar("pT", probemu->pt());
848  auto eta = Scalar("eta", probemu->eta());
849  auto phi = Scalar("phi", probemu->phi());
850  auto isTruth = Scalar("isTruth", checkTruthMuon(probemu));
851  auto mtype = Scalar("mtype", -1000);
852  auto runNumber = Scalar("runNumber", thisEventInfo->runNumber());
853  auto eventNumber = Scalar("eventNumber", thisEventInfo->eventNumber());
854  auto LB = Scalar("LB", thisEventInfo->lumiBlock());
855 
856  if (!m_doTrigger){
857  ATH_MSG_WARNING("Warning, the m_doTrigger activated");
858  }
859 
860  for (const auto &chain: m_Z_mm_trigger) {
861  if (m_r3MatchingTool->match(*probemu, chain, 0.1, false)) {
862  matched_probe=true;
863  break;
864  }
865  }
866 
867  if (matched_probe) {
868  if (probemu->charge() != tagmu->charge()) {
869  mtype = 0;
870  }
871  else {
872  mtype = 1;
873  }
874  break;
875  }
876 
877 
878  else if (!matched_probe) {
879  if (probemu->charge() != tagmu->charge()) {
880  mtype = 2;
881  }
882  else {
883  mtype = 3;
884  }
885  }
886  if (writeTTrees){
887  fill(group_MuonTriggerTP, pT, eta, phi, mass, isTruth, runNumber, LB, eventNumber, mtype, weight);
888  }
889  }
890  }
891 }

◆ doMuonTruthEff()

void DQTGlobalWZFinderAlg::doMuonTruthEff ( std::vector< const xAOD::Muon * > &  goodmuonsZ,
const EventContext &  ctx 
) const
private

Definition at line 893 of file DQTGlobalWZFinderAlg.cxx.

893  {
894  SG::ReadHandle<xAOD::TruthParticleContainer> vtruth(m_TruthParticleContainerKey, ctx);
895  auto group_MuonTruthEff = getGroup("MuonTruthEff");
896  if (! vtruth.isValid() ) {
897  ATH_MSG_WARNING("No muon truth particles");
898  return;
899  }
900  auto match = Monitored::Scalar("match", 0);
901  for (const xAOD::TruthParticle* truthmu : *vtruth) {
902  if (truthmu->abseta() > m_muonMaxEta || truthmu->pt() < m_muonPtCut*GeV) {
903  continue;
904  }
905  TLorentzVector truthp4(truthmu->p4());
906  match = 0;
907  for (const auto& foundmu : goodmuonsZ) {
908  if (foundmu->p4().DeltaR(truthp4) < 0.05) {
909  match = 1;
910  break;
911  }
912  }
913  fill(group_MuonTruthEff, match);
914  }
915 
916 }

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

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

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

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

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

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

Definition at line 112 of file AthMonitorAlgorithm.cxx.

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

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

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

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

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

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

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

◆ fillEleEffHistos()

void DQTGlobalWZFinderAlg::fillEleEffHistos ( bool  tag_good,
bool  probe_good,
bool  probe_anti_good,
bool  os,
double  el_mass 
) const
private

Definition at line 1208 of file DQTGlobalWZFinderAlg.cxx.

1208  {
1209 
1210  using namespace Monitored;
1211 
1212  if(!tag_good)
1213  return;
1214 
1215  auto group_EleTP = getGroup("EleTP");
1216  auto mass = Scalar("mass", el_mass);
1217  auto good_os = Scalar("good_os", false);
1218  auto good_ss = Scalar("good_ss", false);
1219  auto bad_os = Scalar("bad_os", false);
1220  auto bad_ss = Scalar("bad_ss", false);
1221  auto template_os = Scalar("template_os", false);
1222  auto template_ss = Scalar("template_ss", false);
1223 
1224  if(os){
1225  if(probe_good) good_os = true;
1226  else bad_os = true;
1227  if(probe_anti_good) template_os = true;
1228  fill(group_EleTP, mass, good_os, bad_os, template_os);
1229  }else{
1230  if(probe_good) good_ss = true;
1231  else bad_ss = true;
1232  if(probe_anti_good) template_ss = true;
1233  fill(group_EleTP, mass, good_ss, bad_ss, template_ss);
1234  }
1235 }

◆ fillHistograms()

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

adds event to the monitoring histograms

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

Parameters
ctxforwarded from execute
Returns
StatusCode

Implements AthMonitorAlgorithm.

Definition at line 68 of file DQTGlobalWZFinderAlg.cxx.

70 {
71  ATH_MSG_DEBUG("in DQTGlobalWZFinderAlg::fillHistograms()");
72 
73  using namespace Monitored;
74 
75  if (m_doRunBeam) {
76 
77  auto group = getGroup("default");
78 
79  //Get LumiBlock and EventNumber
80  SG::ReadHandle<xAOD::EventInfo> thisEventInfo { GetEventInfo(ctx) };
81  if(! thisEventInfo.isValid()) {
82  ATH_MSG_ERROR("Could not find EventInfo in evtStore()");
83  return StatusCode::FAILURE;
84  }
85 
86  bool isSimulation = thisEventInfo->eventType(xAOD::EventInfo::IS_SIMULATION);
87  auto writeTTrees = Scalar("writeTTrees", isSimulation);
88 
89  auto LB = Scalar<int>("LB", thisEventInfo->lumiBlock());
90  auto eventNumber = Scalar<int>("eventNumber", thisEventInfo->eventNumber());
91  auto runNumber = Scalar<int>("runNumber", thisEventInfo->runNumber());
92 
93  auto avgLiveFrac = Scalar("avgLiveFrac", lbAverageLivefraction(ctx));
94  auto duration = Scalar("duration", lbDuration(ctx));
95  auto avgIntPerXing = Scalar("avgIntPerXing", lbAverageInteractionsPerCrossing(ctx));
96 
97  fill(group, LB, avgLiveFrac, duration, avgIntPerXing);
98 
99  ATH_MSG_DEBUG("Filled LB hists");
100 
101 
102  auto evtWeight = Scalar("evtWeight", 1.0);
103  if (thisEventInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
104  evtWeight = thisEventInfo->mcEventWeight();
105  ATH_MSG_DEBUG("Event Weight: " << evtWeight);
106  }
107 
108  //Get Electrons
109  SG::ReadHandle<xAOD::ElectronContainer> elecTES(m_ElectronContainerKey, ctx);
110  if ( ! elecTES.isValid() ) {
111  ATH_MSG_ERROR("No electron container" << m_ElectronContainerKey << " found in evtStore");
112  return StatusCode::FAILURE;
113  }
114 
115  ATH_MSG_DEBUG("ElectronContainer successfully retrieved");
116 
117 
118  //Get Muons
119 
120  SG::ReadHandle<xAOD::MuonContainer> muons(m_MuonContainerKey, ctx);
121  if (! muons.isValid() ) {
122  ATH_MSG_ERROR("evtStore() does not contain muon Collection with name "<< m_MuonContainerKey);
123  return StatusCode::FAILURE;
124  }
125 
126  ATH_MSG_DEBUG("Got muon collection!");
127 
128  std::vector<const xAOD::Electron*> goodelectrons;
129  std::vector<const xAOD::Muon*> goodmuonsZ;
130  std::vector<const xAOD::Muon*> goodmuonsTP;
131 
132  //get primary vertex info
133  const xAOD::Vertex* pVtx(0);
134  SG::ReadHandle<xAOD::VertexContainer> vertices(m_VertexContainerKey, ctx);
135  if (vertices.isValid()) {
136  ATH_MSG_DEBUG("Collection with name " << m_VertexContainerKey << " with size " << vertices->size() << " found in evtStore()");
137  for(const auto vtx : * vertices) {
138  if(vtx->vertexType()==xAOD::VxType::PriVtx) {
139  pVtx = vtx;
140  break;
141  }
142  }
143  } else {
144  ATH_MSG_WARNING("No collection with name " << m_VertexContainerKey << " found in evtStore()");
145  }
146 
147  const xAOD::Electron* leadingAllEle(0);
148  const xAOD::Electron* subleadingAllEle(0);
149  std::vector<const xAOD::Electron*> allElectrons;
150 
151 
152  // Electron Cut Flow
153  ATH_MSG_DEBUG("Start electron selection");
154 
155  auto elegroup = getGroup("electron");
156 
157  for(const auto electron : *elecTES) {
158  allElectrons.push_back(electron);
159 
160  if(goodElectrons(electron, pVtx, ctx)){
161  ATH_MSG_DEBUG("Good electron");
162 
163  auto ele_Et = Scalar("ele_Et", electron->pt()/GeV);
164  auto ele_Eta = Scalar("ele_Eta", electron->eta());
165  auto ele_Phi = Scalar("ele_Phi", electron->phi());
166  fill(elegroup, ele_Et, ele_Eta, ele_Phi, evtWeight);
167  goodelectrons.push_back(electron);
168  }
169  }
170 
171  // Muon Cut Flow
172 
173  auto muongroup = getGroup("muon");
174  ATH_MSG_DEBUG("Start muon selection");
175  static const SG::AuxElement::Accessor<float> aptc20("ptcone20");
176 
177  for (const xAOD::Muon* muon : *muons){
178  auto muTrk = (muon)->primaryTrackParticle();
179  float d0sig;
180  if (!muTrk) {
181  ATH_MSG_WARNING("No muon track! " << thisEventInfo->runNumber() << " " << thisEventInfo->eventNumber());
182  continue;
183  }
184  try {
185  d0sig = xAOD::TrackingHelpers::d0significance(muTrk, thisEventInfo->beamPosSigmaX(), thisEventInfo->beamPosSigmaY(), thisEventInfo->beamPosSigmaXY());
186  } catch (...) {
187  ATH_MSG_DEBUG("Invalid beamspot - muon");
188  try {
189  d0sig = xAOD::TrackingHelpers::d0significance(muTrk);
190  } catch (...) {
191  ATH_MSG_WARNING("Ridiculous exception thrown - muon");
192  continue;
193  }
194  }
195 
196  float ptcone20 = 0;
197  if (! aptc20.isAvailable(*muon)) {
198  ATH_MSG_WARNING("aptc20 is not available - muon");
199  } else {
200  ptcone20 = aptc20(*muon);
201  }
202 
203  float muonIso = 0.0;
204  if ((muon)->pt() != 0.0){
205  muonIso = ptcone20/((muon)->pt());
206  }
207 
208  ATH_MSG_DEBUG("Muon accept: " << static_cast<bool>(m_muonSelectionTool->accept(*muon)));
209  ATH_MSG_DEBUG("Muon pt: " << (muon)->pt() << " " << m_muonPtCut*GeV);
210  ATH_MSG_DEBUG("Muon iso: " << static_cast<bool>(muonIso < 0.1 ));
211  ATH_MSG_DEBUG("Muon d0sig: " << d0sig);
212  ATH_MSG_DEBUG("Muon Good vtx: " << pVtx);
213  if (pVtx) ATH_MSG_DEBUG("Muon z0sinth: " << std::abs((muTrk->z0()+muTrk->vz()-pVtx->z())*std::sin(muTrk->theta())) << " " << 0.5*mm);
214 
215  if (m_muonSelectionTool->accept(*muon) &&
216  ((muon)->pt() > 0.8*m_muonPtCut*GeV) &&
217  muonIso < 0.1 &&
218  std::abs(d0sig) < 3 &&
219  pVtx &&
220  std::abs((muTrk->z0()+muTrk->vz()-pVtx->z())*std::sin(muTrk->theta())) < 0.5*mm)
221  {
222 
223  goodmuonsTP.push_back(muon);
224  if (((muon)->pt() > m_muonPtCut*GeV))
225  {
226  auto muon_Pt = Scalar("muon_Pt", (muon)->pt()/GeV);
227  auto muon_Eta = Scalar("muon_Eta", (muon)->eta());
228  auto muon_Phi = Scalar("muon_Phi", (muon)->phi());
229  fill(muongroup, muon_Pt, muon_Eta, muon_Phi, evtWeight);
230  goodmuonsZ.push_back(muon);
231  }
232  }
233 
234  }
235 
236  if (isSimulation) {
237  doMuonTruthEff(goodmuonsZ, ctx);
238  }
239 
240  for (const auto iEle : allElectrons) {
241  Float_t pt = iEle->pt();
242  ATH_MSG_DEBUG("Ele pt " << pt);
243  if (!leadingAllEle || pt > leadingAllEle->pt()){
244  subleadingAllEle = leadingAllEle;
245  leadingAllEle = iEle;
246  }
247  else if (!subleadingAllEle || pt > subleadingAllEle->pt()){
248  subleadingAllEle = iEle;
249  }
250  }
251 
252  // Perform all Tag and Probe Procedures
253 
254  doMuonLooseTP(goodmuonsTP, pVtx, ctx, isSimulation, writeTTrees, evtWeight);
255  doMuonInDetTP(goodmuonsTP, pVtx, ctx, isSimulation, writeTTrees, evtWeight);
256  doEleTP(leadingAllEle, subleadingAllEle, pVtx, ctx, writeTTrees, isSimulation, evtWeight);
257  doEleContainerTP(allElectrons, goodelectrons, ctx);
258 
259  // Sort Candidates by Pt
260  const xAOD::Electron* leadingEle(0);
261  const xAOD::Electron* subleadingEle(0);
262  const xAOD::Muon* leadingMuZ(0);
263  const xAOD::Muon* subleadingMuZ(0);
264 
265  ATH_MSG_DEBUG("Beginning ele loop");
266  for (const auto iEle : goodelectrons) {
267  Float_t pt = iEle->pt();
268  ATH_MSG_DEBUG("Ele pt " << pt);
269  if (! leadingEle || pt > leadingEle->pt()) {
270  subleadingEle = leadingEle;
271  leadingEle = iEle;
272  }
273  else if (! subleadingEle || pt > subleadingEle->pt()) {
274  subleadingEle = iEle;
275  }
276  }
277  ATH_MSG_DEBUG("Done ele loop");
278 
279  ATH_MSG_DEBUG("Start mu Z loop");
280  for (const auto iMu : goodmuonsZ) {
281  Float_t pt = iMu->pt();
282  if (! leadingMuZ || pt > leadingMuZ->pt()) {
283  subleadingMuZ = leadingMuZ;
284  leadingMuZ = iMu;
285  }
286  else if (! subleadingMuZ || pt > subleadingMuZ->pt()) {
287  subleadingMuZ = iMu;
288  }
289  }
290  ATH_MSG_DEBUG("Done mu Z loop");
291 
292  // Z Mass
293  bool isZee = (goodelectrons.size() > 1);
294  bool isZmumu = (goodmuonsZ.size() > 1);
295  ATH_MSG_DEBUG("Evaluated Event");
296  auto ZeeGroup = getGroup("Zee");
297  auto ZmumuGroup = getGroup("Zmumu");
298 
299  if(isZee){
300  ATH_MSG_DEBUG("Zee found");
301  TLorentzVector Zee = (leadingEle->p4() + subleadingEle->p4());
302  auto mass = Scalar("mass", Zee.M());
303  auto Zeecharge = Scalar("Zeecharge", leadingEle->charge() + subleadingEle->charge());
304  bool passTrig = true;
305  if (m_doTrigger){
306  passTrig = trigChainsArePassed(m_Z_ee_trigger);
307  }
308  bool inMassWindow = (mass > m_zCutLow*GeV && mass < m_zCutHigh*GeV);
309  auto osel = Scalar<bool>("osel", false);
310  auto ssel = Scalar<bool>("ssel", false);
311  (Zeecharge == 0) ? (osel = true) : (ssel = true);
312  if (inMassWindow){
313  fill(ZeeGroup, Zeecharge, evtWeight);
314  ATH_MSG_DEBUG("Found a Z to ee candidate! Mass = " << mass << ", and charge = " << Zeecharge );
315  if(osel && passTrig){
316  auto eta1 = Scalar("eta1", leadingEle->caloCluster()->etaBE(2));
317  auto eta2 = Scalar("eta2", subleadingEle->caloCluster()->etaBE(2));
318  auto phi1 = Scalar("phi1", leadingEle->phi());
319  auto phi2 = Scalar("phi2", subleadingEle->phi());
320  auto pT1 = Scalar("pT1", leadingEle->pt());
321  auto pT2 = Scalar("pT2", subleadingEle->pt());
322  auto isTruth = Scalar("isTruth", false);
323 
324  if(writeTTrees){
325  isTruth = checkTruthElectron(leadingEle) && checkTruthElectron(subleadingEle);
326  }
327  fill(ZeeGroup, mass, eta1, eta2, phi1, phi2, pT1, pT2, evtWeight, LB, runNumber, eventNumber, isTruth, writeTTrees, osel);
328  }
329  if(ssel && passTrig){
330  if (!isSimulation){
331  fill(ZeeGroup, mass, LB, evtWeight, ssel);
332  }
333  }
334  if(m_doTrigger){
335  doEleTriggerTP(leadingEle, subleadingEle, ctx, writeTTrees, evtWeight, osel, ssel);
336  }
337  }
338  }
339  if (isZmumu){
340  ATH_MSG_DEBUG("Zmumu found");
341  TLorentzVector Zmumu = leadingMuZ->p4() + subleadingMuZ->p4();
342  auto mass = Scalar("mass", Zmumu.M());
343  auto Zmumucharge = Scalar("Zmumucharge", leadingMuZ->charge() + subleadingMuZ->charge());
344  // potentially ignore trigger...
345  bool oktrig = true;
346  if (m_doTrigger){
347  oktrig = trigChainsArePassed(m_Z_mm_trigger);
348  }
349  bool inMassWindow = (mass > m_zCutLow*GeV && mass < m_zCutHigh*GeV);
350  auto osmu = Scalar<bool>("osmu", false);
351  auto ssmu = Scalar<bool>("ssmu", false);
352  (Zmumucharge == 0) ? (osmu = true) : (ssmu = true);
353  if(inMassWindow){
354  fill(ZmumuGroup, Zmumucharge, evtWeight);
355  ATH_MSG_DEBUG("Found a Z to mumu candidate! Mass = " << mass << ", and charge = " << Zmumucharge);
356  if(osmu && oktrig){
357  auto eta1 = Scalar("eta1", leadingMuZ->eta());
358  auto eta2 = Scalar("eta2", subleadingMuZ->eta());
359  auto phi1 = Scalar("phi1", leadingMuZ->phi());
360  auto phi2 = Scalar("phi2", subleadingMuZ->phi());
361  auto pT1 = Scalar("pT1", leadingMuZ->pt());
362  auto pT2 = Scalar("pT2", subleadingMuZ->pt());
363  auto isTruth = Scalar("isTruth", false);
364  if (writeTTrees){
365  isTruth = checkTruthMuon(leadingMuZ) && checkTruthMuon(subleadingMuZ);
366  }
367  fill(ZmumuGroup, eta1, eta2, phi1, phi2, pT1, pT2, isTruth, evtWeight, LB, runNumber, eventNumber, mass, writeTTrees, osmu);
368  }
369  if(osmu && !oktrig){
370  ATH_MSG_DEBUG("Trigger failure!");
371  }
372  if(osmu && m_doTrigger){
373  doMuonTriggerTP(leadingMuZ, subleadingMuZ, ctx, isSimulation, writeTTrees, evtWeight);
374  }
375  if(ssmu && oktrig){
376  if (!isSimulation){
377  fill(ZmumuGroup, mass, LB, evtWeight, ssmu);
378  }
379  }
380  }
381  }
382  }
383 
384  return StatusCode::SUCCESS;
385 }

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

◆ GetEventInfo()

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

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

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

Definition at line 107 of file AthMonitorAlgorithm.cxx.

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

◆ getGroup()

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

Get a specific monitoring tool from the tool handle array.

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

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

Definition at line 164 of file AthMonitorAlgorithm.cxx.

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

◆ getTrigDecisionTool()

const ToolHandle< Trig::TrigDecisionTool > & AthMonitorAlgorithm::getTrigDecisionTool ( ) const
inherited

Get the trigger decision tool member.

The trigger decision tool is used to check whether a specific trigger is passed by an event.

Returns
m_trigDecTool

Definition at line 194 of file AthMonitorAlgorithm.cxx.

194  {
195  return m_trigDecTool;
196 }

◆ goodElectrons()

bool DQTGlobalWZFinderAlg::goodElectrons ( const xAOD::Electron *  electron_itr,
const xAOD::Vertex *  pVtx,
const EventContext &  ctx 
) const
private

Definition at line 671 of file DQTGlobalWZFinderAlg.cxx.

671  {
672 
673  using namespace Monitored;
674 
675  SG::ReadHandle<xAOD::EventInfo> thisEventInfo { GetEventInfo(ctx) };
676 
677  bool isGood = false;
678 
679  static const SG::AuxElement::Accessor<float> aptc20("ptcone20");
680  float ptcone20 = 0;
681  if (! aptc20.isAvailable(*electron_itr)) {
682  ATH_MSG_WARNING("aptc20 is not available - goodElectron");
683  } else {
684  ptcone20 = aptc20(*electron_itr);
685  }
686 
687  float eleIso = 0.0;
688  if ((electron_itr)->pt() != 0.0){
689  eleIso = ptcone20/((electron_itr)->pt());
690  }
691 
692  bool passSel = electron_itr->passSelection("LHMedium");
693  auto elTrk = (electron_itr)->trackParticle();
694 
695  if (!elTrk) {
696  return false;
697  }
698  float d0sig;
699  try {
700  d0sig = xAOD::TrackingHelpers::d0significance(elTrk, thisEventInfo->beamPosSigmaX(), thisEventInfo->beamPosSigmaY(), thisEventInfo->beamPosSigmaXY());
701  } catch (...) {
702  ATH_MSG_DEBUG("Invalid beamspot - electron");
703  try {
704  d0sig = xAOD::TrackingHelpers::d0significance(elTrk);
705  } catch (...) {
706  ATH_MSG_WARNING("Ridiculous exception thrown - electron");
707  return false;
708  }
709  }
710 
711  if ( ((electron_itr)->pt() > m_electronEtCut*GeV) &&
712  std::abs(electron_itr->caloCluster()->etaBE(2)) < 2.4 &&
713  passSel &&
714  (eleIso < 0.1) &&
715  std::abs(d0sig) < 5 &&
716  pVtx &&
717  std::abs((elTrk->z0()+elTrk->vz()-pVtx->z())*std::sin(elTrk->theta())) < 0.5*mm)
718  { // electron dead zone
719  if (std::abs((electron_itr)->caloCluster()->etaBE(2)) > 1.37 && std::abs((electron_itr)->caloCluster()->etaBE(2)) < 1.52 ){
720  isGood = false;
721  } else{
722  isGood = true;
723  }
724  }
725 
726  return isGood;
727 }

◆ initialize()

StatusCode DQTGlobalWZFinderAlg::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 45 of file DQTGlobalWZFinderAlg.cxx.

45  {
46  ATH_CHECK(AthMonitorAlgorithm::initialize());
47  ATH_CHECK(m_muonSelectionTool.retrieve());
48  ATH_CHECK(m_r3MatchingTool.retrieve());
49  if (dataType() == DataType_t::monteCarlo) {
50  ATH_CHECK(m_truthClassifier.retrieve());
51  } else {
52  m_truthClassifier.disable();
53  }
54 
55  ATH_CHECK(m_ElectronContainerKey.initialize());
56  ATH_CHECK(m_MuonContainerKey.initialize());
57  ATH_CHECK(m_PhotonContainerKey.initialize());
58  ATH_CHECK(m_VertexContainerKey.initialize());
59  ATH_CHECK(m_TruthParticleContainerKey.initialize(dataType() == DataType_t::monteCarlo));
60  ATH_CHECK(m_idTrackParticleContainerKey.initialize());
61  ATH_CHECK(m_msTrackParticleContainerKey.initialize());
62  ATH_CHECK(m_isoMuonContainerKey.initialize());
63  ATH_CHECK(m_isoElectronContainerKey.initialize());
64  return StatusCode::SUCCESS;
65 }

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

◆ kinematicCuts()

bool DQTGlobalWZFinderAlg::kinematicCuts ( const xAOD::Egamma *  particle) const
private

Definition at line 657 of file DQTGlobalWZFinderAlg.cxx.

657  {
658 
659  bool isGood = true;
660  if(particle->pt() < m_electronEtCut*GeV) isGood = false;
661 
662  if(std::abs(particle->caloCluster()->etaBE(2)) > 2.4) isGood = false;
663 
664  if(std::abs(particle->caloCluster()->etaBE(2)) > 1.37 &&
665  std::abs(particle->caloCluster()->etaBE(2)) < 1.52) isGood = false;
666 
667  return isGood;
668 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ parseList()

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

Parse a string into a vector.

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

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

Definition at line 341 of file AthMonitorAlgorithm.cxx.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

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

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysStart()

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

Handle START transition.

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

◆ trigChainsArePassed()

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

Check whether triggers are passed.

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

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

Definition at line 199 of file AthMonitorAlgorithm.cxx.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 351 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

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

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

Definition at line 353 of file AthMonitorAlgorithm.h.

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 360 of file AthMonitorAlgorithm.h.

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_do_BCID

BooleanProperty DQTGlobalWZFinderAlg::m_do_BCID {this, "do_BCID", false}
private

Definition at line 65 of file DQTGlobalWZFinderAlg.h.

◆ m_doRunBeam

BooleanProperty DQTGlobalWZFinderAlg::m_doRunBeam {this, "doRunBeam", true}
private

Definition at line 63 of file DQTGlobalWZFinderAlg.h.

◆ m_doTrigger

BooleanProperty DQTGlobalWZFinderAlg::m_doTrigger {this, "doTrigger", false}
private

Definition at line 64 of file DQTGlobalWZFinderAlg.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_ElectronContainerKey

SG::ReadHandleKey<xAOD::ElectronContainer> DQTGlobalWZFinderAlg::m_ElectronContainerKey { this, "ElectronContainerName", "Electrons", "" }
private

Definition at line 90 of file DQTGlobalWZFinderAlg.h.

◆ m_electronEtCut

Gaudi::Property<float_t> DQTGlobalWZFinderAlg::m_electronEtCut {this, "electronEtCut", 27}
private

Definition at line 54 of file DQTGlobalWZFinderAlg.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_idTrackParticleContainerKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> DQTGlobalWZFinderAlg::m_idTrackParticleContainerKey {this, "MuonInDetTrackParticleContainerName", "InDetTrackParticles", ""}
private

Definition at line 100 of file DQTGlobalWZFinderAlg.h.

◆ m_isoElectronContainerKey

SG::ReadDecorHandleKeyArray<xAOD::ElectronContainer> DQTGlobalWZFinderAlg::m_isoElectronContainerKey {this, "IsoElectronVariableNames", {"Electrons.ptcone20"}, "Isolation decoration for electron container"}
private

Definition at line 107 of file DQTGlobalWZFinderAlg.h.

◆ m_isoMuonContainerKey

SG::ReadDecorHandleKeyArray<xAOD::MuonContainer> DQTGlobalWZFinderAlg::m_isoMuonContainerKey {this, "IsoMuonVariableNames", {"Muons.ptcone20"}, "Isolation decoration for muon container"}
private

Definition at line 105 of file DQTGlobalWZFinderAlg.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_msTrackParticleContainerKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> DQTGlobalWZFinderAlg::m_msTrackParticleContainerKey {this, "MuonExtrapolatedTrackParticleContainerName", "ExtrapolatedMuonTrackParticles", ""}
private

Definition at line 102 of file DQTGlobalWZFinderAlg.h.

◆ m_MuonContainerKey

SG::ReadHandleKey<xAOD::MuonContainer> DQTGlobalWZFinderAlg::m_MuonContainerKey { this, "MuonContainerName", "Muons", "" }
private

Definition at line 92 of file DQTGlobalWZFinderAlg.h.

◆ m_muonMaxEta

Gaudi::Property<float_t> DQTGlobalWZFinderAlg::m_muonMaxEta {this, "muonMaxEta", 2.4}
private

Definition at line 58 of file DQTGlobalWZFinderAlg.h.

◆ m_muonPtCut

Gaudi::Property<float_t> DQTGlobalWZFinderAlg::m_muonPtCut {this, "muonPtCut", 27}
private

Definition at line 55 of file DQTGlobalWZFinderAlg.h.

◆ m_muonSelectionTool

ToolHandle<CP::IMuonSelectionTool> DQTGlobalWZFinderAlg::m_muonSelectionTool {this,"MuonSelectionTool","CP::MuonSelectionTool/MuonSelectionTool","MuonSelectionTool"}
private

Definition at line 85 of file DQTGlobalWZFinderAlg.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_PhotonContainerKey

SG::ReadHandleKey<xAOD::PhotonContainer> DQTGlobalWZFinderAlg::m_PhotonContainerKey { this, "PhotonContainerName", "Photons", ""}
private

Definition at line 94 of file DQTGlobalWZFinderAlg.h.

◆ m_r3MatchingTool

ToolHandle<Trig::R3MatchingTool> DQTGlobalWZFinderAlg::m_r3MatchingTool {this, "R3MatchingTool", "Trig::R3MatchingTool", "R3MatchingTool"}
private

Definition at line 86 of file DQTGlobalWZFinderAlg.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_truthClassifier

ToolHandle<IMCTruthClassifier> DQTGlobalWZFinderAlg::m_truthClassifier {this, "MCTruthClassifier", "MCTruthClassifier/MCTruthClassifier", "MCTruthClassifier"}
private

Definition at line 88 of file DQTGlobalWZFinderAlg.h.

◆ m_TruthParticleContainerKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> DQTGlobalWZFinderAlg::m_TruthParticleContainerKey {this, "TruthParticleContainerName", "TruthParticles", "" }
private

Definition at line 98 of file DQTGlobalWZFinderAlg.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> DQTGlobalWZFinderAlg::m_VertexContainerKey { this, "PrimaryVertexContainerName", "PrimaryVertices" }
private

Definition at line 96 of file DQTGlobalWZFinderAlg.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_Z_ee_trigger

Gaudi::Property<std::vector<std::string> > DQTGlobalWZFinderAlg::m_Z_ee_trigger {this, "Z_ee_trigger", {"HLT_e26_lhtight_ivarloose_L1EM22VHI", "HLT_e60_lhmedium_L1EM22VHI"}}
private

Definition at line 60 of file DQTGlobalWZFinderAlg.h.

◆ m_Z_mm_trigger

Gaudi::Property<std::vector<std::string> > DQTGlobalWZFinderAlg::m_Z_mm_trigger {this, "Z_mm_trigger", {"HLT_mu24_ivarmedium_L1MU14FCH", "HLT_mu50_L1MU14FCH"}}
private

Definition at line 61 of file DQTGlobalWZFinderAlg.h.

◆ m_zCutHigh

Gaudi::Property<float_t> DQTGlobalWZFinderAlg::m_zCutHigh {this, "zCutHigh", 116.0}
private

Definition at line 57 of file DQTGlobalWZFinderAlg.h.

◆ m_zCutLow

Gaudi::Property<float_t> DQTGlobalWZFinderAlg::m_zCutLow {this, "zCutLow", 66.0}
private

Definition at line 56 of file DQTGlobalWZFinderAlg.h.

The documentation for this class was generated from the following files:
DQTGlobalWZFinderAlg::doMuonTruthEff
void doMuonTruthEff(std::vector< const xAOD::Muon * > &goodmuonsZ, const EventContext &ctx) const
Definition: DQTGlobalWZFinderAlg.cxx:893
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
AthMonitorAlgorithm::dataType
DataType_t dataType() const
Accessor functions for the data type.
Definition: AthMonitorAlgorithm.h:221
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
xAOD::Electron_v1::charge
float charge() const
Obtain the charge of the object.
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
DQTGlobalWZFinderAlg::m_MuonContainerKey
SG::ReadHandleKey< xAOD::MuonContainer > m_MuonContainerKey
Definition: DQTGlobalWZFinderAlg.h:93
get_generator_info.result
result
Definition: get_generator_info.py:21
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
DQTGlobalWZFinderAlg::fillEleEffHistos
void fillEleEffHistos(bool tag_good, bool probe_good, bool probe_anti_good, bool os, double el_mass) const
Definition: DQTGlobalWZFinderAlg.cxx:1208
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
xAOD::CaloClusterDetails::etaBE
float etaBE(const unsigned sample, const std::uint32_t samplingPattern, const std::span< const float > e_sampl, const std::span< const float > eta_sampl)
Get the eta in one layer of the EM Calo.
Definition: CaloClusterDetails.h:106
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
DQTGlobalWZFinderAlg::doMuonLooseTP
void doMuonLooseTP(std::vector< const xAOD::Muon * > &goodmuonsZ, const xAOD::Vertex *pVtx, const EventContext &ctx, bool isSimulation, bool writeTTrees, const float evtWeight) const
Definition: DQTGlobalWZFinderAlg.cxx:920
CaloCellTimeCorrFiller.LB
LB
Definition: CaloCellTimeCorrFiller.py:37
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
collListGuids.line
string line
Definition: collListGuids.py:77
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
DQTGlobalWZFinderAlg::m_zCutLow
Gaudi::Property< float_t > m_zCutLow
Definition: DQTGlobalWZFinderAlg.h:56
DQTGlobalWZFinderAlg::m_Z_mm_trigger
Gaudi::Property< std::vector< std::string > > m_Z_mm_trigger
Definition: DQTGlobalWZFinderAlg.h:61
met::DeltaR
@ DeltaR
Definition: METRecoCommon.h:11
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
DQTGlobalWZFinderAlg::doMuonTriggerTP
void doMuonTriggerTP(const xAOD::Muon *mu1, const xAOD::Muon *mu2, const EventContext &ctx, bool isSimulation, bool writeTTrees, const float evtWeight) const
Definition: DQTGlobalWZFinderAlg.cxx:791
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
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
test_pyathena.pt
pt
Definition: test_pyathena.py:11
DQTGlobalWZFinderAlg::checkTruthElectron
bool checkTruthElectron(const xAOD::Electron *electron) const
Definition: DQTGlobalWZFinderAlg.cxx:1126
xAOD::Iso::ptcone20
@ ptcone20
Track isolation.
Definition: IsolationType.h:40
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
DQTGlobalWZFinderAlg::m_Z_ee_trigger
Gaudi::Property< std::vector< std::string > > m_Z_ee_trigger
Definition: DQTGlobalWZFinderAlg.h:60
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
DQTGlobalWZFinderAlg::kinematicCuts
bool kinematicCuts(const xAOD::Egamma *particle) const
Definition: DQTGlobalWZFinderAlg.cxx:657
xAOD::eta1
setEt setPhi setE277 setWeta2 eta1
Definition: TrigEMCluster_v1.cxx:41
xAOD::Egamma_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle as a TLoretzVector.
Definition: Egamma_v1.cxx:98
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
DQTGlobalWZFinderAlg::m_electronEtCut
Gaudi::Property< float_t > m_electronEtCut
Definition: DQTGlobalWZFinderAlg.h:54
ZBoson
@ ZBoson
Definition: TruthClasses.h:67
DQTGlobalWZFinderAlg::m_doRunBeam
BooleanProperty m_doRunBeam
Definition: DQTGlobalWZFinderAlg.h:63
xAOD::EventInfo_v1::IS_SIMULATION
@ IS_SIMULATION
true: simulation, false: data
Definition: EventInfo_v1.h:151
DQTGlobalWZFinderAlg::m_isoMuonContainerKey
SG::ReadDecorHandleKeyArray< xAOD::MuonContainer > m_isoMuonContainerKey
Definition: DQTGlobalWZFinderAlg.h:106
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::EgammaHelpers::getBkgElectronMother
const xAOD::TruthParticle * getBkgElectronMother(const xAOD::Electron *el, const bool allTheWayBack=true)
Helper wrapper function for calling the function above extracting the truth from a reco electron.
Definition: EgammaTruthxAODHelpers.cxx:137
AthMonitorAlgorithm::Environment_t::user
@ user
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
FSRPhot
@ FSRPhot
Definition: TruthClasses.h:96
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
xAOD::CaloCluster_v1::etaBE
float etaBE(const unsigned layer) const
Get the eta in one layer of the EM Calo.
Definition: CaloCluster_v1.cxx:628
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
DQTGlobalWZFinderAlg::doEleTP
void doEleTP(const xAOD::Electron *leadingAllEle, const xAOD::Electron *subleadingAllEle, const xAOD::Vertex *pVtx, const EventContext &ctx, bool writeTTrees, bool isSimulation, const float evtWeight) const
Definition: DQTGlobalWZFinderAlg.cxx:466
DQTGlobalWZFinderAlg::m_TruthParticleContainerKey
SG::ReadHandleKey< xAOD::TruthParticleContainer > m_TruthParticleContainerKey
Definition: DQTGlobalWZFinderAlg.h:99
DQTGlobalWZFinderAlg::checkTruthMuon
bool checkTruthMuon(const xAOD::Muon *muon) const
Definition: DQTGlobalWZFinderAlg.cxx:1151
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
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
DQTGlobalWZFinderAlg::doMuonInDetTP
void doMuonInDetTP(std::vector< const xAOD::Muon * > &goodmuonsZ, const xAOD::Vertex *pVtx, const EventContext &ctx, bool isSimulation, bool writeTTrees, const float evtWeight) const
Definition: DQTGlobalWZFinderAlg.cxx:1024
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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
DQTGlobalWZFinderAlg::m_truthClassifier
ToolHandle< IMCTruthClassifier > m_truthClassifier
Definition: DQTGlobalWZFinderAlg.h:88
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
DQTGlobalWZFinderAlg::antiGoodElectrons
bool antiGoodElectrons(const xAOD::Electron *electron_itr, const xAOD::Vertex *pVtx, const EventContext &ctx) const
Definition: DQTGlobalWZFinderAlg.cxx:729
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
DQTGlobalWZFinderAlg::doEleContainerTP
void doEleContainerTP(std::vector< const xAOD::Electron * > &allElectrons, std::vector< const xAOD::Electron * > &goodelectrons, const EventContext &ctx) const
Definition: DQTGlobalWZFinderAlg.cxx:588
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
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:37
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:111
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
DQTGlobalWZFinderAlg::m_muonSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: DQTGlobalWZFinderAlg.h:85
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
DQTGlobalWZFinderAlg::doEleTriggerTP
void doEleTriggerTP(const xAOD::Electron *el1, const xAOD::Electron *el2, const EventContext &ctx, bool writeTTrees, const float evtWeight, bool osel, bool ssel) const
Definition: DQTGlobalWZFinderAlg.cxx:387
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition: Egamma_v1.cxx:388
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:11
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
DQTGlobalWZFinderAlg::m_zCutHigh
Gaudi::Property< float_t > m_zCutHigh
Definition: DQTGlobalWZFinderAlg.h:57
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
DQTGlobalWZFinderAlg::m_PhotonContainerKey
SG::ReadHandleKey< xAOD::PhotonContainer > m_PhotonContainerKey
Definition: DQTGlobalWZFinderAlg.h:95
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::Egamma_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle.
Definition: Egamma_v1.cxx:75
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
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.
DQTGlobalWZFinderAlg::m_ElectronContainerKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_ElectronContainerKey
Definition: DQTGlobalWZFinderAlg.h:91
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:525
DQTGlobalWZFinderAlg::m_r3MatchingTool
ToolHandle< Trig::R3MatchingTool > m_r3MatchingTool
Definition: DQTGlobalWZFinderAlg.h:86
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
IsoMuon
@ IsoMuon
Definition: TruthClasses.h:15
python.BuildSignatureFlags.muonIso
AthConfigFlags muonIso(AthConfigFlags flags, str instanceName, str recoMode)
Definition: BuildSignatureFlags.py:296
DQTGlobalWZFinderAlg::m_idTrackParticleContainerKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_idTrackParticleContainerKey
Definition: DQTGlobalWZFinderAlg.h:101
ParticleDef
Definition: TruthClasses.h:122
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
PixelAthHitMonAlgCfg.duration
duration
Definition: PixelAthHitMonAlgCfg.py:152
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
AthMonitorAlgorithm::DataType_t::cosmics
@ cosmics
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
AthMonitorAlgorithm::Environment_t::online
@ online
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
AthMonitorAlgorithm::lbAverageLivefraction
virtual float lbAverageLivefraction(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the average luminosity livefraction.
Definition: AthMonitorAlgorithm.cxx:279
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
DQTGlobalWZFinderAlg::m_muonPtCut
Gaudi::Property< float_t > m_muonPtCut
Definition: DQTGlobalWZFinderAlg.h:55
python.ElectronD3PDObject.matched
matched
Definition: ElectronD3PDObject.py:138
item
Definition: ItemListSvc.h:43
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
xAOD::Electron_v1
Definition: Electron_v1.h:34
AthMonitorAlgorithm::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the average mu, i.e.
Definition: AthMonitorAlgorithm.cxx:227
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
DQTGlobalWZFinderAlg::checkTruthTrack
bool checkTruthTrack(const xAOD::TrackParticle *trk) const
Definition: DQTGlobalWZFinderAlg.cxx:1180
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:63
xAOD::photon
@ photon
Definition: TrackingPrimitives.h:200
a
TList * a
Definition: liststreamerinfos.cxx:10
DQTGlobalWZFinderAlg::m_isoElectronContainerKey
SG::ReadDecorHandleKeyArray< xAOD::ElectronContainer > m_isoElectronContainerKey
Definition: DQTGlobalWZFinderAlg.h:108
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
xAOD::Photon_v1
Definition: Photon_v1.h:37
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MCTruthPartClassifier
Definition: TruthClassifiers.h:12
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: AthMonitorAlgorithm.cxx:7
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
xAOD::Egamma_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: Egamma_v1.cxx:65
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
DQTGlobalWZFinderAlg::m_doTrigger
BooleanProperty m_doTrigger
Definition: DQTGlobalWZFinderAlg.h:64
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
DQTGlobalWZFinderAlg::m_muonMaxEta
Gaudi::Property< float_t > m_muonMaxEta
Definition: DQTGlobalWZFinderAlg.h:58
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
AthMonitorAlgorithm::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the duration of the luminosity block (in seconds)
Definition: AthMonitorAlgorithm.cxx:324
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
DQTGlobalWZFinderAlg::goodElectrons
bool goodElectrons(const xAOD::Electron *electron_itr, const xAOD::Vertex *pVtx, const EventContext &ctx) const
Definition: DQTGlobalWZFinderAlg.cxx:671
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
DQTGlobalWZFinderAlg::m_msTrackParticleContainerKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_msTrackParticleContainerKey
Definition: DQTGlobalWZFinderAlg.h:103
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
DQTGlobalWZFinderAlg::m_VertexContainerKey
SG::ReadHandleKey< xAOD::VertexContainer > m_VertexContainerKey
Definition: DQTGlobalWZFinderAlg.h:97
match
bool match(std::string s1, std::string s2)
match the individual directories of two strings
Definition: hcg.cxx:356
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
xAOD::Egamma_v1::passSelection
bool passSelection(bool &value, const std::string &menu) const
Check if the egamma object pass a selection menu (using the name) If the menu decision is stored in t...
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
collisions
Definition: collisions.py:1
Generated on Sun Apr 20 2025 21:32:23 for ATLAS Offline Software by   doxygen 1.8.18