ATLAS Offline Software
Classes | Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
DerivationFramework::SkimmingToolHIGG2 Class Reference

#include <SkimmingToolHIGG2.h>

Inheritance diagram for DerivationFramework::SkimmingToolHIGG2:
Collaboration diagram for DerivationFramework::SkimmingToolHIGG2:

Classes

struct  Candidates
 

Public Member Functions

 SkimmingToolHIGG2 (const std::string &t, const std::string &n, const IInterface *p)
 Constructor with parameters. More...
 
 ~SkimmingToolHIGG2 ()
 Destructor. More...
 
virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual bool eventPassesFilter () const override
 Check that the current event passes this filter. More...
 

Private Types

enum  { NUMBER_OF_MERGED_JET_TYPES = 3 }
 

Private Member Functions

bool checkElectronQuality (const xAOD::Electron *el, const bool isTight=false) const
 
bool checkMuonQuality (const xAOD::Muon *mu, const bool isTight=false) const
 
bool checkJetQuality (const xAOD::Jet *jet) const
 
bool checkMergedJetQuality (const xAOD::Jet *jet, const unsigned int type) const
 
bool checkPhotonQuality (const xAOD::Photon *ph) const
 
bool checkTrackQuality (const xAOD::TrackParticle *trk) const
 
bool check2L (const Candidates &evt) const
 
bool check4L (const Candidates &evt) const
 
bool checkTP (const Candidates &evt) const
 
bool check2L2Q (const Candidates &evt) const
 
bool checkJPSI (const Candidates &evt) const
 
bool checkPHI (const Candidates &evt) const
 
TLorentzVector electronFourMomentum (const xAOD::Electron *el) const
 
TLorentzVector jetFourMomentum (const xAOD::Jet *jet) const
 

Static Private Member Functions

static TLorentzVector muonFourMomentum (const xAOD::Muon *mu)
 
static double getDeltaR (const double eta1, const double phi1, const double eta2, const double phi2)
 

Private Attributes

ToolHandle< Trig::TrigDecisionToolm_trigDecisionTool
 
std::atomic< unsigned int > m_ntot
 
std::atomic< unsigned int > m_npass
 
bool m_skipTriggerRequirement
 
std::string m_filterType
 
std::string m_electronSGKey
 
std::string m_muonSGKey
 
std::string m_jetSGKey
 
std::string m_mergedJetSGKey [NUMBER_OF_MERGED_JET_TYPES]
 
std::string m_photonSGKey
 
std::string m_trackSGKey
 
unsigned int m_nLeptons
 
unsigned int m_nElectrons
 
unsigned int m_nMuons
 
unsigned int m_nJets
 
unsigned int m_nMergedJets [NUMBER_OF_MERGED_JET_TYPES] {}
 
unsigned int m_nPhotons
 
unsigned int m_nTracks
 
std::string m_electronQual
 
std::string m_muonQual
 
std::string m_tightMuonQual
 
std::string m_tightElectronQual
 
std::string m_jetQual
 
std::string m_mergedJetQual [NUMBER_OF_MERGED_JET_TYPES]
 
std::string m_photonQual
 
std::string m_primaryElectronQual4L
 
std::vector< std::string > m_trigger2L
 
std::vector< std::string > m_triggerTP
 
std::vector< std::string > m_trigger2L2Q
 
std::vector< std::string > m_triggerJPSI
 
std::vector< std::string > m_triggerPHI
 
double m_electronEtCut
 
double m_muonPtCut
 
double m_tightElectronEtCut
 
double m_tightMuonPtCut
 
double m_jetPtCut
 
double m_mergedJetPtCut [NUMBER_OF_MERGED_JET_TYPES] {}
 
double m_photonPtCut
 
double m_trackPtCut
 
double m_electronEtaCut
 
double m_muonEtaCut
 
double m_caloMuonEtaCut
 
double m_jetEtaCut
 
double m_mergedJetEtaCut [NUMBER_OF_MERGED_JET_TYPES] {}
 
double m_photonEtaCut
 
double m_invariantMassCut
 
double m_invariantMassJpsiLowCut
 
double m_invariantMassJpsiUpCut
 
double m_invariantMassUpsilonLowCut
 
double m_invariantMassUpsilonUpCut
 
double m_invariantMassPhiLowCut
 
double m_invariantMassPhiUpCut
 
double m_leadingElectronEtCut
 
double m_leadingMuonPtCut
 
double m_dRElectronJetCut
 
bool m_checkLArError
 
bool m_defaultElectronFourMomentum
 
bool m_DFCommonJetFourMomentum
 
bool m_requireTightLeptons
 

Static Private Attributes

static const double s_MZ
 
static const double s_MKplus
 

Detailed Description

Author
Susum.nosp@m.u.Od.nosp@m.a@cer.nosp@m.n.ch

Definition at line 35 of file SkimmingToolHIGG2.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
private
Enumerator
NUMBER_OF_MERGED_JET_TYPES 

Definition at line 52 of file SkimmingToolHIGG2.h.

52  {
54  };

Constructor & Destructor Documentation

◆ SkimmingToolHIGG2()

DerivationFramework::SkimmingToolHIGG2::SkimmingToolHIGG2 ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Constructor with parameters.

Definition at line 23 of file SkimmingToolHIGG2.cxx.

25  :
26  base_class(t, n, p),
27  m_trigDecisionTool("Trig::TrigDecisionTool/TrigDecisionTool"),
28  m_ntot(0),
29  m_npass(0)
30 {
31 
32  declareProperty("SkipTriggerRequirement", m_skipTriggerRequirement=false);
33 
34  declareProperty("FilterType", m_filterType="2L");
35 
36  declareProperty("ElectronContainerKey", m_electronSGKey="Electrons");
37  declareProperty("MuonContainerKey", m_muonSGKey="Muons");
38  declareProperty("JetContainerKey", m_jetSGKey="AntiKt4EMTopoJets");
39  declareProperty("MergedJetContainerKey0", m_mergedJetSGKey[0]="AntiKt4EMTopoJets");
40  declareProperty("MergedJetContainerKey1", m_mergedJetSGKey[1]="AntiKt10LCTopoJets");
41  declareProperty("MergedJetContainerKey2", m_mergedJetSGKey[2]="CamKt12LCTopoJets");
42  declareProperty("PhotonContainerKey", m_photonSGKey="Photons");
43  declareProperty("TrackContainerKey", m_trackSGKey="InDetTrackParticles");
44 
45  declareProperty("NumberOfLeptons", m_nLeptons=2);
46  declareProperty("NumberOfElectrons", m_nElectrons=0);
47  declareProperty("NumberOfMuons", m_nMuons=0);
48  declareProperty("NumberOfJets", m_nJets=0);
49  declareProperty("NumberOfMergedJets0", m_nMergedJets[0]=0);
50  declareProperty("NumberOfMergedJets1", m_nMergedJets[1]=0);
51  declareProperty("NumberOfMergedJets2", m_nMergedJets[2]=0);
52  declareProperty("NumberOfPhotons", m_nPhotons=0);
53  declareProperty("NumberOfTracks", m_nTracks=0);
54 
55  declareProperty("ElectronQuality", m_electronQual="any");
56  declareProperty("MuonQuality", m_muonQual="inMS");
57  declareProperty("TightElectronQuality", m_tightElectronQual="DFCommonElectronsLHVeryLoose");
58  declareProperty("TightMuonQuality", m_tightMuonQual="DFCommonGoodMuon");
59  declareProperty("JetQuality", m_jetQual="any");
60  declareProperty("MergedJetQuality0", m_mergedJetQual[0]="any");
61  declareProperty("MergedJetQuality1", m_mergedJetQual[1]="any");
62  declareProperty("MergedJetQuality2", m_mergedJetQual[2]="any");
63  declareProperty("PhotonQuality", m_photonQual="any");
64 
65  declareProperty("PrimaryElectronQuality4L", m_primaryElectronQual4L="DFCommonElectronsLHLoose");
66 
67  declareProperty("Trigger2L", m_trigger2L=std::vector<std::string>());
68  declareProperty("TriggerTP", m_triggerTP=std::vector<std::string>());
69  declareProperty("Trigger2L2Q", m_trigger2L2Q=std::vector<std::string>());
70  declareProperty("TriggerJPSI", m_triggerJPSI=std::vector<std::string>());
71  declareProperty("TriggerPHI", m_triggerPHI=std::vector<std::string>());
72 
73  declareProperty("ElectronEtCut", m_electronEtCut=10.*CLHEP::GeV);
74  declareProperty("MuonPtCut", m_muonPtCut=10.*CLHEP::GeV);
75  declareProperty("TightElectronEtCut", m_tightElectronEtCut=15.*CLHEP::GeV);
76  declareProperty("TightMuonPtCut", m_tightMuonPtCut=15.*CLHEP::GeV);
77  declareProperty("JetPtCut", m_jetPtCut=15.*CLHEP::GeV);
78  declareProperty("MergedJetPtCut0", m_mergedJetPtCut[0]=100.*CLHEP::GeV);
79  declareProperty("MergedJetPtCut1", m_mergedJetPtCut[1]=150.*CLHEP::GeV);
80  declareProperty("MergedJetPtCut2", m_mergedJetPtCut[2]=150.*CLHEP::GeV);
81  declareProperty("PhotonPtCut", m_photonPtCut=15.*CLHEP::GeV);
82  declareProperty("TrackPtCut", m_trackPtCut=20.*CLHEP::GeV);
83 
84  declareProperty("ElectronEtaCut", m_electronEtaCut=9999.);
85  declareProperty("MuonEtaCut", m_muonEtaCut=9999.);
86  declareProperty("CaloMuonEtaCut", m_caloMuonEtaCut=0.2);
87  declareProperty("JetEtaCut", m_jetEtaCut=2.6);
88  declareProperty("MergedJetEtaCut0", m_mergedJetEtaCut[0]=2.6);
89  declareProperty("MergedJetEtaCut1", m_mergedJetEtaCut[1]=2.6);
90  declareProperty("MergedJetEtaCut2", m_mergedJetEtaCut[2]=2.6);
91  declareProperty("PhotonEtaCut", m_photonEtaCut=2.5);
92 
93  declareProperty("InvariantMassCut", m_invariantMassCut=0.*CLHEP::GeV);
94  declareProperty("InvariantMassJpsiLowCut", m_invariantMassJpsiLowCut=2.0*CLHEP::GeV);
95  declareProperty("InvariantMassJpsiUpCut", m_invariantMassJpsiUpCut=4.3*CLHEP::GeV);
96  declareProperty("InvariantMassUpsilonLowCut", m_invariantMassUpsilonLowCut=8.0*CLHEP::GeV);
97  declareProperty("InvariantMassUpsilonUpCut", m_invariantMassUpsilonUpCut=12.0*CLHEP::GeV);
98  declareProperty("InvariantMassPhiLowCut", m_invariantMassPhiLowCut=2.*s_MKplus);
99  declareProperty("InvariantMassPhiUpCut", m_invariantMassPhiUpCut=1.2*CLHEP::GeV);
100 
101  declareProperty("LeadingElectronEtCut", m_leadingElectronEtCut=0.*CLHEP::GeV);
102  declareProperty("LeadingMuonPtCut", m_leadingMuonPtCut=0.*CLHEP::GeV);
103 
104  declareProperty("DRElectronJetCut", m_dRElectronJetCut=0.05);
105 
106  declareProperty("CheckLArError", m_checkLArError=true);
107  declareProperty("UseDefaultElectronFourMomentum", m_defaultElectronFourMomentum=true);
108 
109  declareProperty("UseDFCommonJetFourMomentum", m_DFCommonJetFourMomentum=true);
110 
111  declareProperty("RequireTightLeptons", m_requireTightLeptons=false);
112 }

◆ ~SkimmingToolHIGG2()

DerivationFramework::SkimmingToolHIGG2::~SkimmingToolHIGG2 ( )

Destructor.

Definition at line 115 of file SkimmingToolHIGG2.cxx.

115  {
116 }

Member Function Documentation

◆ check2L()

bool DerivationFramework::SkimmingToolHIGG2::check2L ( const Candidates evt) const
private

Definition at line 399 of file SkimmingToolHIGG2.cxx.

400 {
401  if(!(m_nLeptons>0 and evt.goodElectrons.size()+evt.goodMuons.size()>=m_nLeptons)) return false;
402  if(!(evt.goodJets.size()>=m_nJets and evt.goodPhotons.size()>=m_nPhotons)) return false;
403 
404  bool isTriggerFired(m_trigger2L.empty() or m_skipTriggerRequirement);
405  for(unsigned int i(0); i<m_trigger2L.size(); i++) {
406  if(m_trigDecisionTool->isPassed(m_trigger2L.at(i))) {
407  isTriggerFired = true;
408  break;
409  }
410  }
411  if(!isTriggerFired) return false;
412 
413  unsigned int nGoodLeptons(evt.goodElectrons.size()+evt.goodMuons.size());
414  std::vector<TLorentzVector> v_tlv(nGoodLeptons);
415  std::vector<bool> v_isElectron(nGoodLeptons);
416  std::vector<bool> v_isTight(nGoodLeptons);
417 
418  for(unsigned int el_i(0); el_i<evt.goodElectrons.size(); el_i++) {
419  const xAOD::Electron *el(evt.goodElectrons.at(el_i));
420  TLorentzVector tlv(this->electronFourMomentum(el));
421  v_tlv.at(el_i) = tlv;
422  v_isElectron.at(el_i) = true;
423  v_isTight.at(el_i) = this->checkElectronQuality(el, true);
424  }
425 
426  for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
427  const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
429  unsigned int mu_j(evt.goodElectrons.size()+mu_i);
430  v_tlv.at(mu_j) = tlv;
431  v_isElectron.at(mu_j) = false;
432  v_isTight.at(mu_j) = this->checkMuonQuality(mu, true);
433  }
434 
435  for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
436  for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
437  if(m_requireTightLeptons and (not (v_isTight.at(i0) or v_isTight.at(i1)))) continue;
438 
439  TLorentzVector tlv_2lep(v_tlv.at(i0) + v_tlv.at(i1));
440  // Check two lepton mass
441  if(tlv_2lep.M()>m_invariantMassCut) return true;
442  }
443  }
444 
445  return false;
446 }

◆ check2L2Q()

bool DerivationFramework::SkimmingToolHIGG2::check2L2Q ( const Candidates evt) const
private

Definition at line 577 of file SkimmingToolHIGG2.cxx.

578 {
579  if(!(m_nLeptons>0 and evt.goodElectrons.size()+evt.goodMuons.size()>=m_nLeptons)) return false;
580 
581  bool isTriggerFired(m_trigger2L2Q.empty() or m_skipTriggerRequirement);
582  for(unsigned int i(0); i<m_trigger2L2Q.size(); i++) {
583  if(m_trigDecisionTool->isPassed(m_trigger2L2Q.at(i))) {
584  isTriggerFired = true;
585  break;
586  }
587  }
588  if(!isTriggerFired) return false;
589 
590  bool checkGoodJets(evt.goodJets.size()>=m_nJets and m_nJets>0);
591  for(unsigned int type(0); type<NUMBER_OF_MERGED_JET_TYPES; type++) {
592  if(m_nMergedJets[type]>0) {
593  checkGoodJets = (checkGoodJets or (evt.goodMergedJets[type].size()>=m_nMergedJets[type]));
594  }
595  }
596  if(!checkGoodJets) return false;
597 
598  unsigned int nGoodLeptons(evt.goodElectrons.size()+evt.goodMuons.size());
599  std::vector<TLorentzVector> v_tlv(nGoodLeptons);
600  std::vector<bool> v_isElectron(nGoodLeptons);
601  std::vector<bool> v_isTight(nGoodLeptons);
602 
603  for(unsigned int el_i(0); el_i<evt.goodElectrons.size(); el_i++) {
604  const xAOD::Electron *el(evt.goodElectrons.at(el_i));
605  TLorentzVector tlv(this->electronFourMomentum(el));
606  v_tlv.at(el_i) = tlv;
607  v_isElectron.at(el_i) = true;
608  v_isTight.at(el_i) = this->checkElectronQuality(el, true);
609  }
610 
611  for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
612  const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
614  unsigned int mu_j(evt.goodElectrons.size()+mu_i);
615  v_tlv.at(mu_j) = tlv;
616  v_isElectron.at(mu_j) = false;
617  v_isTight.at(mu_j) = this->checkMuonQuality(mu, true);
618  }
619 
620  for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
621  for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
622  // if(v_isElectron.at(i0)!=v_isElectron.at(i1)) continue; // Events with N(e)=1 and N(mu)=1 are kept.
623  if(m_requireTightLeptons and (not (v_isTight.at(i0) or v_isTight.at(i1)))) continue;
624 
625  TLorentzVector tlv_2lep(v_tlv.at(i0) + v_tlv.at(i1));
626  // Check two lepton mass
627  if(tlv_2lep.M()<m_invariantMassCut) continue;
628 
629  // dR(e-jet)>0.05 is required for at least two jets
630  if(v_isElectron.at(i0)) {
631  unsigned int nGoodJetsWithDRCut(0);
632  unsigned int nGoodJets(evt.goodJets.size());
633  for(unsigned int j(0); j<nGoodJets; j++) {
634  const xAOD::Jet *jet(evt.goodJets.at(j));
635  TLorentzVector jet_tlv(this->jetFourMomentum(jet));
636 
637  double dR_0(DerivationFramework::SkimmingToolHIGG2::getDeltaR(v_tlv.at(i0).Eta(), v_tlv.at(i0).Phi(), jet_tlv.Eta(), jet_tlv.Phi()));
638  if(dR_0<m_dRElectronJetCut) continue;
639 
640  double dR_1(DerivationFramework::SkimmingToolHIGG2::getDeltaR(v_tlv.at(i1).Eta(), v_tlv.at(i1).Phi(), jet_tlv.Eta(), jet_tlv.Phi()));
641  if(dR_1<m_dRElectronJetCut) continue;
642 
643  nGoodJetsWithDRCut++;
644  }
645 
646  bool checkGoodJetsWithDRCut(nGoodJetsWithDRCut>=m_nJets and m_nJets>0);
647 
648  for(unsigned int type(0); type<NUMBER_OF_MERGED_JET_TYPES; type++) {
649  if(m_nMergedJets[type]>0) {
650  unsigned int nGoodMergedJetsWithDRCut(0);
651  unsigned int nGoodMergedJets(evt.goodMergedJets[type].size());
652  for(unsigned int j(0); j<nGoodMergedJets; j++) {
653  const xAOD::Jet *jet(evt.goodMergedJets[type].at(j));
654 
655  double dR_0(DerivationFramework::SkimmingToolHIGG2::getDeltaR(v_tlv.at(i0).Eta(), v_tlv.at(i0).Phi(), jet->eta(), jet->phi()));
656  if(dR_0<m_dRElectronJetCut) continue;
657 
658  double dR_1(DerivationFramework::SkimmingToolHIGG2::getDeltaR(v_tlv.at(i1).Eta(), v_tlv.at(i1).Phi(), jet->eta(), jet->phi()));
659  if(dR_1<m_dRElectronJetCut) continue;
660 
661  nGoodMergedJetsWithDRCut++;
662  }
663 
664  checkGoodJetsWithDRCut = (checkGoodJetsWithDRCut or (nGoodMergedJetsWithDRCut>=m_nMergedJets[type]));
665  }
666  }
667  if(!checkGoodJetsWithDRCut) return false;
668  }
669 
670  // Leading lepton ET/pT cut
671  if((v_tlv.at(i0).Pt()>v_tlv.at(i1).Pt() ? v_tlv.at(i0).Pt() : v_tlv.at(i1).Pt()) > (v_isElectron.at(i0) ? m_leadingElectronEtCut : m_leadingMuonPtCut)) return true;
672  }
673  }
674 
675  return false;
676 }

◆ check4L()

bool DerivationFramework::SkimmingToolHIGG2::check4L ( const Candidates evt) const
private

Definition at line 448 of file SkimmingToolHIGG2.cxx.

449 {
450  if(!(m_nLeptons>0 and evt.goodElectrons.size()+evt.goodMuons.size()>=m_nLeptons)) return false;
451  if(!(evt.goodJets.size()>=m_nJets and evt.goodPhotons.size()>=m_nPhotons)) return false;
452 
453  unsigned int nGoodLeptons(evt.goodElectrons.size()+evt.goodMuons.size());
454  std::vector<TLorentzVector> v_tlv(nGoodLeptons);
455  std::vector<bool> v_pid(nGoodLeptons);
456 
457  for(unsigned int el_i(0); el_i<evt.goodElectrons.size(); el_i++) {
458  const xAOD::Electron *el(evt.goodElectrons.at(el_i));
459  TLorentzVector tlv(this->electronFourMomentum(el));
460  v_tlv.at(el_i) = tlv;
461 
462  bool value(false);
463  bool defined(false);
464  if(m_primaryElectronQual4L.empty()) {
465  // In the case of no identification requirement
466  defined = true;
467  value = true;
468  } else if(m_primaryElectronQual4L=="DFCommonElectronsLHVeryLoose" or
469  m_primaryElectronQual4L=="DFCommonElectronsLHLoose" or
470  m_primaryElectronQual4L=="DFCommonElectronsLHMedium" or
471  m_primaryElectronQual4L=="DFCommonElectronsLHTight" or
472  m_primaryElectronQual4L=="DFCommonElectronsML") {
473  // Use Derivation Framework variable to pickup possible new correction result
474  // If the same electron likelihood configuration is used in AOD creation and DAOD creation,
475  // DFCommonElectronsLHLoose and LHLoose are identical.
477  if(primEleAcc.isAvailable(*el)) {
478  defined = true;
479  value = static_cast<bool>(primEleAcc(*el));
480  }
481  } else {
482  // Electron menu is defined in http://acode-browser.usatlas.bnl.gov/lxr/source/atlas/Reconstruction/egamma/egammaTools/python/EMPIDBuilderBase.py
483  defined = el->passSelection(value, m_primaryElectronQual4L);
484  }
485 
486  v_pid.at(el_i) = (value and defined);
487  }
488 
489  for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
490  const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
492  unsigned int mu_j(evt.goodElectrons.size()+mu_i);
493  v_tlv.at(mu_j) = tlv;
494  v_pid.at(mu_j) = true;
495  }
496 
497  for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
498  for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
499  for(unsigned int i2(i1+1); i2<nGoodLeptons; i2++) {
500  for(unsigned int i3(i2+1); i3<nGoodLeptons; i3++) {
501  TLorentzVector tlv_4lep(v_tlv.at(i0) + v_tlv.at(i1) + v_tlv.at(i2) + v_tlv.at(i3));
502  // Check four lepton mass
503  if(tlv_4lep.M()<m_invariantMassCut) continue;
504 
505  // Check primary dilepton's electron PID (muon PID is always true)
506  if(fabs((v_tlv.at(i0)+v_tlv.at(i1)).M()-s_MZ)<fabs((v_tlv.at(i2)+v_tlv.at(i3)).M()-s_MZ)) {
507  if(v_pid.at(i0) and v_pid.at(i1)) return true;
508  } else {
509  if(v_pid.at(i2) and v_pid.at(i3)) return true;
510  }
511  if(fabs((v_tlv.at(i0)+v_tlv.at(i2)).M()-s_MZ)<fabs((v_tlv.at(i1)+v_tlv.at(i3)).M()-s_MZ)) {
512  if(v_pid.at(i0) and v_pid.at(i2)) return true;
513  } else {
514  if(v_pid.at(i1) and v_pid.at(i3)) return true;
515  }
516  if(fabs((v_tlv.at(i0)+v_tlv.at(i3)).M()-s_MZ)<fabs((v_tlv.at(i1)+v_tlv.at(i2)).M()-s_MZ)) {
517  if(v_pid.at(i0) and v_pid.at(i3)) return true;
518  } else {
519  if(v_pid.at(i1) and v_pid.at(i2)) return true;
520  }
521  }
522  }
523  }
524  }
525 
526  return false;
527 }

◆ checkElectronQuality()

bool DerivationFramework::SkimmingToolHIGG2::checkElectronQuality ( const xAOD::Electron el,
const bool  isTight = false 
) const
private

Definition at line 235 of file SkimmingToolHIGG2.cxx.

236 {
237  if(!el) return false;
238 
239  const std::string electronQual(isTight ? m_tightElectronQual : m_electronQual);
240  const double electronEtCut(isTight ? m_tightElectronEtCut : m_electronEtCut);
241 
242  if(electronQual!="any") {
243  bool value(false);
244  bool defined(false);
245  if(electronQual=="DFCommonElectronsLHVeryLoose" or
246  electronQual=="DFCommonElectronsLHLoose" or
247  electronQual=="DFCommonElectronsLHMedium" or
248  electronQual=="DFCommonElectronsLHTight" or
249  electronQual=="DFCommonElectronsML") {
250  // Use Derivation Framework variable to pickup possible new correction result
251  // If the same electron likelihood configuration is used in AOD creation and DAOD creation,
252  // DFCommonElectronsLHLoose and LHLoose are identical.
253  SG::ConstAccessor<char> qualAcc(electronQual);
254  if(qualAcc.isAvailable(*el)) {
255  defined = true;
256  value = static_cast<bool>(qualAcc(*el));
257  }
258  } else {
259  // Electron menu is defined in http://acode-browser.usatlas.bnl.gov/lxr/source/atlas/Reconstruction/egamma/egammaTools/python/EMPIDBuilderBase.py
260  defined = el->passSelection(value, electronQual);
261  }
262  if(not(value and defined)) return false;
263  }
264 
265  const xAOD::TrackParticle *trackParticle(el->trackParticle());
266  if(!trackParticle) {
267  ATH_MSG_DEBUG("xAOD::TrackParticle pointer is null");
268  return false;
269  }
271  if(!trackParticle->summaryValue(numberOfPixelHits, xAOD::numberOfPixelHits)) {
272  ATH_MSG_WARNING("xAOD::TrackParticle does not give summaryValue correctly for xAOD::numberOfPixelHits");
273  return false;
274  }
276  if(!trackParticle->summaryValue(numberOfSCTHits, xAOD::numberOfSCTHits)) {
277  ATH_MSG_WARNING("xAOD::TrackParticle does not give summaryValue correctly for xAOD::numberOfSCTHits");
278  return false;
279  }
280  if(numberOfPixelHits+numberOfSCTHits==0) return false;
281 
282  const xAOD::CaloCluster *caloCluster(el->caloCluster());
283  if(!caloCluster) {
284  ATH_MSG_WARNING("xAOD::CaloCluster pointer is null");
285  return false;
286  }
287 
288  double eta(trackParticle->eta());
289  if(fabs(eta)>10.) return false;
290  double et(caloCluster->e()/cosh(eta));
291 
292  if(et<electronEtCut) return false;
293  if(fabs(eta)>m_electronEtaCut) return false;
294 
295  return true;
296 }

◆ checkJetQuality()

bool DerivationFramework::SkimmingToolHIGG2::checkJetQuality ( const xAOD::Jet jet) const
private

Definition at line 342 of file SkimmingToolHIGG2.cxx.

343 {
344  if(!jet) return false;
345 
346  if(m_jetQual!="any") {
347  // do something
348  }
349 
350  TLorentzVector tlv(this->jetFourMomentum(jet));
351  if(tlv.Pt()<m_jetPtCut) return false;
352  if(fabs(tlv.Eta())>m_jetEtaCut) return false;
353 
354  return true;
355 }

◆ checkJPSI()

bool DerivationFramework::SkimmingToolHIGG2::checkJPSI ( const Candidates evt) const
private

Definition at line 678 of file SkimmingToolHIGG2.cxx.

679 {
680  if(!(m_nMuons>0 and evt.goodMuons.size()>=m_nMuons)) return false;
681  if(!(evt.goodPhotons.size()>=m_nPhotons)) return false;
682 
683  bool isTriggerFired(m_triggerJPSI.empty() or m_skipTriggerRequirement);
684  for(unsigned int i(0); i<m_triggerJPSI.size(); i++) {
685  if(m_trigDecisionTool->isPassed(m_triggerJPSI.at(i))) {
686  isTriggerFired = true;
687  break;
688  }
689  }
690  if(!isTriggerFired) return false;
691 
692  std::vector<TLorentzVector> v_tlv(evt.goodMuons.size());
693 
694  for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
695  const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
697  v_tlv.at(mu_i) = tlv;
698  }
699 
700  unsigned int nGoodLeptons(v_tlv.size());
701  for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
702  for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
703  TLorentzVector tlv_2lep(v_tlv.at(i0) + v_tlv.at(i1));
704 
705  // Check di-muon mass
706  if((tlv_2lep.M()<m_invariantMassJpsiLowCut or tlv_2lep.M()>m_invariantMassJpsiUpCut) and
707  (tlv_2lep.M()<m_invariantMassUpsilonLowCut or tlv_2lep.M()>m_invariantMassUpsilonUpCut)) continue;
708 
709  // Check leading muon pT
710  if((v_tlv.at(i0).Pt()>v_tlv.at(i1).Pt() ? v_tlv.at(i0).Pt() : v_tlv.at(i1).Pt())>m_leadingMuonPtCut) return true;
711  }
712  }
713 
714  return false;
715 }

◆ checkMergedJetQuality()

bool DerivationFramework::SkimmingToolHIGG2::checkMergedJetQuality ( const xAOD::Jet jet,
const unsigned int  type 
) const
private

Definition at line 357 of file SkimmingToolHIGG2.cxx.

358 {
359  if(!jet) return false;
360 
361  if(m_mergedJetQual[type]!="any") {
362  // do something
363  }
364 
365  if(jet->pt()<m_mergedJetPtCut[type]) return false;
366  if(fabs(jet->eta())>m_mergedJetEtaCut[type]) return false;
367 
368  return true;
369 }

◆ checkMuonQuality()

bool DerivationFramework::SkimmingToolHIGG2::checkMuonQuality ( const xAOD::Muon mu,
const bool  isTight = false 
) const
private

Definition at line 298 of file SkimmingToolHIGG2.cxx.

299 {
300  if(!mu) return false;
301 
302  const std::string muonQual(isTight ? m_tightMuonQual : m_muonQual);
303  const double muonPtCut(isTight ? m_tightMuonPtCut : m_muonPtCut);
304 
305  if(muonQual=="any") {
306  // do nothing
307  } else if(muonQual=="combined") {
308  if(mu->muonType()!=xAOD::Muon::Combined) return false;
309  } else if(muonQual=="standalone") {
310  if(mu->muonType()!=xAOD::Muon::MuonStandAlone) return false;
311  } else if(muonQual=="lowpt") {
312  if(mu->muonType()!=xAOD::Muon::SegmentTagged) return false;
313  } else if(muonQual=="combined+lowpt") {
314  if(mu->muonType()!=xAOD::Muon::Combined and mu->muonType()!=xAOD::Muon::SegmentTagged) return false;
315  } else if(muonQual=="inMS") {
316  if(mu->muonType()==xAOD::Muon::MuonStandAlone and fabs(fabs(mu->eta())-2.6)>0.12) return false;
317  } else if(muonQual=="DFCommonGoodMuon") { // Derivation Framework variable
318  static const SG::ConstAccessor<char> DFCommonGoodMuonAcc("DFCommonGoodMuon");
319  if(!DFCommonGoodMuonAcc.withDefault(*mu, false)) return false;
320  } else if(muonQual=="DFCommonMuonsLoose") { // Derivation Framework variable
321  static const SG::ConstAccessor<char> DFCommonMuonsLooseAcc("DFCommonMuonsLoose");
322  if(!DFCommonMuonsLooseAcc.withDefault(*mu, false)) return false;
323  } else if(muonQual=="DFCommonMuonsMedium") { // Derivation Framework variable
324  static const SG::ConstAccessor<char> DFCommonMuonsMediumAcc("DFCommonMuonsMedium");
325  if(!DFCommonMuonsMediumAcc.withDefault(*mu, false)) return false;
326  } else if(muonQual=="DFCommonMuonsTight") { // Derivation Framework variable
327  static const SG::ConstAccessor<char> DFCommonMuonsTightAcc("DFCommonMuonsTight");
328  if(!DFCommonMuonsTightAcc.withDefault(*mu, false)) return false;
329  } else {
330  ATH_MSG_WARNING("Muon quality " << muonQual << "is not defined");
331  return false;
332  }
333 
334  if(mu->pt()<muonPtCut) return false;
335  if(fabs(mu->eta())>m_muonEtaCut) return false;
336  if(muonQual!="DFCommonGoodMuon" and
337  (mu->muonType()==xAOD::Muon::CaloTagged and fabs(mu->eta())>m_caloMuonEtaCut)) return false;
338 
339  return true;
340 }

◆ checkPHI()

bool DerivationFramework::SkimmingToolHIGG2::checkPHI ( const Candidates evt) const
private

Definition at line 717 of file SkimmingToolHIGG2.cxx.

718 {
719  // Check if there are candidates
720  if(!(m_nTracks>0 and evt.goodTracks.size()>=m_nTracks)) return false;
721  if(!(evt.goodPhotons.size()>=m_nPhotons)) return false;
722 
723  // Check if triggers are OK
724  bool isTriggerFired(m_triggerPHI.empty() or m_skipTriggerRequirement);
725  for(unsigned int i(0); i<m_triggerPHI.size(); i++) {
726  if(m_trigDecisionTool->isPassed(m_triggerPHI.at(i))) {
727  isTriggerFired = true;
728  break;
729  }
730  }
731  if(!isTriggerFired) return false;
732 
733  // Get 4-momentum of tracks (=charged kaons)
734  std::vector<TLorentzVector> v_tlv[2];
735  for(unsigned int trk_i(0); trk_i<evt.goodTracks.size(); trk_i++) {
736  const xAOD::TrackParticle *trk(evt.goodTracks.at(trk_i));
737  TLorentzVector tlv;
738  tlv.SetPtEtaPhiM(trk->pt(), trk->eta(), trk->phi(), s_MKplus); // Kaon is assumed.
739  v_tlv[trk->charge()>0. ? 0 : 1].push_back(tlv); // 0 is positive, 1 is negative
740  }
741 
742  // Check track pair mass
743  unsigned int nGoodTracks[2];
744  nGoodTracks[0] = v_tlv[0].size();
745  nGoodTracks[1] = v_tlv[1].size();
746  for(unsigned int i0(0); i0<nGoodTracks[0]; i0++) {
747  for(unsigned int i1(0); i1<nGoodTracks[1]; i1++) {
748  TLorentzVector tlv_2trk(v_tlv[0].at(i0) + v_tlv[1].at(i1));
749  if(tlv_2trk.M()<m_invariantMassPhiLowCut or tlv_2trk.M()>m_invariantMassPhiUpCut) continue;
750  return true; // One candidate is found.
751  }
752  }
753 
754  return false; // No candidate is found.
755 }

◆ checkPhotonQuality()

bool DerivationFramework::SkimmingToolHIGG2::checkPhotonQuality ( const xAOD::Photon ph) const
private

Definition at line 371 of file SkimmingToolHIGG2.cxx.

372 {
373  if(!ph) return false;
374 
375  if(m_photonQual!="any") {
376  bool value(false);
377  if(!ph->passSelection(value, m_photonQual)) {
378  ATH_MSG_WARNING("xAOD::Photon does not have menu of " << m_photonQual);
379  return false;
380  }
381  if(!value) return false;
382  }
383 
384  if(ph->pt()<m_photonPtCut) return false;
385  if(fabs(ph->eta())>m_photonEtaCut) return false;
386 
387  return true;
388 }

◆ checkTP()

bool DerivationFramework::SkimmingToolHIGG2::checkTP ( const Candidates evt) const
private

Definition at line 529 of file SkimmingToolHIGG2.cxx.

530 {
531  if(!(m_nLeptons>0 and evt.goodElectrons.size()+evt.goodMuons.size()>=m_nLeptons)) return false;
532 
533  bool isTriggerFired(m_triggerTP.empty() or m_skipTriggerRequirement);
534  for(unsigned int i(0); i<m_triggerTP.size(); i++) {
535  if(m_trigDecisionTool->isPassed(m_triggerTP.at(i))) {
536  isTriggerFired = true;
537  break;
538  }
539  }
540  if(!isTriggerFired) return false;
541 
542  unsigned int nGoodLeptons(evt.goodElectrons.size()+evt.goodMuons.size());
543  std::vector<TLorentzVector> v_tlv(nGoodLeptons);
544  std::vector<bool> v_isElectron(nGoodLeptons);
545 
546  for(unsigned int el_i(0); el_i<evt.goodElectrons.size(); el_i++) {
547  const xAOD::Electron *el(evt.goodElectrons.at(el_i));
548  TLorentzVector tlv(this->electronFourMomentum(el));
549  v_tlv.at(el_i) = tlv;
550  v_isElectron.at(el_i) = true;
551  }
552 
553  for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
554  const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
556  unsigned int mu_j(evt.goodElectrons.size()+mu_i);
557  v_tlv.at(mu_j) = tlv;
558  v_isElectron.at(mu_j) = false;
559  }
560 
561  for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
562  for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
563  if(v_isElectron.at(i0)!=v_isElectron.at(i1)) continue;
564 
565  TLorentzVector tlv_2lep(v_tlv.at(i0) + v_tlv.at(i1));
566  // Check two lepton mass
567  if(tlv_2lep.M()<m_invariantMassCut) continue;
568 
569  // Leading lepton ET/pT cut
570  if((v_tlv.at(i0).Pt()>v_tlv.at(i1).Pt() ? v_tlv.at(i0).Pt() : v_tlv.at(i1).Pt()) > (v_isElectron.at(i0) ? m_leadingElectronEtCut : m_leadingMuonPtCut)) return true;
571  }
572  }
573 
574  return false;
575 }

◆ checkTrackQuality()

bool DerivationFramework::SkimmingToolHIGG2::checkTrackQuality ( const xAOD::TrackParticle trk) const
private

Definition at line 390 of file SkimmingToolHIGG2.cxx.

391 {
392  if(!trk) return false;
393 
394  if(trk->pt()<m_trackPtCut) return false;
395 
396  return true;
397 }

◆ electronFourMomentum()

TLorentzVector DerivationFramework::SkimmingToolHIGG2::electronFourMomentum ( const xAOD::Electron el) const
private

Definition at line 757 of file SkimmingToolHIGG2.cxx.

758 {
759  TLorentzVector tlv;
760  tlv.SetPtEtaPhiE(el->pt(), el->eta(), el->phi(), el->e());
761  if(m_defaultElectronFourMomentum) return tlv;
762 
763  const xAOD::TrackParticle *trackParticle(el->trackParticle());
764  if(!trackParticle) {
765  ATH_MSG_WARNING("xAOD::TrackParticle pointer is null");
766  return tlv;
767  }
768  const xAOD::CaloCluster *caloCluster(el->caloCluster());
769  if(!caloCluster) {
770  ATH_MSG_WARNING("xAOD::CaloCluster pointer is null");
771  return tlv;
772  }
773 
774  double eta(trackParticle->eta());
775  double phi(trackParticle->phi());
776  if(fabs(eta)>10.) {
777  ATH_MSG_WARNING("fabs(trackParticle->eta()) = " << eta << " > 10.");
778  return tlv;
779  }
780  double e(caloCluster->e());
781  double et(e/cosh(eta));
782 
783  tlv.SetPtEtaPhiE(et, eta, phi, e);
784  return tlv;
785 }

◆ eventPassesFilter()

bool DerivationFramework::SkimmingToolHIGG2::eventPassesFilter ( ) const
overridevirtual

Check that the current event passes this filter.

Definition at line 146 of file SkimmingToolHIGG2.cxx.

147 {
148  m_ntot++;
149  bool acceptEvent(false);
150  StatusCode sc(StatusCode::SUCCESS);
151 
152  // Retrieve EventInfo
153  const xAOD::EventInfo *eventInfo(nullptr);
154  ATH_CHECK(evtStore()->retrieve(eventInfo), false);
155 
156  // LAr error check
157  if(m_checkLArError) {
159  return acceptEvent;
160  }
161  }
162 
164  // Electrons
165  if(m_nElectrons>0 or m_nLeptons>0) {
166  const xAOD::ElectronContainer *electrons(nullptr);
167  ATH_CHECK(evtStore()->retrieve(electrons, m_electronSGKey), false);
168  for(const auto *el: *electrons) {
169  if(this->checkElectronQuality(el)) evt.goodElectrons.push_back(el);
170  }
171  }
172 
173  // Muons
174  if(m_nMuons>0 or m_nLeptons>0) {
175  const xAOD::MuonContainer *muons(nullptr);
176  ATH_CHECK(evtStore()->retrieve(muons, m_muonSGKey), false);
177  for(const auto *mu: *muons) {
178  if(this->checkMuonQuality(mu)) evt.goodMuons.push_back(mu);
179  }
180  }
181 
182  // Jets
183  if(m_nJets>0) {
184  const xAOD::JetContainer *jets(nullptr);
185  ATH_CHECK(evtStore()->retrieve(jets, m_jetSGKey), false);
186  for(const auto *jet: *jets) {
187  if(this->checkJetQuality(jet)) evt.goodJets.push_back(jet);
188  }
189  }
190  for(unsigned int type(0); type<NUMBER_OF_MERGED_JET_TYPES; type++) {
191  if(m_nMergedJets[type]>0) {
192  const xAOD::JetContainer *jets(nullptr);
193  ATH_CHECK(evtStore()->retrieve(jets, m_mergedJetSGKey[type]), false);
194  for(const auto *jet: *jets) {
195  if(this->checkMergedJetQuality(jet, type)) evt.goodMergedJets[type].push_back(jet);
196  }
197  }
198  }
199 
200  // Photons
201  if(m_nPhotons>0) {
202  const xAOD::PhotonContainer *photons(nullptr);
203  ATH_CHECK(evtStore()->retrieve(photons, m_photonSGKey), false);
204  for(const auto *ph: *photons) {
205  if(this->checkPhotonQuality(ph)) evt.goodPhotons.push_back(ph);
206  }
207  }
208 
209  // Tracks
210  if(m_nTracks>0) {
211  const xAOD::TrackParticleContainer *tracks(nullptr);
212  ATH_CHECK(evtStore()->retrieve(tracks, m_trackSGKey), false);
213  for(const auto *trk: *tracks) {
214  if(this->checkTrackQuality(trk)) evt.goodTracks.push_back(trk);
215  }
216  }
217 
218  // Check conditions of filters
219  if(m_filterType=="2L") {
220  if(this->check2L(evt)) acceptEvent = true;
221  } else if(m_filterType=="4L") {
222  if(this->check4L(evt)) acceptEvent = true;
223  } else if(m_filterType=="TP") {
224  if(this->checkTP(evt)) acceptEvent = true;
225  } else if(m_filterType=="2L2Q") {
226  if(this->check2L2Q(evt)) acceptEvent = true;
227  } else if(m_filterType=="JPSI") {
228  if(this->checkJPSI(evt) or this->checkPHI(evt)) acceptEvent = true;
229  }
230 
231  if(acceptEvent) m_npass++;
232  return acceptEvent;
233 }

◆ finalize()

StatusCode DerivationFramework::SkimmingToolHIGG2::finalize ( )
overridevirtual

Definition at line 138 of file SkimmingToolHIGG2.cxx.

139 {
140  ATH_MSG_VERBOSE("finalize() ...");
141  ATH_MSG_INFO("Processed " << m_ntot << " events, " << m_npass << " events passed filter ");
142  return StatusCode::SUCCESS;
143 }

◆ getDeltaR()

double DerivationFramework::SkimmingToolHIGG2::getDeltaR ( const double  eta1,
const double  phi1,
const double  eta2,
const double  phi2 
)
staticprivate

Definition at line 815 of file SkimmingToolHIGG2.cxx.

816 {
817  double dEta(eta1 - eta2);
818  double dPhi(phi1 - phi2);
819  if(dPhi>+M_PI) dPhi -= 2.*M_PI;
820  if(dPhi<-M_PI) dPhi += 2.*M_PI;
821  double dR(sqrt(dEta*dEta + dPhi*dPhi));
822  return dR;
823 }

◆ initialize()

StatusCode DerivationFramework::SkimmingToolHIGG2::initialize ( )
overridevirtual

Definition at line 119 of file SkimmingToolHIGG2.cxx.

120 {
121  ATH_MSG_VERBOSE("initialize() ...");
122 
123  // if(m_defaultElectronFourMomentum==true and m_DFCommonElectronFourMomentum==true) {
124  // ATH_MSG_FATAL("Wrong setting both m_defaultElectronFourMomentum and m_DFCommonElectronFourMomentum are true.");
125  // return StatusCode::FAILURE;
126  // }
127 
128  // trigger decision tool
129  if(m_trigDecisionTool.retrieve(DisableTool{m_skipTriggerRequirement}).isFailure()) {
130  ATH_MSG_FATAL("Failed to retrieve tool: " << m_trigDecisionTool);
131  return StatusCode::FAILURE;
132  }
133  ATH_MSG_INFO("Retrieved tool: " << m_trigDecisionTool);
134 
135  return StatusCode::SUCCESS;
136 }

◆ jetFourMomentum()

TLorentzVector DerivationFramework::SkimmingToolHIGG2::jetFourMomentum ( const xAOD::Jet jet) const
private

Definition at line 794 of file SkimmingToolHIGG2.cxx.

795 {
796  TLorentzVector tlv;
798  static const SG::ConstAccessor<float> DFCommonJets_Calib_ptAcc("DFCommonJets_Calib_pt");
799  static const SG::ConstAccessor<float> DFCommonJets_Calib_etaAcc("DFCommonJets_Calib_eta");
800  static const SG::ConstAccessor<float> DFCommonJets_Calib_phiAcc("DFCommonJets_Calib_phi");
801  static const SG::ConstAccessor<float> DFCommonJets_Calib_mAcc("DFCommonJets_Calib_m");
802 
803  const float& pt =DFCommonJets_Calib_ptAcc(*jet);
804  const float& eta=DFCommonJets_Calib_etaAcc(*jet);
805  const float& phi=DFCommonJets_Calib_phiAcc(*jet);
806  const float& m =DFCommonJets_Calib_mAcc(*jet);
807  tlv.SetPtEtaPhiM(pt, eta, phi, m);
808  }
809  else
810  tlv.SetPtEtaPhiM(jet->pt(), jet->eta(), jet->phi(), jet->m());
811 
812  return tlv;
813 }

◆ muonFourMomentum()

TLorentzVector DerivationFramework::SkimmingToolHIGG2::muonFourMomentum ( const xAOD::Muon mu)
staticprivate

Definition at line 787 of file SkimmingToolHIGG2.cxx.

788 {
789  TLorentzVector tlv;
790  tlv.SetPtEtaPhiM(mu->pt(), mu->eta(), mu->phi(), mu->m());
791  return tlv;
792 }

Member Data Documentation

◆ m_caloMuonEtaCut

double DerivationFramework::SkimmingToolHIGG2::m_caloMuonEtaCut
private

Definition at line 116 of file SkimmingToolHIGG2.h.

◆ m_checkLArError

bool DerivationFramework::SkimmingToolHIGG2::m_checkLArError
private

Definition at line 134 of file SkimmingToolHIGG2.h.

◆ m_defaultElectronFourMomentum

bool DerivationFramework::SkimmingToolHIGG2::m_defaultElectronFourMomentum
private

Definition at line 135 of file SkimmingToolHIGG2.h.

◆ m_DFCommonJetFourMomentum

bool DerivationFramework::SkimmingToolHIGG2::m_DFCommonJetFourMomentum
private

Definition at line 143 of file SkimmingToolHIGG2.h.

◆ m_dRElectronJetCut

double DerivationFramework::SkimmingToolHIGG2::m_dRElectronJetCut
private

Definition at line 132 of file SkimmingToolHIGG2.h.

◆ m_electronEtaCut

double DerivationFramework::SkimmingToolHIGG2::m_electronEtaCut
private

Definition at line 114 of file SkimmingToolHIGG2.h.

◆ m_electronEtCut

double DerivationFramework::SkimmingToolHIGG2::m_electronEtCut
private

Definition at line 105 of file SkimmingToolHIGG2.h.

◆ m_electronQual

std::string DerivationFramework::SkimmingToolHIGG2::m_electronQual
private

Definition at line 89 of file SkimmingToolHIGG2.h.

◆ m_electronSGKey

std::string DerivationFramework::SkimmingToolHIGG2::m_electronSGKey
private

Definition at line 74 of file SkimmingToolHIGG2.h.

◆ m_filterType

std::string DerivationFramework::SkimmingToolHIGG2::m_filterType
private

Definition at line 72 of file SkimmingToolHIGG2.h.

◆ m_invariantMassCut

double DerivationFramework::SkimmingToolHIGG2::m_invariantMassCut
private

Definition at line 121 of file SkimmingToolHIGG2.h.

◆ m_invariantMassJpsiLowCut

double DerivationFramework::SkimmingToolHIGG2::m_invariantMassJpsiLowCut
private

Definition at line 122 of file SkimmingToolHIGG2.h.

◆ m_invariantMassJpsiUpCut

double DerivationFramework::SkimmingToolHIGG2::m_invariantMassJpsiUpCut
private

Definition at line 123 of file SkimmingToolHIGG2.h.

◆ m_invariantMassPhiLowCut

double DerivationFramework::SkimmingToolHIGG2::m_invariantMassPhiLowCut
private

Definition at line 126 of file SkimmingToolHIGG2.h.

◆ m_invariantMassPhiUpCut

double DerivationFramework::SkimmingToolHIGG2::m_invariantMassPhiUpCut
private

Definition at line 127 of file SkimmingToolHIGG2.h.

◆ m_invariantMassUpsilonLowCut

double DerivationFramework::SkimmingToolHIGG2::m_invariantMassUpsilonLowCut
private

Definition at line 124 of file SkimmingToolHIGG2.h.

◆ m_invariantMassUpsilonUpCut

double DerivationFramework::SkimmingToolHIGG2::m_invariantMassUpsilonUpCut
private

Definition at line 125 of file SkimmingToolHIGG2.h.

◆ m_jetEtaCut

double DerivationFramework::SkimmingToolHIGG2::m_jetEtaCut
private

Definition at line 117 of file SkimmingToolHIGG2.h.

◆ m_jetPtCut

double DerivationFramework::SkimmingToolHIGG2::m_jetPtCut
private

Definition at line 109 of file SkimmingToolHIGG2.h.

◆ m_jetQual

std::string DerivationFramework::SkimmingToolHIGG2::m_jetQual
private

Definition at line 93 of file SkimmingToolHIGG2.h.

◆ m_jetSGKey

std::string DerivationFramework::SkimmingToolHIGG2::m_jetSGKey
private

Definition at line 76 of file SkimmingToolHIGG2.h.

◆ m_leadingElectronEtCut

double DerivationFramework::SkimmingToolHIGG2::m_leadingElectronEtCut
private

Definition at line 129 of file SkimmingToolHIGG2.h.

◆ m_leadingMuonPtCut

double DerivationFramework::SkimmingToolHIGG2::m_leadingMuonPtCut
private

Definition at line 130 of file SkimmingToolHIGG2.h.

◆ m_mergedJetEtaCut

double DerivationFramework::SkimmingToolHIGG2::m_mergedJetEtaCut[NUMBER_OF_MERGED_JET_TYPES] {}
private

Definition at line 118 of file SkimmingToolHIGG2.h.

◆ m_mergedJetPtCut

double DerivationFramework::SkimmingToolHIGG2::m_mergedJetPtCut[NUMBER_OF_MERGED_JET_TYPES] {}
private

Definition at line 110 of file SkimmingToolHIGG2.h.

◆ m_mergedJetQual

std::string DerivationFramework::SkimmingToolHIGG2::m_mergedJetQual[NUMBER_OF_MERGED_JET_TYPES]
private

Definition at line 94 of file SkimmingToolHIGG2.h.

◆ m_mergedJetSGKey

std::string DerivationFramework::SkimmingToolHIGG2::m_mergedJetSGKey[NUMBER_OF_MERGED_JET_TYPES]
private

Definition at line 77 of file SkimmingToolHIGG2.h.

◆ m_muonEtaCut

double DerivationFramework::SkimmingToolHIGG2::m_muonEtaCut
private

Definition at line 115 of file SkimmingToolHIGG2.h.

◆ m_muonPtCut

double DerivationFramework::SkimmingToolHIGG2::m_muonPtCut
private

Definition at line 106 of file SkimmingToolHIGG2.h.

◆ m_muonQual

std::string DerivationFramework::SkimmingToolHIGG2::m_muonQual
private

Definition at line 90 of file SkimmingToolHIGG2.h.

◆ m_muonSGKey

std::string DerivationFramework::SkimmingToolHIGG2::m_muonSGKey
private

Definition at line 75 of file SkimmingToolHIGG2.h.

◆ m_nElectrons

unsigned int DerivationFramework::SkimmingToolHIGG2::m_nElectrons
private

Definition at line 82 of file SkimmingToolHIGG2.h.

◆ m_nJets

unsigned int DerivationFramework::SkimmingToolHIGG2::m_nJets
private

Definition at line 84 of file SkimmingToolHIGG2.h.

◆ m_nLeptons

unsigned int DerivationFramework::SkimmingToolHIGG2::m_nLeptons
private

Definition at line 81 of file SkimmingToolHIGG2.h.

◆ m_nMergedJets

unsigned int DerivationFramework::SkimmingToolHIGG2::m_nMergedJets[NUMBER_OF_MERGED_JET_TYPES] {}
private

Definition at line 85 of file SkimmingToolHIGG2.h.

◆ m_nMuons

unsigned int DerivationFramework::SkimmingToolHIGG2::m_nMuons
private

Definition at line 83 of file SkimmingToolHIGG2.h.

◆ m_npass

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG2::m_npass
mutableprivate

Definition at line 59 of file SkimmingToolHIGG2.h.

◆ m_nPhotons

unsigned int DerivationFramework::SkimmingToolHIGG2::m_nPhotons
private

Definition at line 86 of file SkimmingToolHIGG2.h.

◆ m_ntot

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG2::m_ntot
mutableprivate

Definition at line 58 of file SkimmingToolHIGG2.h.

◆ m_nTracks

unsigned int DerivationFramework::SkimmingToolHIGG2::m_nTracks
private

Definition at line 87 of file SkimmingToolHIGG2.h.

◆ m_photonEtaCut

double DerivationFramework::SkimmingToolHIGG2::m_photonEtaCut
private

Definition at line 119 of file SkimmingToolHIGG2.h.

◆ m_photonPtCut

double DerivationFramework::SkimmingToolHIGG2::m_photonPtCut
private

Definition at line 111 of file SkimmingToolHIGG2.h.

◆ m_photonQual

std::string DerivationFramework::SkimmingToolHIGG2::m_photonQual
private

Definition at line 95 of file SkimmingToolHIGG2.h.

◆ m_photonSGKey

std::string DerivationFramework::SkimmingToolHIGG2::m_photonSGKey
private

Definition at line 78 of file SkimmingToolHIGG2.h.

◆ m_primaryElectronQual4L

std::string DerivationFramework::SkimmingToolHIGG2::m_primaryElectronQual4L
private

Definition at line 97 of file SkimmingToolHIGG2.h.

◆ m_requireTightLeptons

bool DerivationFramework::SkimmingToolHIGG2::m_requireTightLeptons
private

Definition at line 145 of file SkimmingToolHIGG2.h.

◆ m_skipTriggerRequirement

bool DerivationFramework::SkimmingToolHIGG2::m_skipTriggerRequirement
private

Definition at line 61 of file SkimmingToolHIGG2.h.

◆ m_tightElectronEtCut

double DerivationFramework::SkimmingToolHIGG2::m_tightElectronEtCut
private

Definition at line 107 of file SkimmingToolHIGG2.h.

◆ m_tightElectronQual

std::string DerivationFramework::SkimmingToolHIGG2::m_tightElectronQual
private

Definition at line 92 of file SkimmingToolHIGG2.h.

◆ m_tightMuonPtCut

double DerivationFramework::SkimmingToolHIGG2::m_tightMuonPtCut
private

Definition at line 108 of file SkimmingToolHIGG2.h.

◆ m_tightMuonQual

std::string DerivationFramework::SkimmingToolHIGG2::m_tightMuonQual
private

Definition at line 91 of file SkimmingToolHIGG2.h.

◆ m_trackPtCut

double DerivationFramework::SkimmingToolHIGG2::m_trackPtCut
private

Definition at line 112 of file SkimmingToolHIGG2.h.

◆ m_trackSGKey

std::string DerivationFramework::SkimmingToolHIGG2::m_trackSGKey
private

Definition at line 79 of file SkimmingToolHIGG2.h.

◆ m_trigDecisionTool

ToolHandle<Trig::TrigDecisionTool> DerivationFramework::SkimmingToolHIGG2::m_trigDecisionTool
private

Definition at line 56 of file SkimmingToolHIGG2.h.

◆ m_trigger2L

std::vector<std::string> DerivationFramework::SkimmingToolHIGG2::m_trigger2L
private

Definition at line 99 of file SkimmingToolHIGG2.h.

◆ m_trigger2L2Q

std::vector<std::string> DerivationFramework::SkimmingToolHIGG2::m_trigger2L2Q
private

Definition at line 101 of file SkimmingToolHIGG2.h.

◆ m_triggerJPSI

std::vector<std::string> DerivationFramework::SkimmingToolHIGG2::m_triggerJPSI
private

Definition at line 102 of file SkimmingToolHIGG2.h.

◆ m_triggerPHI

std::vector<std::string> DerivationFramework::SkimmingToolHIGG2::m_triggerPHI
private

Definition at line 103 of file SkimmingToolHIGG2.h.

◆ m_triggerTP

std::vector<std::string> DerivationFramework::SkimmingToolHIGG2::m_triggerTP
private

Definition at line 100 of file SkimmingToolHIGG2.h.

◆ s_MKplus

const double DerivationFramework::SkimmingToolHIGG2::s_MKplus
staticprivate

Definition at line 168 of file SkimmingToolHIGG2.h.

◆ s_MZ

const double DerivationFramework::SkimmingToolHIGG2::s_MZ
staticprivate

Definition at line 167 of file SkimmingToolHIGG2.h.


The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
DerivationFramework::SkimmingToolHIGG2::jetFourMomentum
TLorentzVector jetFourMomentum(const xAOD::Jet *jet) const
Definition: SkimmingToolHIGG2.cxx:794
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
DerivationFramework::SkimmingToolHIGG2::m_leadingElectronEtCut
double m_leadingElectronEtCut
Definition: SkimmingToolHIGG2.h:129
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
DerivationFramework::SkimmingToolHIGG2::m_tightMuonPtCut
double m_tightMuonPtCut
Definition: SkimmingToolHIGG2.h:108
DerivationFramework::SkimmingToolHIGG2::check4L
bool check4L(const Candidates &evt) const
Definition: SkimmingToolHIGG2.cxx:448
et
Extra patterns decribing particle interation process.
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
DerivationFramework::SkimmingToolHIGG2::m_muonQual
std::string m_muonQual
Definition: SkimmingToolHIGG2.h:90
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DerivationFramework::SkimmingToolHIGG2::Candidates::goodJets
std::vector< const xAOD::Jet * > goodJets
Definition: SkimmingToolHIGG2.h:66
DerivationFramework::SkimmingToolHIGG2::m_photonSGKey
std::string m_photonSGKey
Definition: SkimmingToolHIGG2.h:78
DerivationFramework::SkimmingToolHIGG2::checkMergedJetQuality
bool checkMergedJetQuality(const xAOD::Jet *jet, const unsigned int type) const
Definition: SkimmingToolHIGG2.cxx:357
DerivationFramework::SkimmingToolHIGG2::m_jetPtCut
double m_jetPtCut
Definition: SkimmingToolHIGG2.h:109
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
DerivationFramework::SkimmingToolHIGG2::m_checkLArError
bool m_checkLArError
Definition: SkimmingToolHIGG2.h:134
ParticleGun_SamplingFraction.eta2
eta2
Definition: ParticleGun_SamplingFraction.py:96
DerivationFramework::SkimmingToolHIGG2::check2L
bool check2L(const Candidates &evt) const
Definition: SkimmingToolHIGG2.cxx:399
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
DerivationFramework::SkimmingToolHIGG2::Candidates
Definition: SkimmingToolHIGG2.h:63
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
DerivationFramework::SkimmingToolHIGG2::m_electronSGKey
std::string m_electronSGKey
Definition: SkimmingToolHIGG2.h:74
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
DerivationFramework::SkimmingToolHIGG2::m_mergedJetPtCut
double m_mergedJetPtCut[NUMBER_OF_MERGED_JET_TYPES]
Definition: SkimmingToolHIGG2.h:110
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
DerivationFramework::SkimmingToolHIGG2::m_invariantMassCut
double m_invariantMassCut
Definition: SkimmingToolHIGG2.h:121
DerivationFramework::SkimmingToolHIGG2::checkTrackQuality
bool checkTrackQuality(const xAOD::TrackParticle *trk) const
Definition: SkimmingToolHIGG2.cxx:390
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
DerivationFramework::SkimmingToolHIGG2::m_trigger2L2Q
std::vector< std::string > m_trigger2L2Q
Definition: SkimmingToolHIGG2.h:101
DerivationFramework::SkimmingToolHIGG2::m_DFCommonJetFourMomentum
bool m_DFCommonJetFourMomentum
Definition: SkimmingToolHIGG2.h:143
DerivationFramework::SkimmingToolHIGG2::m_mergedJetQual
std::string m_mergedJetQual[NUMBER_OF_MERGED_JET_TYPES]
Definition: SkimmingToolHIGG2.h:94
DerivationFramework::SkimmingToolHIGG2::m_requireTightLeptons
bool m_requireTightLeptons
Definition: SkimmingToolHIGG2.h:145
test_pyathena.pt
pt
Definition: test_pyathena.py:11
M_PI
#define M_PI
Definition: ActiveFraction.h:11
defineDB.jets
jets
Definition: JetTagCalibration/share/defineDB.py:24
athena.value
value
Definition: athena.py:124
xAOD::eta1
setEt setPhi setE277 setWeta2 eta1
Definition: TrigEMCluster_v1.cxx:41
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
SG::ConstAccessor< char >
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
DerivationFramework::SkimmingToolHIGG2::m_jetSGKey
std::string m_jetSGKey
Definition: SkimmingToolHIGG2.h:76
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition: EventInfo_v1.h:335
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
DerivationFramework::SkimmingToolHIGG2::m_caloMuonEtaCut
double m_caloMuonEtaCut
Definition: SkimmingToolHIGG2.h:116
DerivationFramework::SkimmingToolHIGG2::s_MZ
static const double s_MZ
Definition: SkimmingToolHIGG2.h:167
DerivationFramework::SkimmingToolHIGG2::Candidates::goodMuons
std::vector< const xAOD::Muon * > goodMuons
Definition: SkimmingToolHIGG2.h:65
DerivationFramework::SkimmingToolHIGG2::m_trigDecisionTool
ToolHandle< Trig::TrigDecisionTool > m_trigDecisionTool
Definition: SkimmingToolHIGG2.h:56
DerivationFramework::SkimmingToolHIGG2::m_invariantMassPhiUpCut
double m_invariantMassPhiUpCut
Definition: SkimmingToolHIGG2.h:127
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
DerivationFramework::SkimmingToolHIGG2::checkPHI
bool checkPHI(const Candidates &evt) const
Definition: SkimmingToolHIGG2.cxx:717
xAOD::EventInfo_v1::Error
@ Error
The sub-detector issued an error.
Definition: EventInfo_v1.h:349
DerivationFramework::SkimmingToolHIGG2::m_defaultElectronFourMomentum
bool m_defaultElectronFourMomentum
Definition: SkimmingToolHIGG2.h:135
DerivationFramework::SkimmingToolHIGG2::m_muonSGKey
std::string m_muonSGKey
Definition: SkimmingToolHIGG2.h:75
DerivationFramework::SkimmingToolHIGG2::m_tightElectronEtCut
double m_tightElectronEtCut
Definition: SkimmingToolHIGG2.h:107
DerivationFramework::SkimmingToolHIGG2::s_MKplus
static const double s_MKplus
Definition: SkimmingToolHIGG2.h:168
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
DerivationFramework::SkimmingToolHIGG2::m_nLeptons
unsigned int m_nLeptons
Definition: SkimmingToolHIGG2.h:81
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
DerivationFramework::SkimmingToolHIGG2::m_jetEtaCut
double m_jetEtaCut
Definition: SkimmingToolHIGG2.h:117
DerivationFramework::SkimmingToolHIGG2::m_trackSGKey
std::string m_trackSGKey
Definition: SkimmingToolHIGG2.h:79
DerivationFramework::SkimmingToolHIGG2::m_npass
std::atomic< unsigned int > m_npass
Definition: SkimmingToolHIGG2.h:59
DerivationFramework::SkimmingToolHIGG2::m_muonPtCut
double m_muonPtCut
Definition: SkimmingToolHIGG2.h:106
DerivationFramework::SkimmingToolHIGG2::m_nMergedJets
unsigned int m_nMergedJets[NUMBER_OF_MERGED_JET_TYPES]
Definition: SkimmingToolHIGG2.h:85
lumiFormat.i
int i
Definition: lumiFormat.py:85
beamspotman.n
n
Definition: beamspotman.py:731
DerivationFramework::SkimmingToolHIGG2::m_electronQual
std::string m_electronQual
Definition: SkimmingToolHIGG2.h:89
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
DerivationFramework::SkimmingToolHIGG2::muonFourMomentum
static TLorentzVector muonFourMomentum(const xAOD::Muon *mu)
Definition: SkimmingToolHIGG2.cxx:787
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:548
DerivationFramework::SkimmingToolHIGG2::getDeltaR
static double getDeltaR(const double eta1, const double phi1, const double eta2, const double phi2)
Definition: SkimmingToolHIGG2.cxx:815
DerivationFramework::SkimmingToolHIGG2::m_primaryElectronQual4L
std::string m_primaryElectronQual4L
Definition: SkimmingToolHIGG2.h:97
DerivationFramework::SkimmingToolHIGG2::m_tightMuonQual
std::string m_tightMuonQual
Definition: SkimmingToolHIGG2.h:91
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
DerivationFramework::SkimmingToolHIGG2::m_nMuons
unsigned int m_nMuons
Definition: SkimmingToolHIGG2.h:83
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
DerivationFramework::SkimmingToolHIGG2::m_skipTriggerRequirement
bool m_skipTriggerRequirement
Definition: SkimmingToolHIGG2.h:61
DerivationFramework::SkimmingToolHIGG2::m_triggerTP
std::vector< std::string > m_triggerTP
Definition: SkimmingToolHIGG2.h:100
DerivationFramework::SkimmingToolHIGG2::m_mergedJetSGKey
std::string m_mergedJetSGKey[NUMBER_OF_MERGED_JET_TYPES]
Definition: SkimmingToolHIGG2.h:77
DerivationFramework::SkimmingToolHIGG2::NUMBER_OF_MERGED_JET_TYPES
@ NUMBER_OF_MERGED_JET_TYPES
Definition: SkimmingToolHIGG2.h:53
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
DerivationFramework::SkimmingToolHIGG2::m_nTracks
unsigned int m_nTracks
Definition: SkimmingToolHIGG2.h:87
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
DerivationFramework::SkimmingToolHIGG2::m_jetQual
std::string m_jetQual
Definition: SkimmingToolHIGG2.h:93
DerivationFramework::SkimmingToolHIGG2::m_invariantMassUpsilonUpCut
double m_invariantMassUpsilonUpCut
Definition: SkimmingToolHIGG2.h:125
DerivationFramework::SkimmingToolHIGG2::m_invariantMassUpsilonLowCut
double m_invariantMassUpsilonLowCut
Definition: SkimmingToolHIGG2.h:124
DerivationFramework::SkimmingToolHIGG2::electronFourMomentum
TLorentzVector electronFourMomentum(const xAOD::Electron *el) const
Definition: SkimmingToolHIGG2.cxx:757
DerivationFramework::SkimmingToolHIGG2::m_muonEtaCut
double m_muonEtaCut
Definition: SkimmingToolHIGG2.h:115
DerivationFramework::SkimmingToolHIGG2::checkMuonQuality
bool checkMuonQuality(const xAOD::Muon *mu, const bool isTight=false) const
Definition: SkimmingToolHIGG2.cxx:298
DerivationFramework::SkimmingToolHIGG2::m_trackPtCut
double m_trackPtCut
Definition: SkimmingToolHIGG2.h:112
DerivationFramework::SkimmingToolHIGG2::m_electronEtaCut
double m_electronEtaCut
Definition: SkimmingToolHIGG2.h:114
DerivationFramework::SkimmingToolHIGG2::checkTP
bool checkTP(const Candidates &evt) const
Definition: SkimmingToolHIGG2.cxx:529
DerivationFramework::SkimmingToolHIGG2::m_photonPtCut
double m_photonPtCut
Definition: SkimmingToolHIGG2.h:111
xAOD::Electron_v1
Definition: Electron_v1.h:34
DerivationFramework::SkimmingToolHIGG2::Candidates::goodMergedJets
std::vector< const xAOD::Jet * > goodMergedJets[NUMBER_OF_MERGED_JET_TYPES]
Definition: SkimmingToolHIGG2.h:67
columnar::ContainerId::eventInfo
@ eventInfo
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
DerivationFramework::SkimmingToolHIGG2::checkJetQuality
bool checkJetQuality(const xAOD::Jet *jet) const
Definition: SkimmingToolHIGG2.cxx:342
xAOD::Jet_v1
Class describing a jet.
Definition: Jet_v1.h:57
DerivationFramework::SkimmingToolHIGG2::m_invariantMassPhiLowCut
double m_invariantMassPhiLowCut
Definition: SkimmingToolHIGG2.h:126
DerivationFramework::SkimmingToolHIGG2::checkJPSI
bool checkJPSI(const Candidates &evt) const
Definition: SkimmingToolHIGG2.cxx:678
DerivationFramework::SkimmingToolHIGG2::m_leadingMuonPtCut
double m_leadingMuonPtCut
Definition: SkimmingToolHIGG2.h:130
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DerivationFramework::SkimmingToolHIGG2::m_invariantMassJpsiUpCut
double m_invariantMassJpsiUpCut
Definition: SkimmingToolHIGG2.h:123
DerivationFramework::SkimmingToolHIGG2::m_dRElectronJetCut
double m_dRElectronJetCut
Definition: SkimmingToolHIGG2.h:132
DerivationFramework::SkimmingToolHIGG2::m_photonQual
std::string m_photonQual
Definition: SkimmingToolHIGG2.h:95
DerivationFramework::SkimmingToolHIGG2::m_nPhotons
unsigned int m_nPhotons
Definition: SkimmingToolHIGG2.h:86
DerivationFramework::SkimmingToolHIGG2::Candidates::goodElectrons
std::vector< const xAOD::Electron * > goodElectrons
Definition: SkimmingToolHIGG2.h:64
DerivationFramework::SkimmingToolHIGG2::checkElectronQuality
bool checkElectronQuality(const xAOD::Electron *el, const bool isTight=false) const
Definition: SkimmingToolHIGG2.cxx:235
DerivationFramework::SkimmingToolHIGG2::m_triggerPHI
std::vector< std::string > m_triggerPHI
Definition: SkimmingToolHIGG2.h:103
xAOD::Egamma_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: Egamma_v1.cxx:65
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
DerivationFramework::SkimmingToolHIGG2::m_ntot
std::atomic< unsigned int > m_ntot
Definition: SkimmingToolHIGG2.h:58
xAOD::Egamma_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: Egamma_v1.cxx:70
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
DerivationFramework::SkimmingToolHIGG2::check2L2Q
bool check2L2Q(const Candidates &evt) const
Definition: SkimmingToolHIGG2.cxx:577
DerivationFramework::SkimmingToolHIGG2::checkPhotonQuality
bool checkPhotonQuality(const xAOD::Photon *ph) const
Definition: SkimmingToolHIGG2.cxx:371
DerivationFramework::SkimmingToolHIGG2::m_mergedJetEtaCut
double m_mergedJetEtaCut[NUMBER_OF_MERGED_JET_TYPES]
Definition: SkimmingToolHIGG2.h:118
TauGNNUtils::Variables::Track::dEta
bool dEta(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:537
DerivationFramework::SkimmingToolHIGG2::m_invariantMassJpsiLowCut
double m_invariantMassJpsiLowCut
Definition: SkimmingToolHIGG2.h:122
DerivationFramework::SkimmingToolHIGG2::m_filterType
std::string m_filterType
Definition: SkimmingToolHIGG2.h:72
DerivationFramework::SkimmingToolHIGG2::m_electronEtCut
double m_electronEtCut
Definition: SkimmingToolHIGG2.h:105
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
DerivationFramework::SkimmingToolHIGG2::m_tightElectronQual
std::string m_tightElectronQual
Definition: SkimmingToolHIGG2.h:92
DerivationFramework::SkimmingToolHIGG2::m_trigger2L
std::vector< std::string > m_trigger2L
Definition: SkimmingToolHIGG2.h:99
InDetDD::electrons
@ electrons
Definition: InDetDD_Defs.h:17
DerivationFramework::SkimmingToolHIGG2::m_nJets
unsigned int m_nJets
Definition: SkimmingToolHIGG2.h:84
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...
DerivationFramework::SkimmingToolHIGG2::m_triggerJPSI
std::vector< std::string > m_triggerJPSI
Definition: SkimmingToolHIGG2.h:102
DerivationFramework::SkimmingToolHIGG2::m_nElectrons
unsigned int m_nElectrons
Definition: SkimmingToolHIGG2.h:82
DerivationFramework::SkimmingToolHIGG2::m_photonEtaCut
double m_photonEtaCut
Definition: SkimmingToolHIGG2.h:119