ATLAS Offline Software
IsolationSelectionTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3  */
4 
5 #include <IsolationSelection/Interp3D.h>
6 #include <IsolationSelection/IsolationConditionCombined.h>
7 #include <IsolationSelection/IsolationConditionFormula.h>
8 #include <IsolationSelection/IsolationConditionHist.h>
9 #include <IsolationSelection/IsolationSelectionTool.h>
10 #include <TF2.h>
11 #include <TFile.h>
12 #include <TH3.h>
13 #include <TObjString.h>
14 #include <TROOT.h>
15 #include <xAODPrimitives/IsolationType.h>
16 
17 #include "PathResolver/PathResolver.h"
18 
19 namespace CP {
20  IsolationSelectionTool::IsolationSelectionTool(const std::string& name) : asg::AsgTool(name) {}
21  const std::vector<std::unique_ptr<IsolationWP>>& IsolationSelectionTool::getMuonWPs() const { return m_muWPs; }
22  const std::vector<std::unique_ptr<IsolationWP>>& IsolationSelectionTool::getElectronWPs() const { return m_elWPs; }
23  const std::vector<std::unique_ptr<IsolationWP>>& IsolationSelectionTool::getPhotonWPs() const { return m_phWPs; }
24  const std::vector<std::unique_ptr<IsolationWP>>& IsolationSelectionTool::getObjWPs() const { return m_objWPs; }
25  IsolationSelectionTool::~IsolationSelectionTool() = default;
26 
27  StatusCode IsolationSelectionTool::initialize() {
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  }
84 
85  void IsolationSelectionTool::addDependencies(const std::string& container, const IsolationWP& wp) {
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  }
93 
94  StatusCode IsolationSelectionTool::setIParticleCutsFrom(xAOD::Type::ObjectType ObjType) {
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  }
110 
111  StatusCode IsolationSelectionTool::addCutToWP(IsolationWP* wp, const std::string& key_in, const xAOD::Iso::IsolationType t,
112  const std::string& expression, const xAOD::Iso::IsolationType isoCutRemap) {
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  }
137 
138  StatusCode IsolationSelectionTool::addCutToWP(IsolationWP* wp, const std::string& key, const xAOD::Iso::IsolationType t,
139  const std::string& expression) {
140  return addCutToWP(wp, key, t, expression, t);
141  }
142 
143  StatusCode IsolationSelectionTool::addMuonWP(const std::string& muWPname) {
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 {
209  ATH_MSG_ERROR("Unknown muon isolation WP: " << muWPname);
210  return StatusCode::FAILURE;
211  }
212  m_muonAccept.addCut(wp->name(), wp->name());
213 #ifndef XAOD_STANDALONE
214  addDependencies(m_inMuonContainer, *wp);
215 #endif
216  m_muWPs.push_back(std::move(wp));
217  return StatusCode::SUCCESS;
218  }
219 
220  StatusCode IsolationSelectionTool::addPhotonWP(const std::string& phWPname) {
221  std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(phWPname);
222  if (phWPname == "TightCaloOnly") {
223  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
224  } else if (phWPname == "FixedCutTight") {
225  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
226  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_track20", xAOD::Iso::ptcone20, "0.05*x", false, m_isoDecSuffix));
227  } else if (phWPname == "FixedCutLoose") {
228  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo20", xAOD::Iso::topoetcone20, "0.065*x", false, m_isoDecSuffix));
229  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_track20", xAOD::Iso::ptcone20, "0.05*x", false, m_isoDecSuffix));
230  } else if (phWPname == "Tight") {
231  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo40", xAOD::Iso::topoetcone40, "0.022*x+2450", false, m_isoDecSuffix));
232  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_Tighttrack20",
233  xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.05*x", false, m_isoDecSuffix));
234  } else if (phWPname == "Loose") {
235  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_calo20", xAOD::Iso::topoetcone20, "0.065*x", false, m_isoDecSuffix));
236  wp->addCut(std::make_unique<IsolationConditionFormula>("PhFixedCut_Tighttrack20",
237  xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000, "0.05*x", false, m_isoDecSuffix));
238  } else {
239  ATH_MSG_ERROR("Unknown photon isolation WP: " << phWPname);
240  return StatusCode::FAILURE;
241  }
242 
243  m_photonAccept.addCut(wp->name(), wp->name());
244 #ifndef XAOD_STANDALONE
245  addDependencies(m_inPhotContainer, *wp);
246 #endif
247  m_phWPs.push_back(std::move(wp));
248 
249  // Return gracefully:
250  return StatusCode::SUCCESS;
251  }
252 
253  StatusCode IsolationSelectionTool::addElectronWP(const std::string& elWPname) {
254  std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(elWPname);
255 
256  if (elWPname == "HighPtCaloOnly") {
257  wp->addCut(std::make_unique<IsolationConditionFormula>("FCHighPtCaloOnly_calo", xAOD::Iso::topoetcone20,
258  "std::max(0.015*x,3.5E3)", false, m_isoDecSuffix)); // units are MeV!
259  } else if (elWPname == "Tight_VarRad") {
260  wp->addCut(std::make_unique<IsolationConditionFormula>(
261  "ElecTight_track", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*x", false, m_isoDecSuffix));
262  wp->addCut(std::make_unique<IsolationConditionFormula>("ElecTight_calo", xAOD::Iso::topoetcone20, "0.06*x", false, m_isoDecSuffix));
263  } else if (elWPname == "Loose_VarRad") {
264  wp->addCut(std::make_unique<IsolationConditionFormula>(
265  "ElecLoose_track", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.15*x", false, m_isoDecSuffix));
266  wp->addCut(std::make_unique<IsolationConditionFormula>("ElecLoose_calo", xAOD::Iso::topoetcone20, "0.20*x", false, m_isoDecSuffix));
267  } else if (elWPname == "TightTrackOnly_VarRad") {
268  wp->addCut(std::make_unique<IsolationConditionFormula>(
269  "ElecTightTrackOnly", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*x", false, m_isoDecSuffix));
270  } else if (elWPname == "TightTrackOnly_FixedRad") {
271  wp->addCut(std::make_unique<IsolationConditionFormula>(
272  "ElecTightTrackOnly_lowPt", xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*(x>50e3?1e9:x)", false, m_isoDecSuffix));
273  wp->addCut(std::make_unique<IsolationConditionFormula>(
274  "ElecTightTrackOnly_highPt", xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000, "0.06*(x>50e3?x:1e9)", false, m_isoDecSuffix));
275  } else if (elWPname == "PflowTight_FixedRad") {
276  std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
277  xAOD::Iso::neflowisol20};
278  std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
279  xAOD::Iso::neflowisol20};
280  wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowTightLowPt", isoTypesLowPt,
281  std::make_unique<TF2>("pflowTFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
282  "0.045*(x>50e3?1e9:x)", m_isoDecSuffix));
283  wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowTightHighPt", isoTypesHighPt,
284  std::make_unique<TF2>("pflowTFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
285  "0.045*(x>50e3?x:1e9)", m_isoDecSuffix));
286  } else if (elWPname == "PflowTight") {
287  std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
288  xAOD::Iso::neflowisol20};
289  wp->addCut(std::make_unique<IsolationConditionCombined>(
290  "ElecPFlowTight", isoTypes, std::make_unique<TF2>("pflowLFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.045*x", m_isoDecSuffix));
291  } else if (elWPname == "PflowLoose_FixedRad") {
292  std::vector<xAOD::Iso::IsolationType> isoTypesHighPt{xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
293  xAOD::Iso::neflowisol20};
294  std::vector<xAOD::Iso::IsolationType> isoTypesLowPt{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
295  xAOD::Iso::neflowisol20};
296  wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowLooseLowPt", isoTypesLowPt,
297  std::make_unique<TF2>("pflowLFunctionLowPt", "fabs(x)+0.4*(y>0?y:0)"),
298  "0.16*(x>50e3?1e9:x)", m_isoDecSuffix));
299  wp->addCut(std::make_unique<IsolationConditionCombined>("ElecPFlowLooseHighPt", isoTypesHighPt,
300  std::make_unique<TF2>("pflowLFunctionHighPt", "fabs(x)+0.4*(y>0?y:0)"),
301  "0.16*(x>50e3?x:1e9)", m_isoDecSuffix));
302  } else if (elWPname == "PflowLoose") {
303  std::vector<xAOD::Iso::IsolationType> isoTypes{xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,
304  xAOD::Iso::neflowisol20};
305  wp->addCut(std::make_unique<IsolationConditionCombined>(
306  "ElecPFlowLoose", isoTypes, std::make_unique<TF2>("pflowLFunction", "fabs(x)+0.4*(y>0?y:0)"), "0.16*x", m_isoDecSuffix));
307  } else {
308  ATH_MSG_ERROR("Unknown electron isolation WP: " << elWPname);
309  return StatusCode::FAILURE;
310  }
311 
312  m_electronAccept.addCut(wp->name(), wp->name());
313 #ifndef XAOD_STANDALONE
314  addDependencies(m_inElecContainer, *wp);
315 #endif
316  m_elWPs.push_back(std::move(wp));
317 
318  // Return gracefully:
319  return StatusCode::SUCCESS;
320  }
321 
322  StatusCode IsolationSelectionTool::addUserDefinedWP(const std::string& WPname, xAOD::Type::ObjectType ObjType,
323  std::vector<std::pair<xAOD::Iso::IsolationType, std::string>>& cuts,
324  std::string key, IsoWPType type) {
325  std::vector<std::unique_ptr<IsolationWP>>* wps(nullptr);
326  asg::AcceptInfo* ac = nullptr;
327  if (ObjType == xAOD::Type::Electron) {
328  if (key == "") key = m_elWPKey;
329  wps = &m_elWPs;
330  ac = &m_electronAccept;
331  } else if (ObjType == xAOD::Type::Muon) {
332  if (key == "") key = m_muWPKey;
333  wps = &m_muWPs;
334  ac = &m_muonAccept;
335  } else if (ObjType == xAOD::Type::Photon) {
336  if (key == "") key = m_phWPKey;
337  wps = &m_phWPs;
338  ac = &m_photonAccept;
339  } else if (ObjType == xAOD::Type::Other) {
340  if (key == "") return StatusCode::FAILURE;
341  wps = &m_objWPs;
342  ac = &m_objAccept;
343  } else {
344  return StatusCode::FAILURE;
345  }
346 
347  std::unique_ptr<IsolationWP> wp = std::make_unique<IsolationWP>(WPname);
348  if (type == Efficiency) {
349  for (auto& c : cuts) ATH_CHECK(addCutToWP(wp.get(), key, c.first, c.second));
350  } else if (type == Cut) {
351  for (auto& c : cuts) wp->addCut(std::make_unique<IsolationConditionFormula>(xAOD::Iso::toCString(c.first), c.first, c.second));
352  } else {
353  ATH_MSG_ERROR("Unknown isolation WP type -- should not happen.");
354  return StatusCode::FAILURE;
355  }
356 
357  ac->addCut(wp->name(), wp->name());
358  wps->push_back(std::move(wp));
359  return StatusCode::SUCCESS;
360  }
361 
362  StatusCode IsolationSelectionTool::addWP(const std::string& WP, xAOD::Type::ObjectType ObjType) {
363  if (ObjType == xAOD::Type::Electron) {
364  return addElectronWP(WP);
365  } else if (ObjType == xAOD::Type::Muon) {
366  return addMuonWP(WP);
367  } else if (ObjType == xAOD::Type::Photon) {
368  return addPhotonWP(WP);
369  }
370 
371  return StatusCode::FAILURE;
372  }
373  StatusCode IsolationSelectionTool::addWP(std::unique_ptr<IsolationWP> wp, xAOD::Type::ObjectType ObjType) {
374  if (ObjType == xAOD::Type::Electron) {
375  m_electronAccept.addCut(wp->name(), wp->name());
376  m_elWPs.push_back(std::move(wp));
377  } else if (ObjType == xAOD::Type::Muon) {
378  m_muonAccept.addCut(wp->name(), wp->name());
379  m_muWPs.push_back(std::move(wp));
380 
381  } else if (ObjType == xAOD::Type::Photon) {
382  m_photonAccept.addCut(wp->name(), wp->name());
383  m_phWPs.push_back(std::move(wp));
384 
385  } else if (ObjType == xAOD::Type::Other) {
386  m_objAccept.addCut(wp->name(), wp->name());
387  m_objWPs.push_back(std::move(wp));
388  } else {
389  return StatusCode::FAILURE;
390  }
391 
392  return StatusCode::SUCCESS;
393  }
394  template <typename T>
395  void IsolationSelectionTool::evaluateWP(const T& x, const std::vector<std::unique_ptr<IsolationWP>>& WP, asg::AcceptData& accept) const {
396  accept.clear();
397  for (const std::unique_ptr<IsolationWP>& i : WP) {
398  if (i->accept(x)) accept.setCutResult(i->name(), true);
399  }
400  }
401  asg::AcceptData IsolationSelectionTool::accept(const xAOD::Photon& x) const {
402  asg::AcceptData accept(&m_photonAccept);
403  evaluateWP(x, m_phWPs, accept);
404  return accept;
405  }
406 
407  asg::AcceptData IsolationSelectionTool::accept(const xAOD::Electron& x) const {
408  asg::AcceptData accept(&m_electronAccept);
409  evaluateWP(x, m_elWPs, accept);
410  return accept;
411  }
412 
413  asg::AcceptData IsolationSelectionTool::accept(const xAOD::Muon& x) const {
414  asg::AcceptData accept(&m_muonAccept);
415  evaluateWP(x, m_muWPs, accept);
416  return accept;
417  }
418 
419  asg::AcceptData IsolationSelectionTool::accept(const xAOD::IParticle& x) const {
420  if (x.type() == xAOD::Type::Electron) {
421  asg::AcceptData accept(&m_electronAccept);
422  evaluateWP(x, m_elWPs, accept);
423  return accept;
424  } else if (x.type() == xAOD::Type::Muon) {
425  asg::AcceptData accept(&m_muonAccept);
426  evaluateWP(x, m_muWPs, accept);
427  return accept;
428  } else if (x.type() == xAOD::Type::Photon) {
429  asg::AcceptData accept(&m_photonAccept);
430  evaluateWP(x, m_phWPs, accept);
431  return accept;
432  }
433 
434  else if (m_iparAcceptInfo && m_iparWPs) {
435  asg::AcceptData accept(m_iparAcceptInfo);
436  evaluateWP(x, *m_iparWPs, accept);
437  return accept;
438  }
439  ATH_MSG_ERROR("Someting here makes really no sense");
440  return asg::AcceptData(&m_objAccept);
441  }
442 
443  asg::AcceptData IsolationSelectionTool::accept(const strObj& x) const {
444  if (x.type == xAOD::Type::Electron) {
445  asg::AcceptData accept(&m_electronAccept);
446  evaluateWP(x, m_elWPs, accept);
447  return accept;
448  } else if (x.type == xAOD::Type::Muon) {
449  asg::AcceptData accept(&m_muonAccept);
450  evaluateWP(x, m_muWPs, accept);
451  return accept;
452  } else if (x.type == xAOD::Type::Photon) {
453  asg::AcceptData accept(&m_photonAccept);
454  evaluateWP(x, m_phWPs, accept);
455  return accept;
456  } else {
457  asg::AcceptData accept(&m_objAccept);
458  evaluateWP(x, m_objWPs, accept);
459  return accept;
460  }
461  return asg::AcceptData(&m_objAccept);
462  }
463 
464  const asg::AcceptInfo& IsolationSelectionTool::getPhotonAcceptInfo() const { return m_photonAccept; }
465 
466  const asg::AcceptInfo& IsolationSelectionTool::getElectronAcceptInfo() const { return m_electronAccept; }
467 
468  const asg::AcceptInfo& IsolationSelectionTool::getMuonAcceptInfo() const { return m_muonAccept; }
469  const asg::AcceptInfo& IsolationSelectionTool::getObjAcceptInfo() const { return m_objAccept; }
470 
471 } // namespace CP
CP::IsolationSelectionTool::m_elWPKey
Gaudi::Property< std::string > m_elWPKey
Definition: IsolationSelectionTool.h:84
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
CP::IsolationSelectionTool::getMuonAcceptInfo
virtual const asg::AcceptInfo & getMuonAcceptInfo() const override
Definition: IsolationSelectionTool.cxx:468
CP::IsolationSelectionTool::getMuonWPs
virtual const std::vector< std::unique_ptr< IsolationWP > > & getMuonWPs() const override
Definition: IsolationSelectionTool.cxx:21
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
CP::IsolationSelectionTool::addWP
StatusCode addWP(const std::string &WP, xAOD::Type::ObjectType type)
Definition: IsolationSelectionTool.cxx:362
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:640
ObjectType
ObjectType
Definition: BaseObject.h:11
CP::IsolationSelectionTool::evaluateWP
void evaluateWP(const T &x, const std::vector< std::unique_ptr< IsolationWP >> &WP, asg::AcceptData &accept) const
Definition: IsolationSelectionTool.cxx:395
IsoCloseByCorrectionTest.WP
WP
Definition: IsoCloseByCorrectionTest.py:56
IsolationType.h
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
CP::IsolationSelectionTool::getObjWPs
virtual const std::vector< std::unique_ptr< IsolationWP > > & getObjWPs() const override
Definition: IsolationSelectionTool.cxx:24
asg
Definition: DataHandleTestTool.h:28
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
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:56
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
IsolationConditionFormula.h
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
CP
Select isolated Photons, Electrons and Muons.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:48
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
Cut
Definition: SUSYToolsAlg.cxx:65
CP::strObj
Definition: IsolationCondition.h:23
CP::IsolationSelectionTool::m_inElecContainer
Gaudi::Property< std::string > m_inElecContainer
Definition: IsolationSelectionTool.h:122
CP::IsolationSelectionTool::IsolationSelectionTool
IsolationSelectionTool(const std::string &name)
Create a proper constructor for Athena.
Definition: IsolationSelectionTool.cxx:20
CP::IsolationSelectionTool::m_elWPname
Gaudi::Property< std::string > m_elWPname
Definition: IsolationSelectionTool.h:77
CP::IsolationSelectionTool::Efficiency
@ Efficiency
Definition: IsolationSelectionTool.h:39
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
IsolationSelectionTool.h
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::getElectronAcceptInfo
virtual const asg::AcceptInfo & getElectronAcceptInfo() const override
Definition: IsolationSelectionTool.cxx:466
CP::IsolationSelectionTool::addMuonWP
StatusCode addMuonWP(const std::string &wpname)
Definition: IsolationSelectionTool.cxx:143
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
xAOD::Iso::IsolationType
IsolationType
Overall enumeration for isolation types in xAOD files.
Definition: IsolationType.h:26
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
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:93
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:401
CP::IsolationSelectionTool::IsoWPType
IsoWPType
Function finalizing the tool.
Definition: IsolationSelectionTool.h:39
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:220
CP::IsolationWP
Definition: IsolationWP.h:16
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
CP::IsolationSelectionTool::~IsolationSelectionTool
virtual ~IsolationSelectionTool()
Destructor.
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
PathResolver.h
CP::IsolationSelectionTool::m_muWPname
Gaudi::Property< std::string > m_muWPname
Definition: IsolationSelectionTool.h:76
CP::IsolationSelectionTool::getPhotonAcceptInfo
virtual const asg::AcceptInfo & getPhotonAcceptInfo() const override
Definition: IsolationSelectionTool.cxx:464
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
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::setIParticleCutsFrom
virtual StatusCode setIParticleCutsFrom(xAOD::Type::ObjectType ObjType) override
Definition: IsolationSelectionTool.cxx:94
IsolationConditionCombined.h
xAOD::Electron_v1
Definition: Electron_v1.h:34
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:431
Muon
struct TBPatternUnitContext Muon
CP::IsolationSelectionTool::addElectronWP
StatusCode addElectronWP(const std::string &wpname)
Definition: IsolationSelectionTool.cxx:253
LArG4AODNtuplePlotter.varname
def varname(hname)
Definition: LArG4AODNtuplePlotter.py:37
Interp3D::VetoInterp
Definition: Interp3D.h:15
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
xAOD::Photon_v1
Definition: Photon_v1.h:37
asg::AcceptData::clear
void clear()
Clear all bits.
Definition: AcceptData.h:54
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CP::IsolationSelectionTool::getPhotonWPs
virtual const std::vector< std::unique_ptr< IsolationWP > > & getPhotonWPs() const override
Definition: IsolationSelectionTool.cxx:23
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000
@ ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000
Definition: IsolationType.h:77
CP::IsolationSelectionTool::initialize
virtual StatusCode initialize() override
Function initialising the tool.
Definition: IsolationSelectionTool.cxx:27
CP::IsolationSelectionTool::m_Interp
std::shared_ptr< Interp3D > m_Interp
Definition: IsolationSelectionTool.h:115
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
CP::IsolationSelectionTool::m_iparWPs
std::vector< std::unique_ptr< IsolationWP > > * m_iparWPs
Iparticle interface.
Definition: IsolationSelectionTool.h:109
CP::IsolationSelectionTool::addUserDefinedWP
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)
Definition: IsolationSelectionTool.cxx:322
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
CP::IsolationSelectionTool::getObjAcceptInfo
virtual const asg::AcceptInfo & getObjAcceptInfo() const override
Definition: IsolationSelectionTool.cxx:469
IsolationConditionHist.h
asg::AcceptData
Definition: AcceptData.h:30
CP::IsolationSelectionTool::m_muWPvec
Gaudi::Property< std::vector< std::string > > m_muWPvec
Definition: IsolationSelectionTool.h:79
python.compressB64.c
def c
Definition: compressB64.py:93
Interp3D.h
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
CP::IsolationSelectionTool::getElectronWPs
virtual const std::vector< std::unique_ptr< IsolationWP > > & getElectronWPs() const override
Definition: IsolationSelectionTool.cxx:22
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 Thu Nov 7 2024 21:17:30 for ATLAS Offline Software by   doxygen 1.8.18