]>
Commit | Line | Data |
---|---|---|
6788af99 | 1 | #ifndef ALIAODTRACKCUTSDIHADRONPID_H |
2 | #define ALIAODTRACKCUTSDIHADRONPID_H | |
97724bd1 | 3 | /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * |
4 | * See cxx source for full Copyright notice */ | |
5 | /* $Id$ */ | |
6788af99 | 6 | |
7 | #include "TFormula.h" | |
8 | #include "TH1F.h" | |
9 | #include "TH2F.h" | |
10 | #include "TH3F.h" | |
11 | #include "TList.h" | |
12 | ||
13 | class AliAODTrackCutsDiHadronPID : public TNamed | |
14 | ||
15 | { | |
16 | ||
17 | public: | |
18 | enum HistoClass {kAllCharged = 0, kPositive = 1, kNegative = 2, | |
19 | kAllPion = 3, kPosPion = 4, kNegPion = 5, | |
20 | kAllKaon = 6, kPosKaon = 7, kNegKaon = 8, | |
21 | kAllProton = 9, kPosProton = 10, kNegProton = 11}; | |
22 | ||
23 | public: | |
24 | AliAODTrackCutsDiHadronPID(); // Default Constructor | |
25 | AliAODTrackCutsDiHadronPID(const char* name); // Named Constructor | |
26 | virtual ~AliAODTrackCutsDiHadronPID(); // Destructor | |
27 | virtual Long64_t Merge(TCollection* list); // Merger | |
28 | ||
f054df96 | 29 | private: |
30 | AliAODTrackCutsDiHadronPID(const AliAODTrackCutsDiHadronPID&); | |
31 | AliAODTrackCutsDiHadronPID& operator=(const AliAODTrackCutsDiHadronPID&); | |
32 | ||
97724bd1 | 33 | // ----------------------------------------------------------------------- |
6788af99 | 34 | // Interface, methods used to get information about the track cuts, and to |
35 | // retrieve filled histograms. | |
97724bd1 | 36 | // ----------------------------------------------------------------------- |
6788af99 | 37 | |
38 | public: | |
39 | void PrintCuts(); // Gives an overview of the cuts. | |
40 | ||
41 | // Return the list of QA histos | |
42 | TList* GetListOfDataQAHistos() const{ | |
43 | if (fDataTrackQAHistos) {return fDataTrackQAHistos;} | |
44 | else return 0x0; | |
45 | } | |
46 | TList* GetListOfPrimRecMCTrackQAHistos() const{ | |
47 | if (fPrimRecMCTrackQAHistos) {return fPrimRecMCTrackQAHistos;} | |
48 | else return 0x0; | |
49 | } | |
50 | TList* GetListOfPrimGenMCTrackQAHistos() const { | |
51 | if (fPrimGenMCTrackQAHistos) {return fPrimGenMCTrackQAHistos;} | |
52 | else return 0x0; | |
53 | } | |
54 | TList* GetListOfSecRecMCTrackQAHistos() const { | |
55 | if (fSecRecMCTrackQAHistos) return fSecRecMCTrackQAHistos; | |
56 | else return 0x0; | |
57 | } | |
58 | TList* GetListOfSecGenMCTrackQAHistos() const { | |
59 | if (fSecGenMCTrackQAHistos) return fSecGenMCTrackQAHistos; | |
60 | else return 0x0; | |
61 | } | |
62 | ||
63 | // Note that the PID histograms have in principle a different number of pT bins. | |
64 | // FIXME: This is not very nice... | |
65 | Int_t GetNPtBins() const {return fNPtBins;} | |
66 | Int_t GetNPtBinsPID(Int_t ptclass = -1) const { | |
67 | // if class = -1, then return the sum. | |
68 | if (ptclass == -1) { | |
69 | Int_t nptbinspid = 0; | |
70 | for (Int_t iPtClass = 0; iPtClass < 5; iPtClass++) { | |
71 | nptbinspid += fNPtBinsPID[iPtClass]; | |
72 | } | |
73 | return nptbinspid; | |
74 | } else if (ptclass >= 0 && ptclass < 5) { | |
75 | return fNPtBinsPID[ptclass]; | |
76 | } else {return -999;} | |
77 | } | |
78 | ||
79 | // Returns the Pt axis for PID and other histograms. | |
80 | Double_t* GetPtAxis() {return fPtAxis;} | |
50dfda71 | 81 | Double_t* GetPtAxisPID() const { |
6788af99 | 82 | const Int_t nptbinspid = GetNPtBinsPID(); |
50dfda71 | 83 | Double_t* ptaxis = new Double_t[nptbinspid + 1]; |
6788af99 | 84 | for (Int_t iPtBin = 0; iPtBin < nptbinspid; iPtBin++) { |
85 | ptaxis[iPtBin] = GetPtMinPID(iPtBin + 1); | |
86 | } | |
87 | ptaxis[nptbinspid] = GetPtMaxPID(nptbinspid); | |
88 | return ptaxis; | |
89 | } | |
90 | ||
91 | // Return data histogram with a specific name. Since the histograms are not streamed, and only the | |
92 | // TList containing them is, we have to retrieve them from the list. | |
93 | TObject* GetHistData(const char* name) const {return fDataTrackQAHistos->FindObject(name);} | |
94 | TObject* GetHistPrimRecMC(const char* name) const {return fPrimRecMCTrackQAHistos->FindObject(name);} | |
95 | TObject* GetHistPrimGenMC(const char* name) const {return fPrimGenMCTrackQAHistos->FindObject(name);} | |
96 | TObject* GetHistSecRecMC(const char* name) const {return fSecRecMCTrackQAHistos->FindObject(name);} | |
97 | TObject* GetHistSecGenMC(const char* name) const {return fSecGenMCTrackQAHistos->FindObject(name);} | |
98 | ||
99 | // Since we will often want to have TOF histograms, here are a few methods which return the | |
100 | // appropriate projections. The class does not own these projections, and the user must take care of them. | |
101 | TH1F* GetHistDataTOFProjection(Int_t charge, Int_t species, Int_t ptbin); | |
97724bd1 | 102 | TObjArray* GetDataTOFProjection(Int_t charge, Int_t species); |
6788af99 | 103 | TH1F* GetHistDataTOFMismatch(Int_t charge, Int_t species, Int_t ptbin); |
97724bd1 | 104 | TObjArray* GetDataTOFMismatch(Int_t charge, Int_t species); |
6788af99 | 105 | Double_t GetPtMinPID(Int_t bin) const { |
106 | Int_t ptclass = GetPtClass(bin); | |
7fcceff8 | 107 | if (ptclass == -1) {return -999.;} |
6788af99 | 108 | Int_t bininptclass = GetBinInPtClass(bin); |
109 | Double_t minpt = fPtBoundaryPID[ptclass]; | |
110 | Double_t maxpt = fPtBoundaryPID[ptclass+1]; | |
111 | Double_t ptres = (maxpt - minpt)/((Double_t)fNPtBinsPID[ptclass]); | |
112 | return (minpt + ptres * ((Double_t)(bininptclass - 1)) ); | |
113 | } | |
114 | Double_t GetPtMaxPID(Int_t bin) const { | |
115 | Int_t ptclass = GetPtClass(bin); | |
7fcceff8 | 116 | if (ptclass == -1) {return -999.;} |
6788af99 | 117 | Int_t bininptclass = GetBinInPtClass(bin); |
118 | Double_t minpt = fPtBoundaryPID[ptclass]; | |
119 | Double_t maxpt = fPtBoundaryPID[ptclass+1]; | |
120 | Double_t ptres = (maxpt - minpt)/((Double_t)fNPtBinsPID[ptclass]); | |
121 | return (minpt + ptres * ((Double_t)(bininptclass)) ); | |
122 | } | |
123 | Double_t GetPtClassMin(Int_t ptclass) const { | |
124 | if (ptclass >= 0 && ptclass < 5) { | |
125 | return fPtBoundaryPID[ptclass]; | |
126 | } else {return -999;} | |
127 | } | |
128 | Double_t GetPtClassMax(Int_t ptclass) const { | |
129 | if (ptclass >= 0 && ptclass < 5) { | |
130 | return fPtBoundaryPID[ptclass+1]; | |
131 | } else {return -999;} | |
132 | } | |
133 | ||
134 | Double_t GetPtBinWidthPID(Int_t bin) const {return (GetPtMaxPID(bin) - GetPtMinPID(bin)); } | |
135 | ||
136 | // BE CAREFUL! Following methods do not apply to the ptaxis of the PID histograms! For that, call | |
137 | // the GetPtMinPID and GetPtMaxPID methods. | |
138 | Double_t GetPtMin(Int_t bin) const { | |
139 | if ((bin < 1) || (bin > fNPtBins + 1)) {cout<<"Bin is out of range..."<<endl; return -999.;} | |
140 | else {return fPtAxis[bin - 1];} | |
141 | } | |
142 | Double_t GetPtMax(Int_t bin) const { | |
143 | if ((bin < 1) || (bin > fNPtBins + 1)) {cout<<"Bin is out of range..."<<endl; return -999.;} | |
144 | else {return fPtAxis[bin];} | |
145 | } | |
146 | Double_t GetPtBinWidth(Int_t bin) const {return (GetPtMax(bin) - GetPtMin(bin)); } | |
147 | ||
148 | Int_t GetNTOFbins(Int_t ptclass, Int_t species) const {return fTOFbins[ptclass][species];} | |
149 | Double_t GetTOFmin(Int_t ptclass, Int_t species) const {return fTOFLowerBound[ptclass][species];} | |
150 | Double_t GetTOFmax(Int_t ptclass, Int_t species) const {return fTOFUpperBound[ptclass][species];} | |
151 | ||
152 | Int_t GetNTPCbins(Int_t ptclass, Int_t species) const {return fTPCbins[ptclass][species];} | |
153 | Double_t GetTPCmin(Int_t ptclass, Int_t species) const {return fTPCLowerBound[ptclass][species];} | |
154 | Double_t GetTPCmax(Int_t ptclass, Int_t species) const {return fTPCUpperBound[ptclass][species];} | |
155 | ||
156 | // Getters (Cuts) | |
157 | UInt_t GetFilterMask() const {return fFilterMask;} | |
158 | Double_t GetMaxEta() const {return fMaxEta;} | |
159 | ULong_t GetDemandedFlags() const {return fDemandedFlags;} | |
160 | TFormula* GetPtDeptDCACutFormula() const {return fPtDeptDCAxyCutFormula;} | |
161 | Double_t GetDCAzCut() const {return fDCAzCut;} | |
162 | UInt_t GetMinSPDHitsForPtDeptDCACut() const {return fMinSPDHitsForPtDeptDCAcut;} | |
163 | ||
164 | // Getters (Settings) | |
165 | Bool_t GetIsMC() const {return fIsMC;} | |
166 | ||
167 | Int_t GetDebugLevel() const {return fDebug;} | |
168 | ||
97724bd1 | 169 | // ----------------------------------------------------------------------- |
6788af99 | 170 | // Methods used to configure the track cuts object, to be called at |
171 | // initialization, i.e., before the object is added to an analysis task. | |
97724bd1 | 172 | // ----------------------------------------------------------------------- |
6788af99 | 173 | |
174 | public: | |
175 | ||
176 | // Request Certain QA histograms being filled. | |
177 | Bool_t RequestQAHistos(Int_t histoclass, Bool_t Enable3DSpectra = kFALSE, Bool_t EnablePIDHistos = kFALSE) { | |
178 | if ((histoclass > -1) && (histoclass < 12)) { | |
179 | fHistRequested[histoclass] = kTRUE; | |
180 | f3DSpectraEnabeled[histoclass] = Enable3DSpectra; | |
181 | fPIDHistosEnabeled[histoclass] = EnablePIDHistos; | |
182 | //cout<<"histoclass: "<<histoclass<<" requested: "<<fHistRequested[histoclass]<<endl; | |
183 | return kTRUE; | |
184 | } else { | |
185 | return kFALSE; | |
186 | } | |
187 | } | |
188 | ||
189 | // Setters (Cuts) | |
190 | void SetPtRange(Double_t minpt, Double_t maxpt) { | |
191 | fMinPt = minpt; | |
192 | fMaxPt = maxpt; | |
193 | fTestPt = kTRUE; | |
194 | } | |
195 | void SetFilterMask(UInt_t filtermask) { | |
196 | fFilterMask = filtermask; | |
197 | fTestFilterMask = kTRUE; | |
198 | } | |
199 | void SetMaxEta(Double_t maxeta) { | |
200 | fMaxEta = maxeta; | |
201 | fTestMaxEta = kTRUE; | |
202 | } | |
203 | void SetMaxRapidity(Double_t maxrapidity) { | |
204 | fMaxRapidity = maxrapidity; | |
205 | fTestMaxRapidity = kTRUE; | |
206 | } | |
207 | void SetDemandNoMismatch() { | |
208 | fTestTOFmismatch = kTRUE; | |
209 | } | |
210 | void SetDemandFlags(ULong_t demandedflags) { | |
211 | fDemandedFlags = demandedflags; | |
212 | fTestFlags = kTRUE; | |
213 | } | |
214 | void SetPtDeptDCACut(TFormula* DCAxyCutFormula, Double_t DCAzCut, UInt_t MinSPDHits = 1) { | |
215 | fPtDeptDCAxyCutFormula = DCAxyCutFormula; | |
216 | fDCAzCut = DCAzCut; | |
217 | fMinSPDHitsForPtDeptDCAcut = MinSPDHits; | |
218 | fTestPtDeptDCAcut = kTRUE; | |
219 | } | |
220 | ||
221 | // Setters (Settings) | |
222 | void SetIsMC(Bool_t ismc = kTRUE) {fIsMC = ismc;} | |
223 | ||
224 | void SetDebugLevel(Int_t debuglevel) {fDebug = debuglevel;} | |
225 | ||
97724bd1 | 226 | // ----------------------------------------------------------------------- |
6788af99 | 227 | // Methods called by the analysis task. |
97724bd1 | 228 | // ----------------------------------------------------------------------- |
6788af99 | 229 | |
230 | public: | |
231 | ||
232 | // These two functions signal the beginning and the end of a new event. | |
233 | void StartNewEvent(); // Some things are set to zero. | |
234 | void EventIsDone(Bool_t IsMC); // Some final histograms are filled. | |
235 | void CreateHistos(); // Should be called by the UserCreateOutput() function of the analysis task. | |
236 | ||
237 | // Is Selected, for different types of tracks. | |
238 | Bool_t IsSelectedData(AliTrackDiHadronPID* track, Double_t randomhittime = -1.e20); | |
239 | Bool_t IsSelectedGeneratedMC(AliAODMCParticle* particle); | |
240 | Bool_t IsSelectedReconstructedMC(AliTrackDiHadronPID* track); | |
241 | ||
97724bd1 | 242 | // ----------------------------------------------------------------------- |
6788af99 | 243 | // Internal methods. |
97724bd1 | 244 | // ----------------------------------------------------------------------- |
6788af99 | 245 | |
246 | public: | |
247 | ||
248 | // For PID histograms we have a certain number of bins in pT, spread out over five | |
249 | // large histograms, i.e., one for the lowest pT, and the biggest range in TOF/TPC, | |
250 | // one for the higher pT and smaller range in TOF/TPC, etc. The following methods | |
251 | // are a mapping between the total pT bin (what the user uses), and the pt bin | |
252 | // within one of the five histograms (what's used internally) | |
253 | Int_t GetPtClass(const Int_t ptbin) const { | |
254 | ||
255 | // Returns a number [0..4] | |
256 | Int_t currentptclass = 0; | |
257 | Int_t currentptbin = fNPtBinsPID[0]; | |
258 | while (currentptbin < ptbin) { | |
259 | currentptclass++; | |
260 | if (currentptclass == 5) {break;} | |
261 | currentptbin += fNPtBinsPID[currentptclass]; | |
262 | } | |
263 | if (currentptclass == 5) {cout<<"GetPtClass -> ptbin out of range!"<<endl; return -1;} | |
264 | return currentptclass; | |
265 | } | |
266 | Int_t GetBinInPtClass(const Int_t ptbin) const { | |
267 | ||
268 | // Returns a number [1..Nbins] | |
269 | Int_t ptclass = GetPtClass(ptbin); | |
270 | if (ptclass == -1) {return -1;} | |
271 | ||
272 | Int_t ptbinout = ptbin; | |
273 | for (Int_t iPtClass = 0; iPtClass < ptclass; iPtClass++) {ptbinout -= fNPtBinsPID[iPtClass];} | |
274 | ||
275 | return ptbinout; | |
276 | ||
277 | } | |
278 | ||
279 | private: | |
280 | ||
281 | // Checks, return kTRUE if track passes the cut. | |
282 | Bool_t CheckPt(Double_t pt) const { | |
283 | if (!fTestPt) return kTRUE; | |
284 | if ((pt > fMinPt) && (pt < fMaxPt)) return kTRUE; | |
285 | return kFALSE; | |
286 | } | |
287 | Bool_t CheckMaxEta(Double_t eta) const { | |
288 | if (!fTestMaxEta) return kTRUE; // Accepted if there is no check on this parameter. | |
289 | if (TMath::Abs(eta) < fMaxEta) return kTRUE; | |
290 | return kFALSE; | |
291 | } | |
292 | Bool_t CheckRapidity(Double_t rap) const { | |
293 | if (!fTestMaxRapidity) return kTRUE; | |
294 | if (TMath::Abs(rap) < fMaxRapidity) return kTRUE; | |
295 | return kFALSE; | |
296 | } | |
297 | Bool_t CheckFilterMask(UInt_t filtermap) const { | |
298 | if (!fTestFilterMask) return kTRUE; | |
299 | if ((fFilterMask & filtermap) == fFilterMask) return kTRUE; | |
300 | return kFALSE; | |
301 | } | |
302 | Bool_t CheckFlags(ULong_t flags) const { | |
303 | if (!fTestFlags) return kTRUE; | |
304 | if ((flags & fDemandedFlags) == fDemandedFlags) return kTRUE; | |
305 | return kFALSE; | |
306 | } | |
307 | Bool_t CheckTOFmismatch(Bool_t ismismatch) const { | |
308 | if (!fTestTOFmismatch) return kTRUE; // if we're not cutting on mismatch, then it's accepted. | |
309 | if (!ismismatch) return kTRUE; // so if the track is not a mismatch, then it is accepted. | |
310 | return kFALSE; // if it is a mismatch, then it's not accepted. | |
311 | } | |
312 | Bool_t CheckPtDeptDCACut(Double_t dcaz, Double_t dcaxy, Double_t pt, UInt_t SPDhits) const { | |
313 | if (!fTestPtDeptDCAcut) return kTRUE; | |
314 | if (SPDhits < fMinSPDHitsForPtDeptDCAcut) return kTRUE; // If there are not enough SPD hits to do the cut. | |
315 | if ((dcaz < fDCAzCut) && (dcaxy < fPtDeptDCAxyCutFormula->Eval(pt))) return kTRUE; | |
316 | return kFALSE; | |
317 | } | |
318 | ||
319 | // Filling QA histograms. | |
320 | Bool_t FillDataHistos(Int_t histoclass, AliTrackDiHadronPID* track); | |
321 | Bool_t FillTOFMismatchHistos(Int_t histoclass, AliTrackDiHadronPID* track, Double_t randomhittime); | |
322 | Bool_t FillGenMCHistos(Int_t histoclass, AliAODMCParticle* particle); | |
323 | Bool_t FillRecMCHistos(Int_t histoclass, AliTrackDiHadronPID* track); | |
324 | ||
325 | // Initializing QA histograms. | |
326 | Bool_t InitializeDataHistos(Int_t histoclass); | |
327 | Bool_t InitializeGenMCHistos(Int_t histoclass); | |
328 | Bool_t InitializeRecMCHistos(Int_t histoclass); | |
329 | ||
330 | void InitializeDefaultHistoNamesAndAxes(); | |
331 | ||
332 | TH1F* InitializePtSpectrum(const char* name, Int_t histoclass); | |
50dfda71 | 333 | TH3F* InitializePhiEtaPt(const char* name, Int_t histoclass); |
6788af99 | 334 | TH1F* InitializeNTracksHisto(const char* name, Int_t histoclass); |
335 | TH1F* InitializeDCAxyHisto(const char* name, Int_t histoclass); | |
336 | TH1F* InitializeDCAzHisto(const char* name, Int_t histoclass); | |
337 | TH3F* InitializeAcceptanceHisto(const char* /*name*/, Int_t /*histoclass*/); // TO BE IMPLEMENTED. | |
338 | TH2F* InitializeDCASpectrum(const char* name, Int_t histoclass); | |
339 | ||
340 | ||
341 | TH3F* InitializePIDHisto(const char* name, Int_t histoclass, Int_t expspecies, Int_t ptclass); | |
342 | TH2F* InitializeTOFMismatchHisto(const char* name, Int_t histoclass, Int_t expspecies, Int_t ptclass); | |
343 | ||
97724bd1 | 344 | // ----------------------------------------------------------------------- |
6788af99 | 345 | // Data members. |
97724bd1 | 346 | // ----------------------------------------------------------------------- |
6788af99 | 347 | |
348 | private: | |
349 | // Track Cuts | |
350 | Double_t fMinPt; | |
351 | Double_t fMaxPt; | |
352 | UInt_t fFilterMask; // FilterMask to-be-checked. | |
353 | Double_t fMaxEta; // Max Eta of the track. | |
354 | Double_t fMaxRapidity; // Rapidity cut (only done for PID plots!!) | |
355 | ULong_t fDemandedFlags; // Flags demanded on the track. | |
356 | UInt_t fMinSPDHitsForPtDeptDCAcut; // Required number of SPD hits for performing Pt-Dept DCA cut. | |
357 | TFormula* fPtDeptDCAxyCutFormula; // Formula for the Pt-Dept DCA cut. | |
358 | Double_t fDCAzCut; // Max z at DCA. | |
359 | ||
360 | // Settings | |
361 | Bool_t fIsMC; // Is the current event MC or not. | |
362 | ||
363 | // Requested Histograms; | |
364 | Bool_t fHistRequested[12]; // | |
365 | Bool_t f3DSpectraEnabeled[12]; // | |
366 | Bool_t fPIDHistosEnabeled[12]; // | |
367 | ||
368 | // Which Track Cuts will be tested. | |
369 | Bool_t fTestPt; // | |
370 | Bool_t fTestFilterMask; // | |
371 | Bool_t fTestMaxEta; // | |
372 | Bool_t fTestMaxRapidity; // | |
373 | Bool_t fTestFlags; // | |
374 | Bool_t fTestTOFmismatch; // | |
375 | Bool_t fTestPtDeptDCAcut; // | |
376 | ||
377 | // QA histograms for Data. | |
378 | TList* fDataTrackQAHistos; // | |
379 | TH1F* fHistDataPt[3]; //! Pt distribution of tracks passing this cut. | |
50dfda71 | 380 | TH3F* fHistDataPhiEtaPt[3]; //! Pt, Eta, Phi distribution. |
6788af99 | 381 | TH1F* fHistDataNTracks[3]; //! Number of tracks passing the cut per event (filling by EventIsDone()). |
382 | TH1F* fHistDataDCAxy[3]; //! DCA_{xy} distribution. | |
383 | TH1F* fHistDataDCAz[3]; //! DCA_{z} distribution | |
384 | TH2F* fHistDataDCAxyOneSigma[12]; //! DCA_{xy} distribution of particles as identified by 1 sigma method. | |
7fcceff8 | 385 | Int_t fNTracks[12]; //! Number of tracks |
6788af99 | 386 | |
387 | TH3F* fHistDataPID[3][3][5]; //! TPC/TOF v.s. pT, [charge][mass assumption][ptclass] | |
388 | TH2F* fHistTOFMismatch[3][3][5]; //! TOF Mismatch histograms, [charge][mass assumption][ptclass] | |
97724bd1 | 389 | TH3F* fHistTPCTOFMismatch[3][3][5]; //! TPC/TOF mismatch histograms (Same as TOF, but now the TPC hit of the track is included.) |
6788af99 | 390 | |
391 | // QA histograms for Primary Reconstructed MC tracks. | |
392 | TList* fPrimRecMCTrackQAHistos; // | |
393 | TH1F* fHistPrimRecMCPt[12]; //! Pt distribution of reconstructed MC track passing this cut. | |
394 | TH1F* fHistPrimRecNTracks[12]; //! | |
395 | TH2F* fHistPrimRecMCDCA[12]; //! DCA_xy distribution of reconstructed MC track passing this cut. | |
396 | ||
397 | // QA histograms for Primary Generated MC particles. | |
398 | TList* fPrimGenMCTrackQAHistos; // | |
399 | TH1F* fHistPrimGenMCPt[12]; //! Pt distribution of generated MC particles passing this cut. | |
400 | ||
401 | // QA histograms for Secondary Reconstructed MC tracks. | |
402 | TList* fSecRecMCTrackQAHistos; // | |
403 | TH1F* fHistSecRecMCPt[12]; //! Pt distribution of reconstructed MC track passing this cut. | |
404 | TH2F* fHistSecRecMCDCAMat[12]; //! DCA_xy distribution of material decay particles. | |
405 | TH2F* fHistSecRecMCDCAWeak[12]; //! DCA_xy distribution of weak decay. | |
406 | ||
407 | // QA histograms for Secondary Generated MC particles. | |
408 | TList* fSecGenMCTrackQAHistos; // | |
409 | TH1F* fHistSecGenMCPt[12]; //! Pt distribution of generated MC particles passing this cut. | |
410 | ||
411 | // Binning of all the histograms. | |
50dfda71 | 412 | Double_t fPtAxis[57]; // Pt axis used in all histograms, except PID and Mismatch histograms. |
6788af99 | 413 | Int_t fNPtBins; // Number of bins in the pt-axis. |
50dfda71 | 414 | Int_t fNEtaBins; // |
415 | Int_t fNPhiBins; // | |
6788af99 | 416 | |
417 | Double_t fPtBoundaryPID[6]; // There are five different PID histo's. This array gives the pT range of these histograms. | |
418 | Int_t fNPtBinsPID[5]; // This array gives the number of pT bins for each of these histograms. | |
419 | ||
420 | Double_t fTOFLowerBound[5][3]; // These arrays give the lower and upper bound of the TOF axes, | |
421 | Double_t fTOFUpperBound[5][3]; // for each species, as well as the number of bins. The numbers | |
422 | Int_t fTOFbins[5][3]; // size of the array is [ptrange][species]. | |
423 | ||
424 | Double_t fTPCLowerBound[5][3]; // The same, but now for TPC. | |
425 | Double_t fTPCUpperBound[5][3]; | |
426 | Int_t fTPCbins[5][3]; | |
427 | ||
428 | // Naming conventions of the histograms. | |
429 | TString fHistoName[12]; // Names of the histogram classes. | |
430 | TString fHistoLatex[12]; // Names of the histogram classes in LaTeX. | |
431 | TString fParticleName[3]; // Names of the particles (Pion, Kaon, Proton) | |
432 | TString fPtClassName[5]; // Names of the ptclasses (should only be for internal use) | |
433 | ||
434 | Int_t fDebug; // Debug flag. | |
435 | ||
97724bd1 | 436 | ClassDef(AliAODTrackCutsDiHadronPID,5); |
6788af99 | 437 | |
438 | }; | |
439 | ||
440 | #endif |