#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::TrigDecisionTool >	m_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.

          {
       NUMBER_OF_MERGED_JET_TYPES = 3
     };

Constructor & Destructor Documentation

◆ SkimmingToolHIGG2()

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

Constructor with parameters.

Definition at line 24 of file SkimmingToolHIGG2.cxx.

                                                    : 
   base_class(t, n, p),
   m_trigDecisionTool("Trig::TrigDecisionTool/TrigDecisionTool"),
   m_ntot(0),
   m_npass(0)
 {
  
   declareProperty("SkipTriggerRequirement", m_skipTriggerRequirement=false);
  
   declareProperty("FilterType", m_filterType="2L");
  
   declareProperty("ElectronContainerKey", m_electronSGKey="Electrons");
   declareProperty("MuonContainerKey", m_muonSGKey="Muons");
   declareProperty("JetContainerKey", m_jetSGKey="AntiKt4EMTopoJets");
   declareProperty("MergedJetContainerKey0", m_mergedJetSGKey[0]="AntiKt4EMTopoJets");
   declareProperty("MergedJetContainerKey1", m_mergedJetSGKey[1]="AntiKt10LCTopoJets");
   declareProperty("MergedJetContainerKey2", m_mergedJetSGKey[2]="CamKt12LCTopoJets");
   declareProperty("PhotonContainerKey", m_photonSGKey="Photons");
   declareProperty("TrackContainerKey", m_trackSGKey="InDetTrackParticles");
  
   declareProperty("NumberOfLeptons", m_nLeptons=2);
   declareProperty("NumberOfElectrons", m_nElectrons=0);
   declareProperty("NumberOfMuons", m_nMuons=0);
   declareProperty("NumberOfJets", m_nJets=0);
   declareProperty("NumberOfMergedJets0", m_nMergedJets[0]=0);
   declareProperty("NumberOfMergedJets1", m_nMergedJets[1]=0);
   declareProperty("NumberOfMergedJets2", m_nMergedJets[2]=0);
   declareProperty("NumberOfPhotons", m_nPhotons=0);
   declareProperty("NumberOfTracks", m_nTracks=0);
  
   declareProperty("ElectronQuality", m_electronQual="any");
   declareProperty("MuonQuality", m_muonQual="inMS");
   declareProperty("TightElectronQuality", m_tightElectronQual="DFCommonElectronsLHVeryLoose");
   declareProperty("TightMuonQuality", m_tightMuonQual="DFCommonGoodMuon");
   declareProperty("JetQuality", m_jetQual="any");
   declareProperty("MergedJetQuality0", m_mergedJetQual[0]="any");
   declareProperty("MergedJetQuality1", m_mergedJetQual[1]="any");
   declareProperty("MergedJetQuality2", m_mergedJetQual[2]="any");
   declareProperty("PhotonQuality", m_photonQual="any");
  
   declareProperty("PrimaryElectronQuality4L", m_primaryElectronQual4L="DFCommonElectronsLHLoose");
  
   declareProperty("Trigger2L", m_trigger2L=std::vector<std::string>()); 
   declareProperty("TriggerTP", m_triggerTP=std::vector<std::string>()); 
   declareProperty("Trigger2L2Q", m_trigger2L2Q=std::vector<std::string>()); 
   declareProperty("TriggerJPSI", m_triggerJPSI=std::vector<std::string>()); 
   declareProperty("TriggerPHI", m_triggerPHI=std::vector<std::string>()); 
  
   declareProperty("ElectronEtCut", m_electronEtCut=10.*CLHEP::GeV); 
   declareProperty("MuonPtCut", m_muonPtCut=10.*CLHEP::GeV); 
   declareProperty("TightElectronEtCut", m_tightElectronEtCut=15.*CLHEP::GeV); 
   declareProperty("TightMuonPtCut", m_tightMuonPtCut=15.*CLHEP::GeV); 
   declareProperty("JetPtCut", m_jetPtCut=15.*CLHEP::GeV); 
   declareProperty("MergedJetPtCut0", m_mergedJetPtCut[0]=100.*CLHEP::GeV); 
   declareProperty("MergedJetPtCut1", m_mergedJetPtCut[1]=150.*CLHEP::GeV); 
   declareProperty("MergedJetPtCut2", m_mergedJetPtCut[2]=150.*CLHEP::GeV); 
   declareProperty("PhotonPtCut", m_photonPtCut=15.*CLHEP::GeV); 
   declareProperty("TrackPtCut", m_trackPtCut=20.*CLHEP::GeV); 
  
   declareProperty("ElectronEtaCut", m_electronEtaCut=9999.); 
   declareProperty("MuonEtaCut", m_muonEtaCut=9999.); 
   declareProperty("CaloMuonEtaCut", m_caloMuonEtaCut=0.2); 
   declareProperty("JetEtaCut", m_jetEtaCut=2.6); 
   declareProperty("MergedJetEtaCut0", m_mergedJetEtaCut[0]=2.6); 
   declareProperty("MergedJetEtaCut1", m_mergedJetEtaCut[1]=2.6); 
   declareProperty("MergedJetEtaCut2", m_mergedJetEtaCut[2]=2.6); 
   declareProperty("PhotonEtaCut", m_photonEtaCut=2.5); 
  
   declareProperty("InvariantMassCut", m_invariantMassCut=0.*CLHEP::GeV); 
   declareProperty("InvariantMassJpsiLowCut", m_invariantMassJpsiLowCut=2.0*CLHEP::GeV); 
   declareProperty("InvariantMassJpsiUpCut", m_invariantMassJpsiUpCut=4.3*CLHEP::GeV); 
   declareProperty("InvariantMassUpsilonLowCut", m_invariantMassUpsilonLowCut=8.0*CLHEP::GeV); 
   declareProperty("InvariantMassUpsilonUpCut", m_invariantMassUpsilonUpCut=12.0*CLHEP::GeV); 
   declareProperty("InvariantMassPhiLowCut", m_invariantMassPhiLowCut=2.*s_MKplus); 
   declareProperty("InvariantMassPhiUpCut", m_invariantMassPhiUpCut=1.2*CLHEP::GeV); 
  
   declareProperty("LeadingElectronEtCut", m_leadingElectronEtCut=0.*CLHEP::GeV); 
   declareProperty("LeadingMuonPtCut", m_leadingMuonPtCut=0.*CLHEP::GeV); 
  
   declareProperty("DRElectronJetCut", m_dRElectronJetCut=0.05);   
  
   declareProperty("CheckLArError", m_checkLArError=true);   
   declareProperty("UseDefaultElectronFourMomentum", m_defaultElectronFourMomentum=true);
  
   declareProperty("UseDFCommonJetFourMomentum", m_DFCommonJetFourMomentum=true);
  
   declareProperty("RequireTightLeptons", m_requireTightLeptons=false);
 }

◆ ~SkimmingToolHIGG2()

DerivationFramework::SkimmingToolHIGG2::~SkimmingToolHIGG2 ( )

Destructor.

Definition at line 116 of file SkimmingToolHIGG2.cxx.

116 {

117 }

Member Function Documentation

◆ check2L()

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

private

Definition at line 400 of file SkimmingToolHIGG2.cxx.

 {
   if(!(m_nLeptons>0 and evt.goodElectrons.size()+evt.goodMuons.size()>=m_nLeptons)) return false;
   if(!(evt.goodJets.size()>=m_nJets and evt.goodPhotons.size()>=m_nPhotons)) return false;
  
   bool isTriggerFired(m_trigger2L.empty() or m_skipTriggerRequirement);
   for(unsigned int i(0); i<m_trigger2L.size(); i++) {
     if(m_trigDecisionTool->isPassed(m_trigger2L.at(i))) {
       isTriggerFired = true;
       break;
     }
   }
   if(!isTriggerFired) return false; 
  
   unsigned int nGoodLeptons(evt.goodElectrons.size()+evt.goodMuons.size());
   std::vector<TLorentzVector> v_tlv(nGoodLeptons);
   std::vector<bool> v_isElectron(nGoodLeptons);
   std::vector<bool> v_isTight(nGoodLeptons);
   
   for(unsigned int el_i(0); el_i<evt.goodElectrons.size(); el_i++) {
     const xAOD::Electron *el(evt.goodElectrons.at(el_i));
     TLorentzVector tlv(this->electronFourMomentum(el));
     v_tlv.at(el_i) = tlv;
     v_isElectron.at(el_i) = true;
     v_isTight.at(el_i) = this->checkElectronQuality(el, true);
   }
   
   for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
     const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
     TLorentzVector tlv(DerivationFramework::SkimmingToolHIGG2::muonFourMomentum(mu));
     unsigned int mu_j(evt.goodElectrons.size()+mu_i);
     v_tlv.at(mu_j) = tlv;
     v_isElectron.at(mu_j) = false;
     v_isTight.at(mu_j) = this->checkMuonQuality(mu, true);
   }
   
   for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
     for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
       if(m_requireTightLeptons and (not (v_isTight.at(i0) or v_isTight.at(i1)))) continue; 
  
       TLorentzVector tlv_2lep(v_tlv.at(i0) + v_tlv.at(i1));
       // Check two lepton mass
       if(tlv_2lep.M()>m_invariantMassCut) return true;
     }
   }
  
   return false;
 }

◆ check2L2Q()

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

private

Definition at line 578 of file SkimmingToolHIGG2.cxx.

 {
   if(!(m_nLeptons>0 and evt.goodElectrons.size()+evt.goodMuons.size()>=m_nLeptons)) return false;
  
   bool isTriggerFired(m_trigger2L2Q.empty() or m_skipTriggerRequirement);
   for(unsigned int i(0); i<m_trigger2L2Q.size(); i++) {
     if(m_trigDecisionTool->isPassed(m_trigger2L2Q.at(i))) {
       isTriggerFired = true;
       break;
     }
   }
   if(!isTriggerFired) return false;
  
   bool checkGoodJets(evt.goodJets.size()>=m_nJets and m_nJets>0);
   for(unsigned int type(0); type<NUMBER_OF_MERGED_JET_TYPES; type++) {
     if(m_nMergedJets[type]>0) {
       checkGoodJets = (checkGoodJets or (evt.goodMergedJets[type].size()>=m_nMergedJets[type]));
     }
   }
   if(!checkGoodJets) return false;
  
   unsigned int nGoodLeptons(evt.goodElectrons.size()+evt.goodMuons.size());
   std::vector<TLorentzVector> v_tlv(nGoodLeptons);
   std::vector<bool> v_isElectron(nGoodLeptons);
   std::vector<bool> v_isTight(nGoodLeptons);
   
   for(unsigned int el_i(0); el_i<evt.goodElectrons.size(); el_i++) {
     const xAOD::Electron *el(evt.goodElectrons.at(el_i));
     TLorentzVector tlv(this->electronFourMomentum(el));
     v_tlv.at(el_i) = tlv;
     v_isElectron.at(el_i) = true;
     v_isTight.at(el_i) = this->checkElectronQuality(el, true);
   }
   
   for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
     const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
     TLorentzVector tlv(DerivationFramework::SkimmingToolHIGG2::muonFourMomentum(mu));
     unsigned int mu_j(evt.goodElectrons.size()+mu_i);
     v_tlv.at(mu_j) = tlv;
     v_isElectron.at(mu_j) = false;
     v_isTight.at(mu_j) = this->checkMuonQuality(mu, true);
   }
   
   for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
     for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
       //      if(v_isElectron.at(i0)!=v_isElectron.at(i1)) continue; // Events with N(e)=1 and N(mu)=1 are kept. 
       if(m_requireTightLeptons and (not (v_isTight.at(i0) or v_isTight.at(i1)))) continue;
       
       TLorentzVector tlv_2lep(v_tlv.at(i0) + v_tlv.at(i1));
       // Check two lepton mass
       if(tlv_2lep.M()<m_invariantMassCut) continue;
  
       // dR(e-jet)>0.05 is required for at least two jets
       if(v_isElectron.at(i0)) {
     unsigned int nGoodJetsWithDRCut(0);
     unsigned int nGoodJets(evt.goodJets.size());
     for(unsigned int j(0); j<nGoodJets; j++) {
       const xAOD::Jet *jet(evt.goodJets.at(j));
       TLorentzVector jet_tlv(this->jetFourMomentum(jet));
  
       double dR_0(DerivationFramework::SkimmingToolHIGG2::getDeltaR(v_tlv.at(i0).Eta(), v_tlv.at(i0).Phi(), jet_tlv.Eta(), jet_tlv.Phi()));
       if(dR_0<m_dRElectronJetCut) continue;
       
       double dR_1(DerivationFramework::SkimmingToolHIGG2::getDeltaR(v_tlv.at(i1).Eta(), v_tlv.at(i1).Phi(), jet_tlv.Eta(), jet_tlv.Phi()));
       if(dR_1<m_dRElectronJetCut) continue;
       
       nGoodJetsWithDRCut++;
     }
  
     bool checkGoodJetsWithDRCut(nGoodJetsWithDRCut>=m_nJets and m_nJets>0);
  
     for(unsigned int type(0); type<NUMBER_OF_MERGED_JET_TYPES; type++) {
       if(m_nMergedJets[type]>0) {
         unsigned int nGoodMergedJetsWithDRCut(0);
         unsigned int nGoodMergedJets(evt.goodMergedJets[type].size());
         for(unsigned int j(0); j<nGoodMergedJets; j++) {
           const xAOD::Jet *jet(evt.goodMergedJets[type].at(j));
           
           double dR_0(DerivationFramework::SkimmingToolHIGG2::getDeltaR(v_tlv.at(i0).Eta(), v_tlv.at(i0).Phi(), jet->eta(), jet->phi()));
           if(dR_0<m_dRElectronJetCut) continue;
           
           double dR_1(DerivationFramework::SkimmingToolHIGG2::getDeltaR(v_tlv.at(i1).Eta(), v_tlv.at(i1).Phi(), jet->eta(), jet->phi()));
           if(dR_1<m_dRElectronJetCut) continue;
           
           nGoodMergedJetsWithDRCut++;
         }
  
         checkGoodJetsWithDRCut = (checkGoodJetsWithDRCut or (nGoodMergedJetsWithDRCut>=m_nMergedJets[type]));
       }
     }
     if(!checkGoodJetsWithDRCut) return false; 
       }
  
       // Leading lepton ET/pT cut
       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;
     }
   }
  
   return false;
 }

◆ check4L()

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

private

Definition at line 449 of file SkimmingToolHIGG2.cxx.

 {
   if(!(m_nLeptons>0 and evt.goodElectrons.size()+evt.goodMuons.size()>=m_nLeptons)) return false;
   if(!(evt.goodJets.size()>=m_nJets and evt.goodPhotons.size()>=m_nPhotons)) return false;
  
   unsigned int nGoodLeptons(evt.goodElectrons.size()+evt.goodMuons.size());
   std::vector<TLorentzVector> v_tlv(nGoodLeptons);
   std::vector<bool> v_pid(nGoodLeptons);
   
   for(unsigned int el_i(0); el_i<evt.goodElectrons.size(); el_i++) {
     const xAOD::Electron *el(evt.goodElectrons.at(el_i));
     TLorentzVector tlv(this->electronFourMomentum(el));
     v_tlv.at(el_i) = tlv;
  
     bool value(false);
     bool defined(false);
     if(m_primaryElectronQual4L.empty()) {
       // In the case of no identification requirement
       defined = true;
       value = true;
     } else if(m_primaryElectronQual4L=="DFCommonElectronsLHVeryLoose" or
           m_primaryElectronQual4L=="DFCommonElectronsLHLoose"     or
           m_primaryElectronQual4L=="DFCommonElectronsLHMedium"    or
           m_primaryElectronQual4L=="DFCommonElectronsLHTight"     or
           m_primaryElectronQual4L=="DFCommonElectronsML") {
       // Use Derivation Framework variable to pickup possible new correction result
       // If the same electron likelihood configuration is used in AOD creation and DAOD creation, 
       // DFCommonElectronsLHLoose and LHLoose are identical.
       SG::ConstAccessor<char> primEleAcc(m_primaryElectronQual4L);
       if(primEleAcc.isAvailable(*el)) {
     defined = true;
     value = static_cast<bool>(primEleAcc(*el));
       }
     } else {
       // Electron menu is defined in http://acode-browser.usatlas.bnl.gov/lxr/source/atlas/Reconstruction/egamma/egammaTools/python/EMPIDBuilderBase.py
       defined = el->passSelection(value, m_primaryElectronQual4L);
     }
  
     v_pid.at(el_i) = (value and defined);
   }
   
   for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
     const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
     TLorentzVector tlv(DerivationFramework::SkimmingToolHIGG2::muonFourMomentum(mu));
     unsigned int mu_j(evt.goodElectrons.size()+mu_i);
     v_tlv.at(mu_j) = tlv;
     v_pid.at(mu_j) = true;
   }
   
   for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
     for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
       for(unsigned int i2(i1+1); i2<nGoodLeptons; i2++) {
     for(unsigned int i3(i2+1); i3<nGoodLeptons; i3++) {
       TLorentzVector tlv_4lep(v_tlv.at(i0) + v_tlv.at(i1) + v_tlv.at(i2) + v_tlv.at(i3));
       // Check four lepton mass
       if(tlv_4lep.M()<m_invariantMassCut) continue;
       
       // Check primary dilepton's electron PID (muon PID is always true)
       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)) {
         if(v_pid.at(i0) and v_pid.at(i1)) return true; 
       } else {
         if(v_pid.at(i2) and v_pid.at(i3)) return true;
       }
       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)) {
         if(v_pid.at(i0) and v_pid.at(i2)) return true;
       } else {
         if(v_pid.at(i1) and v_pid.at(i3)) return true;
       }
       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)) {
         if(v_pid.at(i0) and v_pid.at(i3)) return true;
       } else {
         if(v_pid.at(i1) and v_pid.at(i2)) return true;
       }
     }
       }
     } 
   }
  
   return false;
 }

◆ checkElectronQuality()

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

private

Definition at line 236 of file SkimmingToolHIGG2.cxx.

 {
   if(!el) return false;
  
   const std::string electronQual(isTight ? m_tightElectronQual : m_electronQual);
   const double electronEtCut(isTight ? m_tightElectronEtCut : m_electronEtCut);
  
   if(electronQual!="any") {
     bool value(false);
     bool defined(false);
     if(electronQual=="DFCommonElectronsLHVeryLoose" or
        electronQual=="DFCommonElectronsLHLoose"     or
        electronQual=="DFCommonElectronsLHMedium"    or
        electronQual=="DFCommonElectronsLHTight"     or
        electronQual=="DFCommonElectronsML") {
       // Use Derivation Framework variable to pickup possible new correction result
       // If the same electron likelihood configuration is used in AOD creation and DAOD creation, 
       // DFCommonElectronsLHLoose and LHLoose are identical.
       SG::ConstAccessor<char> qualAcc(electronQual);
       if(qualAcc.isAvailable(*el)) {
     defined = true;
     value = static_cast<bool>(qualAcc(*el));
       }
     } else {
       // Electron menu is defined in http://acode-browser.usatlas.bnl.gov/lxr/source/atlas/Reconstruction/egamma/egammaTools/python/EMPIDBuilderBase.py
       defined = el->passSelection(value, electronQual);
     }
     if(not(value and defined)) return false;
   }
  
   const xAOD::TrackParticle *trackParticle(el->trackParticle());
   if(!trackParticle) {
     ATH_MSG_DEBUG("xAOD::TrackParticle pointer is null");
     return false;
   }
   uint8_t numberOfPixelHits(0);
   if(!trackParticle->summaryValue(numberOfPixelHits, xAOD::numberOfPixelHits)) {
     ATH_MSG_WARNING("xAOD::TrackParticle does not give summaryValue correctly for xAOD::numberOfPixelHits");
     return false;
   }
   uint8_t numberOfSCTHits(0);
   if(!trackParticle->summaryValue(numberOfSCTHits, xAOD::numberOfSCTHits)) {
     ATH_MSG_WARNING("xAOD::TrackParticle does not give summaryValue correctly for xAOD::numberOfSCTHits");
     return false;
   }
   if(numberOfPixelHits+numberOfSCTHits==0) return false; 
  
   const xAOD::CaloCluster *caloCluster(el->caloCluster());
   if(!caloCluster) {
     ATH_MSG_WARNING("xAOD::CaloCluster pointer is null");
     return false;
   }
  
   double eta(trackParticle->eta());
   if(fabs(eta)>10.) return false;
   double et(caloCluster->e()/cosh(eta));
  
   if(et<electronEtCut) return false;
   if(fabs(eta)>m_electronEtaCut) return false;
  
   return true;
 }

◆ checkJetQuality()

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

private

Definition at line 343 of file SkimmingToolHIGG2.cxx.

 {
   if(!jet) return false;
  
   if(m_jetQual!="any") {
     // do something
   }
  
   TLorentzVector tlv(this->jetFourMomentum(jet));
   if(tlv.Pt()<m_jetPtCut) return false;
   if(fabs(tlv.Eta())>m_jetEtaCut) return false;
  
   return true;
 }

◆ checkJPSI()

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

private

Definition at line 679 of file SkimmingToolHIGG2.cxx.

 {
   if(!(m_nMuons>0 and evt.goodMuons.size()>=m_nMuons)) return false;
   if(!(evt.goodPhotons.size()>=m_nPhotons)) return false;
  
   bool isTriggerFired(m_triggerJPSI.empty() or m_skipTriggerRequirement);
   for(unsigned int i(0); i<m_triggerJPSI.size(); i++) {
     if(m_trigDecisionTool->isPassed(m_triggerJPSI.at(i))) {
       isTriggerFired = true;
       break;
     }
   }
   if(!isTriggerFired) return false; 
  
   std::vector<TLorentzVector> v_tlv(evt.goodMuons.size());
   
   for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
     const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
     TLorentzVector tlv(DerivationFramework::SkimmingToolHIGG2::muonFourMomentum(mu));
     v_tlv.at(mu_i) = tlv;
   }
   
   unsigned int nGoodLeptons(v_tlv.size());
   for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
     for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
       TLorentzVector tlv_2lep(v_tlv.at(i0) + v_tlv.at(i1));
  
       // Check di-muon mass
       if((tlv_2lep.M()<m_invariantMassJpsiLowCut    or tlv_2lep.M()>m_invariantMassJpsiUpCut) and
      (tlv_2lep.M()<m_invariantMassUpsilonLowCut or tlv_2lep.M()>m_invariantMassUpsilonUpCut)) continue;
  
       // Check leading muon pT
       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;
     }
   }
  
   return false;
 }

◆ checkMergedJetQuality()

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

private

Definition at line 358 of file SkimmingToolHIGG2.cxx.

 {
   if(!jet) return false;
  
   if(m_mergedJetQual[type]!="any") {
     // do something
   }
  
   if(jet->pt()<m_mergedJetPtCut[type]) return false;
   if(fabs(jet->eta())>m_mergedJetEtaCut[type]) return false;
  
   return true;
 }

◆ checkMuonQuality()

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

private

Definition at line 299 of file SkimmingToolHIGG2.cxx.

 {
   if(!mu) return false;
  
   const std::string muonQual(isTight ? m_tightMuonQual : m_muonQual);
   const double muonPtCut(isTight ? m_tightMuonPtCut : m_muonPtCut);
  
   if(muonQual=="any") {
     // do nothing
   } else if(muonQual=="combined") {
     if(mu->muonType()!=xAOD::Muon::Combined) return false;
   } else if(muonQual=="standalone") {
     if(mu->muonType()!=xAOD::Muon::MuonStandAlone) return false;
   } else if(muonQual=="lowpt") {
     if(mu->muonType()!=xAOD::Muon::SegmentTagged) return false;
   } else if(muonQual=="combined+lowpt") {
     if(mu->muonType()!=xAOD::Muon::Combined and mu->muonType()!=xAOD::Muon::SegmentTagged) return false;
   } else if(muonQual=="inMS") {
     if(mu->muonType()==xAOD::Muon::MuonStandAlone and fabs(fabs(mu->eta())-2.6)>0.12) return false;
   } else if(muonQual=="DFCommonGoodMuon") { // Derivation Framework variable
     static const SG::ConstAccessor<char> DFCommonGoodMuonAcc("DFCommonGoodMuon");
     if(!DFCommonGoodMuonAcc.withDefault(*mu, false)) return false;
   } else if(muonQual=="DFCommonMuonsLoose") { // Derivation Framework variable
     static const SG::ConstAccessor<char> DFCommonMuonsLooseAcc("DFCommonMuonsLoose");
     if(!DFCommonMuonsLooseAcc.withDefault(*mu, false)) return false;
   } else if(muonQual=="DFCommonMuonsMedium") { // Derivation Framework variable
     static const SG::ConstAccessor<char> DFCommonMuonsMediumAcc("DFCommonMuonsMedium");
     if(!DFCommonMuonsMediumAcc.withDefault(*mu, false)) return false;
   } else if(muonQual=="DFCommonMuonsTight") { // Derivation Framework variable
     static const SG::ConstAccessor<char> DFCommonMuonsTightAcc("DFCommonMuonsTight");
     if(!DFCommonMuonsTightAcc.withDefault(*mu, false)) return false;
   } else {
     ATH_MSG_WARNING("Muon quality " << muonQual << "is not defined");
     return false; 
   }
  
   if(mu->pt()<muonPtCut) return false;
   if(fabs(mu->eta())>m_muonEtaCut) return false;
   if(muonQual!="DFCommonGoodMuon" and
      (mu->muonType()==xAOD::Muon::CaloTagged and fabs(mu->eta())>m_caloMuonEtaCut)) return false;
  
   return true;
 }

◆ checkPHI()

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

private

Definition at line 718 of file SkimmingToolHIGG2.cxx.

 {
   // Check if there are candidates
   if(!(m_nTracks>0 and evt.goodTracks.size()>=m_nTracks)) return false;
   if(!(evt.goodPhotons.size()>=m_nPhotons)) return false;
  
   // Check if triggers are OK
   bool isTriggerFired(m_triggerPHI.empty() or m_skipTriggerRequirement);
   for(unsigned int i(0); i<m_triggerPHI.size(); i++) {
     if(m_trigDecisionTool->isPassed(m_triggerPHI.at(i))) {
       isTriggerFired = true;
       break;
     }
   }
   if(!isTriggerFired) return false; 
  
   // Get 4-momentum of tracks (=charged kaons)
   std::vector<TLorentzVector> v_tlv[2];
   for(unsigned int trk_i(0); trk_i<evt.goodTracks.size(); trk_i++) {
     const xAOD::TrackParticle *trk(evt.goodTracks.at(trk_i));
     TLorentzVector tlv;
     tlv.SetPtEtaPhiM(trk->pt(), trk->eta(), trk->phi(), s_MKplus); // Kaon is assumed. 
     v_tlv[trk->charge()>0. ? 0 : 1].push_back(tlv); // 0 is positive, 1 is negative
   }
   
   // Check track pair mass
   unsigned int nGoodTracks[2];
   nGoodTracks[0] = v_tlv[0].size();
   nGoodTracks[1] = v_tlv[1].size();
   for(unsigned int i0(0); i0<nGoodTracks[0]; i0++) {
     for(unsigned int i1(0); i1<nGoodTracks[1]; i1++) {
       TLorentzVector tlv_2trk(v_tlv[0].at(i0) + v_tlv[1].at(i1));
       if(tlv_2trk.M()<m_invariantMassPhiLowCut or tlv_2trk.M()>m_invariantMassPhiUpCut) continue;
       return true; // One candidate is found. 
     }
   }
  
   return false; // No candidate is found. 
 }

◆ checkPhotonQuality()

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

private

Definition at line 372 of file SkimmingToolHIGG2.cxx.

 {
   if(!ph) return false;
  
   if(m_photonQual!="any") {
     bool value(false);
     if(!ph->passSelection(value, m_photonQual)) {
       ATH_MSG_WARNING("xAOD::Photon does not have menu of " << m_photonQual);
       return false;
     } 
     if(!value) return false;
   }
  
   if(ph->pt()<m_photonPtCut) return false;
   if(fabs(ph->eta())>m_photonEtaCut) return false;
  
   return true;
 }

◆ checkTP()

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

private

Definition at line 530 of file SkimmingToolHIGG2.cxx.

 {
   if(!(m_nLeptons>0 and evt.goodElectrons.size()+evt.goodMuons.size()>=m_nLeptons)) return false;
  
   bool isTriggerFired(m_triggerTP.empty() or m_skipTriggerRequirement);
   for(unsigned int i(0); i<m_triggerTP.size(); i++) {
     if(m_trigDecisionTool->isPassed(m_triggerTP.at(i))) {
       isTriggerFired = true;
       break;
     }
   }
   if(!isTriggerFired) return false; 
  
   unsigned int nGoodLeptons(evt.goodElectrons.size()+evt.goodMuons.size());
   std::vector<TLorentzVector> v_tlv(nGoodLeptons);
   std::vector<bool> v_isElectron(nGoodLeptons);
   
   for(unsigned int el_i(0); el_i<evt.goodElectrons.size(); el_i++) {
     const xAOD::Electron *el(evt.goodElectrons.at(el_i));
     TLorentzVector tlv(this->electronFourMomentum(el));
     v_tlv.at(el_i) = tlv;
     v_isElectron.at(el_i) = true;
   }
   
   for(unsigned int mu_i(0); mu_i<evt.goodMuons.size(); mu_i++) {
     const xAOD::Muon *mu(evt.goodMuons.at(mu_i));
     TLorentzVector tlv(DerivationFramework::SkimmingToolHIGG2::muonFourMomentum(mu));
     unsigned int mu_j(evt.goodElectrons.size()+mu_i);
     v_tlv.at(mu_j) = tlv;
     v_isElectron.at(mu_j) = false;
   }
   
   for(unsigned int i0(0); i0<nGoodLeptons; i0++) {
     for(unsigned int i1(i0+1); i1<nGoodLeptons; i1++) {
       if(v_isElectron.at(i0)!=v_isElectron.at(i1)) continue;
       
       TLorentzVector tlv_2lep(v_tlv.at(i0) + v_tlv.at(i1));
       // Check two lepton mass
       if(tlv_2lep.M()<m_invariantMassCut) continue;
  
       // Leading lepton ET/pT cut
       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;
     }
   }
  
   return false;
 }

◆ checkTrackQuality()

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

private

Definition at line 391 of file SkimmingToolHIGG2.cxx.

 {
   if(!trk) return false;
  
   if(trk->pt()<m_trackPtCut) return false;
  
   return true;
 }

◆ electronFourMomentum()

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

private

Definition at line 758 of file SkimmingToolHIGG2.cxx.

 {
   TLorentzVector tlv;
   tlv.SetPtEtaPhiE(el->pt(), el->eta(), el->phi(), el->e());
   if(m_defaultElectronFourMomentum) return tlv;
  
   const xAOD::TrackParticle *trackParticle(el->trackParticle());
   if(!trackParticle) {
     ATH_MSG_WARNING("xAOD::TrackParticle pointer is null");
     return tlv;
   }
   const xAOD::CaloCluster *caloCluster(el->caloCluster());
   if(!caloCluster) {
     ATH_MSG_WARNING("xAOD::CaloCluster pointer is null");
     return tlv;
   }
     
   double eta(trackParticle->eta());
   double phi(trackParticle->phi());
   if(fabs(eta)>10.) {
     ATH_MSG_WARNING("fabs(trackParticle->eta()) = " << eta << " > 10.");
     return tlv;
   }
   double e(caloCluster->e());
   double et(e/cosh(eta));
     
   tlv.SetPtEtaPhiE(et, eta, phi, e);
   return tlv;
 }

◆ eventPassesFilter()

bool DerivationFramework::SkimmingToolHIGG2::eventPassesFilter ( ) const

overridevirtual

Check that the current event passes this filter.

Definition at line 147 of file SkimmingToolHIGG2.cxx.

 {
   m_ntot++;
   bool acceptEvent(false);
   StatusCode sc(StatusCode::SUCCESS);
  
   // Retrieve EventInfo
   const xAOD::EventInfo *eventInfo(nullptr);
   ATH_CHECK(evtStore()->retrieve(eventInfo), false);
  
   // LAr error check
   if(m_checkLArError) {
     if(eventInfo->errorState(xAOD::EventInfo::LAr)==xAOD::EventInfo::Error) {
       return acceptEvent; 
     }
   }
  
   DerivationFramework::SkimmingToolHIGG2::Candidates evt;
   // Electrons
   if(m_nElectrons>0 or m_nLeptons>0) {
     const xAOD::ElectronContainer *electrons(nullptr); 
     ATH_CHECK(evtStore()->retrieve(electrons, m_electronSGKey), false);
     for(const auto *el: *electrons) {
       if(this->checkElectronQuality(el)) evt.goodElectrons.push_back(el);
     } 
   }
  
   // Muons
   if(m_nMuons>0 or m_nLeptons>0) {
     const xAOD::MuonContainer *muons(nullptr); 
     ATH_CHECK(evtStore()->retrieve(muons, m_muonSGKey), false);
     for(const auto *mu: *muons) {
       if(this->checkMuonQuality(mu)) evt.goodMuons.push_back(mu);
     } 
   }
  
   // Jets
   if(m_nJets>0) {
     const xAOD::JetContainer *jets(nullptr); 
     ATH_CHECK(evtStore()->retrieve(jets, m_jetSGKey), false);
     for(const auto *jet: *jets) {
       if(this->checkJetQuality(jet)) evt.goodJets.push_back(jet);
      }
   }
   for(unsigned int type(0); type<NUMBER_OF_MERGED_JET_TYPES; type++) {
     if(m_nMergedJets[type]>0) {
       const xAOD::JetContainer *jets(nullptr);
       ATH_CHECK(evtStore()->retrieve(jets, m_mergedJetSGKey[type]), false);
       for(const auto *jet: *jets) {
     if(this->checkMergedJetQuality(jet, type)) evt.goodMergedJets[type].push_back(jet);
       }
     }
   }
  
   // Photons
   if(m_nPhotons>0) {
     const xAOD::PhotonContainer *photons(nullptr); 
     ATH_CHECK(evtStore()->retrieve(photons, m_photonSGKey), false);
     for(const auto *ph: *photons) {
       if(this->checkPhotonQuality(ph)) evt.goodPhotons.push_back(ph);
     }
   }
  
   // Tracks
   if(m_nTracks>0) {
     const xAOD::TrackParticleContainer *tracks(nullptr);
     ATH_CHECK(evtStore()->retrieve(tracks, m_trackSGKey), false);
     for(const auto *trk: *tracks) {
       if(this->checkTrackQuality(trk)) evt.goodTracks.push_back(trk);
     }
   }
  
   // Check conditions of filters
   if(m_filterType=="2L") {
     if(this->check2L(evt)) acceptEvent = true;
   } else if(m_filterType=="4L") {
     if(this->check4L(evt)) acceptEvent = true;
   } else if(m_filterType=="TP") {
     if(this->checkTP(evt)) acceptEvent = true;
   } else if(m_filterType=="2L2Q") {
     if(this->check2L2Q(evt)) acceptEvent = true;
   } else if(m_filterType=="JPSI") {
     if(this->checkJPSI(evt) or this->checkPHI(evt)) acceptEvent = true;
   }
  
   if(acceptEvent) m_npass++;
   return acceptEvent; 
 }  

◆ finalize()

StatusCode DerivationFramework::SkimmingToolHIGG2::finalize ( )

overridevirtual

Definition at line 139 of file SkimmingToolHIGG2.cxx.

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

◆ getDeltaR()

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

staticprivate

Definition at line 816 of file SkimmingToolHIGG2.cxx.

 {
   double dEta(eta1 - eta2);
   double dPhi(phi1 - phi2);
   if(dPhi>+M_PI) dPhi -= 2.*M_PI;
   if(dPhi<-M_PI) dPhi += 2.*M_PI;
   double dR(sqrt(dEta*dEta + dPhi*dPhi));
   return dR;
 }

◆ initialize()

StatusCode DerivationFramework::SkimmingToolHIGG2::initialize ( )

overridevirtual

Definition at line 120 of file SkimmingToolHIGG2.cxx.

 {
   ATH_MSG_VERBOSE("initialize() ...");
  
   // if(m_defaultElectronFourMomentum==true and m_DFCommonElectronFourMomentum==true) {
   //   ATH_MSG_FATAL("Wrong setting both m_defaultElectronFourMomentum and m_DFCommonElectronFourMomentum are true.");
   //   return StatusCode::FAILURE;
   // }
  
   // trigger decision tool
   if(m_trigDecisionTool.retrieve(DisableTool{m_skipTriggerRequirement}).isFailure()) {
     ATH_MSG_FATAL("Failed to retrieve tool: " << m_trigDecisionTool);
     return StatusCode::FAILURE;
   }
   ATH_MSG_INFO("Retrieved tool: " << m_trigDecisionTool);
  
   return StatusCode::SUCCESS;
 }

◆ jetFourMomentum()

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

private

Definition at line 795 of file SkimmingToolHIGG2.cxx.

 {
   TLorentzVector tlv;
   if(m_DFCommonJetFourMomentum) {
     static const SG::ConstAccessor<float> DFCommonJets_Calib_ptAcc("DFCommonJets_Calib_pt");
     static const SG::ConstAccessor<float> DFCommonJets_Calib_etaAcc("DFCommonJets_Calib_eta");
     static const SG::ConstAccessor<float> DFCommonJets_Calib_phiAcc("DFCommonJets_Calib_phi");
     static const SG::ConstAccessor<float> DFCommonJets_Calib_mAcc("DFCommonJets_Calib_m");
  
     const float& pt =DFCommonJets_Calib_ptAcc(*jet);
     const float& eta=DFCommonJets_Calib_etaAcc(*jet);
     const float& phi=DFCommonJets_Calib_phiAcc(*jet);
     const float& m  =DFCommonJets_Calib_mAcc(*jet);
     tlv.SetPtEtaPhiM(pt, eta, phi, m);
   }
   else
     tlv.SetPtEtaPhiM(jet->pt(), jet->eta(), jet->phi(), jet->m());
  
   return tlv;
 }

◆ muonFourMomentum()

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

staticprivate

Definition at line 788 of file SkimmingToolHIGG2.cxx.

 {
   TLorentzVector tlv;
   tlv.SetPtEtaPhiM(mu->pt(), mu->eta(), mu->phi(), mu->m());
   return tlv;
 }

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:

Classes

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ SkimmingToolHIGG2()

◆ ~SkimmingToolHIGG2()

Member Function Documentation

◆ check2L()

◆ check2L2Q()

◆ check4L()

◆ checkElectronQuality()

◆ checkJetQuality()

◆ checkJPSI()

◆ checkMergedJetQuality()

◆ checkMuonQuality()

◆ checkPHI()

◆ checkPhotonQuality()

◆ checkTP()

◆ checkTrackQuality()

◆ electronFourMomentum()

◆ eventPassesFilter()

◆ finalize()

◆ getDeltaR()

◆ initialize()

◆ jetFourMomentum()

◆ muonFourMomentum()

Member Data Documentation

◆ m_caloMuonEtaCut

◆ m_checkLArError

◆ m_defaultElectronFourMomentum

◆ m_DFCommonJetFourMomentum

◆ m_dRElectronJetCut

◆ m_electronEtaCut

◆ m_electronEtCut

◆ m_electronQual

◆ m_electronSGKey

◆ m_filterType

◆ m_invariantMassCut

◆ m_invariantMassJpsiLowCut

◆ m_invariantMassJpsiUpCut

◆ m_invariantMassPhiLowCut

◆ m_invariantMassPhiUpCut

◆ m_invariantMassUpsilonLowCut

◆ m_invariantMassUpsilonUpCut

◆ m_jetEtaCut

◆ m_jetPtCut

◆ m_jetQual

◆ m_jetSGKey

◆ m_leadingElectronEtCut

◆ m_leadingMuonPtCut

◆ m_mergedJetEtaCut

◆ m_mergedJetPtCut

◆ m_mergedJetQual

◆ m_mergedJetSGKey

◆ m_muonEtaCut

◆ m_muonPtCut

◆ m_muonQual

◆ m_muonSGKey

◆ m_nElectrons

◆ m_nJets

◆ m_nLeptons

◆ m_nMergedJets

◆ m_nMuons

◆ m_npass

◆ m_nPhotons

◆ m_ntot

◆ m_nTracks

◆ m_photonEtaCut

◆ m_photonPtCut

◆ m_photonQual

◆ m_photonSGKey

◆ m_primaryElectronQual4L

◆ m_requireTightLeptons