VGammaORTool Class Reference

This tool can be used to identify the overlap of a V+jets and V+gamma sample or in fact between most V^n+gamma^m and V^n+gamma^(m-1) samples (e.g. More...

#include <VGammaORTool.h>

Inheritance diagram for VGammaORTool:

Collaboration diagram for VGammaORTool:

Public Member Functions
	VGammaORTool (const std::string &name)
virtual	~VGammaORTool () override
virtual StatusCode	inOverlap (bool &result, const std::vector< TLorentzVector > *leptons=0, const std::vector< TLorentzVector > *photons=0, const std::vector< int > *lepton_origins=0, const std::vector< int > *photon_origins=0) const override
	Determine whether current event is in overlap region (set via reference). More...
virtual StatusCode	photonPtsOutsideDr (std::vector< float > &result, const std::vector< TLorentzVector > *leptons=0, const std::vector< TLorentzVector > *photons=0, const std::vector< int > *lepton_origins=0, const std::vector< int > *photon_origins=0) const override
	Determine the pTs of photons outside the dR cut that is configured in tool initialization (dR_lepton_photon_cut). More...
virtual StatusCode	photonPtsOutsideDrs (std::map< float, std::vector< float > > &result, const std::vector< TLorentzVector > *leptons=0, const std::vector< TLorentzVector > *photons=0, const std::vector< int > *lepton_origins=0, const std::vector< int > *photon_origins=0) const override
	Determine the pTs of photons outside of several dR cuts that are configured in tool initialization (dR_lepton_photon_cuts). More...
virtual bool	frixioneIsolated (const xAOD::TruthParticle &photon, const xAOD::TruthParticleContainer &truthParticles, float dR0, float exponent, float epsilon) const override
	Function determining whether a photon is frixione isolated from truthParticles Parameters as defined in https://arxiv.org/pdf/hep-ph/9801442. More...
std::vector< TLorentzVector >	getPhotonP4s (const xAOD::TruthParticleContainer &truthParticleContainer) const
	Get final state photons from truthParticleContainer A minimum pT cut and isolation is applied according to tool configuration Filter function is applied, only photons from relevant origins are kept. More...
std::vector< TLorentzVector >	getLeptonP4s (const xAOD::TruthParticleContainer &truthParticleContainer) const
	Get final state leptons from truthParticleContainer Filter function is applied, only leptons from relevant origins are kept. More...
virtual StatusCode	initialize ()
	Dummy implementation of the initialisation function. More...
virtual void	print () const
	Print the state of the tool. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	photonPtsOutsideDrs (std::map< float, std::vector< float > > &result, const std::vector< float > &drCuts, const std::vector< TLorentzVector > *leptons=0, const std::vector< TLorentzVector > *photons=0, const std::vector< int > *lepton_origins=0, const std::vector< int > *photon_origins=0) const
StatusCode	setInput (std::vector< TLorentzVector > &leptons_out, std::vector< TLorentzVector > &photons_out, const std::vector< TLorentzVector > *lepton_p4s, const std::vector< TLorentzVector > *photon_p4s, const std::vector< int > *lepton_origins, const std::vector< int > *photon_origins) const
std::vector< TLorentzVector >	filterPhotonOrigins (const std::vector< TLorentzVector > &, const std::vector< int > &) const
std::vector< TLorentzVector >	filterLeptonOrigins (const std::vector< TLorentzVector > &, const std::vector< int > &) const
bool	isFromTau (const xAOD::TruthParticle &lepton, int nRecursions=0) const
bool	checkPhotonPts (const std::vector< float > &photon_pts) const
float	frixioneFunc (float dR, float dR0, float exponent, float epsilon) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
asg::AnaToolHandle< MCTruthClassifier >	m_truthClassifier
int	m_n_leptons
std::vector< int >	m_lepton_pdgIds
std::vector< int >	m_preferred_lepton_origins
std::vector< int >	m_lepton_veto_origins
std::vector< int >	m_veto_photon_origins
std::vector< float >	m_photon_pT_cuts
float	m_dR_lepton_photon_cut
std::vector< float >	m_dR_lepton_photon_cuts
bool	m_use_gamma_iso
float	m_frixione_dR
float	m_frixione_exponent
float	m_frixione_epsilon
std::vector< int >	m_abs_pdgids_excluded_from_iso
float	m_min_considered_photon_pT
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

This tool can be used to identify the overlap of a V+jets and V+gamma sample or in fact between most V^n+gamma^m and V^n+gamma^(m-1) samples (e.g.

V+gammagamma vs V+gamma or VV+gamma vs VV). It can either decide whether an event is in the overlap region for fixed cuts on photons and lepton or be used to extract relevant information from the event so that the overlap removal (OR) can be performed at a later stage with a simple 'if' statement.

The OR functions (inOverlap(result), photonPtsOutsideDr(result), or photonPtsOutsideDrs(result)), set the result via reference and return a status code. Usually the tool will take leptons and photons from the current event but this behavior can be overwritten by explicitly setting leptons and photons as additional arguments to the functions.

Further documented at https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/VGammaORTool

Definition at line 37 of file VGammaORTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

VGammaORTool()

VGammaORTool::VGammaORTool

(

const std::string &

name

)

Definition at line 8 of file VGammaORTool.cxx.

  : asg::AsgTool(name),
    m_truthClassifier("MCTruthClassifier",this) {
 
  declareProperty("n_leptons", m_n_leptons = -2);
  declareProperty("lepton_pdgIds", m_lepton_pdgIds = {11, -11, 13, -13, 15, -15});
  declareProperty("veto_lepton_origins", m_lepton_veto_origins = {3, 5, 6, 7, 8, 9, 23, 24, 25, 26, 27, 28, 29, 30, 31,
                                                                  32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42});
  declareProperty("preferred_lepton_origins", m_preferred_lepton_origins = {1, 2, 4, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21});
 
  declareProperty("veto_photon_origins", m_veto_photon_origins = {9, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 42});
 
  declareProperty("photon_pT_cuts", m_photon_pT_cuts = {});
  declareProperty("dR_lepton_photon_cut", m_dR_lepton_photon_cut = 0.1);
  declareProperty("dR_lepton_photon_cuts", m_dR_lepton_photon_cuts = {0.0, 0.05, 0.075, 0.1, 0.125, 0.15, 0.2});
 
  declareProperty("use_gamma_iso", m_use_gamma_iso = false);
  declareProperty("frixione_dR", m_frixione_dR = 0.1);
  declareProperty("frixione_exponent", m_frixione_exponent = 2);
  declareProperty("frixione_epsilon", m_frixione_epsilon = 0.1);
  declareProperty("abs_pdgids_excluded_from_iso", m_abs_pdgids_excluded_from_iso = {11, 12, 13, 14, 15, 16, 22});
  declareProperty("min_considered_photon_pT", m_min_considered_photon_pT = 3.e3);
 
  for (int origin : m_preferred_lepton_origins) {
    if (std::find(m_lepton_veto_origins.begin(), m_lepton_veto_origins.end(), origin) != m_lepton_veto_origins.end()) {
      ATH_MSG_ERROR(origin << " in both lepton origin and lepton veto origin, this is not correct.");
      break;
    }
  }
  // pT cuts are sorted in descending order
  std::sort(m_photon_pT_cuts.begin(), m_photon_pT_cuts.end(), std::greater<float>());
}

~VGammaORTool()

VGammaORTool::~VGammaORTool ( )

overridevirtual

Definition at line 41 of file VGammaORTool.cxx.

                            {
}

Member Function Documentation

checkPhotonPts()

bool VGammaORTool::checkPhotonPts ( const std::vector< float > &  photon_pts ) const

private

Definition at line 333 of file VGammaORTool.cxx.

                                                                         {
  if(m_photon_pT_cuts.size()==0){
    ATH_MSG_ERROR("photon_pT_cuts needs to be a non-empty list, when inOverlap is called, set as property or in constructor.");
    return false;
  }
  if(m_photon_pT_cuts.size()>photon_pts.size()){
    return false;
  }
  for(uint i=0; i<m_photon_pT_cuts.size();i++){
    if(photon_pts[i]<m_photon_pT_cuts[i]){
      return false;
    }
  }
  return true;
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyArrayType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleKeyType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl, const SG::VarHandleType &    )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

filterLeptonOrigins()

std::vector< TLorentzVector > VGammaORTool::filterLeptonOrigins ( const std::vector< TLorentzVector > &  lepton_candidates, const std::vector< int > &  lepton_origins  ) const

private

Definition at line 202 of file VGammaORTool.cxx.

                                                                                                          {
  // this should only happen if the user gives the wrong input
  if (lepton_candidates.size() != lepton_origins.size()) {
    ATH_MSG_ERROR(
      "VGammaORTool::filterLeptonOrigins" << ": size of lepton candidates (" << lepton_candidates.size() << ") different from number of lepton origins (" << lepton_origins.size() <<
        ").");
  }
  std::vector<TLorentzVector> lepton_p4s;
  std::vector<TLorentzVector> leptons_not_vetoed_p4s;
  // find both good photons and photons that are just not vetoed (lower quality, used as fall back)
  for (uint i = 0; i < lepton_candidates.size(); i++) {
    const TLorentzVector p4 = lepton_candidates[i];
    const int p_origin = lepton_origins[i];
    const bool use = std::find(m_preferred_lepton_origins.begin(), m_preferred_lepton_origins.end(), p_origin) != m_preferred_lepton_origins.end();
    if (use) {
      lepton_p4s.push_back(p4);
      if (m_n_leptons>=0 && int(lepton_p4s.size()) >= m_n_leptons) {
        // as soon as enough leptons are found, return them
        // this is why the order of lepton candidates matters
        // if this tool identifies the leptons, taus will be before mu/el and otherwise leptons are ordered by pT
        // in most cases the origin should unambiguosly identify the lepton anyway
        return lepton_p4s;
      }
    } else {
      bool vetoed =
        std::find(m_lepton_veto_origins.begin(), m_lepton_veto_origins.end(), p_origin) != m_lepton_veto_origins.end();
      if (!vetoed) {
        leptons_not_vetoed_p4s.push_back(p4);
      }
    }
  }
  // if not enough good leptons were found (or no expected number of leptons was set),
  // the result is filled with leptons that were merely not vetoed
  for (const auto& l : leptons_not_vetoed_p4s) {
    lepton_p4s.push_back(l);
    if (m_n_leptons>=0 && int(lepton_p4s.size()) >= m_n_leptons) break;
  }
  return lepton_p4s;
}

filterPhotonOrigins()

std::vector< TLorentzVector > VGammaORTool::filterPhotonOrigins ( const std::vector< TLorentzVector > &  photon_candidates, const std::vector< int > &  photon_origins  ) const

private

Definition at line 179 of file VGammaORTool.cxx.

                                                                                                          {
  // this should only happen if the user gives the wrong input
  if (photon_candidates.size() != photon_origins.size()) {
    ATH_MSG_ERROR(
      "VGammaORTool::filterPhotonOrigins" << ": size of photon candidates (" << photon_candidates.size() << ") different from number of photon origins (" << photon_origins.size() <<
        ").");
  }
  // filter out vetoed photons
  std::vector<TLorentzVector> photon_p4s;
  for (uint i = 0; i < photon_candidates.size(); i++) {
    const TLorentzVector p4 = photon_candidates[i];
    const int p_origin = photon_origins[i];
    const bool vetoed =
      std::find(m_veto_photon_origins.begin(), m_veto_photon_origins.end(), p_origin) != m_veto_photon_origins.end();
    if (!vetoed) {
      photon_p4s.push_back(p4);
    }
  }
 
  return photon_p4s;
}

frixioneFunc()

float VGammaORTool::frixioneFunc ( float  dR, float  dR0, float  exponent, float  epsilon  ) const

private

Definition at line 392 of file VGammaORTool.cxx.

                                                                                         {
  return epsilon * TMath::Power((1 - TMath::Cos(dR)) / (1 - TMath::Cos(dR0)), exponent);
}

frixioneIsolated()

bool VGammaORTool::frixioneIsolated ( const xAOD::TruthParticle &  photon, const xAOD::TruthParticleContainer &  truthParticles, float  dR0, float  exponent, float  epsilon  ) const

overridevirtual

Function determining whether a photon is frixione isolated from truthParticles Parameters as defined in https://arxiv.org/pdf/hep-ph/9801442.

Implements IVGammaORTool.

Definition at line 350 of file VGammaORTool.cxx.

                                                         {
  // all photons are isolated if dR is negative
  if (dR0 <= 0.) {
    return true;
  }
  // create map between hadron-photon dr and hadron pt
  std::map<float, float> dr_to_pt;
  for (const auto *p : truthParticles) {
    if (!MC::isStable(p) || HepMC::is_simulation_particle(p)) continue;
    // ignore what typically is leptons and photons
    if (std::find(m_abs_pdgids_excluded_from_iso.begin(), m_abs_pdgids_excluded_from_iso.end(),
                  std::abs(p->pdgId())) != m_abs_pdgids_excluded_from_iso.end()) {
      continue;
    }
    const float dRgamma = photon.p4().DeltaR(p->p4());
    // consider only photons withon isolation cone dR0
    if (dRgamma < dR0) {
      // should two hadrons have the same dr  they are added up
      if (dr_to_pt.count(dRgamma) > 0) {
        dr_to_pt[dRgamma] += p->pt();
      }
      dr_to_pt[dRgamma] = p->pt();
    }
  }
  // use map to determine whether photon is Frixione isolated
  // map is sorted from low to high dr
  float sumPt = 0.;
  for (const auto& pair : dr_to_pt) {
    sumPt += pair.second;
    const float dRgamma = pair.first;
    // if for any dRgamma the sum of pt of hadrons with a distrance of <=dRgamma to photon
    // does not fulfill the Frixione condition, the photon is not isolated
    if (sumPt > photon.pt() * frixioneFunc(dRgamma, dR0, exponent, epsilon)) {
      return false;
    }
  }
  // otherwise the photon is isolated
  return true;
}

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getLeptonP4s()

std::vector< TLorentzVector > VGammaORTool::getLeptonP4s

(

const xAOD::TruthParticleContainer &

truthParticleContainer

)

const

Get final state leptons from truthParticleContainer Filter function is applied, only leptons from relevant origins are kept.

Definition at line 245 of file VGammaORTool.cxx.

                                                                                                           {
  std::vector<const xAOD::TruthParticle*> tau_candidates;
  std::vector<const xAOD::TruthParticle*> elmu_candidates;
  for (const auto *p : truthParticles) {
    // ignore all particles created in Geant4
    if (HepMC::is_simulation_particle(p)) continue;
    // ignore all particles with the wrong pdgid
    if (std::find(m_lepton_pdgIds.begin(), m_lepton_pdgIds.end(), p->pdgId()) == m_lepton_pdgIds.end()) continue;
    // handle taus: use tau instances before decay into non-tau
    if (MC::isTau(p)) {
      bool childIsTau = false;
      bool hasChildren = false;
      // make sure tau has no tau children, i.e. is tau before decay
      for (uint i = 0; i < p->nChildren(); i++) {
        if (p->child(i) == nullptr) continue;
        if (HepMC::is_same_particle(p->child(i),p)) continue;
        hasChildren = true;
        if (p->child(i)->pdgId() == p->pdgId()) {
          childIsTau = true;
          break;
        }
      }
      if (hasChildren && !childIsTau) tau_candidates.push_back(p);
    }
    // electron and muons: use all status 1 not from tau
    else if (MC::isStable(p) && !isFromTau(*p)) {
      elmu_candidates.push_back(p);
    }
  }
  // sort leptons by pT
  sort(tau_candidates.begin(), tau_candidates.end(),
       [](const xAOD::TruthParticle*& p1, const xAOD::TruthParticle*& p2) {
    return p1->pt() > p2->pt();
  });
  sort(elmu_candidates.begin(), elmu_candidates.end(),
       [](const xAOD::TruthParticle*& p1, const xAOD::TruthParticle*& p2) {
    return p1->pt() > p2->pt();
  });
  // put taus before other leptons in a vector
  std::vector<const xAOD::TruthParticle*> lepton_candidates(tau_candidates);
  lepton_candidates.insert(lepton_candidates.end(), elmu_candidates.begin(), elmu_candidates.end());
  // determine lepton origins
  std::vector<TLorentzVector> lepton_p4s;
  std::vector<int> lepton_origins;
  static const SG::ConstAccessor<unsigned int> classifierParticleOriginAcc("classifierParticleOrigin");
  for (const auto& p : lepton_candidates) {
    const unsigned int origin = classifierParticleOriginAcc(*p);
    lepton_origins.push_back(origin);
    lepton_p4s.push_back(p->p4());
  }
  // filter out bad origins
  return filterLeptonOrigins(lepton_p4s, lepton_origins);
}

getName()

const std::string & asg::AsgTool::getName ( const void *  ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getPhotonP4s()

std::vector< TLorentzVector > VGammaORTool::getPhotonP4s

(

const xAOD::TruthParticleContainer &

truthParticleContainer

)

const

Get final state photons from truthParticleContainer A minimum pT cut and isolation is applied according to tool configuration Filter function is applied, only photons from relevant origins are kept.

Definition at line 299 of file VGammaORTool.cxx.

                                                                                                           {
  std::vector<TLorentzVector> photon_p4s;
  std::vector<int> photon_origins;
  for (const auto *p : truthParticles) {
    // consider only final state photons, not from geant, above a lower pt cut
    if (!MC::isStable(p) || HepMC::is_simulation_particle(p) || !MC::isPhoton(p) || p->pt() < m_min_considered_photon_pT) continue;
    // require photons to be isolated if use_gamma_iso is true
    if (m_use_gamma_iso && !frixioneIsolated(*p, truthParticles, m_frixione_dR, m_frixione_exponent, m_frixione_epsilon)) continue;
    // determine photon origin
    static const SG::ConstAccessor<unsigned int> classifierParticleOriginAcc("classifierParticleOrigin");
    const unsigned int origin = classifierParticleOriginAcc(*p);
    photon_origins.push_back(origin);
    photon_p4s.push_back(p->p4());
  }
  // filter out bad photons
  return filterPhotonOrigins(photon_p4s, photon_origins);
}

getProperty()

template<class T >

const T* asg::AsgTool::getProperty ( const std::string &  name ) const

inherited

Get one of the tool's properties.

initialize()

virtual StatusCode asg::AsgTool::initialize ( )

inlinevirtualinherited

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented in SimpleMuonTriggerScaleFactors, Trig::TrigMuonMatching, CP::MuonTriggerScaleFactors, IHIEventShapeMapTool, ST::SUSYObjDef_xAOD, InDetSecVtxTruthMatchTool, JetGrooming::RecSoftDrop, met::METMaker, AsgForwardElectronIsEMSelector, JetGrooming::JetTrimming, ORUtils::BaseOverlapTool, PMGTools::PMGSherpa22VJetsWeightTool, AsgElectronEfficiencyCorrectionTool, CP::ElectronChargeEfficiencyCorrectionTool, AsgForwardElectronLikelihoodTool, CorrectPFOTool, CP::IsolationCorrectionTool, TauAnalysisTools::TauTruthMatchingTool, EGammaAmbiguityTool, InDetVertexTruthMatchTool, AthOnnx::OnnxRuntimeSessionToolCPU, AthOnnx::OnnxRuntimeSessionToolCUDA, PuppiWeightTool, CP::EgammaCalibrationAndSmearingTool, CP::FFJetSmearingTool, JetBalancePFlowJvtTool, JetIsolationTool, JetForwardPFlowJvtTool, MCTruthClassifier, InDet::InDetHardScatterSelectionTool, dRMatchingTool, xAOD::BPhysBlindingTool, JetVertexTaggerTool, tauRecTools::TrackRNN, LVL1::L1CaloOfflineTriggerTowerTools, TauAnalysisTools::TauSelectionTool, JetRecTool, met::METAssociationTool, CP::TrackVertexAssociationTool, met::METAssociator, xAOD::TrackIsolationTool, InDet::InDetTrackSelectionTool, egammaMVACalibTool, TrigConf::xAODConfigTool, JetCleaningTool, met::METCaloRegionsTool, ZDC::ZdcLEDAnalysisTool, ZDC::RpdSubtractCentroidTool, CP::MuonCalibTool, LVL1::L1CaloCells2TriggerTowers, IDTPM::TrackAnalysisInfoWriteTool, JetVertexFractionTool, LVL1BS::PpmByteStreamReadV1V2Tool, JetClusterer, JetForwardJvtToolBDT, CP::AsgFlagSelectionTool, TauTrackFinder, TauAnalysisTools::DiTauSelectionTool, JetClustererByVertex, BookkeeperTool, JetBadChanCorrTool, xAOD::BPhysTrackVertexMapTool, JetModifiedMassDrop, xAOD::CaloIsolationTool, EnhancedBiasWeighter, InDet::InDetUsedInFitTrackDecoratorTool, CP::AsgPtEtaSelectionTool, TauAnalysisTools::BuildTruthTaus, tauRecTools::TauTrackRNNClassifier, InDet::InDetSecVtxTrackSelectionTool, AthONNX::JSSMLTool, JetForwardJvtTool, JetPileupTag::JetVertexNNTagger, CP::EgammaIsGoodOQSelectionTool, CP::IsolationCloseByCorrectionTool, ElectronPhotonVariableCorrectionBase, CP::MuonCalibIntScaleSmearTool, JetFinder, AsgElectronIsEMSelector, CP::MuonCalibIntHighpTSmearTool, CP::MuonCalibIntSagittaTool, met::METBuilderTool, CP::AsgMaskSelectionTool, ECUtils::EventCleaningTool, TauAnalysisTools::TauTruthTrackMatchingTool, met::METSoftTermsTool, LVL1::L1CaloLArTowerEnergy, HiggsTruthCategoryTool, IDTPM::TrackRoiSelectionTool, TauAnalysisTools::CommonDiTauEfficiencyTool, HIJetConstituentSubtractionTool, JetTrackSumMomentsTool, JetGrooming::SoftDrop, JetTrackMomentsTool, met::METTruthTool, PMGTools::PMGSherpaVjetsSysTool, JetQGTaggerVariableTool, ClusterMatching::CaloClusterMatchingTool, AsgPhotonEfficiencyCorrectionTool, FlavorTagDiscriminants::MultifoldGNNTool, InDet::JetTrackFilterTool, DiTauRecTools::DiTauDiscriminantTool, asg::DataHandleTestTool, xAODMaker::FileMetaDataTool, InDet::InclusiveTrackFilterTool, InDet::InDetTrackTruthFilterTool, HIJetClusterSubtractorTool, CP::MVATrackVertexAssociationTool, IDTPM::RoiSelectionTool, IDTPM::VertexRoiSelectionTool, CP::BaseFakeBkgTool, ElectronPhotonVariableCorrectionTool, JetCalibrationTool, JetCaloQualityTool, JetOriginCorrectionTool, IDTPM::TrackObjectSelectionTool, InDet::InDetTrackBiasingTool, HIJetClusterIndexAssociationTool, TauWPDecorator, TrigGlobalEfficiencyCorrectionTool, ZdcRecChannelToolV2, InDetGNNHardScatterSelection::GNNTool, CP::BaseLinearFakeBkgTool, FlavorTagDiscriminants::GNNTool, CP::MuonSelectionTool, TauAnalysisTools::CommonDiTauSmearingTool, JSSTaggerBase, CP::LhoodMM_tools, AsgElectronLikelihoodTool, DiTauRecTools::DiTauIDVarCalculator, CP::JetQGTagger, Pileup1DResidualCalibStep, LVL1::L1CaloFcal23Cells2RxMappingTool, IDTPM::TrackQualitySelectionTool, IDTPM::VertexQualitySelectionTool, ORUtils::OverlapRemovalTool, Ringer::AsgRingerSelectorTool, InDet::InDetTrackSmearingTool, CP::JetJvtEfficiency, JetCopier, JetGrooming::JetGroomer, met::METPhotonAssociator, JetECPSFractionTool, JetPtAssociationTool, met::METElectronAssociator, met::METTauAssociator, PMGTools::PMGDecayProductsSelectionTool, WeightToolBase, HIJetDRAssociationTool, JetClusterMomentsTool, met::METJetAssocTool, TauVertexFinder, IDTPM::JsonPlotsDefReadTool, TauAnalysisTools::DiTauSmearingTool, BJetCorrectionTool, JetDRTrackAssocTool, JetReclusterer, TauDecayModeNNClassifier, BDTVertexWeightCalculator, asg::UnitTestTool1, ZDC::ZdcAnalysisTool, IDTPM::DeltaRMatchingToolBase< T, R >, AsgElectronSelectorTool, GSCCalibStep, EtaMassJESCalibStep, JetReclusteringTool, met::METMuonAssociator, TauPi0CreateROI, TauShotFinder, IDTPM::DeltaRMatchingToolBase< xAOD::TrackParticle, xAOD::TruthParticle >, IDTPM::DeltaRMatchingToolBase< xAOD::TruthParticle, xAOD::TrackParticle >, IDTPM::DeltaRMatchingToolBase< xAOD::TrackParticle >, ZdcRecChannelToolLucrod, PMGTools::PMGTruthWeightTool, JetCalibTool, SmearingCalibStep, JetVoronoiMomentsTool, Trig::MatchFromCompositeTool, asg::UnitTestTool3, IDTPM::TruthTrackMatchingTool, CP::ApplyFakeFactor, AsgElectronChargeIDSelectorTool, HIJetMaxOverMeanTool, PanTau::Tool_FeatureExtractor, TauElectronVetoVariables, ZDC::ZdcTrigValidTool, IDTPM::TruthQualitySelectionTool, CP::IsolationSelectionTool, WeightsAgregator, EL::UnitTestTool, FlavorTagDiscriminants::TrackClassifier, JetLArHVTool, IDTPM::EFTrackMatchingTool, IDTPM::OfflineTrackQualitySelectionTool, IDTPM::TrackTruthMatchingTool, HI::HIPileupTool, BTaggingSelectionTool, InDet::InDetTrackTruthOriginTool, JetHelper::VarTool, FlavorTagDiscriminants::DL2Tool, PileupAreaCalibStep, EnergyCorrelatorGeneralizedRatiosTool, EnergyCorrelatorGeneralizedTool, EnergyCorrelatorRatiosTool, EnergyCorrelatorTool, TauEleOverlapChecker, TauJetRNNEvaluator, asg::UnitTestTool2, JetTruthLabelingTool, ZDC::ZdcRecTool, HIJetConstituentModifierTool, TauCalibrateLC, TauGNNEvaluator, TauPi0ScoreCalculator, TauRecToolBase, Trig::TrigEgammaEmulationPrecisionElectronHypoTool, asg::UnitTestTool1A, PDFWeight, HIEventShapeJetIteration, HIJetSignificanceTool, CP::JetQGTaggerBDT, JetWidthTool, TauVertexVariables, Trig::TrigEgammaEmulationPrecisionPhotonHypoTool, Trig::TrigEgammaMatchingTool, Trig::R3IParticleRetrievalTool, JetPileupLabelingTool, JetFromPseudojet, JetTruthParticleSelectorTool, Trig::TrigEgammaEmulationBaseHypoTool, AthOnnx::OnnxRuntimeInferenceTool, ZDC::RPDAnalysisTool, CP::ApplyE2YFakeRate, ParticleScaleFactorTool, TauAnalysisTools::TauHFVetoTool, InDet::InDetTrackSystematicsTool, JetCaloQualityToolFE, Trig::MatchingTool, Trig::R3MatchingTool, JetParticleAssociation, JetHelper::HistoInput2D, Trig::TrigEgammaEmulationChain, Trig::TrigEgammaEmulationFastCaloHypoTool, xAODtoHepMCTool, HIEventShapeMapTool, HI::HIVertexSelectionTool, TauVertexedClusterDecorator, Trig::IParticleRetrievalTool, HI::HIEventSelectionTool, FlavorTagDiscriminants::HbbTagTool, JetConstituentFrac, JetGroomMRatio, Validator, JetHelper::HistoInput1D, JetHelper::TextInputMCJES, ExtendTrackToLayerTool, Trig::TypedScoringTool, TrackTruthSelectionTool, HIUEModulatorTool, JSSWTopTaggerANN, CP::JvtEfficiencyToolBase, JetEMScaleMomTool, MvaTESVariableDecorator, TauAODMuonRemovalTool, TauCombinedTES, CP::AsymptMatrixTool, ParticleJetDeltaRLabelTool, HIEventShapeSummaryTool, FlavorTagDiscriminants::BTagAugmenterTool, FlavorTagDiscriminants::VRJetOverlapDecoratorTool, JSSTaggerUtils, JetCaloEnergies, ParticleJetGhostLabelTool, FlavorTagDiscriminants::BTagMuonAugmenterTool, BTaggingEfficiencyJsonTool, MBTSTimeFilterTool, JSSWTopTaggerDNN, SmoothedTopTagger, MvaTESEvaluator, BoostedJetTaggerTool, CP::IsolationLowPtPLVTool, Trig::DRScoringTool, Trig::EgammaDRScoringTool, BTaggingSelectionJsonTool, SmoothedWZTagger, CP::FJvtEfficiencyTool, CP::JvtSelectionToolBase, CP::NNJvtSelectionTool, AthAsgExUnittestTool, CP::JvtSelectionTool, CP::FJvtSelectionTool, CP::JvtEfficiencyTool, CP::NNJvtEfficiencyTool, BookkeeperDumperTool, TrigFastCalibWithRings, BTaggingEfficiencyTool, BTaggingTruthTaggingTool, MissingCellListTool, JetVoronoiDiagramHelpers::Diagram, FastJetInterfaceTool, CP::PhotonVertexSelectionTool, met::METSystematicsTool, Trig::TrigEgammaEmulationToolMT, JetAttributeRatioSelector, BTaggingEigenVectorRecompositionTool, Trig::TrigDecisionTool, CP::PhotonPointingTool, met::METRecoTool, CP::PileupReweightingTool, LVL1::L1CaloxAODOfflineTriggerTowerTools, LVL1::TrigT1CaloMonErrorToolV1, met::METTrackFilterTool, LVL1::TrigT1CaloMonErrorTool, SoftKillerWeightTool, EventDensityTool, met::METSignificance, JetUncertaintiesTool, CP::JetTileCorrectionTool, xAODMaker::TriggerMenuMetaDataTool, D3PD::D3PDMCTruthClassifier, JetConstituentModSequence, HistoGroupBase, AsgPhotonIsEMSelector, JetAttributeSelector, TrackVertexAssociationTool, met::METRefinerTool, TauAnalysisTools::CommonSmearingTool, PanTau::Tool_DetailsArranger, LVL1::L1CaloMonitoringCaloTool, LVL1::L1CaloTTIdTools, JetInputElRemovalTool, GoodRunsListSelectionTool, TauAnalysisTools::CommonEfficiencyTool, PanTau::PanTauProcessor, xAODMaker::TruthMetaDataTool, EventShapeCopier, met::METJetTool, ZdcByteStreamReadV1V2Tool, FSR::FsrPhotonTool, Trig::StaticBunchCrossingTool, ZMassConstraint::ConstraintFit, TauAnalysisTools::TauEfficiencyCorrectionsTool, PanTau::Tool_DecayModeDeterminator, PanTau::Tool_ModeDiscriminator, CP::ElectronLRTOverlapRemovalTool, HIClusterSubtraction, JetAttributeHisto, JetPseudojetCopier, met::METEgammaAssociator, Trig::xAODBunchCrossingTool, TauAnalysisTools::DiTauEfficiencyCorrectionsTool, TauAnalysisTools::DiTauTruthMatchingTool, TauAnalysisTools::TauSmearingTool, met::METTruthAssociator, PanTau::Tool_InformationStore, HistoDefinitionTool, PanTau::Tool_InputConverter, DiTauMassTools::MissingMassTool, JetBottomUpSoftDrop, JetRecursiveSoftDrop, PMGTools::PMGCrossSectionTool, JetSoftDrop, TrigEgammaMatchingToolMT, JetConstituentsRetriever, VoronoiWeightTool, JetCaloCellQualityTool, JetContainerHistoFiller, ChargedHadronSubtractionTool, met::METRegionsTool, met::METSoftAssociator, PanTau::Tool_TauConstituentGetter, ConstituentSubtractorTool, JetHistoBase, JetSelectorAttributeRunII, JetSplitter, CaloClusterConstituentsOrigin, CP::MuonLRTOverlapRemovalTool, HistosForJetSelection, JetPruner, JetToolRunner, JetUsedInFitTrackDecoratorTool, JetTrimmer, NSubjettinessRatiosTool, CP::MuonEfficiencyScaleFactors, JetConstitFourMomTool, NSubjettinessTool, ZdcDataAccessV2, JetPseudojetRetriever, LVL1BS::TrigT1CaloDataAccessV2, PanTau::Tool_TauConstituentSelector, CopyTruthParticles, ClusterAtEMScaleTool, CP::IsolationHelper, HIEfficiencyResponseHistos, AsgDeadHVCellRemovalTool, EfficiencyResponseHistos, ConstitTimeCutTool, JetSelectorAttribute, HIJetUEMonitoring, JetSubStructureMomentToolsBase, AsgHelloTool, CopyTruthJetParticles, LeadingJetsRelations, and JetEventSelector.

Definition at line 133 of file AsgTool.h.

{ return StatusCode::SUCCESS; }

inOverlap()

StatusCode VGammaORTool::inOverlap ( bool &  result, const std::vector< TLorentzVector > *  leptons = 0, const std::vector< TLorentzVector > *  photons = 0, const std::vector< int > *  lepton_origins = 0, const std::vector< int > *  photon_origins = 0  ) const

overridevirtual

Determine whether current event is in overlap region (set via reference).

The overlap region is defined by dR_lepton_photon_cut, photon_pT_cut and many more configurable parameters. Note that the function returns a status code. The first agument is the result, the remaining arguments are optional:

• If null pointers are given for leptons or photons, they will be taken from the event
• One can override this behaviour by manually specifying vectors of lepton/photon
• If lepton or photon origins are given in addition to the lepton four vectors, particles from irrelevant origins (e.g. decays) are filtered out This can be useful when working with derivations which store the origin but not the full truth record

Implements IVGammaORTool.

Definition at line 48 of file VGammaORTool.cxx.

                                                               {
  std::vector<float> photon_pts;
  ANA_CHECK(photonPtsOutsideDr(photon_pts,leptons,photons,lepton_origins,photon_origins));
  result = checkPhotonPts(photon_pts);
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isFromTau()

bool VGammaORTool::isFromTau ( const xAOD::TruthParticle &  lepton, int  nRecursions = 0  ) const

private

Definition at line 317 of file VGammaORTool.cxx.

                                                                                  {
  // avoid being stuck in some weird particle family tree
  if(nRecursions>20){
    return false;
  }
  for(uint i=0; i<lepton.nParents(); i++){
    const xAOD::TruthParticle* parent=lepton.parent(i);
    if (MC::isTau(parent)) return true;
    if(parent->pdgId()==lepton.pdgId()){
      return isFromTau(lepton, nRecursions+1);
    }
  }  
  return false;
 
}

msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

photonPtsOutsideDr()

StatusCode VGammaORTool::photonPtsOutsideDr ( std::vector< float > &  result, const std::vector< TLorentzVector > *  leptons = 0, const std::vector< TLorentzVector > *  photons = 0, const std::vector< int > *  lepton_origins = 0, const std::vector< int > *  photon_origins = 0  ) const

overridevirtual

Determine the pTs of photons outside the dR cut that is configured in tool initialization (dR_lepton_photon_cut).

Calculates a vector of photon pts, ordered by descending pt. Once these values are calculated they can be stored and used to easily perform OR with arbitrary pT. Note that the function returns a status code. The first agument is the result, the remaining arguments are optional

• If null pointers are given for leptons or photons, they will be taken from the event
• One can override this behaviour by manually specifying vectors of lepton/photon
• If lepton or photon origins are given in addition to the lepton four vectors, particles from irrelevant origins (e.g. decays) are filtered out This can be useful when working with derivations which store the origin but not the full truth record

Implements IVGammaORTool.

Definition at line 62 of file VGammaORTool.cxx.

                                                                    {
  std::map<float, std::vector<float> > photon_pt_map;
  ANA_CHECK(photonPtsOutsideDrs(photon_pt_map,std::vector<float>(1, m_dR_lepton_photon_cut),leptons,photons,lepton_origins,photon_origins));
  result = photon_pt_map[m_dR_lepton_photon_cut];
  return StatusCode::SUCCESS;
}

photonPtsOutsideDrs() [1/2]

StatusCode VGammaORTool::photonPtsOutsideDrs ( std::map< float, std::vector< float > > &  result, const std::vector< float > &  drCuts, const std::vector< TLorentzVector > *  leptons = 0, const std::vector< TLorentzVector > *  photons = 0, const std::vector< int > *  lepton_origins = 0, const std::vector< int > *  photon_origins = 0  ) const

private

Definition at line 89 of file VGammaORTool.cxx.

                                                                     {
  std::vector<TLorentzVector> good_leptons;
  std::vector<TLorentzVector> good_photons;
  ANA_CHECK(setInput(good_leptons,good_photons,leptons,photons,lepton_origins,photon_origins));
  
  // the actual OR algorithm is here, pts of photon outside dRs are determined first
  for (const auto& drCut : drCuts) {
    result[drCut] = std::vector<float>();
    for (const auto& photon : good_photons) {
      bool tooCloseToLepton = false;
      for (uint i_lep = 0; i_lep < good_leptons.size() && (m_n_leptons<0 || int(i_lep) < m_n_leptons); i_lep++) {
        const float dr = photon.DeltaR(good_leptons[i_lep]);
        if (dr < drCut) {
          tooCloseToLepton = true;
          break;
        }
      }
      if (!tooCloseToLepton) result[drCut].push_back(photon.Pt());
    }
    // photon pts are sorted and returned
    std::sort(result[drCut].begin(), result[drCut].end(), std::greater<float>());
  }
 
  return StatusCode::SUCCESS;
}

photonPtsOutsideDrs() [2/2]

StatusCode VGammaORTool::photonPtsOutsideDrs ( std::map< float, std::vector< float > > &  result, const std::vector< TLorentzVector > *  leptons = 0, const std::vector< TLorentzVector > *  photons = 0, const std::vector< int > *  lepton_origins = 0, const std::vector< int > *  photon_origins = 0  ) const

overridevirtual

Determine the pTs of photons outside of several dR cuts that are configured in tool initialization (dR_lepton_photon_cuts).

Calculates a mapping between dRs and vector of photon pts (ordered by descending pt). Once these values are calculated they can be stored and used to easily perform OR with arbitrary pT and multiple dR cuts. Note that the function returns a status code. The first agument is the result, the remaining arguments are optional

• If null pointers are given for leptons or photons, they will be taken from the event
• One can override this behaviour by manually specifying vectors of lepton/photon
• If lepton or photon origins are given in addition to the lepton four vectors, particles from irrelevant origins (e.g. decays) are filtered out This can be useful when working with derivations which store the origin but not the full truth record

Implements IVGammaORTool.

Definition at line 76 of file VGammaORTool.cxx.

                                                                     {
  ANA_CHECK(photonPtsOutsideDrs(result,m_dR_lepton_photon_cuts,leptons,photons,lepton_origins,photon_origins));
  return StatusCode::SUCCESS;
}

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setInput()

StatusCode VGammaORTool::setInput ( std::vector< TLorentzVector > &  leptons_out, std::vector< TLorentzVector > &  photons_out, const std::vector< TLorentzVector > *  lepton_p4s, const std::vector< TLorentzVector > *  photon_p4s, const std::vector< int > *  lepton_origins, const std::vector< int > *  photon_origins  ) const

private

Definition at line 122 of file VGammaORTool.cxx.

                                                              {
 
  // truth particles are retrieved from event if not given by user
  const xAOD::TruthParticleContainer* truthMuons(nullptr);
  const xAOD::TruthParticleContainer* truthElectrons(nullptr);
  const xAOD::TruthParticleContainer* truthPhotons(nullptr);
  if(lepton_p4s==0 || photon_p4s==0){
    ANA_CHECK(evtStore()->retrieve(truthMuons,"TruthMuons"));
    ANA_CHECK(evtStore()->retrieve(truthElectrons,"TruthElectrons"));
    ANA_CHECK(evtStore()->retrieve(truthPhotons, "TruthPhotons"));
  }
 
  // relevant photons and leptons identified
  if(lepton_p4s==0){
    std::vector<TLorentzVector> muonsOut=getLeptonP4s(*truthMuons);
    std::vector<TLorentzVector> electronsOut=getLeptonP4s(*truthElectrons);
    leptons_out.insert(leptons_out.end(),muonsOut.begin(),muonsOut.end());
    leptons_out.insert(leptons_out.end(),electronsOut.begin(),electronsOut.end());
  }
  else{
    if(lepton_origins!=0){
      leptons_out = filterLeptonOrigins(*lepton_p4s,*lepton_origins);
    }
    else{
      leptons_out = *lepton_p4s;
    }
  }
  if(photon_p4s==0){
    photons_out = getPhotonP4s(*truthPhotons);
  }
  else{
    if(photon_origins!=0){
      photons_out = filterPhotonOrigins(*photon_p4s,*photon_origins);
    }
    else{
      photons_out = *photon_p4s;
    }
  }
 
  ATH_MSG_DEBUG("VGammaORTool::setInput" << ": Found " << photons_out.size() << " photons.");
  ATH_MSG_DEBUG("VGammaORTool::setInput" << ": Found " << leptons_out.size() << " leptons.");
 
  if (m_n_leptons >=0 && int(leptons_out.size()) < m_n_leptons) {
    ATH_MSG_WARNING(
      "VGammaORTool::setInput" << ": Found " << leptons_out.size() << " leptons but expected " << m_n_leptons << ".");
  }
 
  return StatusCode::SUCCESS;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_abs_pdgids_excluded_from_iso

std::vector<int> VGammaORTool::m_abs_pdgids_excluded_from_iso

private

Definition at line 193 of file VGammaORTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dR_lepton_photon_cut

float VGammaORTool::m_dR_lepton_photon_cut

private

Definition at line 180 of file VGammaORTool.h.

m_dR_lepton_photon_cuts

std::vector<float> VGammaORTool::m_dR_lepton_photon_cuts

private

Definition at line 182 of file VGammaORTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_frixione_dR

float VGammaORTool::m_frixione_dR

private

Definition at line 187 of file VGammaORTool.h.

m_frixione_epsilon

float VGammaORTool::m_frixione_epsilon

private

Definition at line 191 of file VGammaORTool.h.

m_frixione_exponent

float VGammaORTool::m_frixione_exponent

private

Definition at line 189 of file VGammaORTool.h.

m_lepton_pdgIds

std::vector<int> VGammaORTool::m_lepton_pdgIds

private

Definition at line 161 of file VGammaORTool.h.

m_lepton_veto_origins

std::vector<int> VGammaORTool::m_lepton_veto_origins

private

Definition at line 169 of file VGammaORTool.h.

m_min_considered_photon_pT

float VGammaORTool::m_min_considered_photon_pT

private

Definition at line 196 of file VGammaORTool.h.

m_n_leptons

int VGammaORTool::m_n_leptons

private

Definition at line 158 of file VGammaORTool.h.

m_photon_pT_cuts

std::vector<float> VGammaORTool::m_photon_pT_cuts

private

Definition at line 178 of file VGammaORTool.h.

m_preferred_lepton_origins

std::vector<int> VGammaORTool::m_preferred_lepton_origins

private

Definition at line 166 of file VGammaORTool.h.

m_truthClassifier

asg::AnaToolHandle<MCTruthClassifier> VGammaORTool::m_truthClassifier

private

Definition at line 150 of file VGammaORTool.h.

m_use_gamma_iso

bool VGammaORTool::m_use_gamma_iso

private

Definition at line 185 of file VGammaORTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_veto_photon_origins

std::vector<int> VGammaORTool::m_veto_photon_origins

private

Definition at line 175 of file VGammaORTool.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• VGammaORTool.h
• VGammaORTool.cxx