]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGLF/QATasks/AliAnalysisTaskQAMultistrange.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Rename of QA tasks
[u/mrichter/AliRoot.git] / PWGLF / QATasks / AliAnalysisTaskQAMultistrange.cxx
CommitLineData
07b2bcd3 1/**************************************************************************
2 * Authors : Domenico Colella *
3 * *
4 * *
5 * Derived from the: *
6 * - Original AliAnalysisTaskCheckCascade (A. Maire, G. Hippolyte) *
7 * - Adapted to PbPb analysis (M. Nicassio) *
8 * *
9 * Permission to use, copy, modify and distribute this software and its *
10 * documentation strictly for non-commercial purposes is hereby granted *
11 * without fee, provided that the above copyright notice appears in all *
12 * copies and that both the copyright notice and this permission notice *
13 * appear in the supporting documentation. The authors make no claims *
14 * about the suitability of this software for any purpose. It is *
15 * provided "as is" without express or implied warranty. *
16 **************************************************************************/
17
18class TTree;
19class TParticle;
20class TVector3;
21
22class AliESDVertex;
23class AliAODVertex;
24class AliESDv0;
25class AliAODv0;
26
27#include <Riostream.h>
28#include "THnSparse.h"
29#include "TVector3.h"
30#include "TMath.h"
31
32#include "AliLog.h"
33#include "AliCentrality.h"
34#include "AliESDEvent.h"
35#include "AliAODEvent.h"
36#include "AliESDtrackCuts.h"
37#include "AliPIDResponse.h"
38
39#include "AliInputEventHandler.h"
40#include "AliAnalysisManager.h"
41#include "AliESDInputHandler.h"
42#include "AliAODInputHandler.h"
43#include "AliCFContainer.h"
44#include "AliMultiplicity.h"
45
46#include "AliESDcascade.h"
47#include "AliAODcascade.h"
48#include "AliAODTrack.h"
49
50#include "AliAnalysisTaskQAMultistrange.h"
51
52ClassImp(AliAnalysisTaskQAMultistrange)
53
54
55
56//________________________________________________________________________
57AliAnalysisTaskQAMultistrange::AliAnalysisTaskQAMultistrange()
58 : AliAnalysisTaskSE(),
59 fAnalysisType ("ESD"),
60 fESDtrackCuts (0),
61 fCollidingSystem ("PbPb"),
62 fPIDResponse (0),
63 fkSDDSelectionOn (kTRUE),
64 fkQualityCutZprimVtxPos (kTRUE),
65 fkQualityCutNoTPConlyPrimVtx(kTRUE),
66 fkQualityCutTPCrefit (kTRUE),
67 fkQualityCutnTPCcls (kTRUE),
68 fkQualityCutPileup (kTRUE),
69 fwithSDD (kTRUE),
70 fMinnTPCcls (0),
71 fCentrLowLim (0),
72 fCentrUpLim (0),
73 fCentrEstimator (0),
74 fkUseCleaning (0),
75 fVtxRange (0),
76 fMinPtCutOnDaughterTracks (0),
77 fEtaCutOnDaughterTracks (0),
78
79
80 fCFContCascadeCuts(0)
81
82
83{
84 // Dummy Constructor
85}
86
87
88//________________________________________________________________________
89AliAnalysisTaskQAMultistrange::AliAnalysisTaskQAMultistrange(const char *name)
90 : AliAnalysisTaskSE(name),
91 fAnalysisType ("ESD"),
92 fESDtrackCuts (0),
93 fCollidingSystem ("PbPb"),
94 fPIDResponse (0),
95 fkSDDSelectionOn (kTRUE),
96 fkQualityCutZprimVtxPos (kTRUE),
97 fkQualityCutNoTPConlyPrimVtx(kTRUE),
98 fkQualityCutTPCrefit (kTRUE),
99 fkQualityCutnTPCcls (kTRUE),
100 fkQualityCutPileup (kTRUE),
101 fwithSDD (kTRUE),
102 fMinnTPCcls (0),
103 fCentrLowLim (0),
104 fCentrUpLim (0),
105 fCentrEstimator (0),
106 fkUseCleaning (0),
107 fVtxRange (0),
108 fMinPtCutOnDaughterTracks (0),
109 fEtaCutOnDaughterTracks (0),
110
111
112 fCFContCascadeCuts(0)
113
114
115{
116 // Constructor
117 // Output slot #0 writes into a TList container (Cascade)
118 DefineOutput(1, AliCFContainer::Class());
119
120 AliLog::SetClassDebugLevel("AliAnalysisTaskQAMultistrange",1);
121}
122
123
124AliAnalysisTaskQAMultistrange::~AliAnalysisTaskQAMultistrange() {
125 //
126 // Destructor
127 //
128 // For all TH1, 2, 3 HnSparse and CFContainer are in the fListCascade TList.
129 // They will be deleted when fListCascade is deleted by the TSelector dtor
130 // Because of TList::SetOwner() ...
131 if (fCFContCascadeCuts && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadeCuts; fCFContCascadeCuts = 0x0; }
132 if (fESDtrackCuts) { delete fESDtrackCuts; fESDtrackCuts = 0x0; }
133}
134
135
136
137//________________________________________________________________________
138void AliAnalysisTaskQAMultistrange::UserCreateOutputObjects() {
139 // Create histograms
140 // Called once
141
142 //-----------------------------------------------
143 // Particle Identification Setup (new PID object)
144 //-----------------------------------------------
145 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
146 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
147 fPIDResponse = inputHandler->GetPIDResponse();
148
149
150 // Only used to get the number of primary reconstructed tracks
151 if (fAnalysisType == "ESD" && (! fESDtrackCuts )){
152 fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE);
153 //Printf("CheckCascade - ESDtrackCuts set up to 2010 std ITS-TPC cuts...");
154 }
155
156
157 //---------------------------------------------------
158 // Define the container for the topological variables
159 //---------------------------------------------------
160 if(! fCFContCascadeCuts) {
161 // Container meant to store all the relevant distributions corresponding to the cut variables.
162 // NB: overflow/underflow of variables on which we want to cut later should be 0!!!
163 const Int_t lNbSteps = 4 ;
164 const Int_t lNbVariables = 21 ;
165 //Array for the number of bins in each dimension :
166 Int_t lNbBinsPerVar[lNbVariables] = {0};
167 lNbBinsPerVar[0] = 25; //DcaCascDaughters : [0.0,2.4,3.0] -> Rec.Cut = 2.0;
168 lNbBinsPerVar[1] = 25; //DcaBachToPrimVertex : [0.0,0.24,100.0] -> Rec.Cut = 0.01;
169 lNbBinsPerVar[2] = 30; //CascCosineOfPointingAngle : [0.97,1.0] -> Rec.Cut = 0.98;
170 lNbBinsPerVar[3] = 40; //CascRadius : [0.0,3.9,1000.0] -> Rec.Cut = 0.2;
171 lNbBinsPerVar[4] = 30; //InvMassLambdaAsCascDghter : [1.1,1.3] -> Rec.Cut = 0.008;
172 lNbBinsPerVar[5] = 20; //DcaV0Daughters : [0.0,2.0] -> Rec.Cut = 1.5;
173 lNbBinsPerVar[6] = 201; //V0CosineOfPointingAngleToPV : [0.89,1.0] -> Rec.Cut = 0.9;
174 lNbBinsPerVar[7] = 40; //V0Radius : [0.0,3.9,1000.0] -> Rec.Cut = 0.2;
175 lNbBinsPerVar[8] = 40; //DcaV0ToPrimVertex : [0.0,0.39,110.0] -> Rec.Cut = 0.01;
176 lNbBinsPerVar[9] = 25; //DcaPosToPrimVertex : [0.0,0.24,100.0] -> Rec.Cut = 0.05;
177 lNbBinsPerVar[10] = 25; //DcaNegToPrimVertex : [0.0,0.24,100.0] -> Rec.Cut = 0.05
178 lNbBinsPerVar[11] = 150; //InvMassXi : 2-MeV/c2 bins
179 lNbBinsPerVar[12] = 120; //InvMassOmega : 2-MeV/c2 bins
180 lNbBinsPerVar[13] = 100; //XiTransvMom : [0.0,10.0]
181 lNbBinsPerVar[14] = 110; //Y(Xi) : 0.02 in rapidity units
182 lNbBinsPerVar[15] = 110; //Y(Omega) : 0.02 in rapidity units
183 lNbBinsPerVar[16] = 112; //Proper lenght of cascade
184 lNbBinsPerVar[17] = 112; //Proper lenght of V0
185 lNbBinsPerVar[18] = 201; //V0CosineOfPointingAngleToXiV
186 lNbBinsPerVar[19] = 11; //Centrality
187 lNbBinsPerVar[20] = 100; //ESD track multiplicity
188 //define the container
189 fCFContCascadeCuts = new AliCFContainer("fCFContCascadeCuts","Container for Cascade cuts", lNbSteps, lNbVariables, lNbBinsPerVar );
190 //Setting the bin limits
191 //0 - DcaXiDaughters
192 Double_t *lBinLim0 = new Double_t[ lNbBinsPerVar[0] + 1 ];
193 for(Int_t i=0; i< lNbBinsPerVar[0]; i++) lBinLim0[i] = (Double_t)0.0 + (2.4 - 0.0)/(lNbBinsPerVar[0] - 1) * (Double_t)i;
194 lBinLim0[ lNbBinsPerVar[0] ] = 3.0;
195 fCFContCascadeCuts -> SetBinLimits(0, lBinLim0);
196 delete [] lBinLim0;
197 //1 - DcaToPrimVertexXi
198 Double_t *lBinLim1 = new Double_t[ lNbBinsPerVar[1] + 1 ];
199 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;
200 lBinLim1[ lNbBinsPerVar[1] ] = 100.0;
201 fCFContCascadeCuts -> SetBinLimits(1, lBinLim1);
202 delete [] lBinLim1;
203 //2 - CascCosineOfPointingAngle
204 fCFContCascadeCuts->SetBinLimits(2, 0.97, 1.);
205 //3 - CascRadius
206 Double_t *lBinLim3 = new Double_t[ lNbBinsPerVar[3]+1 ];
207 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 ;
208 lBinLim3[ lNbBinsPerVar[3] ] = 1000.0;
209 fCFContCascadeCuts -> SetBinLimits(3, lBinLim3 );
210 delete [] lBinLim3;
211 //4 - InvMassLambdaAsCascDghter
212 fCFContCascadeCuts->SetBinLimits(4, 1.1, 1.13);
213 //5 - DcaV0Daughters
214 fCFContCascadeCuts -> SetBinLimits(5, 0., 2.);
215 //6 - V0CosineOfPointingAngleToPV
216 fCFContCascadeCuts -> SetBinLimits(6, 0.8, 1.001);
217 //7 - V0Radius
218 Double_t *lBinLim7 = new Double_t[ lNbBinsPerVar[7] + 1];
219 for(Int_t i=0; i< lNbBinsPerVar[7];i++) lBinLim7[i] = (Double_t)0.0 + (3.9 - 0.0)/(lNbBinsPerVar[7] - 1) * (Double_t)i;
220 lBinLim7[ lNbBinsPerVar[7] ] = 1000.0;
221 fCFContCascadeCuts -> SetBinLimits(7, lBinLim7);
222 delete [] lBinLim7;
223 //8 - DcaV0ToPrimVertex
224 Double_t *lBinLim8 = new Double_t[ lNbBinsPerVar[8]+1 ];
225 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 ;
226 lBinLim8[ lNbBinsPerVar[8] ] = 100.0;
227 fCFContCascadeCuts -> SetBinLimits(8, lBinLim8 );
228 delete [] lBinLim8;
229 //9 - DcaPosToPrimVertex
230 Double_t *lBinLim9 = new Double_t[ lNbBinsPerVar[9]+1 ];
231 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 ;
232 lBinLim9[ lNbBinsPerVar[9] ] = 100.0;
233 fCFContCascadeCuts -> SetBinLimits(9, lBinLim9 );
234 delete [] lBinLim9;
235 //10 - DcaNegToPrimVertex
236 Double_t *lBinLim10 = new Double_t[ lNbBinsPerVar[10]+1 ];
237 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 ;
238 lBinLim10[ lNbBinsPerVar[10] ] = 100.0;
239 fCFContCascadeCuts -> SetBinLimits(10, lBinLim10 );
240 delete [] lBinLim10;
241 //11 - InvMassXi
242 fCFContCascadeCuts->SetBinLimits(11, 1.25, 1.40);
243 //12 - InvMassOmega
244 fCFContCascadeCuts->SetBinLimits(12, 1.62, 1.74);
245 //13 - XiTransvMom
246 fCFContCascadeCuts->SetBinLimits(13, 0.0, 10.0);
247 //14 - Y(Xi)
248 fCFContCascadeCuts->SetBinLimits(14, -1.1, 1.1);
249 //15 - Y(Omega)
250 fCFContCascadeCuts->SetBinLimits(15, -1.1, 1.1);
251 //16 - Proper time of cascade
252 Double_t *lBinLim16 = new Double_t[ lNbBinsPerVar[16]+1 ];
253 for(Int_t i=0; i< lNbBinsPerVar[16];i++) lBinLim16[i] = (Double_t) -1. + (110. + 1.0 ) / (lNbBinsPerVar[16] - 1) * (Double_t) i;
254 lBinLim16[ lNbBinsPerVar[16] ] = 2000.0;
255 fCFContCascadeCuts->SetBinLimits(16, lBinLim16);
256 //17 - Proper time of V0
257 fCFContCascadeCuts->SetBinLimits(17, lBinLim16);
258 //18 - V0CosineOfPointingAngleToXiV
259 fCFContCascadeCuts -> SetBinLimits(18, 0.8, 1.001);
260 //19
261 Double_t *lBinLim19 = new Double_t[ lNbBinsPerVar[19]+1 ];
262 for(Int_t i=3; i< lNbBinsPerVar[19]+1;i++) lBinLim19[i] = (Double_t)(i-1)*10.;
263 lBinLim19[0] = 0.0;
264 lBinLim19[1] = 5.0;
265 lBinLim19[2] = 10.0;
266 fCFContCascadeCuts->SetBinLimits(19, lBinLim19 );
267 delete [] lBinLim19;
268 //20
269 fCFContCascadeCuts->SetBinLimits(20, 0.0, 6000.0);
270 // Setting the number of steps : one for each cascade species (Xi-, Xi+ and Omega-, Omega+)
271 fCFContCascadeCuts->SetStepTitle(0, "#Xi^{-} candidates");
272 fCFContCascadeCuts->SetStepTitle(1, "#bar{#Xi}^{+} candidates");
273 fCFContCascadeCuts->SetStepTitle(2, "#Omega^{-} candidates");
274 fCFContCascadeCuts->SetStepTitle(3, "#bar{#Omega}^{+} candidates");
275 // Setting the variable title, per axis
276 fCFContCascadeCuts->SetVarTitle(0, "Dca(cascade daughters) (cm)");
277 fCFContCascadeCuts->SetVarTitle(1, "ImpactParamToPV(bachelor) (cm)");
278 fCFContCascadeCuts->SetVarTitle(2, "cos(cascade PA)");
279 fCFContCascadeCuts->SetVarTitle(3, "R_{2d}(cascade decay) (cm)");
280 fCFContCascadeCuts->SetVarTitle(4, "M_{#Lambda}(as casc dghter) (GeV/c^{2})");
281 fCFContCascadeCuts->SetVarTitle(5, "Dca(V0 daughters) in Xi (cm)");
282 fCFContCascadeCuts->SetVarTitle(6, "cos(V0 PA) in cascade to PV");
283 fCFContCascadeCuts->SetVarTitle(7, "R_{2d}(V0 decay) (cm)");
284 fCFContCascadeCuts->SetVarTitle(8, "ImpactParamToPV(V0) (cm)");
285 fCFContCascadeCuts->SetVarTitle(9, "ImpactParamToPV(Pos) (cm)");
286 fCFContCascadeCuts->SetVarTitle(10, "ImpactParamToPV(Neg) (cm)");
287 fCFContCascadeCuts->SetVarTitle(11, "Inv. Mass(Xi) (GeV/c^{2})");
288 fCFContCascadeCuts->SetVarTitle(12, "Inv. Mass(Omega) (GeV/c^{2})");
289 fCFContCascadeCuts->SetVarTitle(13, "pt(cascade) (GeV/c)");
290 fCFContCascadeCuts->SetVarTitle(14, "Y(Xi)");
291 fCFContCascadeCuts->SetVarTitle(15, "Y(Omega)");
292 fCFContCascadeCuts->SetVarTitle(16, "mL/p (cascade) (cm)");
293 fCFContCascadeCuts->SetVarTitle(17, "mL/p (V0) (cm)");
294 fCFContCascadeCuts->SetVarTitle(18, "cos(V0 PA) in cascade to XiV");
295 fCFContCascadeCuts->SetVarTitle(19, "Centrality");
296 fCFContCascadeCuts->SetVarTitle(20, "ESD track multiplicity");
297 }
298
299PostData(1, fCFContCascadeCuts);
300
301}// end UserCreateOutputObjects
302
303
304//________________________________________________________________________
305void AliAnalysisTaskQAMultistrange::UserExec(Option_t *) {
306
307 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
308 // Main loop (called for each event)
309 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
310
311 //-----------------------
312 //Define ESD/AOD handlers
313 AliESDEvent *lESDevent = 0x0;
314 AliAODEvent *lAODevent = 0x0;
315
316 //---------------------
317 //Check the PIDresponse
318 if(!fPIDResponse) {
319 AliError("Cannot get pid response");
320 return;
321 }
322
323 //__________________________________________________
324 // After these lines we should have an ESD/AOD event
325
326 //---------------------------------------------------------
327 //Load the InputEvent and check, before any event selection
328 //---------------------------------------------------------
329 Float_t lPrimaryTrackMultiplicity = -1.;
330 AliCentrality* centrality = 0;
331 if (fAnalysisType == "ESD") {
332 lESDevent = dynamic_cast<AliESDEvent*>( InputEvent() );
333 if (!lESDevent) {
334 AliWarning("ERROR: lESDevent not available \n");
335 return;
336 }
337 if (fCollidingSystem == "PbPb") lPrimaryTrackMultiplicity = fESDtrackCuts->CountAcceptedTracks(lESDevent);
338 if (fCollidingSystem == "PbPb") centrality = lESDevent->GetCentrality();
339
340 } else if (fAnalysisType == "AOD") {
341 lAODevent = dynamic_cast<AliAODEvent*>( InputEvent() );
342 if (!lAODevent) {
343 AliWarning("ERROR: lAODevent not available \n");
344 return;
345 }
346 if (fCollidingSystem == "PbPb") {
347 lPrimaryTrackMultiplicity = 0;
348 Int_t nTrackMultiplicity = (InputEvent())->GetNumberOfTracks();
349 for (Int_t itrack = 0; itrack < nTrackMultiplicity; itrack++) {
350 AliAODTrack* track = lAODevent->GetTrack(itrack);
351 if (track->TestFilterBit(AliAODTrack::kTrkGlobalNoDCA)) lPrimaryTrackMultiplicity++;
352 }
353 }
354 if (fCollidingSystem == "PbPb") centrality = lAODevent->GetCentrality();
355 } else {
356 Printf("Analysis type (ESD or AOD) not specified \n");
357 return;
358 }
359
360 //-----------------------------------------
361 // Centrality selection for PbPb collisions
362 //-----------------------------------------
363 Float_t lcentrality = 0.;
364 if (fCollidingSystem == "PbPb") {
365 if (fkUseCleaning) lcentrality = centrality->GetCentralityPercentile(fCentrEstimator.Data());
366 else {
367 lcentrality = centrality->GetCentralityPercentileUnchecked(fCentrEstimator.Data());
368 if (centrality->GetQuality()>1) {
369 PostData(1, fCFContCascadeCuts);
370 return;
371 }
372 }
373 if (lcentrality<fCentrLowLim||lcentrality>=fCentrUpLim) {
374 PostData(1, fCFContCascadeCuts);
375 return;
376 }
377 } else if (fCollidingSystem == "pp") lcentrality = 0.;
378
379
380 //----------------------------------------
381 // SDD selection for pp@2.76TeV collisions
382 //----------------------------------------
383 if (fCollidingSystem == "pp") {
384 if (fAnalysisType == "ESD") {
385 if (fkSDDSelectionOn) {
386 TString trcl = lESDevent->GetFiredTriggerClasses();
387 if (fwithSDD) { if(!(trcl.Contains("ALLNOTRD"))) { PostData(1, fCFContCascadeCuts); return; } }
388 else if (!fwithSDD){ if((trcl.Contains("ALLNOTRD"))) { PostData(1, fCFContCascadeCuts); return; } }
389 }
390 } else if (fAnalysisType == "AOD") {
391 if (fkSDDSelectionOn) {
392 TString trcl = lAODevent->GetFiredTriggerClasses();
393 if (fwithSDD) { if(!(trcl.Contains("ALLNOTRD"))) { PostData(1, fCFContCascadeCuts); return; } }
394 else if (!fwithSDD) { if((trcl.Contains("ALLNOTRD"))) { PostData(1, fCFContCascadeCuts); return; } }
395 }
396 }
397 }
398
399 //--------------------------------------------
400 // Physics selection for pp@2.76TeV collisions
401 //--------------------------------------------
402 // - moved to the runGrid for the PbPb collisions
403 if (fCollidingSystem == "pp") {
404 if (fAnalysisType == "ESD") {
405 UInt_t maskIsSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
406 Bool_t isSelected = 0;
407 isSelected = (maskIsSelected & AliVEvent::kMB) == AliVEvent::kMB;
408 if(! isSelected){ PostData(1, fCFContCascadeCuts); return; }
409 } else if (fAnalysisType == "AOD") {
410 UInt_t maskIsSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
411 Bool_t isSelected = 0;
412 isSelected = (maskIsSelected & AliVEvent::kMB) == AliVEvent::kMB;
413 if(! isSelected){ PostData(1, fCFContCascadeCuts); return; }
414 }
415 }
416
417 //------------------------------
418 // Well-established PV selection
419 //------------------------------
420 Double_t lBestPrimaryVtxPos[3] = {-100.0, -100.0, -100.0};
421 Double_t lMagneticField = -10.;
422 if (fAnalysisType == "ESD") {
423 const AliESDVertex *lPrimaryTrackingESDVtx = lESDevent->GetPrimaryVertexTracks();
424 const AliESDVertex *lPrimaryBestESDVtx = lESDevent->GetPrimaryVertex();
425 if (fkQualityCutNoTPConlyPrimVtx) {
426 const AliESDVertex *lPrimarySPDVtx = lESDevent->GetPrimaryVertexSPD();
427 if (!lPrimarySPDVtx->GetStatus() && !lPrimaryTrackingESDVtx->GetStatus() ){
428 AliWarning(" No SPD prim. vertex nor prim. Tracking vertex ... return !");
429 PostData(1, fCFContCascadeCuts);
430 return;
431 }
432 }
433 lPrimaryBestESDVtx->GetXYZ( lBestPrimaryVtxPos );
434 lMagneticField = lESDevent->GetMagneticField( );
435 } else if (fAnalysisType == "AOD") {
436 const AliAODVertex *lPrimaryBestAODVtx = lAODevent->GetPrimaryVertex();
437 if (!lPrimaryBestAODVtx){
438 AliWarning("No prim. vertex in AOD... return!");
439 PostData(1, fCFContCascadeCuts);
440 return;
441 }
442 lPrimaryBestAODVtx->GetXYZ( lBestPrimaryVtxPos );
443 lMagneticField = lAODevent->GetMagneticField();
444 }
445
446 //------------------------------------------
447 // Pilup selection for pp@2.76TeV collisions
448 //------------------------------------------
449 if (fCollidingSystem == "pp") {
450 if (fAnalysisType == "ESD") {
451 if (fkQualityCutPileup) { if(lESDevent->IsPileupFromSPD()){ PostData(1, fCFContCascadeCuts); return; } }
452 } else if (fAnalysisType == "AOD") {
453 if (fkQualityCutPileup) { if(lAODevent->IsPileupFromSPD()){ PostData(1, fCFContCascadeCuts); return; } }
454 }
455 }
456
457 //----------------------------
458 // Vertex Z position selection
459 //----------------------------
460 if (fkQualityCutZprimVtxPos) {
461 if (TMath::Abs(lBestPrimaryVtxPos[2]) > fVtxRange ) {
462 PostData(1, fCFContCascadeCuts);
463 return;
464 }
465 }
466
467
468
469 //////////////////////////////
470 // CASCADE RECONSTRUCTION PART
471 //////////////////////////////
472
473 //%%%%%%%%%%%%%
474 // Cascade loop
475 Int_t ncascades = 0;
476 if (fAnalysisType == "ESD") ncascades = lESDevent->GetNumberOfCascades();
477 else if (fAnalysisType == "AOD") ncascades = lAODevent->GetNumberOfCascades();
478
479 for (Int_t iXi = 0; iXi < ncascades; iXi++) {// This is the begining of the Cascade loop (ESD or AOD)
480
481 // -------------------------------------
482 // - Initialisation of the local variables that will be needed for ESD/AOD
483 // -- Container variables (1st round)
484 Double_t lDcaXiDaughters = -1. ; //[Container]
485 Double_t lXiCosineOfPointingAngle = -1. ; //[Container]
486 Double_t lPosXi[3] = { -1000.0, -1000.0, -1000.0 }; //Useful to define other variables: radius fid. vol., ctau, etc. for cascade
487 Double_t lXiRadius = -1000. ; //[Container]
488 UShort_t lPosTPCClusters = -1; //To check the quality of the tracks. For ESD only ...
489 UShort_t lNegTPCClusters = -1; //To check the quality of the tracks. For ESD only ...
490 UShort_t lBachTPCClusters = -1; //To check the quality of the tracks. For ESD only ...
491 Double_t lInvMassLambdaAsCascDghter = 0.; //[Container]
492 Double_t lDcaV0DaughtersXi = -1.; //[Container]
493 Double_t lDcaBachToPrimVertexXi = -1.; //[Container]
494 Double_t lDcaV0ToPrimVertexXi = -1.; //[Container]
495 Double_t lDcaPosToPrimVertexXi = -1.; //[Container]
496 Double_t lDcaNegToPrimVertexXi = -1.; //[Container]
497 Double_t lV0CosineOfPointingAngle = -1.; //[Container]
498 Double_t lV0toXiCosineOfPointingAngle = -1.; //[Container]
499 Double_t lPosV0Xi[3] = { -1000. , -1000., -1000. }; //Useful to define other variables: radius fid. vol., ctau, etc. for VO
500 Double_t lV0RadiusXi = -1000.0; //[Container]
501 Double_t lV0quality = 0.; // ??
502 Double_t lInvMassXiMinus = 0.; //[Container]
503 Double_t lInvMassXiPlus = 0.; //[Container]
504 Double_t lInvMassOmegaMinus = 0.; //[Container]
505 Double_t lInvMassOmegaPlus = 0.; //[Container]
506 // -- PID treatment
507 Bool_t lIsBachelorKaonForTPC = kFALSE;
508 Bool_t lIsBachelorPionForTPC = kFALSE;
509 Bool_t lIsNegPionForTPC = kFALSE;
510 Bool_t lIsPosPionForTPC = kFALSE;
511 Bool_t lIsNegProtonForTPC = kFALSE;
512 Bool_t lIsPosProtonForTPC = kFALSE;
513 // -- More container variables and quality checks
514 Double_t lXiMomX = 0.; //Useful to define other variables: lXiTransvMom, lXiTotMom
515 Double_t lXiMomY = 0.; //Useful to define other variables: lXiTransvMom, lXiTotMom
516 Double_t lXiMomZ = 0.; //Useful to define other variables: lXiTransvMom, lXiTotMom
517 Double_t lXiTransvMom = 0.; //[Container]
518 Double_t lXiTotMom = 0.; //Useful to define other variables: cTau
519 Double_t lV0PMomX = 0.; //Useful to define other variables: lV0TotMom, lpTrackTransvMom
520 Double_t lV0PMomY = 0.; //Useful to define other variables: lV0TotMom, lpTrackTransvMom
521 Double_t lV0PMomZ = 0.; //Useful to define other variables: lV0TotMom, lpTrackTransvMom
522 Double_t lV0NMomX = 0.; //Useful to define other variables: lV0TotMom, lnTrackTransvMom
523 Double_t lV0NMomY = 0.; //Useful to define other variables: lV0TotMom, lnTrackTransvMom
524 Double_t lV0NMomZ = 0.; //Useful to define other variables: lV0TotMom, lnTrackTransvMom
525 Double_t lV0TotMom = 0.; //Useful to define other variables: lctauV0
526 Double_t lBachMomX = 0.; //Useful to define other variables: lBachTransvMom
527 Double_t lBachMomY = 0.; //Useful to define other variables: lBachTransvMom
528 Double_t lBachMomZ = 0.; //Useful to define other variables: lBachTransvMom
529 Double_t lBachTransvMom = 0.; //Selection on the min bachelor pT
530 Double_t lpTrackTransvMom = 0.; //Selection on the min bachelor pT
531 Double_t lnTrackTransvMom = 0.; //Selection on the min bachelor pT
532 Short_t lChargeXi = -2; //Useful to select the particles based on the charge
533 Double_t lRapXi = -20.0; //[Container]
534 Double_t lRapOmega = -20.0; //[Container]
535 Float_t etaBach = 0.; //Selection on the eta range
536 Float_t etaPos = 0.; //Selection on the eta range
537 Float_t etaNeg = 0.; //Selection on the eta range
538 // -- variables for the AliCFContainer dedicated to cascade cut optmisiation: ESD and AOD
539 if (fAnalysisType == "ESD") {
540
541 // -------------------------------------
542 // - Load the cascades from the handler
543 AliESDcascade *xi = lESDevent->GetCascade(iXi);
544 if (!xi) continue;
545
546 // ---------------------------------------------------------------------------
547 // - Assigning the necessary variables for specific AliESDcascade data members
548 lV0quality = 0.;
549 xi->ChangeMassHypothesis(lV0quality , 3312); // default working hypothesis : cascade = Xi- decay
550 lDcaXiDaughters = xi->GetDcaXiDaughters();
551 lXiCosineOfPointingAngle = xi->GetCascadeCosineOfPointingAngle( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lBestPrimaryVtxPos[2] );
552 // Take care : the best available vertex should be used (like in AliCascadeVertexer)
553 xi->GetXYZcascade( lPosXi[0], lPosXi[1], lPosXi[2] );
554 lXiRadius = TMath::Sqrt( lPosXi[0]*lPosXi[0] + lPosXi[1]*lPosXi[1] );
555
556 // -------------------------------------------------------------------------------------------------------------------------------
557 // - Around the tracks : Bach + V0 (ESD). Necessary variables for ESDcascade data members coming from the ESDv0 part (inheritance)
558 UInt_t lIdxPosXi = (UInt_t) TMath::Abs( xi->GetPindex() );
559 UInt_t lIdxNegXi = (UInt_t) TMath::Abs( xi->GetNindex() );
560 UInt_t lBachIdx = (UInt_t) TMath::Abs( xi->GetBindex() );
561 // Care track label can be negative in MC production (linked with the track quality)
562 // However = normally, not the case for track index ...
563 // - Rejection of a double use of a daughter track (nothing but just a crosscheck of what is done in the cascade vertexer)
564 if (lBachIdx == lIdxNegXi) continue;
565 if (lBachIdx == lIdxPosXi) continue;
566 // - Get the track for the daughters
567 AliESDtrack *pTrackXi = lESDevent->GetTrack( lIdxPosXi );
568 AliESDtrack *nTrackXi = lESDevent->GetTrack( lIdxNegXi );
569 AliESDtrack *bachTrackXi = lESDevent->GetTrack( lBachIdx );
570 if (!pTrackXi || !nTrackXi || !bachTrackXi ) continue;
571 // - Get the TPCnumber of cluster for the daughters
572 lPosTPCClusters = pTrackXi->GetTPCNcls();
573 lNegTPCClusters = nTrackXi->GetTPCNcls();
574 lBachTPCClusters = bachTrackXi->GetTPCNcls();
575
576 // ------------------------------------
577 // - Rejection of a poor quality tracks
578 if (fkQualityCutTPCrefit) {
579 // 1 - Poor quality related to TPCrefit
580 ULong_t pStatus = pTrackXi->GetStatus();
581 ULong_t nStatus = nTrackXi->GetStatus();
582 ULong_t bachStatus = bachTrackXi->GetStatus();
583 if ((pStatus&AliESDtrack::kTPCrefit) == 0) { AliWarning(" V0 Pos. track has no TPCrefit ... continue!"); continue; }
584 if ((nStatus&AliESDtrack::kTPCrefit) == 0) { AliWarning(" V0 Neg. track has no TPCrefit ... continue!"); continue; }
585 if ((bachStatus&AliESDtrack::kTPCrefit) == 0) { AliWarning(" Bach. track has no TPCrefit ... continue!"); continue; }
586 }
587 if (fkQualityCutnTPCcls) {
588 // 2 - Poor quality related to TPC clusters
589 if (lPosTPCClusters < fMinnTPCcls) { AliWarning(" V0 Pos. track has less than minn TPC clusters ... continue!"); continue; }
590 if (lNegTPCClusters < fMinnTPCcls) { AliWarning(" V0 Neg. track has less than minn TPC clusters ... continue!"); continue; }
591 if (lBachTPCClusters < fMinnTPCcls) { AliWarning(" Bach. track has less than minn TPC clusters ... continue!"); continue; }
592 }
593
594 // ------------------------------
595 etaPos = pTrackXi->Eta();
596 etaNeg = nTrackXi->Eta();
597 etaBach = bachTrackXi->Eta();
598 lInvMassLambdaAsCascDghter = xi->GetEffMass();
599 lDcaV0DaughtersXi = xi->GetDcaV0Daughters();
600 lV0CosineOfPointingAngle = xi->GetV0CosineOfPointingAngle( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lBestPrimaryVtxPos[2] );
601 lDcaV0ToPrimVertexXi = xi->GetD( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lBestPrimaryVtxPos[2] );
602 lDcaBachToPrimVertexXi = TMath::Abs( bachTrackXi->GetD( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lMagneticField) );
603 xi->GetXYZ( lPosV0Xi[0], lPosV0Xi[1], lPosV0Xi[2] );
604 lV0RadiusXi = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0] + lPosV0Xi[1]*lPosV0Xi[1] );
605 lDcaPosToPrimVertexXi = TMath::Abs( pTrackXi->GetD( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lMagneticField ) );
606 lDcaNegToPrimVertexXi = TMath::Abs( nTrackXi->GetD( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lMagneticField ) );
607
608 //----------------------------------------------------------------------------------------------------
609 // - Around effective masses. Change mass hypotheses to cover all the possibilities: Xi-/+, Omega -/+
610 if (bachTrackXi->Charge() < 0) {
611 // Calculate the effective mass of the Xi- candidate. pdg code 3312 = Xi-
612 lV0quality = 0.;
613 xi->ChangeMassHypothesis(lV0quality , 3312);
614 lInvMassXiMinus = xi->GetEffMassXi();
615 // Calculate the effective mass of the Xi- candidate. pdg code 3334 = Omega-
616 lV0quality = 0.;
617 xi->ChangeMassHypothesis(lV0quality , 3334);
618 lInvMassOmegaMinus = xi->GetEffMassXi();
619 // Back to default hyp.
620 lV0quality = 0.;
621 xi->ChangeMassHypothesis(lV0quality , 3312);
622 }// end if negative bachelor
623 if ( bachTrackXi->Charge() > 0 ) {
624 // Calculate the effective mass of the Xi+ candidate. pdg code -3312 = Xi+
625 lV0quality = 0.;
626 xi->ChangeMassHypothesis(lV0quality , -3312);
627 lInvMassXiPlus = xi->GetEffMassXi();
628 // Calculate the effective mass of the Xi+ candidate. pdg code -3334 = Omega+
629 lV0quality = 0.;
630 xi->ChangeMassHypothesis(lV0quality , -3334);
631 lInvMassOmegaPlus = xi->GetEffMassXi();
632 // Back to "default" hyp.
633 lV0quality = 0.;
634 xi->ChangeMassHypothesis(lV0quality , -3312);
635 }// end if positive bachelor
636
637 // ----------------------------------------------
638 // - TPC PID : 3-sigma bands on Bethe-Bloch curve
639 // Bachelor
640 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 4) lIsBachelorKaonForTPC = kTRUE;
641 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 4) lIsBachelorPionForTPC = kTRUE;
642 // Negative V0 daughter
643 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kPion )) < 4) lIsNegPionForTPC = kTRUE;
644 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kProton )) < 4) lIsNegProtonForTPC = kTRUE;
645 // Positive V0 daughter
646 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kPion )) < 4) lIsPosPionForTPC = kTRUE;
647 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 4) lIsPosProtonForTPC = kTRUE;
648
649 // ------------------------------
650 // - Miscellaneous pieces of info that may help regarding data quality assessment.
651 xi->GetPxPyPz( lXiMomX, lXiMomY, lXiMomZ );
652 lXiTransvMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY );
653 lXiTotMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY + lXiMomZ*lXiMomZ );
654 xi->GetNPxPyPz(lV0NMomX,lV0NMomY,lV0NMomZ);
655 xi->GetPPxPyPz(lV0PMomX,lV0PMomY,lV0PMomZ);
656 lV0TotMom = TMath::Sqrt(TMath::Power(lV0NMomX+lV0PMomX,2)+TMath::Power(lV0NMomY+lV0PMomY,2)+TMath::Power(lV0NMomZ+lV0PMomZ,2));
657 xi->GetBPxPyPz( lBachMomX, lBachMomY, lBachMomZ );
658 lBachTransvMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY );
659 lnTrackTransvMom = TMath::Sqrt( lV0NMomX*lV0NMomX + lV0NMomY*lV0NMomY );
660 lpTrackTransvMom = TMath::Sqrt( lV0PMomX*lV0PMomX + lV0PMomY*lV0PMomY );
661 lChargeXi = xi->Charge();
662 lV0toXiCosineOfPointingAngle = xi->GetV0CosineOfPointingAngle( lPosXi[0], lPosXi[1], lPosXi[2] );
663 lRapXi = xi->RapXi();
664 lRapOmega = xi->RapOmega();
665
666 } else if (fAnalysisType == "AOD") {
667
668 // -------------------------------------
669 // - Load the cascades from the handler
670 const AliAODcascade *xi = lAODevent->GetCascade(iXi);
671 if (!xi) continue;
672
673 //----------------------------------------------------------------------------
674 // - Assigning the necessary variables for specific AliESDcascade data members
675 lDcaXiDaughters = xi->DcaXiDaughters();
676 lXiCosineOfPointingAngle = xi->CosPointingAngleXi( lBestPrimaryVtxPos[0],
677 lBestPrimaryVtxPos[1],
678 lBestPrimaryVtxPos[2] );
679 lPosXi[0] = xi->DecayVertexXiX();
680 lPosXi[1] = xi->DecayVertexXiY();
681 lPosXi[2] = xi->DecayVertexXiZ();
682 lXiRadius = TMath::Sqrt( lPosXi[0]*lPosXi[0] + lPosXi[1]*lPosXi[1] );
683
684 //-------------------------------------------------------------------------------------------------------------------------------
685 // - Around the tracks: Bach + V0 (ESD). Necessary variables for ESDcascade data members coming from the ESDv0 part (inheritance)
686 AliAODTrack *pTrackXi = dynamic_cast<AliAODTrack*>( xi->GetDaughter(0) );
687 AliAODTrack *nTrackXi = dynamic_cast<AliAODTrack*>( xi->GetDaughter(1) );
688 AliAODTrack *bachTrackXi = dynamic_cast<AliAODTrack*>( xi->GetDecayVertexXi()->GetDaughter(0) );
689 if (!pTrackXi || !nTrackXi || !bachTrackXi ) continue;
690 UInt_t lIdxPosXi = (UInt_t) TMath::Abs( pTrackXi->GetID() );
691 UInt_t lIdxNegXi = (UInt_t) TMath::Abs( nTrackXi->GetID() );
692 UInt_t lBachIdx = (UInt_t) TMath::Abs( bachTrackXi->GetID() );
693 // Care track label can be negative in MC production (linked with the track quality)
694 // However = normally, not the case for track index ...
695
696 // - Rejection of a double use of a daughter track (nothing but just a crosscheck of what is done in the cascade vertexer)
697 if (lBachIdx == lIdxNegXi) continue;
698 if (lBachIdx == lIdxPosXi) continue;
699 // - Get the TPCnumber of cluster for the daughters
700 lPosTPCClusters = pTrackXi->GetTPCNcls(); // FIXME: Is this ok? or something like in LambdaK0PbPb task AOD?
701 lNegTPCClusters = nTrackXi->GetTPCNcls();
702 lBachTPCClusters = bachTrackXi->GetTPCNcls();
703
704 // ------------------------------------
705 // - Rejection of a poor quality tracks
706 if (fkQualityCutTPCrefit) {
707 // - Poor quality related to TPCrefit
708 if (!(pTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning(" V0 Pos. track has no TPCrefit ... continue!"); continue; }
709 if (!(nTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning(" V0 Neg. track has no TPCrefit ... continue!"); continue; }
710 if (!(bachTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning(" Bach. track has no TPCrefit ... continue!"); continue; }
711 }
712 if (fkQualityCutnTPCcls) {
713 // - Poor quality related to TPC clusters
714 if (lPosTPCClusters < fMinnTPCcls) continue;
715 if (lNegTPCClusters < fMinnTPCcls) continue;
716 if (lBachTPCClusters < fMinnTPCcls) continue;
717 }
718
719 // ------------------------------------------------------------------------------------------------------------------------------
720 // - Around the tracks: Bach + V0 (AOD). Necessary variables for AODcascade data members coming from the AODv0 part (inheritance)
721 etaPos = pTrackXi->Eta();
722 etaNeg = nTrackXi->Eta();
723 etaBach = bachTrackXi->Eta();
724 lChargeXi = xi->ChargeXi();
725 if ( lChargeXi < 0) lInvMassLambdaAsCascDghter = xi->MassLambda();
726 else lInvMassLambdaAsCascDghter = xi->MassAntiLambda();
727 lDcaV0DaughtersXi = xi->DcaV0Daughters();
728 lDcaV0ToPrimVertexXi = xi->DcaV0ToPrimVertex();
729 lDcaBachToPrimVertexXi = xi->DcaBachToPrimVertex();
730 lPosV0Xi[0] = xi->DecayVertexV0X();
731 lPosV0Xi[1] = xi->DecayVertexV0Y();
732 lPosV0Xi[2] = xi->DecayVertexV0Z();
733 lV0RadiusXi = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0] + lPosV0Xi[1]*lPosV0Xi[1] );
734 lV0CosineOfPointingAngle = xi->CosPointingAngle( lBestPrimaryVtxPos );
735 lDcaPosToPrimVertexXi = xi->DcaPosToPrimVertex();
736 lDcaNegToPrimVertexXi = xi->DcaNegToPrimVertex();
737
738 // ---------------------------------------------------------------------------------------------------
739 // - Around effective masses. Change mass hypotheses to cover all the possibilities: Xi-/+, Omega -/+
740 if ( lChargeXi < 0 ) lInvMassXiMinus = xi->MassXi();
741 if ( lChargeXi > 0 ) lInvMassXiPlus = xi->MassXi();
742 if ( lChargeXi < 0 ) lInvMassOmegaMinus = xi->MassOmega();
743 if ( lChargeXi > 0 ) lInvMassOmegaPlus = xi->MassOmega();
744
745 // ----------------------------------------------
746 // - TPC PID : 3-sigma bands on Bethe-Bloch curve
747 // Bachelor
748 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 4) lIsBachelorKaonForTPC = kTRUE;
749 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 4) lIsBachelorPionForTPC = kTRUE;
750 // Negative V0 daughter
751 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kPion )) < 4) lIsNegPionForTPC = kTRUE;
752 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kProton )) < 4) lIsNegProtonForTPC = kTRUE;
753 // Positive V0 daughter
754 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kPion )) < 4) lIsPosPionForTPC = kTRUE;
755 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 4) lIsPosProtonForTPC = kTRUE;
756
757 //---------------------------------
758 // - Extra info for QA (AOD)
759 // Miscellaneous pieces of info that may help regarding data quality assessment.
760 // Cascade transverse and total momentum
761 lXiMomX = xi->MomXiX();
762 lXiMomY = xi->MomXiY();
763 lXiMomZ = xi->MomXiZ();
764 lXiTransvMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY );
765 lXiTotMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY + lXiMomZ*lXiMomZ );
766 Double_t lV0MomX = xi->MomV0X();
767 Double_t lV0MomY = xi->MomV0Y();
768 Double_t lV0MomZ = xi->MomV0Z();
769 lV0TotMom = TMath::Sqrt(TMath::Power(lV0MomX,2)+TMath::Power(lV0MomY,2)+TMath::Power(lV0MomZ,2));
770 lBachMomX = xi->MomBachX();
771 lBachMomY = xi->MomBachY();
772 lBachMomZ = xi->MomBachZ();
773 lBachTransvMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY );
774 lV0NMomX = xi->MomNegX();
775 lV0NMomY = xi->MomNegY();
776 lV0PMomX = xi->MomPosX();
777 lV0PMomY = xi->MomPosY();
778 lnTrackTransvMom = TMath::Sqrt( lV0NMomX*lV0NMomX + lV0NMomY*lV0NMomY );
779 lpTrackTransvMom = TMath::Sqrt( lV0PMomX*lV0PMomX + lV0PMomY*lV0PMomY );
780 lV0toXiCosineOfPointingAngle = xi->CosPointingAngle( xi->GetDecayVertexXi() );
781 lRapXi = xi->RapXi();
782 lRapOmega = xi->RapOmega();
783
784 }// end of AOD treatment
785
786 //---------------------------------------
787 // Cut on pt of the three daughter tracks
788 if (lBachTransvMom<fMinPtCutOnDaughterTracks) continue;
789 if (lpTrackTransvMom<fMinPtCutOnDaughterTracks) continue;
790 if (lnTrackTransvMom<fMinPtCutOnDaughterTracks) continue;
791
792 //---------------------------------------------------
793 // Cut on pseudorapidity of the three daughter tracks
794 if (TMath::Abs(etaBach)>fEtaCutOnDaughterTracks) continue;
795 if (TMath::Abs(etaPos)>fEtaCutOnDaughterTracks) continue;
796 if (TMath::Abs(etaNeg)>fEtaCutOnDaughterTracks) continue;
797
798 //----------------------------------
799 // Calculate proper time for cascade
800 Double_t cascadeMass = 0.;
801 if ( ( (lChargeXi<0) && lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) ||
802 ( (lChargeXi>0) && lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC ) ) cascadeMass = 1.321;
803 if ( ( (lChargeXi<0) && lIsBachelorKaonForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) ||
804 ( (lChargeXi>0) && lIsBachelorKaonForTPC && lIsNegProtonForTPC && lIsPosPionForTPC ) ) cascadeMass = 1.672;
805 Double_t lctau = TMath::Sqrt(TMath::Power((lPosXi[0]-lBestPrimaryVtxPos[0]),2)+TMath::Power((lPosXi[1]-lBestPrimaryVtxPos[1]),2)+TMath::Power(( lPosXi[2]-lBestPrimaryVtxPos[2]),2));
806 if (lXiTotMom!=0) lctau = lctau*cascadeMass/lXiTotMom;
807 else lctau = -1.;
808 // Calculate proper time for Lambda (reconstructed)
809 Float_t lambdaMass = 1.115683; // PDG mass
810 Float_t distV0Xi = TMath::Sqrt(TMath::Power((lPosV0Xi[0]-lPosXi[0]),2)+TMath::Power((lPosV0Xi[1]-lPosXi[1]),2)+TMath::Power((lPosV0Xi[2]-lPosXi[2]),2));
811 Float_t lctauV0 = -1.;
812 if (lV0TotMom!=0) lctauV0 = distV0Xi*lambdaMass/lV0TotMom;
813
814
815 // Fill the AliCFContainer (optimisation of topological selections)
816 Double_t lContainerCutVars[21] = {0.0};
817 lContainerCutVars[0] = lDcaXiDaughters;
818 lContainerCutVars[1] = lDcaBachToPrimVertexXi;
819 lContainerCutVars[2] = lXiCosineOfPointingAngle;
820 lContainerCutVars[3] = lXiRadius;
821 lContainerCutVars[4] = lInvMassLambdaAsCascDghter;
822 lContainerCutVars[5] = lDcaV0DaughtersXi;
823 lContainerCutVars[6] = lV0CosineOfPointingAngle;
824 lContainerCutVars[7] = lV0RadiusXi;
825 lContainerCutVars[8] = lDcaV0ToPrimVertexXi;
826 lContainerCutVars[9] = lDcaPosToPrimVertexXi;
827 lContainerCutVars[10] = lDcaNegToPrimVertexXi;
828 lContainerCutVars[13] = lXiTransvMom;
829 lContainerCutVars[16] = lctau;
830 lContainerCutVars[17] = lctauV0;
831 lContainerCutVars[18] = lV0toXiCosineOfPointingAngle;
832 lContainerCutVars[19] = lcentrality;
833 lContainerCutVars[20] = lPrimaryTrackMultiplicity;
834 if ( lChargeXi < 0 ) {
835 lContainerCutVars[11] = lInvMassXiMinus;
836 lContainerCutVars[12] = lInvMassOmegaMinus;
837 lContainerCutVars[14] = lRapXi;
838 lContainerCutVars[15] = -1.;
839 if (lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC) fCFContCascadeCuts->Fill(lContainerCutVars,0); // for Xi-
840 lContainerCutVars[11] = lInvMassXiMinus;
841 lContainerCutVars[12] = lInvMassOmegaMinus;
842 lContainerCutVars[14] = -1.;
843 lContainerCutVars[15] = lRapOmega;
844 if (lIsBachelorKaonForTPC && lIsPosProtonForTPC && lIsNegPionForTPC) fCFContCascadeCuts->Fill(lContainerCutVars,2); // for Omega-
845 } else {
846 lContainerCutVars[11] = lInvMassXiPlus;
847 lContainerCutVars[12] = lInvMassOmegaPlus;
848 lContainerCutVars[14] = lRapXi;
849 lContainerCutVars[15] = -1.;
850 if (lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC) fCFContCascadeCuts->Fill(lContainerCutVars,1); // for Xi+
851 lContainerCutVars[11] = lInvMassXiPlus;
852 lContainerCutVars[12] = lInvMassOmegaPlus;
853 lContainerCutVars[14] = -1.;
854 lContainerCutVars[15] = lRapOmega;
855 if (lIsBachelorKaonForTPC && lIsNegProtonForTPC && lIsPosPionForTPC) fCFContCascadeCuts->Fill(lContainerCutVars,3); // for Omega+
856 }
857
858
859 }// end of the Cascade loop (ESD or AOD)
860
861
862 // Post output data.
863 PostData(1, fCFContCascadeCuts);
864}
865
866//________________________________________________________________________
867void AliAnalysisTaskQAMultistrange::Terminate(Option_t *)
868{
869
870}
871