a7459fa2aeac2901cdf294b027c08e0617cd3cbe
[u/mrichter/AliRoot.git] / PWG2 / SPECTRA / AliAnalysisTaskCheckCascade.cxx
1
2 /**************************************************************************
3  *  Authors : Antonin Maire, Boris Hippolyte                              *
4  * Contributors are mentioned in the code where appropriate.              *
5  *                                                                        *
6  * Permission to use, copy, modify and distribute this software and its   *
7  * documentation strictly for non-commercial purposes is hereby granted   *
8  * without fee, provided that the above copyright notice appears in all   *
9  * copies and that both the copyright notice and this permission notice   *
10  * appear in the supporting documentation. The authors make no claims     *
11  * about the suitability of this software for any purpose. It is          *
12  * provided "as is" without express or implied warranty.                  *
13  **************************************************************************/
14
15 //-----------------------------------------------------------------
16 //                 AliAnalysisTaskCheckCascade class
17 //            (AliAnalysisTaskCheckCascade)
18 //            This task has four roles :
19 //              1. QAing the Cascades from ESD and AOD
20 //                 Origin:  AliAnalysisTaskESDCheckV0 by B.H. Nov2007, hippolyt@in2p3.fr
21 //              2. Prepare the plots which stand as raw material for yield extraction (wi/wo PID)
22 //              3. Supply an AliCFContainer meant to define the optimised topological selections
23 //              4. Rough azimuthal correlation study (Eta, Phi)
24 //            Adapted to Cascade : A.Maire Mar2008, antonin.maire@ires.in2p3.fr
25 //            Modified :           A.Maire Nov2010, antonin.maire@ires.in2p3.fr
26 //-----------------------------------------------------------------
27
28
29
30 class TTree;
31 class TParticle;
32
33 //class AliMCEventHandler;
34 //class AliMCEvent;
35 //class AliStack;
36
37 class AliESDVertex;
38 class AliAODVertex;
39 class AliESDv0;
40 class AliAODv0;
41
42 #include <Riostream.h>
43 #include "TList.h"
44 #include "TH1.h"
45 #include "TH2.h"
46 #include "TH3.h"
47 #include "THnSparse.h"
48 #include "TVector3.h"
49 #include "TCanvas.h"
50 #include "TMath.h"
51 #include "TLegend.h"
52
53
54 #include "AliLog.h"
55
56 #include "AliESDEvent.h"
57 #include "AliAODEvent.h"
58 //     #include "AliV0vertexer.h"
59 //     #include "AliCascadeVertexer.h"
60 #include "AliESDpid.h"
61 #include "AliESDtrackCuts.h"
62
63 #include "AliInputEventHandler.h"
64 #include "AliAnalysisManager.h"
65 #include "AliMCEventHandler.h"
66
67 #include "AliCFContainer.h"
68 #include "AliMultiplicity.h"
69
70 #include "AliESDcascade.h"
71 #include "AliAODcascade.h"
72
73 #include "AliAnalysisTaskCheckCascade.h"
74
75 ClassImp(AliAnalysisTaskCheckCascade)
76
77
78
79 //________________________________________________________________________
80 AliAnalysisTaskCheckCascade::AliAnalysisTaskCheckCascade() 
81   : AliAnalysisTaskSE(), fAnalysisType("ESD"), fTriggerMaskType("kMB"), fCollidingSystems(0), fESDpid(0), fESDtrackCuts(0), /*fPaveTextBookKeeping(0),*/
82     fkRerunV0CascVertexers         (0),
83     fkQualityCutZprimVtxPos        (kTRUE),
84     fkRejectEventPileUp            (kTRUE),
85     fkQualityCutNoTPConlyPrimVtx   (kTRUE),
86     fkQualityCutTPCrefit           (kTRUE),
87     fkQualityCut80TPCcls           (kTRUE),
88     fkIsDataRecoWith1PadTPCCluster (kTRUE),
89     fkExtraSelections              (0),
90     fAngularCorrelationType        ("TrigLeadingTrck-AssoCasc"),
91
92         // - Cascade part initialisation
93     fListHistCascade(0),
94     fHistCascadeMultiplicityBeforeTrigSel(0),
95     fHistCascadeMultiplicityForTrigEvt(0), fHistTrackMultiplicityForTrigEvt(0), fHistTPCrefitTrackMultiplicityForTrigEvt(0), fHistPrimaryTrackMultiplicityForTrigEvt(0),
96     fHistCascadeMultiplicityForTrigEvtAndZprimVtx(0), fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx(0),
97     fHistCascadeMultiplicityForSelEvt(0),
98     fHistPosBestPrimaryVtxXForSelEvt(0), fHistPosBestPrimaryVtxYForSelEvt(0), fHistPosBestPrimaryVtxZForSelEvt(0),
99     fHistTPCrefitTrackMultiplicityForCascadeEvt(0), fHistPrimaryTrackMultiplicityForCascadeEvt(0),
100     fHistPosV0TPCClusters(0), fHistNegV0TPCClusters(0), fHistBachTPCClusters(0),
101     fHistVtxStatus(0),
102
103     fHistPosTrkgPrimaryVtxXForCascadeEvt(0), fHistPosTrkgPrimaryVtxYForCascadeEvt(0), fHistPosTrkgPrimaryVtxZForCascadeEvt(0), fHistTrkgPrimaryVtxRadius(0),
104     fHistPosBestPrimaryVtxXForCascadeEvt(0), fHistPosBestPrimaryVtxYForCascadeEvt(0), fHistPosBestPrimaryVtxZForCascadeEvt(0), fHistBestPrimaryVtxRadius(0),
105     f2dHistTrkgPrimVtxVsBestPrimVtx(0),
106
107     fHistEffMassXi(0),  fHistChi2Xi(0),  
108     fHistDcaXiDaughters(0), fHistDcaBachToPrimVertex(0), fHistXiCosineOfPointingAngle(0), fHistXiRadius(0),
109
110     fHistMassLambdaAsCascDghter(0),
111     fHistV0Chi2Xi(0),
112     fHistDcaV0DaughtersXi(0),
113     fHistDcaV0ToPrimVertexXi(0), 
114     fHistV0CosineOfPointingAngleXi(0),
115     fHistV0RadiusXi(0),
116     fHistDcaPosToPrimVertexXi(0), fHistDcaNegToPrimVertexXi(0), 
117
118     fHistMassXiMinus(0), fHistMassXiPlus(0),
119     fHistMassOmegaMinus(0), fHistMassOmegaPlus(0),
120     fHistMassWithCombPIDXiMinus(0), fHistMassWithCombPIDXiPlus(0),
121     fHistMassWithCombPIDOmegaMinus(0), fHistMassWithCombPIDOmegaPlus(0),
122
123     fHistXiTransvMom(0),    fHistXiTotMom(0),
124     fHistBachTransvMomXi(0),   fHistBachTotMomXi(0),
125
126     fHistChargeXi(0),
127     fHistV0toXiCosineOfPointingAngle(0),
128
129     fHistRapXi(0), fHistRapOmega(0), fHistEtaXi(0),
130     fHistThetaXi(0), fHistPhiXi(0),
131
132     fHistcTauXiMinus(0), fHistcTauXiPlus(0), fHistcTauOmegaMinus(0), fHistcTauOmegaPlus(0),
133
134     f2dHistArmenteros(0),                       
135     f2dHistEffMassLambdaVsEffMassXiMinus(0), f2dHistEffMassXiVsEffMassOmegaMinus(0),
136     f2dHistEffMassLambdaVsEffMassXiPlus(0), f2dHistEffMassXiVsEffMassOmegaPlus(0),
137     f2dHistXiRadiusVsEffMassXiMinus(0), f2dHistXiRadiusVsEffMassXiPlus(0),
138     f2dHistXiRadiusVsEffMassOmegaMinus(0), f2dHistXiRadiusVsEffMassOmegaPlus(0),
139     
140     f2dHistTPCdEdxOfCascDghters(0),
141     
142     f3dHistXiPtVsEffMassVsYXiMinus(0), f3dHistXiPtVsEffMassVsYXiPlus(0),
143     f3dHistXiPtVsEffMassVsYOmegaMinus(0), f3dHistXiPtVsEffMassVsYOmegaPlus(0),
144     
145     fCFContCascadePIDXiMinus(0),
146     fCFContCascadePIDXiPlus(0),
147     fCFContCascadePIDOmegaMinus(0),
148     fCFContCascadePIDOmegaPlus(0),
149     fCFContCascadeCuts(0),
150     
151     fHnSpAngularCorrXiMinus(0), fHnSpAngularCorrXiPlus(0), 
152     fHnSpAngularCorrOmegaMinus(0), fHnSpAngularCorrOmegaPlus(0)
153
154 {
155   // Dummy Constructor
156         for(Int_t iAlephIdx   = 0; iAlephIdx   < 5; iAlephIdx++   ) { fAlephParameters [iAlephIdx]    = -1.; }
157         for(Int_t iV0selIdx   = 0; iV0selIdx   < 7; iV0selIdx++   ) { fV0Sels          [iV0selIdx   ] = -1.; }
158         for(Int_t iCascSelIdx = 0; iCascSelIdx < 8; iCascSelIdx++ ) { fCascSels        [iCascSelIdx ] = -1.; }
159 }
160
161
162
163
164
165
166
167
168 //________________________________________________________________________
169 AliAnalysisTaskCheckCascade::AliAnalysisTaskCheckCascade(const char *name) 
170   : AliAnalysisTaskSE(name), fAnalysisType("ESD"), fTriggerMaskType("kMB"), fCollidingSystems(0), fESDpid(0), fESDtrackCuts(0), /*fPaveTextBookKeeping(0),*/
171     fkRerunV0CascVertexers         (0),
172     fkQualityCutZprimVtxPos        (kTRUE),
173     fkRejectEventPileUp            (kTRUE),
174     fkQualityCutNoTPConlyPrimVtx   (kTRUE),
175     fkQualityCutTPCrefit           (kTRUE),
176     fkQualityCut80TPCcls           (kTRUE),
177     fkIsDataRecoWith1PadTPCCluster (kTRUE),
178     fkExtraSelections              (0),
179     fAngularCorrelationType        ("TrigLeadingTrck-AssoCasc"),
180      
181         // - Cascade part initialisation
182     fListHistCascade(0),
183     fHistCascadeMultiplicityBeforeTrigSel(0),
184     fHistCascadeMultiplicityForTrigEvt(0), fHistTrackMultiplicityForTrigEvt(0), fHistTPCrefitTrackMultiplicityForTrigEvt(0), fHistPrimaryTrackMultiplicityForTrigEvt(0),
185     fHistCascadeMultiplicityForTrigEvtAndZprimVtx(0), fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx(0),
186     fHistCascadeMultiplicityForSelEvt(0),
187     fHistPosBestPrimaryVtxXForSelEvt(0), fHistPosBestPrimaryVtxYForSelEvt(0), fHistPosBestPrimaryVtxZForSelEvt(0),
188     fHistTPCrefitTrackMultiplicityForCascadeEvt(0), fHistPrimaryTrackMultiplicityForCascadeEvt(0),
189     fHistPosV0TPCClusters(0), fHistNegV0TPCClusters(0), fHistBachTPCClusters(0),
190     fHistVtxStatus(0),
191
192     fHistPosTrkgPrimaryVtxXForCascadeEvt(0), fHistPosTrkgPrimaryVtxYForCascadeEvt(0), fHistPosTrkgPrimaryVtxZForCascadeEvt(0), fHistTrkgPrimaryVtxRadius(0),
193     fHistPosBestPrimaryVtxXForCascadeEvt(0), fHistPosBestPrimaryVtxYForCascadeEvt(0), fHistPosBestPrimaryVtxZForCascadeEvt(0), fHistBestPrimaryVtxRadius(0),
194     f2dHistTrkgPrimVtxVsBestPrimVtx(0),
195
196     fHistEffMassXi(0),  fHistChi2Xi(0),  
197     fHistDcaXiDaughters(0), fHistDcaBachToPrimVertex(0), fHistXiCosineOfPointingAngle(0), fHistXiRadius(0),
198
199     fHistMassLambdaAsCascDghter(0),
200     fHistV0Chi2Xi(0),
201     fHistDcaV0DaughtersXi(0),
202     fHistDcaV0ToPrimVertexXi(0), 
203     fHistV0CosineOfPointingAngleXi(0),
204     fHistV0RadiusXi(0),
205     fHistDcaPosToPrimVertexXi(0), fHistDcaNegToPrimVertexXi(0), 
206
207     fHistMassXiMinus(0), fHistMassXiPlus(0),
208     fHistMassOmegaMinus(0), fHistMassOmegaPlus(0),
209     fHistMassWithCombPIDXiMinus(0), fHistMassWithCombPIDXiPlus(0),
210     fHistMassWithCombPIDOmegaMinus(0), fHistMassWithCombPIDOmegaPlus(0),
211
212     fHistXiTransvMom(0),    fHistXiTotMom(0),
213     fHistBachTransvMomXi(0),   fHistBachTotMomXi(0),
214
215     fHistChargeXi(0),
216     fHistV0toXiCosineOfPointingAngle(0),
217
218     fHistRapXi(0), fHistRapOmega(0), fHistEtaXi(0),
219     fHistThetaXi(0), fHistPhiXi(0),
220
221     fHistcTauXiMinus(0), fHistcTauXiPlus(0), fHistcTauOmegaMinus(0), fHistcTauOmegaPlus(0),
222
223     f2dHistArmenteros(0),                       
224     f2dHistEffMassLambdaVsEffMassXiMinus(0), f2dHistEffMassXiVsEffMassOmegaMinus(0),
225     f2dHistEffMassLambdaVsEffMassXiPlus(0), f2dHistEffMassXiVsEffMassOmegaPlus(0),
226     f2dHistXiRadiusVsEffMassXiMinus(0), f2dHistXiRadiusVsEffMassXiPlus(0),
227     f2dHistXiRadiusVsEffMassOmegaMinus(0), f2dHistXiRadiusVsEffMassOmegaPlus(0),
228     
229     f2dHistTPCdEdxOfCascDghters(0),
230     
231     f3dHistXiPtVsEffMassVsYXiMinus(0), f3dHistXiPtVsEffMassVsYXiPlus(0),
232     f3dHistXiPtVsEffMassVsYOmegaMinus(0), f3dHistXiPtVsEffMassVsYOmegaPlus(0),
233     
234     fCFContCascadePIDXiMinus(0),
235     fCFContCascadePIDXiPlus(0),
236     fCFContCascadePIDOmegaMinus(0),
237     fCFContCascadePIDOmegaPlus(0),
238     fCFContCascadeCuts(0),
239     
240     fHnSpAngularCorrXiMinus(0), fHnSpAngularCorrXiPlus(0), 
241     fHnSpAngularCorrOmegaMinus(0), fHnSpAngularCorrOmegaPlus(0)
242
243 {
244   // Constructor
245
246   // Define input and output slots here
247   // Input slot #0 works with a TChain
248   // DefineInput(0, TChain::Class());
249   // Output slot #1 writes into a TList container (cascade)
250         
251         for(Int_t iAlephIdx   = 0; iAlephIdx   < 5; iAlephIdx++   ) { fAlephParameters [iAlephIdx]    = -1.; }
252         
253         // Loose
254         /*
255 //         fV0Sels[0] =  33.  ;  // max allowed chi2
256 //         fV0Sels[1] =   0.01;  // min allowed impact parameter for the 1st daughter (LHC09a4 : 0.05)
257 //         fV0Sels[2] =   0.01;  // min allowed impact parameter for the 2nd daughter (LHC09a4 : 0.05)
258 //         fV0Sels[3] =   2.0 ;  // max allowed DCA between the daughter tracks       (LHC09a4 : 0.5)
259 //         fV0Sels[4] =   0.0 ;  // min allowed cosine of V0's pointing angle         (LHC09a4 : 0.99)
260 //         fV0Sels[5] =   0.2 ;  // min radius of the fiducial volume                 (LHC09a4 : 0.2)
261 //         fV0Sels[6] = 100.  ;  // max radius of the fiducial volume                 (LHC09a4 : 100.0)
262 //         
263 //         fCascSels[0] =  33.   ;  // max allowed chi2 (same as PDC07)
264 //         fCascSels[1] =   0.02 ;  // min allowed V0 impact parameter                    (PDC07 : 0.05   / LHC09a4 : 0.025 )
265 //         fCascSels[2] =   0.008;  // "window" around the Lambda mass                    (PDC07 : 0.008  / LHC09a4 : 0.010 )
266 //         fCascSels[3] =   0.01 ;  // min allowed bachelor's impact parameter            (PDC07 : 0.035  / LHC09a4 : 0.025 )
267 //         fCascSels[4] =   0.5  ;  // max allowed DCA between the V0 and the bachelor    (PDC07 : 0.1    / LHC09a4 : 0.2   )
268 //         fCascSels[5] =   0.98 ;  // min allowed cosine of the cascade pointing angle   (PDC07 : 0.9985 / LHC09a4 : 0.998 )
269 //         fCascSels[6] =   0.2  ;  // min radius of the fiducial volume                  (PDC07 : 0.9    / LHC09a4 : 0.2   )
270 //         fCascSels[7] = 100.   ;  // max radius of the fiducial volume                  (PDC07 : 100    / LHC09a4 : 100   )
271         */
272         
273         
274         // Hyper Loose "à la 900 GeV 2009 data", with lower cosine of pointing angle for Xi (0.95 down to 0.82) = 900 GeV paper
275         
276         fV0Sels[0] =  33.  ;  // max allowed chi2
277         fV0Sels[1] =   0.001; // min allowed impact parameter for the 1st daughter (LHC09a4 : 0.05)
278         fV0Sels[2] =   0.001; // min allowed impact parameter for the 2nd daughter (LHC09a4 : 0.05)
279         fV0Sels[3] =   5.0 ;  // max allowed DCA between the daughter tracks       (LHC09a4 : 0.5)
280         fV0Sels[4] =   0.0 ;  // min allowed cosine of V0's pointing angle         (LHC09a4 : 0.99)
281         fV0Sels[5] =   0.1 ;  // min radius of the fiducial volume                 (LHC09a4 : 0.2)
282         fV0Sels[6] = 100.  ;  // max radius of the fiducial volume                 (LHC09a4 : 100.0)
283         
284         fCascSels[0] =  33.   ;  // max allowed chi2 (same as PDC07)
285         fCascSels[1] =   0.001;  // min allowed V0 impact parameter                    (PDC07 : 0.05   / LHC09a4 : 0.025 )
286         fCascSels[2] =   0.008;  // "window" around the Lambda mass                    (PDC07 : 0.008  / LHC09a4 : 0.010 )
287         fCascSels[3] =   0.001;  // min allowed bachelor's impact parameter            (PDC07 : 0.035  / LHC09a4 : 0.025 )
288         fCascSels[4] =   5.0  ;  // max allowed DCA between the V0 and the bachelor    (PDC07 : 0.1    / LHC09a4 : 0.2   )
289         fCascSels[5] =   0.82 ;  //FIXME min allowed cosine of the cascade pointing angle   (PDC07 : 0.9985 / LHC09a4 : 0.998 )
290         fCascSels[6] =   0.1  ;  // min radius of the fiducial volume                  (PDC07 : 0.9    / LHC09a4 : 0.2   )
291         fCascSels[7] = 100.   ;  // max radius of the fiducial volume                  (PDC07 : 100    / LHC09a4 : 100   )
292         
293         
294         //New default vtxR (http://alisoft.cern.ch/viewvc?view=rev&root=AliRoot&revision=40955, 5 May 2010)
295         /*
296         fV0Sels[0] =  33.  ;  // max allowed chi2
297         fV0Sels[1] =   0.05;  // min allowed impact parameter for the 1st daughter (LHC09a4 : 0.05)
298         fV0Sels[2] =   0.05;  // min allowed impact parameter for the 2nd daughter (LHC09a4 : 0.05)
299         fV0Sels[3] =   1.5 ;  // max allowed DCA between the daughter tracks       (LHC09a4 : 0.5)
300         fV0Sels[4] =   0.9 ;  // min allowed cosine of V0's pointing angle         (LHC09a4 : 0.99)
301         fV0Sels[5] =   0.2 ;  // min radius of the fiducial volume                 (LHC09a4 : 0.2)
302         fV0Sels[6] = 100.  ;  // max radius of the fiducial volume                 (LHC09a4 : 100.0)
303         
304         fCascSels[0] =  33.   ;  // max allowed chi2 (same as PDC07)
305         fCascSels[1] =   0.01 ;  // min allowed V0 impact parameter                    (PDC07 : 0.05   / LHC09a4 : 0.025 )
306         fCascSels[2] =   0.008;  // "window" around the Lambda mass                    (PDC07 : 0.008  / LHC09a4 : 0.010 )
307         fCascSels[3] =   0.01 ;  // min allowed bachelor's impact parameter            (PDC07 : 0.035  / LHC09a4 : 0.025 )
308         fCascSels[4] =   2.0  ;  // max allowed DCA between the V0 and the bachelor    (PDC07 : 0.1    / LHC09a4 : 0.2   )
309         fCascSels[5] =   0.98 ;  // min allowed cosine of the cascade pointing angle   (PDC07 : 0.9985 / LHC09a4 : 0.998 )
310         fCascSels[6] =   0.2  ;  // min radius of the fiducial volume                  (PDC07 : 0.9    / LHC09a4 : 0.2   )
311         fCascSels[7] = 100.   ;  // max radius of the fiducial volume                  (PDC07 : 100    / LHC09a4 : 100   )
312         */
313         
314         // Tight for Xi in p-p (http://alisoft.cern.ch/viewvc?view=rev&root=AliRoot&revision=40955, 5 May 2010)
315         /*
316         fV0Sels[0] =  33.  ;  // max allowed chi2
317         fV0Sels[1] =   0.05;  // min allowed impact parameter for the 1st daughter (LHC09a4 : 0.05)
318         fV0Sels[2] =   0.05;  // min allowed impact parameter for the 2nd daughter (LHC09a4 : 0.05)
319         fV0Sels[3] =   0.5 ;  // max allowed DCA between the daughter tracks       (LHC09a4 : 0.5)
320         fV0Sels[4] =   0.99 ; // min allowed cosine of V0's pointing angle         (LHC09a4 : 0.99)
321         fV0Sels[5] =   0.2 ;  // min radius of the fiducial volume                 (LHC09a4 : 0.2)
322         fV0Sels[6] = 100.  ;  // max radius of the fiducial volume                 (LHC09a4 : 100.0)
323         
324         fCascSels[0] =  33.   ;   // max allowed chi2 (same as PDC07)
325         fCascSels[1] =   0.05 ;   // min allowed V0 impact parameter                    (PDC07 : 0.05   / LHC09a4 : 0.025 )
326         fCascSels[2] =   0.01;    // "window" around the Lambda mass                    (PDC07 : 0.008  / LHC09a4 : 0.010 )
327         fCascSels[3] =   0.035 ;  // min allowed bachelor's impact parameter            (PDC07 : 0.035  / LHC09a4 : 0.025 )
328         fCascSels[4] =   0.10  ;  // max allowed DCA between the V0 and the bachelor    (PDC07 : 0.1    / LHC09a4 : 0.2   )
329         fCascSels[5] =   0.9985 ; // min allowed cosine of the cascade pointing angle   (PDC07 : 0.9985 / LHC09a4 : 0.998 )
330         fCascSels[6] =   0.2  ;   // min radius of the fiducial volume                  (PDC07 : 0.9    / LHC09a4 : 0.2   )
331         fCascSels[7] = 100.   ;   // max radius of the fiducial volume                  (PDC07 : 100    / LHC09a4 : 100   )
332         */
333         
334         //NOTE
335         // For PbPb coming data, take a look at Iouri's proposal
336         // https://savannah.cern.ch/bugs/index.php?69877
337
338         
339   // Output slot #0 writes into a TList container (Cascade)
340   DefineOutput(1, TList::Class());
341   /*DefineOutput(2, TPaveText::Class());*/
342 }
343
344
345 AliAnalysisTaskCheckCascade::~AliAnalysisTaskCheckCascade()
346 {
347   //
348   // Destructor
349   //
350
351   // For all TH1, 2, 3 HnSparse and CFContainer are in the fListCascade TList.
352   // They will be deleted when fListCascade is deleted by the TSelector dtor
353   // Because of TList::SetOwner() ...
354         
355   if (fListHistCascade)         { delete fListHistCascade;     fListHistCascade = 0x0;    }
356   if (fESDpid)                  { delete fESDpid;              fESDpid = 0x0;} // fESDpid is not stored into the TList
357   if (fESDtrackCuts)            { delete fESDtrackCuts;        fESDtrackCuts = 0x0; }
358   //if (fPaveTextBookKeeping)     { delete fPaveTextBookKeeping; fPaveTextBookKeeping = 0x0;} // fPaveTextBookKeeping is not strored in the TList
359 }
360
361
362
363 //________________________________________________________________________
364 void AliAnalysisTaskCheckCascade::UserCreateOutputObjects()
365 {
366   // Create histograms
367   // Called once
368
369
370
371  fListHistCascade = new TList();
372  fListHistCascade->SetOwner();  // See http://root.cern.ch/root/html/TCollection.html#TCollection:SetOwner
373  
374  
375 if(! fESDpid){
376
377   AliMCEventHandler *lmcEvtHandler  = dynamic_cast<AliMCEventHandler*>( (AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler() );
378   
379   if( !lmcEvtHandler ){ // !0x0 = real data or !1 = there is an MC handler available (useMC = kTRUE in AnalysisTrainNew), so = data from MC
380         
381         if(fkIsDataRecoWith1PadTPCCluster){
382                 // Parameters extracted for LHC10d Pass2 - A. Kalweit
383                 fAlephParameters[0] = 1.28949/50.; // = 0,0257898
384                 fAlephParameters[1] = 2.74095e+01;
385                 fAlephParameters[2] = TMath::Exp(-3.21763e+01);
386                 fAlephParameters[3] = 2.44026;
387                 fAlephParameters[4] = 6.58800;
388         }
389         else {
390                 // Reasonable parameters extracted for real p-p event (Dec 2009 - GSI Pass5) - A.Kalweit
391                 fAlephParameters[0] = 0.0283086;        // No extra-division to apply in SetBlochParam
392                 fAlephParameters[1] = 2.63394e+01;
393                 fAlephParameters[2] = 5.04114e-11;
394                 fAlephParameters[3] = 2.12543e+00;
395                 fAlephParameters[4] = 4.88663e+00; 
396         }
397         
398         Printf("CheckCascade -      Check Aleph Param in case of REAL Data (fAlephParameters[3] = %f)  (To be compared with : 2.44026 for 1-pad-cluster prod. / 2.12543 otherwise)\n",  fAlephParameters[3]);
399
400   }
401   else { // MC reco
402         if(fkIsDataRecoWith1PadTPCCluster){
403                 // Home made parameterization for LHC10f6a production = p+p 7 TeV
404                 fAlephParameters[0] = 0.04;
405                 fAlephParameters[1] = 17.5;
406                 fAlephParameters[2] = 3.4e-09;
407                 fAlephParameters[3] = 2.15;
408                 fAlephParameters[4] = 3.91720e+00; 
409                 
410                 // Home made parameterization for LHC10e13 production = p+p 900 GeV/c
411                 
412         }
413         else {
414                 // Reasonable parameters extracted for p-p simulation (LHC09a4) - A.Kalweit
415                 // fAlephParameters[0] = 4.23232575531564326e+00;//50*0.76176e-1; // do not forget to divide this value by 50 in SetBlochParam !
416                 // fAlephParameters[1] = 8.68482806165147636e+00;//10.632; 
417                 // fAlephParameters[2] = 1.34000000000000005e-05;//0.13279e-4;
418                 // fAlephParameters[3] = 2.30445734159456084e+00;//1.8631;
419                 // fAlephParameters[4] = 2.25624744086878559e+00;//1.9479;  
420                 
421                 // Reasonable parameters extracted for MC LHC09d10 event (Jan 2010) - A.Kalweit
422                 fAlephParameters[0] = 2.15898e+00/50.;
423                 fAlephParameters[1] = 1.75295e+01;
424                 fAlephParameters[2] = 3.40030e-09;
425                 fAlephParameters[3] = 1.96178e+00;
426                 fAlephParameters[4] = 3.91720e+00;
427         }
428         Printf("CheckCascade -      Check Aleph Param in case of MC Data (fAlephParameters[3] = %f) (To be compared with : 2.15 for 1-pad-cluster prod. / 1.96178 otherwise)\n",  fAlephParameters[3]);
429   }
430
431   fESDpid = new AliESDpid();
432   fESDpid->GetTPCResponse().SetBetheBlochParameters( fAlephParameters[0],
433                                                      fAlephParameters[1],
434                                                      fAlephParameters[2],
435                                                      fAlephParameters[3],
436                                                      fAlephParameters[4] );
437 }
438  
439 if(! fESDtrackCuts ){
440       fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE); // Std definition of primary (see kTRUE argument) tracks for 2010
441       fESDtrackCuts->SetEtaRange(-0.8,+0.8);
442       fESDtrackCuts->SetPtRange(0.15, 1e10);
443       Printf("CheckCascade - ESDtrackCuts set up to 2010 std ITS-TPC cuts...");
444 }
445  
446 /* 
447 if( !fPaveTextBookKeeping){
448         // FIXME : prepare a field with the AliRoot+root distrib ...
449
450         fPaveTextBookKeeping = new TPaveText(0.1, 0.1, 0.9, 0.9,"NDC");
451         fPaveTextBookKeeping->SetName("fPaveTextBookKeeping");
452         fPaveTextBookKeeping->SetBorderSize(0);
453         fPaveTextBookKeeping->SetTextAlign(12);
454         fPaveTextBookKeeping->SetFillColor(kWhite);
455         fPaveTextBookKeeping->SetTextFont(42);        // regular Arial or Helvetica,
456         fPaveTextBookKeeping->SetTextColor(kBlue+4);
457         
458         fPaveTextBookKeeping->AddText( "Task CHECK CASCADE analysis" );
459         fPaveTextBookKeeping->AddText("- - - - - - - - - - - ");
460         fPaveTextBookKeeping->AddText( Form("AnalysisType : %s ", fAnalysisType.Data() ));
461         if(!fCollidingSystems)  fPaveTextBookKeeping->AddText("Colliding system : p-p collisions ");
462         else                    fPaveTextBookKeeping->AddText("Colliding system : A-A collisions ");
463
464         fPaveTextBookKeeping->AddText("- - - - - - - - - - - ");
465     
466         if(fkRerunV0CascVertexers){
467                 fPaveTextBookKeeping->AddText("A.1. With V0 vertexer : ");
468                 fPaveTextBookKeeping->AddText( Form("  - V0 #chi^{2} _________________ <  %.3f ",               fV0Sels[0] ));
469                 fPaveTextBookKeeping->AddText( Form("  - DCA(prim. Vtx/ 1^{st} daughter) ___ >  %.3f     cm ",  fV0Sels[1] ));
470                 fPaveTextBookKeeping->AddText( Form("  - DCA(prim. Vtx/ 2^{nd} daughter) __  >  %.3f     cm",   fV0Sels[2] ));
471                 fPaveTextBookKeeping->AddText( Form("  - DCA between V0 daughters ___ <  %.3f      cm",         fV0Sels[3] ));
472                 fPaveTextBookKeeping->AddText( Form("  - cos(V0 pointing angle) _______ >  %.3f ",              fV0Sels[4] ));
473                 fPaveTextBookKeeping->AddText( Form("  - R_{transv}(V0 decay) ________ >  %.3f             cm", fV0Sels[5] ));
474                 fPaveTextBookKeeping->AddText( Form("  - R_{transv}(V0 decay) ________ <  %.3f         cm",     fV0Sels[6] ));
475                 
476                 fPaveTextBookKeeping->AddText(" "); 
477                 
478                 fPaveTextBookKeeping->AddText("A.2. With Casc. vertexer : ");
479                 fPaveTextBookKeeping->AddText( Form("  - Casc. #chi^{2} ______________  <  %.3f ",                               fCascSels[0] ));
480                 fPaveTextBookKeeping->AddText( Form("  - DCA(prim. Vtx/ V0) _________ >  %.3f    cm",                            fCascSels[1] ));
481                 fPaveTextBookKeeping->AddText( Form("  - | M_{#Lambda}(reco) - M_{#Lambda}(pdg) | _______ <  %.3f    GeV/c^{2}", fCascSels[2] ));
482                 fPaveTextBookKeeping->AddText( Form("  - DCA(prim. Vtx/ Bach) _______ >  %.3f    cm",                            fCascSels[3] ));
483                 fPaveTextBookKeeping->AddText( Form("  - DCA between Bach/ #Lambda ______ <  %.3f    cm",                        fCascSels[4] ));
484                 fPaveTextBookKeeping->AddText( Form("  - cos(Casc. pointing angle) ____ >  %.3f ",                               fCascSels[5] ));
485                 fPaveTextBookKeeping->AddText( Form("  - R_{transv}(Casc. decay) ______ >  %.3f         cm",                     fCascSels[6] ));
486                 fPaveTextBookKeeping->AddText( Form("  - R_{transv}(Casc. decay) ______ <  %.3f     cm",                         fCascSels[7] ));
487         }
488         else{   fPaveTextBookKeeping->AddText("A. No rerunning of the V0/Casc. vertexers ... See std cuts in (AliRoot+Rec.C) used for this prod. cycle");}
489
490         fPaveTextBookKeeping->AddText("- - - - - - - - - - - ");
491         
492         if(fkQualityCutZprimVtxPos)      fPaveTextBookKeeping->AddText("B. Quality Cut(prim. Vtx z-Pos)    = ON  ");
493         else                             fPaveTextBookKeeping->AddText("B. Quality Cut(prim. Vtx z-Pos)    = Off ");
494         if(fkQualityCutNoTPConlyPrimVtx) fPaveTextBookKeeping->AddText("C. Quality Cut(No TPC prim. vtx) = ON  ");
495         else                             fPaveTextBookKeeping->AddText("C. Quality Cut(No TPC prim. vtx) = Off ");
496         if(fkQualityCutTPCrefit)         fPaveTextBookKeeping->AddText("D. Quality Cut(TPCrefit)               = ON  ");
497         else                             fPaveTextBookKeeping->AddText("D. Quality Cut(TPCrefit)               = Off ");
498         if(fkQualityCut80TPCcls)         fPaveTextBookKeeping->AddText("E. Quality Cut(80 TPC clusters)   = ON  ");
499         else                             fPaveTextBookKeeping->AddText("E. Quality Cut(80 TPC clusters)   = Off ");
500         if(fkExtraSelections)            fPaveTextBookKeeping->AddText("F. Extra Analysis Selections         = ON  ");
501         else                             fPaveTextBookKeeping->AddText("F. Extra Analysis Selections         = Off ");
502
503         fPaveTextBookKeeping->AddText("- - - - - - - - - - - ");
504
505         fPaveTextBookKeeping->AddText("G. TPC Aleph Param : ");
506         fPaveTextBookKeeping->AddText( Form("   - fAlephParam [0] =  %.5g", fAlephParameters[0] ));
507         fPaveTextBookKeeping->AddText( Form("   - fAlephParam [1] =  %.5g", fAlephParameters[1] ));
508         fPaveTextBookKeeping->AddText( Form("   - fAlephParam [2] =  %.5g", fAlephParameters[2] ));
509         fPaveTextBookKeeping->AddText( Form("   - fAlephParam [3] =  %.5g", fAlephParameters[3] ));
510         fPaveTextBookKeeping->AddText( Form("   - fAlephParam [4] =  %.5g", fAlephParameters[4] ));
511 }       
512 */ 
513  
514         // - General histos
515         //--------------
516  
517 if(! fHistCascadeMultiplicityBeforeTrigSel) {
518         if(fCollidingSystems)// AA collisions
519                 fHistCascadeMultiplicityBeforeTrigSel = new TH1F("fHistCascadeMultiplicityBeforeTrigSel", 
520                         "Cascades per event (before Trig. Sel.);Nbr of Cascades/Evt;Events", 
521                         100, 0, 100);           
522         else // pp collisions
523                 fHistCascadeMultiplicityBeforeTrigSel = new TH1F("fHistCascadeMultiplicityBeforeTrigSel", 
524                         "Cascades per event (before Trig. Sel.);Nbr of Cascades/Evt;Events", 
525                         25, 0, 25);
526         fListHistCascade->Add(fHistCascadeMultiplicityBeforeTrigSel);
527 }
528
529         // - Histos for events passing the trigger selection
530         //--------------
531         
532 if(! fHistCascadeMultiplicityForTrigEvt) {
533         if(fCollidingSystems)// AA collisions
534                 fHistCascadeMultiplicityForTrigEvt = new TH1F("fHistCascadeMultiplicityForTrigEvt", 
535                         "Cascades per event (for triggered evt);Nbr of Cascades/Evt;Events", 
536                         100, 0, 100);           
537         else // pp collisions
538                 fHistCascadeMultiplicityForTrigEvt = new TH1F("fHistCascadeMultiplicityForTrigEvt", 
539                         "Cascades per event (for triggered evt);Nbr of Cascades/Evt;Events", 
540                         25, 0, 25);
541         fListHistCascade->Add(fHistCascadeMultiplicityForTrigEvt);
542 }
543
544  
545 if(! fHistTrackMultiplicityForTrigEvt) {        
546         if(fCollidingSystems)// AA collisions   
547                 fHistTrackMultiplicityForTrigEvt = new TH1F("fHistTrackMultiplicityForTrigEvt", 
548                         "Track Multiplicity (for triggered evt);Nbr of tracks/Evt;Events", 
549                         200, 0, 20000);                 
550         else // pp collisions
551                 fHistTrackMultiplicityForTrigEvt = new TH1F("fHistTrackMultiplicityForTrigEvt", 
552                         "Track Multiplicity (for triggered evt);Nbr of tracks/Evt;Events", 
553                         300, 0, 300);
554         fListHistCascade->Add(fHistTrackMultiplicityForTrigEvt);
555 }
556
557 if(! fHistTPCrefitTrackMultiplicityForTrigEvt) {        
558         if(fCollidingSystems)// AA collisions   
559                 fHistTPCrefitTrackMultiplicityForTrigEvt = new TH1F("fHistTPCrefitTrackMultiplicityForTrigEvt", 
560                         "TPCrefit track Multiplicity (for triggered evt);Nbr of TPCrefit tracks/Evt;Events", 
561                         200, 0, 20000);                 
562         else // pp collisions
563                 fHistTPCrefitTrackMultiplicityForTrigEvt = new TH1F("fHistTPCrefitTrackMultiplicityForTrigEvt", 
564                         "TPCrefit track Multiplicity (for triggered evt);Nbr of TPCrefit tracks/Evt;Events", 
565                         300, 0, 300);
566         fListHistCascade->Add(fHistTPCrefitTrackMultiplicityForTrigEvt);
567 }
568
569
570 if(! fHistPrimaryTrackMultiplicityForTrigEvt) { 
571         if(fCollidingSystems)// AA collisions   
572                 fHistPrimaryTrackMultiplicityForTrigEvt = new TH1F("fHistPrimaryTrackMultiplicityForTrigEvt", 
573                         "Primary track Multiplicity (for triggered evt);Nbr of primary tracks/Evt;Events", 
574                         100, 0, 10000);                 
575         else // pp collisions
576                 fHistPrimaryTrackMultiplicityForTrigEvt = new TH1F("fHistPrimaryTrackMultiplicityForTrigEvt", 
577                         "Primary track Multiplicity (for triggered evt);Nbr of primary tracks/Evt;Events", 
578                         200, 0, 200);
579         fListHistCascade->Add(fHistPrimaryTrackMultiplicityForTrigEvt);
580 }
581
582
583         // - Histos for events passing the trigger selection + |z(prim. vertex)| < XX cm
584         //--------------
585         
586 if(! fHistCascadeMultiplicityForTrigEvtAndZprimVtx) {
587         if(fCollidingSystems)// AA collisions
588                 fHistCascadeMultiplicityForTrigEvtAndZprimVtx = new TH1F("fHistCascadeMultiplicityForTrigEvtAndZprimVtx", 
589                         "Cascades per event;Nbr of Cascades/Evt;Events", 
590                         100, 0, 100);           
591         else // pp collisions
592                 fHistCascadeMultiplicityForTrigEvtAndZprimVtx = new TH1F("fHistCascadeMultiplicityForTrigEvtAndZprimVtx", 
593                         "Cascades per event;Nbr of Cascades/Evt;Events", 
594                         25, 0, 25);
595         fListHistCascade->Add(fHistCascadeMultiplicityForTrigEvtAndZprimVtx);
596 }
597
598
599         // - Histos for events passing the trigger selection + |z(prim. vertex)| < XX cm + after pile-up rejection
600         //--------------
601         
602 if(! fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx) {
603         if(fCollidingSystems)// AA collisions
604                 fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx = new TH1F("fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx", 
605                         "Cascades per event;Nbr of Cascades/Evt;Events", 
606                         100, 0, 100);           
607         else // pp collisions
608                 fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx = new TH1F("fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx", 
609                         "Cascades per event;Nbr of Cascades/Evt;Events", 
610                         25, 0, 25);
611         fListHistCascade->Add(fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx);
612 }
613
614
615         // - Histos for events passing the event selection at the analysis level
616         //--------------
617         
618 if(! fHistCascadeMultiplicityForSelEvt) {
619         if(fCollidingSystems)// AA collisions
620                 fHistCascadeMultiplicityForSelEvt = new TH1F("fHistCascadeMultiplicityForSelEvt", 
621                         "Cascades per event;Nbr of Cascades/Evt;Events", 
622                         100, 0, 100);           
623         else // pp collisions
624                 fHistCascadeMultiplicityForSelEvt = new TH1F("fHistCascadeMultiplicityForSelEvt", 
625                         "Cascades per event;Nbr of Cascades/Evt;Events", 
626                         25, 0, 25);
627         fListHistCascade->Add(fHistCascadeMultiplicityForSelEvt);
628 }
629
630
631 if(! fHistPosBestPrimaryVtxXForSelEvt ){
632         fHistPosBestPrimaryVtxXForSelEvt   = new TH1F( "fHistPosBestPrimaryVtxXForSelEvt" , "Best Prim. Vertex Position in x; x (cm); Events" , 360, -0.9, 0.9 );
633         fListHistCascade->Add(fHistPosBestPrimaryVtxXForSelEvt);
634 }
635
636 if(! fHistPosBestPrimaryVtxYForSelEvt){
637         fHistPosBestPrimaryVtxYForSelEvt   = new TH1F( "fHistPosBestPrimaryVtxYForSelEvt" , "Best Prim. Vertex Position in y; y (cm); Events" , 360, -0.9, 0.9 );
638         fListHistCascade->Add(fHistPosBestPrimaryVtxYForSelEvt);
639 }
640
641 if(! fHistPosBestPrimaryVtxZForSelEvt ){
642         fHistPosBestPrimaryVtxZForSelEvt   = new TH1F( "fHistPosBestPrimaryVtxZForSelEvt" , "Best Prim. Vertex Position in z; z (cm); Events" , 300, -30.0, 30.0 );
643         fListHistCascade->Add(fHistPosBestPrimaryVtxZForSelEvt);
644 }
645
646
647
648
649         // - Histos for events containing at least ONE CASCADE
650         //--------------
651         
652 if(! fHistTPCrefitTrackMultiplicityForCascadeEvt) {
653         if(fCollidingSystems)// AA collisions   
654                 fHistTPCrefitTrackMultiplicityForCascadeEvt = new TH1F("fHistTPCrefitTrackMultiplicityForCascadeEvt", 
655                         "TPCrefit track Multiplicity (for evt with Casc.);Nbr of TPCrefit tracks/Evt with cascade(s);Events", 
656                         200, 0, 20000);                 
657         else // pp collisions
658                 fHistTPCrefitTrackMultiplicityForCascadeEvt = new TH1F("fHistTPCrefitTrackMultiplicityForCascadeEvt", 
659                         "TPCrefit track Multiplicity (for evt with Casc.);Nbr of TPCrefit tracks/Evt with cascade(s);Events", 
660                         300, 0, 300);
661         fListHistCascade->Add(fHistTPCrefitTrackMultiplicityForCascadeEvt);
662 }
663
664 if(! fHistPrimaryTrackMultiplicityForCascadeEvt) {      
665         if(fCollidingSystems)// AA collisions   
666                 fHistPrimaryTrackMultiplicityForCascadeEvt = new TH1F("fHistPrimaryTrackMultiplicityForCascadeEvt", 
667                         "Primary track Multiplicity (for evt with Casc.);Nbr of primary tracks/Evt;Events", 
668                         100, 0, 10000);                 
669         else // pp collisions
670                 fHistPrimaryTrackMultiplicityForCascadeEvt = new TH1F("fHistPrimaryTrackMultiplicityForCascadeEvt", 
671                         "Primary track Multiplicity (for evt with Casc.);Nbr of primary tracks/Evt;Events", 
672                         200, 0, 200);
673         fListHistCascade->Add(fHistPrimaryTrackMultiplicityForCascadeEvt);
674 }
675
676 if(! fHistPosV0TPCClusters ){
677         fHistPosV0TPCClusters = new TH1F("fHistPosV0TPCClusters", "TPC clusters for Pos. V0 daughter track, in Casc; Nbr of TPC clusters (V0 Pos.); Track counts", 165, 0.0 ,165.0);
678         fListHistCascade->Add(fHistPosV0TPCClusters);
679 }
680
681 if(! fHistNegV0TPCClusters ){
682         fHistNegV0TPCClusters = new TH1F("fHistNegV0TPCClusters", "TPC clusters for Neg. V0 daughter track, in Casc; Nbr of TPC clusters (V0 Neg.); Track counts", 165, 0.0 ,165.0);
683         fListHistCascade->Add(fHistNegV0TPCClusters);
684 }
685
686 if(! fHistBachTPCClusters ){
687         fHistBachTPCClusters = new TH1F("fHistBachTPCClusters", "TPC clusters for Bachelor track; Nbr of TPC clusters (Bach); Track counts", 165, 0.0 ,165.0);
688         fListHistCascade->Add(fHistBachTPCClusters);
689 }
690
691
692
693
694
695
696
697 if(! fHistVtxStatus ){
698         fHistVtxStatus   = new TH1F( "fHistVtxStatus" , "Does a Trckg Prim.vtx exist ?; true=1 or false=0; Nb of Events" , 4, -1.0, 3.0 );
699         fListHistCascade->Add(fHistVtxStatus);
700 }
701
702
703         // - Vertex Positions
704   
705 if(! fHistPosTrkgPrimaryVtxXForCascadeEvt ){
706         fHistPosTrkgPrimaryVtxXForCascadeEvt   = new TH1F( "fHistPosTrkgPrimaryVtxXForCascadeEvt" , "Trkg Prim. Vertex Position in x; x (cm); Events" , 360, -0.9, 0.9 );
707         fListHistCascade->Add(fHistPosTrkgPrimaryVtxXForCascadeEvt);
708 }
709
710
711 if(! fHistPosTrkgPrimaryVtxYForCascadeEvt){
712         fHistPosTrkgPrimaryVtxYForCascadeEvt   = new TH1F( "fHistPosTrkgPrimaryVtxYForCascadeEvt" , "Trkg Prim. Vertex Position in y; y (cm); Events" , 360, -0.9, 0.9 );
713         fListHistCascade->Add(fHistPosTrkgPrimaryVtxYForCascadeEvt);
714 }
715
716 if(! fHistPosTrkgPrimaryVtxZForCascadeEvt ){
717         fHistPosTrkgPrimaryVtxZForCascadeEvt   = new TH1F( "fHistPosTrkgPrimaryVtxZForCascadeEvt" , "Trkg Prim. Vertex Position in z; z (cm); Events" , 300, -30.0, 30.0 );
718         fListHistCascade->Add(fHistPosTrkgPrimaryVtxZForCascadeEvt);
719 }
720
721 if(! fHistTrkgPrimaryVtxRadius ){
722         fHistTrkgPrimaryVtxRadius  = new TH1F( "fHistTrkgPrimaryVtxRadius",  "Trkg Prim. Vertex radius; r (cm); Events" , 150, 0., 15.0 );
723         fListHistCascade->Add(fHistTrkgPrimaryVtxRadius);
724 }
725
726
727
728
729 if(! fHistPosBestPrimaryVtxXForCascadeEvt ){
730         fHistPosBestPrimaryVtxXForCascadeEvt   = new TH1F( "fHistPosBestPrimaryVtxXForCascadeEvt" , "Best Prim. Vertex Position in x; x (cm); Events" , 360, -0.9, 0.9 );
731         fListHistCascade->Add(fHistPosBestPrimaryVtxXForCascadeEvt);
732 }
733
734 if(! fHistPosBestPrimaryVtxYForCascadeEvt){
735         fHistPosBestPrimaryVtxYForCascadeEvt   = new TH1F( "fHistPosBestPrimaryVtxYForCascadeEvt" , "Best Prim. Vertex Position in y; y (cm); Events" , 360, -0.9, 0.9 );
736         fListHistCascade->Add(fHistPosBestPrimaryVtxYForCascadeEvt);
737 }
738
739 if(! fHistPosBestPrimaryVtxZForCascadeEvt ){
740         fHistPosBestPrimaryVtxZForCascadeEvt   = new TH1F( "fHistPosBestPrimaryVtxZForCascadeEvt" , "Best Prim. Vertex Position in z; z (cm); Events" , 300, -30.0, 30.0 );
741         fListHistCascade->Add(fHistPosBestPrimaryVtxZForCascadeEvt);
742 }
743
744 if(! fHistBestPrimaryVtxRadius ){
745         fHistBestPrimaryVtxRadius  = new TH1F( "fHistBestPrimaryVtxRadius",  "Best Prim.  vertex radius; r (cm); Events" , 150, 0., 15.0 );
746         fListHistCascade->Add(fHistBestPrimaryVtxRadius);
747 }
748
749 if(! f2dHistTrkgPrimVtxVsBestPrimVtx) {
750         f2dHistTrkgPrimVtxVsBestPrimVtx = new TH2F( "f2dHistTrkgPrimVtxVsBestPrimVtx", "r_{Trck Prim. Vtx} Vs r_{Best Prim. Vtx}; r_{Track Vtx} (cm); r_{Best Vtx} (cm)", 300, 0., 15.0, 300, 0., 15.);
751         fListHistCascade->Add(f2dHistTrkgPrimVtxVsBestPrimVtx);
752 }
753
754
755
756
757 // - Typical histos for cascades
758
759
760 if(! fHistEffMassXi) {
761      fHistEffMassXi = new TH1F("fHistEffMassXi", "Cascade candidates ; Invariant Mass (GeV/c^{2}) ; Counts", 400, 1.2, 2.0);
762      fListHistCascade->Add(fHistEffMassXi);
763 }
764    
765 if(! fHistChi2Xi ){
766         fHistChi2Xi = new TH1F("fHistChi2Xi", "Cascade #chi^{2}; #chi^{2}; Number of Cascades", 160, 0, 40);
767         fListHistCascade->Add(fHistChi2Xi);
768 }
769   
770 if(! fHistDcaXiDaughters ){
771         fHistDcaXiDaughters = new TH1F( "fHistDcaXiDaughters",  "DCA between Xi Daughters; DCA (cm) ; Number of Cascades", 100, 0., 0.5);
772         fListHistCascade->Add(fHistDcaXiDaughters);
773 }
774
775 if(! fHistDcaBachToPrimVertex) {
776         fHistDcaBachToPrimVertex = new TH1F("fHistDcaBachToPrimVertex", "DCA of Bach. to Prim. Vertex;DCA (cm);Number of Cascades", 250, 0., 0.25);
777         fListHistCascade->Add(fHistDcaBachToPrimVertex);
778 }
779
780 if(! fHistXiCosineOfPointingAngle) {
781         fHistXiCosineOfPointingAngle = new TH1F("fHistXiCosineOfPointingAngle", "Cosine of Xi Pointing Angle; Cos (Xi Point.Angl);Number of Xis", 200, 0.99, 1.0);
782         fListHistCascade->Add(fHistXiCosineOfPointingAngle);
783 }
784
785 if(! fHistXiRadius ){
786         fHistXiRadius  = new TH1F( "fHistXiRadius",  "Casc. decay transv. radius; r (cm); Counts" , 1050, 0., 105.0 );
787         fListHistCascade->Add(fHistXiRadius);
788 }
789
790
791 // - Histos about ~ the "V0 part" of the cascade,  coming by inheritance from AliESDv0
792
793
794
795 if (! fHistMassLambdaAsCascDghter) {
796      fHistMassLambdaAsCascDghter = new TH1F("fHistMassLambdaAsCascDghter","#Lambda associated to Casc. candidates;Eff. Mass (GeV/c^{2});Counts", 300,1.00,1.3);
797     fListHistCascade->Add(fHistMassLambdaAsCascDghter);
798 }
799
800 if (! fHistV0Chi2Xi) {
801         fHistV0Chi2Xi = new TH1F("fHistV0Chi2Xi", "V0 #chi^{2}, in cascade; #chi^{2};Counts", 160, 0, 40);
802         fListHistCascade->Add(fHistV0Chi2Xi);
803 }
804
805 if (! fHistDcaV0DaughtersXi) {
806         fHistDcaV0DaughtersXi = new TH1F("fHistDcaV0DaughtersXi", "DCA between V0 daughters, in cascade;DCA (cm);Number of V0s", 120, 0., 0.6);
807         fListHistCascade->Add(fHistDcaV0DaughtersXi);
808 }
809
810 if (! fHistDcaV0ToPrimVertexXi) {
811         fHistDcaV0ToPrimVertexXi = new TH1F("fHistDcaV0ToPrimVertexXi", "DCA of V0 to Prim. Vertex, in cascade;DCA (cm);Number of Cascades", 200, 0., 1.);
812         fListHistCascade->Add(fHistDcaV0ToPrimVertexXi);
813 }
814
815 if (! fHistV0CosineOfPointingAngleXi) {
816         fHistV0CosineOfPointingAngleXi = new TH1F("fHistV0CosineOfPointingAngleXi", "Cosine of V0 Pointing Angle, in cascade;Cos(V0 Point. Angl); Counts", 200, 0.98, 1.0);
817         fListHistCascade->Add(fHistV0CosineOfPointingAngleXi);
818 }
819
820 if (! fHistV0RadiusXi) {
821         fHistV0RadiusXi = new TH1F("fHistV0RadiusXi", "V0 decay radius, in cascade; radius (cm); Counts", 1050, 0., 105.0);
822         fListHistCascade->Add(fHistV0RadiusXi);
823 }
824
825 if (! fHistDcaPosToPrimVertexXi) {
826         fHistDcaPosToPrimVertexXi = new TH1F("fHistDcaPosToPrimVertexXi", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Counts", 300, 0, 3);
827         fListHistCascade->Add(fHistDcaPosToPrimVertexXi);
828 }
829
830 if (! fHistDcaNegToPrimVertexXi) {
831         fHistDcaNegToPrimVertexXi = new TH1F("fHistDcaNegToPrimVertexXi", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Counts", 300, 0, 3);
832         fListHistCascade->Add(fHistDcaNegToPrimVertexXi);
833 }
834
835
836
837
838         // - Effective mass histos for cascades.
839 // By cascade hyp  
840 if (! fHistMassXiMinus) {
841     fHistMassXiMinus = new TH1F("fHistMassXiMinus","#Xi^{-} candidates;M( #Lambda , #pi^{-} ) (GeV/c^{2});Counts", 400,1.2,2.0);
842     fListHistCascade->Add(fHistMassXiMinus);
843 }
844   
845 if (! fHistMassXiPlus) {
846     fHistMassXiPlus = new TH1F("fHistMassXiPlus","#Xi^{+} candidates;M( #bar{#Lambda}^{0} , #pi^{+} ) (GeV/c^{2});Counts",400,1.2,2.0);
847     fListHistCascade->Add(fHistMassXiPlus);
848 }
849
850 if (! fHistMassOmegaMinus) {
851         fHistMassOmegaMinus = new TH1F("fHistMassOmegaMinus","#Omega^{-} candidates;M( #Lambda , K^{-} ) (GeV/c^{2});Counts", 500,1.5,2.5);
852     fListHistCascade->Add(fHistMassOmegaMinus);
853 }
854  
855 if (! fHistMassOmegaPlus) {
856         fHistMassOmegaPlus = new TH1F("fHistMassOmegaPlus","#Omega^{+} candidates;M( #bar{#Lambda}^{0} , K^{+} ) (GeV/c^{2});Counts", 500,1.5,2.5);
857     fListHistCascade->Add(fHistMassOmegaPlus);
858 }
859
860 // By cascade hyp + bachelor PID
861 if (! fHistMassWithCombPIDXiMinus) {
862     fHistMassWithCombPIDXiMinus = new TH1F("fHistMassWithCombPIDXiMinus","#Xi^{-} candidates, with Bach. comb. PID;M( #Lambda , #pi^{-} ) (GeV/c^{2});Counts", 400,1.2,2.0);
863     fListHistCascade->Add(fHistMassWithCombPIDXiMinus);
864 }
865   
866 if (! fHistMassWithCombPIDXiPlus) {
867     fHistMassWithCombPIDXiPlus = new TH1F("fHistMassWithCombPIDXiPlus","#Xi^{+} candidates, with Bach. comb. PID;M( #bar{#Lambda}^{0} , #pi^{+} ) (GeV/c^{2});Counts",400,1.2,2.0);
868     fListHistCascade->Add(fHistMassWithCombPIDXiPlus);
869 }
870
871 if (! fHistMassWithCombPIDOmegaMinus) {
872         fHistMassWithCombPIDOmegaMinus = new TH1F("fHistMassWithCombPIDOmegaMinus","#Omega^{-} candidates, with Bach. comb. PID;M( #Lambda , K^{-} ) (GeV/c^{2});Counts", 500,1.5,2.5);
873     fListHistCascade->Add(fHistMassWithCombPIDOmegaMinus);
874 }
875  
876 if (! fHistMassWithCombPIDOmegaPlus) {
877         fHistMassWithCombPIDOmegaPlus = new TH1F("fHistMassWithCombPIDOmegaPlus","#Omega^{+} candidates, with Bach. comb. PID;M( #bar{#Lambda}^{0} , K^{+} ) (GeV/c^{2});Counts", 500,1.5,2.5);
878     fListHistCascade->Add(fHistMassWithCombPIDOmegaPlus);
879 }
880
881
882
883         // - Complements for QA
884
885 if(! fHistXiTransvMom ){
886         fHistXiTransvMom  = new TH1F( "fHistXiTransvMom" , "#Xi transverse momentum (cand. around the mass peak) ; p_{t}(#Xi) (GeV/c); Counts", 100, 0.0, 10.0);
887         fListHistCascade->Add(fHistXiTransvMom);
888 }
889
890 if(! fHistXiTotMom ){
891         fHistXiTotMom  = new TH1F( "fHistXiTotMom" , "#Xi momentum norm (cand. around the mass peak); p_{tot}(#Xi) (GeV/c); Counts", 150, 0.0, 15.0);
892         fListHistCascade->Add(fHistXiTotMom);
893 }
894
895
896 if(! fHistBachTransvMomXi ){
897         fHistBachTransvMomXi  = new TH1F( "fHistBachTransvMomXi" , "#Xi Bach. transverse momentum (cand. around the mass peak) ; p_{t}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0);
898         fListHistCascade->Add(fHistBachTransvMomXi);
899 }
900
901 if(! fHistBachTotMomXi ){
902         fHistBachTotMomXi  = new TH1F( "fHistBachTotMomXi" , "#Xi Bach. momentum norm (cand. around the mass peak); p_{tot}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0);
903         fListHistCascade->Add(fHistBachTotMomXi);
904 }
905
906
907 if(! fHistChargeXi ){
908         fHistChargeXi  = new TH1F( "fHistChargeXi" , "Charge of casc. candidates ; Sign ; Counts", 5, -2.0, 3.0);
909         fListHistCascade->Add(fHistChargeXi);
910 }
911
912
913 if (! fHistV0toXiCosineOfPointingAngle) {
914         fHistV0toXiCosineOfPointingAngle = new TH1F("fHistV0toXiCosineOfPointingAngle", "Cos. of V0 Ptng Angl / Xi vtx ;Cos(V0 Point. Angl / Xi vtx); Counts", 100, 0.99, 1.0);
915         fListHistCascade->Add(fHistV0toXiCosineOfPointingAngle);
916 }
917
918
919 if(! fHistRapXi ){
920         fHistRapXi  = new TH1F( "fHistRapXi" , "Rapidity of #Xi candidates (around the mass peak); y ; Counts", 200, -5.0, 5.0);
921         fListHistCascade->Add(fHistRapXi);
922 }
923
924 if(! fHistRapOmega ){
925         fHistRapOmega  = new TH1F( "fHistRapOmega" , "Rapidity of #Omega candidates (around the mass peak); y ; Counts", 200, -5.0, 5.0);
926         fListHistCascade->Add(fHistRapOmega);
927 }
928
929 if(! fHistEtaXi ){
930         fHistEtaXi  = new TH1F( "fHistEtaXi" , "Pseudo-rap. of #Xi candidates (around the mass peak) ; #eta ; Counts", 120, -3.0, 3.0);
931         fListHistCascade->Add(fHistEtaXi);
932 }
933
934 if(! fHistThetaXi ){
935         fHistThetaXi  = new TH1F( "fHistThetaXi" , "#theta of #Xi candidates (around the mass peak); #theta (deg) ; Counts", 180, 0., 180.0);
936         fListHistCascade->Add(fHistThetaXi);
937 }
938
939 if(! fHistPhiXi ){
940         fHistPhiXi  = new TH1F( "fHistPhiXi" , "#phi of #Xi candidates (around the mass peak); #phi (deg) ; Counts", 360, 0., 360.);
941         fListHistCascade->Add(fHistPhiXi);
942 }
943
944
945 if(! fHistcTauXiMinus){
946         fHistcTauXiMinus = new TH1F("fHistcTauXiMinus", "Lifetime c.#tau for #Xi^{-}; L_{3D}.m_{PDG}(#Xi^{-}) / p_{3D} (cm); Counts", 100, 0., 50.);
947         fListHistCascade->Add(fHistcTauXiMinus);
948 }
949
950 if(! fHistcTauXiPlus){
951         fHistcTauXiPlus = new TH1F("fHistcTauXiPlus", "Lifetime c.#tau for #Xi^{+}; L_{3D}.m_{PDG}(#bar{#Xi}^{+}) / p_{3D} (cm); Counts", 100, 0., 50.);
952         fListHistCascade->Add(fHistcTauXiPlus);
953 }
954
955 if(! fHistcTauOmegaMinus){
956         fHistcTauOmegaMinus = new TH1F("fHistcTauOmegaMinus", "Lifetime c.#tau for #Omega^{-}; L_{3D}.m_{PDG}(#Omega^{-}) / p_{3D} (cm); Counts", 100, 0., 50.);
957         fListHistCascade->Add(fHistcTauOmegaMinus);
958 }
959
960 if(! fHistcTauOmegaPlus){
961         fHistcTauOmegaPlus = new TH1F("fHistcTauOmegaPlus", "Lifetime c.#tau for #Omega^{+}; L_{3D}.m_{PDG}(#bar{#Omega}^{+}) / p_{3D} (cm); Counts", 100, 0., 50.);
962         fListHistCascade->Add(fHistcTauOmegaPlus);
963 }
964
965
966 if(! f2dHistArmenteros) {
967         f2dHistArmenteros = new TH2F( "f2dHistArmenteros", "#alpha_{Arm}(casc. cand.) Vs Pt_{Arm}(casc. cand.); #alpha_{Arm} ; Pt_{Arm} (GeV/c)", 140, -1.2, 1.2, 300, 0., 0.3);
968         fListHistCascade->Add(f2dHistArmenteros);
969 }
970
971 //-------
972
973 if(! f2dHistEffMassLambdaVsEffMassXiMinus) {
974         f2dHistEffMassLambdaVsEffMassXiMinus = new TH2F( "f2dHistEffMassLambdaVsEffMassXiMinus", "M_{#Lambda} Vs M_{#Xi^{-} candidates} ; Inv. M_{#Lambda^{0}} (GeV/c^{2}) ; M( #Lambda , #pi^{-} ) (GeV/c^{2})", 300, 1.1,1.13, 400, 1.2, 2.0);
975         fListHistCascade->Add(f2dHistEffMassLambdaVsEffMassXiMinus);
976 }
977
978 if(! f2dHistEffMassXiVsEffMassOmegaMinus) {
979         f2dHistEffMassXiVsEffMassOmegaMinus = new TH2F( "f2dHistEffMassXiVsEffMassOmegaMinus", "M_{#Xi^{-} candidates} Vs M_{#Omega^{-} candidates} ; M( #Lambda , #pi^{-} ) (GeV/c^{2}) ; M( #Lambda , K^{-} ) (GeV/c^{2})", 400, 1.2, 2.0, 500, 1.5, 2.5);
980         fListHistCascade->Add(f2dHistEffMassXiVsEffMassOmegaMinus);
981 }
982
983 if(! f2dHistEffMassLambdaVsEffMassXiPlus) {
984         f2dHistEffMassLambdaVsEffMassXiPlus = new TH2F( "f2dHistEffMassLambdaVsEffMassXiPlus", "M_{#Lambda} Vs M_{#Xi^{+} candidates} ; Inv. M_{#Lambda^{0}} (GeV/c^{2}) ; M( #Lambda , #pi^{+} ) (GeV/c^{2})", 300, 1.1,1.13, 400, 1.2, 2.0);
985         fListHistCascade->Add(f2dHistEffMassLambdaVsEffMassXiPlus);
986 }
987
988 if(! f2dHistEffMassXiVsEffMassOmegaPlus) {
989         f2dHistEffMassXiVsEffMassOmegaPlus = new TH2F( "f2dHistEffMassXiVsEffMassOmegaPlus", "M_{#Xi^{+} candidates} Vs M_{#Omega^{+} candidates} ; M( #Lambda , #pi^{+} ) (GeV/c^{2}) ; M( #Lambda , K^{+} ) (GeV/c^{2})", 400, 1.2, 2.0, 500, 1.5, 2.5);
990         fListHistCascade->Add(f2dHistEffMassXiVsEffMassOmegaPlus);
991 }
992
993 //-------
994
995 if(! f2dHistXiRadiusVsEffMassXiMinus) {
996         f2dHistXiRadiusVsEffMassXiMinus = new TH2F( "f2dHistXiRadiusVsEffMassXiMinus", "Transv. R_{Xi Decay} Vs M_{#Xi^{-} candidates}; r_{cascade} (cm); M( #Lambda , #pi^{-} ) (GeV/c^{2}) ", 450, 0., 45.0, 400, 1.2, 2.0);
997         fListHistCascade->Add(f2dHistXiRadiusVsEffMassXiMinus);
998 }
999
1000 if(! f2dHistXiRadiusVsEffMassXiPlus) {
1001         f2dHistXiRadiusVsEffMassXiPlus = new TH2F( "f2dHistXiRadiusVsEffMassXiPlus", "Transv. R_{Xi Decay} Vs M_{#Xi^{+} candidates}; r_{cascade} (cm); M( #Lambda , #pi^{+} ) (GeV/c^{2}) ", 450, 0., 45.0, 400, 1.2, 2.0);
1002         fListHistCascade->Add(f2dHistXiRadiusVsEffMassXiPlus);
1003 }
1004
1005 if(! f2dHistXiRadiusVsEffMassOmegaMinus) {
1006         f2dHistXiRadiusVsEffMassOmegaMinus = new TH2F( "f2dHistXiRadiusVsEffMassOmegaMinus", "Transv. R_{Xi Decay} Vs M_{#Omega^{-} candidates}; r_{cascade} (cm); M( #Lambda , K^{-} ) (GeV/c^{2}) ", 450, 0., 45.0, 500, 1.5, 2.5);
1007         fListHistCascade->Add(f2dHistXiRadiusVsEffMassOmegaMinus);
1008 }
1009
1010 if(! f2dHistXiRadiusVsEffMassOmegaPlus) {
1011         f2dHistXiRadiusVsEffMassOmegaPlus = new TH2F( "f2dHistXiRadiusVsEffMassOmegaPlus", "Transv. R_{Xi Decay} Vs M_{#Omega^{+} candidates}; r_{cascade} (cm); M( #Lambda , K^{+} ) (GeV/c^{2}) ", 450, 0., 45.0, 500, 1.5, 2.5);
1012         fListHistCascade->Add(f2dHistXiRadiusVsEffMassOmegaPlus);
1013 }
1014
1015 //------
1016
1017 if(! f2dHistTPCdEdxOfCascDghters){
1018         f2dHistTPCdEdxOfCascDghters = new TH2F( "f2dHistTPCdEdxOfCascDghters", "TPC dE/dx of the cascade daughters; charge x || #vec{p}_{TPC inner wall}(Casc. daughter) || (GeV/c); TPC signal (ADC) ", 2000, -10.0, 10.0, 450, 0., 900.);
1019         fListHistCascade->Add(f2dHistTPCdEdxOfCascDghters);
1020 }
1021
1022
1023
1024 // Part 2 : Raw material for yield extraction -------
1025
1026 if(! f3dHistXiPtVsEffMassVsYXiMinus) {
1027         f3dHistXiPtVsEffMassVsYXiMinus = new TH3F( "f3dHistXiPtVsEffMassVsYXiMinus", "Pt_{cascade} Vs M_{#Xi^{-} candidates} Vs Y_{#Xi}; Pt_{cascade} (GeV/c); M( #Lambda , #pi^{-} ) (GeV/c^{2}) ;Y_{#Xi} ", 100, 0., 10.0, 400, 1.2, 2.0, 44, -1.1,1.1);
1028         fListHistCascade->Add(f3dHistXiPtVsEffMassVsYXiMinus);
1029 }
1030
1031 if(! f3dHistXiPtVsEffMassVsYXiPlus) {
1032         f3dHistXiPtVsEffMassVsYXiPlus = new TH3F( "f3dHistXiPtVsEffMassVsYXiPlus", "Pt_{cascade} Vs M_{#Xi^{+} candidates} Vs Y_{#Xi}; Pt_{cascade} (GeV/c); M( #Lambda , #pi^{+} ) (GeV/c^{2}); Y_{#Xi}", 100, 0., 10.0, 400, 1.2, 2.0, 44, -1.1,1.1);
1033         fListHistCascade->Add(f3dHistXiPtVsEffMassVsYXiPlus);
1034 }
1035
1036 if(! f3dHistXiPtVsEffMassVsYOmegaMinus) {
1037         f3dHistXiPtVsEffMassVsYOmegaMinus = new TH3F( "f3dHistXiPtVsEffMassVsYOmegaMinus", "Pt_{cascade} Vs M_{#Omega^{-} candidates} Vs Y_{#Omega}; Pt_{cascade} (GeV/c); M( #Lambda , K^{-} ) (GeV/c^{2}); Y_{#Omega}", 100, 0., 10.0, 500, 1.5, 2.5, 44, -1.1,1.1);
1038         fListHistCascade->Add(f3dHistXiPtVsEffMassVsYOmegaMinus);
1039 }
1040
1041 if(! f3dHistXiPtVsEffMassVsYOmegaPlus) {
1042         f3dHistXiPtVsEffMassVsYOmegaPlus = new TH3F( "f3dHistXiPtVsEffMassVsYOmegaPlus", "Pt_{cascade} Vs M_{#Omega^{+} candidates} Vs Y_{#Omega}; Pt_{cascade} (GeV/c); M( #Lambda , K^{+} ) (GeV/c^{2}); Y_{#Omega}", 100, 0., 10.0, 500, 1.5, 2.5, 44, -1.1,1.1);
1043         fListHistCascade->Add(f3dHistXiPtVsEffMassVsYOmegaPlus);
1044 }
1045
1046 //--
1047 if(! fCFContCascadePIDXiMinus)  {
1048   const Int_t  lNbSteps      =  7 ;
1049   const Int_t  lNbVariables  =  4 ;
1050
1051   //array for the number of bins in each dimension :
1052   Int_t lNbBinsPerVar[4] = {0};
1053   lNbBinsPerVar[0] = 100;
1054   lNbBinsPerVar[1] = 400;
1055   lNbBinsPerVar[2] = 44;
1056   lNbBinsPerVar[3] = 250;
1057    
1058   
1059   fCFContCascadePIDXiMinus = new AliCFContainer("fCFContCascadePIDXiMinus","Pt_{cascade} Vs M_{#Xi^{-} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
1060   
1061   //setting the bin limits (valid  for v4-18-10-AN)
1062   fCFContCascadePIDXiMinus->SetBinLimits(0,   0.0  ,  10.0 );   // Pt(Cascade)
1063   fCFContCascadePIDXiMinus->SetBinLimits(1,   1.2  ,   2.0 );   // Xi Effective mass
1064   fCFContCascadePIDXiMinus->SetBinLimits(2,  -1.1  ,   1.1 );   // Rapidity
1065   if(fCollidingSystems) 
1066         fCFContCascadePIDXiMinus->SetBinLimits(3, 0.0, 20000.0  );    // Primary track Multiplicity
1067   else
1068         fCFContCascadePIDXiMinus->SetBinLimits(3, 0.0, 250.0  );     // Primary track Multiplicity
1069   
1070   // Setting the step title : one per PID case
1071   fCFContCascadePIDXiMinus->SetStepTitle(0, "No PID");
1072   fCFContCascadePIDXiMinus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
1073   fCFContCascadePIDXiMinus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
1074   fCFContCascadePIDXiMinus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
1075   fCFContCascadePIDXiMinus->SetStepTitle(4, "Comb. PID / Bachelor");
1076   fCFContCascadePIDXiMinus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
1077   fCFContCascadePIDXiMinus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
1078   
1079   // Setting the variable title, per axis
1080   fCFContCascadePIDXiMinus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
1081   fCFContCascadePIDXiMinus->SetVarTitle(1, "M( #Lambda , #pi^{-} ) (GeV/c^{2})");
1082   fCFContCascadePIDXiMinus->SetVarTitle(2, "Y_{#Xi}");
1083   fCFContCascadePIDXiMinus->SetVarTitle(3, "Primary track Multiplicity");
1084   
1085   fListHistCascade->Add(fCFContCascadePIDXiMinus);
1086   
1087 }
1088
1089 if(! fCFContCascadePIDXiPlus)  {
1090   const Int_t  lNbSteps      =  7 ;
1091   const Int_t  lNbVariables  =  4 ;
1092
1093   //array for the number of bins in each dimension :
1094   Int_t lNbBinsPerVar[4] = {0};
1095   lNbBinsPerVar[0] = 100;
1096   lNbBinsPerVar[1] = 400;
1097   lNbBinsPerVar[2] = 44;
1098   lNbBinsPerVar[3] = 250;
1099    
1100   
1101   fCFContCascadePIDXiPlus = new AliCFContainer("fCFContCascadePIDXiPlus","Pt_{cascade} Vs M_{#Xi^{+} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
1102   
1103   
1104   //setting the bin limits (valid  for v4-18-10-AN)
1105   fCFContCascadePIDXiPlus->SetBinLimits(0,   0.0  ,  10.0 );    // Pt(Cascade)
1106   fCFContCascadePIDXiPlus->SetBinLimits(1,   1.2  ,   2.0 );    // Xi Effective mass
1107   fCFContCascadePIDXiPlus->SetBinLimits(2,  -1.1  ,   1.1 );    // Rapidity
1108   if(fCollidingSystems) 
1109         fCFContCascadePIDXiPlus->SetBinLimits(3, 0.0, 20000.0  );    // Primary track Multiplicity
1110   else
1111         fCFContCascadePIDXiPlus->SetBinLimits(3, 0.0, 250.0  );     // Primary track Multiplicity
1112   
1113   // Setting the step title : one per PID case
1114   fCFContCascadePIDXiPlus->SetStepTitle(0, "No PID");
1115   fCFContCascadePIDXiPlus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
1116   fCFContCascadePIDXiPlus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
1117   fCFContCascadePIDXiPlus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
1118   fCFContCascadePIDXiPlus->SetStepTitle(4, "Comb. PID / Bachelor");
1119   fCFContCascadePIDXiPlus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
1120   fCFContCascadePIDXiPlus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
1121   
1122   // Setting the variable title, per axis
1123   fCFContCascadePIDXiPlus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
1124   fCFContCascadePIDXiPlus->SetVarTitle(1, "M( #Lambda , #pi^{+} ) (GeV/c^{2})");
1125   fCFContCascadePIDXiPlus->SetVarTitle(2, "Y_{#Xi}");
1126   fCFContCascadePIDXiPlus->SetVarTitle(3, "Primary track Multiplicity");
1127   
1128   fListHistCascade->Add(fCFContCascadePIDXiPlus);
1129   
1130 }
1131
1132
1133 if(! fCFContCascadePIDOmegaMinus)  {
1134   const Int_t  lNbSteps      =  7 ;
1135   const Int_t  lNbVariables  =  4 ;
1136
1137   //array for the number of bins in each dimension :
1138   Int_t lNbBinsPerVar[4] = {0};
1139   lNbBinsPerVar[0] = 100;
1140   lNbBinsPerVar[1] = 500;
1141   lNbBinsPerVar[2] = 44;
1142   lNbBinsPerVar[3] = 250;
1143    
1144   
1145   fCFContCascadePIDOmegaMinus = new AliCFContainer("fCFContCascadePIDOmegaMinus","Pt_{cascade} Vs M_{#Omega^{-} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
1146   
1147   
1148   //setting the bin limits (valid  for v4-18-10-AN)
1149   fCFContCascadePIDOmegaMinus->SetBinLimits(0,   0.0  ,  10.0 );        // Pt(Cascade)
1150   fCFContCascadePIDOmegaMinus->SetBinLimits(1,   1.5  ,   2.5 );        // Omega Effective mass
1151   fCFContCascadePIDOmegaMinus->SetBinLimits(2,  -1.1  ,   1.1 );        // Rapidity
1152   if(fCollidingSystems) 
1153         fCFContCascadePIDOmegaMinus->SetBinLimits(3, 0.0, 20000.0  );    //Primary track Multiplicity
1154   else
1155         fCFContCascadePIDOmegaMinus->SetBinLimits(3, 0.0, 250.0  );     // Primary track Multiplicity
1156   
1157   // Setting the step title : one per PID case
1158   fCFContCascadePIDOmegaMinus->SetStepTitle(0, "No PID");
1159   fCFContCascadePIDOmegaMinus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
1160   fCFContCascadePIDOmegaMinus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
1161   fCFContCascadePIDOmegaMinus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
1162   fCFContCascadePIDOmegaMinus->SetStepTitle(4, "Comb. PID / Bachelor");
1163   fCFContCascadePIDOmegaMinus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
1164   fCFContCascadePIDOmegaMinus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
1165   
1166   // Setting the variable title, per axis
1167   fCFContCascadePIDOmegaMinus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
1168   fCFContCascadePIDOmegaMinus->SetVarTitle(1, "M( #Lambda , K^{-} ) (GeV/c^{2})");
1169   fCFContCascadePIDOmegaMinus->SetVarTitle(2, "Y_{#Omega}");
1170   fCFContCascadePIDOmegaMinus->SetVarTitle(3, "Primary track Multiplicity");
1171   
1172   fListHistCascade->Add(fCFContCascadePIDOmegaMinus);
1173   
1174 }
1175
1176 if(! fCFContCascadePIDOmegaPlus)  {
1177   const Int_t  lNbSteps      =  7 ;
1178   const Int_t  lNbVariables  =  4 ;
1179
1180   //array for the number of bins in each dimension :
1181   Int_t lNbBinsPerVar[4] = {0};
1182   lNbBinsPerVar[0] = 100;
1183   lNbBinsPerVar[1] = 500;
1184   lNbBinsPerVar[2] = 44;
1185   lNbBinsPerVar[3] = 250;
1186    
1187   
1188   fCFContCascadePIDOmegaPlus = new AliCFContainer("fCFContCascadePIDOmegaPlus","Pt_{cascade} Vs M_{#Omega^{+} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
1189   
1190   
1191   //setting the bin limits (valid  for v4-18-10-AN)
1192   fCFContCascadePIDOmegaPlus->SetBinLimits(0,   0.0  ,  10.0 ); // Pt(Cascade)
1193   fCFContCascadePIDOmegaPlus->SetBinLimits(1,   1.5  ,   2.5 ); // Omega Effective mass
1194   fCFContCascadePIDOmegaPlus->SetBinLimits(2,  -1.1  ,   1.1 ); // Rapidity
1195   if(fCollidingSystems) 
1196         fCFContCascadePIDOmegaPlus->SetBinLimits(3, 0.0, 20000.0  );    // Primary track Multiplicity
1197   else
1198         fCFContCascadePIDOmegaPlus->SetBinLimits(3, 0.0, 250.0  );     // Primary track Multiplicity
1199   
1200   // Setting the step title : one per PID case
1201   fCFContCascadePIDOmegaPlus->SetStepTitle(0, "No PID");
1202   fCFContCascadePIDOmegaPlus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
1203   fCFContCascadePIDOmegaPlus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
1204   fCFContCascadePIDOmegaPlus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
1205   fCFContCascadePIDOmegaPlus->SetStepTitle(4, "Comb. PID / Bachelor");
1206   fCFContCascadePIDOmegaPlus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
1207   fCFContCascadePIDOmegaPlus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
1208   
1209   // Setting the variable title, per axis
1210   fCFContCascadePIDOmegaPlus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
1211   fCFContCascadePIDOmegaPlus->SetVarTitle(1, "M( #Lambda , K^{+} ) (GeV/c^{2})");
1212   fCFContCascadePIDOmegaPlus->SetVarTitle(2, "Y_{#Omega}");
1213   fCFContCascadePIDOmegaPlus->SetVarTitle(3, "Primary track Multiplicity"); 
1214   
1215   fListHistCascade->Add(fCFContCascadePIDOmegaPlus);
1216   
1217 }
1218
1219
1220
1221
1222
1223 // Part 3 : Towards the optimisation of topological selections -------
1224 if(! fCFContCascadeCuts){
1225    
1226         // Container meant to store all the relevant distributions corresponding to the cut variables.
1227         // So far, 20 variables have been identified.
1228         // The following will be done in quite a brut force way ... 
1229         // FIXME Improvement expected later (before Pb-Pb data at least)
1230         //          - Define a user binning to have less bins in each dimension
1231         //          - boolean for enabling/disbaling this CFContainer
1232   const Int_t  lNbSteps      =  4 ;
1233   const Int_t  lNbVariables  =  20 ;
1234   
1235   //array for the number of bins in each dimension :
1236   Int_t lNbBinsPerVar[20] = {0};
1237   lNbBinsPerVar[0]  = 25;
1238   lNbBinsPerVar[1]  = 25;
1239   lNbBinsPerVar[2]  = 20;
1240   lNbBinsPerVar[3]  = 40;
1241   lNbBinsPerVar[4]  = 30;
1242   lNbBinsPerVar[5]  = 25;
1243   
1244   lNbBinsPerVar[6]  = 20;
1245   lNbBinsPerVar[7]  = 40;
1246   lNbBinsPerVar[8]  = 40;
1247   lNbBinsPerVar[9]  = 25;
1248   lNbBinsPerVar[10] = 25;
1249   
1250   lNbBinsPerVar[11] = 75;  // 2-MeV/c2 bins
1251   lNbBinsPerVar[12] = 60;  // 2-MeV/c2 bins
1252   
1253   lNbBinsPerVar[13] = 100;
1254   
1255   lNbBinsPerVar[14] = 44; // 0.05 in rapidity units
1256   lNbBinsPerVar[15] = 44; // 0.05 in rapidity units
1257   
1258   lNbBinsPerVar[16] = 20;
1259  
1260   lNbBinsPerVar[17] = 50;
1261   lNbBinsPerVar[18] = 100;
1262   lNbBinsPerVar[19] = 24;
1263     
1264  fCFContCascadeCuts = new AliCFContainer("fCFContCascadeCuts","Container for Cascade cuts", lNbSteps, lNbVariables, lNbBinsPerVar );
1265   
1266   
1267   //setting the bin limits 
1268    
1269   //0
1270   Double_t *lBinLim0  = new Double_t[ lNbBinsPerVar[0]+1 ];
1271         for(Int_t i=0; i< lNbBinsPerVar[0];i++)  lBinLim0[i]  = (Double_t)0.0   + (4.8  - 0.0 )/(lNbBinsPerVar[0]-1)  * (Double_t)i ;
1272         lBinLim0[ lNbBinsPerVar[0]  ] = 20.0;
1273   fCFContCascadeCuts -> SetBinLimits(0,  lBinLim0 );            // DcaXiDaughters : 0.0 to 5.0  
1274   delete [] lBinLim0;  
1275   //1
1276   Double_t *lBinLim1  = new Double_t[ lNbBinsPerVar[1]+1 ];
1277         for(Int_t i=0; i< lNbBinsPerVar[1];i++)   lBinLim1[i]  = (Double_t)0.0   + (0.24  - 0.0 )/(lNbBinsPerVar[1]-1)  * (Double_t)i ;
1278         lBinLim1[ lNbBinsPerVar[1]  ] = 100.0;
1279   fCFContCascadeCuts -> SetBinLimits(1,  lBinLim1 );            // DcaBachToPrimVertexXi : 0.0 to 0.25  
1280   delete [] lBinLim1;  
1281   //2 
1282   Double_t *lBinLim2  = new Double_t[ lNbBinsPerVar[2]+1 ];
1283         for(Int_t i=1; i< lNbBinsPerVar[2]+1;i++)   lBinLim2[i]  = (Double_t)0.81   + (1.0  - 0.81 )/(lNbBinsPerVar[2]-1)  * (Double_t) (i-1) ;   
1284         lBinLim2[0] = 0.0;
1285   fCFContCascadeCuts -> SetBinLimits(2,  lBinLim2 );            // XiCosineOfPointingAngle : 0.80 to 1.0        
1286   delete [] lBinLim2;  
1287   //3
1288   Double_t *lBinLim3  = new Double_t[ lNbBinsPerVar[3]+1 ];
1289         for(Int_t i=0; i< lNbBinsPerVar[3];i++)   lBinLim3[i]  = (Double_t)0.0   + (3.9  - 0.0 )/(lNbBinsPerVar[3]-1)  * (Double_t)i ;
1290         lBinLim3[ lNbBinsPerVar[3]  ] = 110.0;
1291   fCFContCascadeCuts -> SetBinLimits(3,  lBinLim3 );            // XiRadius : 0.0 to 4.0        
1292   delete [] lBinLim3;  
1293   //4
1294   fCFContCascadeCuts->SetBinLimits(4,    1.1  ,  1.13 );        // InvMassLambdaAsCascDghter
1295   //5
1296   Double_t *lBinLim5  = new Double_t[ lNbBinsPerVar[5]+1 ];
1297         for(Int_t i=0; i< lNbBinsPerVar[5];i++)   lBinLim5[i]  = (Double_t)0.0   + (4.8  - 0.0 )/(lNbBinsPerVar[5]-1)  * (Double_t)i ;
1298         lBinLim5[ lNbBinsPerVar[5]  ] = 20.0;
1299   fCFContCascadeCuts -> SetBinLimits(5,  lBinLim5 );            // DcaV0DaughtersXi : 0.0 to 5.0        
1300   delete [] lBinLim5;  
1301   
1302   
1303   //6 
1304   Double_t *lBinLim6  = new Double_t[ lNbBinsPerVar[6]+1 ];
1305         for(Int_t i=1; i< lNbBinsPerVar[6]+1 ;i++)   lBinLim6[i]  = (Double_t)0.81   + (1.0  - 0.81 )/(lNbBinsPerVar[6]-1)  * (Double_t) (i-1) ;   
1306         lBinLim6[0] = 0.0;
1307   fCFContCascadeCuts -> SetBinLimits(6,  lBinLim6 );            // V0CosineOfPointingAngleXi : 0.80 to 1.0      
1308   delete [] lBinLim6;  
1309   //7
1310   Double_t *lBinLim7  = new Double_t[ lNbBinsPerVar[7]+1 ];
1311         for(Int_t i=0; i< lNbBinsPerVar[7];i++)   lBinLim7[i]  = (Double_t)0.0   + (7.8  - 0.0 )/(lNbBinsPerVar[7]-1)  * (Double_t)i ;
1312         lBinLim7[ lNbBinsPerVar[7]  ] = 100.0;
1313   fCFContCascadeCuts -> SetBinLimits(7,  lBinLim7 );            // V0RadiusXi : 0.0 to 8.0      
1314   delete [] lBinLim7;  
1315   //8
1316   Double_t *lBinLim8  = new Double_t[ lNbBinsPerVar[8]+1 ];
1317         for(Int_t i=0; i< lNbBinsPerVar[8];i++)   lBinLim8[i]  = (Double_t)0.0   + (0.39  - 0.0 )/(lNbBinsPerVar[8]-1)  * (Double_t)i ;
1318         lBinLim8[ lNbBinsPerVar[8]  ] = 100.0;
1319   fCFContCascadeCuts -> SetBinLimits(8,  lBinLim8 );            // DcaV0ToPrimVertexXi : 0.0 to 0.40    
1320   delete [] lBinLim8;  
1321   //9
1322   Double_t *lBinLim9  = new Double_t[ lNbBinsPerVar[9]+1 ];
1323         for(Int_t i=0; i< lNbBinsPerVar[9];i++)   lBinLim9[i]  = (Double_t)0.0   + (0.24  - 0.0 )/(lNbBinsPerVar[9]-1)  * (Double_t)i ;
1324         lBinLim9[ lNbBinsPerVar[9]  ] = 100.0;
1325   fCFContCascadeCuts -> SetBinLimits(9,  lBinLim9 );            // DcaPosToPrimVertexXi : 0.0 to 0.25   
1326   delete [] lBinLim9; 
1327   //10
1328   Double_t *lBinLim10  = new Double_t[ lNbBinsPerVar[10]+1 ];
1329         for(Int_t i=0; i< lNbBinsPerVar[10];i++)   lBinLim10[i]  = (Double_t)0.0   + (0.24  - 0.0 )/(lNbBinsPerVar[10]-1)  * (Double_t)i ;
1330         lBinLim10[ lNbBinsPerVar[10]  ] = 100.0;
1331   fCFContCascadeCuts -> SetBinLimits(10,  lBinLim10 );            // DcaPosToPrimVertexXi : 0.0 to 0.25 
1332   delete [] lBinLim10; 
1333   
1334   //11
1335   fCFContCascadeCuts->SetBinLimits(11,   1.25 ,  1.40 );        // InvMassXi
1336   fCFContCascadeCuts->SetBinLimits(12,   1.62  , 1.74 );        // InvMassOmega
1337   fCFContCascadeCuts->SetBinLimits(13,   0.0  , 10.0  );        // XiTransvMom 
1338   fCFContCascadeCuts->SetBinLimits(14,  -1.1  ,  1.1  );        // Y(Xi)
1339   fCFContCascadeCuts->SetBinLimits(15,  -1.1  ,  1.1  );        // Y(Omega)
1340   fCFContCascadeCuts->SetBinLimits(16, -10.0  , 10.0  );        // BestPrimaryVtxPosZ
1341   if(fCollidingSystems){
1342         fCFContCascadeCuts->SetBinLimits(17,   0.0, 10000.0  );    // nTrackPrimaryMultiplicity
1343         fCFContCascadeCuts->SetBinLimits(18,   0.0, 10000.0  );    // SPDTrackletsMultiplicity
1344   }
1345   else{  
1346         fCFContCascadeCuts->SetBinLimits(17,   0.0, 250.0  );     // nTrackPrimaryMultiplicity
1347         fCFContCascadeCuts->SetBinLimits(18,   0.0, 200.0  );     // SPDTrackletsMultiplicity
1348   }
1349   fCFContCascadeCuts->SetBinLimits(19,  68.0  ,164.0  );        // BachTPCClusters
1350   
1351   
1352   // Regular binning definition (valid for v4-18-10-AN on)
1353   /*
1354   fCFContCascadeCuts->SetBinLimits(0,    0.0  ,  2.5  );        // DcaXiDaughters
1355   fCFContCascadeCuts->SetBinLimits(1,    0.0  ,  0.25 );        // DcaBachToPrimVertexXi
1356   fCFContCascadeCuts->SetBinLimits(2,    0.99 ,  1.0  );        // XiCosineOfPointingAngle
1357   fCFContCascadeCuts->SetBinLimits(3,    0.0  ,  4.0  );        // XiRadius
1358   fCFContCascadeCuts->SetBinLimits(4,    1.1  ,  1.15 );        // InvMassLambdaAsCascDghter
1359   fCFContCascadeCuts->SetBinLimits(5,    0.0  ,  1.0  );        // DcaV0DaughtersXi
1360   fCFContCascadeCuts->SetBinLimits(6,    0.98 ,  1.0  );        // V0CosineOfPointingAngleXi
1361   fCFContCascadeCuts->SetBinLimits(7,    0.0  , 20.0  );        // V0RadiusXi
1362   fCFContCascadeCuts->SetBinLimits(8,    0.0  ,  1.0  );        // DcaV0ToPrimVertexXi
1363   fCFContCascadeCuts->SetBinLimits(9,    0.0  ,  0.25 );        // DcaPosToPrimVertexXi
1364   fCFContCascadeCuts->SetBinLimits(10,   0.0  ,  0.25 );        // DcaNegToPrimVertexXi
1365   fCFContCascadeCuts->SetBinLimits(11,   1.25 ,  1.40 );        // InvMassXi
1366   fCFContCascadeCuts->SetBinLimits(12,   1.62  , 1.74 );        // InvMassOmega
1367   fCFContCascadeCuts->SetBinLimits(13,   0.0  , 10.0  );        // XiTransvMom 
1368   fCFContCascadeCuts->SetBinLimits(14,  -1.1  ,  1.1  );        // Y(Xi)
1369   fCFContCascadeCuts->SetBinLimits(15,  -1.1  ,  1.1  );        // Y(Omega)
1370   fCFContCascadeCuts->SetBinLimits(16, -10.0  , 10.0  );        // BestPrimaryVtxPosZ
1371   if(fCollidingSystems){
1372         fCFContCascadeCuts->SetBinLimits(17,   0.0, 10000.0  );    // nTrackPrimaryMultiplicity
1373         fCFContCascadeCuts->SetBinLimits(18,   0.0, 10000.0  );    // SPDTrackletsMultiplicity
1374   }
1375   else{  
1376         fCFContCascadeCuts->SetBinLimits(17,   0.0, 250.0  );     // nTrackPrimaryMultiplicity
1377         fCFContCascadeCuts->SetBinLimits(18,   0.0, 200.0  );     // SPDTrackletsMultiplicity
1378   }
1379   fCFContCascadeCuts->SetBinLimits(19,  25.0  ,165.0  );        // BachTPCClusters
1380   */
1381   
1382   
1383   // Setting the number of steps : one for each cascade species (Xi-, Xi+ and Omega-, Omega+)
1384   fCFContCascadeCuts->SetStepTitle(0, "#Xi^{-} candidates");
1385   fCFContCascadeCuts->SetStepTitle(1, "#bar{#Xi}^{+} candidates");
1386   fCFContCascadeCuts->SetStepTitle(2, "#Omega^{-} candidates");
1387   fCFContCascadeCuts->SetStepTitle(3, "#bar{#Omega}^{+} candidates");
1388   
1389   // Setting the variable title, per axis
1390   // fCFContCascadeCuts->SetVarTitle(40,  "Chi2Xi");
1391   fCFContCascadeCuts->SetVarTitle(0,  "Dca(XiDaughters) (cm)");
1392   fCFContCascadeCuts->SetVarTitle(1,  "Dca(Bach/PrimVertex) (cm)");
1393   fCFContCascadeCuts->SetVarTitle(2,  "cos(Xi pointing angle)");
1394   fCFContCascadeCuts->SetVarTitle(3,  "R_{2d}(Xi decay) (cm)");
1395   fCFContCascadeCuts->SetVarTitle(4,  "M_{#Lambda}(As Casc Dghter) (GeV/c^{2})");
1396    // fCFContCascadeCuts->SetVarTitle(40,  "V0Chi2Xi");
1397   fCFContCascadeCuts->SetVarTitle(5,  "Dca(V0 Daughters) in Xi (cm)");
1398   
1399   fCFContCascadeCuts->SetVarTitle(6,  "cos(V0 pointing Angle) in Casc");
1400   fCFContCascadeCuts->SetVarTitle(7,  "R_{2d}(V0 decay) (cm)");
1401   fCFContCascadeCuts->SetVarTitle(8,  "Dca(V0/PrimVertex) (cm)");
1402   fCFContCascadeCuts->SetVarTitle(9,  "Dca(Pos/PrimVertex) (cm)");
1403   fCFContCascadeCuts->SetVarTitle(10, "Dca(Neg/PrimVertex) (cm)");
1404   
1405   fCFContCascadeCuts->SetVarTitle(11, "Inv. Mass(Xi) (GeV/c^{2})");
1406   fCFContCascadeCuts->SetVarTitle(12, "Inv. Mass(Omega) (GeV/c^{2})");
1407   
1408   fCFContCascadeCuts->SetVarTitle(13, "pt(Casc.) (GeV/c)");
1409   //fCFContCascadeCuts->SetVarTitle(40, "V0toXiCosineOfPointingAngle");
1410   
1411   fCFContCascadeCuts->SetVarTitle(14, "Y(Xi)");
1412   fCFContCascadeCuts->SetVarTitle(15, "Y(Omega)");
1413   
1414   fCFContCascadeCuts->SetVarTitle(16, "Z-position(BestPrimVtx) (cm)");
1415   
1416   fCFContCascadeCuts->SetVarTitle(17, "Primary Track Multiplicity");
1417   fCFContCascadeCuts->SetVarTitle(18, "SPD tracklets Multiplicity");
1418   fCFContCascadeCuts->SetVarTitle(19, "Bach.TPC Clusters");
1419   
1420   fListHistCascade->Add(fCFContCascadeCuts);
1421 }
1422
1423
1424
1425 // Part 4 : Angular correlation study -------
1426
1427 if(! fHnSpAngularCorrXiMinus){
1428         // Delta Phi(Casc,any trck) Vs Delta Eta(Casc,any trck) Vs Casc Pt Vs Pt of the tracks
1429         // Delta Phi  = 360 bins de -180., 180.
1430         // Delta Eta  = 120 bins de -3.0, 3.0
1431         // Pt Cascade = 100 bins de 0., 10.0,
1432         // Pt track = 150 bins de 0., 15.0
1433         
1434    Int_t    bins[5] = { 360, 120, 100, 150, 40};
1435    Double_t xmin[5] = {-50., -3.,  0.,  0., 1.30};
1436    Double_t xmax[5] = { 310., 3., 10., 15., 1.34};
1437
1438     TString strHnSparseTitle("");
1439     TString strAxisTitle[5];
1440     if(fAngularCorrelationType == "TrigAnyCasc-AssoAnyPrim" ){
1441         strHnSparseTitle = "Angular Correlation for #Xi^{-}: Trig = Casc. / Asso = all prim. tracks";
1442         strAxisTitle[0]  = " #Delta#phi(Casc,Track) (deg)";
1443         strAxisTitle[1]  = " #Delta#eta(Casc,Track)";
1444         strAxisTitle[2]  = " Pt_{Casc} (GeV/c)";
1445         strAxisTitle[3]  = " Pt_{asso. track} (GeV/c)";
1446     }
1447     else if(fAngularCorrelationType == "TrigCascLeading-AssoAnyPrim"){
1448         strHnSparseTitle = "Angular Correlation for #Xi^{-}: Trig = Casc. (leading part.) / Asso = all prim. tracks";
1449         strAxisTitle[0]  = " #Delta#phi(Casc_{LEADING},Track) (deg)";
1450         strAxisTitle[1]  = " #Delta#eta(Casc_{LEADING},Track)";
1451         strAxisTitle[2]  = " Pt(Casc_{LEADING}) (GeV/c)";
1452         strAxisTitle[3]  = " Pt_{asso. track} (GeV/c)";
1453     }
1454     else if(fAngularCorrelationType == "TrigLeadingTrck-AssoCasc"){
1455         strHnSparseTitle = "Angular Correlation for #Xi^{-}: Trig = leading track / Asso = any cascade";
1456         strAxisTitle[0]  = " #Delta#phi(Leading Track,Casc) (deg)";
1457         strAxisTitle[1]  = " #Delta#eta(Leading Track,Casc)";
1458         strAxisTitle[2]  = " Pt(asso. Casc) (GeV/c)";
1459         strAxisTitle[3]  = " Pt_{Leading track} (GeV/c)";
1460
1461     }
1462         strAxisTitle[4]  = " Eff. Inv Mass (GeV/c^{2})";
1463
1464    fHnSpAngularCorrXiMinus = new THnSparseF("fHnSpAngularCorrXiMinus", strHnSparseTitle.Data(), 5, bins, xmin, xmax);
1465         fHnSpAngularCorrXiMinus->GetAxis(0)->SetTitle( strAxisTitle[0].Data() );
1466         fHnSpAngularCorrXiMinus->GetAxis(1)->SetTitle( strAxisTitle[1].Data() );
1467         fHnSpAngularCorrXiMinus->GetAxis(2)->SetTitle( strAxisTitle[2].Data() );
1468         fHnSpAngularCorrXiMinus->GetAxis(3)->SetTitle( strAxisTitle[3].Data() );
1469         fHnSpAngularCorrXiMinus->GetAxis(4)->SetTitle( strAxisTitle[4].Data() );
1470         fHnSpAngularCorrXiMinus->Sumw2();
1471    fListHistCascade->Add(fHnSpAngularCorrXiMinus);
1472 }
1473
1474 if(! fHnSpAngularCorrXiPlus){
1475         // Delta Phi(Casc,any trck) Vs Delta Eta(Casc,any trck) Vs Casc Pt Vs Pt of the tracks
1476         // Delta Phi  = 360 bins de -180., 180.
1477         // Delta Eta  = 120 bins de -3.0, 3.0
1478         // Pt Cascade = 100 bins de 0., 10.0,
1479         // Pt track = 150 bins de 0., 15.0
1480    Int_t    bins[5] = { 360, 120, 100, 150, 40};
1481    Double_t xmin[5] = {-50., -3.,  0.,  0., 1.30};
1482    Double_t xmax[5] = { 310., 3., 10., 15., 1.34};
1483    
1484     TString strHnSparseTitle("");
1485     TString strAxisTitle[5];
1486     if(fAngularCorrelationType == "TrigAnyCasc-AssoAnyPrim" ){
1487         strHnSparseTitle = "Angular Correlation for #bar{#Xi}^{+}: Trig = Casc. / Asso = all prim. tracks";
1488         strAxisTitle[0]  = " #Delta#phi(Casc,Track) (deg)";
1489         strAxisTitle[1]  = " #Delta#eta(Casc,Track)";
1490         strAxisTitle[2]  = " Pt_{Casc} (GeV/c)";
1491         strAxisTitle[3]  = " Pt_{asso. track} (GeV/c)";
1492     }
1493     else if(fAngularCorrelationType == "TrigCascLeading-AssoAnyPrim"){
1494         strHnSparseTitle = "Angular Correlation for #bar{#Xi}^{+}: Trig = Casc. (leading part.) / Asso = all prim. tracks";
1495         strAxisTitle[0]  = " #Delta#phi(Casc_{LEADING},Track) (deg)";
1496         strAxisTitle[1]  = " #Delta#eta(Casc_{LEADING},Track)";
1497         strAxisTitle[2]  = " Pt(Casc_{LEADING}) (GeV/c)";
1498         strAxisTitle[3]  = " Pt_{asso. track} (GeV/c)";
1499     }
1500     else if(fAngularCorrelationType == "TrigLeadingTrck-AssoCasc"){
1501         strHnSparseTitle = "Angular Correlation for #bar{#Xi}^{+}: Trig = leading track / Asso = any cascade";
1502         strAxisTitle[0]  = " #Delta#phi(Leading Track,Casc) (deg)";
1503         strAxisTitle[1]  = " #Delta#eta(Leading Track,Casc)";
1504         strAxisTitle[2]  = " Pt(asso. Casc) (GeV/c)";
1505         strAxisTitle[3]  = " Pt_{Leading track} (GeV/c)";
1506
1507     }
1508         strAxisTitle[4]  = " Eff. Inv Mass (GeV/c^{2})";
1509
1510    fHnSpAngularCorrXiPlus = new THnSparseF("fHnSpAngularCorrXiPlus", strHnSparseTitle.Data(), 5, bins, xmin, xmax);
1511         fHnSpAngularCorrXiPlus->GetAxis(0)->SetTitle( strAxisTitle[0].Data() );
1512         fHnSpAngularCorrXiPlus->GetAxis(1)->SetTitle( strAxisTitle[1].Data() );
1513         fHnSpAngularCorrXiPlus->GetAxis(2)->SetTitle( strAxisTitle[2].Data() );
1514         fHnSpAngularCorrXiPlus->GetAxis(3)->SetTitle( strAxisTitle[3].Data() );
1515         fHnSpAngularCorrXiPlus->GetAxis(4)->SetTitle( strAxisTitle[4].Data() );
1516         fHnSpAngularCorrXiPlus->Sumw2();
1517    fListHistCascade->Add(fHnSpAngularCorrXiPlus);
1518 }
1519
1520 if(! fHnSpAngularCorrOmegaMinus){
1521         // Delta Phi(Casc,any trck) Vs Delta Eta(Casc,any trck) Vs Casc Pt Vs Pt of the tracks
1522         // Delta Phi  = 360 bins de -180., 180.
1523         // Delta Eta  = 120 bins de -3.0, 3.0
1524         // Pt Cascade = 100 bins de 0., 10.0,
1525         // Pt track = 150 bins de 0., 15.0
1526         
1527    Int_t    bins[5] = { 360, 120, 100, 150, 40};
1528    Double_t xmin[5] = {-50., -3.,  0.,  0., 1.65};
1529    Double_t xmax[5] = { 310., 3., 10., 15., 1.69};
1530    
1531     TString strHnSparseTitle("");
1532     TString strAxisTitle[5];
1533     if(fAngularCorrelationType == "TrigAnyCasc-AssoAnyPrim" ){
1534         strHnSparseTitle = "Angular Correlation for #Omega^{-}: Trig = Casc. / Asso = all prim. tracks";
1535         strAxisTitle[0]  = " #Delta#phi(Casc,Track) (deg)";
1536         strAxisTitle[1]  = " #Delta#eta(Casc,Track)";
1537         strAxisTitle[2]  = " Pt_{Casc} (GeV/c)";
1538         strAxisTitle[3]  = " Pt_{asso. track} (GeV/c)";
1539     }
1540     else if(fAngularCorrelationType == "TrigCascLeading-AssoAnyPrim"){
1541         strHnSparseTitle = "Angular Correlation for #Omega^{-}: Trig = Casc. (leading part.) / Asso = all prim. tracks";
1542         strAxisTitle[0]  = " #Delta#phi(Casc_{LEADING},Track) (deg)";
1543         strAxisTitle[1]  = " #Delta#eta(Casc_{LEADING},Track)";
1544         strAxisTitle[2]  = " Pt(Casc_{LEADING}) (GeV/c)";
1545         strAxisTitle[3]  = " Pt_{asso. track} (GeV/c)";
1546     }
1547     else if(fAngularCorrelationType == "TrigLeadingTrck-AssoCasc"){
1548         strHnSparseTitle = "Angular Correlation for #Omega^{-}: Trig = leading track / Asso = any cascade";
1549         strAxisTitle[0]  = " #Delta#phi(Leading Track,Casc) (deg)";
1550         strAxisTitle[1]  = " #Delta#eta(Leading Track,Casc)";
1551         strAxisTitle[2]  = " Pt(asso. Casc) (GeV/c)";
1552         strAxisTitle[3]  = " Pt_{Leading track} (GeV/c)";
1553
1554     }
1555         strAxisTitle[4]  = " Eff. Inv Mass (GeV/c^{2})";
1556     
1557    fHnSpAngularCorrOmegaMinus = new THnSparseF("fHnSpAngularCorrOmegaMinus", strHnSparseTitle.Data(), 5, bins, xmin, xmax);
1558         fHnSpAngularCorrOmegaMinus->GetAxis(0)->SetTitle( strAxisTitle[0].Data() );
1559         fHnSpAngularCorrOmegaMinus->GetAxis(1)->SetTitle( strAxisTitle[1].Data() );
1560         fHnSpAngularCorrOmegaMinus->GetAxis(2)->SetTitle( strAxisTitle[2].Data() );
1561         fHnSpAngularCorrOmegaMinus->GetAxis(3)->SetTitle( strAxisTitle[3].Data() );
1562         fHnSpAngularCorrOmegaMinus->GetAxis(4)->SetTitle( strAxisTitle[4].Data() );
1563         fHnSpAngularCorrOmegaMinus->Sumw2();
1564    fListHistCascade->Add(fHnSpAngularCorrOmegaMinus);
1565 }
1566
1567 if(! fHnSpAngularCorrOmegaPlus){
1568         // Delta Phi(Casc,any trck) Vs Delta Eta(Casc,any trck) Vs Casc Pt Vs Pt of the tracks
1569         // Delta Phi  = 360 bins de -180., 180.
1570         // Delta Eta  = 120 bins de -3.0, 3.0
1571         // Pt Cascade = 100 bins de 0., 10.0,
1572         // Pt track = 150 bins de 0., 15.0
1573    Int_t    bins[5] = { 360, 120, 100, 150, 40};
1574    Double_t xmin[5] = {-50., -3.,  0.,  0., 1.65};
1575    Double_t xmax[5] = { 310., 3., 10., 15., 1.69};
1576    
1577     TString strHnSparseTitle("");
1578     TString strAxisTitle[5];
1579         if(fAngularCorrelationType == "TrigAnyCasc-AssoAnyPrim" ){
1580         strHnSparseTitle = "Angular Correlation for #bar{#Omega}^{+}: Trig = Casc. / Asso = all prim. tracks";
1581         strAxisTitle[0]  = " #Delta#phi(Casc,Track) (deg)";
1582         strAxisTitle[1]  = " #Delta#eta(Casc,Track)";
1583         strAxisTitle[2]  = " Pt_{Casc} (GeV/c)";
1584         strAxisTitle[3]  = " Pt_{asso. track} (GeV/c)";
1585     }
1586     else if(fAngularCorrelationType == "TrigCascLeading-AssoAnyPrim"){
1587         strHnSparseTitle = "Angular Correlation for #bar{#Omega}^{+}: Trig = Casc. (leading part.) / Asso = all prim. tracks";
1588         strAxisTitle[0]  = " #Delta#phi(Casc_{LEADING},Track) (deg)";
1589         strAxisTitle[1]  = " #Delta#eta(Casc_{LEADING},Track)";
1590         strAxisTitle[2]  = " Pt(Casc_{LEADING}) (GeV/c)";
1591         strAxisTitle[3]  = " Pt_{asso. track} (GeV/c)";
1592     }
1593     else if(fAngularCorrelationType == "TrigLeadingTrck-AssoCasc"){
1594         strHnSparseTitle = "Angular Correlation for #bar{#Omega}^{+}: Trig = leading track / Asso = any cascade";
1595         strAxisTitle[0]  = " #Delta#phi(Leading Track,Casc) (deg)";
1596         strAxisTitle[1]  = " #Delta#eta(Leading Track,Casc)";
1597         strAxisTitle[2]  = " Pt(asso. Casc) (GeV/c)";
1598         strAxisTitle[3]  = " Pt_{Leading track} (GeV/c)";
1599
1600     }
1601         strAxisTitle[4]  = " Eff. Inv Mass (GeV/c^{2})";
1602    
1603    fHnSpAngularCorrOmegaPlus = new THnSparseF("fHnSpAngularCorrOmegaPlus", strHnSparseTitle.Data(), 5, bins, xmin, xmax);
1604         fHnSpAngularCorrOmegaPlus->GetAxis(0)->SetTitle( strAxisTitle[0].Data() );
1605         fHnSpAngularCorrOmegaPlus->GetAxis(1)->SetTitle( strAxisTitle[1].Data() );
1606         fHnSpAngularCorrOmegaPlus->GetAxis(2)->SetTitle( strAxisTitle[2].Data() );
1607         fHnSpAngularCorrOmegaPlus->GetAxis(3)->SetTitle( strAxisTitle[3].Data() );
1608         fHnSpAngularCorrOmegaPlus->GetAxis(4)->SetTitle( strAxisTitle[4].Data() );
1609         fHnSpAngularCorrOmegaPlus->Sumw2();
1610    fListHistCascade->Add(fHnSpAngularCorrOmegaPlus);
1611 }
1612
1613
1614 PostData(1, fListHistCascade);
1615 /* PostData(2, fPaveTextBookKeeping);*/
1616 }// end UserCreateOutputObjects
1617
1618
1619
1620
1621
1622
1623 //________________________________________________________________________
1624 void AliAnalysisTaskCheckCascade::UserExec(Option_t *) 
1625 {
1626   // Main loop
1627   // Called for each event
1628
1629         AliESDEvent *lESDevent = 0x0;
1630         AliAODEvent *lAODevent = 0x0;
1631         Int_t    ncascades                      = -1;
1632         Int_t    nTrackMultiplicity             = -1;
1633         Int_t    nTrackWithTPCrefitMultiplicity = -1;
1634         Int_t    nTrackPrimaryMultiplicity      = -1;
1635
1636         Short_t  lStatusTrackingPrimVtx         = -2;
1637         Double_t lTrkgPrimaryVtxPos[3]          = {-100.0, -100.0, -100.0};
1638         Double_t lBestPrimaryVtxPos[3]          = {-100.0, -100.0, -100.0};
1639         Double_t lMagneticField                 = -10.;
1640
1641         
1642         
1643   // Connect to the InputEvent  
1644   // After these lines, we should have an ESD/AOD event + the number of cascades in it.
1645                 
1646   if(fAnalysisType == "ESD"){
1647         lESDevent = dynamic_cast<AliESDEvent*>( InputEvent() );
1648         if (!lESDevent) {
1649                 AliWarning("ERROR: lESDevent not available \n");
1650                 return;
1651         }
1652         
1653         fHistCascadeMultiplicityBeforeTrigSel->Fill ( lESDevent->GetNumberOfCascades() );
1654         
1655         //-------------------------------------------------
1656         // 0 - Trigger managment
1657         // NOTE : Check the availability of the proper trigger 
1658         
1659         // 1st option
1660                 //AliMCEventHandler *lmcEvtHandler  = dynamic_cast<AliMCEventHandler*>( (AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler() );
1661                 //if( !lmcEvtHandler ){  // !0x0 = real data or !1 = there is an MC handler available (useMC = kTRUE in AnalysisTrainNew), so = data from MC
1662                 //             if ( !( lESDevent->IsTriggerClassFired("CINT1B-ABCE-NOPF-ALL")) ) return;
1663                 //}
1664
1665         // 2nd option - Presuppose the presence of AliPhysicsSelectionTask FIXME
1666         
1667         UInt_t maskIsSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
1668         Bool_t isSelected = 0;
1669         if(     fTriggerMaskType == "kMB")           isSelected = (maskIsSelected & AliVEvent::kMB) == AliVEvent::kMB;
1670         else if(fTriggerMaskType == "kHighMult")     isSelected = (maskIsSelected & AliVEvent::kHighMult) == AliVEvent::kHighMult;
1671         else                                         isSelected = 1; // default = select anyway (use case = run without Phys Selection task)
1672         
1673         if ( ! isSelected ) { 
1674                 PostData(1, fListHistCascade); 
1675                 return;
1676         }
1677         
1678         //else Printf("Event selected ... \n");
1679         
1680         
1681         
1682         //-------------------------------------------------
1683         // 1 - Cascade vertexer (ESD)
1684         
1685         if(fkRerunV0CascVertexers){ // FIXME : relaunch V0 and Cascade vertexers
1686                 if(fAnalysisType == "ESD" ){
1687 //                         lESDevent->ResetCascades();
1688 //                         lESDevent->ResetV0s();
1689 //                 
1690 //                         AliV0vertexer lV0vtxer;
1691 //                         AliCascadeVertexer lCascVtxer;
1692 //                 
1693 //                         lV0vtxer.SetDefaultCuts(fV0Sels);
1694 //                         lCascVtxer.SetDefaultCuts(fCascSels);
1695 //                 
1696 //                         lV0vtxer.Tracks2V0vertices(lESDevent);
1697 //                         lCascVtxer.V0sTracks2CascadeVertices(lESDevent);
1698                }
1699         }// end if(RelaunchV0CascVertexers)
1700         
1701         //-------------------------------------------------
1702         ncascades                      = lESDevent->GetNumberOfCascades();
1703         nTrackWithTPCrefitMultiplicity = DoESDTrackWithTPCrefitMultiplicity(lESDevent);
1704         nTrackPrimaryMultiplicity      = fESDtrackCuts->CountAcceptedTracks(lESDevent);
1705
1706   }//if (fAnalysisType == "ESD")
1707   
1708   
1709   if(fAnalysisType == "AOD"){  
1710           lAODevent = dynamic_cast<AliAODEvent*>( InputEvent() ); 
1711         if (!lAODevent) {
1712                 AliWarning("ERROR: lAODevent not available \n");
1713                 return;
1714         }
1715         ncascades                      = lAODevent->GetNumberOfCascades();
1716         nTrackWithTPCrefitMultiplicity = -1;
1717         nTrackPrimaryMultiplicity      = -1;
1718         
1719         fHistCascadeMultiplicityBeforeTrigSel->Fill ( ncascades );
1720   }
1721
1722   // For AOD or ESD ...
1723         nTrackMultiplicity = (InputEvent())->GetNumberOfTracks();
1724
1725
1726         //-------------------------------------------------
1727         fHistTrackMultiplicityForTrigEvt         ->Fill( nTrackMultiplicity             );
1728         fHistTPCrefitTrackMultiplicityForTrigEvt ->Fill( nTrackWithTPCrefitMultiplicity );
1729         fHistPrimaryTrackMultiplicityForTrigEvt  ->Fill( nTrackPrimaryMultiplicity      );
1730         fHistCascadeMultiplicityForTrigEvt       ->Fill( ncascades                      );
1731
1732
1733
1734
1735   // ---------------------------------------------------------------
1736   // I - Global characteristics of the events + general histos (filled for any selected events and/or for the analysed events)
1737
1738                 // - I.Step 1 : Characteristics of the event : prim. Vtx + magnetic field (ESD)
1739                 //-------------
1740
1741    if(fAnalysisType == "ESD"){
1742         const AliESDVertex *lPrimaryTrackingESDVtx = lESDevent->GetPrimaryVertexTracks();
1743                 // get the vtx stored in ESD found with tracks
1744                 lPrimaryTrackingESDVtx->GetXYZ( lTrkgPrimaryVtxPos );
1745         
1746         
1747         const AliESDVertex *lPrimaryBestESDVtx = lESDevent->GetPrimaryVertex(); 
1748                 // get the best primary vertex available for the event
1749                 // As done in AliCascadeVertexer, we keep the one which is the best one available.
1750                 // between : Tracking vertex > SPD vertex > TPC vertex > default SPD vertex
1751                 // This one will be used for next calculations (DCA essentially)
1752                 lPrimaryBestESDVtx->GetXYZ( lBestPrimaryVtxPos );
1753                 lStatusTrackingPrimVtx  = lPrimaryTrackingESDVtx->GetStatus();
1754
1755         // FIXME : quality cut on the z-position of the prim vertex.
1756         if(fkQualityCutZprimVtxPos) {
1757                 if(TMath::Abs(lBestPrimaryVtxPos[2]) > 10.0 ) { 
1758                         AliWarning("Pb / | Z position of Best Prim Vtx | > 10.0 cm ... return !"); 
1759                         PostData(1, fListHistCascade); 
1760                         return; 
1761                 }
1762         }
1763         
1764         fHistCascadeMultiplicityForTrigEvtAndZprimVtx->Fill( ncascades  );
1765         
1766         // FIXME : quality selection regarding pile-up rejection 
1767         if(fkRejectEventPileUp) {
1768                 if(lESDevent->IsPileupFromSPD() ){// minContributors=3, minZdist=0.8, nSigmaZdist=3., nSigmaDiamXY=2., nSigmaDiamZ=5.  -> see http://alisoft.cern.ch/viewvc/trunk/STEER/AliESDEvent.h?root=AliRoot&r1=41914&r2=42199&pathrev=42199
1769                         AliWarning("Pb / Event tagged as pile-up by SPD... return !"); 
1770                         PostData(1, fListHistCascade); 
1771                         return; 
1772                 }
1773         }
1774         
1775         fHistCascadeMultiplicityForTrigEvtNonPiledUpAndZprimVtx->Fill( ncascades  );
1776         
1777         // FIXME : remove TPC-only primary vertex : retain only events with tracking + SPD vertex
1778         if(fkQualityCutNoTPConlyPrimVtx) {
1779                 const AliESDVertex *lPrimarySPDVtx = lESDevent->GetPrimaryVertexSPD();
1780                 if (!lPrimarySPDVtx->GetStatus() && !lPrimaryTrackingESDVtx->GetStatus() ){
1781                         AliWarning("Pb / No SPD prim. vertex nor prim. Tracking vertex ... return !");
1782                         PostData(1, fListHistCascade); 
1783                         return;
1784                 }
1785         }
1786         
1787         // NOTE : For older evts
1788         
1789         // As previously done in AliCascadeVertexer, we keep, between both retrieved vertices (SPD or Tracking) 
1790         // the one which is the best one available.
1791         // This one will be used for next calculations (DCA essentially)
1792         // At that time, the TPC-only primary vertex was not considered
1793         
1794         
1795         lMagneticField = lESDevent->GetMagneticField( );
1796         // FIXME if(TMath::Abs(lMagneticField ) < 10e-6) continue;
1797         
1798    }// end if(ESD)
1799         
1800    if(fAnalysisType == "AOD"){
1801         // To be developed
1802         const AliAODVertex *lPrimaryBestAODVtx = lAODevent->GetPrimaryVertex(); 
1803         // get the best primary vertex available for the event
1804         // We may keep the one which is the best one available = GetVertex(0)
1805         // Pb with pile-up to expect
1806         // This one will be used for next calculations (DCA essentially)
1807         lPrimaryBestAODVtx->GetXYZ( lBestPrimaryVtxPos );
1808         
1809         lStatusTrackingPrimVtx  = -1;
1810         lTrkgPrimaryVtxPos[0]   = -100.0;
1811         lTrkgPrimaryVtxPos[1]   = -100.0;
1812         lTrkgPrimaryVtxPos[2]   = -100.0;
1813         lMagneticField = 0.;
1814    }
1815
1816
1817                 // - I.Step 2 : Filling histos that characterize the selected event : x,y,z prim. Vtx distrib. (ESD)
1818                 //-------------
1819
1820         fHistCascadeMultiplicityForSelEvt ->Fill( ncascades );
1821         fHistPosBestPrimaryVtxXForSelEvt  ->Fill( lBestPrimaryVtxPos[0] );
1822         fHistPosBestPrimaryVtxYForSelEvt  ->Fill( lBestPrimaryVtxPos[1] );
1823         fHistPosBestPrimaryVtxZForSelEvt  ->Fill( lBestPrimaryVtxPos[2] );
1824        
1825
1826   
1827   // ---------------------------------------------------------------
1828   // II - Calcultaion Part dedicated to Xi vertices
1829   
1830   for (Int_t iXi = 0; iXi < ncascades; iXi++)
1831   {// This is the begining of the Cascade loop (ESD or AOD)
1832            
1833     // -------------------------------------
1834     // II.Init - Initialisation of the local variables that will be needed for ESD/AOD
1835
1836   
1837         // - 0th part of initialisation : around primary vertex ...
1838         
1839         Double_t lTrkgPrimaryVtxRadius3D = -500.0;
1840         Double_t lBestPrimaryVtxRadius3D = -500.0;
1841
1842         // - 1st part of initialisation : variables needed to store AliESDCascade data members
1843         Double_t lEffMassXi      = 0. ;
1844         Double_t lChi2Xi         = -1. ;
1845         Double_t lDcaXiDaughters = -1. ;
1846         Double_t lXiCosineOfPointingAngle = -1. ;
1847         Double_t lPosXi[3] = { -1000.0, -1000.0, -1000.0 };
1848         Double_t lXiRadius2D = -1000. ;
1849         Double_t lXiRadius3D = -1000. ;
1850         
1851         // - 2nd part of initialisation : Nbr of clusters within TPC for the 3 daughter cascade tracks
1852         Int_t    lPosTPCClusters    = -1; // For ESD only ...//FIXME : wait for availability in AOD
1853         Int_t    lNegTPCClusters    = -1; // For ESD only ...
1854         Int_t    lBachTPCClusters   = -1; // For ESD only ...
1855         
1856         Double_t lInnerWallMomCascDghters[3] = {-100., -100., -100.};
1857         Double_t lTPCSignalCascDghters   [3] = {-100., -100., -100.};
1858         
1859         
1860         // - 3rd part of initialisation : about V0 part in cascades
1861         Double_t lInvMassLambdaAsCascDghter = 0.;
1862         Double_t lV0Chi2Xi         = -1. ;
1863         Double_t lDcaV0DaughtersXi = -1.;
1864                 
1865         Double_t lDcaBachToPrimVertexXi = -1., lDcaV0ToPrimVertexXi = -1.;
1866         Double_t lDcaPosToPrimVertexXi  = -1.;
1867         Double_t lDcaNegToPrimVertexXi  = -1.;
1868         Double_t lV0CosineOfPointingAngleXi = -1. ;
1869         Double_t lPosV0Xi[3] = { -1000. , -1000., -1000. }; // Position of VO coming from cascade
1870         Double_t lV0RadiusXi = -1000.0;
1871         Double_t lV0quality  = 0.;
1872
1873         
1874         // - 4th part of initialisation : Effective masses
1875         Double_t lInvMassXiMinus    = 0.;
1876         Double_t lInvMassXiPlus     = 0.;
1877         Double_t lInvMassOmegaMinus = 0.;
1878         Double_t lInvMassOmegaPlus  = 0.;
1879   
1880         // - 5th part of initialisation : PID treatment
1881         Bool_t   lIsPosInXiProton      = kFALSE;
1882         Bool_t   lIsPosInXiPion        = kFALSE;
1883         Bool_t   lIsPosInOmegaProton   = kFALSE;
1884         Bool_t   lIsPosInOmegaPion     = kFALSE;
1885                         
1886         Bool_t   lIsNegInXiProton      = kFALSE;
1887         Bool_t   lIsNegInXiPion        = kFALSE;
1888         Bool_t   lIsNegInOmegaProton   = kFALSE;
1889         Bool_t   lIsNegInOmegaPion     = kFALSE;
1890         
1891         Bool_t   lIsBachelorKaon       = kFALSE;
1892         Bool_t   lIsBachelorPion       = kFALSE; 
1893         
1894         Bool_t   lIsBachelorKaonForTPC = kFALSE; // For ESD only ...//FIXME : wait for availability in AOD
1895         Bool_t   lIsBachelorPionForTPC = kFALSE; // For ESD only ...
1896         Bool_t   lIsNegPionForTPC      = kFALSE; // For ESD only ...
1897         Bool_t   lIsPosPionForTPC      = kFALSE; // For ESD only ...
1898         Bool_t   lIsNegProtonForTPC    = kFALSE; // For ESD only ...
1899         Bool_t   lIsPosProtonForTPC    = kFALSE; // For ESD only ...
1900
1901         // - 6th part of initialisation : extra info for QA
1902         Double_t lXiMomX       = 0. , lXiMomY = 0., lXiMomZ = 0.;
1903         Double_t lXiTransvMom  = 0. ;
1904         Double_t lXiTotMom     = 0. ;
1905                 
1906         Double_t lBachMomX       = 0., lBachMomY  = 0., lBachMomZ   = 0.;
1907         Double_t lBachTransvMom  = 0.;
1908         Double_t lBachTotMom     = 0.;
1909         
1910         Short_t  lChargeXi = -2;
1911         Double_t lV0toXiCosineOfPointingAngle = 0. ;
1912         
1913         Double_t lRapXi   = -20.0, lRapOmega = -20.0,  lEta = -20.0, lTheta = 360., lPhi = 720. ;
1914         Double_t lAlphaXi = -200., lPtArmXi  = -200.0;
1915         
1916         // - 7th part of initialisation : variables for the AliCFContainer dedicated to cascade cut optmisiation
1917         Int_t    lSPDTrackletsMultiplicity = -1;
1918   
1919         // - 8th part of initialisation : variables needed for Angular correlations
1920         TVector3 lTVect3MomXi(0.,0.,0.);
1921         Int_t    lArrTrackID[3] = {-1, -1, -1};
1922
1923           
1924   if(fAnalysisType == "ESD"){ 
1925   
1926   // -------------------------------------
1927   // II.ESD - Calcultaion Part dedicated to Xi vertices (ESD)
1928   
1929         AliESDcascade *xi = lESDevent->GetCascade(iXi);
1930         if (!xi) continue;
1931         
1932         
1933                 // - II.Step 1 : around primary vertex
1934                 //-------------
1935         lTrkgPrimaryVtxRadius3D = TMath::Sqrt(  lTrkgPrimaryVtxPos[0] * lTrkgPrimaryVtxPos[0] +
1936                                                 lTrkgPrimaryVtxPos[1] * lTrkgPrimaryVtxPos[1] +
1937                                                 lTrkgPrimaryVtxPos[2] * lTrkgPrimaryVtxPos[2] );
1938
1939         lBestPrimaryVtxRadius3D = TMath::Sqrt(  lBestPrimaryVtxPos[0] * lBestPrimaryVtxPos[0] +
1940                                                 lBestPrimaryVtxPos[1] * lBestPrimaryVtxPos[1] +
1941                                                 lBestPrimaryVtxPos[2] * lBestPrimaryVtxPos[2] );
1942
1943
1944         
1945                 // - II.Step 2 : Assigning the necessary variables for specific AliESDcascade data members (ESD)        
1946                 //-------------
1947         lV0quality = 0.;
1948         xi->ChangeMassHypothesis(lV0quality , 3312); // default working hypothesis : cascade = Xi- decay
1949
1950         lEffMassXi                      = xi->GetEffMassXi();
1951         lChi2Xi                         = xi->GetChi2Xi();
1952         lDcaXiDaughters                 = xi->GetDcaXiDaughters();
1953         lXiCosineOfPointingAngle        = xi->GetCascadeCosineOfPointingAngle( lBestPrimaryVtxPos[0],
1954                                                                                lBestPrimaryVtxPos[1],
1955                                                                                lBestPrimaryVtxPos[2] );
1956                 // Take care : the best available vertex should be used (like in AliCascadeVertexer)
1957         
1958         xi->GetXYZcascade( lPosXi[0],  lPosXi[1], lPosXi[2] ); 
1959         lXiRadius2D    = TMath::Sqrt( lPosXi[0]*lPosXi[0]  +  lPosXi[1]*lPosXi[1] );
1960         lXiRadius3D    = TMath::Sqrt( lPosXi[0]*lPosXi[0]  +  lPosXi[1]*lPosXi[1] +  lPosXi[2]*lPosXi[2]);
1961                 
1962                 
1963
1964                 // - II.Step 3 : around the tracks : Bach + V0 (ESD)
1965                 // ~ Necessary variables for ESDcascade data members coming from the ESDv0 part (inheritance)
1966                 //-------------
1967                 
1968         UInt_t lIdxPosXi        = (UInt_t) TMath::Abs( xi->GetPindex() );
1969         UInt_t lIdxNegXi        = (UInt_t) TMath::Abs( xi->GetNindex() );
1970         UInt_t lBachIdx         = (UInt_t) TMath::Abs( xi->GetBindex() );
1971                 // Care track label can be negative in MC production (linked with the track quality)
1972                 // However = normally, not the case for track index ...
1973         
1974                 // FIXME : rejection of a double use of a daughter track (nothing but just a crosscheck of what is done in the cascade vertexer)
1975                 if(lBachIdx == lIdxNegXi) {
1976                         AliWarning("Pb / Idx(Bach. track) = Idx(Neg. track) ... continue!"); continue;
1977                 }
1978                 if(lBachIdx == lIdxPosXi) {
1979                         AliWarning("Pb / Idx(Bach. track) = Idx(Pos. track) ... continue!"); continue;
1980                 }
1981         
1982         AliESDtrack *pTrackXi           = lESDevent->GetTrack( lIdxPosXi );
1983         AliESDtrack *nTrackXi           = lESDevent->GetTrack( lIdxNegXi );
1984         AliESDtrack *bachTrackXi        = lESDevent->GetTrack( lBachIdx );
1985                 if (!pTrackXi || !nTrackXi || !bachTrackXi ) {
1986                         AliWarning("ERROR: Could not retrieve one of the 3 ESD daughter tracks of the cascade ...");
1987                         continue;
1988                 }
1989         
1990         
1991         lPosTPCClusters   = pTrackXi->GetTPCNcls();
1992         lNegTPCClusters   = nTrackXi->GetTPCNcls();
1993         lBachTPCClusters  = bachTrackXi->GetTPCNcls();
1994         
1995                 // FIXME : rejection of a poor quality tracks
1996         if(fkQualityCutTPCrefit){
1997                 // 1 - Poor quality related to TPCrefit
1998                 ULong_t pStatus    = pTrackXi->GetStatus();
1999                 ULong_t nStatus    = nTrackXi->GetStatus();
2000                 ULong_t bachStatus = bachTrackXi->GetStatus();
2001                 if ((pStatus&AliESDtrack::kTPCrefit)    == 0) { AliWarning("Pb / V0 Pos. track has no TPCrefit ... continue!"); continue; }
2002                 if ((nStatus&AliESDtrack::kTPCrefit)    == 0) { AliWarning("Pb / V0 Neg. track has no TPCrefit ... continue!"); continue; }
2003                 if ((bachStatus&AliESDtrack::kTPCrefit) == 0) { AliWarning("Pb / Bach.   track has no TPCrefit ... continue!"); continue; }
2004         }
2005         if(fkQualityCut80TPCcls){
2006                 // 2 - Poor quality related to TPC clusters
2007                 if(lPosTPCClusters  < 80) { AliWarning("Pb / V0 Pos. track has less than 80 TPC clusters ... continue!"); continue; }
2008                 if(lNegTPCClusters  < 80) { AliWarning("Pb / V0 Neg. track has less than 80 TPC clusters ... continue!"); continue; }
2009                 if(lBachTPCClusters < 80) { AliWarning("Pb / Bach.   track has less than 80 TPC clusters ... continue!"); continue; }
2010         }
2011         
2012         const AliExternalTrackParam *pExtTrack    = pTrackXi    ->GetInnerParam();
2013         const AliExternalTrackParam *nExtTrack    = nTrackXi    ->GetInnerParam();
2014         const AliExternalTrackParam *bachExtTrack = bachTrackXi ->GetInnerParam();
2015         
2016         if (pExtTrack) {
2017                 lInnerWallMomCascDghters[0] = pExtTrack ->GetP() * pExtTrack ->Charge();
2018                 lTPCSignalCascDghters   [0] = pTrackXi  ->GetTPCsignal();
2019         }
2020         if (nExtTrack) {
2021                 lInnerWallMomCascDghters[1] = nExtTrack ->GetP() * nExtTrack ->Charge();
2022                 lTPCSignalCascDghters   [1] = nTrackXi  ->GetTPCsignal();
2023         }
2024         if (bachExtTrack) {
2025                 lInnerWallMomCascDghters[2] = bachExtTrack ->GetP() * bachExtTrack ->Charge();
2026                 lTPCSignalCascDghters   [2] = bachTrackXi  ->GetTPCsignal();
2027         }
2028
2029
2030         lInvMassLambdaAsCascDghter      = xi->GetEffMass();
2031                 // This value shouldn't change, whatever the working hyp. is : Xi-, Xi+, Omega-, Omega+
2032         lDcaV0DaughtersXi               = xi->GetDcaV0Daughters(); 
2033         lV0Chi2Xi                       = xi->GetChi2V0();
2034         
2035         lV0CosineOfPointingAngleXi      = xi->GetV0CosineOfPointingAngle( lBestPrimaryVtxPos[0],
2036                                                                           lBestPrimaryVtxPos[1],
2037                                                                           lBestPrimaryVtxPos[2] );
2038
2039         lDcaV0ToPrimVertexXi            = xi->GetD( lBestPrimaryVtxPos[0], 
2040                                                     lBestPrimaryVtxPos[1], 
2041                                                     lBestPrimaryVtxPos[2] );
2042                 
2043         lDcaBachToPrimVertexXi = TMath::Abs( bachTrackXi->GetD( lBestPrimaryVtxPos[0], 
2044                                                                 lBestPrimaryVtxPos[1], 
2045                                                                 lMagneticField  ) ); 
2046                                         // Note : AliExternalTrackParam::GetD returns an algebraic value ...
2047                 
2048                 xi->GetXYZ( lPosV0Xi[0],  lPosV0Xi[1], lPosV0Xi[2] ); 
2049         lV0RadiusXi             = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0]  +  lPosV0Xi[1]*lPosV0Xi[1] );
2050         
2051         lDcaPosToPrimVertexXi   = TMath::Abs( pTrackXi  ->GetD( lBestPrimaryVtxPos[0], 
2052                                                                 lBestPrimaryVtxPos[1], 
2053                                                                 lMagneticField  )     ); 
2054         
2055         lDcaNegToPrimVertexXi   = TMath::Abs( nTrackXi  ->GetD( lBestPrimaryVtxPos[0], 
2056                                                                 lBestPrimaryVtxPos[1], 
2057                                                                 lMagneticField  )     ); 
2058                 
2059                 // - II.Step 3' : extra-selection for cascade candidates
2060                 // Towards optimisation of AA selection
2061         // FIXME
2062         if(fkExtraSelections){
2063                 // if(lChi2Xi > 2000) continue;
2064                 // if(lV0Chi2Xi > 2000) continue;
2065                 
2066                 if(lDcaXiDaughters > 0.05) continue; // > 0.1 by default
2067                 //if(lXiCosineOfPointingAngle < 0.999 ) continue;
2068                 if(lXiRadius2D < 1.0) continue;
2069                 if(lXiRadius2D > 100) continue;
2070                 if(TMath::Abs(lInvMassLambdaAsCascDghter-1.11568) > 0.008) continue;
2071                 if(lDcaV0DaughtersXi > 0.3) continue;
2072                 
2073                 if(lV0CosineOfPointingAngleXi > 0.9999) continue;
2074                 //if(lDcaV0ToPrimVertexXi < 0.09) continue;
2075                 if(lDcaBachToPrimVertexXi < 0.04) continue;
2076                 
2077                 if(lV0RadiusXi < 1.0) continue;
2078                 if(lV0RadiusXi > 100) continue;
2079                 //if(lDcaPosToPrimVertexXi < 0.6) continue;
2080                 //if(lDcaNegToPrimVertexXi < 0.6) continue;
2081         }
2082         
2083         
2084         
2085                 // - II.Step 4 : around effective masses (ESD)
2086                 // ~ change mass hypotheses to cover all the possibilities :  Xi-/+, Omega -/+
2087                 //-------------
2088
2089         
2090         if( bachTrackXi->Charge() < 0 ) {
2091                 lV0quality = 0.;
2092                 xi->ChangeMassHypothesis(lV0quality , 3312);    
2093                         // Calculate the effective mass of the Xi- candidate. 
2094                         // pdg code 3312 = Xi-
2095                 lInvMassXiMinus = xi->GetEffMassXi();
2096                 
2097                 lV0quality = 0.;
2098                 xi->ChangeMassHypothesis(lV0quality , 3334);    
2099                         // Calculate the effective mass of the Xi- candidate. 
2100                         // pdg code 3334 = Omega-
2101                 lInvMassOmegaMinus = xi->GetEffMassXi();
2102                                         
2103                 lV0quality = 0.;
2104                 xi->ChangeMassHypothesis(lV0quality , 3312);    // Back to default hyp.
2105         }// end if negative bachelor
2106         
2107         
2108         if( bachTrackXi->Charge() >  0 ){
2109                 lV0quality = 0.;
2110                 xi->ChangeMassHypothesis(lV0quality , -3312);   
2111                         // Calculate the effective mass of the Xi+ candidate. 
2112                         // pdg code -3312 = Xi+
2113                 lInvMassXiPlus = xi->GetEffMassXi();
2114                 
2115                 lV0quality = 0.;
2116                 xi->ChangeMassHypothesis(lV0quality , -3334);   
2117                         // Calculate the effective mass of the Xi+ candidate. 
2118                         // pdg code -3334  = Omega+
2119                 lInvMassOmegaPlus = xi->GetEffMassXi();
2120                 
2121                 lV0quality = 0.;
2122                 xi->ChangeMassHypothesis(lV0quality , -3312);   // Back to "default" hyp.
2123         }// end if positive bachelor
2124         
2125         
2126         
2127                 // - II.Step 5 : PID on the daughter tracks
2128                 //-------------
2129         
2130         // A - Combined PID
2131         // Reasonable guess for the priors for the cascade track sample (e-, mu, pi, K, p)
2132         Double_t lPriorsGuessXi[5]    = {0, 0, 2, 0, 1};
2133         Double_t lPriorsGuessOmega[5] = {0, 0, 1, 1, 1};
2134         
2135         // Combined VO-positive-daughter PID
2136         AliPID pPidXi;          pPidXi.SetPriors(    lPriorsGuessXi    );
2137         AliPID pPidOmega;       pPidOmega.SetPriors( lPriorsGuessOmega );
2138                 
2139         if( pTrackXi->IsOn(AliESDtrack::kESDpid) ){  // Combined PID exists
2140                 Double_t r[10] = {0.}; pTrackXi->GetESDpid(r);
2141                 pPidXi.SetProbabilities(r);
2142                 pPidOmega.SetProbabilities(r);
2143                 
2144                 // Check if the V0 positive track is a proton (case for Xi-)
2145                 Double_t pproton = pPidXi.GetProbability(AliPID::kProton);
2146                 if (pproton > pPidXi.GetProbability(AliPID::kElectron) &&
2147                     pproton > pPidXi.GetProbability(AliPID::kMuon)     &&
2148                     pproton > pPidXi.GetProbability(AliPID::kPion)     &&
2149                     pproton > pPidXi.GetProbability(AliPID::kKaon)     )     lIsPosInXiProton = kTRUE;
2150                 
2151                 // Check if the V0 positive track is a pi+ (case for Xi+)
2152                 Double_t ppion = pPidXi.GetProbability(AliPID::kPion);
2153                 if (ppion > pPidXi.GetProbability(AliPID::kElectron) &&
2154                     ppion > pPidXi.GetProbability(AliPID::kMuon)     &&
2155                     ppion > pPidXi.GetProbability(AliPID::kKaon)     &&
2156                     ppion > pPidXi.GetProbability(AliPID::kProton)   )     lIsPosInXiPion = kTRUE;
2157                 
2158                 
2159                 // Check if the V0 positive track is a proton (case for Omega-)
2160                 pproton = 0.;
2161                     pproton = pPidOmega.GetProbability(AliPID::kProton);
2162                 if (pproton > pPidOmega.GetProbability(AliPID::kElectron) &&
2163                     pproton > pPidOmega.GetProbability(AliPID::kMuon)     &&
2164                     pproton > pPidOmega.GetProbability(AliPID::kPion)     &&
2165                     pproton > pPidOmega.GetProbability(AliPID::kKaon)     )  lIsPosInOmegaProton = kTRUE;
2166                 
2167                 // Check if the V0 positive track is a pi+ (case for Omega+)
2168                 ppion = 0.;
2169                     ppion = pPidOmega.GetProbability(AliPID::kPion);
2170                 if (ppion > pPidOmega.GetProbability(AliPID::kElectron) &&
2171                     ppion > pPidOmega.GetProbability(AliPID::kMuon)     &&
2172                     ppion > pPidOmega.GetProbability(AliPID::kKaon)     &&
2173                     ppion > pPidOmega.GetProbability(AliPID::kProton)   )    lIsPosInOmegaPion = kTRUE;
2174                 
2175         }// end if V0 positive track with existing combined PID 
2176         
2177         
2178         // Combined VO-negative-daughter PID
2179         AliPID nPidXi;          nPidXi.SetPriors(    lPriorsGuessXi    );
2180         AliPID nPidOmega;       nPidOmega.SetPriors( lPriorsGuessOmega );
2181                 
2182         if( nTrackXi->IsOn(AliESDtrack::kESDpid) ){  // Combined PID exists
2183                 Double_t r[10] = {0.}; nTrackXi->GetESDpid(r);
2184                 nPidXi.SetProbabilities(r);
2185                 nPidOmega.SetProbabilities(r);
2186                 
2187                 // Check if the V0 negative track is a pi- (case for Xi-)
2188                 Double_t ppion = nPidXi.GetProbability(AliPID::kPion);
2189                 if (ppion > nPidXi.GetProbability(AliPID::kElectron) &&
2190                     ppion > nPidXi.GetProbability(AliPID::kMuon)     &&
2191                     ppion > nPidXi.GetProbability(AliPID::kKaon)     &&
2192                     ppion > nPidXi.GetProbability(AliPID::kProton)   )     lIsNegInXiPion = kTRUE;
2193
2194                 // Check if the V0 negative track is an anti-proton (case for Xi+)
2195                 Double_t pproton = nPidXi.GetProbability(AliPID::kProton);
2196                 if (pproton > nPidXi.GetProbability(AliPID::kElectron) &&
2197                     pproton > nPidXi.GetProbability(AliPID::kMuon)     &&
2198                     pproton > nPidXi.GetProbability(AliPID::kPion)     &&
2199                     pproton > nPidXi.GetProbability(AliPID::kKaon)     )     lIsNegInXiProton = kTRUE;
2200                 
2201                 // Check if the V0 negative track is a pi- (case for Omega-)
2202                 ppion = 0.;
2203                     ppion = nPidOmega.GetProbability(AliPID::kPion);
2204                 if (ppion > nPidOmega.GetProbability(AliPID::kElectron) &&
2205                     ppion > nPidOmega.GetProbability(AliPID::kMuon)     &&
2206                     ppion > nPidOmega.GetProbability(AliPID::kKaon)     &&
2207                     ppion > nPidOmega.GetProbability(AliPID::kProton)   )    lIsNegInOmegaPion = kTRUE;
2208                 
2209                 // Check if the V0 negative track is an anti-proton (case for Omega+)
2210                 pproton = 0.;
2211                          pproton = nPidOmega.GetProbability(AliPID::kProton);
2212                 if (pproton > nPidOmega.GetProbability(AliPID::kElectron) &&
2213                     pproton > nPidOmega.GetProbability(AliPID::kMuon)     &&
2214                     pproton > nPidOmega.GetProbability(AliPID::kPion)     &&
2215                     pproton > nPidOmega.GetProbability(AliPID::kKaon)     )  lIsNegInOmegaProton = kTRUE;
2216                 
2217         }// end if V0 negative track with existing combined PID 
2218         
2219                 
2220         // Combined bachelor PID
2221         AliPID bachPidXi;       bachPidXi.SetPriors(    lPriorsGuessXi    );
2222         AliPID bachPidOmega;    bachPidOmega.SetPriors( lPriorsGuessOmega );
2223         
2224         if( bachTrackXi->IsOn(AliESDtrack::kESDpid) ){  // Combined PID exists
2225                 Double_t r[10] = {0.}; bachTrackXi->GetESDpid(r);
2226                 bachPidXi.SetProbabilities(r);
2227                 bachPidOmega.SetProbabilities(r);
2228                 // Check if the bachelor track is a pion
2229                 Double_t ppion = bachPidXi.GetProbability(AliPID::kPion);
2230                 if (ppion > bachPidXi.GetProbability(AliPID::kElectron) &&
2231                     ppion > bachPidXi.GetProbability(AliPID::kMuon)     &&
2232                     ppion > bachPidXi.GetProbability(AliPID::kKaon)     &&
2233                     ppion > bachPidXi.GetProbability(AliPID::kProton)   )     lIsBachelorPion = kTRUE;
2234                 // Check if the bachelor track is a kaon
2235                 Double_t pkaon = bachPidOmega.GetProbability(AliPID::kKaon);
2236                 if (pkaon > bachPidOmega.GetProbability(AliPID::kElectron) &&
2237                     pkaon > bachPidOmega.GetProbability(AliPID::kMuon)     &&
2238                     pkaon > bachPidOmega.GetProbability(AliPID::kPion)     &&
2239                     pkaon > bachPidOmega.GetProbability(AliPID::kProton)   )  lIsBachelorKaon = kTRUE;  
2240         }// end if bachelor track with existing combined PID
2241         
2242         
2243         // B - TPC PID : 3-sigma bands on Bethe-Bloch curve
2244         
2245         // Bachelor
2246         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 4) lIsBachelorKaonForTPC = kTRUE;
2247         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 4) lIsBachelorPionForTPC = kTRUE;
2248         
2249         // Negative V0 daughter
2250         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kPion   )) < 4) lIsNegPionForTPC   = kTRUE;
2251         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kProton )) < 4) lIsNegProtonForTPC = kTRUE;
2252         
2253         // Positive V0 daughter
2254         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kPion   )) < 4) lIsPosPionForTPC   = kTRUE;
2255         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 4) lIsPosProtonForTPC = kTRUE;
2256         
2257         /*
2258         const AliExternalTrackParam *pInnerWallTrackXi    = pTrackXi    ->GetInnerParam();
2259         const AliExternalTrackParam *nInnerWallTrackXi    = nTrackXi    ->GetInnerParam();
2260         const AliExternalTrackParam *bachInnerWallTrackXi = bachTrackXi ->GetInnerParam();
2261         if(pInnerWallTrackXi && nInnerWallTrackXi && bachInnerWallTrackXi ){
2262                 
2263                 Double_t pMomInnerWall    = pInnerWallTrackXi   ->GetP();
2264                 Double_t nMomInnerWall    = nInnerWallTrackXi   ->GetP();
2265                 Double_t bachMomInnerWall = bachInnerWallTrackXi->GetP();
2266                 
2267                 // Bachelor
2268                 if (TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 3)                              lIsBachelorPionForTPC = kTRUE;
2269                 if (bachMomInnerWall < 0.350  && TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 5) lIsBachelorKaonForTPC = kTRUE;
2270                 if (bachMomInnerWall > 0.350  && TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 3) lIsBachelorKaonForTPC = kTRUE;
2271                 
2272                 // Negative V0 daughter
2273                 if (TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kPion   )) < 3  )                           lIsNegPionForTPC   = kTRUE;
2274                 if (nMomInnerWall < 0.6  && TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kProton ) ) < 5 )   lIsNegProtonForTPC = kTRUE;
2275                 if (nMomInnerWall > 0.6  && TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kProton ) ) < 3 )   lIsNegProtonForTPC = kTRUE;
2276                 
2277                 // Positive V0 daughter
2278                 if (TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kPion   )) < 3 )                            lIsPosPionForTPC   = kTRUE;
2279                 if (pMomInnerWall < 0.6  && TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 5)     lIsPosProtonForTPC = kTRUE;
2280                 if (pMomInnerWall > 0.6  && TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 3)     lIsPosProtonForTPC = kTRUE;
2281         }
2282         */
2283         
2284         
2285         
2286                 
2287                 // - II.Step 6 : extra info for QA (ESD)
2288                 // miscellaneous pieces of info that may help regarding data quality assessment.
2289                 //-------------
2290
2291         xi->GetPxPyPz( lXiMomX, lXiMomY, lXiMomZ );
2292                 lXiTransvMom    = TMath::Sqrt( lXiMomX*lXiMomX   + lXiMomY*lXiMomY );
2293                 lXiTotMom       = TMath::Sqrt( lXiMomX*lXiMomX   + lXiMomY*lXiMomY   + lXiMomZ*lXiMomZ );
2294                 
2295         xi->GetBPxPyPz(  lBachMomX,  lBachMomY,  lBachMomZ );
2296                 lBachTransvMom  = TMath::Sqrt( lBachMomX*lBachMomX   + lBachMomY*lBachMomY );
2297                 lBachTotMom     = TMath::Sqrt( lBachMomX*lBachMomX   + lBachMomY*lBachMomY  +  lBachMomZ*lBachMomZ  );
2298
2299         lChargeXi = xi->Charge();
2300
2301         lV0toXiCosineOfPointingAngle = xi->GetV0CosineOfPointingAngle( lPosXi[0], lPosXi[1], lPosXi[2] );
2302         
2303         lRapXi    = xi->RapXi();
2304         lRapOmega = xi->RapOmega();
2305         lEta      = xi->Eta();
2306         lTheta    = xi->Theta() *180.0/TMath::Pi();
2307         lPhi      = xi->Phi()   *180.0/TMath::Pi();
2308         lAlphaXi  = xi->AlphaXi();
2309         lPtArmXi  = xi->PtArmXi();
2310         
2311         
2312         //FIXME : Extra-cut = Anti-splitting cut for lambda daughters
2313         Bool_t kAntiSplittingLambda = kFALSE;
2314         
2315         if(kAntiSplittingLambda){
2316                 Double_t lNMomX = 0., lNMomY = 0., lNMomZ = 0.;
2317                 Double_t lPMomX = 0., lPMomY = 0., lPMomZ = 0.;
2318                 
2319                 xi->GetPPxPyPz(lPMomX, lPMomY, lPMomZ); 
2320                 xi->GetNPxPyPz(lNMomX, lNMomY, lNMomZ); 
2321                 
2322                 if( xi->Charge() < 0){// Xi- or Omega-
2323                         if(TMath::Abs(lBachTransvMom - TMath::Sqrt( lNMomX*lNMomX + lNMomY*lNMomY )  ) < 0.075) continue;
2324                 }
2325                 else {                //Xi+ or Omega+
2326                         if(TMath::Abs(lBachTransvMom - TMath::Sqrt( lPMomX*lPMomX + lPMomY*lPMomY ) ) < 0.075) continue;
2327                 }
2328         }
2329         
2330         //FIXME : Just to know which file is currently open : locate the file containing Xi
2331         // cout << "Name of the file containing Xi candidate(s) :" 
2332         //        << CurrentFileName() 
2333         //        << " / entry: "     << Entry()
2334         //        << " / in file: "   << lESDevent->GetEventNumberInFile()   // <- Cvetan / From Mihaela: AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->GetTree()->GetReadEntry();
2335         //        << " : mass(Xi) = " << xi->GetEffMassXi() 
2336         //        << " / charge = "   << lChargeXi
2337         //        << " / pt(Casc) = " << lXiTransvMom
2338         //        << " / Decay 2d R(Xi) = " << lXiRadius2D 
2339         //        << " / Track Index(Pos)  = " << lIdxPosXi << "/ Nb(TPC clusters) = " << lPosTPCClusters 
2340         //        << " / Track Index(Neg)  = " << lIdxNegXi << "/ Nb(TPC clusters) = " << lNegTPCClusters 
2341         //        << " / Track Index(Bach) = " << lBachIdx  << "/ Nb(TPC clusters) = " << lBachTPCClusters 
2342         //        << endl;
2343
2344         
2345                 // II.Step 7 - Complementary info for monitoring the cascade cut variables
2346         
2347         const AliMultiplicity *lAliMult = lESDevent->GetMultiplicity();
2348         lSPDTrackletsMultiplicity = lAliMult->GetNumberOfTracklets();
2349         
2350                 // II.Step 8 - Azimuthal correlation study
2351                 //-------------
2352         
2353         lTVect3MomXi.SetXYZ( lXiMomX, lXiMomY, lXiMomZ );
2354         lArrTrackID[0] = pTrackXi   ->GetID();
2355         lArrTrackID[1] = nTrackXi   ->GetID();
2356         lArrTrackID[2] = bachTrackXi->GetID();
2357         
2358         
2359   }// end of ESD treatment
2360   
2361  
2362   if(fAnalysisType == "AOD"){
2363         
2364         // -------------------------------------
2365         // II.AOD - Calcultaion Part dedicated to Xi vertices (ESD)
2366         
2367         const AliAODcascade *xi = lAODevent->GetCascade(iXi);
2368         if (!xi) continue;
2369                 
2370         // Just to know which file is currently open : locate the file containing Xi
2371         // cout << "Name of the file containing Xi candidate(s) :" <<  fesdH->GetTree()->GetCurrentFile()->GetName() << endl;
2372         
2373         
2374                 // - II.Step 1 : Characteristics of the event : prim. Vtx + magnetic field (AOD)
2375                 //-------------
2376         
2377
2378         lTrkgPrimaryVtxRadius3D = -500. ;
2379         // FIXME : We don't have the different prim. vertex at the AOD level -> nothing to do.
2380
2381         lBestPrimaryVtxRadius3D = TMath::Sqrt(  lBestPrimaryVtxPos[0] * lBestPrimaryVtxPos[0] +
2382                                                 lBestPrimaryVtxPos[1] * lBestPrimaryVtxPos[1] +
2383                                                 lBestPrimaryVtxPos[2] * lBestPrimaryVtxPos[2] );
2384                 
2385         
2386                 // - II.Step 2 : Assigning the necessary variables for specific AliAODcascade data members (AOD)        
2387                 //-------------
2388         
2389         lEffMassXi                      = xi->MassXi(); // default working hypothesis : cascade = Xi- decay
2390         lChi2Xi                         = xi->Chi2Xi();
2391         lDcaXiDaughters                 = xi->DcaXiDaughters();
2392         lXiCosineOfPointingAngle        = xi->CosPointingAngleXi( lBestPrimaryVtxPos[0], 
2393                                                                   lBestPrimaryVtxPos[1], 
2394                                                                   lBestPrimaryVtxPos[2] );
2395                                         // Take care : 
2396                                         // the best available vertex should be used (like in AliCascadeVertexer)
2397
2398                 lPosXi[0] = xi->DecayVertexXiX();
2399                 lPosXi[1] = xi->DecayVertexXiY();
2400                 lPosXi[2] = xi->DecayVertexXiZ();
2401         lXiRadius2D = TMath::Sqrt( lPosXi[0]*lPosXi[0]  +  lPosXi[1]*lPosXi[1] );
2402         lXiRadius3D = TMath::Sqrt( lPosXi[0]*lPosXi[0]  +  lPosXi[1]*lPosXi[1] +  lPosXi[2]*lPosXi[2] );
2403                 
2404
2405                 // - II.Step 3 : around the tracks : Bach + V0 (AOD)
2406                 // ~ Necessary variables for AODcascade data members coming from the AODv0 part (inheritance)
2407                 //-------------
2408                 
2409         lChargeXi                       = xi->ChargeXi();
2410         
2411         if( lChargeXi < 0)      
2412           lInvMassLambdaAsCascDghter    = xi->MassLambda();
2413         else                    
2414           lInvMassLambdaAsCascDghter    = xi->MassAntiLambda();
2415
2416         lDcaV0DaughtersXi               = xi->DcaV0Daughters(); 
2417         lV0Chi2Xi                       = xi->Chi2V0();
2418
2419         lV0CosineOfPointingAngleXi      = xi->CosPointingAngle( lBestPrimaryVtxPos );
2420         lDcaV0ToPrimVertexXi            = xi->DcaV0ToPrimVertex();
2421         
2422         lDcaBachToPrimVertexXi          = xi->DcaBachToPrimVertex(); 
2423         
2424         
2425                 lPosV0Xi[0] = xi->DecayVertexV0X();
2426                 lPosV0Xi[1] = xi->DecayVertexV0Y();
2427                 lPosV0Xi[2] = xi->DecayVertexV0Z(); 
2428         lV0RadiusXi     = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0]  +  lPosV0Xi[1]*lPosV0Xi[1] );
2429
2430         lDcaPosToPrimVertexXi           = xi->DcaPosToPrimVertex(); 
2431         lDcaNegToPrimVertexXi           = xi->DcaNegToPrimVertex(); 
2432
2433
2434                 // - II.Step 4 : around effective masses (AOD)
2435                 // ~ change mass hypotheses to cover all the possibilities :  Xi-/+, Omega -/+
2436                 //-------------
2437
2438         if( lChargeXi < 0 )             lInvMassXiMinus         = xi->MassXi();
2439         if( lChargeXi > 0 )             lInvMassXiPlus          = xi->MassXi();
2440         if( lChargeXi < 0 )             lInvMassOmegaMinus      = xi->MassOmega();
2441         if( lChargeXi > 0 )             lInvMassOmegaPlus       = xi->MassOmega();
2442
2443         
2444                 // - II.Step 5 : PID on the daughters (To be developed ...)
2445                 //-------------
2446         
2447         // Combined PID
2448         
2449         /* 
2450         // Reasonable guess for the priors for the cascade track sample
2451         Double_t lPriorsGuessXi[5]    = {0.0, 0.0, 2, 0, 1};
2452         Double_t lPriorsGuessOmega[5] = {0.0, 0.0, 1, 1, 1};
2453         AliPID bachPidXi;       bachPidXi.SetPriors(    lPriorsGuessXi    );
2454         AliPID bachPidOmega;    bachPidOmega.SetPriors( lPriorsGuessOmega );
2455         
2456         const AliAODTrack *bachTrackXi = lAODevent->GetTrack( xi->GetBachID() ); // FIXME : GetBachID not implemented ?
2457         
2458         if( bachTrackXi->IsOn(AliESDtrack::kESDpid) ){  // Combined PID exists, the AOD flags = a copy of the ESD ones
2459                 Double_t r[10]; bachTrackXi->GetPID(r);
2460                 bachPidXi.SetProbabilities(r);
2461                 bachPidOmega.SetProbabilities(r);
2462                 // Check if the bachelor track is a pion
2463                 Double_t ppion = bachPidXi.GetProbability(AliPID::kPion);
2464                 if (ppion > bachPidXi.GetProbability(AliPID::kElectron) &&
2465                     ppion > bachPidXi.GetProbability(AliPID::kMuon)     &&
2466                     ppion > bachPidXi.GetProbability(AliPID::kKaon)     &&
2467                     ppion > bachPidXi.GetProbability(AliPID::kProton)   )     lIsBachelorPion = kTRUE;
2468                 // Check if the bachelor track is a kaon
2469                 Double_t pkaon = bachPidOmega.GetProbability(AliPID::kKaon);
2470                 if (pkaon > bachPidOmega.GetProbability(AliPID::kElectron) &&
2471                     pkaon > bachPidOmega.GetProbability(AliPID::kMuon)     &&
2472                     pkaon > bachPidOmega.GetProbability(AliPID::kPion)     &&
2473                     pkaon > bachPidOmega.GetProbability(AliPID::kProton)   )  lIsBachelorKaon = kTRUE;
2474                 
2475         }// end if bachelor track with existing combined PID
2476         */
2477         
2478         // TPC PID
2479         
2480                 // - II.Step 6 : extra info for QA (AOD)
2481                 // miscellaneous pieces onf info that may help regarding data quality assessment.
2482                 //-------------
2483
2484                 lXiMomX = xi->MomXiX();
2485                 lXiMomY = xi->MomXiY();
2486                 lXiMomZ = xi->MomXiZ();
2487         lXiTransvMom    = TMath::Sqrt( lXiMomX*lXiMomX   + lXiMomY*lXiMomY );
2488         lXiTotMom       = TMath::Sqrt( lXiMomX*lXiMomX   + lXiMomY*lXiMomY   + lXiMomZ*lXiMomZ );
2489         
2490                 lBachMomX = xi->MomBachX();
2491                 lBachMomY = xi->MomBachY();
2492                 lBachMomZ = xi->MomBachZ();             
2493         lBachTransvMom  = TMath::Sqrt( lBachMomX*lBachMomX   + lBachMomY*lBachMomY );
2494         lBachTotMom     = TMath::Sqrt( lBachMomX*lBachMomX   + lBachMomY*lBachMomY  +  lBachMomZ*lBachMomZ  );
2495
2496         
2497         lV0toXiCosineOfPointingAngle = xi->CosPointingAngle( xi->GetDecayVertexXi() );
2498         
2499         lRapXi    = xi->RapXi();
2500         lRapOmega = xi->RapOmega();
2501         lEta      = xi->Eta();                          // Will not work ! need a method Pz(), Py() Px() 
2502         lTheta    = xi->Theta() *180.0/TMath::Pi();     // in AODcascade.
2503         lPhi      = xi->Phi()   *180.0/TMath::Pi();     // Here, we will get eta, theta, phi for the V0 ...
2504         lAlphaXi  = xi->AlphaXi();
2505         lPtArmXi  = xi->PtArmXi();
2506
2507                 // II.Step 7 - Complementary info for monitoring the cascade cut variables
2508         //FIXME : missing for AOD : Tacklet Multiplicity + TPCCluster
2509         
2510                 // II.Step 8 - Azimuthal correlation study
2511                 //-------------
2512         
2513         lTVect3MomXi.SetXYZ( lXiMomX, lXiMomY, lXiMomZ );
2514         
2515         AliAODTrack *pTrackXi    = dynamic_cast<AliAODTrack*>( xi->GetDaughter(0) );
2516         AliAODTrack *nTrackXi    = dynamic_cast<AliAODTrack*>( xi->GetDaughter(1) );
2517         AliAODTrack *bachTrackXi = dynamic_cast<AliAODTrack*>( xi->GetDecayVertexXi()->GetDaughter(0) );        
2518                 if (!pTrackXi || !nTrackXi || !bachTrackXi ) {
2519                         AliWarning("ERROR: Could not retrieve one of the 3 AOD daughter tracks of the cascade ...");
2520                         continue;
2521                 }
2522                 
2523         lArrTrackID[0] = pTrackXi   ->GetID();
2524         lArrTrackID[1] = nTrackXi   ->GetID();
2525         lArrTrackID[2] = bachTrackXi->GetID();
2526         
2527   }// end of AOD treatment
2528
2529
2530     // -------------------------------------
2531     // II.Fill - Filling the TH1,2,3Fs, HnSparses, CFContainers, FOR events with CASCADES !
2532         
2533         // if( lIsBachelorKaonForTPC )
2534         //                 // FIXME : Just to know which file is currently open : locate the file containing Xi
2535         // cout << "Name of the file containing Omega candidate(s) :" 
2536         //         << CurrentFileName() 
2537         //         << " / entry: "     << Entry()
2538         //         << " / in file: "   << lESDevent->GetEventNumberInFile()   // <- Cvetan / From Mihaela: AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->GetTree()->GetReadEntry();
2539         //         << " : mass(Omega+) = " << lInvMassOmegaPlus 
2540         //         << " : mass(Omega-) = " << lInvMassOmegaMinus
2541         //         << " / charge = "   << lChargeXi
2542         //         << " / pt(Casc) = " << lXiTransvMom
2543         //         << " / Decay 2d R(Xi) = " << lXiRadius2D 
2544         //         << endl;
2545   
2546
2547         // - II.Fill.Step 1      : primary vertex
2548   
2549         fHistTPCrefitTrackMultiplicityForCascadeEvt->Fill( nTrackWithTPCrefitMultiplicity );
2550         fHistPrimaryTrackMultiplicityForCascadeEvt ->Fill( nTrackPrimaryMultiplicity );
2551         
2552         fHistPosV0TPCClusters           ->Fill( lPosTPCClusters  );
2553         fHistNegV0TPCClusters           ->Fill( lNegTPCClusters  );
2554         fHistBachTPCClusters            ->Fill( lBachTPCClusters );
2555         
2556         f2dHistTPCdEdxOfCascDghters     ->Fill( lInnerWallMomCascDghters[0] , lTPCSignalCascDghters[0]  );
2557         f2dHistTPCdEdxOfCascDghters     ->Fill( lInnerWallMomCascDghters[1] , lTPCSignalCascDghters[1]  );
2558         f2dHistTPCdEdxOfCascDghters     ->Fill( lInnerWallMomCascDghters[2] , lTPCSignalCascDghters[2]  );
2559         
2560         fHistVtxStatus                  ->Fill( lStatusTrackingPrimVtx   );  // 1 if tracking vtx = ok
2561
2562         if( lStatusTrackingPrimVtx ){
2563                 fHistPosTrkgPrimaryVtxXForCascadeEvt  ->Fill( lTrkgPrimaryVtxPos[0]    );
2564                 fHistPosTrkgPrimaryVtxYForCascadeEvt  ->Fill( lTrkgPrimaryVtxPos[1]    );
2565                 fHistPosTrkgPrimaryVtxZForCascadeEvt  ->Fill( lTrkgPrimaryVtxPos[2]    );
2566                 fHistTrkgPrimaryVtxRadius             ->Fill( lTrkgPrimaryVtxRadius3D );
2567         }
2568
2569         fHistPosBestPrimaryVtxXForCascadeEvt   ->Fill( lBestPrimaryVtxPos[0]    );
2570         fHistPosBestPrimaryVtxYForCascadeEvt   ->Fill( lBestPrimaryVtxPos[1]    );
2571         fHistPosBestPrimaryVtxZForCascadeEvt   ->Fill( lBestPrimaryVtxPos[2]    );
2572         fHistBestPrimaryVtxRadius              ->Fill( lBestPrimaryVtxRadius3D  );
2573         
2574         f2dHistTrkgPrimVtxVsBestPrimVtx->Fill( lTrkgPrimaryVtxRadius3D, lBestPrimaryVtxRadius3D );
2575
2576         // **************************** With PID on ? ... for the signal region ? ************FIXME**************************************
2577         if( ( (lChargeXi<0) && lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) ||
2578             ( (lChargeXi>0) && lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC )  )
2579                 // NOTE : 
2580                 // with this PID condition, it could happen that a cascade candidate satisfies the wrong requirement,
2581                 // e.g. one looks at a Xi- candidate for which lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC = kFALSE
2582                 //      Expectation: it should be excluded.
2583                 //      but lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC = kTRUE
2584                 //      then this bad Xi-candidate will contribute anyway (OR condition).
2585                 // Hence : the extra condition on the sign of the Cascade
2586         {
2587                 //         if( TMath::Abs( lInvMassXiMinus-1.3217 ) < 0.010 || TMath::Abs( lInvMassXiPlus-1.3217 ) < 0.010){}  }
2588                         
2589                 // II.Fill.Step 2
2590                 fHistEffMassXi                  ->Fill( lEffMassXi               );
2591                 fHistChi2Xi                     ->Fill( lChi2Xi                  );     // Flag CascadeVtxer: Cut Variable a
2592                 fHistDcaXiDaughters             ->Fill( lDcaXiDaughters          );     // Flag CascadeVtxer: Cut Variable e 
2593                 fHistDcaBachToPrimVertex        ->Fill( lDcaBachToPrimVertexXi   );     // Flag CascadeVtxer: Cut Variable d
2594                 fHistXiCosineOfPointingAngle    ->Fill( lXiCosineOfPointingAngle );     // Flag CascadeVtxer: Cut Variable f
2595                 fHistXiRadius                   ->Fill( lXiRadius2D                );   // Flag CascadeVtxer: Cut Variable g+h
2596                 
2597                 
2598                 // II.Fill.Step 3
2599                 fHistMassLambdaAsCascDghter     ->Fill( lInvMassLambdaAsCascDghter );   // Flag CascadeVtxer: Cut Variable c
2600                 fHistV0Chi2Xi                   ->Fill( lV0Chi2Xi                  );   
2601                 fHistDcaV0DaughtersXi           ->Fill( lDcaV0DaughtersXi          );
2602                 fHistV0CosineOfPointingAngleXi  ->Fill( lV0CosineOfPointingAngleXi ); 
2603                 fHistV0RadiusXi                 ->Fill( lV0RadiusXi                );
2604                 
2605                 fHistDcaV0ToPrimVertexXi        ->Fill( lDcaV0ToPrimVertexXi       );   // Flag CascadeVtxer: Cut Variable b
2606                 fHistDcaPosToPrimVertexXi       ->Fill( lDcaPosToPrimVertexXi      );
2607                 fHistDcaNegToPrimVertexXi       ->Fill( lDcaNegToPrimVertexXi      );
2608                 
2609         
2610                 // II.Fill.Step 4 : extra QA info
2611                 
2612                 fHistChargeXi                   ->Fill( lChargeXi      );
2613                 fHistV0toXiCosineOfPointingAngle->Fill( lV0toXiCosineOfPointingAngle );
2614         
2615                 if( TMath::Abs( lInvMassXiMinus-1.3217 ) < 0.010 || TMath::Abs( lInvMassXiPlus-1.3217 ) < 0.010){// One InvMass should be different from 0
2616                         fHistXiTransvMom        ->Fill( lXiTransvMom   );
2617                         fHistXiTotMom           ->Fill( lXiTotMom      );
2618         
2619                         fHistBachTransvMomXi    ->Fill( lBachTransvMom );
2620                         fHistBachTotMomXi       ->Fill( lBachTotMom    );
2621         
2622                         fHistRapXi              ->Fill( lRapXi         );
2623                         fHistEtaXi              ->Fill( lEta           );
2624                         fHistThetaXi            ->Fill( lTheta         );
2625                         fHistPhiXi              ->Fill( lPhi           );
2626
2627                 }
2628                 
2629                 if( (lChargeXi < 0) && (TMath::Abs( lInvMassXiMinus-1.3217 ) < 0.010) )         fHistcTauXiMinus     ->Fill( lXiRadius3D * 1.3271/lXiTotMom );
2630                 if( (lChargeXi > 0) && (TMath::Abs( lInvMassXiPlus -1.3217 ) < 0.010) )         fHistcTauXiPlus      ->Fill( lXiRadius3D * 1.3271/lXiTotMom );
2631
2632                 if( TMath::Abs( lInvMassOmegaMinus-1.672 ) < 0.010 || TMath::Abs( lInvMassOmegaPlus-1.672 ) < 0.010 ){// One InvMass should be different from 0
2633                         fHistRapOmega           ->Fill( lRapOmega            ); 
2634
2635                 }
2636                 
2637                 if( (lChargeXi < 0) && (TMath::Abs( lInvMassOmegaMinus-1.672 ) < 0.010) )        fHistcTauOmegaMinus ->Fill( lXiRadius3D * 1.67245/lXiTotMom );
2638                 if( (lChargeXi > 0) && (TMath::Abs( lInvMassOmegaPlus- 1.672 ) < 0.010) )        fHistcTauOmegaPlus  ->Fill( lXiRadius3D * 1.67245/lXiTotMom );
2639         
2640                 f2dHistArmenteros               ->Fill( lChargeXi*lAlphaXi, lPtArmXi   );
2641         }// end with PID ...
2642         
2643         // II.Fill.Step 5 : inv mass plots 1D
2644         if( lChargeXi < 0 ){
2645                                         fHistMassXiMinus               ->Fill( lInvMassXiMinus    );
2646                                         fHistMassOmegaMinus            ->Fill( lInvMassOmegaMinus );
2647                 if(lIsBachelorPion)     fHistMassWithCombPIDXiMinus    ->Fill( lInvMassXiMinus    );
2648                 if(lIsBachelorKaon)     fHistMassWithCombPIDOmegaMinus ->Fill( lInvMassOmegaMinus );
2649         }
2650         
2651         if( lChargeXi > 0 ){
2652                                         fHistMassXiPlus                ->Fill( lInvMassXiPlus     );
2653                                         fHistMassOmegaPlus             ->Fill( lInvMassOmegaPlus  );
2654                 if(lIsBachelorPion)     fHistMassWithCombPIDXiPlus     ->Fill( lInvMassXiPlus     );
2655                 if(lIsBachelorKaon)     fHistMassWithCombPIDOmegaPlus  ->Fill( lInvMassOmegaPlus  );
2656         }
2657         
2658         
2659         // II.Fill.Step 6 : inv mass plots 2D, 3D
2660         if( lChargeXi < 0 ) {
2661                 f2dHistEffMassLambdaVsEffMassXiMinus->Fill( lInvMassLambdaAsCascDghter, lInvMassXiMinus ); 
2662                 f2dHistEffMassXiVsEffMassOmegaMinus ->Fill( lInvMassXiMinus, lInvMassOmegaMinus );
2663                 f2dHistXiRadiusVsEffMassXiMinus     ->Fill( lXiRadius2D, lInvMassXiMinus );
2664                 f2dHistXiRadiusVsEffMassOmegaMinus  ->Fill( lXiRadius2D, lInvMassOmegaMinus );
2665                 f3dHistXiPtVsEffMassVsYXiMinus      ->Fill( lXiTransvMom, lInvMassXiMinus,    lRapXi    );
2666                 f3dHistXiPtVsEffMassVsYOmegaMinus   ->Fill( lXiTransvMom, lInvMassOmegaMinus, lRapOmega );
2667         }
2668         else{
2669                 f2dHistEffMassLambdaVsEffMassXiPlus ->Fill( lInvMassLambdaAsCascDghter, lInvMassXiPlus );
2670                 f2dHistEffMassXiVsEffMassOmegaPlus  ->Fill( lInvMassXiPlus, lInvMassOmegaPlus );
2671                 f2dHistXiRadiusVsEffMassXiPlus      ->Fill( lXiRadius2D, lInvMassXiPlus);
2672                 f2dHistXiRadiusVsEffMassOmegaPlus   ->Fill( lXiRadius2D, lInvMassOmegaPlus );
2673                 f3dHistXiPtVsEffMassVsYXiPlus       ->Fill( lXiTransvMom, lInvMassXiPlus,    lRapXi    );
2674                 f3dHistXiPtVsEffMassVsYOmegaPlus    ->Fill( lXiTransvMom, lInvMassOmegaPlus, lRapOmega );
2675         }
2676         
2677         // - Filling the AliCFContainers related to PID
2678         
2679         Double_t lContainerPIDVars[4] = {0.0};
2680         
2681         // Xi Minus             
2682         if( lChargeXi < 0 ) {
2683                 lContainerPIDVars[0] = lXiTransvMom       ;
2684                 lContainerPIDVars[1] = lInvMassXiMinus    ;
2685                 lContainerPIDVars[2] = lRapXi             ;
2686                 lContainerPIDVars[3] = nTrackPrimaryMultiplicity;       // FIXME : nTrackPrimaryMultiplicity not set for AOD ... = -1
2687                         
2688                 // No PID
2689                         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 0); // No PID
2690                 // TPC PID
2691                 if( lIsBachelorPionForTPC  )
2692                         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
2693                 
2694                 if( lIsBachelorPionForTPC && 
2695                     lIsPosProtonForTPC     )
2696                         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
2697                 
2698                 if( lIsBachelorPionForTPC && 
2699                     lIsPosProtonForTPC    && 
2700                     lIsNegPionForTPC       )
2701                         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
2702                 
2703                 // Combined PID
2704                 if( lIsBachelorPion        )
2705                         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
2706                 
2707                 if( lIsBachelorPion       && 
2708                     lIsPosInXiProton    )
2709                         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
2710                 
2711                 if(lIsBachelorPion     && 
2712                    lIsPosInXiProton && 
2713                    lIsNegInXiPion    )
2714                         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
2715         }
2716         
2717         lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.; lContainerPIDVars[3] = 0.;
2718         
2719         // Xi Plus              
2720         if( lChargeXi > 0 ) {
2721                 lContainerPIDVars[0] = lXiTransvMom       ;
2722                 lContainerPIDVars[1] = lInvMassXiPlus     ;
2723                 lContainerPIDVars[2] = lRapXi             ;
2724                 lContainerPIDVars[3] = nTrackPrimaryMultiplicity;       // FIXME : nTrackPrimaryMultiplicity not set for AOD ... = -1
2725                         
2726                 // No PID
2727                         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 0); // No PID
2728                 // TPC PID
2729                 if( lIsBachelorPionForTPC  )
2730                         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
2731                 
2732                 if( lIsBachelorPionForTPC && 
2733                     lIsNegProtonForTPC     )
2734                         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
2735                 
2736                 if( lIsBachelorPionForTPC && 
2737                     lIsNegProtonForTPC    && 
2738                     lIsPosPionForTPC       )
2739                         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
2740                 
2741                 // Combined PID
2742                 if( lIsBachelorPion        )
2743                         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
2744                 
2745                 if( lIsBachelorPion       && 
2746                     lIsNegInXiProton    )
2747                         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
2748                 
2749                 if(lIsBachelorPion     && 
2750                    lIsNegInXiProton && 
2751                    lIsPosInXiPion    )
2752                         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
2753         }
2754         
2755         lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.; lContainerPIDVars[3] = 0.;
2756         
2757         // Omega Minus          
2758         if( lChargeXi < 0 ) {
2759                 lContainerPIDVars[0] = lXiTransvMom       ;
2760                 lContainerPIDVars[1] = lInvMassOmegaMinus ;
2761                 lContainerPIDVars[2] = lRapOmega          ;
2762                 lContainerPIDVars[3] = nTrackPrimaryMultiplicity;       // FIXME : nTrackPrimaryMultiplicity not set for AOD ... = -1
2763                         
2764                 // No PID
2765                         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 0); // No PID
2766                 // TPC PID
2767                 if( lIsBachelorKaonForTPC  )
2768                         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
2769                 
2770                 if( lIsBachelorKaonForTPC && 
2771                     lIsPosProtonForTPC     )
2772                         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
2773                 
2774                 if( lIsBachelorKaonForTPC && 
2775                     lIsPosProtonForTPC    && 
2776                     lIsNegPionForTPC       )
2777                         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
2778                 
2779                 // Combined PID
2780                 if( lIsBachelorKaon        )
2781                         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
2782                 
2783                 if( lIsBachelorKaon       && 
2784                     lIsPosInOmegaProton    )
2785                         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
2786                 
2787                 if(lIsBachelorKaon     && 
2788                    lIsPosInOmegaProton && 
2789                    lIsNegInOmegaPion    )
2790                         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
2791         }
2792         
2793         lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.; lContainerPIDVars[3] = 0.;
2794         
2795         // Omega Plus           
2796         if( lChargeXi > 0 ) {
2797                 lContainerPIDVars[0] = lXiTransvMom       ;
2798                 lContainerPIDVars[1] = lInvMassOmegaPlus ;
2799                 lContainerPIDVars[2] = lRapOmega          ;
2800                 lContainerPIDVars[3] = nTrackPrimaryMultiplicity;       // FIXME : nTrackPrimaryMultiplicity not set for AOD ... = -1
2801                         
2802                 // No PID
2803                         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 0); // No PID
2804                 // TPC PID
2805                 if( lIsBachelorKaonForTPC  )
2806                         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
2807                 
2808                 if( lIsBachelorKaonForTPC && 
2809                     lIsNegProtonForTPC     )
2810                         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
2811                 
2812                 if( lIsBachelorKaonForTPC && 
2813                     lIsNegProtonForTPC    && 
2814                     lIsPosPionForTPC       )
2815                         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
2816                 
2817                 // Combined PID
2818                 if( lIsBachelorKaon        )
2819                         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
2820                 
2821                 if( lIsBachelorKaon       && 
2822                     lIsNegInOmegaProton    )
2823                         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
2824                 
2825                 if(lIsBachelorKaon     && 
2826                    lIsNegInOmegaProton && 
2827                    lIsPosInOmegaPion    )
2828                         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
2829         }
2830         
2831                 
2832         // II.Fill.Step 7 : filling the AliCFContainer (optimisation of topological selections)
2833         Double_t lContainerCutVars[20] = {0.0};
2834                         
2835         lContainerCutVars[0]  = lDcaXiDaughters;
2836         lContainerCutVars[1]  = lDcaBachToPrimVertexXi;
2837         lContainerCutVars[2]  = lXiCosineOfPointingAngle;
2838         lContainerCutVars[3]  = lXiRadius2D;
2839         lContainerCutVars[4]  = lInvMassLambdaAsCascDghter;
2840         lContainerCutVars[5]  = lDcaV0DaughtersXi;
2841         lContainerCutVars[6]  = lV0CosineOfPointingAngleXi;
2842         lContainerCutVars[7]  = lV0RadiusXi;
2843         lContainerCutVars[8]  = lDcaV0ToPrimVertexXi;   
2844         lContainerCutVars[9]  = lDcaPosToPrimVertexXi;
2845         lContainerCutVars[10] = lDcaNegToPrimVertexXi;
2846         
2847         lContainerCutVars[13] = lXiTransvMom;
2848         
2849         lContainerCutVars[16] = lBestPrimaryVtxPos[2];
2850         lContainerCutVars[17] = nTrackPrimaryMultiplicity;       // FIXME : nTrackPrimaryMultiplicity not checked for AOD ... = 0
2851         lContainerCutVars[18] = lSPDTrackletsMultiplicity;       // FIXME : SPDTrackletsMultiplicity is not available for AOD ... = -1
2852         lContainerCutVars[19] = lBachTPCClusters;                // FIXME : BachTPCClusters          is not available for AOD ... = -1
2853         
2854         if( lChargeXi < 0 ) {
2855                 lContainerCutVars[11] = lInvMassXiMinus;
2856                 lContainerCutVars[12] = 1.63;
2857                 lContainerCutVars[14] = lRapXi;
2858                 lContainerCutVars[15] = -1.;
2859                         if( lIsBachelorPionForTPC   && lIsPosProtonForTPC    && lIsNegPionForTPC )       fCFContCascadeCuts->Fill(lContainerCutVars,0); // for Xi-
2860
2861                 lContainerCutVars[11] = 1.26;
2862                 lContainerCutVars[12] = lInvMassOmegaMinus;
2863                 lContainerCutVars[14] = -1.;
2864                 lContainerCutVars[15] = lRapOmega;
2865                         if( lIsBachelorKaonForTPC   && lIsPosProtonForTPC    && lIsNegPionForTPC )       fCFContCascadeCuts->Fill(lContainerCutVars,2); // for Omega-
2866         }
2867         else{
2868                 lContainerCutVars[11] = lInvMassXiPlus;
2869                 lContainerCutVars[12] = 1.63;
2870                 lContainerCutVars[14] = lRapXi;
2871                 lContainerCutVars[15] = -1.; 
2872                         if( lIsBachelorPionForTPC   && lIsNegProtonForTPC    && lIsPosPionForTPC )       fCFContCascadeCuts->Fill(lContainerCutVars,1); // for Xi+
2873
2874                 lContainerCutVars[11] = 1.26;
2875                 lContainerCutVars[12] = lInvMassOmegaPlus;
2876                 lContainerCutVars[14] = -1.;
2877                 lContainerCutVars[15] = lRapOmega;
2878                         if( lIsBachelorKaonForTPC   && lIsNegProtonForTPC    && lIsPosPionForTPC )       fCFContCascadeCuts->Fill(lContainerCutVars,3); // for Omega+
2879         }
2880
2881                         
2882         // II.Fill.Step 8 :  angular correlations
2883         
2884         if( lChargeXi < 0 ){
2885                 if( lIsBachelorPionForTPC   && lIsPosProtonForTPC    && lIsNegPionForTPC )      DoAngularCorrelation("Xi-",    lInvMassXiMinus,    lArrTrackID, lTVect3MomXi, lEta, lRapXi);
2886                 if( lIsBachelorKaonForTPC   && lIsPosProtonForTPC    && lIsNegPionForTPC )      DoAngularCorrelation("Omega-", lInvMassOmegaMinus, lArrTrackID, lTVect3MomXi, lEta, lRapOmega);
2887         }
2888         else{
2889                 if( lIsBachelorPionForTPC   && lIsNegProtonForTPC    && lIsPosPionForTPC )      DoAngularCorrelation("Xi+",    lInvMassXiPlus,    lArrTrackID, lTVect3MomXi, lEta, lRapXi);
2890                 if( lIsBachelorKaonForTPC   && lIsNegProtonForTPC    && lIsPosPionForTPC )      DoAngularCorrelation("Omega+", lInvMassOmegaPlus, lArrTrackID, lTVect3MomXi, lEta, lRapOmega);
2891         }
2892         
2893         
2894     }// end of the Cascade loop (ESD or AOD)
2895     
2896   
2897   // Post output data.
2898  PostData(1, fListHistCascade);
2899 }
2900
2901
2902 void AliAnalysisTaskCheckCascade::DoAngularCorrelation( const Char_t   *lCascType, 
2903                                                               Double_t  lInvMassCascade, 
2904                                                         const Int_t    *lArrTrackID,
2905                                                               TVector3 &lTVect3MomXi, 
2906                                                               Double_t  lEtaXi,
2907                                                               Double_t  lRapCascade){
2908   // Perform the Delta(Phi)Delta(Eta) analysis 
2909   // by properly filling the THnSparseF 
2910
2911         if( fAnalysisType == "AOD") return; // FIXME : AOD development lost, because of AliESDtrack needed by AliESDtrackCuts
2912
2913         TString lStrCascType( lCascType );
2914
2915         // Check the Xi- candidate is within the proper mass window m0 +- 10 MeV
2916         Double_t lCascPdgMass = 0.0;
2917         if( lStrCascType.Contains("Xi") )       lCascPdgMass = 1.3217;
2918         if( lStrCascType.Contains("Omega") )    lCascPdgMass = 1.6724;
2919
2920         if( lInvMassCascade > lCascPdgMass + 0.010) return;
2921         if( lInvMassCascade < lCascPdgMass - 0.010) return;
2922
2923         // Check the Xi- candidate is within the proper rapidity window (flat efficiency)
2924         if( lRapCascade >  0.5 ) return;
2925         if( lRapCascade < -0.5 ) return;
2926
2927
2928         // 3 options to follow for the correlations:
2929         // 1.1 - "TrigAnyCasc-AssoAnyPrim"
2930         // 1.2 - "TrigCascLeading-AssoAnyPrim"
2931         // 2.  - "TrigLeadingTrck-AssoCasc"
2932
2933         if(fAngularCorrelationType.Contains("AssoAnyPrim") ){
2934         //----------------------- Option 1 ---------------------------------------------------------------------------------------------------
2935         // Cascade    = trigger, 
2936         // Associated = all the primary tracks in the event.
2937         //     1.1 Cascade = trigger above a certain pt but nothing more complicated than that
2938         //     1.2 Cascade = leading particle (à la heavy-ion -> test for coalescence)
2939
2940                 Bool_t kRejectLowPtCascades = kTRUE;
2941                 if(kRejectLowPtCascades && (lTVect3MomXi.Pt() < 1.7) ) return;
2942                 // Do not even consider the cascade of low pt for the correlation ...
2943
2944                 if(fAngularCorrelationType == "TrigCascLeading-AssoAnyPrim"){// Require the Cascade To be the Leading Part. in the event
2945
2946                         // 1st loop: check there is no primary track with a higher pt ...
2947                         // = The cascade is meant to be a leading particle : Pt(Casc) > any primary track in the event
2948                         for(Int_t TrckIdx = 0; TrckIdx < (InputEvent())->GetNumberOfTracks() ; TrckIdx++ )
2949                         {// Loop over all the tracks of the event
2950
2951                                 AliESDtrack *lCurrentTrck = dynamic_cast<AliESDtrack*>( (InputEvent())->GetTrack( TrckIdx ) );
2952                                         if (!lCurrentTrck ) {
2953                                                 AliWarning("ERROR Correl. Study : Could not retrieve a track while looping over the event tracks ...");
2954                                                 continue;
2955                                         }
2956
2957                                 if( !fESDtrackCuts->AcceptTrack(lCurrentTrck) ) continue;
2958                                 // Just consider primary tracks (= reject track that are not primary ones)
2959                                 if(lTVect3MomXi.Pt() < lCurrentTrck->Pt() ) return;     
2960                                 // Room for improvement: //FIXME
2961                                 // 1. There is a given resolution on pt : maybe release the cut Pt(casc) < Pt(track)*90% ?
2962                                 // 2. Apply this cut only when DeltaPhi(casc, track) > 90 deg = when track is in the near-side ?
2963                                 // 3. Anti-splitting cut (like in Femto analysis) ? = now done via ESDtrackCuts ...
2964
2965                         }// end control loop
2966                 }// end of prelim. check : Cascade = leading part in the event
2967
2968                 // 2nd loop: filling loop
2969                 for(Int_t TrckIdx = 0; TrckIdx < (InputEvent())->GetNumberOfTracks() ; TrckIdx++ )
2970                 {// Loop over all the tracks of the event
2971
2972                         AliESDtrack *lCurrentTrck = dynamic_cast<AliESDtrack*>( (InputEvent())->GetTrack( TrckIdx ) );
2973                                 if (!lCurrentTrck ) {
2974                                         AliWarning("ERROR Correl. Study : Could not retrieve a track while looping over the event tracks ...");
2975                                         continue;
2976                                 }
2977                         // Just consider primary tracks (= reject track that are not primary ones)
2978                         if( !fESDtrackCuts->AcceptTrack(lCurrentTrck) ) continue;
2979
2980                         // Room for improvement: //FIXME
2981                         // 1.   
2982                         // 2. Exclude the tracks that build the condisdered cascade = the bachelor + the V0 dghters
2983                         //     This may bias the outcome, especially for low multplicity events.
2984                         // Note : For ESD event, track ID == track index.
2985                                 if(lCurrentTrck->GetID() == lArrTrackID[0]) continue;
2986                                 if(lCurrentTrck->GetID() == lArrTrackID[1]) continue;
2987                                 if(lCurrentTrck->GetID() == lArrTrackID[2]) continue;
2988
2989                         TVector3 lTVect3MomTrck(lCurrentTrck->Px(), lCurrentTrck->Py(), lCurrentTrck->Pz() );
2990
2991                         // 2 hypotheses made here :
2992                         //   - The Xi trajectory is a straight line,
2993                         //   - The Xi doesn't loose any energy by crossing the first layer(s) of ITS, if ever;
2994                         //      So, meaning hyp: vect p(Xi) at the emission = vect p(Xi) at the decay vertex
2995                         //      By doing this, we introduce a systematic error on the cascade Phi ...
2996                         // Room for improvement: take into account the curvature of the Xi trajectory ?
2997                         //                       or rather, the resolution in space of the decay vertex ...
2998                         //FIXME
2999
3000                         Double_t lHnSpFillVar[5] = {0.};
3001                         lHnSpFillVar[0] = lTVect3MomXi.DeltaPhi(lTVect3MomTrck) * 180.0/TMath::Pi(); // Delta phi(Casc,Track) (deg)
3002                         if(lHnSpFillVar[0] < -50.0) lHnSpFillVar[0] += 360.0;   
3003                         lHnSpFillVar[1] = lEtaXi - lCurrentTrck->Eta();                 // Delta eta(Casc,Track)
3004                         lHnSpFillVar[2] = lTVect3MomXi.Pt();                            // Pt_{Casc}
3005                         lHnSpFillVar[3] = lCurrentTrck->Pt();                           // Pt_{any track}
3006                         lHnSpFillVar[4] = lInvMassCascade;                              // Eff. Inv Mass (control var)
3007
3008                         if(      lStrCascType.Contains("Xi-") )      fHnSpAngularCorrXiMinus    ->Fill( lHnSpFillVar );
3009                         else if( lStrCascType.Contains("Xi+") )      fHnSpAngularCorrXiPlus     ->Fill( lHnSpFillVar );
3010                         else if( lStrCascType.Contains("Omega-") )   fHnSpAngularCorrOmegaMinus ->Fill( lHnSpFillVar );
3011                         else if( lStrCascType.Contains("Omega+") )   fHnSpAngularCorrOmegaPlus  ->Fill( lHnSpFillVar );
3012
3013                 }// end - Loop over all the tracks in the event
3014
3015         }// end of correlation type : "Trig = Casc - Asso = AnyPrim", (cases 1.1 and 1.2)
3016
3017
3018
3019         else if(fAngularCorrelationType == "TrigLeadingTrck-AssoCasc"){
3020
3021         //----------------------- Option 2 ---------------------------------------------------------------------------------------------------
3022         // Trigger    = trigger,
3023         // Associated = the cascade'S' in the event
3024         // NOTE : several good cascades could be present in the event (e.g. one leading track as trigger, 2 associated Xi) ...
3025         //       The present function will then be called several times.
3026         //        = issue for the normalisation ...
3027
3028                 // 1st loop: 
3029                 //            find the index of the (1) primary track (2) which is the leading particle in pt
3030                 // NOTE :  we do not take into account the Cascade pt, i.e. pt(Casc) could be greater or lower than pt(Leading) ...
3031                 Int_t    lLeadingPrimTrackIdx = -1;
3032                 Double_t lPtMax               =  0.1;
3033
3034                 for(Int_t TrckIdx = 0; TrckIdx < (InputEvent())->GetNumberOfTracks() ; TrckIdx++ )
3035                 {// Loop over all the tracks of the event
3036
3037                         AliESDtrack *lCurrentTrck = dynamic_cast<AliESDtrack*>( (InputEvent())->GetTrack( TrckIdx ) );
3038                                 if (!lCurrentTrck ) {
3039                                         AliWarning("ERROR Correl. Study : Could not retrieve a track while looping over the event tracks ...");
3040                                         continue;
3041                                 }
3042         
3043                         // Primary track selection
3044                         if( !fESDtrackCuts->AcceptTrack(lCurrentTrck) ) continue;
3045         
3046                         // Exclude the tracks that build the condisdered cascade = the bachelor + the V0 dghters
3047                         //     This may bias the outcome, especially for low multplicity events.
3048                         // Note : For ESD event, track ID == track index.
3049                         if(lCurrentTrck->GetID() == lArrTrackID[0]) continue;
3050                         if(lCurrentTrck->GetID() == lArrTrackID[1]) continue;
3051                         if(lCurrentTrck->GetID() == lArrTrackID[2]) continue;
3052         
3053                         // Towards the leading track
3054                         if( lPtMax < lCurrentTrck->Pt() ){
3055                                 lLeadingPrimTrackIdx = TMath::Abs( lCurrentTrck->GetID() );
3056                                 lPtMax               = lCurrentTrck->Pt();
3057                         }
3058                 }// end leading track finding loop
3059         
3060                 if( lLeadingPrimTrackIdx < 0 ) return;
3061                 if( lPtMax < 0.101 )           return;
3062         
3063         
3064                 // 2nd step: filling ONCE the THnSparse
3065                 AliESDtrack *lLeadingTrck = dynamic_cast<AliESDtrack*>( (InputEvent())->GetTrack( lLeadingPrimTrackIdx ) );
3066                 
3067                 TVector3 lTVect3MomLeadingTrck( lLeadingTrck->Px(), lLeadingTrck->Py(), lLeadingTrck->Pz() );
3068                 
3069                 // 2 hypotheses made here :
3070                 //   - The Xi trajectory is a straight line,
3071                 //   - The Xi doesn't loose any energy by crossing the first layer(s) of ITS, if ever;
3072                 //      So, meaning hyp: vect p(Xi) at the emission = vect p(Xi) at the decay vertex
3073                 //      By doing this, we introduce a systematic error on the cascade Phi ...
3074                 // Room for improvement: take into account the curvature of the Xi trajectory ?
3075                 //                       or rather, the resolution in space of the decay vertex ...
3076                 //FIXME
3077         
3078                 Double_t lHnSpFillVar[5] = {0.};
3079                 lHnSpFillVar[0] = lTVect3MomLeadingTrck.DeltaPhi(lTVect3MomXi) * 180.0/TMath::Pi(); // Delta phi(leading Track, Casc) (deg)
3080                 if(lHnSpFillVar[0] < -50.0) lHnSpFillVar[0] += 360.0;
3081                 lHnSpFillVar[1] = lLeadingTrck->Eta() - lEtaXi;                 // Delta eta(leading Track, Casc)
3082                 lHnSpFillVar[2] = lTVect3MomXi.Pt();                            // Pt_{Casc}
3083                 lHnSpFillVar[3] = lLeadingTrck->Pt();                           // Pt_{leading track}
3084                 lHnSpFillVar[4] = lInvMassCascade;                              // Eff. Inv Mass (control var)
3085                 
3086                 if(      lStrCascType.Contains("Xi-") )      fHnSpAngularCorrXiMinus    ->Fill( lHnSpFillVar );
3087                 else if( lStrCascType.Contains("Xi+") )      fHnSpAngularCorrXiPlus     ->Fill( lHnSpFillVar );
3088                 else if( lStrCascType.Contains("Omega-") )   fHnSpAngularCorrOmegaMinus ->Fill( lHnSpFillVar );
3089                 else if( lStrCascType.Contains("Omega+") )   fHnSpAngularCorrOmegaPlus  ->Fill( lHnSpFillVar );
3090         }// end of correlation type : "Trig = LeadingTrck -Asso = Casc"
3091         else
3092                 return;
3093
3094 }
3095
3096 Int_t AliAnalysisTaskCheckCascade::DoESDTrackWithTPCrefitMultiplicity(const AliESDEvent *lESDevent)
3097 {
3098     // Checking the number of tracks with TPCrefit for each event
3099     // Needed for a rough assessment of the event multiplicity
3100         
3101         Int_t nTrackWithTPCrefitMultiplicity = 0;
3102         for(Int_t iTrackIdx = 0; iTrackIdx < (InputEvent())->GetNumberOfTracks(); iTrackIdx++){
3103                 AliESDtrack *esdTrack   = 0x0;
3104                              esdTrack   = lESDevent->GetTrack( iTrackIdx );
3105                 if (!esdTrack) { AliWarning("Pb / Could not retrieve one track within the track loop for TPCrefit check ..."); continue; }
3106
3107                 ULong_t lTrackStatus    = esdTrack->GetStatus();
3108                             if ((lTrackStatus&AliESDtrack::kTPCrefit)    == 0) continue;
3109                             else nTrackWithTPCrefitMultiplicity++;
3110                     // FIXME :
3111                     // The goal here is to get a better assessment of the event multiplicity.
3112                     // (InputEvent())->GetNumberOfTracks() takes into account ITS std alone tracks + global tracks
3113                     // This may introduce a bias. Hence the number of TPC refit tracks.
3114                     // Note : the event multiplicity = analysis on its own... See Jacek's or Jan Fiete's analysis on dN/d(eta)
3115
3116         }// end loop over all event tracks
3117         return  nTrackWithTPCrefitMultiplicity;
3118 }
3119
3120
3121
3122
3123
3124 //________________________________________________________________________
3125 void AliAnalysisTaskCheckCascade::Terminate(Option_t *) 
3126 {
3127   // Draw result to the screen
3128   // Called once at the end of the query
3129
3130   TList *cRetrievedList = 0x0;
3131          cRetrievedList = (TList*)GetOutputData(1);
3132         if(!cRetrievedList){
3133                 AliWarning("ERROR - AliAnalysisTaskCheckCascade: ouput data container list not available\n"); return;
3134         }
3135
3136   fHistTrackMultiplicityForTrigEvt = dynamic_cast<TH1F*> (   cRetrievedList->FindObject("fHistTrackMultiplicityForTrigEvt") );
3137   if (!fHistTrackMultiplicityForTrigEvt) {
3138                 AliWarning("ERROR - AliAnalysisTaskCheckCascade: fHistTrackMultiplicityForTrigEvt not available\n"); return;
3139         }
3140  
3141   fHistCascadeMultiplicityForTrigEvt = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistCascadeMultiplicityForTrigEvt") );
3142         if (!fHistCascadeMultiplicityForTrigEvt) {
3143                 AliWarning("ERROR - AliAnalysisTaskCheckCascade: fHistCascadeMultiplicityForTrigEvt not available\n"); return;
3144         }
3145         
3146   fHistMassXiMinus    = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassXiMinus") ); 
3147         if (!fHistMassXiMinus) {
3148                 AliWarning("ERROR - AliAnalysisTaskCheckCascade: fHistMassXiMinus not available\n"); return;
3149         }
3150   fHistMassXiPlus     = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassXiPlus") );
3151         if (!fHistMassXiPlus) {
3152                 AliWarning("ERROR - AliAnalysisTaskCheckCascade: fHistMassXiPlus not available\n"); return;
3153         }       
3154   fHistMassOmegaMinus = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassOmegaMinus") );
3155         if (!fHistMassOmegaMinus) {
3156                 AliWarning("ERROR - AliAnalysisTaskCheckCascade: fHistMassOmegaMinus not available\n"); return;
3157         }
3158   fHistMassOmegaPlus  = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassOmegaPlus") );       
3159         if (!fHistMassOmegaPlus) {
3160                 AliWarning("ERROR - AliAnalysisTaskCheckCascade: fHistMassOmegaPlus not available\n"); return;