#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 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 387 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 421 of file SkimmingToolHIGG1.cxx.

                                                                                 {
 
  return ph->e();
 
}

◆ CorrectedEta()

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

private

Definition at line 430 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 765 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

overridevirtual

Check that the current event passes this filter.

Definition at line 157 of file SkimmingToolHIGG1.cxx.

{
 
  m_n_tot++;
 
  bool writeEvent(false);
  const EventContext& ctx = Gaudi::Hive::currentContext();
  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 414 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 799 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 814 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 294 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 448 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 208 of file SkimmingToolHIGG1.cxx.

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

◆ SubcutHighPtOnePhotonOneElectron()

bool DerivationFramework::SkimmingToolHIGG1::SubcutHighPtOnePhotonOneElectron ( ) const

private

Definition at line 724 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 374 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 366 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 333 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 216 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 496 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 668 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 466 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 564 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 631 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 593 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 246 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 349 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 226 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 542 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