#include <SkimmingToolHIGG1.h>

Inheritance diagram for DerivationFramework::SkimmingToolHIGG1:

Collaboration diagram for DerivationFramework::SkimmingToolHIGG1:

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

Private Types
using	LeadingPhotons_t = std::array<const xAOD::Photon*, 2>
	Leading and sub-leading photon (in that order).

Private Member Functions
bool	SubcutOneMergedElectron () const
bool	SubcutGoodRunList () const
bool	SubcutLArError (const xAOD::EventInfo &eventInfo) const
bool	SubcutTrigger () const
std::optional< LeadingPhotons_t >	SubcutPreselect () const
bool	SubcutOnePhotonOneElectron () const
bool	SubcutTwoElectrons () const
bool	SubcutOnePhotonOneMuon () const
bool	SubcutOnePhotonTwoElectrons () const
bool	SubcutOnePhotonTwoMuons () const
bool	SubcutOnePhotonMergedElectrons (const xAOD::EventInfo &eventInfo) const
bool	SubcutHighPtOnePhotonOneElectron () const
bool	SubcutKinematic (const LeadingPhotons_t &leadingPhotons, double invariantMass) const
bool	SubcutQuality (const LeadingPhotons_t &leadingPhotons) const
bool	SubcutIsolation () const
bool	SubcutInvariantMass (double invariantMass) const
bool	PhotonPreselect (const xAOD::Photon *ph) const
bool	ElectronPreselect (const xAOD::Electron *el) const
bool	MergedElectronPreselect (const xAOD::Electron *el) const
bool	MuonPreselect (const xAOD::Muon *mu) const
double	CalculateInvariantMass (const LeadingPhotons_t &leadingPhotons) const
double	GetDiphotonVertex () const
double	CorrectedEta (const xAOD::Photon *ph) const

Static Private Member Functions
static double	CorrectedEnergy (const xAOD::Photon *ph)
static double	ReturnRZ_1stSampling_cscopt2 (double eta1)

Private Attributes
ToolHandle< Trig::TrigDecisionTool >	m_trigDecisionTool
bool	m_reqGRL
bool	m_reqLArError
bool	m_reqTrigger
bool	m_reqPreselection
bool	m_incMergedElectron
bool	m_incSingleElectron
bool	m_incDoubleElectron
bool	m_incSingleMuon
bool	m_incDoubleMuon
bool	m_incDoubleElectronPhoton
bool	m_incMergedElectronPhoton
bool	m_incHighPtElectronPhoton
bool	m_incTwoPhotons
bool	m_reqKinematic
bool	m_reqQuality
bool	m_reqIsolation
bool	m_reqInvariantMass
std::string	m_goodRunList
std::string	m_defaultTrigger
std::vector< std::string >	m_triggers
std::vector< std::string >	m_mergedtriggers
double	m_minPhotonPt
bool	m_removeCrack
double	m_maxEta
bool	m_relativePtCuts
double	m_leadingPhotonPt
double	m_subleadingPhotonPt
double	m_minInvariantMass
double	m_maxInvariantMass
double	m_minElectronPt
double	m_minMergedElectronPt
double	m_minMuonPt
double	m_maxMuonEta
std::atomic< unsigned int >	m_n_tot {0}
std::atomic< unsigned int >	m_n_passGRL {0}
std::atomic< unsigned int >	m_n_passLArError {0}
std::atomic< unsigned int >	m_n_passTrigger {0}
std::atomic< unsigned int >	m_n_passPreselect {0}
std::atomic< unsigned int >	m_n_passSingleElectronPreselect {0}
std::atomic< unsigned int >	m_n_passDoubleElectronPreselect {0}
std::atomic< unsigned int >	m_n_passSingleMuonPreselect {0}
std::atomic< unsigned int >	m_n_passSinglePhotonDoubleMuonPreselect {0}
std::atomic< unsigned int >	m_n_passSinglePhotonDoubleElectronPreselect {0}
std::atomic< unsigned int >	m_n_passSinglePhotonMergedElectronPreselect {0}
std::atomic< unsigned int >	m_n_passHighPtPhotonMergedElectronPreselect {0}
std::atomic< unsigned int >	m_n_passSingleMergedElectronPreselect {0}
std::atomic< unsigned int >	m_n_passKinematic {0}
std::atomic< unsigned int >	m_n_passQuality {0}
std::atomic< unsigned int >	m_n_passIsolation {0}
std::atomic< unsigned int >	m_n_passInvariantMass {0}
std::atomic< unsigned int >	m_n_pass {0}
ToolHandle< IAsgElectronIsEMSelector >	m_mergedCutTools
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }
SG::ReadHandleKey< xAOD::PhotonContainer >	m_photonKey { this, "PhotonKey", "Photons", "" }
SG::ReadHandleKey< xAOD::ElectronContainer >	m_electronKey { this, "ElectronKey", "Electrons", "" }
SG::ReadHandleKey< xAOD::MuonContainer >	m_muonKey { this, "MuonKey", "Muons", "" }

Static Private Attributes
static const double	s_MZ = 91187.6*CLHEP::MeV

Detailed Description

Author: jsaxo.nosp@m.n@ce.nosp@m.rn.ch; magda.nosp@m.c@ce.nosp@m.rn.ch

Definition at line 46 of file SkimmingToolHIGG1.h.

Member Typedef Documentation

◆ LeadingPhotons_t

using DerivationFramework::SkimmingToolHIGG1::LeadingPhotons_t = std::array<const xAOD::Photon*, 2>

private

Leading and sub-leading photon (in that order).

Definition at line 127 of file SkimmingToolHIGG1.h.

Constructor & Destructor Documentation

◆ SkimmingToolHIGG1()

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

Constructor with parameters.

Definition at line 22 of file SkimmingToolHIGG1.cxx.

                                                     : 
  base_class(t, n, p),
  m_trigDecisionTool("Trig::TrigDecisionTool/TrigDecisionTool"),
  m_mergedCutTools("")
{
 
 
  declareProperty("RequireGRL",            m_reqGRL           = true);
  declareProperty("ReqireLArError",        m_reqLArError      = true);
  declareProperty("RequireTrigger",        m_reqTrigger       = true);
  declareProperty("RequirePreselection",   m_reqPreselection  = true);
  declareProperty("IncludeSingleMergedElectronPreselection", m_incMergedElectron = false);
  declareProperty("IncludeSingleElectronPreselection",   m_incSingleElectron  = true);
  declareProperty("IncludeDoubleElectronPreselection",   m_incDoubleElectron  = false);
  declareProperty("IncludeSingleMuonPreselection",       m_incSingleMuon  = true);
  declareProperty("IncludeDoubleMuonPreselection",       m_incDoubleMuon  = false);
  declareProperty("IncludePhotonDoubleElectronPreselection", m_incDoubleElectronPhoton = false);
  declareProperty("IncludePhotonMergedElectronPreselection", m_incMergedElectronPhoton = false);
  declareProperty("IncludeHighPtPhotonElectronPreselection", m_incHighPtElectronPhoton = false);
  declareProperty("IncludeDoublePhotonPreselection",     m_incTwoPhotons  = true);
 
  declareProperty("RequireKinematic",      m_reqKinematic     = true);
  declareProperty("RequireQuality",        m_reqQuality       = true);
  declareProperty("RequireIsolation",      m_reqIsolation     = true);
  declareProperty("RequireInvariantMass",  m_reqInvariantMass = true);
 
  declareProperty("GoodRunList",           m_goodRunList = "");
 
  declareProperty("DefaultTrigger",        m_defaultTrigger = "EF_g35_loose_g25_loose");
  declareProperty("Triggers",              m_triggers = std::vector<std::string>()); 
  declareProperty("MergedElectronTriggers",m_mergedtriggers = std::vector<std::string>() );
 
  declareProperty("MinimumPhotonPt",       m_minPhotonPt = 20*CLHEP::GeV);
  declareProperty("MinimumElectronPt",     m_minElectronPt = 20*CLHEP::GeV);
  declareProperty("MinimumMergedElectronPt",  m_minMergedElectronPt = 18*CLHEP::GeV);
 
  declareProperty("MinimumMuonPt",         m_minMuonPt = 20*CLHEP::GeV);
  declareProperty("MaxMuonEta",            m_maxMuonEta = 2.7);
  declareProperty("RemoveCrack",           m_removeCrack = true);
  declareProperty("MaxEta",                m_maxEta = 2.47);
 
  declareProperty("RelativePtCuts",        m_relativePtCuts     = true);
  declareProperty("LeadingPhotonPtCut",    m_leadingPhotonPt    = 0.35);
  declareProperty("SubleadingPhotonPtCut", m_subleadingPhotonPt = 0.25);
 
  declareProperty("MinInvariantMass",      m_minInvariantMass = 105*CLHEP::GeV);
  declareProperty("MaxInvariantMass",      m_maxInvariantMass = 160*CLHEP::GeV);
 
  declareProperty("MergedElectronCutTool",  m_mergedCutTools);
 
}

◆ ~SkimmingToolHIGG1()

DerivationFramework::SkimmingToolHIGG1::~SkimmingToolHIGG1 ( )

Destructor.

Definition at line 77 of file SkimmingToolHIGG1.cxx.

77 {

78}

Member Function Documentation

◆ CalculateInvariantMass()

double DerivationFramework::SkimmingToolHIGG1::CalculateInvariantMass ( const LeadingPhotons_t & leadingPhotons ) const

private

CAUTION - PLACEHOLDERS

CAUTION - CONSTANTS SHOULD BE UPDATED.

Definition at line 386 of file SkimmingToolHIGG1.cxx.

                                                                                                                {
  const double ph_e_lead   = CorrectedEnergy(leadingPhotons[0]);
  const double ph_e_subl   = CorrectedEnergy(leadingPhotons[1]);
  const double ph_eta_lead = CorrectedEta(leadingPhotons[0]);
  const double ph_eta_subl = CorrectedEta(leadingPhotons[1]);
 
  const double ph_phi_lead = leadingPhotons[0]->phi();
  const double ph_phi_subl = leadingPhotons[1]->phi();
 
  const double ph_pt_lead  = ph_e_lead / cosh(ph_eta_lead);
  const double ph_pt_subl  = ph_e_subl / cosh(ph_eta_subl);
 
  TLorentzVector leadPhotonLV;
  TLorentzVector sublPhotonLV;
  leadPhotonLV.SetPtEtaPhiM(ph_pt_lead, ph_eta_lead, ph_phi_lead, 0.);
  sublPhotonLV.SetPtEtaPhiM(ph_pt_subl, ph_eta_subl, ph_phi_subl, 0.);
 
  return (leadPhotonLV + sublPhotonLV).M();
 
}

◆ CorrectedEnergy()

double DerivationFramework::SkimmingToolHIGG1::CorrectedEnergy ( const xAOD::Photon * ph )

staticprivate

Definition at line 420 of file SkimmingToolHIGG1.cxx.

                                                                                 {
 
  return ph->e();
 
}

◆ CorrectedEta()

double DerivationFramework::SkimmingToolHIGG1::CorrectedEta ( const xAOD::Photon * ph ) const

private

Definition at line 429 of file SkimmingToolHIGG1.cxx.

                                                                                    {
 
  double eta1 = ph->caloCluster()->etaBE(1); 
 
  double R_photom_n_front, Z_photom_n_front;
  if (std::abs(eta1) < 1.5) { // barrel
    R_photom_n_front = ReturnRZ_1stSampling_cscopt2(eta1);
    Z_photom_n_front = R_photom_n_front*sinh(eta1);
  } else { // endcap
    Z_photom_n_front = ReturnRZ_1stSampling_cscopt2(eta1);
    R_photom_n_front = Z_photom_n_front/sinh(eta1);
  }
 
  return asinh((Z_photom_n_front - GetDiphotonVertex())/R_photom_n_front);
 
}

◆ ElectronPreselect()

bool DerivationFramework::SkimmingToolHIGG1::ElectronPreselect ( const xAOD::Electron * el ) const

private

Definition at line 764 of file SkimmingToolHIGG1.cxx.

                                                                                         {
 
  if (!el) return false;
 
  bool val(false);
  bool defined(false);
 
  static const SG::ConstAccessor<char> DFCommonElectronsLooseAcc("DFCommonElectronsLoose");
  if(DFCommonElectronsLooseAcc.isAvailable(*el)){
    defined = true;
    val = val || static_cast<bool>(DFCommonElectronsLooseAcc(*el));
  }else{
    defined = el->passSelection(val, "Loose");
  } 
 
  static const SG::ConstAccessor<char> DFCommonElectronsLHLooseAcc("DFCommonElectronsLHLoose");
  if(DFCommonElectronsLHLooseAcc.isAvailable(*el)){
    defined = true;
    val = val || static_cast<bool>(DFCommonElectronsLHLooseAcc(*el));
  }
 
  if(!defined || !val) return false;
 
  double eta = std::abs(el->eta());
  double pt = el->pt();
 
  if (eta > m_maxEta) return false;
  if (m_removeCrack && 1.37 <= eta && eta <= 1.52) return false;
  if (pt <= m_minElectronPt) return false;
 
  return true;
 
}

◆ eventPassesFilter()

bool DerivationFramework::SkimmingToolHIGG1::eventPassesFilter ( const EventContext & ctx ) const

overridevirtual

Check that the current event passes this filter.

Definition at line 157 of file SkimmingToolHIGG1.cxx.

{
 
  m_n_tot++;
 
  bool writeEvent(false);
  SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey, ctx);
 
  if (m_reqGRL      && !SubcutGoodRunList() ) return false;
  if (m_reqLArError && !SubcutLArError(*eventInfo)    ) return false;
  if (m_reqTrigger  && !SubcutTrigger()     ) return false;
 
  const auto leadingPhotons = SubcutPreselect();
  if (m_incTwoPhotons && !m_reqPreselection) writeEvent = true;     
 
  // ey, ee, muy events
  if (m_incSingleElectron && SubcutOnePhotonOneElectron() ) writeEvent = true;
  if (m_incDoubleElectron && SubcutTwoElectrons()         ) writeEvent = true;
  if (m_incSingleMuon     && SubcutOnePhotonOneMuon()     ) writeEvent = true;
  
  // eey, mumuy events
  if (m_incMergedElectronPhoton && SubcutOnePhotonMergedElectrons(*eventInfo)) writeEvent = true;
  if (m_incDoubleMuon           && SubcutOnePhotonTwoMuons()       ) writeEvent = true;
  if (m_incDoubleElectronPhoton && SubcutOnePhotonTwoElectrons()   ) writeEvent = true;
  if (m_incHighPtElectronPhoton && SubcutHighPtOnePhotonOneElectron() ) writeEvent = true;
 
  if (m_incMergedElectron && SubcutOneMergedElectron() ) writeEvent = true;
  // There *must* be two photons for the remaining 
  // pieces, but you can still save the event...
  if (m_incTwoPhotons && leadingPhotons) {
    GetDiphotonVertex(); 
    const double mass = CalculateInvariantMass(leadingPhotons.value());
 
    bool passTwoPhotonCuts(true);     
    if (m_reqQuality         && !SubcutQuality(leadingPhotons.value())) passTwoPhotonCuts = false;
    if (m_reqKinematic       && !SubcutKinematic(leadingPhotons.value(), mass)) passTwoPhotonCuts = false;
    if (m_reqIsolation       && !SubcutIsolation()) passTwoPhotonCuts = false;
    if (m_reqInvariantMass   && !SubcutInvariantMass(mass)) passTwoPhotonCuts = false;
    // yy events
    if (passTwoPhotonCuts) writeEvent = true; 
    
  }
   
 
  if (!writeEvent) return false;
  
  m_n_pass++;
  return true;
}

◆ finalize()

StatusCode DerivationFramework::SkimmingToolHIGG1::finalize ( )

overridevirtual

Definition at line 115 of file SkimmingToolHIGG1.cxx.

{
  ATH_MSG_VERBOSE("finalize() ...");
  ATH_MSG_INFO("Processed " << m_n_tot << " events, " << m_n_pass << " events passed filter ");
 
  
  ATH_MSG_INFO("GRL       :: " << m_n_passGRL);
  ATH_MSG_INFO("lar       :: " << m_n_passLArError);
  ATH_MSG_INFO("trig      :: " << m_n_passTrigger);
  ATH_MSG_INFO("----------------------------");
  if(m_incDoubleElectron)
    ATH_MSG_INFO("2e        :: " << m_n_passDoubleElectronPreselect);
  if(m_incSingleElectron)
    ATH_MSG_INFO("1y1e      :: " << m_n_passSingleElectronPreselect);
  if(m_incSingleMuon)
    ATH_MSG_INFO("1y1mu     :: " << m_n_passSingleMuonPreselect);
  if(m_incDoubleMuon)
    ATH_MSG_INFO("1y2mu     :: " << m_n_passSinglePhotonDoubleMuonPreselect);
  if(m_incDoubleElectronPhoton)
    ATH_MSG_INFO("1y2e      :: " << m_n_passSinglePhotonDoubleElectronPreselect);
  if(m_incMergedElectronPhoton)
    ATH_MSG_INFO("1y1eMerge :: " << m_n_passSinglePhotonMergedElectronPreselect);
  if(m_incHighPtElectronPhoton)
    ATH_MSG_INFO("1y1e HiPt :: " << m_n_passHighPtPhotonMergedElectronPreselect);
  if(m_incMergedElectron)
    ATH_MSG_INFO("1eMerge   :: " << m_n_passSingleMergedElectronPreselect);
 
  if(m_incTwoPhotons){
    ATH_MSG_INFO("2y        :: " << m_n_passPreselect);
    ATH_MSG_INFO("----------------------------");
    ATH_MSG_INFO("2y - kin       :: " << m_n_passKinematic);
    ATH_MSG_INFO("2y - qual      :: " << m_n_passQuality);
    ATH_MSG_INFO("2y - iso       :: " << m_n_passIsolation);
    ATH_MSG_INFO("2y - inv       :: " << m_n_passInvariantMass);
  }
  ATH_MSG_INFO("----------------------------");
  ATH_MSG_INFO("passed     :: " << m_n_pass);
  
  return StatusCode::SUCCESS;
}

◆ GetDiphotonVertex()

double DerivationFramework::SkimmingToolHIGG1::GetDiphotonVertex ( ) const

private

Definition at line 413 of file SkimmingToolHIGG1.cxx.

◆ initialize()

StatusCode DerivationFramework::SkimmingToolHIGG1::initialize ( )

overridevirtual

Definition at line 81 of file SkimmingToolHIGG1.cxx.

{
  ATH_MSG_VERBOSE("INITIALIZING HSG1 SELECTOR TOOL");
  // trigger decision tool
  if(m_trigDecisionTool.retrieve(DisableTool{!m_reqTrigger}).isFailure()) {
    ATH_MSG_FATAL("Failed to retrieve tool: " << m_trigDecisionTool);
    return StatusCode::FAILURE;
  }
  if (m_triggers.empty()) m_triggers.push_back(m_defaultTrigger);
  ATH_MSG_INFO("Retrieved tool: " << m_trigDecisionTool);
  //
  if(m_incMergedElectronPhoton){
    if( m_mergedCutTools.retrieve().isFailure() )
    {
      ATH_MSG_FATAL("Failed to retrieve tool: ElectronPhotonSelectorTools");
      return StatusCode::FAILURE;
    }
  }
 
  ATH_CHECK( m_eventInfoKey.initialize() );
 
  ATH_CHECK( m_photonKey.initialize() );
 
  ATH_CHECK( m_electronKey.initialize() );
 
  ATH_CHECK( m_muonKey.initialize() );
  
  return StatusCode::SUCCESS;
}

◆ MergedElectronPreselect()

bool DerivationFramework::SkimmingToolHIGG1::MergedElectronPreselect ( const xAOD::Electron * el ) const

private

Definition at line 798 of file SkimmingToolHIGG1.cxx.

                                                                                               {
 
  if (!el) return false;
 
  double eta = std::abs(el->eta());
  double pt = el->pt();
 
  if (eta > m_maxEta) return false;
  if (m_removeCrack && 1.37 <= eta && eta <= 1.52) return false;
  if (pt <= m_minMergedElectronPt) return false;
 
  return m_mergedCutTools->accept(el) || ElectronPreselect(el);
 
}

◆ MuonPreselect()

bool DerivationFramework::SkimmingToolHIGG1::MuonPreselect ( const xAOD::Muon * mu ) const

private

Definition at line 813 of file SkimmingToolHIGG1.cxx.

                                                                                 {
 
  if (!mu) return false;
 
  static const SG::ConstAccessor<char> DFCommonGoodMuonAcc("DFCommonGoodMuon");
  if(DFCommonGoodMuonAcc.isAvailable(*mu))
    if( !static_cast<bool>(DFCommonGoodMuonAcc(*mu)) )
      return false;
  
  static const SG::ConstAccessor<char> DFCommonMuonsPreselectionAcc("DFCommonMuonsPreselection");
  if(DFCommonMuonsPreselectionAcc.isAvailable(*mu))
    if( !static_cast<bool>(DFCommonMuonsPreselectionAcc(*mu)) )
      return false;
 
  double eta = std::abs(mu->eta());
  double pt = mu->pt();
 
  if (eta > m_maxMuonEta) return false;
  if (pt <= m_minMuonPt) return false;
 
  return true;
 
}

◆ PhotonPreselect()

bool DerivationFramework::SkimmingToolHIGG1::PhotonPreselect ( const xAOD::Photon * ph ) const

private

Definition at line 293 of file SkimmingToolHIGG1.cxx.

                                                                                     {
 
  if (!ph) return false;
 
  if (!ph->isGoodOQ(34214)) return false;
 
  bool val(false);
  bool defined(false);
 
  static const SG::ConstAccessor<char> DFCommonPhotonsIsEMLooseAcc("DFCommonPhotonsIsEMLoose");
  if(DFCommonPhotonsIsEMLooseAcc.isAvailable(*ph)){
    defined = true;
    val = static_cast<bool>(DFCommonPhotonsIsEMLooseAcc(*ph));
  }
  else{
    defined = ph->passSelection(val, "Loose");
  }
  
  if(!defined || !val) return false;
  
 
  // veto topo-seeded clusters 
  // uint16_t author = 0;
  // author = ph->author();  
  // if (author & xAOD::EgammaParameters::AuthorCaloTopo35) return false;
 
  // Check which variable versions are best...
  const xAOD::CaloCluster *caloCluster(ph->caloCluster());
  double eta = std::abs(caloCluster->etaBE(2));
 
  if (eta > m_maxEta)             return false;
  if (m_removeCrack && 
      1.37 <= eta && eta <= 1.52) return false;
  if (caloCluster->e()/cosh(eta) < m_minPhotonPt) return false;
 
  return true;
 
}

◆ ReturnRZ_1stSampling_cscopt2()

double DerivationFramework::SkimmingToolHIGG1::ReturnRZ_1stSampling_cscopt2 ( double eta1 )

staticprivate

Definition at line 447 of file SkimmingToolHIGG1.cxx.

                                                                                     {
 
  float abs_eta1 = std::abs(eta1);
 
  double radius = -99999;
  if (abs_eta1 < 0.8) {
    radius = 1558.859292 - 4.990838  * abs_eta1 - 21.144279 * abs_eta1 * abs_eta1;
  } else if (abs_eta1 < 1.5) {
    radius = 1522.775373 + 27.970192 * abs_eta1 - 21.104108 * abs_eta1 * abs_eta1;
  } else { //endcap
    radius = 3790.671754;
    if (eta1 < 0.) radius = -radius;
  }
 
  return radius;
 
}

◆ SubcutGoodRunList()

bool DerivationFramework::SkimmingToolHIGG1::SubcutGoodRunList ( ) const

private

Definition at line 207 of file SkimmingToolHIGG1.cxx.

                                                                   {
 
  // Placeholder
  m_n_passGRL++;
  return true;
}

◆ SubcutHighPtOnePhotonOneElectron()

bool DerivationFramework::SkimmingToolHIGG1::SubcutHighPtOnePhotonOneElectron ( ) const

private

Definition at line 723 of file SkimmingToolHIGG1.cxx.

{
 
 
  SG::ReadHandle<xAOD::PhotonContainer> photons (m_photonKey);
 
  xAOD::PhotonContainer::const_iterator ph_itr(photons->begin());
  xAOD::PhotonContainer::const_iterator ph_end(photons->end());
 
  SG::ReadHandle<xAOD::ElectronContainer> electrons (m_electronKey);
 
  xAOD::ElectronContainer::const_iterator el_itr(electrons->begin());
  xAOD::ElectronContainer::const_iterator el_end(electrons->end());
 
  int nPhoton    = 0;
  int nElectron  = 0;
 
  for( ; ph_itr != ph_end; ++ph_itr){
    if(PhotonPreselect(*ph_itr) && (*ph_itr)->pt() > 500*CLHEP::GeV){
      ++nPhoton;
    }
  }
 
  for( ; el_itr != el_end; ++el_itr){
    if( std::abs((*el_itr)->eta()) <= m_maxEta  && (*el_itr)->pt() > m_minElectronPt){
      ++nElectron; 
    }
  }
 
  if(nPhoton >= 1 &&  nElectron >= 1 ){
    ATH_MSG_DEBUG("Event selected with " << nPhoton << " high pt photons and " << nElectron << " merged electron");
    ++m_n_passHighPtPhotonMergedElectronPreselect;
    return true;
  } else {
    return false;
  }
 
}

◆ SubcutInvariantMass()

bool DerivationFramework::SkimmingToolHIGG1::SubcutInvariantMass ( double invariantMass ) const

private

Definition at line 373 of file SkimmingToolHIGG1.cxx.

                                                                                         {
 
  bool passInvariantMass =  (!m_minInvariantMass ||
                             m_minInvariantMass < invariantMass);
 
  passInvariantMass &= (!m_maxInvariantMass ||
                        invariantMass < m_maxInvariantMass);
 
  if (passInvariantMass) m_n_passInvariantMass++;
  return passInvariantMass;
 
}

◆ SubcutIsolation()

bool DerivationFramework::SkimmingToolHIGG1::SubcutIsolation ( ) const

private

Definition at line 365 of file SkimmingToolHIGG1.cxx.

                                                                 {
 
  // PLACEHOLDER!!!
  m_n_passIsolation++;
  return true;
}

◆ SubcutKinematic()

bool DerivationFramework::SkimmingToolHIGG1::SubcutKinematic	(	const LeadingPhotons_t &	leadingPhotons,
		double	invariantMass ) const

private

Definition at line 332 of file SkimmingToolHIGG1.cxx.

                                                                                                                             {
 
  bool passKinematic;
  if (m_relativePtCuts) {
    passKinematic =  (leadingPhotons[0]->pt() > invariantMass * m_leadingPhotonPt);
    passKinematic &= (leadingPhotons[1]->pt() > invariantMass * m_subleadingPhotonPt);
  } else {
    passKinematic =  (leadingPhotons[0]->pt() > m_leadingPhotonPt);
    passKinematic &= (leadingPhotons[1]->pt() > m_subleadingPhotonPt);
  }
 
  if (passKinematic) m_n_passKinematic++;
  return passKinematic;
 
}

◆ SubcutLArError()

bool DerivationFramework::SkimmingToolHIGG1::SubcutLArError ( const xAOD::EventInfo & eventInfo ) const

private

Definition at line 215 of file SkimmingToolHIGG1.cxx.

                                                                                              {
 
  if (eventInfo.errorState(xAOD::EventInfo::LAr) != xAOD::EventInfo::Error) {
    m_n_passLArError++;
    return true;
  }
  else return false;
}

◆ SubcutOneMergedElectron()

bool DerivationFramework::SkimmingToolHIGG1::SubcutOneMergedElectron ( ) const

private

Definition at line 495 of file SkimmingToolHIGG1.cxx.

                                                                         {
  
  SG::ReadHandle<xAOD::ElectronContainer> electrons (m_electronKey);
 
  int nEle(0);
  for(const auto *const el: *electrons){
    if( el->pt() < m_minElectronPt)
      continue;
    //Count the number of Si tracks matching the electron
    int nSiTrack(0);
    int z0_1 = 1;
    for( unsigned int trk_i(0); trk_i < el->nTrackParticles(); ++trk_i){
      const auto *ele_tp =  el->trackParticle(trk_i);
      if(!ele_tp){
        continue;
      }
      uint8_t nPixHits(0), nPixDead(0), nSCTHits(0), nSCTDead(0);
      bool allFound = true;
      allFound = allFound && ele_tp->summaryValue(nPixHits, xAOD::numberOfPixelHits);
      allFound = allFound && ele_tp->summaryValue(nPixDead, xAOD::numberOfPixelDeadSensors);
      allFound = allFound && ele_tp->summaryValue(nSCTHits, xAOD::numberOfSCTHits);
      allFound = allFound && ele_tp->summaryValue(nSCTDead, xAOD::numberOfSCTDeadSensors);
 
      // Require that the track be a reasonble silicon track
      int nSiHitsPlusDeadSensors = nPixHits + nPixDead + nSCTHits + nSCTDead;
      if(nSiHitsPlusDeadSensors >= 7)
      {
        //Ensure that the tracks come from roughly the same region of the detector
        if(nSiTrack == 0)
          z0_1 = ele_tp->z0();
        else if( std::abs(z0_1 - ele_tp->z0()) > 10 )
          continue;
        ++nSiTrack;
      }
    }
    //If 2 or more the electron is selected
    if(nSiTrack>1)
      ++nEle;
  }
  if(nEle>0){
    ++m_n_passSingleMergedElectronPreselect;
    return true;
  }
  return false;
}

◆ SubcutOnePhotonMergedElectrons()

bool DerivationFramework::SkimmingToolHIGG1::SubcutOnePhotonMergedElectrons ( const xAOD::EventInfo & eventInfo ) const

private

Definition at line 667 of file SkimmingToolHIGG1.cxx.

{
 
 
  bool passTrigger=false;
  if(!m_mergedtriggers.empty()) {
    for (unsigned int i = 0; i < m_mergedtriggers.size(); i++) {
      ATH_MSG_DEBUG("TRIGGER = " << m_mergedtriggers.at(i));
      if(m_trigDecisionTool->isPassed(m_mergedtriggers.at(i)))
        passTrigger = true;
    }
  } else {
    if(!eventInfo.eventType(xAOD::EventInfo::IS_SIMULATION))
      ATH_MSG_WARNING("Selecting Merged electrons but no Merged Triggers Selected ! -- was that intentional?");
    passTrigger =  true;
  }
  if(!passTrigger)
    return false;
   
 
  SG::ReadHandle<xAOD::PhotonContainer> photons (m_photonKey);
 
  SG::ReadHandle<xAOD::ElectronContainer> electrons (m_electronKey);
 
  bool passSelection = false;
 
  for(const auto *el : *electrons){
    if(MergedElectronPreselect(el)){
      for(const auto *ph: *photons){
        if(PhotonPreselect(ph)){
          passSelection = true;
          auto eph = ph->p4() + el->p4();
          if(eph.M() >  90 * CLHEP::GeV)  
          {  
            break;
          }
        }
      }
    }
    if(passSelection)
    { 
      break;
    }
  }
 
  if(passSelection){
    ATH_MSG_DEBUG("Event selected with a photons and a merged electron");
    ++m_n_passSinglePhotonMergedElectronPreselect;
    return true;
  } else {
    return false;
  }
 
}

◆ SubcutOnePhotonOneElectron()

bool DerivationFramework::SkimmingToolHIGG1::SubcutOnePhotonOneElectron ( ) const

private

Definition at line 465 of file SkimmingToolHIGG1.cxx.

                                                                            {
 
  SG::ReadHandle<xAOD::PhotonContainer> photons (m_photonKey);
 
  xAOD::PhotonContainer::const_iterator ph_itr(photons->begin());
  xAOD::PhotonContainer::const_iterator ph_end(photons->end());
 
  SG::ReadHandle<xAOD::ElectronContainer> electrons (m_electronKey);
 
  xAOD::ElectronContainer::const_iterator el_itr(electrons->begin());
  xAOD::ElectronContainer::const_iterator el_end(electrons->end());
 
  bool passSingleElectronPreselect = false;
 
  for( ; ph_itr != ph_end; ++ph_itr){
    if(PhotonPreselect(*ph_itr)){
      for( ; el_itr != el_end; ++el_itr){
        if(ElectronPreselect(*el_itr)){
          passSingleElectronPreselect = true;
        }
      }
    }
  }
 
 
  if(passSingleElectronPreselect) m_n_passSingleElectronPreselect++;
  return passSingleElectronPreselect;
}

◆ SubcutOnePhotonOneMuon()

bool DerivationFramework::SkimmingToolHIGG1::SubcutOnePhotonOneMuon ( ) const

private

Definition at line 563 of file SkimmingToolHIGG1.cxx.

                                                                        {
 
  SG::ReadHandle<xAOD::PhotonContainer> photons (m_photonKey);
 
  xAOD::PhotonContainer::const_iterator ph_itr(photons->begin());
  xAOD::PhotonContainer::const_iterator ph_end(photons->end());
 
  SG::ReadHandle<xAOD::MuonContainer> muons (m_muonKey);
 
  xAOD::MuonContainer::const_iterator mu_itr(muons->begin());
  xAOD::MuonContainer::const_iterator mu_end(muons->end());
 
  bool passSingleMuonPreselect = false;
 
  for( ; ph_itr != ph_end; ++ph_itr){
    if(PhotonPreselect(*ph_itr)){
      for( ; mu_itr != mu_end; ++mu_itr){
        if(MuonPreselect(*mu_itr)){
          passSingleMuonPreselect = true;
        }
      }
    }
  }
 
 
  if(passSingleMuonPreselect) m_n_passSingleMuonPreselect++;
  return passSingleMuonPreselect;
}

◆ SubcutOnePhotonTwoElectrons()

bool DerivationFramework::SkimmingToolHIGG1::SubcutOnePhotonTwoElectrons ( ) const

private

Definition at line 630 of file SkimmingToolHIGG1.cxx.

{
  SG::ReadHandle<xAOD::PhotonContainer> photons (m_photonKey);
 
  xAOD::PhotonContainer::const_iterator ph_itr(photons->begin());
  xAOD::PhotonContainer::const_iterator ph_end(photons->end());
 
  SG::ReadHandle<xAOD::ElectronContainer> electrons (m_electronKey);
 
  xAOD::ElectronContainer::const_iterator el_itr(electrons->begin());
  xAOD::ElectronContainer::const_iterator el_end(electrons->end());
 
  int nPhoton    = 0;
  int nElectron  = 0;
 
  for( ; ph_itr != ph_end; ++ph_itr){
    if(PhotonPreselect(*ph_itr)){
      ++nPhoton;
    }
  }
 
  for( ; el_itr != el_end; ++el_itr){
    if(ElectronPreselect(*el_itr)){
      ++nElectron; 
    }
  }
 
  if(nPhoton >= 1 &&  nElectron >= 2){
    ATH_MSG_DEBUG("Event selected with " << nPhoton << " photons and " << nElectron << " electrons");
    ++m_n_passSinglePhotonDoubleElectronPreselect;
    return true;
  } else {
    return false;
  }
 
}

◆ SubcutOnePhotonTwoMuons()

bool DerivationFramework::SkimmingToolHIGG1::SubcutOnePhotonTwoMuons ( ) const

private

Definition at line 592 of file SkimmingToolHIGG1.cxx.

{
  SG::ReadHandle<xAOD::PhotonContainer> photons (m_photonKey);
 
  xAOD::PhotonContainer::const_iterator ph_itr(photons->begin());
  xAOD::PhotonContainer::const_iterator ph_end(photons->end());
 
  SG::ReadHandle<xAOD::MuonContainer> muons (m_muonKey);
 
  xAOD::MuonContainer::const_iterator mu_itr(muons->begin());
  xAOD::MuonContainer::const_iterator mu_end(muons->end());
 
  int nPhoton = 0;
  int nMuon   = 0;
 
  for( ; ph_itr != ph_end; ++ph_itr){
    if(PhotonPreselect(*ph_itr)){
      ++nPhoton;
    }
  }
 
  for( ; mu_itr != mu_end; ++mu_itr){
    if(MuonPreselect(*mu_itr)){
      ++nMuon;
    }
  }
 
 
  if(nPhoton >= 1 &&  nMuon >= 2){
    ATH_MSG_DEBUG("Event selected with " << nPhoton << " photons and " << nMuon << " muons");
    m_n_passSinglePhotonDoubleMuonPreselect++;
    return true;
  } else {
    return false;
  }
}

◆ SubcutPreselect()

std::optional< DerivationFramework::SkimmingToolHIGG1::LeadingPhotons_t > DerivationFramework::SkimmingToolHIGG1::SubcutPreselect ( ) const

private

Definition at line 245 of file SkimmingToolHIGG1.cxx.

                                                            {
 
  SG::ReadHandle<xAOD::PhotonContainer> photons (m_photonKey);
 
  xAOD::PhotonContainer::const_iterator ph_itr(photons->begin());
  xAOD::PhotonContainer::const_iterator ph_end(photons->end());
 
  int ph_pos_lead = -1;
  int ph_pos_subl = -1;
  int ph_pt_lead = 0;
  int ph_pt_subl = 0;
 
  for(int i = 0; ph_itr != ph_end; ++ph_itr, ++i) {
 
    if (PhotonPreselect(*ph_itr)) {
 
      if ((*ph_itr)->pt() > ph_pt_lead) {
 
        ph_pos_subl = ph_pos_lead; ph_pos_lead = i;
        ph_pt_subl = ph_pt_lead;
        ph_pt_lead = (*ph_itr)->pt();
 
      } else if ((*ph_itr)->pt() > ph_pt_subl) {
        ph_pos_subl = i;
        ph_pt_subl = (*ph_itr)->pt();
      }
    }
  }
 
  // save this for the derivation.
  //std::vector<int> *leadingV = new std::vector<int>();
  //leadingV->push_back(m_ph_pos_lead);
  //leadingV->push_back(m_ph_pos_subl);
  //if (!evtStore()->contains<std::vector<int> >("leadingV")) CHECK(evtStore()->record(leadingV, "leadingV"));
 
  // save this for this code.
  if (ph_pos_subl != -1) {
    const xAOD::Photon* ph_lead = *(photons->begin() + ph_pos_lead);
    const xAOD::Photon* ph_subl = *(photons->begin() + ph_pos_subl);
    m_n_passPreselect++;
    
    return LeadingPhotons_t{ph_lead,ph_subl};
  }
 
  return {};
}

◆ SubcutQuality()

bool DerivationFramework::SkimmingToolHIGG1::SubcutQuality ( const LeadingPhotons_t & leadingPhotons ) const

private

Definition at line 348 of file SkimmingToolHIGG1.cxx.

                                                                                                     {
 
  bool val(0);
  bool passQuality = false;
  leadingPhotons[0]->passSelection(val, "Tight");
  const int ph_tight_lead = val;
 
  leadingPhotons[1]->passSelection(val, "Tight");
  const int ph_tight_subl = val;
 
  passQuality = (ph_tight_lead && ph_tight_subl);
 
  if (passQuality) m_n_passQuality++;
  return passQuality;
 
}

◆ SubcutTrigger()

bool DerivationFramework::SkimmingToolHIGG1::SubcutTrigger ( ) const

private

Definition at line 225 of file SkimmingToolHIGG1.cxx.

                                                               {
 
  //just for counting purposes
  bool passTrigger = !m_reqTrigger;
  
  if(m_triggers.empty()) passTrigger = true;
 
  for (unsigned int i = 0; i < m_triggers.size(); i++) {
    ATH_MSG_DEBUG("TRIGGER = " << m_triggers.at(i));
    if(m_trigDecisionTool->isPassed(m_triggers.at(i)))
      passTrigger = true;
  }
  
  if (passTrigger) m_n_passTrigger++;
  return passTrigger;
 
}

◆ SubcutTwoElectrons()

bool DerivationFramework::SkimmingToolHIGG1::SubcutTwoElectrons ( ) const

private

Definition at line 541 of file SkimmingToolHIGG1.cxx.

                                                                    {
 
  SG::ReadHandle<xAOD::ElectronContainer> electrons (m_electronKey);
 
  xAOD::ElectronContainer::const_iterator el_itr(electrons->begin());
  xAOD::ElectronContainer::const_iterator el_end(electrons->end());
 
  int nEle(0);
  bool passDoubleElectronPreselect = false;
  
  for( ; el_itr != el_end; ++el_itr){
    if(ElectronPreselect(*el_itr))
      nEle++;
  }
  
  if(nEle >=2) passDoubleElectronPreselect = true;
  
  if(passDoubleElectronPreselect) m_n_passDoubleElectronPreselect++;
  return passDoubleElectronPreselect;
}

Member Data Documentation

◆ m_defaultTrigger

std::string DerivationFramework::SkimmingToolHIGG1::m_defaultTrigger

private

Definition at line 97 of file SkimmingToolHIGG1.h.

◆ m_electronKey

SG::ReadHandleKey<xAOD::ElectronContainer > DerivationFramework::SkimmingToolHIGG1::m_electronKey { this, "ElectronKey", "Electrons", "" }

private

Definition at line 194 of file SkimmingToolHIGG1.h.

194{ this, "ElectronKey", "Electrons", "" };

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> DerivationFramework::SkimmingToolHIGG1::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }

private

Definition at line 188 of file SkimmingToolHIGG1.h.

188{ this, "EventInfoKey", "EventInfo", "" };

◆ m_goodRunList

std::string DerivationFramework::SkimmingToolHIGG1::m_goodRunList

private

Definition at line 95 of file SkimmingToolHIGG1.h.

◆ m_incDoubleElectron

bool DerivationFramework::SkimmingToolHIGG1::m_incDoubleElectron

private

Definition at line 80 of file SkimmingToolHIGG1.h.

◆ m_incDoubleElectronPhoton

bool DerivationFramework::SkimmingToolHIGG1::m_incDoubleElectronPhoton

private

Definition at line 83 of file SkimmingToolHIGG1.h.

◆ m_incDoubleMuon

bool DerivationFramework::SkimmingToolHIGG1::m_incDoubleMuon

private

Definition at line 82 of file SkimmingToolHIGG1.h.

◆ m_incHighPtElectronPhoton

bool DerivationFramework::SkimmingToolHIGG1::m_incHighPtElectronPhoton

private

Definition at line 85 of file SkimmingToolHIGG1.h.

◆ m_incMergedElectron

bool DerivationFramework::SkimmingToolHIGG1::m_incMergedElectron

private

Definition at line 78 of file SkimmingToolHIGG1.h.

◆ m_incMergedElectronPhoton

bool DerivationFramework::SkimmingToolHIGG1::m_incMergedElectronPhoton

private

Definition at line 84 of file SkimmingToolHIGG1.h.

◆ m_incSingleElectron

bool DerivationFramework::SkimmingToolHIGG1::m_incSingleElectron

private

Definition at line 79 of file SkimmingToolHIGG1.h.

◆ m_incSingleMuon

bool DerivationFramework::SkimmingToolHIGG1::m_incSingleMuon

private

Definition at line 81 of file SkimmingToolHIGG1.h.

◆ m_incTwoPhotons

bool DerivationFramework::SkimmingToolHIGG1::m_incTwoPhotons

private

Definition at line 86 of file SkimmingToolHIGG1.h.

◆ m_leadingPhotonPt

double DerivationFramework::SkimmingToolHIGG1::m_leadingPhotonPt

private

Definition at line 106 of file SkimmingToolHIGG1.h.

◆ m_maxEta

double DerivationFramework::SkimmingToolHIGG1::m_maxEta

private

Definition at line 103 of file SkimmingToolHIGG1.h.

◆ m_maxInvariantMass

double DerivationFramework::SkimmingToolHIGG1::m_maxInvariantMass

private

Definition at line 110 of file SkimmingToolHIGG1.h.

◆ m_maxMuonEta

double DerivationFramework::SkimmingToolHIGG1::m_maxMuonEta

private

Definition at line 115 of file SkimmingToolHIGG1.h.

◆ m_mergedCutTools

ToolHandle<IAsgElectronIsEMSelector> DerivationFramework::SkimmingToolHIGG1::m_mergedCutTools

private

Definition at line 185 of file SkimmingToolHIGG1.h.

◆ m_mergedtriggers

std::vector<std::string> DerivationFramework::SkimmingToolHIGG1::m_mergedtriggers

private

Definition at line 99 of file SkimmingToolHIGG1.h.

◆ m_minElectronPt

double DerivationFramework::SkimmingToolHIGG1::m_minElectronPt

private

Definition at line 112 of file SkimmingToolHIGG1.h.

◆ m_minInvariantMass

double DerivationFramework::SkimmingToolHIGG1::m_minInvariantMass

private

Definition at line 109 of file SkimmingToolHIGG1.h.

◆ m_minMergedElectronPt

double DerivationFramework::SkimmingToolHIGG1::m_minMergedElectronPt

private

Definition at line 113 of file SkimmingToolHIGG1.h.

◆ m_minMuonPt

double DerivationFramework::SkimmingToolHIGG1::m_minMuonPt

private

Definition at line 114 of file SkimmingToolHIGG1.h.

◆ m_minPhotonPt

double DerivationFramework::SkimmingToolHIGG1::m_minPhotonPt

private

Definition at line 101 of file SkimmingToolHIGG1.h.

◆ m_muonKey

SG::ReadHandleKey<xAOD::MuonContainer > DerivationFramework::SkimmingToolHIGG1::m_muonKey { this, "MuonKey", "Muons", "" }

private

Definition at line 197 of file SkimmingToolHIGG1.h.

197{ this, "MuonKey", "Muons", "" };

◆ m_n_pass

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_pass {0}

mutableprivate

Definition at line 174 of file SkimmingToolHIGG1.h.

174{0};

◆ m_n_passDoubleElectronPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passDoubleElectronPreselect {0}

mutableprivate

Definition at line 163 of file SkimmingToolHIGG1.h.

163{0};

◆ m_n_passGRL

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passGRL {0}

mutableprivate

Definition at line 158 of file SkimmingToolHIGG1.h.

158{0};

◆ m_n_passHighPtPhotonMergedElectronPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passHighPtPhotonMergedElectronPreselect {0}

mutableprivate

Definition at line 168 of file SkimmingToolHIGG1.h.

168{0};

◆ m_n_passInvariantMass

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passInvariantMass {0}

mutableprivate

Definition at line 173 of file SkimmingToolHIGG1.h.

173{0};

◆ m_n_passIsolation

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passIsolation {0}

mutableprivate

Definition at line 172 of file SkimmingToolHIGG1.h.

172{0};

◆ m_n_passKinematic

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passKinematic {0}

mutableprivate

Definition at line 170 of file SkimmingToolHIGG1.h.

170{0};

◆ m_n_passLArError

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passLArError {0}

mutableprivate

Definition at line 159 of file SkimmingToolHIGG1.h.

159{0};

◆ m_n_passPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passPreselect {0}

mutableprivate

Definition at line 161 of file SkimmingToolHIGG1.h.

161{0};

◆ m_n_passQuality

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passQuality {0}

mutableprivate

Definition at line 171 of file SkimmingToolHIGG1.h.

171{0};

◆ m_n_passSingleElectronPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passSingleElectronPreselect {0}

mutableprivate

Definition at line 162 of file SkimmingToolHIGG1.h.

162{0};

◆ m_n_passSingleMergedElectronPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passSingleMergedElectronPreselect {0}

mutableprivate

Definition at line 169 of file SkimmingToolHIGG1.h.

169{0};

◆ m_n_passSingleMuonPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passSingleMuonPreselect {0}

mutableprivate

Definition at line 164 of file SkimmingToolHIGG1.h.

164{0};

◆ m_n_passSinglePhotonDoubleElectronPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passSinglePhotonDoubleElectronPreselect {0}

mutableprivate

Definition at line 166 of file SkimmingToolHIGG1.h.

166{0};

◆ m_n_passSinglePhotonDoubleMuonPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passSinglePhotonDoubleMuonPreselect {0}

mutableprivate

Definition at line 165 of file SkimmingToolHIGG1.h.

165{0};

◆ m_n_passSinglePhotonMergedElectronPreselect

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passSinglePhotonMergedElectronPreselect {0}

mutableprivate

Definition at line 167 of file SkimmingToolHIGG1.h.

167{0};

◆ m_n_passTrigger

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_passTrigger {0}

mutableprivate

Definition at line 160 of file SkimmingToolHIGG1.h.

160{0};

◆ m_n_tot

std::atomic<unsigned int> DerivationFramework::SkimmingToolHIGG1::m_n_tot {0}

mutableprivate

Definition at line 157 of file SkimmingToolHIGG1.h.

157{0};

◆ m_photonKey

SG::ReadHandleKey<xAOD::PhotonContainer > DerivationFramework::SkimmingToolHIGG1::m_photonKey { this, "PhotonKey", "Photons", "" }

private

Definition at line 191 of file SkimmingToolHIGG1.h.

191{ this, "PhotonKey", "Photons", "" };

◆ m_relativePtCuts

bool DerivationFramework::SkimmingToolHIGG1::m_relativePtCuts

private

Definition at line 105 of file SkimmingToolHIGG1.h.

◆ m_removeCrack

bool DerivationFramework::SkimmingToolHIGG1::m_removeCrack

private

Definition at line 102 of file SkimmingToolHIGG1.h.

◆ m_reqGRL

bool DerivationFramework::SkimmingToolHIGG1::m_reqGRL

private

Definition at line 74 of file SkimmingToolHIGG1.h.

◆ m_reqInvariantMass

bool DerivationFramework::SkimmingToolHIGG1::m_reqInvariantMass

private

Definition at line 90 of file SkimmingToolHIGG1.h.

◆ m_reqIsolation

bool DerivationFramework::SkimmingToolHIGG1::m_reqIsolation

private

Definition at line 89 of file SkimmingToolHIGG1.h.

◆ m_reqKinematic

bool DerivationFramework::SkimmingToolHIGG1::m_reqKinematic

private

Definition at line 87 of file SkimmingToolHIGG1.h.

◆ m_reqLArError

bool DerivationFramework::SkimmingToolHIGG1::m_reqLArError

private

Definition at line 75 of file SkimmingToolHIGG1.h.

◆ m_reqPreselection

bool DerivationFramework::SkimmingToolHIGG1::m_reqPreselection

private

Definition at line 77 of file SkimmingToolHIGG1.h.

◆ m_reqQuality

bool DerivationFramework::SkimmingToolHIGG1::m_reqQuality

private

Definition at line 88 of file SkimmingToolHIGG1.h.

◆ m_reqTrigger

bool DerivationFramework::SkimmingToolHIGG1::m_reqTrigger

private

Definition at line 76 of file SkimmingToolHIGG1.h.

◆ m_subleadingPhotonPt

double DerivationFramework::SkimmingToolHIGG1::m_subleadingPhotonPt

private

Definition at line 107 of file SkimmingToolHIGG1.h.

◆ m_trigDecisionTool

ToolHandle<Trig::TrigDecisionTool> DerivationFramework::SkimmingToolHIGG1::m_trigDecisionTool

private

Definition at line 69 of file SkimmingToolHIGG1.h.

◆ m_triggers

std::vector<std::string> DerivationFramework::SkimmingToolHIGG1::m_triggers

private

Definition at line 98 of file SkimmingToolHIGG1.h.

◆ s_MZ

const double DerivationFramework::SkimmingToolHIGG1::s_MZ = 91187.6*CLHEP::MeV

staticprivate

Definition at line 180 of file SkimmingToolHIGG1.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ LeadingPhotons_t

Constructor & Destructor Documentation

◆ SkimmingToolHIGG1()

◆ ~SkimmingToolHIGG1()

Member Function Documentation

◆ CalculateInvariantMass()

◆ CorrectedEnergy()

◆ CorrectedEta()

◆ ElectronPreselect()

◆ eventPassesFilter()

◆ finalize()

◆ GetDiphotonVertex()

◆ initialize()

◆ MergedElectronPreselect()

◆ MuonPreselect()

◆ PhotonPreselect()

◆ ReturnRZ_1stSampling_cscopt2()

◆ SubcutGoodRunList()

◆ SubcutHighPtOnePhotonOneElectron()

◆ SubcutInvariantMass()

◆ SubcutIsolation()

◆ SubcutKinematic()

◆ SubcutLArError()

◆ SubcutOneMergedElectron()

◆ SubcutOnePhotonMergedElectrons()

◆ SubcutOnePhotonOneElectron()

◆ SubcutOnePhotonOneMuon()

◆ SubcutOnePhotonTwoElectrons()

◆ SubcutOnePhotonTwoMuons()

◆ SubcutPreselect()

◆ SubcutQuality()

◆ SubcutTrigger()

◆ SubcutTwoElectrons()

Member Data Documentation

◆ m_defaultTrigger

◆ m_electronKey

◆ m_eventInfoKey

◆ m_goodRunList

◆ m_incDoubleElectron

◆ m_incDoubleElectronPhoton

◆ m_incDoubleMuon

◆ m_incHighPtElectronPhoton

◆ m_incMergedElectron

◆ m_incMergedElectronPhoton

◆ m_incSingleElectron

◆ m_incSingleMuon

◆ m_incTwoPhotons

◆ m_leadingPhotonPt

◆ m_maxEta

◆ m_maxInvariantMass

◆ m_maxMuonEta

◆ m_mergedCutTools

◆ m_mergedtriggers

◆ m_minElectronPt

◆ m_minInvariantMass

◆ m_minMergedElectronPt

◆ m_minMuonPt

◆ m_minPhotonPt

◆ m_muonKey

◆ m_n_pass

◆ m_n_passDoubleElectronPreselect

◆ m_n_passGRL

◆ m_n_passHighPtPhotonMergedElectronPreselect

◆ m_n_passInvariantMass

◆ m_n_passIsolation

◆ m_n_passKinematic

◆ m_n_passLArError

◆ m_n_passPreselect

◆ m_n_passQuality

◆ m_n_passSingleElectronPreselect

◆ m_n_passSingleMergedElectronPreselect

◆ m_n_passSingleMuonPreselect