ATLAS Offline Software
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
CP::IsolationSelectionTool Class Reference

#include <IsolationSelectionTool.h>

Inheritance diagram for CP::IsolationSelectionTool:
Collaboration diagram for CP::IsolationSelectionTool:

Public Types

enum  IsoWPType { Efficiency , Cut }
 Function finalizing the tool. More...

Public Member Functions

 IsolationSelectionTool (const std::string &name)
 Create a proper constructor for Athena.
virtual ~IsolationSelectionTool ()
 Destructor.
virtual StatusCode initialize () override
 Function initialising the tool.
virtual asg::AcceptData accept (const xAOD::Photon &x) const override
 Declare the interface that the class provides.
virtual asg::AcceptData accept (const xAOD::Electron &x) const override
virtual asg::AcceptData accept (const xAOD::Muon &x) const override
virtual asg::AcceptData accept (const strObj &x) const override
virtual asg::AcceptData accept (const xAOD::IParticle &x) const override
virtual const asg::AcceptInfo & getPhotonAcceptInfo () const override
virtual const asg::AcceptInfo & getElectronAcceptInfo () const override
virtual const asg::AcceptInfo & getMuonAcceptInfo () const override
virtual const asg::AcceptInfo & getObjAcceptInfo () const override
virtual const std::vector< std::unique_ptr< IsolationWP > > & getMuonWPs () const override
virtual const std::vector< std::unique_ptr< IsolationWP > > & getElectronWPs () const override
virtual const std::vector< std::unique_ptr< IsolationWP > > & getPhotonWPs () const override
virtual const std::vector< std::unique_ptr< IsolationWP > > & getObjWPs () const override
virtual StatusCode setIParticleCutsFrom (xAOD::Type::ObjectType ObjType) override
StatusCode addWP (const std::string &WP, xAOD::Type::ObjectType type)
StatusCode addWP (std::unique_ptr< IsolationWP > wp, xAOD::Type::ObjectType type)
StatusCode addMuonWP (const std::string &wpname)
StatusCode addPhotonWP (const std::string &wpname)
StatusCode addElectronWP (const std::string &wpname)
StatusCode addUserDefinedWP (const std::string &WPname, xAOD::Type::ObjectType ObjType, std::vector< std::pair< xAOD::Iso::IsolationType, std::string > > &cuts, std::string key="", IsoWPType type=Efficiency)
StatusCode addCutToWP (IsolationWP *wp, const std::string &key_in, const xAOD::Iso::IsolationType t, const std::string &expression, const xAOD::Iso::IsolationType isoCutRemap)
StatusCode addCutToWP (IsolationWP *wp, const std::string &key, const xAOD::Iso::IsolationType t, const std::string &expression)
virtual void print () const
 Print the state of the tool.
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T * getProperty (const std::string &name) const
 Get one of the tool's properties.
const std::string & msg_level_name () const __attribute__((deprecated))
 A deprecated function for getting the message level's name.
const std::string & getName (const void *ptr) const
 Get the name of an object that is / should be in the event store.
SG::sgkey_t getKey (const void *ptr) const
 Get the (hashed) key of an object that is in the event store.

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
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.

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

template<typename T>
void evaluateWP (const T &x, const std::vector< std::unique_ptr< IsolationWP > > &WP, asg::AcceptData &accept) const
void addDependencies (const std::string &container, const IsolationWP &wp)
std::string createPieceWisePolinomialFunction (const std::vector< double > &boundaries, const std::vector< std::vector< double > > &parameters, bool isOpen=false) const
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

Gaudi::Property< std::string > m_muWPname {this, "MuonWP", "Undefined", "Working point for muon"}
Gaudi::Property< std::string > m_elWPname {this, "ElectronWP", "Undefined", "Working point for electron"}
Gaudi::Property< std::string > m_phWPname {this, "PhotonWP", "Undefined", "Working point for photon"}
Gaudi::Property< std::vector< std::string > > m_muWPvec {this, "MuonWPVec", {}, "Vector of working points for muon"}
Gaudi::Property< std::vector< std::string > > m_elWPvec {this, "ElectronWPVec", {}, "Vector of working points for electron"}
Gaudi::Property< std::vector< std::string > > m_phWPvec {this, "PhotonWPVec", {}, "Vector of working points for photon"}
Gaudi::Property< std::string > m_muWPKey {this, "MuonKey", "/Muons/DFCommonGoodMuon/mu_cutValues_", "path of the cut map for muon"}
Gaudi::Property< std::string > m_elWPKey
Gaudi::Property< std::string > m_phWPKey
Gaudi::Property< std::string > m_isoDecSuffix
Gaudi::Property< std::string > m_calibFileName {this, "CalibFileName", "", " The config to use"}
 input file
std::unique_ptr< TFile > m_calibFile {nullptr}
std::vector< std::unique_ptr< IsolationWP > > m_muWPs {}
 internal use
std::vector< std::unique_ptr< IsolationWP > > m_elWPs {}
std::vector< std::unique_ptr< IsolationWP > > m_phWPs {}
std::vector< std::unique_ptr< IsolationWP > > m_objWPs {}
asg::AcceptInfo m_photonAccept {"IsolationSelectionToolPhotonAcceptInfo"}
 AcceptInfo's.
asg::AcceptInfo m_electronAccept {"IsolationSelectionToolElectronAcceptInfo"}
asg::AcceptInfo m_muonAccept {"IsolationSelectionToolMuonAcceptInfo"}
asg::AcceptInfo m_objAccept {"IsolationSelectionToolObjAcceptInfo"}
std::vector< std::unique_ptr< IsolationWP > > * m_iparWPs {nullptr}
 Iparticle interface.
asg::AcceptInfo * m_iparAcceptInfo {nullptr}
Gaudi::Property< bool > m_doInterpM {this, "doCutInterpolationMuon", false, "flag to perform cut interpolation, muon"}
Gaudi::Property< bool > m_doInterpE {this, "doCutInterpolationElec", true, "flag to perform cut interpolation, electron"}
std::shared_ptr< Interp3D > m_Interp {nullptr}
SG::ReadDecorHandleKeyArray< xAOD::IParticleContainer > m_isoDecors {this, "IsolationDecors", {}, "List of decorations needed by the tool"}
Gaudi::Property< std::string > m_inMuonContainer {this, "InMuonContainer", "" , "Name of the muon container parsed to the tool."}
 Properties to declare the data dependencies to the avalanche scheduler.
Gaudi::Property< std::string > m_inElecContainer {this, "InElectronContainer", "" , "Name of the electron container parsed to the tool."}
Gaudi::Property< std::string > m_inPhotContainer {this, "InPhotonContainer", "", "Name of the photon container parsed to the tool."}
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 25 of file IsolationSelectionTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ IsoWPType

enum CP::IsolationSelectionTool::IsoWPType

Function finalizing the tool.

Enumerator
Efficiency 
Cut 

Definition at line 39 of file IsolationSelectionTool.h.

39{ Efficiency, Cut };

Constructor & Destructor Documentation

◆ IsolationSelectionTool()

CP::IsolationSelectionTool::IsolationSelectionTool ( const std::string & name)

Create a proper constructor for Athena.

Constructor for standalone usage, but please do use the interface and ToolHandle

Definition at line 20 of file IsolationSelectionTool.cxx.

20: asg::AsgTool(name) {}

◆ ~IsolationSelectionTool()

CP::IsolationSelectionTool::~IsolationSelectionTool ( )
virtualdefault

Destructor.

Member Function Documentation

◆ accept() [1/5]

asg::AcceptData CP::IsolationSelectionTool::accept ( const strObj & x) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 627 of file IsolationSelectionTool.cxx.

627 {
628 if (x.type == xAOD::Type::Electron) {
629 asg::AcceptData accept(&m_electronAccept);
630 evaluateWP(x, m_elWPs, accept);
631 return accept;
632 } else if (x.type == xAOD::Type::Muon) {
633 asg::AcceptData accept(&m_muonAccept);
634 evaluateWP(x, m_muWPs, accept);
635 return accept;
636 } else if (x.type == xAOD::Type::Photon) {
637 asg::AcceptData accept(&m_photonAccept);
638 evaluateWP(x, m_phWPs, accept);
639 return accept;
640 } else {
641 asg::AcceptData accept(&m_objAccept);
642 evaluateWP(x, m_objWPs, accept);
643 return accept;
644 }
645 return asg::AcceptData(&m_objAccept);
646 }
x
#define x
CP::IsolationSelectionTool::evaluateWP
void evaluateWP(const T &x, const std::vector< std::unique_ptr< IsolationWP > > &WP, asg::AcceptData &accept) const
Definition IsolationSelectionTool.cxx:579
CP::IsolationSelectionTool::m_photonAccept
asg::AcceptInfo m_photonAccept
AcceptInfo's.
Definition IsolationSelectionTool.h:103
CP::IsolationSelectionTool::m_muWPs
std::vector< std::unique_ptr< IsolationWP > > m_muWPs
internal use
Definition IsolationSelectionTool.h:97
CP::IsolationSelectionTool::m_objWPs
std::vector< std::unique_ptr< IsolationWP > > m_objWPs
Definition IsolationSelectionTool.h:100
CP::IsolationSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::Photon &x) const override
Declare the interface that the class provides.
Definition IsolationSelectionTool.cxx:585
CP::IsolationSelectionTool::m_phWPs
std::vector< std::unique_ptr< IsolationWP > > m_phWPs
Definition IsolationSelectionTool.h:99
CP::IsolationSelectionTool::m_elWPs
std::vector< std::unique_ptr< IsolationWP > > m_elWPs
Definition IsolationSelectionTool.h:98
xAODType::Photon
@ Photon
The object is a photon.
Definition ObjectType.h:47
xAODType::Muon
@ Muon
The object is a muon.
Definition ObjectType.h:48
xAODType::Electron
@ Electron
The object is an electron.
Definition ObjectType.h:46

◆ accept() [2/5]

asg::AcceptData CP::IsolationSelectionTool::accept ( const xAOD::Electron & x) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 591 of file IsolationSelectionTool.cxx.

591 {
592 asg::AcceptData accept(&m_electronAccept);
593 evaluateWP(x, m_elWPs, accept);
594 return accept;
595 }

◆ accept() [3/5]

asg::AcceptData CP::IsolationSelectionTool::accept ( const xAOD::IParticle & x) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 603 of file IsolationSelectionTool.cxx.

603 {
604 if (x.type() == xAOD::Type::Electron) {
605 asg::AcceptData accept(&m_electronAccept);
606 evaluateWP(x, m_elWPs, accept);
607 return accept;
608 } else if (x.type() == xAOD::Type::Muon) {
609 asg::AcceptData accept(&m_muonAccept);
610 evaluateWP(x, m_muWPs, accept);
611 return accept;
612 } else if (x.type() == xAOD::Type::Photon) {
613 asg::AcceptData accept(&m_photonAccept);
614 evaluateWP(x, m_phWPs, accept);
615 return accept;
616 }
617
618 else if (m_iparAcceptInfo && m_iparWPs) {
619 asg::AcceptData accept(m_iparAcceptInfo);
620 evaluateWP(x, *m_iparWPs, accept);
621 return accept;
622 }
623 ATH_MSG_ERROR("Someting here makes really no sense");
624 return asg::AcceptData(&m_objAccept);
625 }
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
CP::IsolationSelectionTool::m_iparWPs
std::vector< std::unique_ptr< IsolationWP > > * m_iparWPs
Iparticle interface.
Definition IsolationSelectionTool.h:109

◆ accept() [4/5]

asg::AcceptData CP::IsolationSelectionTool::accept ( const xAOD::Muon & x) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 597 of file IsolationSelectionTool.cxx.

597 {
598 asg::AcceptData accept(&m_muonAccept);
599 evaluateWP(x, m_muWPs, accept);
600 return accept;
601 }

◆ accept() [5/5]

asg::AcceptData CP::IsolationSelectionTool::accept ( const xAOD::Photon & x) const
overridevirtual

Declare the interface that the class provides.

Implements CP::IIsolationSelectionTool.

Definition at line 585 of file IsolationSelectionTool.cxx.

585 {
586 asg::AcceptData accept(&m_photonAccept);
587 evaluateWP(x, m_phWPs, accept);
588 return accept;
589 }

◆ addCutToWP() [1/2]

StatusCode CP::IsolationSelectionTool::addCutToWP ( IsolationWP * wp,
const std::string & key,
const xAOD::Iso::IsolationType t,
const std::string & expression )

Definition at line 138 of file IsolationSelectionTool.cxx.

139 {
140 return addCutToWP(wp, key, t, expression, t);
141 }
CP::IsolationSelectionTool::addCutToWP
StatusCode addCutToWP(IsolationWP *wp, const std::string &key_in, const xAOD::Iso::IsolationType t, const std::string &expression, const xAOD::Iso::IsolationType isoCutRemap)
Definition IsolationSelectionTool.cxx:111

◆ addCutToWP() [2/2]

StatusCode CP::IsolationSelectionTool::addCutToWP ( IsolationWP * wp,
const std::string & key_in,
const xAOD::Iso::IsolationType t,
const std::string & expression,
const xAOD::Iso::IsolationType isoCutRemap )

Definition at line 111 of file IsolationSelectionTool.cxx.

112 {
113 if (!m_calibFile) {
114 ATH_MSG_ERROR("Calibration File (" << m_calibFileName << ") is missing.");
115 return StatusCode::FAILURE;
116 }
117
118 std::string varname(xAOD::Iso::toCString(isoCutRemap));
119 std::string key = key_in + varname;
120
121 TH3F* calibHisto{nullptr};
122 m_calibFile->GetObject(key.c_str(), calibHisto);
123 if (!calibHisto) {
124 ATH_MSG_FATAL(" Failed to load " << key << " from " << m_calibFile->GetName());
125 return StatusCode::FAILURE;
126 }
127 calibHisto->SetDirectory(nullptr);
128 std::unique_ptr<TH3F> histogram(calibHisto);
129 std::unique_ptr<IsolationConditionHist> ich =
130 std::make_unique<IsolationConditionHist>(varname, t, expression, std::move(histogram));
131 if ((m_doInterpM && key.find("Muon") != std::string::npos) || (m_doInterpE && key.find("Electron") != std::string::npos))
132 ich->setInterp(m_Interp);
133 wp->addCut(std::move(ich));
134
135 return StatusCode::SUCCESS;
136 }
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34
histogram
std::string histogram
Definition chains.cxx:52
CP::IsolationSelectionTool::m_doInterpM
Gaudi::Property< bool > m_doInterpM
Definition IsolationSelectionTool.h:113
CP::IsolationSelectionTool::m_doInterpE
Gaudi::Property< bool > m_doInterpE
Definition IsolationSelectionTool.h:114
CP::IsolationSelectionTool::m_calibFile
std::unique_ptr< TFile > m_calibFile
Definition IsolationSelectionTool.h:94
CP::IsolationSelectionTool::m_Interp
std::shared_ptr< Interp3D > m_Interp
Definition IsolationSelectionTool.h:115
CP::IsolationSelectionTool::m_calibFileName
Gaudi::Property< std::string > m_calibFileName
input file
Definition IsolationSelectionTool.h:93
xAOD::Iso::toCString
static const char * toCString(IsolationConeSize conesize)
Definition IsolationConeSize.h:30

◆ addDependencies()

void CP::IsolationSelectionTool::addDependencies ( const std::string & container,
const IsolationWP & wp )
private

Definition at line 85 of file IsolationSelectionTool.cxx.

85 {
86 if (container.empty()) return;
87 for (const std::unique_ptr<IsolationCondition>& cond : wp.conditions()) {
88 for (unsigned int acc = 0; acc < cond->num_types(); ++acc) {
89 m_isoDecors.emplace_back(container + "." + SG::AuxTypeRegistry::instance().getName(cond->accessor(acc).auxid()));
90 }
91 }
92 }
CP::IsolationSelectionTool::m_isoDecors
SG::ReadDecorHandleKeyArray< xAOD::IParticleContainer > m_isoDecors
Definition IsolationSelectionTool.h:118
SG::AuxTypeRegistry::instance
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Definition AuxTypeRegistry.cxx:640
asg::AsgTool::getName
const std::string & getName(const void *ptr) const
Get the name of an object that is / should be in the event store.
Definition AsgTool.cxx:106
xAOD::acc
static const SG::AuxElement::Accessor< ElementLink< IParticleContainer > > acc("originalObjectLink")
Object used for setting/getting the dynamic decoration in question.

◆ addElectronWP()

StatusCode CP::IsolationSelectionTool::addElectronWP ( const std::string & wpname)

Definition at line 437 of file IsolationSelectionTool.cxx.

437 {
438 std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(elWPname);
439
440 if (elWPname == "HighPtCaloOnly") {
441 wp->addCut(std::make_unique<IsolationConditionFormula>("FCHighPtCaloOnly_calo", xAOD::Iso::topoetcone20,
442 "std::max(0.015*x,3.5E3)", false, m_isoDecSuffix)); // units are MeV!
443 } else if (elWPname == "Tight_VarRad") {
444 wp->addCut(std::make_unique<IsolationConditionFormula>(
445 "ElecTight_track", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*x", false, m_isoDecSuffix));
446 wp->addCut(std::make_unique<IsolationConditionFormula>("ElecTight_calo", xAOD::Iso::topoetcone20, "0.06*x", false, m_isoDecSuffix));
447 } else if (elWPname == "Loose_VarRad") {
448 wp->addCut(std::make_unique<IsolationConditionFormula>(
449 "ElecLoose_track", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.15*x", false, m_isoDecSuffix));
450 wp->addCut(std::make_unique<IsolationConditionFormula>("ElecLoose_calo", xAOD::Iso::topoetcone20, "0.20*x", false, m_isoDecSuffix));
451 } else if (elWPname == "TightTrackOnly_VarRad") {
452 wp->addCut(std::make_unique<IsolationConditionFormula>(
453 "ElecTightTrackOnly", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*x", false, m_isoDecSuffix));
454 } else if (elWPname == "TightTrackOnly_FixedRad") {
455 wp->addCut(std::make_unique<IsolationConditionFormula>(
456 "ElecTightTrackOnly_lowPt", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*(x>50e3?1e9:x)", false, m_isoDecSuffix));
457 wp->addCut(std::make_unique<IsolationConditionFormula>(
458 "ElecTightTrackOnly_highPt", xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*(x>50e3?x:1e9)", false, m_isoDecSuffix));
459 } else if (elWPname == "PflowTight_FixedRad") {
460 std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
461 xAOD::Iso::neflowisol20};
462 std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
463 xAOD::Iso::neflowisol20};
464 wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowTightLowPt", isoTypesLowPt,
465 std::make_unique<TF2>("pflowTFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
466 "0.045*(x>50e3?1e9:x)", m_isoDecSuffix));
467 wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowTightHighPt", isoTypesHighPt,
468 std::make_unique<TF2>("pflowTFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
469 "0.045*(x>50e3?x:1e9)", m_isoDecSuffix));
470 } else if (elWPname == "PflowTight") {
471 std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
472 xAOD::Iso::neflowisol20};
473 wp->addCut(std::make_unique<IsolationConditionCombined>(
474 "ElecPFlowTight", isoTypes, std::make_unique<TF2>("pflowLFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.045*x", m_isoDecSuffix));
475 } else if (elWPname == "PflowLoose_FixedRad") {
476 std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
477 xAOD::Iso::neflowisol20};
478 std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
479 xAOD::Iso::neflowisol20};
480 wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowLooseLowPt", isoTypesLowPt,
481 std::make_unique<TF2>("pflowLFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
482 "0.16*(x>50e3?1e9:x)", m_isoDecSuffix));
483 wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowLooseHighPt", isoTypesHighPt,
484 std::make_unique<TF2>("pflowLFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
485 "0.16*(x>50e3?x:1e9)", m_isoDecSuffix));
486 } else if (elWPname == "PflowLoose") {
487 std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
488 xAOD::Iso::neflowisol20};
489 wp->addCut(std::make_unique<IsolationConditionCombined>(
490 "ElecPFlowLoose", isoTypes, std::make_unique<TF2>("pflowLFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.16*x", m_isoDecSuffix));
491 } else {
492 ATH_MSG_ERROR("Unknown electron isolation WP: " << elWPname);
493 return StatusCode::FAILURE;
494 }
495
496 m_electronAccept.addCut(wp->name(), wp->name());
497#ifndef XAOD_STANDALONE
498 addDependencies(m_inElecContainer, *wp);
499#endif
500 m_elWPs.push_back(std::move(wp));
501
502 // Return gracefully:
503 return StatusCode::SUCCESS;
504 }
CP::IsolationSelectionTool::m_inElecContainer
Gaudi::Property< std::string > m_inElecContainer
Definition IsolationSelectionTool.h:122
CP::IsolationSelectionTool::m_isoDecSuffix
Gaudi::Property< std::string > m_isoDecSuffix
Definition IsolationSelectionTool.h:88
CP::IsolationSelectionTool::addDependencies
void addDependencies(const std::string &container, const IsolationWP &wp)
Definition IsolationSelectionTool.cxx:85
xAOD::Iso::neflowisol20
@ neflowisol20
Neutral eflow isolation.
Definition IsolationType.h:64
xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500
@ ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500
Ptcone http://arxiv.org/abs/1007.2221 for high mu.
Definition IsolationType.h:109
xAOD::Iso::topoetcone20
@ topoetcone20
Topo-cluster ET-sum.
Definition IsolationType.h:48
xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
@ ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
Definition IsolationType.h:112
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
@ ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
Definition IsolationType.h:101
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500
@ ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500
Definition IsolationType.h:98

◆ addMuonWP()

StatusCode CP::IsolationSelectionTool::addMuonWP ( const std::string & wpname)

Definition at line 143 of file IsolationSelectionTool.cxx.

143 {
144 std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(muWPname);
145 if (muWPname == "HighPtTrackOnly") {
146 wp->addCut(std::make_unique<IsolationConditionFormula>(
147 "ptcone20_Tight_1p25", xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "1.25E03", false, m_isoDecSuffix)); // units are MeV!
148 } else if (muWPname == "TightTrackOnly_FixedRad") {
149 wp->addCut(std::make_unique<IsolationConditionFormula>(
150 "MuonFixedCutHighMuTrackOnly_lowPt", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000, "0.06*(x>50e3?1e9:x)", false, m_isoDecSuffix));
151 wp->addCut(std::make_unique<IsolationConditionFormula>(
152 "MuonFixedCutHighMuTrackOnly_highPt", xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.06*(x>50e3?x:1e9)", false, m_isoDecSuffix));
153 } else if (muWPname == "Tight_FixedRad") {
154 wp->addCut(std::make_unique<IsolationConditionFormula>(
155 "MuonFixedCutHighMuTight_track_lowPt", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000, "0.04*(x>50e3?1e9:x)", false, m_isoDecSuffix));
156 wp->addCut(std::make_unique<IsolationConditionFormula>(
157 "MuonFixedCutHighMuTight_track_highPt", xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.04*(x>50e3?x:1e9)", false, m_isoDecSuffix));
158 wp->addCut(std::make_unique<IsolationConditionFormula>("MuonFixedCutHighMuTight_calo", xAOD::Iso::topoetcone20, "0.15*x", false, m_isoDecSuffix));
159 } else if (muWPname == "Loose_FixedRad") {
160 wp->addCut(std::make_unique<IsolationConditionFormula>(
161 "MuonFixedCutHighMuLoose_track_lowPt", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000, "0.15*(x>50e3?1e9:x)", false, m_isoDecSuffix));
162 wp->addCut(std::make_unique<IsolationConditionFormula>(
163 "MuonFixedCutHighMuLoose_track_highPt", xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.15*(x>50e3?x:1e9)", false, m_isoDecSuffix));
164 wp->addCut(std::make_unique<IsolationConditionFormula>("MuonFixedCutHighMuLoose_calo", xAOD::Iso::topoetcone20, "0.30*x", false, m_isoDecSuffix));
165 } else if (muWPname == "TightTrackOnly_VarRad") {
166 wp->addCut(std::make_unique<IsolationConditionFormula>("MuonFixedCutHighMuTrackOnly",
167 xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000, "0.06*x", false, m_isoDecSuffix));
168 } else if (muWPname == "Tight_VarRad") {
169 wp->addCut(std::make_unique<IsolationConditionFormula>("MuonFixedCutHighMuTight_track",
170 xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000, "0.04*x", false, m_isoDecSuffix));
171 wp->addCut(std::make_unique<IsolationConditionFormula>("MuonFixedCutHighMuTight_calo", xAOD::Iso::topoetcone20, "0.15*x", false, m_isoDecSuffix));
172 } else if (muWPname == "Loose_VarRad") {
173 wp->addCut(std::make_unique<IsolationConditionFormula>("MuonFixedCutHighMuLoose_track",
174 xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000, "0.15*x", false, m_isoDecSuffix));
175 wp->addCut(std::make_unique<IsolationConditionFormula>("MuonFixedCutHighMuLoose_calo", xAOD::Iso::topoetcone20, "0.30*x", false, m_isoDecSuffix));
176 } else if (muWPname == "PflowTight_FixedRad") {
177 std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt500,
178 xAOD::Iso::neflowisol20};
179 std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500,
180 xAOD::Iso::neflowisol20};
181 wp->addCut(std::make_unique<IsolationConditionCombined>("MuonPFlowTightLowPt", isoTypesLowPt,
182 std::make_unique<TF2>("pflowTFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
183 "0.045*(x>50e3?1e9:x)", m_isoDecSuffix));
184 wp->addCut(std::make_unique<IsolationConditionCombined>("MuonPFlowTightHighPt", isoTypesHighPt,
185 std::make_unique<TF2>("pflowTFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
186 "0.045*(x>50e3?x:1e9)", m_isoDecSuffix));
187 } else if (muWPname == "PflowTight_VarRad") {
188 std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500,
189 xAOD::Iso::neflowisol20};
190 wp->addCut(std::make_unique<IsolationConditionCombined>(
191 "MuonPFlowTight", isoTypes, std::make_unique<TF2>("pflowTFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.045*x", m_isoDecSuffix));
192 } else if (muWPname == "PflowLoose_FixedRad") {
193 std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt500,
194 xAOD::Iso::neflowisol20};
195 std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500,
196 xAOD::Iso::neflowisol20};
197 wp->addCut(std::make_unique<IsolationConditionCombined>("MuonPFlowLooseLowPt", isoTypesLowPt,
198 std::make_unique<TF2>("pflowLFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
199 "0.16*(x>50e3?1e9:x)", m_isoDecSuffix));
200 wp->addCut(std::make_unique<IsolationConditionCombined>("MuonPFlowLooseHighPt", isoTypesHighPt,
201 std::make_unique<TF2>("pflowLFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
202 "0.16*(x>50e3?x:1e9)", m_isoDecSuffix));
203 } else if (muWPname == "PflowLoose_VarRad") {
204 std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500,
205 xAOD::Iso::neflowisol20};
206 wp->addCut(std::make_unique<IsolationConditionCombined>(
207 "MuonPFlowLoose", isoTypes, std::make_unique<TF2>("pflowTFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.16*x", m_isoDecSuffix));
208 } else if (muWPname == "R3PLITasPLIVefficiencyTight") {
209 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
210 const std::vector<double> boundaries = {5500.0, 10000.0, 15000.0, 20000.0, 25000.0, 32000.0, 43000.0, 60000.0, 95000.0};
211 const std::vector<std::vector<double>> parameters = {{3.75},
212 {2.4599999999999946, 0.0002400000000000006},
213 {2.6437499999999883, 0.00023250000000000085},
214 {5.576250000000033, 2.249999999999814e-05},
215 {7.061249999999798, -5.2499999999991085e-05},
216 {6.933482142856749, -4.553571428570058e-05},
217 {7.271590909090752, -5.5909090909086746e-05},
218 {5.105882352941061, -1.1764705882350721e-05},
219 {4.4250000000000025, -2.97364147850582e-20},
220 {4.425000000000001}};
221 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
222 wp->addCut(std::make_unique<IsolationConditionCombined>("R3PLITasPLIVefficiencyTight", isoTypes,
223 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
224 cutFunction,
225 m_isoDecSuffix, true));
226 } else if (muWPname == "R3PLITasPLIVefficiencyVeryTight") {
227 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
228 const std::vector<double> boundaries = {5500.0, 10000.0, 15000.0, 20000.0, 25000.0, 32000.0, 43000.0, 60000.0, 95000.0};
229 const std::vector<std::vector<double>> parameters = {{4.050000000000001},
230 {2.5912499999999903, 0.0002625000000000011},
231 {2.8012499999999214, 0.00024750000000000623},
232 {5.677499999999787, 4.500000000001207e-05},
233 {6.2137499999998145, 2.2500000000008228e-05},
234 {7.09151785714283, -1.8749999999999094e-05},
235 {8.57727272727282, -6.545454545454794e-05},
236 {5.969852941176529, -1.0294117647059968e-05},
237 {5.528483606557319, -2.581967213113981e-06},
238 {5.324999999999999}};
239 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
240 wp->addCut(std::make_unique<IsolationConditionCombined>("R3PLITasPLIVefficiencyVeryTight", isoTypes,
241 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
242 cutFunction,
243 m_isoDecSuffix, true));
244 } else if (muWPname == "R3PLITasPLIVrejectionTight") {
245 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
246 const std::vector<double> boundaries = {5500.0, 10000.0, 15000.0, 20000.0, 25000.0, 32000.0, 43000.0, 60000.0, 95000.0};
247 const std::vector<std::vector<double>> parameters = {{3.6750000000000007},
248 {2.4374999999999987, 0.00022500000000000008},
249 {2.572499999999916, 0.00022500000000000666},
250 {5.351249999999845, 2.2500000000008773e-05},
251 {7.113749999999581, -6.749999999998147e-05},
252 {7.213392857142764, -6.964285714285394e-05},
253 {7.4778409090906415, -7.977272727272016e-05},
254 {4.105790441176434, -1.3419117647058116e-05},
255 {3.590163934426209, -4.180327868852198e-06},
256 {3.1499999999999986}};
257 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
258 wp->addCut(std::make_unique<IsolationConditionCombined>("R3PLITasPLIVrejectionTight", isoTypes,
259 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
260 cutFunction,
261 m_isoDecSuffix, true));
262 } else if (muWPname == "R3PLITasPLIVrejectionVeryTight") {
263 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
264 const std::vector<double> boundaries = {5500.0, 10000.0, 15000.0, 20000.0, 25000.0, 32000.0, 43000.0, 60000.0, 95000.0};
265 const std::vector<std::vector<double>> parameters = {{3.974999999999998},
266 {2.5875000000000035, 0.0002549999999999993},
267 {2.8687499999999373, 0.00023250000000000495},
268 {5.527499999999797, 4.500000000001146e-05},
269 {6.048749999999677, 2.2500000000014293e-05},
270 {7.019196428571157, -2.4107142857133378e-05},
271 {8.878977272727232, -8.38636363636353e-05},
272 {5.708823529411479, -1.76470588235239e-05},
273 {5.215573770491751, -7.131147540982918e-06},
274 {4.649999999999999}};
275 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
276 wp->addCut(std::make_unique<IsolationConditionCombined>("R3PLITasPLIVrejectionVeryTight", isoTypes,
277 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
278 cutFunction,
279 m_isoDecSuffix, true));
280 } else if (muWPname == "R2PLITasPLIVefficiencyTight") {
281 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
282 const std::vector<double> boundaries = {5500.0, 10000.0, 15000.0, 20000.0, 25000.0, 32000.0, 43000.0, 60000.0, 95000.0};
283 const std::vector<std::vector<double>> parameters = {{3.974999999999998},
284 {2.789999999999986, 0.00021000000000000172},
285 {2.39249999999993, 0.00025500000000000555},
286 {5.737499999999933, 1.5000000000003797e-05},
287 {7.413749999999598, -6.749999999998225e-05},
288 {7.098214285714245, -5.3571428571427186e-05},
289 {6.934090909090853, -4.909090909090761e-05},
290 {5.253676470587868, -1.6176470588228218e-05},
291 {4.275000000000021, -3.17095862137587e-19},
292 {4.349999999999998}};
293 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
294 wp->addCut(std::make_unique<IsolationConditionCombined>("R2PLITasPLIVefficiencyTight", isoTypes,
295 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
296 cutFunction,
297 m_isoDecSuffix, true));
298 } else if (muWPname == "R2PLITasPLIVefficiencyVeryTight") {
299 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
300 const std::vector<double> boundaries = {5500.0, 10000.0, 15000.0, 20000.0, 25000.0, 32000.0, 43000.0, 60000.0, 95000.0};
301 const std::vector<std::vector<double>> parameters = {{4.199999999999999},
302 {2.9625000000000026, 0.00022499999999999956},
303 {2.7674999999999454, 0.0002550000000000043},
304 {5.752499999999801, 4.500000000001117e-05},
305 {6.2887499999995, 2.2500000000022112e-05},
306 {7.265625000000208, -2.4107142857150163e-05},
307 {8.287500000000128, -5.863636363636705e-05},
308 {5.99329044117658, -1.194852941176682e-05},
309 {5.653893442622939, -5.5327868852457475e-06},
310 {5.25}};
311 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
312 wp->addCut(std::make_unique<IsolationConditionCombined>("R2PLITasPLIVefficiencyVeryTight", isoTypes,
313 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
314 cutFunction,
315 m_isoDecSuffix, true));
316 } else if (muWPname == "R2PLITasPLIVrejectionTight") {
317 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
318 const std::vector<double> boundaries = {5500.0, 10000.0, 15000.0, 20000.0, 25000.0, 32000.0, 43000.0, 60000.0, 95000.0};
319 const std::vector<std::vector<double>> parameters = {{3.8999999999999986},
320 {2.853749999999994, 0.00018750000000000065},
321 {2.321250000000002, 0.0002474999999999998},
322 {5.426250000000083, 2.2499999999995095e-05},
323 {7.312499999999872, -7.499999999999437e-05},
324 {7.552232142857126, -8.303571428571374e-05},
325 {7.140340909090713, -7.022727272726753e-05},
326 {4.7727941176470186, -2.499999999999921e-05},
327 {3.679918032786865, -5.409836065573509e-06},
328 {3.0}};
329 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
330 wp->addCut(std::make_unique<IsolationConditionCombined>("R2PLITasPLIVrejectionTight", isoTypes,
331 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
332 cutFunction,
333 m_isoDecSuffix, true));
334 } else if (muWPname == "R2PLITasPLIVrejectionVeryTight") {
335 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
336 const std::vector<double> boundaries = {5500.0, 10000.0, 15000.0, 20000.0, 25000.0, 32000.0, 43000.0, 60000.0, 95000.0};
337 const std::vector<std::vector<double>> parameters = {{4.199999999999999},
338 {2.9887499999999982, 0.0002175000000000001},
339 {2.9287500000000426, 0.0002324999999999965},
340 {5.602499999999976, 4.500000000000134e-05},
341 {6.262499999999722, 1.5000000000012243e-05},
342 {7.651339285714248, -4.5535714285712985e-05},
343 {8.947159090908924, -8.659090909090467e-05},
344 {5.994117647058617, -2.3529411764701903e-05},
345 {4.8565573770491985, -2.213114754098622e-06},
346 {4.349999999999998}};
347 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
348 wp->addCut(std::make_unique<IsolationConditionCombined>("R2PLITasPLIVrejectionVeryTight", isoTypes,
349 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
350 cutFunction,
351 m_isoDecSuffix, true));
352 } else if (muWPname == "R3PLITVeryLoose") {
353 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
354 const std::vector<double> boundaries = {15000.0, 20000.0, 25000.0, 30000.0, 40000.0, 50000.0, 75000.0, 100000.0, 110000.0, 120000.0, 160000.0};
355 const std::vector<std::vector<double>> parameters = {{-0.3040909, 0.0002809},
356 {1.56375, 9.75e-05},
357 {1.22625, 9.75e-05},
358 {1.4625, 7.5e-05},
359 {1.4622506, 6.45e-05},
360 {1.6695205, 4.62e-05},
361 {1.9120284, 3.31e-05},
362 {2.9462838, 1.26e-05},
363 {3.375},
364 {3.45},
365 {3.225},
366 {3.3}};
367 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
368 wp->addCut(std::make_unique<IsolationConditionCombined>("R3PLITVeryLoose", isoTypes,
369 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
370 cutFunction,
371 m_isoDecSuffix, true));
372 } else if (muWPname == "R2PLITVeryLoose") {
373 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
374 const std::vector<double> boundaries = {15000.0, 20000.0, 25000.0, 30000.0, 40000.0, 50000.0, 75000.0, 100000.0, 110000.0, 120000.0, 160000.0};
375 const std::vector<std::vector<double>> parameters = {{0.0886364, 0.0002536},
376 {1.8651869, 8.55e-05},
377 {1.7625, 7.5e-05},
378 {1.4625, 7.5e-05},
379 {1.5238217, 6.21e-05},
380 {1.743375, 4.43e-05},
381 {2.1522807, 2.78e-05},
382 {2.3787162, 1.74e-05},
383 {3.3},
384 {3.45},
385 {3.15},
386 {3.075}};
387 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
388 wp->addCut(std::make_unique<IsolationConditionCombined>("R2PLITVeryLoose", isoTypes,
389 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
390 cutFunction,
391 m_isoDecSuffix, true));
392 } else {
393 ATH_MSG_ERROR("Unknown muon isolation WP: " << muWPname);
394 return StatusCode::FAILURE;
395 }
396 m_muonAccept.addCut(wp->name(), wp->name());
397#ifndef XAOD_STANDALONE
398 addDependencies(m_inMuonContainer, *wp);
399#endif
400 m_muWPs.push_back(std::move(wp));
401 return StatusCode::SUCCESS;
402 }
CP::IsolationSelectionTool::createPieceWisePolinomialFunction
std::string createPieceWisePolinomialFunction(const std::vector< double > &boundaries, const std::vector< std::vector< double > > &parameters, bool isOpen=false) const
Definition IsolationSelectionTool.cxx:655
CP::IsolationSelectionTool::m_inMuonContainer
Gaudi::Property< std::string > m_inMuonContainer
Properties to declare the data dependencies to the avalanche scheduler.
Definition IsolationSelectionTool.h:121
offline_dict.parameters
dict parameters
Definition offline_dict.py:2
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000
@ ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000
Definition IsolationType.h:77
xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000
@ ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000
Definition IsolationType.h:88
xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt500
@ ptcone20_Nonprompt_All_MaxWeightTTVA_pt500
Ptcone http://arxiv.org/abs/1007.2221 for high mu.
Definition IsolationType.h:85
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500
@ ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500
Definition IsolationType.h:74

◆ addPhotonWP()

StatusCode CP::IsolationSelectionTool::addPhotonWP ( const std::string & wpname)

Definition at line 404 of file IsolationSelectionTool.cxx.

404 {
405 std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(phWPname);
406 if (phWPname == "TightCaloOnly") {
407 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
408 } else if (phWPname == "FixedCutTight") {
409 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
410 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_track20", xAOD::Iso::ptcone20, "0.05*x", false, m_isoDecSuffix));
411 } else if (phWPname == "FixedCutLoose") {
412 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo20", xAOD::Iso::topoetcone20, "0.065*x", false, m_isoDecSuffix));
413 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_track20", xAOD::Iso::ptcone20, "0.05*x", false, m_isoDecSuffix));
414 } else if (phWPname == "Tight") {
415 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
416 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_Tighttrack20",
417 xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.05*x", false, m_isoDecSuffix));
418 } else if (phWPname == "Loose") {
419 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo20", xAOD::Iso::topoetcone20, "0.065*x", false, m_isoDecSuffix));
420 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_Tighttrack20",
421 xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.05*x", false, m_isoDecSuffix));
422 } else {
423 ATH_MSG_ERROR("Unknown photon isolation WP: " << phWPname);
424 return StatusCode::FAILURE;
425 }
426
427 m_photonAccept.addCut(wp->name(), wp->name());
428#ifndef XAOD_STANDALONE
429 addDependencies(m_inPhotContainer, *wp);
430#endif
431 m_phWPs.push_back(std::move(wp));
432
433 // Return gracefully:
434 return StatusCode::SUCCESS;
435 }
CP::IsolationSelectionTool::m_inPhotContainer
Gaudi::Property< std::string > m_inPhotContainer
Definition IsolationSelectionTool.h:123
xAOD::Iso::ptcone20
@ ptcone20
Track isolation.
Definition IsolationType.h:40

◆ addUserDefinedWP()

StatusCode CP::IsolationSelectionTool::addUserDefinedWP ( const std::string & WPname,
xAOD::Type::ObjectType ObjType,
std::vector< std::pair< xAOD::Iso::IsolationType, std::string > > & cuts,
std::string key = "",
IsoWPType type = Efficiency )

Definition at line 506 of file IsolationSelectionTool.cxx.

508 {
509 std::vector<std::unique_ptr<IsolationWP>>* wps(nullptr);
510 asg::AcceptInfo* ac = nullptr;
511 if (ObjType == xAOD::Type::Electron) {
512 if (key == "") key = m_elWPKey;
513 wps = &m_elWPs;
514 ac = &m_electronAccept;
515 } else if (ObjType == xAOD::Type::Muon) {
516 if (key == "") key = m_muWPKey;
517 wps = &m_muWPs;
518 ac = &m_muonAccept;
519 } else if (ObjType == xAOD::Type::Photon) {
520 if (key == "") key = m_phWPKey;
521 wps = &m_phWPs;
522 ac = &m_photonAccept;
523 } else if (ObjType == xAOD::Type::Other) {
524 if (key == "") return StatusCode::FAILURE;
525 wps = &m_objWPs;
526 ac = &m_objAccept;
527 } else {
528 return StatusCode::FAILURE;
529 }
530
531 std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(WPname);
532 if (type == Efficiency) {
533 for (auto& c : cuts) ATH_CHECK(addCutToWP(wp.get(), key, c.first, c.second));
534 } else if (type == Cut) {
535 for (auto& c : cuts) wp->addCut(std::make_unique<IsolationConditionFormula>(xAOD::Iso::toCString(c.first), c.first, c.second));
536 } else {
537 ATH_MSG_ERROR("Unknown isolation WP type -- should not happen.");
538 return StatusCode::FAILURE;
539 }
540
541 ac->addCut(wp->name(), wp->name());
542 wps->push_back(std::move(wp));
543 return StatusCode::SUCCESS;
544 }
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
CP::IsolationSelectionTool::m_phWPKey
Gaudi::Property< std::string > m_phWPKey
Definition IsolationSelectionTool.h:86
CP::IsolationSelectionTool::m_elWPKey
Gaudi::Property< std::string > m_elWPKey
Definition IsolationSelectionTool.h:84
CP::IsolationSelectionTool::m_muWPKey
Gaudi::Property< std::string > m_muWPKey
Definition IsolationSelectionTool.h:83
asg::AcceptInfo::addCut
int addCut(const std::string &cutName, const std::string &cutDescription)
Add a cut; returning the cut position.
Definition AcceptInfo.h:53
xAODType::Other
@ Other
An object not falling into any of the other categories.
Definition ObjectType.h:34

◆ addWP() [1/2]

StatusCode CP::IsolationSelectionTool::addWP ( const std::string & WP,
xAOD::Type::ObjectType type )

Definition at line 546 of file IsolationSelectionTool.cxx.

546 {
547 if (ObjType == xAOD::Type::Electron) {
548 return addElectronWP(WP);
549 } else if (ObjType == xAOD::Type::Muon) {
550 return addMuonWP(WP);
551 } else if (ObjType == xAOD::Type::Photon) {
552 return addPhotonWP(WP);
553 }
554
555 return StatusCode::FAILURE;
556 }
CP::IsolationSelectionTool::addMuonWP
StatusCode addMuonWP(const std::string &wpname)
Definition IsolationSelectionTool.cxx:143
CP::IsolationSelectionTool::addElectronWP
StatusCode addElectronWP(const std::string &wpname)
Definition IsolationSelectionTool.cxx:437
CP::IsolationSelectionTool::addPhotonWP
StatusCode addPhotonWP(const std::string &wpname)
Definition IsolationSelectionTool.cxx:404

◆ addWP() [2/2]

StatusCode CP::IsolationSelectionTool::addWP ( std::unique_ptr< IsolationWP > wp,
xAOD::Type::ObjectType type )

Definition at line 557 of file IsolationSelectionTool.cxx.

557 {
558 if (ObjType == xAOD::Type::Electron) {
559 m_electronAccept.addCut(wp->name(), wp->name());
560 m_elWPs.push_back(std::move(wp));
561 } else if (ObjType == xAOD::Type::Muon) {
562 m_muonAccept.addCut(wp->name(), wp->name());
563 m_muWPs.push_back(std::move(wp));
564
565 } else if (ObjType == xAOD::Type::Photon) {
566 m_photonAccept.addCut(wp->name(), wp->name());
567 m_phWPs.push_back(std::move(wp));
568
569 } else if (ObjType == xAOD::Type::Other) {
570 m_objAccept.addCut(wp->name(), wp->name());
571 m_objWPs.push_back(std::move(wp));
572 } else {
573 return StatusCode::FAILURE;
574 }
575
576 return StatusCode::SUCCESS;
577 }

◆ createPieceWisePolinomialFunction()

std::string CP::IsolationSelectionTool::createPieceWisePolinomialFunction ( const std::vector< double > & boundaries,
const std::vector< std::vector< double > > & parameters,
bool isOpen = false ) const
private

Definition at line 655 of file IsolationSelectionTool.cxx.

655 {
656
657 if (isOpen && boundaries.size() != parameters.size() - 1) {
658 ATH_MSG_ERROR("The number of region boundaries must be one less than the number of parameters for the piecewise polynomial function.");
659 return "";
660 } else if (!isOpen && boundaries.size() != parameters.size() + 1) {
661 ATH_MSG_ERROR("The number of region boundaries must be one more than the number of parameters for the piecewise polynomial function.");
662 return "";
663 }
664
665 std::ostringstream oss;
666 oss << std::setprecision(16);
667
668 // a lambda for the polynomial expression
669 // one could remove the zeroes in the parameters vector
670 auto polynomial = [](const std::vector<double>& params) {
671 std::ostringstream oss;
672 oss << std::setprecision(16);
673 oss << "(";
674 for (size_t i = 0; i < params.size(); ++i) {
675 if (i > 0) oss << " + ";
676 if (i == 0) {
677 oss << params[i]; // constant term
678 } else if (i == 1) {
679 oss << params[i] << " * x"; // linear term
680 } else {// higher order terms
681 oss << params[i] << " * pow(x, " << i << ")"; // higher order terms
682 }
683 }
684 oss << ")";
685 return oss.str();
686 };
687
688 // Start the function definition, using concateation of ternary operators
689 // if isOpen==false, just nullify the function before the first and after the last boundary
690 // just create a copy of params, and insert 0.0 at the beginning and end if isOpen==false
691 std::vector<std::vector<double>> params = parameters;
692 if (!isOpen) {
693 params.insert(params.begin(), {0.0}); // add a zero vector at the beginning
694 params.push_back({0.0}); // add a zero vector at the end
695 }
696
697 // now loop over the boundaries and parameters (we can ignore isOpen finally)
698 for (size_t i = 0; i < boundaries.size(); ++i) {
699 if (i == 0) oss << "(";
700 oss << "(x < " << boundaries[i] << ") ? " << polynomial(params[i]) << " : ";
701 }
702 oss << polynomial(params.back()) << ")"; // last segment, no ternary operator
703
704 return oss.str();
705
706 }
PowhegControl_ttFCNC_NLO.params
params
Definition PowhegControl_ttFCNC_NLO.py:226

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ 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.

95{ return m_detStore; }

◆ evaluateWP()

template<typename T>
void CP::IsolationSelectionTool::evaluateWP ( const T & x,
const std::vector< std::unique_ptr< IsolationWP > > & WP,
asg::AcceptData & accept ) const
private

Definition at line 579 of file IsolationSelectionTool.cxx.

579 {
580 accept.clear();
581 for (const std::unique_ptr<IsolationWP>& i : WP) {
582 if (i->accept(x)) accept.setCutResult(i->name(), true);
583 }
584 }

◆ evtStore()

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.

85{ 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

◆ getElectronAcceptInfo()

const asg::AcceptInfo & CP::IsolationSelectionTool::getElectronAcceptInfo ( ) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 650 of file IsolationSelectionTool.cxx.

650{ return m_electronAccept; }

◆ getElectronWPs()

const std::vector< std::unique_ptr< IsolationWP > > & CP::IsolationSelectionTool::getElectronWPs ( ) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 22 of file IsolationSelectionTool.cxx.

22{ return m_elWPs; }

◆ 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
ptrThe 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.

119 {
120
121#ifdef XAOD_STANDALONE
122 // In case we use @c xAOD::TEvent, we have a direct function call
123 // for this.
124 return evtStore()->event()->getKey( ptr );
125#else
126 const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127 return ( proxy == nullptr ? 0 : proxy->sgkey() );
128#endif // XAOD_STANDALONE
129 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
Definition AthCommonDataStore.h:85
StateLessPT_NewConfig.proxy
proxy
Definition StateLessPT_NewConfig.py:407

◆ getMuonAcceptInfo()

const asg::AcceptInfo & CP::IsolationSelectionTool::getMuonAcceptInfo ( ) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 652 of file IsolationSelectionTool.cxx.

652{ return m_muonAccept; }

◆ getMuonWPs()

const std::vector< std::unique_ptr< IsolationWP > > & CP::IsolationSelectionTool::getMuonWPs ( ) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 21 of file IsolationSelectionTool.cxx.

21{ return m_muWPs; }

◆ 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
ptrThe 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.

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

◆ getObjAcceptInfo()

const asg::AcceptInfo & CP::IsolationSelectionTool::getObjAcceptInfo ( ) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 653 of file IsolationSelectionTool.cxx.

653{ return m_objAccept; }

◆ getObjWPs()

const std::vector< std::unique_ptr< IsolationWP > > & CP::IsolationSelectionTool::getObjWPs ( ) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 24 of file IsolationSelectionTool.cxx.

24{ return m_objWPs; }

◆ getPhotonAcceptInfo()

const asg::AcceptInfo & CP::IsolationSelectionTool::getPhotonAcceptInfo ( ) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 648 of file IsolationSelectionTool.cxx.

648{ return m_photonAccept; }

◆ getPhotonWPs()

const std::vector< std::unique_ptr< IsolationWP > > & CP::IsolationSelectionTool::getPhotonWPs ( ) const
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 23 of file IsolationSelectionTool.cxx.

23{ return m_phWPs; }

◆ getProperty()

template<class T>
const T * asg::AsgTool::getProperty ( const std::string & name) const
inherited

Get one of the tool's properties.

◆ initialize()

StatusCode CP::IsolationSelectionTool::initialize ( void )
overridevirtual

Function initialising the tool.

Greet the user:

setup working points

Return gracefully:

Reimplemented from asg::AsgTool.

Definition at line 27 of file IsolationSelectionTool.cxx.

27 {
29 ATH_MSG_INFO("Initialising...");
30
31 ATH_MSG_INFO("IsoDecSuffix: " << m_isoDecSuffix);
32
33 if (!m_calibFileName.empty()) {
34 std::string filename = PathResolverFindCalibFile(m_calibFileName);
35
36 ATH_MSG_INFO("Reading input file " << m_calibFileName << " from " << filename);
37 m_calibFile = std::make_unique<TFile>(filename.c_str(), "READ");
38
39 TObjString* versionInfo{nullptr};
40 m_calibFile->GetObject("VersionInfo", versionInfo);
41 if (versionInfo)
42 ATH_MSG_INFO("VersionInfo:" << versionInfo->String());
43 else
44 ATH_MSG_WARNING("VersionInfo of input file (" << filename << ") is missing.");
45 }
46
47 if (m_doInterpE || m_doInterpM) {
48 // special setting for electrons
49 // do not apply interpolation in crack vicinity for topoetcone
50 std::vector<std::pair<double, double>> rangeEtaNoInt;
51 std::pair<double, double> apair(1.26, 1.665);
52 rangeEtaNoInt.push_back(apair);
53 // do not apply interpolation between Z defined and J/Psi defined cuts (pT < > 15 GeV/c) for both calo and track iso
54 std::vector<std::pair<double, double>> rangePtNoInt;
55 apair.first = 12.5;
56 apair.second = 17.5;
57 rangePtNoInt.push_back(apair);
58 std::map<std::string, Interp3D::VetoInterp> amap;
59 Interp3D::VetoInterp veto;
60 veto.xRange = rangePtNoInt;
61 veto.yRange = std::vector<std::pair<double, double>>();
62 amap.insert(std::make_pair(std::string("el_cutValues_ptvarcone20"), veto));
63 veto.yRange = rangeEtaNoInt;
64 amap.insert(std::make_pair(std::string("el_cutValues_topoetcone20"), veto));
65 m_Interp = std::make_unique<Interp3D>(amap);
66 m_Interp->debug(false);
67 }
68
70 if (m_phWPname != "Undefined") ATH_CHECK(addPhotonWP(m_phWPname));
71 if (m_elWPname != "Undefined") ATH_CHECK(addElectronWP(m_elWPname));
72 if (m_muWPname != "Undefined") ATH_CHECK(addMuonWP(m_muWPname));
73 for (const std::string& c : m_muWPvec) ATH_CHECK(addMuonWP(c));
74 for (const std::string& c : m_elWPvec) ATH_CHECK(addElectronWP(c));
75 for (const std::string& c : m_phWPvec) ATH_CHECK(addPhotonWP(c));
76
77 m_calibFile.reset();
78 #ifndef XAOD_STANDALONE
79 ATH_CHECK(m_isoDecors.initialize());
80 #endif
82 return StatusCode::SUCCESS;
83 }
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition PathResolver.cxx:325
CP::IsolationSelectionTool::m_muWPname
Gaudi::Property< std::string > m_muWPname
Definition IsolationSelectionTool.h:76
CP::IsolationSelectionTool::m_muWPvec
Gaudi::Property< std::vector< std::string > > m_muWPvec
Definition IsolationSelectionTool.h:79
CP::IsolationSelectionTool::m_phWPvec
Gaudi::Property< std::vector< std::string > > m_phWPvec
Definition IsolationSelectionTool.h:81
CP::IsolationSelectionTool::m_phWPname
Gaudi::Property< std::string > m_phWPname
Definition IsolationSelectionTool.h:78
CP::IsolationSelectionTool::m_elWPname
Gaudi::Property< std::string > m_elWPname
Definition IsolationSelectionTool.h:77
CP::IsolationSelectionTool::m_elWPvec
Gaudi::Property< std::vector< std::string > > m_elWPvec
Definition IsolationSelectionTool.h:80
veto
std::vector< std::string > veto
these patterns are anded
Definition listroot.cxx:191

◆ 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.

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ 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.

101 {
102
103 return MSG::name( msg().level() );
104 }
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition MsgLevel.cxx:19

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ 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.

◆ print()

void asg::AsgTool::print ( ) const
virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

131 {
132
133 ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134 return;
135 }

◆ 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.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ 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.

364 {
365 handlesArray.renounce();
366 }

◆ setIParticleCutsFrom()

StatusCode CP::IsolationSelectionTool::setIParticleCutsFrom ( xAOD::Type::ObjectType ObjType)
overridevirtual

Implements CP::IIsolationSelectionTool.

Definition at line 94 of file IsolationSelectionTool.cxx.

94 {
95 if (ObjType == xAOD::Type::Electron) {
96 m_iparAcceptInfo = &m_electronAccept;
97 m_iparWPs = &m_elWPs;
98 } else if (ObjType == xAOD::Type::Muon) {
99 m_iparAcceptInfo = &m_muonAccept;
100 m_iparWPs = &m_muWPs;
101 } else if (ObjType == xAOD::Type::Photon) {
102 m_iparAcceptInfo = &m_photonAccept;
103 m_iparWPs = &m_phWPs;
104 } else {
105 return StatusCode::FAILURE;
106 }
107
108 return StatusCode::SUCCESS;
109 }

◆ 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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ 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.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

Member Data Documentation

◆ m_calibFile

std::unique_ptr<TFile> CP::IsolationSelectionTool::m_calibFile {nullptr}
private

Definition at line 94 of file IsolationSelectionTool.h.

94{nullptr};

◆ m_calibFileName

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_calibFileName {this, "CalibFileName", "", " The config to use"}
private

input file

Definition at line 93 of file IsolationSelectionTool.h.

93{this, "CalibFileName", "", " The config to use"};

◆ 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_doInterpE

Gaudi::Property<bool> CP::IsolationSelectionTool::m_doInterpE {this, "doCutInterpolationElec", true, "flag to perform cut interpolation, electron"}
private

Definition at line 114 of file IsolationSelectionTool.h.

114{this, "doCutInterpolationElec", true, "flag to perform cut interpolation, electron"};

◆ m_doInterpM

Gaudi::Property<bool> CP::IsolationSelectionTool::m_doInterpM {this, "doCutInterpolationMuon", false, "flag to perform cut interpolation, muon"}
private

Definition at line 113 of file IsolationSelectionTool.h.

113{this, "doCutInterpolationMuon", false, "flag to perform cut interpolation, muon"};

◆ m_electronAccept

asg::AcceptInfo CP::IsolationSelectionTool::m_electronAccept {"IsolationSelectionToolElectronAcceptInfo"}
private

Definition at line 104 of file IsolationSelectionTool.h.

104{"IsolationSelectionToolElectronAcceptInfo"};

◆ m_elWPKey

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_elWPKey
private
Initial value:
{this, "ElectronKey", "/ElectronPhoton/LHTight/el_cutValues_",
"path of the cut map for electron"}

Definition at line 84 of file IsolationSelectionTool.h.

84 {this, "ElectronKey", "/ElectronPhoton/LHTight/el_cutValues_",
85 "path of the cut map for electron"};

◆ m_elWPname

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_elWPname {this, "ElectronWP", "Undefined", "Working point for electron"}
private

Definition at line 77 of file IsolationSelectionTool.h.

77{this, "ElectronWP", "Undefined", "Working point for electron"};

◆ m_elWPs

std::vector<std::unique_ptr<IsolationWP> > CP::IsolationSelectionTool::m_elWPs {}
private

Definition at line 98 of file IsolationSelectionTool.h.

98{};

◆ m_elWPvec

Gaudi::Property<std::vector<std::string> > CP::IsolationSelectionTool::m_elWPvec {this, "ElectronWPVec", {}, "Vector of working points for electron"}
private

Definition at line 80 of file IsolationSelectionTool.h.

80{this, "ElectronWPVec", {}, "Vector of working points for electron"};

◆ 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_inElecContainer

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_inElecContainer {this, "InElectronContainer", "" , "Name of the electron container parsed to the tool."}
private

Definition at line 122 of file IsolationSelectionTool.h.

122{this, "InElectronContainer", "" , "Name of the electron container parsed to the tool."};

◆ m_inMuonContainer

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_inMuonContainer {this, "InMuonContainer", "" , "Name of the muon container parsed to the tool."}
private

Properties to declare the data dependencies to the avalanche scheduler.

Definition at line 121 of file IsolationSelectionTool.h.

121{this, "InMuonContainer", "" , "Name of the muon container parsed to the tool."};

◆ m_inPhotContainer

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_inPhotContainer {this, "InPhotonContainer", "", "Name of the photon container parsed to the tool."}
private

Definition at line 123 of file IsolationSelectionTool.h.

123{this, "InPhotonContainer", "", "Name of the photon container parsed to the tool."};

◆ m_Interp

std::shared_ptr<Interp3D> CP::IsolationSelectionTool::m_Interp {nullptr}
private

Definition at line 115 of file IsolationSelectionTool.h.

115{nullptr};

◆ m_iparAcceptInfo

asg::AcceptInfo* CP::IsolationSelectionTool::m_iparAcceptInfo {nullptr}
private

Definition at line 110 of file IsolationSelectionTool.h.

110{nullptr};

◆ m_iparWPs

std::vector<std::unique_ptr<IsolationWP> >* CP::IsolationSelectionTool::m_iparWPs {nullptr}
private

Iparticle interface.

Definition at line 109 of file IsolationSelectionTool.h.

109{nullptr};

◆ m_isoDecors

SG::ReadDecorHandleKeyArray<xAOD::IParticleContainer> CP::IsolationSelectionTool::m_isoDecors {this, "IsolationDecors", {}, "List of decorations needed by the tool"}
private

Definition at line 118 of file IsolationSelectionTool.h.

118{this, "IsolationDecors", {}, "List of decorations needed by the tool"};

◆ m_isoDecSuffix

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_isoDecSuffix
private
Initial value:
{
this, "IsoDecSuffix", "", "Suffix added to output isolation variables to allow to NOT overwrite existing values"}

Definition at line 88 of file IsolationSelectionTool.h.

88 {
89 this, "IsoDecSuffix", "", "Suffix added to output isolation variables to allow to NOT overwrite existing values"};

◆ m_muonAccept

asg::AcceptInfo CP::IsolationSelectionTool::m_muonAccept {"IsolationSelectionToolMuonAcceptInfo"}
private

Definition at line 105 of file IsolationSelectionTool.h.

105{"IsolationSelectionToolMuonAcceptInfo"};

◆ m_muWPKey

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_muWPKey {this, "MuonKey", "/Muons/DFCommonGoodMuon/mu_cutValues_", "path of the cut map for muon"}
private

Definition at line 83 of file IsolationSelectionTool.h.

83{this, "MuonKey", "/Muons/DFCommonGoodMuon/mu_cutValues_", "path of the cut map for muon"};

◆ m_muWPname

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_muWPname {this, "MuonWP", "Undefined", "Working point for muon"}
private

Definition at line 76 of file IsolationSelectionTool.h.

76{this, "MuonWP", "Undefined", "Working point for muon"};

◆ m_muWPs

std::vector<std::unique_ptr<IsolationWP> > CP::IsolationSelectionTool::m_muWPs {}
private

internal use

Definition at line 97 of file IsolationSelectionTool.h.

97{};

◆ m_muWPvec

Gaudi::Property<std::vector<std::string> > CP::IsolationSelectionTool::m_muWPvec {this, "MuonWPVec", {}, "Vector of working points for muon"}
private

Definition at line 79 of file IsolationSelectionTool.h.

79{this, "MuonWPVec", {}, "Vector of working points for muon"};

◆ m_objAccept

asg::AcceptInfo CP::IsolationSelectionTool::m_objAccept {"IsolationSelectionToolObjAcceptInfo"}
private

Definition at line 106 of file IsolationSelectionTool.h.

106{"IsolationSelectionToolObjAcceptInfo"};

◆ m_objWPs

std::vector<std::unique_ptr<IsolationWP> > CP::IsolationSelectionTool::m_objWPs {}
private

Definition at line 100 of file IsolationSelectionTool.h.

100{};

◆ m_photonAccept

asg::AcceptInfo CP::IsolationSelectionTool::m_photonAccept {"IsolationSelectionToolPhotonAcceptInfo"}
private

AcceptInfo's.

Definition at line 103 of file IsolationSelectionTool.h.

103{"IsolationSelectionToolPhotonAcceptInfo"};

◆ m_phWPKey

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_phWPKey
private
Initial value:
{this, "PhotonKey", "/ElectronPhoton/LHTight/el_cutValues_",
"path of the cut map for photon"}

Definition at line 86 of file IsolationSelectionTool.h.

86 {this, "PhotonKey", "/ElectronPhoton/LHTight/el_cutValues_",
87 "path of the cut map for photon"};

◆ m_phWPname

Gaudi::Property<std::string> CP::IsolationSelectionTool::m_phWPname {this, "PhotonWP", "Undefined", "Working point for photon"}
private

Definition at line 78 of file IsolationSelectionTool.h.

78{this, "PhotonWP", "Undefined", "Working point for photon"};

◆ m_phWPs

std::vector<std::unique_ptr<IsolationWP> > CP::IsolationSelectionTool::m_phWPs {}
private

Definition at line 99 of file IsolationSelectionTool.h.

99{};

◆ m_phWPvec

Gaudi::Property<std::vector<std::string> > CP::IsolationSelectionTool::m_phWPvec {this, "PhotonWPVec", {}, "Vector of working points for photon"}
private

Definition at line 81 of file IsolationSelectionTool.h.

81{this, "PhotonWPVec", {}, "Vector of working points for photon"};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.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:
Generated on for ATLAS Offline Software by doxygen 1.14.0