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.
	~SkimmingToolHIGG2 ()
	Destructor.
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual bool	eventPassesFilter () const override
	Check that the current event passes this filter.

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.

                                                         {
}  

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:

• SkimmingToolHIGG2.h
• SkimmingToolHIGG2.cxx