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 605 of file IsolationSelectionTool.cxx.

605 {
606 if (x.type == xAOD::Type::Electron) {
607 asg::AcceptData accept(&m_electronAccept);
608 evaluateWP(x, m_elWPs, accept);
609 return accept;
610 } else if (x.type == xAOD::Type::Muon) {
611 asg::AcceptData accept(&m_muonAccept);
612 evaluateWP(x, m_muWPs, accept);
613 return accept;
614 } else if (x.type == xAOD::Type::Photon) {
615 asg::AcceptData accept(&m_photonAccept);
616 evaluateWP(x, m_phWPs, accept);
617 return accept;
618 } else {
619 asg::AcceptData accept(&m_objAccept);
620 evaluateWP(x, m_objWPs, accept);
621 return accept;
622 }
623 return asg::AcceptData(&m_objAccept);
624 }
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:557
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:563
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 569 of file IsolationSelectionTool.cxx.

569 {
570 asg::AcceptData accept(&m_electronAccept);
571 evaluateWP(x, m_elWPs, accept);
572 return accept;
573 }

◆ accept() [3/5]

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

Implements CP::IIsolationSelectionTool.

Definition at line 581 of file IsolationSelectionTool.cxx.

581 {
582 if (x.type() == xAOD::Type::Electron) {
583 asg::AcceptData accept(&m_electronAccept);
584 evaluateWP(x, m_elWPs, accept);
585 return accept;
586 } else if (x.type() == xAOD::Type::Muon) {
587 asg::AcceptData accept(&m_muonAccept);
588 evaluateWP(x, m_muWPs, accept);
589 return accept;
590 } else if (x.type() == xAOD::Type::Photon) {
591 asg::AcceptData accept(&m_photonAccept);
592 evaluateWP(x, m_phWPs, accept);
593 return accept;
594 }
595
596 else if (m_iparAcceptInfo && m_iparWPs) {
597 asg::AcceptData accept(m_iparAcceptInfo);
598 evaluateWP(x, *m_iparWPs, accept);
599 return accept;
600 }
601 ATH_MSG_ERROR("Someting here makes really no sense");
602 return asg::AcceptData(&m_objAccept);
603 }
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 575 of file IsolationSelectionTool.cxx.

575 {
576 asg::AcceptData accept(&m_muonAccept);
577 evaluateWP(x, m_muWPs, accept);
578 return accept;
579 }

◆ 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 563 of file IsolationSelectionTool.cxx.

563 {
564 asg::AcceptData accept(&m_photonAccept);
565 evaluateWP(x, m_phWPs, accept);
566 return accept;
567 }

◆ 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 415 of file IsolationSelectionTool.cxx.

415 {
416 std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(elWPname);
417
418 if (elWPname == "HighPtCaloOnly") {
419 wp->addCut(std::make_unique<IsolationConditionFormula>("FCHighPtCaloOnly_calo", xAOD::Iso::topoetcone20,
420 "std::max(0.015*x,3.5E3)", false, m_isoDecSuffix)); // units are MeV!
421 } else if (elWPname == "Tight_VarRad") {
422 wp->addCut(std::make_unique<IsolationConditionFormula>(
423 "ElecTight_track", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*x", false, m_isoDecSuffix));
424 wp->addCut(std::make_unique<IsolationConditionFormula>("ElecTight_calo", xAOD::Iso::topoetcone20, "0.06*x", false, m_isoDecSuffix));
425 } else if (elWPname == "Loose_VarRad") {
426 wp->addCut(std::make_unique<IsolationConditionFormula>(
427 "ElecLoose_track", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.15*x", false, m_isoDecSuffix));
428 wp->addCut(std::make_unique<IsolationConditionFormula>("ElecLoose_calo", xAOD::Iso::topoetcone20, "0.20*x", false, m_isoDecSuffix));
429 } else if (elWPname == "TightTrackOnly_VarRad") {
430 wp->addCut(std::make_unique<IsolationConditionFormula>(
431 "ElecTightTrackOnly", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*x", false, m_isoDecSuffix));
432 } else if (elWPname == "TightTrackOnly_FixedRad") {
433 wp->addCut(std::make_unique<IsolationConditionFormula>(
434 "ElecTightTrackOnly_lowPt", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*(x>50e3?1e9:x)", false, m_isoDecSuffix));
435 wp->addCut(std::make_unique<IsolationConditionFormula>(
436 "ElecTightTrackOnly_highPt", xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*(x>50e3?x:1e9)", false, m_isoDecSuffix));
437 } else if (elWPname == "PflowTight_FixedRad") {
438 std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
439 xAOD::Iso::neflowisol20};
440 std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
441 xAOD::Iso::neflowisol20};
442 wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowTightLowPt", isoTypesLowPt,
443 std::make_unique<TF2>("pflowTFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
444 "0.045*(x>50e3?1e9:x)", m_isoDecSuffix));
445 wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowTightHighPt", isoTypesHighPt,
446 std::make_unique<TF2>("pflowTFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
447 "0.045*(x>50e3?x:1e9)", m_isoDecSuffix));
448 } else if (elWPname == "PflowTight") {
449 std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
450 xAOD::Iso::neflowisol20};
451 wp->addCut(std::make_unique<IsolationConditionCombined>(
452 "ElecPFlowTight", isoTypes, std::make_unique<TF2>("pflowLFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.045*x", m_isoDecSuffix));
453 } else if (elWPname == "PflowLoose_FixedRad") {
454 std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
455 xAOD::Iso::neflowisol20};
456 std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
457 xAOD::Iso::neflowisol20};
458 wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowLooseLowPt", isoTypesLowPt,
459 std::make_unique<TF2>("pflowLFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
460 "0.16*(x>50e3?1e9:x)", m_isoDecSuffix));
461 wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowLooseHighPt", isoTypesHighPt,
462 std::make_unique<TF2>("pflowLFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
463 "0.16*(x>50e3?x:1e9)", m_isoDecSuffix));
464 } else if (elWPname == "PflowLoose") {
465 std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
466 xAOD::Iso::neflowisol20};
467 wp->addCut(std::make_unique<IsolationConditionCombined>(
468 "ElecPFlowLoose", isoTypes, std::make_unique<TF2>("pflowLFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.16*x", m_isoDecSuffix));
469 } else {
470 ATH_MSG_ERROR("Unknown electron isolation WP: " << elWPname);
471 return StatusCode::FAILURE;
472 }
473
474 m_electronAccept.addCut(wp->name(), wp->name());
475#ifndef XAOD_STANDALONE
476 addDependencies(m_inElecContainer, *wp);
477#endif
478 m_elWPs.push_back(std::move(wp));
479
480 // Return gracefully:
481 return StatusCode::SUCCESS;
482 }
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 = {5000.0, 6000.0, 7000.0, 8000.0, 9000.0, 10000.0, 11000.0, 12000.0, 13000.0, 14000.0, 15000.0, 16000.0, 17000.0, 18000.0, 19000.0, 20000.0, 21000.0, 22000.0, 23000.0, 24000.0, 25000.0, 26000.0, 27000.0, 28000.0, 29000.0, 30000.0, 31000.0, 33000.0, 34000.0, 35000.0, 36000.0, 37000.0, 38000.0, 40000.0, 41000.0, 42000.0, 44000.0, 46000.0, 48000.0, 49000.0, 50000.0, 51000.0, 52000.0, 54000.0, 56000.0, 58000.0, 60000.0, 65000.0, 70000.0, 75000.0, 80000.0, 90000.0, 100000.0, 110000.0, 120000.0, 160000.0};
355 const std::vector<std::vector<double>> parameters = {{0.0000}, {1.0500}, {1.5000}, {1.8000}, {2.1750}, {2.5500}, {2.7000}, {3.0000}, {3.2250}, {3.4500}, {3.6000}, {3.0750}, {3.1500}, {3.3000}, {3.3750}, {3.4500}, {3.2250}, {3.3000}, {3.4500}, {3.5250}, {3.6000}, {3.3750}, {3.4500}, {3.5250}, {3.6000}, {3.6750}, {3.4500}, {3.5250}, {3.6000}, {3.6750}, {3.7500}, {3.8250}, {3.9000}, {3.9750}, {3.5250}, {3.6000}, {3.6750}, {3.7500}, {3.8250}, {3.9000}, {3.9750}, {3.5250}, {3.6000}, {3.6750}, {3.7500}, {3.8250}, {3.9000}, {4.0500}, {4.1250}, {4.2750}, {3.9000}, {4.0500}, {4.1250}, {3.3750}, {3.4500}, {3.2250}, {3.3000}};
356 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
357 wp->addCut(std::make_unique<IsolationConditionCombined>("R3PLITVeryLoose", isoTypes,
358 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
359 cutFunction,
360 m_isoDecSuffix, true));
361 } else if (muWPname == "R2PLITVeryLoose") {
362 const std::vector<std::string>& isoTypes = {"PLIT_TPLTmu_pmuxpromp", "PLIT_TPLTmu_pnpxall"};
363 const std::vector<double> boundaries = {5000.0, 6000.0, 7000.0, 8000.0, 9000.0, 10000.0, 11000.0, 12000.0, 13000.0, 14000.0, 15000.0, 17000.0, 18000.0, 19000.0, 20000.0, 21000.0, 22000.0, 23000.0, 24000.0, 25000.0, 26000.0, 27000.0, 28000.0, 29000.0, 30000.0, 32000.0, 33000.0, 34000.0, 35000.0, 36000.0, 38000.0, 39000.0, 40000.0, 41000.0, 43000.0, 44000.0, 46000.0, 48000.0, 50000.0, 51000.0, 54000.0, 56000.0, 58000.0, 60000.0, 65000.0, 70000.0, 75000.0, 80000.0, 90000.0, 100000.0, 110000.0, 120000.0, 160000.0};
364 const std::vector<std::vector<double>> parameters = {{0.0000}, {1.3500}, {1.6500}, {2.0250}, {2.3250}, {2.7000}, {2.7750}, {3.0000}, {3.3000}, {3.5250}, {3.6000}, {3.2250}, {3.3750}, {3.4500}, {3.5250}, {3.3000}, {3.3750}, {3.4500}, {3.5250}, {3.6000}, {3.3750}, {3.4500}, {3.5250}, {3.6000}, {3.6750}, {3.4500}, {3.5250}, {3.6000}, {3.6750}, {3.7500}, {3.8250}, {3.9000}, {3.9750}, {3.5250}, {3.6000}, {3.6750}, {3.7500}, {3.8250}, {3.9000}, {3.5250}, {3.6000}, {3.6750}, {3.7500}, {3.8250}, {3.9000}, {4.0500}, {4.1250}, {3.7500}, {3.8250}, {4.0500}, {3.3000}, {3.4500}, {3.1500}, {3.0750}};
365 const std::string cutFunction = createPieceWisePolinomialFunction(boundaries, parameters, true);
366 wp->addCut(std::make_unique<IsolationConditionCombined>("R2PLITVeryLoose", isoTypes,
367 std::make_unique<TF2>("muonPLIT", "TMath::Log(x / y)"),
368 cutFunction,
369 m_isoDecSuffix, true));
370 } else {
371 ATH_MSG_ERROR("Unknown muon isolation WP: " << muWPname);
372 return StatusCode::FAILURE;
373 }
374 m_muonAccept.addCut(wp->name(), wp->name());
375#ifndef XAOD_STANDALONE
376 addDependencies(m_inMuonContainer, *wp);
377#endif
378 m_muWPs.push_back(std::move(wp));
379 return StatusCode::SUCCESS;
380 }
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:633
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 382 of file IsolationSelectionTool.cxx.

382 {
383 std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(phWPname);
384 if (phWPname == "TightCaloOnly") {
385 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
386 } else if (phWPname == "FixedCutTight") {
387 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
388 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_track20", xAOD::Iso::ptcone20, "0.05*x", false, m_isoDecSuffix));
389 } else if (phWPname == "FixedCutLoose") {
390 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo20", xAOD::Iso::topoetcone20, "0.065*x", false, m_isoDecSuffix));
391 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_track20", xAOD::Iso::ptcone20, "0.05*x", false, m_isoDecSuffix));
392 } else if (phWPname == "Tight") {
393 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
394 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_Tighttrack20",
395 xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.05*x", false, m_isoDecSuffix));
396 } else if (phWPname == "Loose") {
397 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo20", xAOD::Iso::topoetcone20, "0.065*x", false, m_isoDecSuffix));
398 wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_Tighttrack20",
399 xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.05*x", false, m_isoDecSuffix));
400 } else {
401 ATH_MSG_ERROR("Unknown photon isolation WP: " << phWPname);
402 return StatusCode::FAILURE;
403 }
404
405 m_photonAccept.addCut(wp->name(), wp->name());
406#ifndef XAOD_STANDALONE
407 addDependencies(m_inPhotContainer, *wp);
408#endif
409 m_phWPs.push_back(std::move(wp));
410
411 // Return gracefully:
412 return StatusCode::SUCCESS;
413 }
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 484 of file IsolationSelectionTool.cxx.

486 {
487 std::vector<std::unique_ptr<IsolationWP>>* wps(nullptr);
488 asg::AcceptInfo* ac = nullptr;
489 if (ObjType == xAOD::Type::Electron) {
490 if (key == "") key = m_elWPKey;
491 wps = &m_elWPs;
492 ac = &m_electronAccept;
493 } else if (ObjType == xAOD::Type::Muon) {
494 if (key == "") key = m_muWPKey;
495 wps = &m_muWPs;
496 ac = &m_muonAccept;
497 } else if (ObjType == xAOD::Type::Photon) {
498 if (key == "") key = m_phWPKey;
499 wps = &m_phWPs;
500 ac = &m_photonAccept;
501 } else if (ObjType == xAOD::Type::Other) {
502 if (key == "") return StatusCode::FAILURE;
503 wps = &m_objWPs;
504 ac = &m_objAccept;
505 } else {
506 return StatusCode::FAILURE;
507 }
508
509 std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(WPname);
510 if (type == Efficiency) {
511 for (auto& c : cuts) ATH_CHECK(addCutToWP(wp.get(), key, c.first, c.second));
512 } else if (type == Cut) {
513 for (auto& c : cuts) wp->addCut(std::make_unique<IsolationConditionFormula>(xAOD::Iso::toCString(c.first), c.first, c.second));
514 } else {
515 ATH_MSG_ERROR("Unknown isolation WP type -- should not happen.");
516 return StatusCode::FAILURE;
517 }
518
519 ac->addCut(wp->name(), wp->name());
520 wps->push_back(std::move(wp));
521 return StatusCode::SUCCESS;
522 }
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 524 of file IsolationSelectionTool.cxx.

524 {
525 if (ObjType == xAOD::Type::Electron) {
526 return addElectronWP(WP);
527 } else if (ObjType == xAOD::Type::Muon) {
528 return addMuonWP(WP);
529 } else if (ObjType == xAOD::Type::Photon) {
530 return addPhotonWP(WP);
531 }
532
533 return StatusCode::FAILURE;
534 }
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:415
CP::IsolationSelectionTool::addPhotonWP
StatusCode addPhotonWP(const std::string &wpname)
Definition IsolationSelectionTool.cxx:382

◆ addWP() [2/2]

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

Definition at line 535 of file IsolationSelectionTool.cxx.

535 {
536 if (ObjType == xAOD::Type::Electron) {
537 m_electronAccept.addCut(wp->name(), wp->name());
538 m_elWPs.push_back(std::move(wp));
539 } else if (ObjType == xAOD::Type::Muon) {
540 m_muonAccept.addCut(wp->name(), wp->name());
541 m_muWPs.push_back(std::move(wp));
542
543 } else if (ObjType == xAOD::Type::Photon) {
544 m_photonAccept.addCut(wp->name(), wp->name());
545 m_phWPs.push_back(std::move(wp));
546
547 } else if (ObjType == xAOD::Type::Other) {
548 m_objAccept.addCut(wp->name(), wp->name());
549 m_objWPs.push_back(std::move(wp));
550 } else {
551 return StatusCode::FAILURE;
552 }
553
554 return StatusCode::SUCCESS;
555 }

◆ 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 633 of file IsolationSelectionTool.cxx.

633 {
634
635 if (isOpen && boundaries.size() != parameters.size() - 1) {
636 ATH_MSG_ERROR("The number of region boundaries must be one less than the number of parameters for the piecewise polynomial function.");
637 return "";
638 } else if (!isOpen && boundaries.size() != parameters.size() + 1) {
639 ATH_MSG_ERROR("The number of region boundaries must be one more than the number of parameters for the piecewise polynomial function.");
640 return "";
641 }
642
643 std::ostringstream oss;
644 oss << std::setprecision(16);
645
646 // a lambda for the polynomial expression
647 // one could remove the zeroes in the parameters vector
648 auto polynomial = [](const std::vector<double>& params) {
649 std::ostringstream oss;
650 oss << std::setprecision(16);
651 oss << "(";
652 for (size_t i = 0; i < params.size(); ++i) {
653 if (i > 0) oss << " + ";
654 if (i == 0) {
655 oss << params[i]; // constant term
656 } else if (i == 1) {
657 oss << params[i] << " * x"; // linear term
658 } else {// higher order terms
659 oss << params[i] << " * pow(x, " << i << ")"; // higher order terms
660 }
661 }
662 oss << ")";
663 return oss.str();
664 };
665
666 // Start the function definition, using concateation of ternary operators
667 // if isOpen==false, just nullify the function before the first and after the last boundary
668 // just create a copy of params, and insert 0.0 at the beginning and end if isOpen==false
669 std::vector<std::vector<double>> params = parameters;
670 if (!isOpen) {
671 params.insert(params.begin(), {0.0}); // add a zero vector at the beginning
672 params.push_back({0.0}); // add a zero vector at the end
673 }
674
675 // now loop over the boundaries and parameters (we can ignore isOpen finally)
676 for (size_t i = 0; i < boundaries.size(); ++i) {
677 if (i == 0) oss << "(";
678 oss << "(x < " << boundaries[i] << ") ? " << polynomial(params[i]) << " : ";
679 }
680 oss << polynomial(params.back()) << ")"; // last segment, no ternary operator
681
682 return oss.str();
683
684 }
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 557 of file IsolationSelectionTool.cxx.

557 {
558 accept.clear();
559 for (const std::unique_ptr<IsolationWP>& i : WP) {
560 if (i->accept(x)) accept.setCutResult(i->name(), true);
561 }
562 }

◆ 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 628 of file IsolationSelectionTool.cxx.

628{ 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 630 of file IsolationSelectionTool.cxx.

630{ 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 631 of file IsolationSelectionTool.cxx.

631{ 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 626 of file IsolationSelectionTool.cxx.

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