ATLAS Offline Software
Public Types | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
CP::IsolationSelectionTool Class Referenceabstract

#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. More...
 
virtual ~IsolationSelectionTool ()
 Destructor. More...
 
virtual StatusCode initialize () override
 Function initialising the tool. More...
 
virtual asg::AcceptData accept (const xAOD::Photon &x) const override
 Declare the interface that the class provides. More...
 
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 =0
 Print the state of the tool. More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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 More...
 
std::unique_ptr< TFile > m_calibFile {nullptr}
 
std::vector< std::unique_ptr< IsolationWP > > m_muWPs {}
 internal use More...
 
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. More...
 
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. More...
 
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. More...
 
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) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
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 587 of file IsolationSelectionTool.cxx.

587  {
588  if (x.type == xAOD::Type::Electron) {
589  asg::AcceptData accept(&m_electronAccept);
590  evaluateWP(x, m_elWPs, accept);
591  return accept;
592  } else if (x.type == xAOD::Type::Muon) {
593  asg::AcceptData accept(&m_muonAccept);
594  evaluateWP(x, m_muWPs, accept);
595  return accept;
596  } else if (x.type == xAOD::Type::Photon) {
597  asg::AcceptData accept(&m_photonAccept);
598  evaluateWP(x, m_phWPs, accept);
599  return accept;
600  } else {
601  asg::AcceptData accept(&m_objAccept);
602  evaluateWP(x, m_objWPs, accept);
603  return accept;
604  }
605  return asg::AcceptData(&m_objAccept);
606  }

◆ accept() [2/5]

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

Implements CP::IIsolationSelectionTool.

Definition at line 551 of file IsolationSelectionTool.cxx.

551  {
552  asg::AcceptData accept(&m_electronAccept);
553  evaluateWP(x, m_elWPs, accept);
554  return accept;
555  }

◆ accept() [3/5]

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

Implements CP::IIsolationSelectionTool.

Definition at line 563 of file IsolationSelectionTool.cxx.

563  {
564  if (x.type() == xAOD::Type::Electron) {
565  asg::AcceptData accept(&m_electronAccept);
566  evaluateWP(x, m_elWPs, accept);
567  return accept;
568  } else if (x.type() == xAOD::Type::Muon) {
569  asg::AcceptData accept(&m_muonAccept);
570  evaluateWP(x, m_muWPs, accept);
571  return accept;
572  } else if (x.type() == xAOD::Type::Photon) {
573  asg::AcceptData accept(&m_photonAccept);
574  evaluateWP(x, m_phWPs, accept);
575  return accept;
576  }
577 
578  else if (m_iparAcceptInfo && m_iparWPs) {
579  asg::AcceptData accept(m_iparAcceptInfo);
580  evaluateWP(x, *m_iparWPs, accept);
581  return accept;
582  }
583  ATH_MSG_ERROR("Someting here makes really no sense");
584  return asg::AcceptData(&m_objAccept);
585  }

◆ accept() [4/5]

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

Implements CP::IIsolationSelectionTool.

Definition at line 557 of file IsolationSelectionTool.cxx.

557  {
558  asg::AcceptData accept(&m_muonAccept);
559  evaluateWP(x, m_muWPs, accept);
560  return accept;
561  }

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

545  {
546  asg::AcceptData accept(&m_photonAccept);
547  evaluateWP(x, m_phWPs, accept);
548  return accept;
549  }

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

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

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

◆ addElectronWP()

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

Definition at line 397 of file IsolationSelectionTool.cxx.

397  {
398  std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(elWPname);
399 
400  if (elWPname == "HighPtCaloOnly") {
401  wp->addCut(std::make_unique<IsolationConditionFormula>("FCHighPtCaloOnly_calo", xAOD::Iso::topoetcone20,
402  "std::max(0.015*x,3.5E3)", false, m_isoDecSuffix)); // units are MeV!
403  } else if (elWPname == "Tight_VarRad") {
404  wp->addCut(std::make_unique<IsolationConditionFormula>(
405  "ElecTight_track", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*x", false, m_isoDecSuffix));
406  wp->addCut(std::make_unique<IsolationConditionFormula>("ElecTight_calo", xAOD::Iso::topoetcone20, "0.06*x", false, m_isoDecSuffix));
407  } else if (elWPname == "Loose_VarRad") {
408  wp->addCut(std::make_unique<IsolationConditionFormula>(
409  "ElecLoose_track", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.15*x", false, m_isoDecSuffix));
410  wp->addCut(std::make_unique<IsolationConditionFormula>("ElecLoose_calo", xAOD::Iso::topoetcone20, "0.20*x", false, m_isoDecSuffix));
411  } else if (elWPname == "TightTrackOnly_VarRad") {
412  wp->addCut(std::make_unique<IsolationConditionFormula>(
413  "ElecTightTrackOnly", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*x", false, m_isoDecSuffix));
414  } else if (elWPname == "TightTrackOnly_FixedRad") {
415  wp->addCut(std::make_unique<IsolationConditionFormula>(
416  "ElecTightTrackOnly_lowPt", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*(x>50e3?1e9:x)", false, m_isoDecSuffix));
417  wp->addCut(std::make_unique<IsolationConditionFormula>(
418  "ElecTightTrackOnly_highPt", xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*(x>50e3?x:1e9)", false, m_isoDecSuffix));
419  } else if (elWPname == "PflowTight_FixedRad") {
420  std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
421  xAOD::Iso::neflowisol20};
422  std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
423  xAOD::Iso::neflowisol20};
424  wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowTightLowPt", isoTypesLowPt,
425  std::make_unique<TF2>("pflowTFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
426  "0.045*(x>50e3?1e9:x)", m_isoDecSuffix));
427  wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowTightHighPt", isoTypesHighPt,
428  std::make_unique<TF2>("pflowTFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
429  "0.045*(x>50e3?x:1e9)", m_isoDecSuffix));
430  } else if (elWPname == "PflowTight") {
431  std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
432  xAOD::Iso::neflowisol20};
433  wp->addCut(std::make_unique<IsolationConditionCombined>(
434  "ElecPFlowTight", isoTypes, std::make_unique<TF2>("pflowLFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.045*x", m_isoDecSuffix));
435  } else if (elWPname == "PflowLoose_FixedRad") {
436  std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
437  xAOD::Iso::neflowisol20};
438  std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
439  xAOD::Iso::neflowisol20};
440  wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowLooseLowPt", isoTypesLowPt,
441  std::make_unique<TF2>("pflowLFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
442  "0.16*(x>50e3?1e9:x)", m_isoDecSuffix));
443  wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowLooseHighPt", isoTypesHighPt,
444  std::make_unique<TF2>("pflowLFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
445  "0.16*(x>50e3?x:1e9)", m_isoDecSuffix));
446  } else if (elWPname == "PflowLoose") {
447  std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
448  xAOD::Iso::neflowisol20};
449  wp->addCut(std::make_unique<IsolationConditionCombined>(
450  "ElecPFlowLoose", isoTypes, std::make_unique<TF2>("pflowLFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.16*x", m_isoDecSuffix));
451  } else {
452  ATH_MSG_ERROR("Unknown electron isolation WP: " << elWPname);
453  return StatusCode::FAILURE;
454  }
455 
456  m_electronAccept.addCut(wp->name(), wp->name());
457 #ifndef XAOD_STANDALONE
458  addDependencies(m_inElecContainer, *wp);
459 #endif
460  m_elWPs.push_back(std::move(wp));
461 
462  // Return gracefully:
463  return StatusCode::SUCCESS;
464  }

◆ 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 {
353  ATH_MSG_ERROR("Unknown muon isolation WP: " << muWPname);
354  return StatusCode::FAILURE;
355  }
356  m_muonAccept.addCut(wp->name(), wp->name());
357 #ifndef XAOD_STANDALONE
358  addDependencies(m_inMuonContainer, *wp);
359 #endif
360  m_muWPs.push_back(std::move(wp));
361  return StatusCode::SUCCESS;
362  }

◆ addPhotonWP()

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

Definition at line 364 of file IsolationSelectionTool.cxx.

364  {
365  std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(phWPname);
366  if (phWPname == "TightCaloOnly") {
367  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
368  } else if (phWPname == "FixedCutTight") {
369  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
370  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_track20", xAOD::Iso::ptcone20, "0.05*x", false, m_isoDecSuffix));
371  } else if (phWPname == "FixedCutLoose") {
372  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo20", xAOD::Iso::topoetcone20, "0.065*x", false, m_isoDecSuffix));
373  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_track20", xAOD::Iso::ptcone20, "0.05*x", false, m_isoDecSuffix));
374  } else if (phWPname == "Tight") {
375  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
376  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_Tighttrack20",
377  xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.05*x", false, m_isoDecSuffix));
378  } else if (phWPname == "Loose") {
379  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo20", xAOD::Iso::topoetcone20, "0.065*x", false, m_isoDecSuffix));
380  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_Tighttrack20",
381  xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.05*x", false, m_isoDecSuffix));
382  } else {
383  ATH_MSG_ERROR("Unknown photon isolation WP: " << phWPname);
384  return StatusCode::FAILURE;
385  }
386 
387  m_photonAccept.addCut(wp->name(), wp->name());
388 #ifndef XAOD_STANDALONE
389  addDependencies(m_inPhotContainer, *wp);
390 #endif
391  m_phWPs.push_back(std::move(wp));
392 
393  // Return gracefully:
394  return StatusCode::SUCCESS;
395  }

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

468  {
469  std::vector<std::unique_ptr<IsolationWP>>* wps(nullptr);
470  asg::AcceptInfo* ac = nullptr;
471  if (ObjType == xAOD::Type::Electron) {
472  if (key == "") key = m_elWPKey;
473  wps = &m_elWPs;
474  ac = &m_electronAccept;
475  } else if (ObjType == xAOD::Type::Muon) {
476  if (key == "") key = m_muWPKey;
477  wps = &m_muWPs;
478  ac = &m_muonAccept;
479  } else if (ObjType == xAOD::Type::Photon) {
480  if (key == "") key = m_phWPKey;
481  wps = &m_phWPs;
482  ac = &m_photonAccept;
483  } else if (ObjType == xAOD::Type::Other) {
484  if (key == "") return StatusCode::FAILURE;
485  wps = &m_objWPs;
486  ac = &m_objAccept;
487  } else {
488  return StatusCode::FAILURE;
489  }
490 
491  std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(WPname);
492  if (type == Efficiency) {
493  for (auto& c : cuts) ATH_CHECK(addCutToWP(wp.get(), key, c.first, c.second));
494  } else if (type == Cut) {
495  for (auto& c : cuts) wp->addCut(std::make_unique<IsolationConditionFormula>(xAOD::Iso::toCString(c.first), c.first, c.second));
496  } else {
497  ATH_MSG_ERROR("Unknown isolation WP type -- should not happen.");
498  return StatusCode::FAILURE;
499  }
500 
501  ac->addCut(wp->name(), wp->name());
502  wps->push_back(std::move(wp));
503  return StatusCode::SUCCESS;
504  }

◆ addWP() [1/2]

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

Definition at line 506 of file IsolationSelectionTool.cxx.

506  {
507  if (ObjType == xAOD::Type::Electron) {
508  return addElectronWP(WP);
509  } else if (ObjType == xAOD::Type::Muon) {
510  return addMuonWP(WP);
511  } else if (ObjType == xAOD::Type::Photon) {
512  return addPhotonWP(WP);
513  }
514 
515  return StatusCode::FAILURE;
516  }

◆ addWP() [2/2]

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

Definition at line 517 of file IsolationSelectionTool.cxx.

517  {
518  if (ObjType == xAOD::Type::Electron) {
519  m_electronAccept.addCut(wp->name(), wp->name());
520  m_elWPs.push_back(std::move(wp));
521  } else if (ObjType == xAOD::Type::Muon) {
522  m_muonAccept.addCut(wp->name(), wp->name());
523  m_muWPs.push_back(std::move(wp));
524 
525  } else if (ObjType == xAOD::Type::Photon) {
526  m_photonAccept.addCut(wp->name(), wp->name());
527  m_phWPs.push_back(std::move(wp));
528 
529  } else if (ObjType == xAOD::Type::Other) {
530  m_objAccept.addCut(wp->name(), wp->name());
531  m_objWPs.push_back(std::move(wp));
532  } else {
533  return StatusCode::FAILURE;
534  }
535 
536  return StatusCode::SUCCESS;
537  }

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

615  {
616 
617  if (isOpen && boundaries.size() != parameters.size() - 1) {
618  ATH_MSG_ERROR("The number of region boundaries must be one less than the number of parameters for the piecewise polynomial function.");
619  return "";
620  } else if (!isOpen && boundaries.size() != parameters.size() + 1) {
621  ATH_MSG_ERROR("The number of region boundaries must be one more than the number of parameters for the piecewise polynomial function.");
622  return "";
623  }
624 
625  std::ostringstream oss;
626  oss << std::setprecision(16);
627 
628  // a lambda for the polynomial expression
629  // one could remove the zeroes in the parameters vector
630  auto polynomial = [](const std::vector<double>& params) {
631  std::ostringstream oss;
632  oss << std::setprecision(16);
633  oss << "(";
634  for (size_t i = 0; i < params.size(); ++i) {
635  if (i > 0) oss << " + ";
636  if (i == 0) {
637  oss << params[i]; // constant term
638  } else if (i == 1) {
639  oss << params[i] << " * x"; // linear term
640  } else {// higher order terms
641  oss << params[i] << " * pow(x, " << i << ")"; // higher order terms
642  }
643  }
644  oss << ")";
645  return oss.str();
646  };
647 
648  // Start the function definition, using concateation of ternary operators
649  // if isOpen==false, just nullify the function before the first and after the last boundary
650  // just create a copy of params, and insert 0.0 at the beginning and end if isOpen==false
651  std::vector<std::vector<double>> params = parameters;
652  if (!isOpen) {
653  params.insert(params.begin(), {0.0}); // add a zero vector at the beginning
654  params.push_back({0.0}); // add a zero vector at the end
655  }
656 
657  // now loop over the boundaries and parameters (we can ignore isOpen finally)
658  for (size_t i = 0; i < boundaries.size(); ++i) {
659  if (i == 0) oss << "(";
660  oss << "(x < " << boundaries[i] << ") ? " << polynomial(params[i]) << " : ";
661  }
662  oss << polynomial(params.back()) << ")"; // last segment, no ternary operator
663 
664  return oss.str();
665 
666  }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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  }

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

539  {
540  accept.clear();
541  for (const std::unique_ptr<IsolationWP>& i : WP) {
542  if (i->accept(x)) accept.setCutResult(i->name(), true);
543  }
544  }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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 610 of file IsolationSelectionTool.cxx.

610 { 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  }

◆ getMuonAcceptInfo()

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

Implements CP::IIsolationSelectionTool.

Definition at line 612 of file IsolationSelectionTool.cxx.

612 { 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 613 of file IsolationSelectionTool.cxx.

613 { 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 608 of file IsolationSelectionTool.cxx.

608 { 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 ( )
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
81  return StatusCode::SUCCESS;
83  }

◆ 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() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

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

◆ 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() [1/2]

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

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const
pure virtualinherited

Print the state of the tool.

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

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

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

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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  }

Member Data Documentation

◆ m_calibFile

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

Definition at line 94 of file IsolationSelectionTool.h.

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

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

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

◆ m_electronAccept

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

Definition at line 104 of file IsolationSelectionTool.h.

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

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

◆ m_elWPs

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

Definition at line 98 of file IsolationSelectionTool.h.

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

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

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

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

◆ m_Interp

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

Definition at line 115 of file IsolationSelectionTool.h.

◆ m_iparAcceptInfo

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

Definition at line 110 of file IsolationSelectionTool.h.

◆ m_iparWPs

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

Iparticle interface.

Definition at line 109 of file IsolationSelectionTool.h.

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

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

◆ m_muonAccept

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

Definition at line 105 of file IsolationSelectionTool.h.

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

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

◆ m_muWPs

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

internal use

Definition at line 97 of file IsolationSelectionTool.h.

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

◆ m_objAccept

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

Definition at line 106 of file IsolationSelectionTool.h.

◆ m_objWPs

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

Definition at line 100 of file IsolationSelectionTool.h.

◆ m_photonAccept

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

AcceptInfo's.

Definition at line 103 of file IsolationSelectionTool.h.

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

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

◆ m_phWPs

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

Definition at line 99 of file IsolationSelectionTool.h.

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

◆ 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:
CP::IsolationSelectionTool::m_elWPKey
Gaudi::Property< std::string > m_elWPKey
Definition: IsolationSelectionTool.h:84
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:615
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
CP::IsolationSelectionTool::m_isoDecors
SG::ReadDecorHandleKeyArray< xAOD::IParticleContainer > m_isoDecors
Definition: IsolationSelectionTool.h:118
CP::IsolationSelectionTool::m_photonAccept
asg::AcceptInfo m_photonAccept
AcceptInfo's.
Definition: IsolationSelectionTool.h:103
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
xAOD::Iso::topoetcone20
@ topoetcone20
Topo-cluster ET-sum.
Definition: IsolationType.h:48
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
xAOD::Iso::neflowisol20
@ neflowisol20
Neutral eflow isolation.
Definition: IsolationType.h:64
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
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
SG::AuxTypeRegistry::instance
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Definition: AuxTypeRegistry.cxx:639
CP::IsolationSelectionTool::evaluateWP
void evaluateWP(const T &x, const std::vector< std::unique_ptr< IsolationWP >> &WP, asg::AcceptData &accept) const
Definition: IsolationSelectionTool.cxx:539
IsoCloseByCorrectionTest.WP
WP
Definition: IsoCloseByCorrectionTest.py:56
CP::IsolationSelectionTool::m_electronAccept
asg::AcceptInfo m_electronAccept
Definition: IsolationSelectionTool.h:104
xAOD::Iso::ptcone20
@ ptcone20
Track isolation.
Definition: IsolationType.h:40
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
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
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
python.HION12.expression
string expression
Definition: HION12.py:55
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
x
#define x
CP::IsolationSelectionTool::m_inMuonContainer
Gaudi::Property< std::string > m_inMuonContainer
Properties to declare the data dependencies to the avalanche scheduler.
Definition: IsolationSelectionTool.h:121
CP::IsolationSelectionTool::m_objWPs
std::vector< std::unique_ptr< IsolationWP > > m_objWPs
Definition: IsolationSelectionTool.h:100
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
Cut
Definition: SUSYToolsAlg.cxx:65
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
CP::IsolationSelectionTool::m_inElecContainer
Gaudi::Property< std::string > m_inElecContainer
Definition: IsolationSelectionTool.h:122
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
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
CP::IsolationSelectionTool::m_elWPname
Gaudi::Property< std::string > m_elWPname
Definition: IsolationSelectionTool.h:77
CP::IsolationSelectionTool::Efficiency
@ Efficiency
Definition: IsolationSelectionTool.h:39
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CP::IsolationSelectionTool::m_calibFileName
Gaudi::Property< std::string > m_calibFileName
input file
Definition: IsolationSelectionTool.h:93
asg::AcceptInfo
Definition: AcceptInfo.h:28
CP::IsolationSelectionTool::m_elWPvec
Gaudi::Property< std::vector< std::string > > m_elWPvec
Definition: IsolationSelectionTool.h:80
CP::IsolationSelectionTool::m_phWPs
std::vector< std::unique_ptr< IsolationWP > > m_phWPs
Definition: IsolationSelectionTool.h:99
lumiFormat.i
int i
Definition: lumiFormat.py:85
CP::IsolationSelectionTool::addMuonWP
StatusCode addMuonWP(const std::string &wpname)
Definition: IsolationSelectionTool.cxx:143
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
CP::IsolationSelectionTool::m_isoDecSuffix
Gaudi::Property< std::string > m_isoDecSuffix
Definition: IsolationSelectionTool.h:88
CP::IsolationSelectionTool::m_muWPs
std::vector< std::unique_ptr< IsolationWP > > m_muWPs
internal use
Definition: IsolationSelectionTool.h:97
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:92
xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
@ ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
Definition: IsolationType.h:112
CP::IsolationSelectionTool::m_inPhotContainer
Gaudi::Property< std::string > m_inPhotContainer
Definition: IsolationSelectionTool.h:123
CP::IsolationSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::Photon &x) const override
Declare the interface that the class provides.
Definition: IsolationSelectionTool.cxx:545
AthenaPoolTestRead.acc
acc
Definition: AthenaPoolTestRead.py:16
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CP::IsolationSelectionTool::addPhotonWP
StatusCode addPhotonWP(const std::string &wpname)
Definition: IsolationSelectionTool.cxx:364
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
PlotSFuncertainty.wp
wp
Definition: PlotSFuncertainty.py:112
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
@ ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
Definition: IsolationType.h:101
CP::IsolationSelectionTool::m_objAccept
asg::AcceptInfo m_objAccept
Definition: IsolationSelectionTool.h:106
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
CP::IsolationSelectionTool::m_phWPKey
Gaudi::Property< std::string > m_phWPKey
Definition: IsolationSelectionTool.h:86
CP::IsolationSelectionTool::m_phWPname
Gaudi::Property< std::string > m_phWPname
Definition: IsolationSelectionTool.h:78
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
CP::IsolationSelectionTool::m_muWPname
Gaudi::Property< std::string > m_muWPname
Definition: IsolationSelectionTool.h:76
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500
@ ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500
Definition: IsolationType.h:98
CP::IsolationSelectionTool::m_doInterpM
Gaudi::Property< bool > m_doInterpM
Definition: IsolationSelectionTool.h:113
CP::IsolationSelectionTool::m_calibFile
std::unique_ptr< TFile > m_calibFile
Definition: IsolationSelectionTool.h:94
CP::IsolationSelectionTool::m_muWPKey
Gaudi::Property< std::string > m_muWPKey
Definition: IsolationSelectionTool.h:83
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:283
Muon
struct TBPatternUnitContext Muon
CP::IsolationSelectionTool::addElectronWP
StatusCode addElectronWP(const std::string &wpname)
Definition: IsolationSelectionTool.cxx:397
LArG4AODNtuplePlotter.varname
def varname(hname)
Definition: LArG4AODNtuplePlotter.py:37
Interp3D::VetoInterp
Definition: Interp3D.h:15
a
TList * a
Definition: liststreamerinfos.cxx:10
asg::AcceptData::setCutResult
void setCutResult(const std::string &cutName, bool cutResult)
Set the result of a cut, based on the cut name (safer)
Definition: AcceptData.h:134
CP::IsolationSelectionTool::m_muonAccept
asg::AcceptInfo m_muonAccept
Definition: IsolationSelectionTool.h:105
h
asg::AcceptData::clear
void clear()
Clear all bits.
Definition: AcceptData.h:54
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000
@ ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000
Definition: IsolationType.h:77
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CP::IsolationSelectionTool::m_Interp
std::shared_ptr< Interp3D > m_Interp
Definition: IsolationSelectionTool.h:115
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:23
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
CP::IsolationSelectionTool::m_iparWPs
std::vector< std::unique_ptr< IsolationWP > > * m_iparWPs
Iparticle interface.
Definition: IsolationSelectionTool.h:109
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
CP::IsolationSelectionTool::m_phWPvec
Gaudi::Property< std::vector< std::string > > m_phWPvec
Definition: IsolationSelectionTool.h:81
CP::IsolationSelectionTool::addDependencies
void addDependencies(const std::string &container, const IsolationWP &wp)
Definition: IsolationSelectionTool.cxx:85
veto
std::vector< std::string > veto
these patterns are anded
Definition: listroot.cxx:191
CP::IsolationSelectionTool::m_doInterpE
Gaudi::Property< bool > m_doInterpE
Definition: IsolationSelectionTool.h:114
xAOD::Iso::topoetcone40
@ topoetcone40
Definition: IsolationType.h:50
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
asg::AcceptData
Definition: AcceptData.h:30
CP::IsolationSelectionTool::m_muWPvec
Gaudi::Property< std::vector< std::string > > m_muWPvec
Definition: IsolationSelectionTool.h:79
SG::DataProxy
Definition: DataProxy.h:45
python.compressB64.c
def c
Definition: compressB64.py:93
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500
@ ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500
Definition: IsolationType.h:74
xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000
@ ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000
Definition: IsolationType.h:88
histogram
std::string histogram
Definition: chains.cxx:52
CP::IsolationSelectionTool::m_elWPs
std::vector< std::unique_ptr< IsolationWP > > m_elWPs
Definition: IsolationSelectionTool.h:98
CP::IsolationSelectionTool::m_iparAcceptInfo
asg::AcceptInfo * m_iparAcceptInfo
Definition: IsolationSelectionTool.h:110
fitman.k
k
Definition: fitman.py:528
asg::AcceptInfo::addCut
int addCut(const std::string &cutName, const std::string &cutDescription)
Add a cut; returning the cut position.
Definition: AcceptInfo.h:53
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Tue Sep 2 2025 22:08:37 for ATLAS Offline Software by   doxygen 1.8.18