Project
Loading...
Searching...
No Matches
Tracks.cxx
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
12#define _USE_MATH_DEFINES
13
14#include <cmath>
15#include <memory>
16
17// root includes
18#include "TFile.h"
19#include "TRandom3.h"
20
21// o2 includes
22#include "DataFormatsTPC/TrackTPC.h"
23#include "DataFormatsTPC/dEdxInfo.h"
24#include "GPUCommonArray.h"
25#include "DetectorsBase/Propagator.h"
26#include "TPCQC/Tracks.h"
27#include "TPCQC/Helpers.h"
28
29ClassImp(o2::tpc::qc::Tracks);
30
31using namespace o2::tpc::qc;
32struct binning {
33 int bins;
34 double min;
35 double max;
36};
37// DCA histograms
38const std::vector<std::string_view> types{"A_Pos", "A_Neg", "C_Pos", "C_Neg"};
39const binning binsDCAr{200, -5., 5.};
40const binning binsDCArLargerRange{400, -10., 10.};
41const binning binsEta{200, -1., 1.};
42const binning binsClus{120, 60., 180.};
43const binning binsClusLargerRange{140, 60., 200.};
44//______________________________________________________________________________
45void Tracks::initializeHistograms()
46{
47
48 TH1::AddDirectory(false);
49 const auto logPtBinning = helpers::makeLogBinning(100, 0.05, 20);
50 // 1d hitograms
51 mMapHist["hNClustersBeforeCuts"] = std::make_unique<TH1F>("hNClustersBeforeCuts", "Number of clusters (before cuts);# TPC clusters", binsClus.max, 0, binsClus.max);
52 mMapHist["hNClustersAfterCuts"] = std::make_unique<TH1F>("hNClustersAfterCuts", "Number of clusters;# TPC clusters", binsClus.bins, binsClus.min, binsClus.max);
53 mMapHist["hEta"] = std::make_unique<TH1F>("hEta", "Pseudorapidity;#eta", binsEta.bins, binsEta.min, binsEta.max);
54 mMapHist["hPhiAside"] = std::make_unique<TH1F>("hPhiAside", "Azimuthal angle, A side;#phi", 360, 0., 2 * M_PI);
55 mMapHist["hPhiCside"] = std::make_unique<TH1F>("hPhiCside", "Azimuthal angle, C side;#phi", 360, 0., 2 * M_PI);
56 mMapHist["hPt"] = std::make_unique<TH1F>("hPt", "Transverse momentum;#it{p}_{T} (GeV/#it{c})", logPtBinning.size() - 1, logPtBinning.data());
57 mMapHist["hSign"] = std::make_unique<TH1F>("hSign", "Sign of electric charge;charge sign", 3, -1.5, 1.5);
58 if (!mTurnOffHistosForAsync) {
59 mMapHist["hEtaNeg"] = std::make_unique<TH1F>("hEtaNeg", "Pseudorapidity, neg. tracks;#eta", binsEta.bins, binsEta.min, binsEta.max);
60 mMapHist["hEtaPos"] = std::make_unique<TH1F>("hEtaPos", "Pseudorapidity, pos. tracks;#eta", binsEta.bins, binsEta.min, binsEta.max);
61 mMapHist["hPhiAsideNeg"] = std::make_unique<TH1F>("hPhiAsideNeg", "Azimuthal angle, A side, neg. tracks;#phi", 360, 0., 2 * M_PI);
62 mMapHist["hPhiAsidePos"] = std::make_unique<TH1F>("hPhiAsidePos", "Azimuthal angle, A side, pos. tracks;#phi", 360, 0., 2 * M_PI);
63 mMapHist["hPhiCsideNeg"] = std::make_unique<TH1F>("hPhiCsideNeg", "Azimuthal angle, C side, neg. tracks;#phi", 360, 0., 2 * M_PI);
64 mMapHist["hPhiCsidePos"] = std::make_unique<TH1F>("hPhiCsidePos", "Azimuthal angle, C side, pos. tracks;#phi", 360, 0., 2 * M_PI);
65 // 1d ratio histograms
66 mMapHist["hEtaRatio"] = std::make_unique<TH1F>("hEtaRatio", "Pseudorapidity, ratio neg./pos.;#eta", binsEta.bins, binsEta.min, binsEta.max);
67 mMapHist["hPhiAsideRatio"] = std::make_unique<TH1F>("hPhiAsideRatio", "Azimuthal angle, A side, ratio neg./pos.;#phi", 360, 0., 2 * M_PI);
68 mMapHist["hPhiCsideRatio"] = std::make_unique<TH1F>("hPhiCsideRatio", "Azimuthal angle, C side, ratio neg./pos.;#phi", 360, 0., 2 * M_PI);
69 mMapHist["hPtRatio"] = std::make_unique<TH1F>("hPtRatio", "Transverse momentum, ratio neg./pos. ;#it{p}_{T}", logPtBinning.size() - 1, logPtBinning.data());
70 mMapHist["hPhiBothSides"] = std::make_unique<TH1F>("hPhiBothSides", "Azimuthal angle, both sides clusters;#phi", 360, 0., 2 * M_PI);
71 mMapHist["hPtNeg"] = std::make_unique<TH1F>("hPtNeg", "Transverse momentum, neg. tracks;#it{p}_{T} (GeV/#it{c})", logPtBinning.size() - 1, logPtBinning.data());
72 mMapHist["hPtPos"] = std::make_unique<TH1F>("hPtPos", "Transverse momentum, pos. tracks;#it{p}_{T} (GeV/#it{c})", logPtBinning.size() - 1, logPtBinning.data());
73 }
74 mMapHist["hEtaBeforeCuts"] = std::make_unique<TH1F>("hEtaBeforeCuts", "Pseudorapidity (before cuts);#eta", 400, -2., 2.);
75 mMapHist["hPtBeforeCuts"] = std::make_unique<TH1F>("hPtBeforeCuts", "Transverse momentum (before cuts);#it{p}_{T} (GeV/#it{c})", logPtBinning.size() - 1, logPtBinning.data());
76 mMapHist["hQOverPt"] = std::make_unique<TH1F>("hQOverPt", "Charge over transverse momentum;q/#it{p}_{T}", 400, -20., 20.);
77 // 2d histograms
78 mMapHist["h2DNClustersEta"] = std::make_unique<TH2F>("h2DNClustersEta", "Number of clusters vs. #eta;#eta;# TPC clusters", binsEta.bins, binsEta.min, binsEta.max, binsClusLargerRange.bins, binsClusLargerRange.min, binsClusLargerRange.max);
79 mMapHist["h2DNClustersPhiAside"] = std::make_unique<TH2F>("h2DNClustersPhiAside", "Number of clusters vs. #phi, A side ;#phi;# TPC clusters", 360, 0., 2 * M_PI, binsClus.bins, binsClus.min, binsClus.max);
80 mMapHist["h2DNClustersPhiCside"] = std::make_unique<TH2F>("h2DNClustersPhiCside", "Number of clusters vs. #phi, C side ;#phi;# TPC clusters", 360, 0., 2 * M_PI, binsClus.bins, binsClus.min, binsClus.max);
81 mMapHist["h2DNClustersPt"] = std::make_unique<TH2F>("h2DNClustersPt", "Number of clusters vs. #it{p}_{T};#it{p}_{T} (GeV/#it{c});# TPC clusters", logPtBinning.size() - 1, logPtBinning.data(), binsClusLargerRange.bins, binsClusLargerRange.min, binsClusLargerRange.max);
82 mMapHist["h2DEtaPhi"] = std::make_unique<TH2F>("h2DEtaPhi", "Tracks in #eta vs. #phi;#phi;#eta", 360, 0., 2 * M_PI, binsEta.bins, binsEta.min, binsEta.max);
83 mMapHist["h2DNClustersEtaBeforeCuts"] = std::make_unique<TH2F>("h2DNClustersEtaBeforeCuts", "NClusters vs. #eta (before cuts);#eta;# TPC clusters", 400, -2., 2., 200, -0.5, 199.5);
84 mMapHist["h2DNClustersPtBeforeCuts"] = std::make_unique<TH2F>("h2DNClustersPtBeforeCuts", "NClusters vs. #it{p}_{T} (before cuts);#it{p}_{T} (GeV/#it{c});# TPC clusters", logPtBinning.size() - 1, logPtBinning.data(), 200, -0.5, 199.5);
85 mMapHist["h2DEtaPhiBeforeCuts"] = std::make_unique<TH2F>("h2DEtaPhiBeforeCuts", "Tracks in #eta vs. #phi (before cuts);#phi;#eta", 360, 0., 2 * M_PI, 400, -2., 2.);
86 if (!mTurnOffHistosForAsync) {
87 mMapHist["h2DQOverPtPhiAside"] = std::make_unique<TH2F>("h2DQOverPtPhiAside", "Charger over #it{p}_{T} vs. #phi, A side;#phi;q/#it{p}_{T}", 360, 0., 2 * M_PI, 400, -20., 20.);
88 mMapHist["h2DQOverPtPhiCside"] = std::make_unique<TH2F>("h2DQOverPtPhiCside", "Charger over #it{p}_{T} vs. #phi, C side;#phi;q/#it{p}_{T}", 360, 0., 2 * M_PI, 400, -20., 20.);
89 mMapHist["h2DEtaPhiNeg"] = std::make_unique<TH2F>("h2DEtaPhiNeg", "Negative tracks in #eta vs. #phi;#phi;#eta", 360, 0., 2 * M_PI, binsEta.bins, binsEta.min, binsEta.max);
90 mMapHist["h2DEtaPhiPos"] = std::make_unique<TH2F>("h2DEtaPhiPos", "Positive tracks in #eta vs. #phi;#phi;#eta", 360, 0., 2 * M_PI, binsEta.bins, binsEta.min, binsEta.max);
91 // eta vs pt and phi vs pt possitive and negative signs
92 mMapHist["hEtaVsPtPos"] = std::make_unique<TH2F>("hEtaVsPtPos", "#eta vs. #it{p}_{T} (Pos.);#it{p}_{T} (GeV/#it{c});#eta", logPtBinning.size() - 1, logPtBinning.data(), binsEta.bins, binsEta.min, binsEta.max);
93 mMapHist["hEtaVsPtNeg"] = std::make_unique<TH2F>("hEtaVsPtNeg", "#eta vs. #it{p}_{T} (Neg.);#it{p}_{T} (GeV/#it{c});#eta", logPtBinning.size() - 1, logPtBinning.data(), binsEta.bins, binsEta.min, binsEta.max);
94 mMapHist["hPhiVsPtPos"] = std::make_unique<TH2F>("hPhiVsPtPos", "#phi vs. #it{p}_{T} (Pos.);#it{p}_{T} (GeV/#it{c});#phi", logPtBinning.size() - 1, logPtBinning.data(), 360, 0., 2 * M_PI);
95 mMapHist["hPhiVsPtNeg"] = std::make_unique<TH2F>("hPhiVsPtNeg", "#phi vs. #it{p}_{T} (Neg.);#it{p}_{T} (GeV/#it{c});#phi", logPtBinning.size() - 1, logPtBinning.data(), 360, 0., 2 * M_PI);
96 }
97 // DCA Histograms
98 for (const auto type : types) {
99 mMapHist[fmt::format("hDCAr_{}", type).data()] = std::make_unique<TH2F>(fmt::format("hDCAr_{}", type).data(), fmt::format("DCAr {};#phi;DCAr (cm)", type).data(), 360, 0, o2::math_utils::twoPid(), binsDCAr.bins, binsDCAr.min, binsDCAr.max);
100 mMapHist[fmt::format("hDCAr_{}_pTmin", type).data()] = std::make_unique<TH2F>(fmt::format("hDCAr_{}_pTmin", type).data(), fmt::format("DCAr {} #it{{p}}_{{T}}^{{min}};#phi;DCAr (cm)", type).data(), 360, 0, o2::math_utils::twoPid(), binsDCAr.bins, binsDCAr.min, binsDCAr.max);
101 }
102 // DCA vs variables Histograms
103 mMapHist["hDCArVsPtPos"] = std::make_unique<TH2F>("hDCArVsPtPos", "DCAr Pos;#it{p}_{T} (GeV/#it{c});DCAr (cm)", logPtBinning.size() - 1, logPtBinning.data(), binsDCArLargerRange.bins, binsDCArLargerRange.min, binsDCArLargerRange.max);
104 mMapHist["hDCArVsEtaPos"] = std::make_unique<TH2F>("hDCArVsEtaPos", "DCAr Pos;#eta;DCAr (cm)", binsEta.bins, binsEta.min, binsEta.max, binsDCArLargerRange.bins, binsDCArLargerRange.min, binsDCArLargerRange.max);
105 mMapHist["hDCArVsNClsPos"] = std::make_unique<TH2F>("hDCArVsNClsPos", "DCAr Pos;# TPC clusters;DCAr (cm)", binsClus.bins, binsClus.min, binsClus.max, binsDCAr.bins, binsDCAr.min, binsDCAr.max);
106 mMapHist["hDCArVsPtNeg"] = std::make_unique<TH2F>("hDCArVsPtNeg", "DCAr Neg;#it{p}_{T} (GeV/#it{c});DCAr (cm)", logPtBinning.size() - 1, logPtBinning.data(), binsDCArLargerRange.bins, binsDCArLargerRange.min, binsDCArLargerRange.max);
107 mMapHist["hDCArVsEtaNeg"] = std::make_unique<TH2F>("hDCArVsEtaNeg", "DCAr Neg;#eta;DCAr (cm)", binsEta.bins, binsEta.min, binsEta.max, binsDCArLargerRange.bins, binsDCArLargerRange.min, binsDCArLargerRange.max);
108 mMapHist["hDCArVsNClsNeg"] = std::make_unique<TH2F>("hDCArVsNClsNeg", "DCAr Neg;# TPC clusters;DCAr (cm)", binsClus.bins, binsClus.min, binsClus.max, binsDCAr.bins, binsDCAr.min, binsDCAr.max);
109 // DCA vs variables Histogram with pT min selection
110 mMapHist["hDCArVsEtaPos_pTmin"] = std::make_unique<TH2F>("hDCArVsEtaPos_pTmin", "DCAr Pos #it{p}_{T}^{min};#eta;DCAr (cm)", binsEta.bins, binsEta.min, binsEta.max, binsDCAr.bins, binsDCAr.min, binsDCAr.max);
111 mMapHist["hDCArVsNClsPos_pTmin"] = std::make_unique<TH2F>("hDCArVsNClsPos_pTmin", "DCAr Pos #it{p}_{T}^{min};# TPC clusters;DCAr (cm)", binsClus.bins, binsClus.min, binsClus.max, binsDCAr.bins, binsDCAr.min, binsDCAr.max);
112 mMapHist["hDCArVsEtaNeg_pTmin"] = std::make_unique<TH2F>("hDCArVsEtaNeg_pTmin", "DCAr Neg #it{p}_{T}^{min};#eta;DCAr (cm)", binsEta.bins, binsEta.min, binsEta.max, binsDCAr.bins, binsDCAr.min, binsDCAr.max);
113 mMapHist["hDCArVsNClsNeg_pTmin"] = std::make_unique<TH2F>("hDCArVsNClsNeg_pTmin", "DCAr Neg #it{p}_{T}^{min};# TPC clusters;DCAr (cm)", binsClus.bins, binsClus.min, binsClus.max, binsDCAr.bins, binsDCAr.min, binsDCAr.max);
114}
115//______________________________________________________________________________
116void Tracks::resetHistograms()
117{
118 for (const auto& pair : mMapHist) {
119 pair.second->Reset();
120 }
121}
122//______________________________________________________________________________
123bool Tracks::processTrack(const o2::tpc::TrackTPC& track)
124{
125 // ===| variables required for cutting and filling |===
126 const auto eta = track.getEta();
127 const auto phi = track.getPhi();
128 const auto pt = track.getPt();
129 const auto sign = track.getSign();
130 const auto qOverPt = track.getQ2Pt();
131 const auto nCls = track.getNClusterReferences();
132 const auto dEdxTot = track.getdEdx().dEdxTotTPC;
133 const auto hasASideOnly = track.hasASideClustersOnly();
134 const auto hasCSideOnly = track.hasCSideClustersOnly();
135
136 const auto absEta = std::abs(eta);
137
138 // ===| histogram filling before cuts |===
139 mMapHist["hNClustersBeforeCuts"]->Fill(nCls);
140 mMapHist["hEtaBeforeCuts"]->Fill(eta);
141 mMapHist["hPtBeforeCuts"]->Fill(pt);
142 mMapHist["h2DNClustersEtaBeforeCuts"]->Fill(eta, nCls);
143 mMapHist["h2DNClustersPtBeforeCuts"]->Fill(pt, nCls);
144 mMapHist["h2DEtaPhiBeforeCuts"]->Fill(phi, eta);
145
146 // ===| histogram filling including cuts |===
147 if (absEta < mCutAbsEta && nCls > mCutMinnCls && dEdxTot > mCutMindEdxTot) {
148
149 // ===| 1D histogram filling |===
150 mMapHist["hNClustersAfterCuts"]->Fill(nCls);
151 mMapHist["hEta"]->Fill(eta);
152
153 //---| propagate to 0,0,0 |---
154 //
155 // propagator instance must be configured before (LUT, MagField)
156 auto propagator = o2::base::Propagator::Instance(true);
157 const int type = (track.getQ2Pt() < 0) + 2 * track.hasCSideClustersOnly();
158 auto dcaHist = mMapHist[fmt::format("hDCAr_{}", types[type]).data()].get();
159 auto dcaHist_pTmin = mMapHist[fmt::format("hDCAr_{}_pTmin", types[type]).data()].get();
160 const std::string signType((sign < 0) ? "Neg" : "Pos");
161 auto dcaHistPT = mMapHist["hDCArVsPt" + signType].get();
162 auto dcaHistEta = mMapHist["hDCArVsEta" + signType].get();
163 auto dcaHistNCluster = mMapHist["hDCArVsNCls" + signType].get();
164 auto dcaHistEta_pTmin = mMapHist["hDCArVsEta" + signType + "_pTmin"].get();
165 auto dcaHistNCluster_pTmin = mMapHist["hDCArVsNCls" + signType + "_pTmin"].get();
166
167 // set-up sampling for the DCA calculation
168 Double_t sampleProb = 2;
169
170 if (mSamplingFractionDCAr > 0) { // for now no SEED is given.
171 TRandom3 randomGenerator(0);
172 sampleProb = randomGenerator.Uniform(1);
173 }
174
175 bool isDcaCalculated = false;
176 float dcaValue = -999;
177
178 if (sampleProb > (Double_t)(1. - mSamplingFractionDCAr)) {
179
180 if (propagator->getMatLUT() && propagator->hasMagFieldSet()) {
181 // ---| fill DCA histos |---
182 o2::gpu::gpustd::array<float, 2> dca;
183 o2::track::TrackPar propTrack(track);
184 if (propagator->propagateToDCABxByBz(mPositionOfPV, propTrack, 2.f, o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca)) {
185 const auto phi = o2::math_utils::to02PiGen(track.getPhi());
186 dcaHistPT->Fill(pt, dca[0]);
187 dcaHist->Fill(phi, dca[0]);
188 dcaHistEta->Fill(eta, dca[0]);
189 dcaHistNCluster->Fill(nCls, dca[0]);
190 if (pt > mCutMinPtDCAr) {
191 dcaHist_pTmin->Fill(phi, dca[0]);
192 dcaHistEta_pTmin->Fill(eta, dca[0]);
193 dcaHistNCluster_pTmin->Fill(nCls, dca[0]);
194 }
195 dcaValue = dca[0];
196 isDcaCalculated = true;
197 }
198 } else {
199 static bool reported = false;
200 if (!reported) {
201 LOGP(error, "o2::base::Propagator not properly initialized, MatLUT ({}) and / or Field ({}) missing, will not fill DCA histograms", (void*)propagator->getMatLUT(), propagator->hasMagFieldSet());
202 dcaHist->SetTitle(fmt::format("DCAr {} o2::base::Propagator not properly initialized", types[type]).data());
203 dcaHistPT->SetTitle(fmt::format("DCAr #it{{p}}_{{T}} {} o2::base::Propagator not properly initialized", signType).data());
204 dcaHist_pTmin->SetTitle(fmt::format("DCAr {} #it{{p}}_{{T}}^{{min}} o2::base::Propagator not properly initialized", types[type]).data());
205 dcaHistEta->SetTitle(fmt::format("DCAr #eta {} o2::base::Propagator not properly initialized", signType).data());
206 dcaHistNCluster->SetTitle(fmt::format("DCAr nClusters {} o2::base::Propagator not properly initialized", signType).data());
207 dcaHistEta_pTmin->SetTitle(fmt::format("DCAr #eta {} #it{{p}}_{{T}}^{{min}} o2::base::Propagator not properly initialized", signType).data());
208 dcaHistNCluster_pTmin->SetTitle(fmt::format("DCAr nClusters {} #it{{p}}_{{T}}^{{min}} o2::base::Propagator not properly initialized", signType).data());
209 reported = true;
210 }
211 }
212 }
213
214 if (mUseCutMaxAbsDCArOnHistos && !isDcaCalculated) {
215 // In this case the DCAr selection should be applied but is not available for the track, hence we simply return and report back
216 // For ease we just report back for every histogram that the propagator was not initialized
217 static bool reported = false;
218 if (!reported) {
219 LOGP(error, "o2::base::Propagator not properly initialized, MatLUT ({}) and / or Field ({}) missing, will not fill apply DCAr selection on histograms", (void*)propagator->getMatLUT(), propagator->hasMagFieldSet());
220 mMapHist["hPhiAside"]->SetTitle("hPhiAside o2::base::Propagator not properly initialized");
221 mMapHist["hPhiCside"]->SetTitle("hPhiCside o2::base::Propagator not properly initialized");
222 mMapHist["hPhiBothSides"]->SetTitle("hPhiBothSides o2::base::Propagator not properly initialized");
223 mMapHist["hPt"]->SetTitle("hPt o2::base::Propagator not properly initialized");
224 mMapHist["hSign"]->SetTitle("hSign o2::base::Propagator not properly initialized");
225 mMapHist["hQOverPt"]->SetTitle("hQOverPt o2::base::Propagator not properly initialized");
226 mMapHist["hEtaNeg"]->SetTitle("hEtaNeg o2::base::Propagator not properly initialized");
227 mMapHist["hPhiAsideNeg"]->SetTitle("hPhiAsideNeg o2::base::Propagator not properly initialized");
228 mMapHist["hPhiCsideNeg"]->SetTitle("hPhiCsideNeg o2::base::Propagator not properly initialized");
229 mMapHist["hEtaPos"]->SetTitle("hEtaPos o2::base::Propagator not properly initialized");
230 mMapHist["hPtPos"]->SetTitle("hPtPos o2::base::Propagator not properly initialized");
231 mMapHist["hPhiAsidePos"]->SetTitle("hPhiAsidePos o2::base::Propagator not properly initialized");
232 mMapHist["hPhiCsidePos"]->SetTitle("hPhiCsidePos o2::base::Propagator not properly initialized");
233 mMapHist["h2DNClustersEta"]->SetTitle("h2DNClustersEta o2::base::Propagator not properly initialized");
234 mMapHist["h2DNClustersPhiAside"]->SetTitle("h2DNClustersPhiAside o2::base::Propagator not properly initialized");
235 mMapHist["h2DQOverPtPhiAside"]->SetTitle("h2DQOverPtPhiAside o2::base::Propagator not properly initialized");
236 mMapHist["h2DNClustersPhiCside"]->SetTitle("h2DNClustersPhiCside o2::base::Propagator not properly initialized");
237 mMapHist["h2DQOverPtPhiCside"]->SetTitle("h2DQOverPtPhiCside o2::base::Propagator not properly initialized");
238 mMapHist["h2DNClustersPt"]->SetTitle("h2DNClustersPt o2::base::Propagator not properly initialized");
239 mMapHist["h2DEtaPhi"]->SetTitle("h2DEtaPhi o2::base::Propagator not properly initialized");
240 mMapHist["h2DEtaPhiNeg"]->SetTitle("h2DEtaPhiNeg o2::base::Propagator not properly initialized");
241 mMapHist["hEtaVsPtNeg"]->SetTitle("hEtaVsPtNeg o2::base::Propagator not properly initialized");
242 mMapHist["hPhiVsPtNeg"]->SetTitle("hPhiVsPtNeg o2::base::Propagator not properly initialized");
243 mMapHist["h2DEtaPhiPos"]->SetTitle("h2DEtaPhiPos o2::base::Propagator not properly initialized");
244 mMapHist["hEtaVsPtPos"]->SetTitle("hEtaVsPtPos o2::base::Propagator not properly initialized");
245 mMapHist["hPhiVsPtPos"]->SetTitle("hPhiVsPtPos o2::base::Propagator not properly initialized");
246 }
247 return true;
248 }
249
250 if (mUseCutMaxAbsDCArOnHistos && (std::abs(dcaValue) > mCutMaxAbsDCAr)) {
251 return true;
252 }
253
254 if (hasASideOnly == 1) {
255 mMapHist["hPhiAside"]->Fill(phi);
256 } else if (hasCSideOnly == 1) {
257 mMapHist["hPhiCside"]->Fill(phi);
258 } else {
259 if (!mTurnOffHistosForAsync) {
260 mMapHist["hPhiBothSides"]->Fill(phi);
261 }
262 }
263
264 mMapHist["hPt"]->Fill(pt);
265 mMapHist["hSign"]->Fill(sign);
266 mMapHist["hQOverPt"]->Fill(qOverPt);
267
268 if (sign < 0.) {
269 if (!mTurnOffHistosForAsync) {
270 mMapHist["hEtaNeg"]->Fill(eta);
271 mMapHist["hPtNeg"]->Fill(pt);
272 }
273 if (!mTurnOffHistosForAsync) {
274 if (hasASideOnly == 1) {
275 mMapHist["hPhiAsideNeg"]->Fill(phi);
276 } else if (hasCSideOnly == 1) {
277 mMapHist["hPhiCsideNeg"]->Fill(phi);
278 }
279 }
280 } else {
281 if (!mTurnOffHistosForAsync) {
282 mMapHist["hEtaPos"]->Fill(eta);
283 mMapHist["hPtPos"]->Fill(pt);
284 }
285 if (!mTurnOffHistosForAsync) {
286 if (hasASideOnly == 1) {
287 mMapHist["hPhiAsidePos"]->Fill(phi);
288 } else if (hasCSideOnly == 1) {
289 mMapHist["hPhiCsidePos"]->Fill(phi);
290 }
291 }
292 }
293
294 // ===| 2D histogram filling |===
295 mMapHist["h2DNClustersEta"]->Fill(eta, nCls);
296
297 if (hasASideOnly == 1) {
298 mMapHist["h2DNClustersPhiAside"]->Fill(phi, nCls);
299 if (!mTurnOffHistosForAsync) {
300 mMapHist["h2DQOverPtPhiAside"]->Fill(phi, qOverPt);
301 }
302 } else if (hasCSideOnly == 1) {
303 mMapHist["h2DNClustersPhiCside"]->Fill(phi, nCls);
304 if (!mTurnOffHistosForAsync) {
305 mMapHist["h2DQOverPtPhiCside"]->Fill(phi, qOverPt);
306 }
307 }
308
309 mMapHist["h2DNClustersPt"]->Fill(pt, nCls);
310 mMapHist["h2DEtaPhi"]->Fill(phi, eta);
311
312 if (!mTurnOffHistosForAsync) {
313 if (sign < 0.) {
314 mMapHist["h2DEtaPhiNeg"]->Fill(phi, eta);
315 mMapHist["hEtaVsPtNeg"]->Fill(pt, eta);
316 mMapHist["hPhiVsPtNeg"]->Fill(pt, phi);
317 } else {
318 mMapHist["h2DEtaPhiPos"]->Fill(phi, eta);
319 mMapHist["hEtaVsPtPos"]->Fill(pt, eta);
320 mMapHist["hPhiVsPtPos"]->Fill(pt, phi);
321 }
322 }
323 }
324
325 return true;
326}
327
328//______________________________________________________________________________
329void Tracks::processEndOfCycle()
330{
331 if (!mTurnOffHistosForAsync) {
332 // ===| Dividing of 1D histograms -> Ratios |===
333 mMapHist["hEtaRatio"]->Divide(mMapHist["hEtaNeg"].get(), mMapHist["hEtaPos"].get());
334 mMapHist["hPhiAsideRatio"]->Divide(mMapHist["hPhiAsideNeg"].get(), mMapHist["hPhiAsidePos"].get());
335 mMapHist["hPhiCsideRatio"]->Divide(mMapHist["hPhiCsideNeg"].get(), mMapHist["hPhiCsidePos"].get());
336 mMapHist["hPtRatio"]->Divide(mMapHist["hPtNeg"].get(), mMapHist["hPtPos"].get());
337 }
338}
339
340//______________________________________________________________________________
341void Tracks::dumpToFile(std::string_view filename)
342{
343 auto f = std::unique_ptr<TFile>(TFile::Open(filename.data(), "recreate"));
344 for (const auto& [name, hist] : mMapHist) {
345 TObjArray arr;
346 arr.SetName(name.data());
347 arr.Add(hist.get());
348 arr.Write(arr.GetName(), TObject::kSingleKey);
349 }
350 f->Close();
351}
binsEta
const binning binsEta
Definition Tracks.cxx:41
binsDCArLargerRange
const binning binsDCArLargerRange
Definition Tracks.cxx:40
binsClus
const binning binsClus
Definition Tracks.cxx:42
ClassImp
ClassImp(o2::tpc::qc::Tracks)
binsClusLargerRange
const binning binsClusLargerRange
Definition Tracks.cxx:43
binsDCAr
const binning binsDCAr
Definition Tracks.cxx:39
o2::base::PropagatorImpl< float >::Instance
GPUd() value_type estimateLTFast(o2 static GPUd() float estimateLTIncrement(const o2 PropagatorImpl * Instance(bool uninitialized=false)
Definition Propagator.h:143
o2::tpc::qc::Tracks
Tracks quality control class.
Definition Tracks.h:49
o2::tpc::qc::Tracks::processEndOfCycle
void processEndOfCycle()
Function to be called at each endOfCycle.
Definition Tracks.cxx:329
o2::tpc::qc::Tracks::dumpToFile
void dumpToFile(std::string_view filename)
Dump results to a file.
Definition Tracks.cxx:341
o2::tpc::qc::Tracks::processTrack
bool processTrack(const o2::tpc::TrackTPC &track)
Definition Tracks.cxx:123
o2::tpc::qc::Tracks::resetHistograms
void resetHistograms()
Reset all histograms.
Definition Tracks.cxx:116
types
GLsizei GLenum GLenum * types
Definition glcorearb.h:2516
name
GLuint const GLchar * name
Definition glcorearb.h:781
f
GLdouble f
Definition glcorearb.h:310
type
GLint GLint GLsizei GLint GLenum GLenum type
Definition glcorearb.h:275
data
GLboolean * data
Definition glcorearb.h:298
o2::gpu::gpustd::array
std::array< T, N > array
Definition GPUCommonArray.h:44
o2::math_utils::to02PiGen
float to02PiGen(float phi)
Definition Utils.h:70
o2::tpc::qc::helpers::makeLogBinning
std::vector< double > makeLogBinning(const int nbins, const double min, const double max)
get a vector containing binning info for constant sized bins on a log axis
Definition Helpers.cxx:22
filename
std::string filename()
Definition o2FairMQHeaderSizeTest.cxx:55
binning::bins
int bins
Definition PID.cxx:34
binning::max
double max
Definition PID.cxx:36
binning::min
double min
Definition PID.cxx:35