]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGCF/FEMTOSCOPY/K0Analysis/PLamAnalysis/AliAnalysisTaskProtonLambda.h
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'feature-movesplit'
[u/mrichter/AliRoot.git] / PWGCF / FEMTOSCOPY / K0Analysis / PLamAnalysis / AliAnalysisTaskProtonLambda.h
CommitLineData
369a736f 1#ifndef ALIANALYSISTASKPROTONLAMBDA_H
2#define ALIANALYSISTASKPROTONLAMBDA_H
3
4/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5 * See cxx source for full Copyright notice */
6
7// Task to study femtoscopic proton-lambda correlations
8// Author: Hans Beck, Hans.Beck@cern.ch
9
10// Includes. All classes used in the .h file need to be included.
11// Your task compiles with forward declaration and including in the .cxx
12// file, but forward declaration will fail when loading this task from
13// a library and just including this .h file.
14/* #include <TH1F.h> */
15/* #include <TH2F.h> */
16/* #include <TH3F.h> */
17/* #include <TList.h> */
18/* #include <TAxis.h> */
19class TH1F;
20class TH2F;
21class TH3F;
22#include <THnSparse.h>
23class TList;
24class TAxis;
25
26#include <AliAnalysisTaskSE.h>
27/* #include <AliTPCPIDResponse.h> */
28/* #include <AliPIDResponse.h> */
29class AliTPCPIDResponse;
30class AliPIDResponse;
31
32#include <AliAODEvent.h>
33#include <AliAODVertex.h>
34#include <AliAODv0.h>
35#include <AliAODTrack.h>
36
37class AliAnalysisTaskProtonLambda : public AliAnalysisTaskSE {
38 // Forward declaration for nested classes
39 private:
40 class FemtoBufferTrack;
41 class FemtoBufferV0;
42 class FemtoBufferEvent;
43 class FemtoBuffer;
44 public:
45 AliAnalysisTaskProtonLambda(); // Dummy constructor
46 AliAnalysisTaskProtonLambda(const char *name); // Constructor
47 virtual ~AliAnalysisTaskProtonLambda(); // Destructor
48 AliAnalysisTaskProtonLambda(const AliAnalysisTaskProtonLambda& atpl); // Not implemented
49 AliAnalysisTaskProtonLambda& operator=(const AliAnalysisTaskProtonLambda& atpl); //Not implemented
50
51 void UserCreateOutputObjects(); // Called once at the beginning
52 void UserExec(Option_t *option); // Main loop
53 void Terminate(Option_t *); // Called once at the end
54
55 private:
56 void ProcessOffline(AliAODv0 *v0, AliAODTrack *pTrack, AliAODTrack *nTrack); //! Use offline V0 finder
57 void ProcessOnTheFly(AliAODv0 *v0, AliAODTrack *pTrack, AliAODTrack *nTrack); //! Use on-the-fly V0 finder
58 void ProcessTOF(AliAODTrack *track); // Use Tof for 1.0 GeV/c < p < 3.25 GeV/c
59 void ProcessTPC(AliAODTrack *track); // Use TPC for p < 0.75 GeV/c
60 void ProcessHybrid(AliAODTrack *track); // Preselection via TPC, identification w/ Tof 0.75 GeV/c < p < 1.0 GeV/c
61 void CleaningProcedure(); // Assure uniqueness of all daughters and primaries
62 void ProcessReal(); // TTR cut & qinv calc for real events
63 void ProcessMixed(); // TTR cut & qinv calc for mixed events
64 void ProcessRealBackground(); // Check procedure with lambda background from sideband, real events
65 void ProcessMixedBackground(); // Check procedure with lambda background from sideband, real events
66
67 Float_t Qinv(FemtoBufferV0 v01, FemtoBufferV0 v02); // Calcs Qinv for (anti-)Lam(anti-)Lam
68 Float_t Qinv(FemtoBufferV0 v0, FemtoBufferTrack track); // Calcs Qinv for (anti-)Lam(anti-)Pro
69 Float_t Qinv(FemtoBufferTrack track, FemtoBufferV0 v0); // Calls Qinv(v0, track)
70 Float_t QinvProPro(FemtoBufferTrack proTrack1,
71 FemtoBufferTrack proTrack2); // Calcs Qinv for proton proton
72 Float_t QinvPioPro(FemtoBufferTrack pioTrack,
73 FemtoBufferTrack proTrack); // Calcs Qinv for pion proton
74 Float_t QinvConstr(FemtoBufferV0 v0, FemtoBufferTrack track); // w/ vtx constraint for pri pro
75 Float_t QinvConstr(FemtoBufferTrack track, FemtoBufferV0 v0); // Calls QinvConstr(v0, track)
76 Float_t Minv(FemtoBufferV0 v01, FemtoBufferV0 v02); // Calcs Minv for (anti-)Lam(anti-)Lam
77 Float_t Minv(FemtoBufferV0 v0, FemtoBufferTrack track); // Calcs Minv for (anti-)Lam(anti-)Pro
78 Float_t Minv(FemtoBufferTrack track, FemtoBufferV0 v0); // Calls Minv(v0, track)
79 Float_t mt(FemtoBufferTrack track, FemtoBufferV0 v0); // mt of pair
80 Float_t mt(FemtoBufferV0 v0, FemtoBufferTrack track); // ""
81 Float_t mt(FemtoBufferV0 v01, FemtoBufferV0 v02); // ""
82 static Float_t ktSquared(FemtoBufferV0 v01, FemtoBufferV0 v02); // kt squared
83 static Float_t ktSquared(FemtoBufferTrack track, FemtoBufferV0 v0); // ""
84 static Float_t ktSquared(FemtoBufferV0 v0, FemtoBufferTrack track); // ""
85 static Float_t calcDist(const Float_t r1[3], const Float_t r2[3]); // Calcs the distance between vector r1 and r2
86 // static Float_t calcDistSft(const Float_t r1[3], const Float_t r2[3],
87 // const FemtoBufferEvent *evt1,
88 // const FemtoBufferEvent *evt2); // Calcs the distance between vector r1 and r2 shifting them first to originate both in (0,0,0)
89 Bool_t goodDCA(AliAODTrack *track); //! Does a cut on the DCAxy value and fills a histogram
90 Float_t RapidityProton(AliAODTrack *track); //! Rapidity assuming proton mass
91 // void getTPConlyV0Info(const AliAODTrack *posDaughter,const AliAODTrack *negDaughter, Double_t tpcV0Mom[3], Double_t TPConlyV0MinvLam, Double_t TPConlyV0MinvALam); //! Get V0 momentum and invariant mass using TPC only tracks
92
93 // For AOD tracks, need a function to get the dca
94 static Float_t DCAxy(const AliAODTrack *track, const AliVEvent *evt);
95 void StoreGlobalTrackReference(AliAODTrack *track); // Store pointer to global track
96 void ResetGlobalTrackReference(); // Reset all pointers to global tracks
97 Bool_t acceptTrack(const AliAODTrack *track); // Famous crossed rows / findable clusters
98 Bool_t GoodTPCFitMapSharedMap(const AliAODTrack *track); // Rejects shared clusters, primaries
99 Bool_t GoodTPCFitMapSharedMap(const AliAODTrack *pTrack,
100 const AliAODTrack *nTrack);// Rejects shared clusters, two V0 daughters
101 Float_t GetCorrectedTOFSignal(const AliVTrack *track); // Return correct TOF signal for old and new AODs
102 void FillDedxHist(const AliVTrack *track); // Fill dE/dx histograms
103
104 const Bool_t fkUseOnTheFly; //! Use on-the-fly or offline V0 finder
105 const Float_t fkAbsZvertexCut; //! Values of Zvertex and centrality cut
106 const Float_t fkCentCut; //! are needed for event mixing
107 const Float_t fkLamMass; //! PDG-Mass of the lambda particle
108 const Float_t fkProMass; //! PDG-Mass of the lambda particle
109 const Float_t fkPioMass; //! PDG-Mass of the lambda particle
110
111 Double_t fPrimaryVtxPosition[3]; //! Position of prim. vertex
112
113 AliPIDResponse *fPIDResponse; //! PID response object
114 AliTPCPIDResponse *fTpcResponse; //! Bethe-Bloch parametrisation
115
116
117 FemtoBuffer *fFemtoBuffer; //! Event mixing: event collection
118
119 AliAODEvent *fAOD; //! AOD event
120 AliAODVertex *fPrimaryVtx; //! AOD vertex
121
122 TList *fOutputList; //! V0 output list
123 TList *fOutputPrimaries; //! Primaries output list
124 TList *fOutput2Part; //! Two-particle output list
125
126 // Store pointers to global tracks for pid and dca
127 AliAODTrack **fGTI; //! Array of pointers, just nicely sorted according to the id
128 const UShort_t fTrackBuffSize; //! Size fo the above array, ~12000 for PbPb
129 //
130 //! --------- Histograms ---------
131 //
132 TH1F *fHistGoodEvent; //! Control hist for event cuts
133
134 // Low memory version: just get rid of a lot of histograms
135 /* TH2F *fHistPrimaryVertexPosXY; //! Primary vertex position in XY */
136 /* TH1F *fHistPrimaryVertexPosZ; //! Primary vertex position in Z */
137 /* TH1F *fHistTrackMultiplicity; //! Track multiplicity distribution */
138
139 /* TH1F *fHistShareV0pos; //! Number of shared clusters, V0 pos daughter */
140 /* TH1F *fHistShareV0neg; //! Number of shared clusters, V0 neg daughter */
141
142 /* TH2F *fHistPosTofBeforeCut; //! Tof signal for pos. daughter w/o cut */
143 /* TH2F *fHistPosTofAfterCut; //! Tof signal for pos. daughter with cut */
144 /* TH2F *fHistNegTofBeforeCut; //! Tof signal for pos. daughter w/o cut */
145 /* TH2F *fHistNegTofAfterCut; //! Tof signal for pos. daughter with cut */
146 /* TH2F *fHistPosTpcBeforeCut; //! Tpc signal for pos. daughter w/o cut */
147 /* TH2F *fHistPosTpcAfterCut; //! Tpc signal for pos. daughter with cut */
148 /* TH2F *fHistNegTpcBeforeCut; //! Tpc signal for pos. daughter w/o cut */
149 /* TH2F *fHistNegTpcAfterCut; //! Tpc signal for pos. daughter with cut */
150
151 /* TH2F *fHistGoodV0; //! Control histogram for cuts */
152 /* TH2F *fHistCorrectSigns; //! Check of sign of tracks */
153 /* TH2F *fHistDcaPosToPrimVertex; //! DCA of pos daughter to primary vertex */
154 /* TH2F *fHistDcaNegToPrimVertex; //! DCA of neg daughter to primary vertex */
155 /* TH2F *fHistDcaPosToPrimVertexZoom; //! Zoom */
156 /* TH2F *fHistDcaNegToPrimVertexZoom; //! Zoom */
157 /* TH2F *fHistRadiusV0; //! Radial position of V0 vertex */
158 /* TH2F *fHistDecayLengthV0; //! Dist prim. vertex - V0 vertex */
159 /* TH2F *fHistDcaV0Daughters; //! DCA of daughters */
160 /* TH2F *fHistChi2; //! Chi2 for V0 vertex */
161 /* TH2F *fHistCosPointAngle; //! Cosine of pointing angle */
162 /* TH2F *fHistCosPointAngleZoom; //! Zoom */
163
164 TH1F *fHistSideBandOffLam; //! Off: side band background lambda
165 TH1F *fHistSideBandOffALam; //! Off: side band background anti-lambda
166
167 TH2F *fHistTPCNclsPosOffLam; //! Off: lam-mass vs TPCNcls(pos daughter)
168 TH2F *fHistTPCNclsNegOffLam; //! Off: lam-mass vs TPCNcls(neg daughter)
169 TH2F *fHistTPCNclsPosOffALam; //! Off: alam-mass vs TPCNcls(pos daughter)
170 TH2F *fHistTPCNclsNegOffALam; //! Off: alam-mass vs TPCNcls(neg daughter)
171 /* TH2F *fHistPosNsigmaTpcOffLam; //! */
172 /* TH2F *fHistPosNsigmaTpcOffALam; //! */
173 /* TH2F *fHistNegNsigmaTpcOffLam; //! */
174 /* TH2F *fHistNegNsigmaTpcOffALam; //! */
175 /* TH2F *fHistUseTofOffLam; //! */
176 /* TH2F *fHistUseTofOffALam; //! */
177 /* TH2F *fHistDcaPosOffLam; //! Off: lam-mass vs DCA(pos - prim. vertex) */
178 /* TH2F *fHistDcaPosOffALam; //! Off: alam-mass vs DCA(pos - prim. vertex) */
179 /* TH2F *fHistDcaNegOffLam; //! Off: lam-mass vs DCA(neg - prim. vertex) */
180 /* TH2F *fHistDcaNegOffALam; //! Off: alam-mass vs DCA(neg - prim. vertex) */
181 /* TH2F *fHistDcaV0DaughtersOffLam; //! Off: lam-mass vs DCA(V0-daughters) */
182 /* TH2F *fHistDcaV0DaughtersOffALam; //! Off: alam-mass vs DCA(V0-daughters) */
183 /* TH2F *fHistCosPointLamOff; //! Off: lam-mass vs cosine(pointing angle) */
184 /* TH2F *fHistCosPointALamOff; //! Off: Alam-mass vs cosine(pointing angle) */
185 /* TH2F *fHistCosPointLamZoomOff; //! Zoom */
186 /* TH2F *fHistCosPointALamZoomOff; //! Zoom */
187 /* TH2F *fHistV0RadiusLamOff; //! Off: lam-mass vs radial position(V0) */
188 /* TH2F *fHistV0RadiusALamOff; //! Off: alam-mass vs radial position(V0) */
189 /* TH2F *fHistV0DecayLengthLamOff; //! Off: lam-mass vs decay length(V0) */
190 /* TH2F *fHistV0DecayLengthALamOff; //! Off: alam-mass vs decay length(V0) */
191 /* TH2F *fHistDcaV0PriVertexLamOff; //! Off: lam-mass vs dca (prim. vertex - V0) */
192 /* TH2F *fHistDcaV0PriVertexALamOff; //! Off: alam-mass vs dca (prim. vertex - V0) */
193 TH1F *fHistMassLambdaOff; //! Off: invariant mass assuming lambda
194 TH1F *fHistMassAntiLambdaOff; //! Off: invariant mass assuming anti-lambda
195 /* TH2F *fHistPtVsMassLambdaOff; //! Off: lam-mass vs pt(V0) */
196 /* TH2F *fHistPtVsMassAntiLambdaOff; //! Off: alam-mass vs pt(V0) */
197 TH3F *fHistYPtMassLamOff; //! Off: lam-mass vs y-pt
198 TH3F *fHistYPtMassALamOff; //! Off: alam-mass vs y-pt
199 /* TH2F *fHistPtVsYLambdaOff; //! Off: y-pt (lambda) */
200 /* TH2F *fHistPtVsYAntiLambdaOff; //! Off: y-pt (anti-lambda) */
201
202 TH1F *fHistSideBandOnLam; //! On-the-fly: side band background lambda
203 TH1F *fHistSideBandOnALam; //! On-the-fly: side band background anti-lambda
204
205 /* TH2F *fHistLikeSignOnLam; //! On-the-fly: lambda mass vs signs of pairs */
206 /* TH2F *fHistLikeSignOnALam; //! On-the-fly: antilambda mass vs signs of pairs */
207 TH2F *fHistTPCNclsPosOnLam; //! On: lam-mass vs TPCNcls(pos daughter)
208 TH2F *fHistTPCNclsNegOnLam; //! On: lam-mass vs TPCNcls(neg daughter)
209 TH2F *fHistTPCNclsPosOnALam; //! On: alam-mass vs TPCNcls(pos daughter)
210 TH2F *fHistTPCNclsNegOnALam; //! On: alam-mass vs TPCNcls(neg daughter)
211 /* TH2F *fHistPosNsigmaTpcOnLam; //! */
212 /* TH2F *fHistPosNsigmaTpcOnALam; //! */
213 /* TH2F *fHistNegNsigmaTpcOnLam; //! */
214 /* TH2F *fHistNegNsigmaTpcOnALam; //! */
215 /* TH2F *fHistUseTofOnLam; //! */
216 /* TH2F *fHistUseTofOnALam; //! */
217 /* TH2F *fHistDcaPosOnLam; //! On: lam-mass vs DCA(pos - prim. vertex) */
218 /* TH2F *fHistDcaPosOnALam; //! On: alam-mass vs DCA(pos - prim. vertex) */
219 /* TH2F *fHistDcaNegOnLam; //! On: lam-mass vs DCA(neg - prim. vertex) */
220 /* TH2F *fHistDcaNegOnALam; //! On: alam-mass vs DCA(neg - prim. vertex) */
221 /* TH2F *fHistDcaV0DaughtersOnLam; //! On: lam-mass vs DCA(V0-daughters) */
222 /* TH2F *fHistDcaV0DaughtersOnALam; //! On: alam-mass vs DCA(V0-daughters) */
223 /* TH2F *fHistCosPointLamOn; //! On: lam-mass vs cosine(pointing angle) */
224 /* TH2F *fHistCosPointALamOn; //! On: Alam-mass vs cosine(pointing angle) */
225 /* TH2F *fHistCosPointLamZoomOn; //! Zoom */
226 /* TH2F *fHistCosPointALamZoomOn; //! Zoom */
227 /* TH2F *fHistV0RadiusLamOn; //! On: lam-mass vs radial position(V0) */
228 /* TH2F *fHistV0RadiusALamOn; //! On: alam-mass vs radial position(V0) */
229 /* TH2F *fHistV0DecayLengthLamOn; //! On: lam-mass vs decay length(V0) */
230 /* TH2F *fHistV0DecayLengthALamOn; //! On: alam-mass vs decay length(V0) */
231 /* TH2F *fHistDcaV0PriVertexLamOn; //! On: lam-mass vs dca (prim. vertex - V0) */
232 /* TH2F *fHistDcaV0PriVertexALamOn; //! On: alam-mass vs dca (prim. vertex - V0) */
233 /* TH2F *fHistChi2TPCPosLamOn; //! On: Chi2 TPC clusters */
234 /* TH2F *fHistChi2TPCPosALamOn; //! */
235 /* TH2F *fHistChi2TPCNegLamOn; //! */
236 /* TH2F *fHistChi2TPCNegALamOn; //! */
237 /* TH1F *fHistMinvTPConlyLamOn; //! On: minv w/ TPC only daughters, lambda */
238 /* TH1F *fHistMinvTPConlyALamOn; //! On: --""-- , anti-lambda */
239 TH1F *fHistMassLambdaOn; //! On: invariant mass assuming lambda
240 TH1F *fHistMassAntiLambdaOn; //! On: invariant mass assuming anti-lambda
241 /* TH2F *fHistPtVsMassLambdaOn; //! On: lam-mass vs pt(V0) */
242 /* TH2F *fHistPtVsMassAntiLambdaOn; //! On: alam-mass vs pt(V0) */
243 TH3F *fHistYPtMassLamOn; //! On: lam-mass vs y-pt
244 TH3F *fHistYPtMassALamOn; //! On: alam-mass vs y-pt
245 /* TH2F *fHistPtVsYLambdaOn; //! On: y-pt (lambda) */
246 /* TH2F *fHistPtVsYAntiLambdaOn; //! On: y-pt (anti-lambda) */
247
248 /* TH3F *fHistMomDiffLam; //! Momentum difference standard V0 / */
249 /* TH3F *fHistMomDiffALam; //! TPC only V0 */
250 /* TH3F *fHistMomDiffBgLam; //! */
251 /* TH3F *fHistMomDiffBgALam; //! */
252 /* TH3F *fHistMomDiffWoSPDLam; //! Momentum difference standard V0 / */
253 /* TH3F *fHistMomDiffWoSPDALam; //! TPC only V0, only tracks without */
254 /* TH3F *fHistMomDiffWoSPDBgLam; //! SPD hits */
255 /* TH3F *fHistMomDiffWoSPDBgALam; //! */
256
257 // Primary particles
258 TH1F *fPriHistShare; //! Primaries: number of shared clusters
259 // ToF histograms
260 /* TH1F *fPriHistPosNsigmaTof; //! Primaries: Nsigma TOF distribution (pos) */
261 TH2F *fPriHistPosNsigmaTofVsP; //! Pri: Nsigma TOF vs total momentum (pos)
262 TH2F *fPriHistPosNsigmaTofVsPt; //! Pri: Nsigma TOF vs transverse momentum (pos)
263 /* TH1F *fPriHistNegNsigmaTof; //! Primaries: Nsigma TOF distribution (neg) */
264 TH2F *fPriHistNegNsigmaTofVsP; //! Pri: Nsigma TOF vs total momentum (neg)
265 TH2F *fPriHistNegNsigmaTofVsPt; //! Pri: Nsigma TOF vs transverse momentum (neg)
266 TH2F *fPriHistTOFsignalPosVsP; //! Pri: TOF signal vs p (pos)
267 TH2F *fPriHistTOFsignalPosVsPt; //! Pri: TOF signal vs pt (pos)
268 TH2F *fPriHistTOFsignalNegVsP; //! Pri: TOF signal vs p (neg)
269 TH2F *fPriHistTOFsignalNegVsPt; //! Pri: TOF signal vs pt (neg)
270 // Hybrid analysis: dEdx & ToF histograms
271 TH1F *fPriHistHybridTOFsigPosWoTPC; //! Pri: TOF signal without dEdx selection (pos)
272 TH1F *fPriHistHybridTOFsigPosTPCok; //! Pri: TOF signal with dEdx selection (pos)
273 TH1F *fPriHistHybridTOFsigNegWoTPC; //! Pri: TOF signal without dEdx selection (neg)
274 TH1F *fPriHistHybridTOFsigNegTPCok; //! Pri: TOF signal with dEdx selection (neg)
275
276 /* TH1F *fPriHistHasTofPos; //! Pri: 1 = TOFpid bit is there, 0 else */
277 TH2F *fPriHistTPCsignalPos; //! Pri: TPC dE/dx signal vs p
278 /* TH2F *fPriHistNsigmaTPCPos; //! Pri: Nsigma TPC distribution vs p */
279 /* TH2F *fPriHistTPCsignalTOFcutPos; //! Pri: dE/dx vs p + TOF sigma(proton) > -10 */
280 /* TH2F *fPriHistNsigmaTPCTOFcutPos; //! Pri: Nsigma TPC vs p + TOF sigma(proton) > -10 */
281 TH2F *fPriHistTPCsignalLowPPos; //! Pri: dEdx for 0.1 < p < 0.3
282 TH2F *fPriHistTPCsignalMedPPos; //! Pri: dEdx for 0.3 < p < 0.9
283 TH2F *fPriHistTPCsignalHigPPos; //! Pri: dEdx for 0.9 < p < 1.9
284
285 /* TH1F *fPriHistHasTofNeg; //! Pri: 1 = TOFpid bit is there, 0 else */
286 TH2F *fPriHistTPCsignalNeg; //! Pri: TPC dE/dx signal vs p
287 /* TH2F *fPriHistNsigmaTPCNeg; //! Pri: Nsigma TPC distribution vs p */
288 /* TH2F *fPriHistTPCsignalTOFcutNeg; //! Pri: " + TOF sigma(proton) > -10 */
289 /* TH2F *fPriHistNsigmaTPCTOFcutNeg; //! Pri: Nsigma TPC vs p + TOF sigma(proton) > -10 */
290 TH2F *fPriHistTPCsignalLowPNeg; //! Pri: dEdx for 0.1 < p < 0.3
291 TH2F *fPriHistTPCsignalMedPNeg; //! Pri: dEdx for 0.3 < p < 0.9
292 TH2F *fPriHistTPCsignalHigPNeg; //! Pri: dEdx for 0.9 < p < 1.9
293
294 TH3F *fPriHistDCAxyYPtPro; //! Pri: DCAxy vs (y,pt) for protons
295 TH3F *fPriHistDCAxyYPtAPro; //! Pri: DCAxy vs (y,pt) for anti-protons
296
297 /* // Histograms for two particle observables */
298 /* TH2F *f2HistLamLamMeanMinDistProReal; //! TTR: Real events */
299 /* TH2F *f2HistLamLamMeanMinDistPioReal; //! */
300 /* TH2F *f2HistLamProMeanMinDistProReal; //! */
301 /* TH2F *f2HistALamALamMeanMinDistAProReal; //! */
302 /* TH2F *f2HistALamALamMeanMinDistPioReal; //! */
303 /* TH2F *f2HistALamAProMeanMinDistAProReal; //! */
304 /* TH2F *f2HistSftLamLamMeanMinDistProReal; //! TTR: Shifted pri vtx */
305 /* TH2F *f2HistSftLamLamMeanMinDistPioReal; //! */
306 /* TH2F *f2HistSftLamProMeanMinDistProReal; //! */
307 /* TH2F *f2HistSftALamALamMeanMinDistAProReal; //! */
308 /* TH2F *f2HistSftALamALamMeanMinDistPioReal; //! */
309 /* TH2F *f2HistSftALamAProMeanMinDistAProReal; //! */
310 /* TH2F *f2HistSftIrocLamLamMeanMinDistProReal; //! TTR: Shifted pri vtx: IROCs */
311 /* TH2F *f2HistSftIrocLamLamMeanMinDistPioReal; //! */
312 /* TH2F *f2HistSftIrocLamProMeanMinDistProReal; //! */
313 /* TH2F *f2HistSftIrocALamALamMeanMinDistAProReal; //! */
314 /* TH2F *f2HistSftIrocALamALamMeanMinDistPioReal; //! */
315 /* TH2F *f2HistSftIrocALamAProMeanMinDistAProReal; //! */
316 /* TH2F *f2HistSftOrocLamLamMeanMinDistProReal; //! TTR: Shifted pri vtx: OROCs */
317 /* TH2F *f2HistSftOrocLamLamMeanMinDistPioReal; //! */
318 /* TH2F *f2HistSftOrocLamProMeanMinDistProReal; //! */
319 /* TH2F *f2HistSftOrocALamALamMeanMinDistAProReal; //! */
320 /* TH2F *f2HistSftOrocALamALamMeanMinDistPioReal; //! */
321 /* TH2F *f2HistSftOrocALamAProMeanMinDistAProReal; //! */
322
323 // transverse mass mt of the pair
324 /* TH1F *f2HistMtLamLamReal; //! */
325 TH1F *f2HistMtLamProReal; //!
326 /* TH1F *f2HistMtALamALamReal; //! */
327 TH1F *f2HistMtALamAProReal; //!
328 // .. for low q pairs only
329 /* TH1F *f2HistMtLowQLamLamReal; //! */
330 TH1F *f2HistMtLowQLamProReal; //!
331 /* TH1F *f2HistMtLowQALamALamReal; //! */
332 TH1F *f2HistMtLowQALamAProReal; //!
333
334 // September '12: use a THnSparseF with 4 dimensions
335 // for pro lam: qinv propro, mean d propro
336 // min d propro, qinv lampro
337 THnSparseF *LamProReal; //!
338 THnSparseF *ALamAProReal;//!
339
340 // Changed on march 4th: all correlation functions vs
341 // distances to try out diff. cuts
342 /* TH3F *f3HistLamLamQinvReal; //! Qinv distribution real events */
343 /* TH3F *f3HistALamALamQinvReal; //! */
344 /* TH3F *f3HistLamLamMinvReal; //! Minv distribution real events */
345 /* TH3F *f3HistLamProMinvReal; //! */
346 /* TH3F *f3HistALamALamMinvReal; //! */
347 /* TH3F *f3HistALamAProMinvReal; //! */
348
349 // Background lambdas: real events
350 /* TH2F *f2HistBgLamBgLamMeanMinDistProReal; //! TTR: Real events */
351 /* TH2F *f2HistBgLamBgLamMeanMinDistPioReal; //! */
352 /* TH2F *f2HistBgLamProMeanMinDistProReal; //! */
353 /* TH2F *f2HistBgALamBgALamMeanMinDistAProReal;//! */
354 /* TH2F *f2HistBgALamBgALamMeanMinDistPioReal; //! */
355 /* TH2F *f2HistBgALamAProMeanMinDistAProReal; //! */
356 /* TH2F *f2HistSftBgLamBgLamMeanMinDistProReal; //! TTR: Shifted pri vtx */
357 /* TH2F *f2HistSftBgLamBgLamMeanMinDistPioReal; //! */
358 /* TH2F *f2HistSftBgLamProMeanMinDistProReal; //! */
359 /* TH2F *f2HistSftBgALamBgALamMeanMinDistAProReal;//! */
360 /* TH2F *f2HistSftBgALamBgALamMeanMinDistPioReal; //! */
361 /* TH2F *f2HistSftBgALamAProMeanMinDistAProReal; //! */
362 /* TH2F *f2HistSftIrocBgLamBgLamMeanMinDistProReal; //! TTR: Shifted pri vtx: IROCs */
363 /* TH2F *f2HistSftIrocBgLamBgLamMeanMinDistPioReal; //! */
364 /* TH2F *f2HistSftIrocBgLamProMeanMinDistProReal; //! */
365 /* TH2F *f2HistSftIrocBgALamBgALamMeanMinDistAProReal;//! */
366 /* TH2F *f2HistSftIrocBgALamBgALamMeanMinDistPioReal; //! */
367 /* TH2F *f2HistSftIrocBgALamAProMeanMinDistAProReal; //! */
368 /* TH2F *f2HistSftOrocBgLamBgLamMeanMinDistProReal; //! TTR: Shifted pri vtx: OROCs */
369 /* TH2F *f2HistSftOrocBgLamBgLamMeanMinDistPioReal; //! */
370 /* TH2F *f2HistSftOrocBgLamProMeanMinDistProReal; //! */
371 /* TH2F *f2HistSftOrocBgALamBgALamMeanMinDistAProReal;//! */
372 /* TH2F *f2HistSftOrocBgALamBgALamMeanMinDistPioReal; //! */
373 /* TH2F *f2HistSftOrocBgALamAProMeanMinDistAProReal; //! */
374
375 // September '12: use a THnSparseF with 4 dimensions
376 // for pro lam: qinv propro, mean d propro
377 // min d propro, qinv lampro
378 THnSparseF *BgLamProReal; //!
379 THnSparseF *BgALamAProReal;//!
380
381 /* TH3F *f3HistBgLamBgLamQinvReal; //! Qinv distribution real events */
382 /* TH3F *f3HistBgALamBgALamQinvReal; //! */
383
384 // Mixed events
385 /* TH2F *f2HistLamLamMeanMinDistProMixed; //! TTR: Mixed events */
386 /* TH2F *f2HistLamLamMeanMinDistPioMixed; //! */
387 /* TH2F *f2HistLamProMeanMinDistProMixed; //! */
388 /* TH2F *f2HistALamALamMeanMinDistAProMixed; //! */
389 /* TH2F *f2HistALamALamMeanMinDistPioMixed; //! */
390 /* TH2F *f2HistALamAProMeanMinDistAProMixed; //! */
391 /* TH2F *f2HistSftLamLamMeanMinDistProMixed; //! TTR: Mixed events, shifted pri vtx */
392 /* TH2F *f2HistSftLamLamMeanMinDistPioMixed; //! */
393 /* TH2F *f2HistSftLamProMeanMinDistProMixed; //! */
394 /* TH2F *f2HistSftALamALamMeanMinDistAProMixed; //! */
395 /* TH2F *f2HistSftALamALamMeanMinDistPioMixed; //! */
396 /* TH2F *f2HistSftALamAProMeanMinDistAProMixed; //! */
397 /* TH2F *f2HistSftIrocLamLamMeanMinDistProMixed; //! TTR: Mixed events, shifted pri vtx, IROCs */
398 /* TH2F *f2HistSftIrocLamLamMeanMinDistPioMixed; //! */
399 /* TH2F *f2HistSftIrocLamProMeanMinDistProMixed; //! */
400 /* TH2F *f2HistSftIrocALamALamMeanMinDistAProMixed; //! */
401 /* TH2F *f2HistSftIrocALamALamMeanMinDistPioMixed; //! */
402 /* TH2F *f2HistSftIrocALamAProMeanMinDistAProMixed; //! */
403 /* TH2F *f2HistSftOrocLamLamMeanMinDistProMixed; //! TTR: Mixed events, shifted pri vtx, OROCs */
404 /* TH2F *f2HistSftOrocLamLamMeanMinDistPioMixed; //! */
405 /* TH2F *f2HistSftOrocLamProMeanMinDistProMixed; //! */
406 /* TH2F *f2HistSftOrocALamALamMeanMinDistAProMixed; //! */
407 /* TH2F *f2HistSftOrocALamALamMeanMinDistPioMixed; //! */
408 /* TH2F *f2HistSftOrocALamAProMeanMinDistAProMixed; //! */
409
410 // September '12: use a THnSparseF with 4 dimensions
411 // for pro lam: qinv propro, mean d propro
412 // min d propro, qinv lampro
413 THnSparseF *LamProMixed; //!
414 THnSparseF *ALamAProMixed;//!
415
416 /* TH3F *f3HistLamLamQinvMixed; //! Qinv distribution mixed events */
417 /* TH3F *f3HistALamALamQinvMixed; //! */
418 /* TH3F *f3HistLamLamMinvMixed; //! Minv distribution mixed events */
419 /* TH3F *f3HistLamProMinvMixed; //! */
420 /* TH3F *f3HistALamALamMinvMixed; //! */
421 /* TH3F *f3HistALamAProMinvMixed; //! */
422 // Background lambdas: mixed events
423 /* TH2F *f2HistBgLamBgLamMeanMinDistProMixed; //! TTR: Mixed events */
424 /* TH2F *f2HistBgLamBgLamMeanMinDistPioMixed; //! */
425 /* TH2F *f2HistBgLamProMeanMinDistProMixed; //! */
426 /* TH2F *f2HistBgALamBgALamMeanMinDistAProMixed;//! */
427 /* TH2F *f2HistBgALamBgALamMeanMinDistPioMixed; //! */
428 /* TH2F *f2HistBgALamAProMeanMinDistAProMixed; //! */
429 /* TH2F *f2HistSftBgLamBgLamMeanMinDistProMixed; //! TTR: Mixed events, shifted pri vtx */
430 /* TH2F *f2HistSftBgLamBgLamMeanMinDistPioMixed; //! */
431 /* TH2F *f2HistSftBgLamProMeanMinDistProMixed; //! */
432 /* TH2F *f2HistSftBgALamBgALamMeanMinDistAProMixed;//! */
433 /* TH2F *f2HistSftBgALamBgALamMeanMinDistPioMixed; //! */
434 /* TH2F *f2HistSftBgALamAProMeanMinDistAProMixed; //! */
435 /* TH2F *f2HistSftIrocBgLamBgLamMeanMinDistProMixed; //! TTR: Mixed events, shifted pri vtx, IROCs */
436 /* TH2F *f2HistSftIrocBgLamBgLamMeanMinDistPioMixed; //! */
437 /* TH2F *f2HistSftIrocBgLamProMeanMinDistProMixed; //! */
438 /* TH2F *f2HistSftIrocBgALamBgALamMeanMinDistAProMixed;//! */
439 /* TH2F *f2HistSftIrocBgALamBgALamMeanMinDistPioMixed; //! */
440 /* TH2F *f2HistSftIrocBgALamAProMeanMinDistAProMixed; //! */
441 /* TH2F *f2HistSftOrocBgLamBgLamMeanMinDistProMixed; //! TTR: Mixed events, shifted pri vtx, OROCs */
442 /* TH2F *f2HistSftOrocBgLamBgLamMeanMinDistPioMixed; //! */
443 /* TH2F *f2HistSftOrocBgLamProMeanMinDistProMixed; //! */
444 /* TH2F *f2HistSftOrocBgALamBgALamMeanMinDistAProMixed;//! */
445 /* TH2F *f2HistSftOrocBgALamBgALamMeanMinDistPioMixed; //! */
446 /* TH2F *f2HistSftOrocBgALamAProMeanMinDistAProMixed; //! */
447
448 // September '12: use a THnSparseF with 4 dimensions
449 // for pro lam: qinv propro, mean d propro
450 // min d propro, qinv lampro
451 THnSparseF *BgLamProMixed; //!
452 THnSparseF *BgALamAProMixed; //!
453
454 /* TH3F *f3HistBgLamBgLamQinvMixed; //! Qinv distribution mixed events */
455 /* TH3F *f3HistBgALamBgALamQinvMixed; //! */
456
457 private:
458 // ------------------------------------
459 //
460 // Nested classes for event mixing
461 // Features are
462 // * low memory usage as only needed variables
463 // are stored and not, e.g., the full AliAODTrack
464 // * it's fast, as memory allocation occours
465 // only once and no deep copying is done
466 // when doing the fifo shift and reseting
467 // the event. Resetting and shifting could
468 // be reduced to only a few integer assignments.
469 //
470 // ------------------------------------
471
472
473 class FemtoBufferTrack{// Charged tracks
474 public:
475 FemtoBufferTrack(); // Constructor
476 FemtoBufferTrack(const AliAODTrack *track,
477 const Float_t bfield,
478 const Float_t priVtx[3]); // Constructor
479 ~FemtoBufferTrack(){;} // Destructor, nothing to do.
480 FemtoBufferTrack(const FemtoBufferTrack& fbt); // Copy constructor
481 FemtoBufferTrack& operator=(const FemtoBufferTrack& fbt); // Assignment operator
482 void Set(const AliAODTrack *track, // Set parameters of the FemtoBufferTrack
483 const Float_t bfield, // to these of the given AliAODtrack
484 const Float_t priVtx[3]);
485 void Set(const AliAODTrack *track, // Overloaded fct that just
486 const Float_t bfield, // calls Set(..,Float)
487 const Double_t priVtx[3]);
488 // Two functions to get the global and shifted positions. Both is not trivial as
489 // tracks in ALICE get propagated in the local system
490 // Shifted for studying all events shifted to (0,0,0)
491 void GetShiftedPositionAtShiftedRadii(const AliAODTrack *track,
492 const Float_t bfield, const Float_t priVtx[3]);
493 // Global if not shifted
494 void GetGlobalPositionAtGlobalRadii(const AliAODTrack *track,
495 const Float_t bfield);
496 Bool_t UseIt() const {return fID!=65535;} // Use entry? eg. set to false by cleaning procedure
497 void SetBadFlag(){fID=65535;} // Can only set 'bad track' flag
498 // Interpretation of ALICE coding rule RC14 is that FemtoBufferTrack is a private member
499 // of AliAnalysisTaskProtonLambda, so the following data member are private
500 UShort_t fID; //! Unique track id (->AliAODTrack.h), UShort_t goes to 65000
501 Double_t fP[3]; //! Momentum of track
502 /* Float_t fXglobal[9][3]; //! Global positions at different global radii */
503 Float_t fXshifted[9][3]; //! Shifted positions at different shifted radii
504 };
505
506 class FemtoBufferV0{// V0 vertices
507 public:
508 // Constructors n stuff
509 FemtoBufferV0(); // Constructor
510 FemtoBufferV0(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter,
511 const Double_t bfield, Double_t priVtxPos[3]); // Constructor
512 ~FemtoBufferV0(){;} // Destructor, nothing to do.
513 FemtoBufferV0(const FemtoBufferV0 &fbv); // Copy constructor
514 FemtoBufferV0& operator=(const FemtoBufferV0 &fbv);// Assignment operator
515 // Functions
516 void Set(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter
517 ,const Double_t bfield, Double_t priVtxPos[3]); // Set properties of this to these of v0
518 Bool_t UseIt() const {return fCosPoint>0;} // Use entry? eg. set to false by cleaning procedure
519 void SetBadFlag(){fCosPoint=-9999.;fPosDaughter.SetBadFlag();
520 fNegDaughter.SetBadFlag();} // Can only set 'bad track' flag
521 // Data member
522 Double_t fP[3]; //! Momentum (x,y,z)
523 Float_t fCosPoint; //! Cosine of pointing angle
524 FemtoBufferTrack fPosDaughter; //! Positive daughter of the V0
525 FemtoBufferTrack fNegDaughter; //! Negative daughter fo the V0
526 };
527
528 class FemtoBufferEvent{// Event
529 public:
530 FemtoBufferEvent(); // Constructor
531 FemtoBufferEvent(const UShort_t priTrackBuff,const UShort_t V0Buff,
532 const Double_t bfield,const Double_t priVtxPos[3]); // Constructor
533 FemtoBufferEvent(const UShort_t priTrackBuff,const UShort_t V0Buff); // Constructor
534 FemtoBufferEvent(const FemtoBufferEvent &fbe); // Copy constructor
535 // Assignment operator won't change the size of the arrays!
536 FemtoBufferEvent& operator=(const FemtoBufferEvent &fbe); // Assignment operator
537 ~FemtoBufferEvent(); // Destructor
538 void Reset(const Double_t bfield, const Double_t priVtxPos[3]);// Resets the event with new variables given
539
540 // Functions to add particles to the event
541 void AddPro(const AliAODTrack *track); // Add a proton to this event
542 void AddAPro(const AliAODTrack *track); // Add a anti-proton this actual event
543 void AddLam(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter);
544 // Add a lamba to this event
545 void AddALam(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter);
546 // Add a anti-lambda to this event
547 void AddBgLam(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter);
548 // Add lambda background to this event
549 void AddBgALam(const AliAODv0 *v0,const AliAODTrack *posDaughter,const AliAODTrack *negDaughter);
550 // Add anti-lambda background to this event
551
552 // Getters for the event properties, no setters as you're not supposed to change them :)
553 // The fBfield and fPriVtxPos get set on each 'reset' for a new event and the limits get set
554 // on creation of the event
555 Double_t GetBfield()const{return fBfield;} // Getter for magnetic field of event
556 void GetVtxPos(Double_t xyz[3])const{for(Int_t i=0;i<3;i++)xyz[i]=fPriVtxPos[i];} // Get the xyz of the vertex.
557 UShort_t GetPriTrackLim()const{return fPriTrackLim;} // Get the size of the array for primary tracks
558 UShort_t GetV0Lim()const{return fV0Lim;} // Get the size of the array for V0s
559 // The number of tracks stored in the event
560 UShort_t GetNPro()const{return fNProTracks;} // Number of stored protons
561 UShort_t GetNAPro()const{return fNAProTracks;} // .. anti-protons
562 UShort_t GetNLam()const{return fNLamTracks;} // .. lambda
563 UShort_t GetNALam()const{return fNALamTracks;} // .. anti-lambda
564 UShort_t GetNBgLam()const{return fNBgLamTracks;} // .. background lambda
565 UShort_t GetNBgALam()const{return fNBgALamTracks;} // .. background anti-lambda
566
567 // Data member, sorry for this private public private mixture,
568 // but what's this reorder warning? sometimes it's there, st not..
569 private:
570 // Size of the arrays for tracks. Constant and private to reflect the idea that
571 // the arrays get allocated only once to avoid excessive memory allocation
572 const UShort_t fPriTrackLim; // Limit for primary tracks
573 const UShort_t fV0Lim; // Limit for V0s
574 public:
575 // Pointer to array of ...
576 FemtoBufferTrack *fProTracks; //! Proton tracks
577 FemtoBufferTrack *fAProTracks; //! Anti-proton tracks
578
579 FemtoBufferV0 *fLamTracks; //! Lambda tracks
580 FemtoBufferV0 *fALamTracks; //! Anti-lambda tracks
581
582 FemtoBufferV0 *fBgLamTracks; //! Background lambda tracks
583 FemtoBufferV0 *fBgALamTracks; //! Background anti-lambda tracks
584 private:
585 // Number of stored tracks in the event
586 UShort_t fNProTracks; // Number of stored protons
587 UShort_t fNAProTracks; // Number of stored anti-protons
588 UShort_t fNLamTracks; // Number of stored lambdas
589 UShort_t fNALamTracks; // Number of stored anti-lambdas
590 UShort_t fNBgLamTracks; // Number of stored lambdas
591 UShort_t fNBgALamTracks; // Number of stored anti-lambdas
592
593 // Double_t needed??? magnetic field probably is like 5.0 and not 5.0000120047
594 Double_t fBfield; // Magnetic field in ALICE unit [kG]
595 Double_t fPriVtxPos[3]; // Primary vtx position
596 };
597
598 class FemtoBuffer { // Holds the events
599 public:
600 FemtoBuffer(); // Dummy constructor
601 FemtoBuffer(const UChar_t ZvertexBins,const UChar_t CentBins,const UChar_t MixBuff,
602 const UShort_t PriTrackLim,const UShort_t V0Lim,const Float_t AbsZvertexCut,const Float_t CentCut); // Constructor
603 FemtoBuffer(const FemtoBuffer &fb); //Ctor
604 FemtoBuffer& operator=(const AliAnalysisTaskProtonLambda::FemtoBuffer&); // Assignment
605 ~FemtoBuffer(); // Destructor
606 void ShiftAndAdd(AliAODEvent *evt); // Discard last event, shift all, set first one
607 void ShiftAndAdd(const Double_t bfield,const Double_t priVtxPos[3],const Float_t centrality); // Discard last event, shift all, set first one
608 FemtoBufferEvent *GetEvt(const UChar_t i)const{return fCurEvt[i];}; // Returns a pointer to the i'th event of the current event mixing class
609 UChar_t GetMixBuffSize()const{return fkMixBuffSize;}// Returns the number of events held in every mixing bin
610
611 private:
612 const UChar_t fkZvertexBins; // Number of bins in Zvertex
613 const UChar_t fkCentBins; // Number of bins in centrality
614 const UChar_t fkMixBuffSize; // Number of stored events
615 const UShort_t fkPriTrackLim; // Buffer size protons per event
616 const UShort_t fkV0Lim; // Buffer size lambdas per event
617
618 const TAxis *fZvertexAxis; //! To find Zvertex bin
619 const TAxis *fCentAxis; //! To find centrality bin
620
621 FemtoBufferEvent **fCurEvt;//! Array of pointer to the set of the current events
622 // Note that the pointer won't be constant
623 FemtoBufferEvent ****fEC; //! The internal thing where the events
624 // are stored.
625 // fEC stands for event collection.
626 };
627
628 ClassDef(AliAnalysisTaskProtonLambda, 1);
629};
630
631#endif