ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
HistHandler.cxx File Reference
#include <MuonEfficiencyCorrections/HistHandler.h>
#include <MuonEfficiencyCorrections/UtilFunctions.h>
#include <iostream>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <TH1.h>
#include <TH2Poly.h>
Include dependency graph for HistHandler.cxx:

Go to the source code of this file.

Functions

namespace ADD_CMODE (CP)

Function Documentation

◆ ADD_CMODE()

namespace ADD_CMODE ( CP )

Definition at line 1 of file HistHandler.cxx.

16 {
17 //###########################################################################################################
18 // AxisHandlerProvider
19 //###########################################################################################################
20 std::unique_ptr<AxisHandler> AxisHandlerProvider::GetAxisHandler(columnar::ColumnarTool<> * parent, const TAxis * axisptr) {
21 if (axisptr != nullptr) {
22 std::string axis = axisptr->GetTitle();
23 axis = EraseWhiteSpaces(axis);
24 size_t Abs1 = axis.find("|");
25 size_t Abs2(0);
26 if (Abs1 != std::string::npos) Abs2 = axis.find("|", Abs1 + 1);
27 bool AbsAxis = (Abs2 != std::string::npos) && (Abs2 != 0);
28 if (axis.find("pt") != std::string::npos || axis.find("pT") != std::string::npos || axis.find("p_{T}") != std::string::npos) {
29 return std::make_unique<PtAxisHandler>(parent);
30 } else if (axis.find("phi") != std::string::npos) {
31 return std::make_unique<PhiAxisHandler>(parent);
32 } else if (axis.find("q") != std::string::npos || axis.find("charge") != std::string::npos) {
33 return std::make_unique<ChargeAxisHandler>(parent);
34 } else if (axis.find("eta") != std::string::npos) {
35 if (AbsAxis) return std::make_unique<AbsEtaAxisHandler>(parent);
36 return std::make_unique<EtaAxisHandler>(parent);
37 } else if (axis.find("dRJet") != std::string::npos || axis.find("#DeltaR (jet, #mu)") != std::string::npos) {
38 return std::make_unique<dRJetAxisHandler>(parent);
39 }
40
41 Error("AxisHandlerProvider", "Can not interpret axis title '%s'", axis.c_str());
42 } else {
43 Error("AxisHandlerProvider", "nullptr pointer passed");
44 }
45 return std::make_unique<UndefinedAxisHandler>(parent);
46 }
47
48
49 CP::CorrectionCode PtAxisHandler::GetBinningParameter(columnar::MuonId mu, float & value) const {
50 value = ptAcc(mu) / 1000.;
51 return CP::CorrectionCode::Ok;
52 }
53 CP::CorrectionCode ChargeAxisHandler::GetBinningParameter(columnar::MuonId mu, float & value) const {
54 value = chargeAcc (mu);
55 return CP::CorrectionCode::Ok;
56 }
57 CP::CorrectionCode EtaAxisHandler::GetBinningParameter(columnar::MuonId mu, float & value) const {
58 value = etaAcc(mu);
59 return CP::CorrectionCode::Ok;
60 }
61 CP::CorrectionCode AbsEtaAxisHandler::GetBinningParameter(columnar::MuonId mu, float & value) const {
62 value = std::abs(etaAcc(mu));
63 return CP::CorrectionCode::Ok;
64 }
65 CP::CorrectionCode PhiAxisHandler::GetBinningParameter(columnar::MuonId mu, float & value) const {
66 value = phiAcc(mu);
67 return CP::CorrectionCode::Ok;
68 }
69 void dRJetAxisHandler::set_close_jet_decorator(const std::string& decor_name){
70 s_close_jet_decor = decor_name;
71 }
72
73 void dRJetAxisHandler::set_use_2D_sf(const bool in)
74 {
75 s_use_2D_sf=in;
76 }
77
78 std::string dRJetAxisHandler::s_close_jet_decor = "dRJet";
79 bool dRJetAxisHandler::s_use_2D_sf = false;
80 dRJetAxisHandler::dRJetAxisHandler(columnar::ColumnarTool<> * parent):
81 AxisHandler(parent),
82 m_use_2D_sf(s_use_2D_sf),
83 m_acc(*this,s_close_jet_decor){}
84
85 CP::CorrectionCode dRJetAxisHandler::GetBinningParameter(columnar::MuonId mu, float & value) const {
86
87 static std::atomic<unsigned int> warned = {0};
88
89 if(!m_use_2D_sf) value = -2.;
90 else if (acc_dR_deriv.isAvailable(mu)){
91 value = acc_dR_deriv(mu);
92 }else if( m_acc.isAvailable(mu) ) {
93 // decoration available in DxAOD
94 value = m_acc(mu);
95 if (warned < 5){
96 Warning("MuonEfficiencyCorrections::dRJetAxisHandler()", "The DFCommonJetDr jet decoration is not available in the derivation will fall back to %s",s_close_jet_decor.c_str());
97 ++warned;
98 }
99 } else {
100 // decoration not available
101 value = -2.;
102 // We want these warnings to be printed few times per job, so that they're visible, then stop before log file's size blows up
103 if (warned<5){
104 Warning("MuonEfficiencyCorrections::dRJetAxisHandler()", "The %s decoration has not been found for the Muon. Isolation scale-factors are now also binned in #Delta R(jet,#mu)", s_close_jet_decor.c_str());
105 Warning("MuonEfficiencyCorrections::dRJetAxisHandler()", "using the closest calibrated AntiKt4EMTopo jet with p_{T}>20~GeV and surving the standard OR criteria.");
106 Warning("MuonEfficiencyCorrections::dRJetAxisHandler()", "You should decorate your muon appropiately before passing to the tool, and use dRJet = -1 in case there is no jet in an event.");
107 Warning("MuonEfficiencyCorrections::dRJetAxisHandler()", "For the time being the inclusive scale-factor is going to be returned.");
108 Warning("MuonEfficiencyCorrections::dRJetAxisHandler()", "In future derivations, muons will also be decorated centrally with DFCommonJetDr, for your benefit.");
109 Warning("MuonEfficiencyCorrections::dRJetAxisHandler()", "You can define custom jet decorations via the 'CloseJetDRDecorator' property of the MuonEfficiencyCorrections tool");
110 ++warned;
111 }
112 }
113 return CP::CorrectionCode::Ok;
114 }
115
116 CP::CorrectionCode UndefinedAxisHandler::GetBinningParameter(columnar::MuonId, float &) const {
117 return CP::CorrectionCode::Error;
118 }
119 //###########################################################################################################
120 // HistHandler
121 //###########################################################################################################
122 HistHandler::HistHandler(columnar::ColumnarTool<>* /*parent*/, TH1* Hist) :
123 m_H(clone(Hist)) {
124
125 }
126 // void HistHandler::Copy(const HistHandler & other) {
127 // if (this == &other) {
128 // return;
129 // }
130 // if (other.m_H) {
131 // m_H = clone(other.GetHist());
132 // }
133 // }
134 // HistHandler::HistHandler(const HistHandler & other) :
135 // m_H() {
136 // Copy(other);
137 // }
138 HistHandler::~HistHandler() {
139 }
140 void HistHandler::SetBinContent(int bin, float val) {
141 if (m_H) {
142 m_H->SetBinContent(bin, val);
143 }
144 }
145 void HistHandler::SetBinError(int bin, float val) {
146 if (m_H) {
147 m_H->SetBinError(bin, val);
148 }
149 }
150 //###########################################################################################################
151 // HistHandler_TH1
152 //###########################################################################################################
153 HistHandler_TH1::HistHandler_TH1(columnar::ColumnarTool<>* parent, TH1* h) :
154 HistHandler(parent, h),
155 m_x_handler(h == nullptr ? 0 : AxisHandlerProvider::GetAxisHandler(parent, h->GetXaxis())) {
156 }
157
158 HistHandler_TH1::~HistHandler_TH1() {
159 }
160 int HistHandler_TH1::nBins() const {return GetHist()->GetNbinsX() + 2;}
161 int HistHandler_TH1::nOverFlowBins() const {return 2; }
162 bool HistHandler_TH1::isOverFlowBin(int b) const { return b == 0 || b >= nBins() -1; }
163 std::string HistHandler_TH1::GetBinName(unsigned int bin) const {
164 TAxis* xAx = GetHist()->GetXaxis();
165 return Form("%s_%.2f_to_%.2f", xAx->GetTitle(), xAx->GetBinLowEdge(bin), xAx->GetBinUpEdge(bin));
166 }
167 CP::CorrectionCode HistHandler_TH1::FindBin(columnar::MuonId muon, int & bin) const {
168 if (!GetHist()) {
169 bin = -1;
170 return CP::CorrectionCode::Error;
171 }
172 float par = 0;
173 if (m_x_handler->GetBinningParameter(muon, par) == CP::CorrectionCode::Error) {
174 return CP::CorrectionCode::Error;
175 } else {
176 bin = GetHist()->FindBin(par);
177 if (bin < 1 || bin > GetHist()->GetNbinsX()) {
178 return CP::CorrectionCode::OutOfValidityRange;
179 }
180 }
181 return CP::CorrectionCode::Ok;
182 }
183
184 //###########################################################################################################
185 // HistHandler_TH2
186 //###########################################################################################################
187 HistHandler_TH2::HistHandler_TH2(columnar::ColumnarTool<>* parent, TH1* h) :
188 HistHandler(parent, h),
189 m_x_handler(h == nullptr ? 0 : AxisHandlerProvider::GetAxisHandler(parent, h->GetXaxis())),
190 m_y_handler(h == nullptr ? 0 : AxisHandlerProvider::GetAxisHandler(parent, h->GetYaxis())) {
191
192 }
193 int HistHandler_TH2::nBins() const {
194 return (GetHist()->GetNbinsX() + 2) * (GetHist()->GetNbinsY() + 2);
195 }
196 int HistHandler_TH2::nOverFlowBins() const {return 2*GetHist()->GetNbinsX() + 2*GetHist()->GetNbinsY() + 4; }
197 bool HistHandler_TH2::isOverFlowBin(int b) const {
198 int x(-1),y(-1), z(-1);
199 GetHist()->GetBinXYZ(b,x,y,z);
200 return x == 0 || x == GetHist()->GetXaxis()->GetNbins() + 1 || y == 0 || y == GetHist()->GetYaxis()->GetNbins() + 1;
201 }
202 CP::CorrectionCode HistHandler_TH2::FindBin(columnar::MuonId muon, int & bin) const {
203 if (!GetHist()) return CP::CorrectionCode::Error;
204 float parx = 0;
205 float pary = 0;
206 if (m_x_handler->GetBinningParameter(muon, parx) == CP::CorrectionCode::Error ||
207 m_y_handler->GetBinningParameter(muon, pary) == CP::CorrectionCode::Error) {
208 return CP::CorrectionCode::Error;
209 } else {
210 int binx = GetHist()->GetXaxis()->FindBin(parx);
211 int biny = GetHist()->GetYaxis()->FindBin(pary);
212 if (binx < 1 || binx > GetHist()->GetNbinsX() || biny < 1 || biny > GetHist()->GetNbinsY()) {
213 return CP::CorrectionCode::OutOfValidityRange;
214 }
215 bin = GetHist()->GetBin(binx, biny);
216 }
217 return CP::CorrectionCode::Ok;
218 }
219 HistHandler_TH2::~HistHandler_TH2() {
220 }
221 std::string HistHandler_TH2::GetBinName(unsigned int bin) const {
222 int x(0), y(0), z(0);
223 GetHist()->GetBinXYZ(bin, x, y, z);
224 TAxis* xAx = GetHist()->GetXaxis();
225 TAxis* yAx = GetHist()->GetYaxis();
226 return Form("%s_%.2f_to_%.2f_times_%s_%.2f_to_%.2f",
227 //xAxis
228 xAx->GetTitle(), xAx->GetBinLowEdge(x), xAx->GetBinUpEdge(x),
229 //yAxis
230 yAx->GetTitle(), yAx->GetBinLowEdge(y), yAx->GetBinUpEdge(y));
231 }
232 //###########################################################################################################
233 // HistHandler_TH3
234 //###########################################################################################################
235
236 HistHandler_TH3::HistHandler_TH3(columnar::ColumnarTool<>* parent, TH1* h) :
237 HistHandler(parent,h),
238 m_x_handler(GetHist() == nullptr ? 0 : AxisHandlerProvider::GetAxisHandler(parent, h->GetXaxis())),
239 m_y_handler(GetHist() == nullptr ? 0 : AxisHandlerProvider::GetAxisHandler(parent, h->GetYaxis())),
240 m_z_handler(GetHist() == nullptr ? 0 : AxisHandlerProvider::GetAxisHandler(parent, h->GetZaxis())) {
241
242 }
243 HistHandler_TH3::~HistHandler_TH3() {
244 }
245 int HistHandler_TH3::nBins() const {
246 return (GetHist()->GetNbinsX() + 2) * (GetHist()->GetNbinsY() + 2) * (GetHist()->GetNbinsZ() + 2);
247 }
248 int HistHandler_TH3::nOverFlowBins() const {return 2*(GetHist()->GetNbinsX()*GetHist()->GetNbinsY() +
249 GetHist()->GetNbinsX()*GetHist()->GetNbinsZ() +
250 GetHist()->GetNbinsY()*GetHist()->GetNbinsZ()) + 8; }
251 bool HistHandler_TH3::isOverFlowBin(int b) const {
252 int x(-1),y(-1), z(-1);
253 GetHist()->GetBinXYZ(b,x,y,z);
254 return x == 0 || x == GetHist()->GetXaxis()->GetNbins() + 1 ||
255 y == 0 || y == GetHist()->GetYaxis()->GetNbins() + 1 ||
256 z == 0 || z == GetHist()->GetZaxis()->GetNbins() + 1;
257 }
258 CP::CorrectionCode HistHandler_TH3::FindBin(columnar::MuonId muon, int & bin) const {
259 if (!GetHist()) return CP::CorrectionCode::Error;
260 float parx = 0;
261 float pary = 0;
262 float parz = 0;
263 if (m_x_handler->GetBinningParameter(muon, parx) == CP::CorrectionCode::Error ||
264 m_y_handler->GetBinningParameter(muon, pary) == CP::CorrectionCode::Error ||
265 m_z_handler->GetBinningParameter(muon, parz) == CP::CorrectionCode::Error) return CP::CorrectionCode::Error;
266 else {
267 int binx = GetHist()->GetXaxis()->FindBin(parx);
268 int biny = GetHist()->GetYaxis()->FindBin(pary);
269 int binz = GetHist()->GetZaxis()->FindBin(parz);
270 if (binx < 1 || binx > GetHist()->GetNbinsX() || biny < 1 || biny > GetHist()->GetNbinsY() || binz < 1 || binz > GetHist()->GetNbinsZ()) {
271 return CP::CorrectionCode::OutOfValidityRange;
272 }
273 bin = GetHist()->GetBin(binx, biny, binz);
274 }
275 return CP::CorrectionCode::Ok;
276 }
277
278 std::string HistHandler_TH3::GetBinName(unsigned int bin) const {
279 int x(0), y(0), z(0);
280 GetHist()->GetBinXYZ(bin, x, y, z);
281 TAxis* xAx = GetHist()->GetXaxis();
282 TAxis* yAx = GetHist()->GetYaxis();
283 TAxis* zAx = GetHist()->GetZaxis();
284 return Form("%s_%.2f_to_%.2f_times_%s_%.2f_to_%.2f_times_%s_%.2f_to_%.2f",
285 //xAxis
286 xAx->GetTitle(), xAx->GetBinLowEdge(x), xAx->GetBinUpEdge(x),
287 //yAxis
288 yAx->GetTitle(), yAx->GetBinLowEdge(y), yAx->GetBinUpEdge(y),
289 //zAxis
290 zAx->GetTitle(), zAx->GetBinLowEdge(z), zAx->GetBinUpEdge(z));
291 }
292
293 //###########################################################################################################
294 // HistHandler_TH2Poly
295 //###########################################################################################################
296
297 HistHandler_TH2Poly::HistHandler_TH2Poly(columnar::ColumnarTool<>* parent, TH2Poly * h) :
298 HistHandler(parent, h),
299 m_h(h),
300 m_x_handler(GetHist() == nullptr ? 0 : AxisHandlerProvider::GetAxisHandler(parent, h->GetXaxis())),
301 m_y_handler(GetHist() == nullptr ? 0 : AxisHandlerProvider::GetAxisHandler(parent, h->GetYaxis())) {
302
303 }
304
305 HistHandler_TH2Poly::~HistHandler_TH2Poly() {
306 }
307 int HistHandler_TH2Poly::nBins() const {
308 return m_h->GetNumberOfBins() + 1;
309 }
310
311 int HistHandler_TH2Poly::nOverFlowBins() const {return 10;}
312 bool HistHandler_TH2Poly::isOverFlowBin(int b) const {return b < 1;}
313
314 CP::CorrectionCode HistHandler_TH2Poly::FindBin(columnar::MuonId muon, int & bin) const {
315 if (!m_h) return CP::CorrectionCode::Error;
316 float parx = 0;
317 float pary = 0;
318 if (m_x_handler->GetBinningParameter(muon, parx) == CP::CorrectionCode::Error ||
319 m_y_handler->GetBinningParameter(muon, pary) == CP::CorrectionCode::Error) return CP::CorrectionCode::Error;
320 else {
321 bin = GetHist()->FindBin(parx, pary);
322 if (bin < 0) {
323 return CP::CorrectionCode::OutOfValidityRange;
324 }
325 }
326 return CP::CorrectionCode::Ok;
327 }
328 std::string HistHandler_TH2Poly::GetBinName(unsigned int bin) const {
329 int x(0), y(0), z(0);
330 GetHist()->GetBinXYZ(bin, x, y, z);
331 TAxis* xAx = GetHist()->GetXaxis();
332 TAxis* yAx = GetHist()->GetYaxis();
333 return Form("%s_%.2f_to_%.2f__times_%s_%.2f_to_%.2f",
334 xAx->GetTitle(), xAx->GetBinLowEdge(x), xAx->GetBinUpEdge(x),
335 yAx->GetTitle(), yAx->GetBinLowEdge(y), yAx->GetBinUpEdge(y));
336 }
337} // namespace ADD_CMODE(CP)
y
#define y
x
#define x
z
#define z
h
Header file for AthHistogramAlgorithm.
CP::CorrectionCode
Return value from object correction CP tools.
Definition CorrectionCode.h:31
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition CorrectionCode.h:36
CP::CorrectionCode::OutOfValidityRange
@ OutOfValidityRange
Input object is out of validity range.
Definition CorrectionCode.h:37
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition CorrectionCode.h:38
L1Topo::Error
Error
The different types of error that can be flagged in the L1TopoRDO.
Definition Error.h:16
columnar::MuonId
ObjectId< MuonDef > MuonId
Definition MuonDef.h:22
test_pyathena.parent
parent
Definition test_pyathena.py:15
yodamerge_tmp.axis
list axis
Definition yodamerge_tmp.py:241
Generated on for ATLAS Offline Software by doxygen 1.17.0