]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWGLF/STRANGENESS/LambdaK0/AliAnalysisTaskExtractV0.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Changes to acquire V0M, V0A, SPD, TRK and ZNA centrality data simultaneously for...
[u/mrichter/AliRoot.git] / PWGLF / STRANGENESS / LambdaK0 / AliAnalysisTaskExtractV0.cxx
CommitLineData
bcb6ffdb 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
17//
18// Modified version of AliAnalysisTaskCheckCascade.cxx.
19// This is a 'hybrid' output version, in that it uses a classic TTree
20// ROOT object to store the candidates, plus a couple of histograms filled on
21// a per-event basis for storing variables too numerous to put in a tree.
22//
23// --- Added bits of code for checking V0s
24// (from AliAnalysisTaskCheckStrange.cxx)
25//
26// --- Algorithm Description
27// 1. Perform Physics Selection
28// 2. Perform Primary Vertex |z|<10cm selection
29// 3. Perform Primary Vertex NoTPCOnly vertexing selection (>0 contrib.)
30// 4. Perform Pileup Rejection
31// 5. Analysis Loops:
32// 5a. Fill TTree object with V0 information, candidates
33//
34// Please Report Any Bugs!
35//
36// --- David Dobrigkeit Chinellato
37// (david.chinellato@gmail.com)
38//
39// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
40
41class TTree;
42class TParticle;
43class TVector3;
44
45//class AliMCEventHandler;
46//class AliMCEvent;
47//class AliStack;
48
49class AliESDVertex;
50class AliAODVertex;
51class AliESDv0;
52class AliAODv0;
53
54#include <Riostream.h>
55#include "TList.h"
56#include "TH1.h"
57#include "TH2.h"
58#include "TH3.h"
59#include "THnSparse.h"
60#include "TVector3.h"
61#include "TCanvas.h"
62#include "TMath.h"
63#include "TLegend.h"
64#include "AliLog.h"
548bd092 65#include "AliCentrality.h"
bcb6ffdb 66#include "AliESDEvent.h"
67#include "AliAODEvent.h"
68#include "AliV0vertexer.h"
69#include "AliCascadeVertexer.h"
70#include "AliESDpid.h"
71#include "AliESDtrack.h"
72#include "AliESDtrackCuts.h"
73#include "AliInputEventHandler.h"
74#include "AliAnalysisManager.h"
75#include "AliMCEventHandler.h"
76
77#include "AliCFContainer.h"
78#include "AliMultiplicity.h"
79
80#include "AliESDcascade.h"
81#include "AliAODcascade.h"
82#include "AliESDUtils.h"
0eebce93 83#include "AliESDHeader.h"
bcb6ffdb 84
85#include "AliAnalysisTaskExtractV0.h"
86
4f8ed367 87//debugging purposes
88#include "TObjectTable.h"
89
bcb6ffdb 90ClassImp(AliAnalysisTaskExtractV0)
91
92AliAnalysisTaskExtractV0::AliAnalysisTaskExtractV0()
76029adc 93 : AliAnalysisTaskSE(), fListHistV0(0), fTree(0), fPIDResponse(0),fESDtrackCuts(0),
85b81f83 94 fkIsNuclear ( kFALSE ),
048f4f8f 95 fkSwitchINT7 ( kFALSE ),
85b81f83 96 fkUseOnTheFly ( kFALSE ),
97 fkTakeAllTracks ( kFALSE ),
e039e6b3 98 fCentralityEstimator("V0M"),
df0fac9b 99 fkLightWeight ( kFALSE ),
85b81f83 100//------------------------------------------------
101// Initialize
102 fTreeVariableChi2V0(0),
103 fTreeVariableDcaV0Daughters(0),
104 fTreeVariableDcaV0ToPrimVertex(0),
105 fTreeVariableDcaPosToPrimVertex(0),
106 fTreeVariableDcaNegToPrimVertex(0),
107 fTreeVariableV0CosineOfPointingAngle(0),
108 fTreeVariableV0Radius(0),
109 fTreeVariablePt(0),
110 fTreeVariableRapK0Short(0),
111 fTreeVariableRapLambda(0),
112 fTreeVariableInvMassK0s(0),
113 fTreeVariableInvMassLambda(0),
114 fTreeVariableInvMassAntiLambda(0),
115 fTreeVariableAlphaV0(0),
116 fTreeVariablePtArmV0(0),
117 fTreeVariableNegTotMomentum(0),
118 fTreeVariablePosTotMomentum(0),
119 fTreeVariableNegdEdxSig(0),
120 fTreeVariablePosdEdxSig(0),
121 fTreeVariableNegEta(0),
122 fTreeVariablePosEta(0),
123
124 fTreeVariableNSigmasPosProton(0),
125 fTreeVariableNSigmasPosPion(0),
126 fTreeVariableNSigmasNegProton(0),
127 fTreeVariableNSigmasNegPion(0),
128
129 fTreeVariableDistOverTotMom(0),
130 fTreeVariableLeastNbrCrossedRows(0),
131 fTreeVariableLeastRatioCrossedRowsOverFindable(0),
132 fTreeVariableMultiplicity(0),
5d43de53 133 fTreeVariableMultiplicityV0A(0),
134 fTreeVariableMultiplicityZNA(0),
135 fTreeVariableMultiplicityTRK(0),
136 fTreeVariableMultiplicitySPD(0),
85b81f83 137
138 fTreeVariableRunNumber(0),
139 fTreeVariableEventNumber(0),
140
141 fTreeVariableV0x(0),
142 fTreeVariableV0y(0),
143 fTreeVariableV0z(0),
144
145 fTreeVariableV0Px(0),
146 fTreeVariableV0Py(0),
147 fTreeVariableV0Pz(0),
148
149 fTreeVariablePVx(0),
150 fTreeVariablePVy(0),
151 fTreeVariablePVz(0),
bcb6ffdb 152
3db9b379 153 fTreeVariableNegTrackStatus(0),
154 fTreeVariablePosTrackStatus(0),
155
bcb6ffdb 156//------------------------------------------------
157// HISTOGRAMS
158// --- Filled on an Event-by-event basis
159//------------------------------------------------
160 fHistV0MultiplicityBeforeTrigSel(0),
161 fHistV0MultiplicityForTrigEvt(0),
162 fHistV0MultiplicityForSelEvt(0),
163 fHistV0MultiplicityForSelEvtNoTPCOnly(0),
164 fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup(0),
165 fHistMultiplicityBeforeTrigSel(0),
166 fHistMultiplicityForTrigEvt(0),
167 fHistMultiplicity(0),
168 fHistMultiplicityNoTPCOnly(0),
169 fHistMultiplicityNoTPCOnlyNoPileup(0),
1d94e33b 170
d0e77a8c 171//V0A Centrality
172fHistMultiplicityV0ABeforeTrigSel(0),
173fHistMultiplicityV0AForTrigEvt(0),
174fHistMultiplicityV0A(0),
175fHistMultiplicityV0ANoTPCOnly(0),
176fHistMultiplicityV0ANoTPCOnlyNoPileup(0),
177
178//ZNA Centrality
179fHistMultiplicityZNABeforeTrigSel(0),
180fHistMultiplicityZNAForTrigEvt(0),
181fHistMultiplicityZNA(0),
182fHistMultiplicityZNANoTPCOnly(0),
183fHistMultiplicityZNANoTPCOnlyNoPileup(0),
184
185//TRK Centrality
186fHistMultiplicityTRKBeforeTrigSel(0),
187fHistMultiplicityTRKForTrigEvt(0),
188fHistMultiplicityTRK(0),
189fHistMultiplicityTRKNoTPCOnly(0),
190fHistMultiplicityTRKNoTPCOnlyNoPileup(0),
191
192//SPD Centrality
193fHistMultiplicitySPDBeforeTrigSel(0),
194fHistMultiplicitySPDForTrigEvt(0),
195fHistMultiplicitySPD(0),
196fHistMultiplicitySPDNoTPCOnly(0),
197fHistMultiplicitySPDNoTPCOnlyNoPileup(0),
198
1d94e33b 199 //Raw Data for Vertex Z position estimator change
200 f2dHistMultiplicityVsVertexZBeforeTrigSel(0),
201 f2dHistMultiplicityVsVertexZForTrigEvt(0),
202 f2dHistMultiplicityVsVertexZ(0),
203 f2dHistMultiplicityVsVertexZNoTPCOnly(0),
204 f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup(0),
205
bcb6ffdb 206 fHistPVx(0),
207 fHistPVy(0),
208 fHistPVz(0),
209 fHistPVxAnalysis(0),
210 fHistPVyAnalysis(0),
4f8ed367 211 fHistPVzAnalysis(0),
212 fHistSwappedV0Counter(0)
bcb6ffdb 213{
214 // Dummy Constructor
215}
216
217AliAnalysisTaskExtractV0::AliAnalysisTaskExtractV0(const char *name)
76029adc 218 : AliAnalysisTaskSE(name), fListHistV0(0), fTree(0), fPIDResponse(0),fESDtrackCuts(0),
85b81f83 219 fkIsNuclear ( kFALSE ),
048f4f8f 220 fkSwitchINT7 ( kFALSE ),
85b81f83 221 fkUseOnTheFly ( kFALSE ),
222 fkTakeAllTracks ( kFALSE ),
e039e6b3 223 fCentralityEstimator("V0M"),
df0fac9b 224 fkLightWeight ( kFALSE ),
85b81f83 225//------------------------------------------------
226// Initialize
227 fTreeVariableChi2V0(0),
228 fTreeVariableDcaV0Daughters(0),
229 fTreeVariableDcaV0ToPrimVertex(0),
230 fTreeVariableDcaPosToPrimVertex(0),
231 fTreeVariableDcaNegToPrimVertex(0),
232 fTreeVariableV0CosineOfPointingAngle(0),
233 fTreeVariableV0Radius(0),
234 fTreeVariablePt(0),
235 fTreeVariableRapK0Short(0),
236 fTreeVariableRapLambda(0),
237 fTreeVariableInvMassK0s(0),
238 fTreeVariableInvMassLambda(0),
239 fTreeVariableInvMassAntiLambda(0),
240 fTreeVariableAlphaV0(0),
241 fTreeVariablePtArmV0(0),
242 fTreeVariableNegTotMomentum(0),
243 fTreeVariablePosTotMomentum(0),
244 fTreeVariableNegdEdxSig(0),
245 fTreeVariablePosdEdxSig(0),
246 fTreeVariableNegEta(0),
247 fTreeVariablePosEta(0),
248
249 fTreeVariableNSigmasPosProton(0),
250 fTreeVariableNSigmasPosPion(0),
251 fTreeVariableNSigmasNegProton(0),
252 fTreeVariableNSigmasNegPion(0),
253
254 fTreeVariableDistOverTotMom(0),
255 fTreeVariableLeastNbrCrossedRows(0),
256 fTreeVariableLeastRatioCrossedRowsOverFindable(0),
257 fTreeVariableMultiplicity(0),
5d43de53 258 fTreeVariableMultiplicityV0A(0),
259 fTreeVariableMultiplicityZNA(0),
260 fTreeVariableMultiplicityTRK(0),
261 fTreeVariableMultiplicitySPD(0),
262
85b81f83 263 fTreeVariableRunNumber(0),
264 fTreeVariableEventNumber(0),
265
266 fTreeVariableV0x(0),
267 fTreeVariableV0y(0),
268 fTreeVariableV0z(0),
269
270 fTreeVariableV0Px(0),
271 fTreeVariableV0Py(0),
272 fTreeVariableV0Pz(0),
273
274 fTreeVariablePVx(0),
275 fTreeVariablePVy(0),
276 fTreeVariablePVz(0),
277
3db9b379 278 fTreeVariableNegTrackStatus(0),
279 fTreeVariablePosTrackStatus(0),
280
bcb6ffdb 281//------------------------------------------------
282// HISTOGRAMS
283// --- Filled on an Event-by-event basis
284//------------------------------------------------
285 fHistV0MultiplicityBeforeTrigSel(0),
286 fHistV0MultiplicityForTrigEvt(0),
287 fHistV0MultiplicityForSelEvt(0),
288 fHistV0MultiplicityForSelEvtNoTPCOnly(0),
289 fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup(0),
290 fHistMultiplicityBeforeTrigSel(0),
291 fHistMultiplicityForTrigEvt(0),
292 fHistMultiplicity(0),
293 fHistMultiplicityNoTPCOnly(0),
294 fHistMultiplicityNoTPCOnlyNoPileup(0),
1d94e33b 295
d0e77a8c 296
297//V0A Centrality
298fHistMultiplicityV0ABeforeTrigSel(0),
299fHistMultiplicityV0AForTrigEvt(0),
300fHistMultiplicityV0A(0),
301fHistMultiplicityV0ANoTPCOnly(0),
302fHistMultiplicityV0ANoTPCOnlyNoPileup(0),
303
304//ZNA Centrality
305fHistMultiplicityZNABeforeTrigSel(0),
306fHistMultiplicityZNAForTrigEvt(0),
307fHistMultiplicityZNA(0),
308fHistMultiplicityZNANoTPCOnly(0),
309fHistMultiplicityZNANoTPCOnlyNoPileup(0),
310
311//TRK Centrality
312fHistMultiplicityTRKBeforeTrigSel(0),
313fHistMultiplicityTRKForTrigEvt(0),
314fHistMultiplicityTRK(0),
315fHistMultiplicityTRKNoTPCOnly(0),
316fHistMultiplicityTRKNoTPCOnlyNoPileup(0),
317
318//SPD Centrality
319fHistMultiplicitySPDBeforeTrigSel(0),
320fHistMultiplicitySPDForTrigEvt(0),
321fHistMultiplicitySPD(0),
322fHistMultiplicitySPDNoTPCOnly(0),
323fHistMultiplicitySPDNoTPCOnlyNoPileup(0),
324
1d94e33b 325 //Raw Data for Vertex Z position estimator change
326 f2dHistMultiplicityVsVertexZBeforeTrigSel(0),
327 f2dHistMultiplicityVsVertexZForTrigEvt(0),
328 f2dHistMultiplicityVsVertexZ(0),
329 f2dHistMultiplicityVsVertexZNoTPCOnly(0),
330 f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup(0),
331
bcb6ffdb 332 fHistPVx(0),
333 fHistPVy(0),
334 fHistPVz(0),
335 fHistPVxAnalysis(0),
336 fHistPVyAnalysis(0),
4f8ed367 337 fHistPVzAnalysis(0),
338 fHistSwappedV0Counter(0)
bcb6ffdb 339{
340 // Constructor
341 // Output slot #0 writes into a TList container (Lambda Histos and fTree)
342 DefineOutput(1, TList::Class());
343 DefineOutput(2, TTree::Class());
344}
345
346
347AliAnalysisTaskExtractV0::~AliAnalysisTaskExtractV0()
348{
349//------------------------------------------------
350// DESTRUCTOR
351//------------------------------------------------
352
353 if (fListHistV0){
354 delete fListHistV0;
355 fListHistV0 = 0x0;
356 }
357 if (fTree){
358 delete fTree;
359 fTree = 0x0;
360 }
76029adc 361 //cleanup esd track cuts object too...
362 if (fESDtrackCuts){
363 delete fESDtrackCuts;
364 fESDtrackCuts = 0x0;
365 }
366
367
bcb6ffdb 368}
369
370
371
372//________________________________________________________________________
373void AliAnalysisTaskExtractV0::UserCreateOutputObjects()
374{
bcb6ffdb 375
eff0b6fc 376 //Create File-resident Tree, please.
377 OpenFile(2);
bcb6ffdb 378 // Called once
eff0b6fc 379 fTree = new TTree("fTree","V0Candidates");
bcb6ffdb 380
381//------------------------------------------------
382// fTree Branch definitions
383//------------------------------------------------
384
385//-----------BASIC-INFO---------------------------
eff0b6fc 386/* 1*/ fTree->Branch("fTreeVariableChi2V0",&fTreeVariableChi2V0,"fTreeVariableChi2V0/F");
387/* 2*/ fTree->Branch("fTreeVariableDcaV0Daughters",&fTreeVariableDcaV0Daughters,"fTreeVariableDcaV0Daughters/F");
bcb6ffdb 388/* 3*/ fTree->Branch("fTreeVariableDcaPosToPrimVertex",&fTreeVariableDcaPosToPrimVertex,"fTreeVariableDcaPosToPrimVertex/F");
389/* 4*/ fTree->Branch("fTreeVariableDcaNegToPrimVertex",&fTreeVariableDcaNegToPrimVertex,"fTreeVariableDcaNegToPrimVertex/F");
390/* 5*/ fTree->Branch("fTreeVariableV0Radius",&fTreeVariableV0Radius,"fTreeVariableV0Radius/F");
391/* 6*/ fTree->Branch("fTreeVariablePt",&fTreeVariablePt,"fTreeVariablePt/F");
392/* 7*/ fTree->Branch("fTreeVariableRapK0Short",&fTreeVariableRapK0Short,"fTreeVariableRapK0Short/F");
393/* 8*/ fTree->Branch("fTreeVariableRapLambda",&fTreeVariableRapLambda,"fTreeVariableRapLambda/F");
394/* 9*/ fTree->Branch("fTreeVariableInvMassK0s",&fTreeVariableInvMassK0s,"fTreeVariableInvMassK0s/F");
395/*10*/ fTree->Branch("fTreeVariableInvMassLambda",&fTreeVariableInvMassLambda,"fTreeVariableInvMassLambda/F");
396/*11*/ fTree->Branch("fTreeVariableInvMassAntiLambda",&fTreeVariableInvMassAntiLambda,"fTreeVariableInvMassAntiLambda/F");
397/*12*/ fTree->Branch("fTreeVariableV0CosineOfPointingAngle",&fTreeVariableV0CosineOfPointingAngle,"fTreeVariableV0CosineOfPointingAngle/F");
398/*13*/ fTree->Branch("fTreeVariableAlphaV0",&fTreeVariableAlphaV0,"fTreeVariableAlphaV0/F");
399/*14*/ fTree->Branch("fTreeVariablePtArmV0",&fTreeVariablePtArmV0,"fTreeVariablePtArmV0/F");
400/*15*/ fTree->Branch("fTreeVariableLeastNbrCrossedRows",&fTreeVariableLeastNbrCrossedRows,"fTreeVariableLeastNbrCrossedRows/I");
401/*16*/ fTree->Branch("fTreeVariableLeastRatioCrossedRowsOverFindable",&fTreeVariableLeastRatioCrossedRowsOverFindable,"fTreeVariableLeastRatioCrossedRowsOverFindable/F");
402//-----------MULTIPLICITY-INFO--------------------
403/*17*/ fTree->Branch("fTreeVariableMultiplicity",&fTreeVariableMultiplicity,"fTreeVariableMultiplicity/I");
5d43de53 404 /*17*/ fTree->Branch("fTreeVariableMultiplicityV0A",&fTreeVariableMultiplicityV0A,"fTreeVariableMultiplicityV0A/I");
405 /*17*/ fTree->Branch("fTreeVariableMultiplicityZNA",&fTreeVariableMultiplicityZNA,"fTreeVariableMultiplicityZNA/I");
406 /*17*/ fTree->Branch("fTreeVariableMultiplicityTRK",&fTreeVariableMultiplicityTRK,"fTreeVariableMultiplicityTRK/I");
407 /*17*/ fTree->Branch("fTreeVariableMultiplicitySPD",&fTreeVariableMultiplicitySPD,"fTreeVariableMultiplicitySPD/I");
bcb6ffdb 408//------------------------------------------------
409/*18*/ fTree->Branch("fTreeVariableDistOverTotMom",&fTreeVariableDistOverTotMom,"fTreeVariableDistOverTotMom/F");
410/*19*/ fTree->Branch("fTreeVariableNSigmasPosProton",&fTreeVariableNSigmasPosProton,"fTreeVariableNSigmasPosProton/F");
411/*20*/ fTree->Branch("fTreeVariableNSigmasPosPion",&fTreeVariableNSigmasPosPion,"fTreeVariableNSigmasPosPion/F");
412/*21*/ fTree->Branch("fTreeVariableNSigmasNegProton",&fTreeVariableNSigmasNegProton,"fTreeVariableNSigmasNegProton/F");
413/*22*/ fTree->Branch("fTreeVariableNSigmasNegPion",&fTreeVariableNSigmasNegPion,"fTreeVariableNSigmasNegPion/F");
414/*23*/ fTree->Branch("fTreeVariableNegEta",&fTreeVariableNegEta,"fTreeVariableNegEta/F");
415/*24*/ fTree->Branch("fTreeVariablePosEta",&fTreeVariablePosEta,"fTreeVariablePosEta/F");
0eebce93 416/*25*/ fTree->Branch("fTreeVariableRunNumber",&fTreeVariableRunNumber,"fTreeVariableRunNumber/I");
417/*26*/ fTree->Branch("fTreeVariableEventNumber",&fTreeVariableEventNumber,"fTreeVariableEventNumber/l");
df0fac9b 418
419 if( fkLightWeight == kFALSE ){
57d075b9 420//-----------FOR CTAU DEBUGGING: Full Phase Space + Decay Position Info
653265df 421 fTree->Branch("fTreeVariablePVx",&fTreeVariablePVx,"fTreeVariablePVx/F");
422 fTree->Branch("fTreeVariablePVy",&fTreeVariablePVy,"fTreeVariablePVy/F");
423 fTree->Branch("fTreeVariablePVz",&fTreeVariablePVz,"fTreeVariablePVz/F");
424
57d075b9 425 fTree->Branch("fTreeVariableV0x",&fTreeVariableV0x,"fTreeVariableV0x/F");
426 fTree->Branch("fTreeVariableV0y",&fTreeVariableV0y,"fTreeVariableV0y/F");
427 fTree->Branch("fTreeVariableV0z",&fTreeVariableV0z,"fTreeVariableV0z/F");
428
429 fTree->Branch("fTreeVariableV0Px",&fTreeVariableV0Px,"fTreeVariableV0Px/F");
430 fTree->Branch("fTreeVariableV0Py",&fTreeVariableV0Py,"fTreeVariableV0Py/F");
431 fTree->Branch("fTreeVariableV0Pz",&fTreeVariableV0Pz,"fTreeVariableV0Pz/F");
3db9b379 432
433 fTree->Branch("fTreeVariableNegTrackStatus",&fTreeVariableNegTrackStatus,"fTreeVariableNegTrackStatus/l");
434 fTree->Branch("fTreeVariablePosTrackStatus",&fTreeVariablePosTrackStatus,"fTreeVariablePosTrackStatus/l");
df0fac9b 435 }
3db9b379 436
bcb6ffdb 437//------------------------------------------------
438// Particle Identification Setup
439//------------------------------------------------
440
441 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
442 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
443 fPIDResponse = inputHandler->GetPIDResponse();
444
76029adc 445 // Multiplicity
446
447 if(! fESDtrackCuts ){
448 fESDtrackCuts = new AliESDtrackCuts();
449 }
450
bcb6ffdb 451
452//------------------------------------------------
453// V0 Multiplicity Histograms
454//------------------------------------------------
455
eff0b6fc 456 // Create histograms
457 //Create File-resident Tree, please.
458 OpenFile(1);
459
460 fListHistV0 = new TList();
461 fListHistV0->SetOwner(); // See http://root.cern.ch/root/html/TCollection.html#TCollection:SetOwner
462
bcb6ffdb 463 if(! fHistV0MultiplicityBeforeTrigSel) {
464 fHistV0MultiplicityBeforeTrigSel = new TH1F("fHistV0MultiplicityBeforeTrigSel",
465 "V0s per event (before Trig. Sel.);Nbr of V0s/Evt;Events",
466 25, 0, 25);
467 fListHistV0->Add(fHistV0MultiplicityBeforeTrigSel);
468 }
469
470 if(! fHistV0MultiplicityForTrigEvt) {
471 fHistV0MultiplicityForTrigEvt = new TH1F("fHistV0MultiplicityForTrigEvt",
472 "V0s per event (for triggered evt);Nbr of V0s/Evt;Events",
473 25, 0, 25);
474 fListHistV0->Add(fHistV0MultiplicityForTrigEvt);
475 }
476
477 if(! fHistV0MultiplicityForSelEvt) {
478 fHistV0MultiplicityForSelEvt = new TH1F("fHistV0MultiplicityForSelEvt",
479 "V0s per event;Nbr of V0s/Evt;Events",
480 25, 0, 25);
481 fListHistV0->Add(fHistV0MultiplicityForSelEvt);
482 }
483
484 if(! fHistV0MultiplicityForSelEvtNoTPCOnly) {
485 fHistV0MultiplicityForSelEvtNoTPCOnly = new TH1F("fHistV0MultiplicityForSelEvtNoTPCOnly",
486 "V0s per event;Nbr of V0s/Evt;Events",
487 25, 0, 25);
488 fListHistV0->Add(fHistV0MultiplicityForSelEvtNoTPCOnly);
489 }
490
491 if(! fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup) {
492 fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup = new TH1F("fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup",
493 "V0s per event;Nbr of V0s/Evt;Events",
494 25, 0, 25);
495 fListHistV0->Add(fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup);
496 }
497
498//------------------------------------------------
499// Track Multiplicity Histograms
500//------------------------------------------------
501
d0e77a8c 502 //Default V0M Centrality (if PbPb)
bcb6ffdb 503 if(! fHistMultiplicityBeforeTrigSel) {
504 fHistMultiplicityBeforeTrigSel = new TH1F("fHistMultiplicityBeforeTrigSel",
505 "Tracks per event;Nbr of Tracks;Events",
506 200, 0, 200);
507 fListHistV0->Add(fHistMultiplicityBeforeTrigSel);
508 }
509 if(! fHistMultiplicityForTrigEvt) {
510 fHistMultiplicityForTrigEvt = new TH1F("fHistMultiplicityForTrigEvt",
511 "Tracks per event;Nbr of Tracks;Events",
512 200, 0, 200);
513 fListHistV0->Add(fHistMultiplicityForTrigEvt);
514 }
515 if(! fHistMultiplicity) {
516 fHistMultiplicity = new TH1F("fHistMultiplicity",
517 "Tracks per event;Nbr of Tracks;Events",
518 200, 0, 200);
519 fListHistV0->Add(fHistMultiplicity);
520 }
521 if(! fHistMultiplicityNoTPCOnly) {
522 fHistMultiplicityNoTPCOnly = new TH1F("fHistMultiplicityNoTPCOnly",
523 "Tracks per event;Nbr of Tracks;Events",
524 200, 0, 200);
525 fListHistV0->Add(fHistMultiplicityNoTPCOnly);
526 }
527 if(! fHistMultiplicityNoTPCOnlyNoPileup) {
528 fHistMultiplicityNoTPCOnlyNoPileup = new TH1F("fHistMultiplicityNoTPCOnlyNoPileup",
529 "Tracks per event;Nbr of Tracks;Events",
530 200, 0, 200);
531 fListHistV0->Add(fHistMultiplicityNoTPCOnlyNoPileup);
532 }
d0e77a8c 533
534 //V0A Centrality (if PbPb / pPb)
535 if(! fHistMultiplicityV0ABeforeTrigSel) {
536 fHistMultiplicityV0ABeforeTrigSel = new TH1F("fHistMultiplicityV0ABeforeTrigSel",
537 "Centrality Distribution: V0A;V0A Centrality;Events",
538 200, 0, 200);
539 fListHistV0->Add(fHistMultiplicityV0ABeforeTrigSel);
540 }
541 if(! fHistMultiplicityV0AForTrigEvt) {
542 fHistMultiplicityV0AForTrigEvt = new TH1F("fHistMultiplicityV0AForTrigEvt",
543 "Centrality Distribution: V0A;V0A Centrality;Events",
544 200, 0, 200);
545 fListHistV0->Add(fHistMultiplicityV0AForTrigEvt);
546 }
547 if(! fHistMultiplicityV0A) {
548 fHistMultiplicityV0A = new TH1F("fHistMultiplicityV0A",
549 "Centrality Distribution: V0A;V0A Centrality;Events",
550 200, 0, 200);
551 fListHistV0->Add(fHistMultiplicityV0A);
552 }
553 if(! fHistMultiplicityV0ANoTPCOnly) {
554 fHistMultiplicityV0ANoTPCOnly = new TH1F("fHistMultiplicityV0ANoTPCOnly",
555 "Centrality Distribution: V0A;V0A Centrality;Events",
556 200, 0, 200);
557 fListHistV0->Add(fHistMultiplicityV0ANoTPCOnly);
558 }
559 if(! fHistMultiplicityV0ANoTPCOnlyNoPileup) {
560 fHistMultiplicityV0ANoTPCOnlyNoPileup = new TH1F("fHistMultiplicityV0ANoTPCOnlyNoPileup",
561 "Centrality Distribution: V0A;V0A Centrality;Events",
562 200, 0, 200);
563 fListHistV0->Add(fHistMultiplicityV0ANoTPCOnlyNoPileup);
564 }
565
566 //ZNA Centrality (if PbPb / pPb)
567 if(! fHistMultiplicityZNABeforeTrigSel) {
568 fHistMultiplicityZNABeforeTrigSel = new TH1F("fHistMultiplicityZNABeforeTrigSel",
569 "Centrality Distribution: ZNA;ZNA Centrality;Events",
570 200, 0, 200);
571 fListHistV0->Add(fHistMultiplicityZNABeforeTrigSel);
572 }
573 if(! fHistMultiplicityZNAForTrigEvt) {
574 fHistMultiplicityZNAForTrigEvt = new TH1F("fHistMultiplicityZNAForTrigEvt",
575 "Centrality Distribution: ZNA;ZNA Centrality;Events",
576 200, 0, 200);
577 fListHistV0->Add(fHistMultiplicityZNAForTrigEvt);
578 }
579 if(! fHistMultiplicityZNA) {
580 fHistMultiplicityZNA = new TH1F("fHistMultiplicityZNA",
581 "Centrality Distribution: ZNA;ZNA Centrality;Events",
582 200, 0, 200);
583 fListHistV0->Add(fHistMultiplicityZNA);
584 }
585 if(! fHistMultiplicityZNANoTPCOnly) {
586 fHistMultiplicityZNANoTPCOnly = new TH1F("fHistMultiplicityZNANoTPCOnly",
587 "Centrality Distribution: ZNA;ZNA Centrality;Events",
588 200, 0, 200);
589 fListHistV0->Add(fHistMultiplicityZNANoTPCOnly);
590 }
591 if(! fHistMultiplicityZNANoTPCOnlyNoPileup) {
592 fHistMultiplicityZNANoTPCOnlyNoPileup = new TH1F("fHistMultiplicityZNANoTPCOnlyNoPileup",
593 "Centrality Distribution: ZNA;ZNA Centrality;Events",
594 200, 0, 200);
595 fListHistV0->Add(fHistMultiplicityZNANoTPCOnlyNoPileup);
596 }
597
598 //TRK Centrality (if PbPb / pPb)
599 if(! fHistMultiplicityTRKBeforeTrigSel) {
600 fHistMultiplicityTRKBeforeTrigSel = new TH1F("fHistMultiplicityTRKBeforeTrigSel",
601 "Centrality Distribution: TRK;TRK Centrality;Events",
602 200, 0, 200);
603 fListHistV0->Add(fHistMultiplicityTRKBeforeTrigSel);
604 }
605 if(! fHistMultiplicityTRKForTrigEvt) {
606 fHistMultiplicityTRKForTrigEvt = new TH1F("fHistMultiplicityTRKForTrigEvt",
607 "Centrality Distribution: TRK;TRK Centrality;Events",
608 200, 0, 200);
609 fListHistV0->Add(fHistMultiplicityTRKForTrigEvt);
610 }
611 if(! fHistMultiplicityTRK) {
612 fHistMultiplicityTRK = new TH1F("fHistMultiplicityTRK",
613 "Centrality Distribution: TRK;TRK Centrality;Events",
614 200, 0, 200);
615 fListHistV0->Add(fHistMultiplicityTRK);
616 }
617 if(! fHistMultiplicityTRKNoTPCOnly) {
618 fHistMultiplicityTRKNoTPCOnly = new TH1F("fHistMultiplicityTRKNoTPCOnly",
619 "Centrality Distribution: TRK;TRK Centrality;Events",
620 200, 0, 200);
621 fListHistV0->Add(fHistMultiplicityTRKNoTPCOnly);
622 }
623 if(! fHistMultiplicityTRKNoTPCOnlyNoPileup) {
624 fHistMultiplicityTRKNoTPCOnlyNoPileup = new TH1F("fHistMultiplicityTRKNoTPCOnlyNoPileup",
625 "Centrality Distribution: TRK;TRK Centrality;Events",
626 200, 0, 200);
627 fListHistV0->Add(fHistMultiplicityTRKNoTPCOnlyNoPileup);
628 }
629
630 //SPD Centrality (if PbPb / pPb)
631 if(! fHistMultiplicitySPDBeforeTrigSel) {
632 fHistMultiplicitySPDBeforeTrigSel = new TH1F("fHistMultiplicitySPDBeforeTrigSel",
633 "Centrality Distribution: SPD;SPD Centrality;Events",
634 200, 0, 200);
635 fListHistV0->Add(fHistMultiplicitySPDBeforeTrigSel);
636 }
637 if(! fHistMultiplicitySPDForTrigEvt) {
638 fHistMultiplicitySPDForTrigEvt = new TH1F("fHistMultiplicitySPDForTrigEvt",
639 "Centrality Distribution: SPD;SPD Centrality;Events",
640 200, 0, 200);
641 fListHistV0->Add(fHistMultiplicitySPDForTrigEvt);
642 }
643 if(! fHistMultiplicitySPD) {
644 fHistMultiplicitySPD = new TH1F("fHistMultiplicitySPD",
645 "Centrality Distribution: SPD;SPD Centrality;Events",
646 200, 0, 200);
647 fListHistV0->Add(fHistMultiplicitySPD);
648 }
649 if(! fHistMultiplicitySPDNoTPCOnly) {
650 fHistMultiplicitySPDNoTPCOnly = new TH1F("fHistMultiplicitySPDNoTPCOnly",
651 "Centrality Distribution: SPD;SPD Centrality;Events",
652 200, 0, 200);
653 fListHistV0->Add(fHistMultiplicitySPDNoTPCOnly);
654 }
655 if(! fHistMultiplicitySPDNoTPCOnlyNoPileup) {
656 fHistMultiplicitySPDNoTPCOnlyNoPileup = new TH1F("fHistMultiplicitySPDNoTPCOnlyNoPileup",
657 "Centrality Distribution: SPD;SPD Centrality;Events",
658 200, 0, 200);
659 fListHistV0->Add(fHistMultiplicitySPDNoTPCOnlyNoPileup);
660 }
661
1d94e33b 662 //Raw Data for Vertex Z position estimator change
663 //TH2F *f2dHistMultiplicityVsVertexZBeforeTrigSel; //! multiplicity distribution
664 //TH2F *f2dHistMultiplicityVsVertexZForTrigEvt; //! multiplicity distribution
665 //TH2F *f2dHistMultiplicityVsVertexZ; //! multiplicity distribution
666 //TH2F *f2dHistMultiplicityVsVertexZNoTPCOnly; //! multiplicity distribution
667 //TH2F *f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup; //! multiplicity distribution
668
669 if(! f2dHistMultiplicityVsVertexZBeforeTrigSel) {
670 f2dHistMultiplicityVsVertexZBeforeTrigSel = new TH2F("f2dHistMultiplicityVsVertexZBeforeTrigSel",
671 "Tracks per event", 200, 0, 200,400, -20, 20);
672 fListHistV0->Add(f2dHistMultiplicityVsVertexZBeforeTrigSel);
673 }
674 if(! f2dHistMultiplicityVsVertexZForTrigEvt) {
675 f2dHistMultiplicityVsVertexZForTrigEvt = new TH2F("f2dHistMultiplicityVsVertexZForTrigEvt",
676 "Tracks per event", 200, 0, 200, 400, -20, 20);
677 fListHistV0->Add(f2dHistMultiplicityVsVertexZForTrigEvt);
678 }
679 if(! f2dHistMultiplicityVsVertexZ) {
680 f2dHistMultiplicityVsVertexZ = new TH2F("f2dHistMultiplicityVsVertexZ",
681 "Tracks per event", 200, 0, 200, 400, -20, 20);
682 fListHistV0->Add(f2dHistMultiplicityVsVertexZ);
683 }
684 if(! f2dHistMultiplicityVsVertexZNoTPCOnly) {
685 f2dHistMultiplicityVsVertexZNoTPCOnly = new TH2F("f2dHistMultiplicityVsVertexZNoTPCOnly",
686 "Tracks per event", 200, 0, 200, 400, -20, 20);
687 fListHistV0->Add(f2dHistMultiplicityVsVertexZNoTPCOnly);
688 }
689 if(! f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup) {
690 f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup = new TH2F("f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup",
691 "Tracks per event", 200, 0, 200, 400, -20, 20);
692 fListHistV0->Add(f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup);
693 }
694
695//-----------------------------------------------------
696
bcb6ffdb 697 if(! fHistPVx) {
698 fHistPVx = new TH1F("fHistPVx",
699 "PV x position;Nbr of Evts;x",
700 2000, -0.5, 0.5);
701 fListHistV0->Add(fHistPVx);
702 }
703 if(! fHistPVy) {
704 fHistPVy = new TH1F("fHistPVy",
705 "PV y position;Nbr of Evts;y",
706 2000, -0.5, 0.5);
707 fListHistV0->Add(fHistPVy);
708 }
709 if(! fHistPVz) {
710 fHistPVz = new TH1F("fHistPVz",
711 "PV z position;Nbr of Evts;z",
712 400, -20, 20);
713 fListHistV0->Add(fHistPVz);
714 }
715 if(! fHistPVxAnalysis) {
716 fHistPVxAnalysis = new TH1F("fHistPVxAnalysis",
717 "PV x position;Nbr of Evts;x",
718 2000, -0.5, 0.5);
719 fListHistV0->Add(fHistPVxAnalysis);
720 }
721 if(! fHistPVyAnalysis) {
722 fHistPVyAnalysis = new TH1F("fHistPVyAnalysis",
723 "PV y position;Nbr of Evts;y",
724 2000, -0.5, 0.5);
725 fListHistV0->Add(fHistPVyAnalysis);
726 }
727 if(! fHistPVzAnalysis) {
728 fHistPVzAnalysis = new TH1F("fHistPVzAnalysis",
729 "PV z position;Nbr of Evts;z",
730 400, -20, 20);
731 fListHistV0->Add(fHistPVzAnalysis);
732 }
4f8ed367 733 if(! fHistSwappedV0Counter) {
734 fHistSwappedV0Counter = new TH1F("fHistSwappedV0Counter",
735 "Swap or not histo;Swapped (1) or not (0); count",
736 2, 0, 2);
737 fListHistV0->Add(fHistSwappedV0Counter);
738 }
bcb6ffdb 739 //Regular output: Histograms
740 PostData(1, fListHistV0);
741 //TTree Object: Saved to base directory. Should cache to disk while saving.
742 //(Important to avoid excessive memory usage, particularly when merging)
743 PostData(2, fTree);
744
745}// end UserCreateOutputObjects
746
747
748//________________________________________________________________________
749void AliAnalysisTaskExtractV0::UserExec(Option_t *)
750{
751 // Main loop
752 // Called for each event
4f8ed367 753 //gObjectTable->Print();
bcb6ffdb 754 AliESDEvent *lESDevent = 0x0;
0eebce93 755
bcb6ffdb 756 //AliAODEvent *lAODevent = 0x0;
757 Int_t nV0s = -1;
758
759 Double_t lTrkgPrimaryVtxPos[3] = {-100.0, -100.0, -100.0};
760 Double_t lBestPrimaryVtxPos[3] = {-100.0, -100.0, -100.0};
761 Double_t lMagneticField = -10.;
762
763 // Connect to the InputEvent
764 // After these lines, we should have an ESD/AOD event + the number of cascades in it.
765
766 // Appropriate for ESD analysis!
767
768 lESDevent = dynamic_cast<AliESDEvent*>( InputEvent() );
769 if (!lESDevent) {
770 AliWarning("ERROR: lESDevent not available \n");
771 return;
772 }
0eebce93 773 fTreeVariableRunNumber = lESDevent->GetRunNumber();
774 fTreeVariableEventNumber =
775 ( ( ((ULong64_t)lESDevent->GetPeriodNumber() ) << 36 ) |
776 ( ((ULong64_t)lESDevent->GetOrbitNumber () ) << 12 ) |
777 ((ULong64_t)lESDevent->GetBunchCrossNumber() ) );
bcb6ffdb 778
779 //REVISED multiplicity estimator after 'multiplicity day' (2011)
d0e77a8c 780 Int_t lMultiplicity = -100;
781 Int_t lMultiplicityV0A = -100;
782 Int_t lMultiplicityZNA = -100;
783 Int_t lMultiplicityTRK = -100;
784 Int_t lMultiplicitySPD = -100;
4f8ed367 785
76029adc 786 if(fkIsNuclear == kFALSE) lMultiplicity = fESDtrackCuts->GetReferenceMultiplicity(lESDevent, AliESDtrackCuts::kTrackletsITSTPC,0.5);
548bd092 787
788 //---> If this is a nuclear collision, then go nuclear on "multiplicity" variable...
789 //---> Warning: Experimental
790 if(fkIsNuclear == kTRUE){
791 AliCentrality* centrality;
792 centrality = lESDevent->GetCentrality();
e039e6b3 793 lMultiplicity = ( ( Int_t ) ( centrality->GetCentralityPercentile( fCentralityEstimator.Data() ) ) );
d0e77a8c 794 lMultiplicityV0A = ( ( Int_t ) ( centrality->GetCentralityPercentile( "V0A" ) ) );
795 lMultiplicityZNA = ( ( Int_t ) ( centrality->GetCentralityPercentile( "ZNA" ) ) );
796 lMultiplicityTRK = ( ( Int_t ) ( centrality->GetCentralityPercentile( "TRK" ) ) );
797 lMultiplicitySPD = ( ( Int_t ) ( centrality->GetCentralityPercentile( "SPD" ) ) );
548bd092 798 if (centrality->GetQuality()>1) {
799 PostData(1, fListHistV0);
800 PostData(2, fTree);
801 return;
802 }
803 }
4f8ed367 804
bcb6ffdb 805 //Set variable for filling tree afterwards!
548bd092 806 //---> pp case......: GetReferenceMultiplicity
807 //---> Pb-Pb case...: Centrality by V0M
d0e77a8c 808 fTreeVariableMultiplicity = lMultiplicity;
809 fTreeVariableMultiplicityV0A = lMultiplicityV0A;
810 fTreeVariableMultiplicityZNA = lMultiplicityZNA;
811 fTreeVariableMultiplicityTRK = lMultiplicityTRK;
812 fTreeVariableMultiplicitySPD = lMultiplicitySPD;
813
814 fHistMultiplicityBeforeTrigSel->Fill ( lMultiplicity );
815 fHistMultiplicityV0ABeforeTrigSel->Fill ( lMultiplicityV0A );
816 fHistMultiplicityZNABeforeTrigSel->Fill ( lMultiplicityZNA );
817 fHistMultiplicityTRKBeforeTrigSel->Fill ( lMultiplicityTRK );
818 fHistMultiplicitySPDBeforeTrigSel->Fill ( lMultiplicitySPD );
819
820 fHistV0MultiplicityBeforeTrigSel->Fill ( lESDevent->GetNumberOfV0s() );
4f8ed367 821
bcb6ffdb 822//------------------------------------------------
823// Physics Selection
824//------------------------------------------------
825
826// new method
827 UInt_t maskIsSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
828 Bool_t isSelected = 0;
829 isSelected = (maskIsSelected & AliVEvent::kMB) == AliVEvent::kMB;
548bd092 830
048f4f8f 831 //pA triggering: CINT7
832 if( fkSwitchINT7 ) isSelected = (maskIsSelected & AliVEvent::kINT7) == AliVEvent::kINT7;
833
548bd092 834 //Standard Min-Bias Selection
bcb6ffdb 835 if ( ! isSelected ) {
836 PostData(1, fListHistV0);
837 PostData(2, fTree);
838 return;
839 }
840
841//------------------------------------------------
842// After Trigger Selection
843//------------------------------------------------
844
845 nV0s = lESDevent->GetNumberOfV0s();
846
847 fHistV0MultiplicityForTrigEvt ->Fill( nV0s );
548bd092 848 fHistMultiplicityForTrigEvt ->Fill( lMultiplicity );
d0e77a8c 849 fHistMultiplicityV0AForTrigEvt ->Fill( lMultiplicityV0A );
850 fHistMultiplicityZNAForTrigEvt ->Fill( lMultiplicityZNA );
851 fHistMultiplicityTRKForTrigEvt ->Fill( lMultiplicityTRK );
852 fHistMultiplicitySPDForTrigEvt ->Fill( lMultiplicitySPD );
853
bcb6ffdb 854//------------------------------------------------
855// Getting: Primary Vertex + MagField Info
856//------------------------------------------------
857
858 const AliESDVertex *lPrimaryTrackingESDVtx = lESDevent->GetPrimaryVertexTracks();
859 // get the vtx stored in ESD found with tracks
860 lPrimaryTrackingESDVtx->GetXYZ( lTrkgPrimaryVtxPos );
861
862 const AliESDVertex *lPrimaryBestESDVtx = lESDevent->GetPrimaryVertex();
863 // get the best primary vertex available for the event
864 // As done in AliCascadeVertexer, we keep the one which is the best one available.
865 // between : Tracking vertex > SPD vertex > TPC vertex > default SPD vertex
866 // This one will be used for next calculations (DCA essentially)
867 lPrimaryBestESDVtx->GetXYZ( lBestPrimaryVtxPos );
868
869 Double_t tPrimaryVtxPosition[3];
870 const AliVVertex *primaryVtx = lESDevent->GetPrimaryVertex();
871 tPrimaryVtxPosition[0] = primaryVtx->GetX();
872 tPrimaryVtxPosition[1] = primaryVtx->GetY();
873 tPrimaryVtxPosition[2] = primaryVtx->GetZ();
874 fHistPVx->Fill( tPrimaryVtxPosition[0] );
875 fHistPVy->Fill( tPrimaryVtxPosition[1] );
876 fHistPVz->Fill( tPrimaryVtxPosition[2] );
877
1d94e33b 878 f2dHistMultiplicityVsVertexZForTrigEvt->Fill( lMultiplicity, tPrimaryVtxPosition[2] );
879
bcb6ffdb 880//------------------------------------------------
881// Primary Vertex Z position: SKIP
882//------------------------------------------------
883
884 if(TMath::Abs(lBestPrimaryVtxPos[2]) > 10.0 ) {
885 AliWarning("Pb / | Z position of Best Prim Vtx | > 10.0 cm ... return !");
886 PostData(1, fListHistV0);
887 PostData(2, fTree);
888 return;
889 }
890
1d94e33b 891 f2dHistMultiplicityVsVertexZ->Fill( lMultiplicity, tPrimaryVtxPosition[2] );
892
d0e77a8c 893 lMagneticField = lESDevent->GetMagneticField( );
894 fHistV0MultiplicityForSelEvt ->Fill( nV0s );
895 fHistMultiplicity->Fill(lMultiplicity);
896 fHistMultiplicityV0A->Fill(lMultiplicityV0A);
897 fHistMultiplicityZNA->Fill(lMultiplicityZNA);
898 fHistMultiplicityTRK->Fill(lMultiplicityTRK);
899 fHistMultiplicitySPD->Fill(lMultiplicitySPD);
bcb6ffdb 900
901//------------------------------------------------
902// Only look at events with well-established PV
903//------------------------------------------------
904
905 const AliESDVertex *lPrimaryTrackingESDVtxCheck = lESDevent->GetPrimaryVertexTracks();
906 const AliESDVertex *lPrimarySPDVtx = lESDevent->GetPrimaryVertexSPD();
907 if (!lPrimarySPDVtx->GetStatus() && !lPrimaryTrackingESDVtxCheck->GetStatus() ){
908 AliWarning("Pb / No SPD prim. vertex nor prim. Tracking vertex ... return !");
909 PostData(1, fListHistV0);
910 PostData(2, fTree);
911 return;
912 }
913
1d94e33b 914
915 f2dHistMultiplicityVsVertexZNoTPCOnly->Fill( lMultiplicity, tPrimaryVtxPosition[2] );
d0e77a8c 916 fHistV0MultiplicityForSelEvtNoTPCOnly ->Fill( nV0s );
917 fHistMultiplicityNoTPCOnly->Fill(lMultiplicity);
918 fHistMultiplicityV0ANoTPCOnly->Fill(lMultiplicityV0A);
919 fHistMultiplicityZNANoTPCOnly->Fill(lMultiplicityZNA);
920 fHistMultiplicityTRKNoTPCOnly->Fill(lMultiplicityTRK);
921 fHistMultiplicitySPDNoTPCOnly->Fill(lMultiplicitySPD);
bcb6ffdb 922
923//------------------------------------------------
924// Pileup Rejection
925//------------------------------------------------
926
927 // FIXME : quality selection regarding pile-up rejection
4f8ed367 928 if(lESDevent->IsPileupFromSPD() && !fkIsNuclear){// 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
bcb6ffdb 929 PostData(1, fListHistV0);
930 PostData(2, fTree);
931 return;
932 }
1d94e33b 933
d0e77a8c 934 f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup->Fill( lMultiplicity, tPrimaryVtxPosition[2] );
935 fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup ->Fill( nV0s );
936 fHistMultiplicityNoTPCOnlyNoPileup->Fill(lMultiplicity);
937 fHistMultiplicityV0ANoTPCOnlyNoPileup->Fill(lMultiplicityV0A);
938 fHistMultiplicityZNANoTPCOnlyNoPileup->Fill(lMultiplicityZNA);
939 fHistMultiplicityTRKNoTPCOnlyNoPileup->Fill(lMultiplicityTRK);
940 fHistMultiplicitySPDNoTPCOnlyNoPileup->Fill(lMultiplicitySPD);
bcb6ffdb 941
942//------------------------------------------------
943// MAIN LAMBDA LOOP STARTS HERE
944//------------------------------------------------
945
946 if( ! (lESDevent->GetPrimaryVertex()->IsFromVertexerZ() ) ){
947 fHistPVxAnalysis->Fill( tPrimaryVtxPosition[0] );
948 fHistPVyAnalysis->Fill( tPrimaryVtxPosition[1] );
949 fHistPVzAnalysis->Fill( tPrimaryVtxPosition[2] );
950 }
951
653265df 952 fTreeVariablePVx = tPrimaryVtxPosition[0];
953 fTreeVariablePVy = tPrimaryVtxPosition[1];
954 fTreeVariablePVz = tPrimaryVtxPosition[2];
955
bcb6ffdb 956//Variable definition
957 Int_t lOnFlyStatus = 0;// nv0sOn = 0, nv0sOff = 0;
958 Double_t lChi2V0 = 0;
959 Double_t lDcaV0Daughters = 0, lDcaV0ToPrimVertex = 0;
960 Double_t lDcaPosToPrimVertex = 0, lDcaNegToPrimVertex = 0;
961 Double_t lV0CosineOfPointingAngle = 0;
962 Double_t lV0Radius = 0, lPt = 0;
963 Double_t lRapK0Short = 0, lRapLambda = 0;
964 Double_t lInvMassK0s = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0;
965 Double_t lAlphaV0 = 0, lPtArmV0 = 0;
966
967 Double_t fMinV0Pt = 0;
968 Double_t fMaxV0Pt = 100;
969
970 Int_t nv0s = 0;
971 nv0s = lESDevent->GetNumberOfV0s();
972
4f8ed367 973 //for (Int_t iV0 = 0; iV0 < nv0s; iV0++)
974 for (Int_t iV0 = 0; iV0 < nv0s; iV0++) //extra-crazy test
bcb6ffdb 975 {// This is the begining of the V0 loop
976 AliESDv0 *v0 = ((AliESDEvent*)lESDevent)->GetV0(iV0);
977 if (!v0) continue;
4f8ed367 978
979 //---> Fix On-the-Fly candidates, count how many swapped
980 if( v0->GetParamN()->Charge() > 0 && v0->GetParamP()->Charge() < 0 ){
981 fHistSwappedV0Counter -> Fill( 1 );
982 }else{
983 fHistSwappedV0Counter -> Fill( 0 );
984 }
985 if ( fkUseOnTheFly ) CheckChargeV0(v0);
986
bcb6ffdb 987 Double_t tDecayVertexV0[3]; v0->GetXYZ(tDecayVertexV0[0],tDecayVertexV0[1],tDecayVertexV0[2]);
57d075b9 988
bcb6ffdb 989 Double_t tV0mom[3];
990 v0->GetPxPyPz( tV0mom[0],tV0mom[1],tV0mom[2] );
991 Double_t lV0TotalMomentum = TMath::Sqrt(
992 tV0mom[0]*tV0mom[0]+tV0mom[1]*tV0mom[1]+tV0mom[2]*tV0mom[2] );
993
994 lV0Radius = TMath::Sqrt(tDecayVertexV0[0]*tDecayVertexV0[0]+tDecayVertexV0[1]*tDecayVertexV0[1]);
57d075b9 995
996 //Set Variables for later filling
997 fTreeVariableV0x = tDecayVertexV0[0];
998 fTreeVariableV0y = tDecayVertexV0[1];
999 fTreeVariableV0z = tDecayVertexV0[2];
1000
1001 //Set Variables for later filling
1002 fTreeVariableV0Px = tV0mom[0];
1003 fTreeVariableV0Py = tV0mom[1];
1004 fTreeVariableV0Pz = tV0mom[2];
1005
bcb6ffdb 1006 lPt = v0->Pt();
1007 lRapK0Short = v0->RapK0Short();
1008 lRapLambda = v0->RapLambda();
1009 if ((lPt<fMinV0Pt)||(fMaxV0Pt<lPt)) continue;
1010
1011 UInt_t lKeyPos = (UInt_t)TMath::Abs(v0->GetPindex());
1012 UInt_t lKeyNeg = (UInt_t)TMath::Abs(v0->GetNindex());
1013
1014 Double_t lMomPos[3]; v0->GetPPxPyPz(lMomPos[0],lMomPos[1],lMomPos[2]);
1015 Double_t lMomNeg[3]; v0->GetNPxPyPz(lMomNeg[0],lMomNeg[1],lMomNeg[2]);
1016
1017 AliESDtrack *pTrack=((AliESDEvent*)lESDevent)->GetTrack(lKeyPos);
1018 AliESDtrack *nTrack=((AliESDEvent*)lESDevent)->GetTrack(lKeyNeg);
1019 if (!pTrack || !nTrack) {
1020 Printf("ERROR: Could not retreive one of the daughter track");
1021 continue;
1022 }
1023
1024 //Daughter Eta for Eta selection, afterwards
1025 fTreeVariableNegEta = nTrack->Eta();
1026 fTreeVariablePosEta = pTrack->Eta();
1027
1028 // Filter like-sign V0 (next: add counter and distribution)
1029 if ( pTrack->GetSign() == nTrack->GetSign()){
1030 continue;
1031 }
1032
1033 //________________________________________________________________________
1034 // Track quality cuts
1035 Float_t lPosTrackCrossedRows = pTrack->GetTPCClusterInfo(2,1);
1036 Float_t lNegTrackCrossedRows = nTrack->GetTPCClusterInfo(2,1);
4f8ed367 1037 fTreeVariableLeastNbrCrossedRows = (Int_t) lPosTrackCrossedRows;
bcb6ffdb 1038 if( lNegTrackCrossedRows < fTreeVariableLeastNbrCrossedRows )
4f8ed367 1039 fTreeVariableLeastNbrCrossedRows = (Int_t) lNegTrackCrossedRows;
bcb6ffdb 1040
1041 // TPC refit condition (done during reconstruction for Offline but not for On-the-fly)
1042 if( !(pTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue;
1043 if( !(nTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue;
3db9b379 1044
1045 //Get status flags
1046 fTreeVariablePosTrackStatus = pTrack->GetStatus();
1047 fTreeVariableNegTrackStatus = nTrack->GetStatus();
1048
85b81f83 1049 if ( ( ( ( pTrack->GetTPCClusterInfo(2,1) ) < 70 ) || ( ( nTrack->GetTPCClusterInfo(2,1) ) < 70 ) )&&(fkTakeAllTracks==kFALSE) ) continue;
bcb6ffdb 1050
1051 //GetKinkIndex condition
1052 if( pTrack->GetKinkIndex(0)>0 || nTrack->GetKinkIndex(0)>0 ) continue;
1053
1054 //Findable clusters > 0 condition
1055 if( pTrack->GetTPCNclsF()<=0 || nTrack->GetTPCNclsF()<=0 ) continue;
1056
1057 //Compute ratio Crossed Rows / Findable clusters
1058 //Note: above test avoids division by zero!
1059 Float_t lPosTrackCrossedRowsOverFindable = lPosTrackCrossedRows / ((double)(pTrack->GetTPCNclsF()));
1060 Float_t lNegTrackCrossedRowsOverFindable = lNegTrackCrossedRows / ((double)(nTrack->GetTPCNclsF()));
1061
1062 fTreeVariableLeastRatioCrossedRowsOverFindable = lPosTrackCrossedRowsOverFindable;
1063 if( lNegTrackCrossedRowsOverFindable < fTreeVariableLeastRatioCrossedRowsOverFindable )
1064 fTreeVariableLeastRatioCrossedRowsOverFindable = lNegTrackCrossedRowsOverFindable;
1065
1066 //Lowest Cut Level for Ratio Crossed Rows / Findable = 0.8, set here
85b81f83 1067 if ( (fTreeVariableLeastRatioCrossedRowsOverFindable < 0.8)&&(fkTakeAllTracks==kFALSE) ) continue;
bcb6ffdb 1068
1069 //End track Quality Cuts
1070 //________________________________________________________________________
1071
1072 lDcaPosToPrimVertex = TMath::Abs(pTrack->GetD(tPrimaryVtxPosition[0],
1073 tPrimaryVtxPosition[1],
1074 lMagneticField) );
1075
1076 lDcaNegToPrimVertex = TMath::Abs(nTrack->GetD(tPrimaryVtxPosition[0],
1077 tPrimaryVtxPosition[1],
1078 lMagneticField) );
1079
1080 lOnFlyStatus = v0->GetOnFlyStatus();
1081 lChi2V0 = v0->GetChi2V0();
1082 lDcaV0Daughters = v0->GetDcaV0Daughters();
1083 lDcaV0ToPrimVertex = v0->GetD(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]);
1084 lV0CosineOfPointingAngle = v0->GetV0CosineOfPointingAngle(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]);
1085 fTreeVariableV0CosineOfPointingAngle=lV0CosineOfPointingAngle;
1086
1087 // Getting invariant mass infos directly from ESD
1088 v0->ChangeMassHypothesis(310);
1089 lInvMassK0s = v0->GetEffMass();
1090 v0->ChangeMassHypothesis(3122);
1091 lInvMassLambda = v0->GetEffMass();
1092 v0->ChangeMassHypothesis(-3122);
1093 lInvMassAntiLambda = v0->GetEffMass();
1094 lAlphaV0 = v0->AlphaV0();
1095 lPtArmV0 = v0->PtArmV0();
1096
1097 fTreeVariablePt = v0->Pt();
1098 fTreeVariableChi2V0 = lChi2V0;
1099 fTreeVariableDcaV0ToPrimVertex = lDcaV0ToPrimVertex;
1100 fTreeVariableDcaV0Daughters = lDcaV0Daughters;
1101 fTreeVariableV0CosineOfPointingAngle = lV0CosineOfPointingAngle;
1102 fTreeVariableV0Radius = lV0Radius;
1103 fTreeVariableDcaPosToPrimVertex = lDcaPosToPrimVertex;
1104 fTreeVariableDcaNegToPrimVertex = lDcaNegToPrimVertex;
1105 fTreeVariableInvMassK0s = lInvMassK0s;
1106 fTreeVariableInvMassLambda = lInvMassLambda;
1107 fTreeVariableInvMassAntiLambda = lInvMassAntiLambda;
1108 fTreeVariableRapK0Short = lRapK0Short;
1109 fTreeVariableRapLambda = lRapLambda;
1110 fTreeVariableAlphaV0 = lAlphaV0;
1111 fTreeVariablePtArmV0 = lPtArmV0;
1112
1113 //Official means of acquiring N-sigmas
1114 fTreeVariableNSigmasPosProton = fPIDResponse->NumberOfSigmasTPC( pTrack, AliPID::kProton );
1115 fTreeVariableNSigmasPosPion = fPIDResponse->NumberOfSigmasTPC( pTrack, AliPID::kPion );
1116 fTreeVariableNSigmasNegProton = fPIDResponse->NumberOfSigmasTPC( nTrack, AliPID::kProton );
1117 fTreeVariableNSigmasNegPion = fPIDResponse->NumberOfSigmasTPC( nTrack, AliPID::kPion );
1118
1119//This requires an Invariant Mass Hypothesis afterwards
1120 fTreeVariableDistOverTotMom = TMath::Sqrt(
1121 TMath::Power( tDecayVertexV0[0] - lBestPrimaryVtxPos[0] , 2) +
1122 TMath::Power( tDecayVertexV0[1] - lBestPrimaryVtxPos[1] , 2) +
1123 TMath::Power( tDecayVertexV0[2] - lBestPrimaryVtxPos[2] , 2)
1124 );
1125 fTreeVariableDistOverTotMom /= (lV0TotalMomentum+1e-10); //avoid division by zero, to be sure
1126
1127//------------------------------------------------
1128// Fill Tree!
1129//------------------------------------------------
1130
1131// The conditionals are meant to decrease excessive
1132// memory usage!
1133
1134//First Selection: Reject OnFly
4f8ed367 1135 if( (lOnFlyStatus == 0 && fkUseOnTheFly == kFALSE) || (lOnFlyStatus != 0 && fkUseOnTheFly == kTRUE ) ){
bcb6ffdb 1136 //Second Selection: rough 20-sigma band, parametric.
1137 //K0Short: Enough to parametrize peak broadening with linear function.
1138 Double_t lUpperLimitK0Short = (5.63707e-01) + (1.14979e-02)*fTreeVariablePt;
1139 Double_t lLowerLimitK0Short = (4.30006e-01) - (1.10029e-02)*fTreeVariablePt;
1140 //Lambda: Linear (for higher pt) plus exponential (for low-pt broadening)
1141 //[0]+[1]*x+[2]*TMath::Exp(-[3]*x)
1142 Double_t lUpperLimitLambda = (1.13688e+00) + (5.27838e-03)*fTreeVariablePt + (8.42220e-02)*TMath::Exp(-(3.80595e+00)*fTreeVariablePt);
1143 Double_t lLowerLimitLambda = (1.09501e+00) - (5.23272e-03)*fTreeVariablePt - (7.52690e-02)*TMath::Exp(-(3.46339e+00)*fTreeVariablePt);
1144 //Do Selection
1145 if( (fTreeVariableInvMassLambda < lUpperLimitLambda && fTreeVariableInvMassLambda > lLowerLimitLambda ) ||
1146 (fTreeVariableInvMassAntiLambda < lUpperLimitLambda && fTreeVariableInvMassAntiLambda > lLowerLimitLambda ) ||
1147 (fTreeVariableInvMassK0s < lUpperLimitK0Short && fTreeVariableInvMassK0s > lLowerLimitK0Short ) ){
4f8ed367 1148 //Pre-selection in case this is AA...
1149 if( fkIsNuclear == kFALSE ) fTree->Fill();
1150 if( fkIsNuclear == kTRUE){
1151 //If this is a nuclear collision___________________
1152 // ... pre-filter with TPC, daughter eta selection
1153 if( (fTreeVariableInvMassLambda < lUpperLimitLambda && fTreeVariableInvMassLambda > lLowerLimitLambda
1154 && TMath::Abs(fTreeVariableNSigmasPosProton) < 6.0 && TMath::Abs(fTreeVariableNSigmasNegPion) < 6.0 ) ||
1155 (fTreeVariableInvMassAntiLambda < lUpperLimitLambda && fTreeVariableInvMassAntiLambda > lLowerLimitLambda
1156 && TMath::Abs(fTreeVariableNSigmasNegProton) < 6.0 && TMath::Abs(fTreeVariableNSigmasPosPion) < 6.0 ) ||
1157 (fTreeVariableInvMassK0s < lUpperLimitK0Short && fTreeVariableInvMassK0s > lLowerLimitK0Short
1158 && TMath::Abs(fTreeVariableNSigmasNegPion) < 6.0 && TMath::Abs(fTreeVariableNSigmasPosPion) < 6.0 ) ){
1159 //insane test
1160 if ( TMath::Abs(fTreeVariableNegEta)<0.8 && TMath::Abs(fTreeVariablePosEta)<0.8 ) fTree->Fill();
1161 }
1162 }//end nuclear_____________________________________
bcb6ffdb 1163 }
1164 }
1165
1166//------------------------------------------------
1167// Fill tree over.
1168//------------------------------------------------
1169
1170 }// This is the end of the V0 loop
1171
1172 // Post output data.
1173 PostData(1, fListHistV0);
1174 PostData(2, fTree);
4f8ed367 1175
1176
bcb6ffdb 1177}
1178
1179//________________________________________________________________________
1180void AliAnalysisTaskExtractV0::Terminate(Option_t *)
1181{
1182 // Draw result to the screen
1183 // Called once at the end of the query
1184 // This will draw the V0 candidate multiplicity, whose
1185 // number of entries corresponds to the number of triggered events.
1186 TList *cRetrievedList = 0x0;
1187 cRetrievedList = (TList*)GetOutputData(1);
1188 if(!cRetrievedList){
1189 Printf("ERROR - AliAnalysisTaskExtractV0 : ouput data container list not available\n");
1190 return;
1191 }
1192 fHistV0MultiplicityForTrigEvt = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistV0MultiplicityForTrigEvt") );
1193 if (!fHistV0MultiplicityForTrigEvt) {
1194 Printf("ERROR - AliAnalysisTaskExtractV0 : fHistV0MultiplicityForTrigEvt not available");
1195 return;
1196 }
1197 TCanvas *canCheck = new TCanvas("AliAnalysisTaskExtractV0","V0 Multiplicity",10,10,510,510);
1198 canCheck->cd(1)->SetLogy();
1199 fHistV0MultiplicityForTrigEvt->SetMarkerStyle(22);
1200 fHistV0MultiplicityForTrigEvt->DrawCopy("E");
1201}
1202
4f8ed367 1203//________________________________________________________________________
1204void AliAnalysisTaskExtractV0::CheckChargeV0(AliESDv0 *v0)
1205{
1206 // This function checks charge of negative and positive daughter tracks.
1207 // If incorrectly defined (onfly vertexer), swaps out.
1208 if( v0->GetParamN()->Charge() > 0 && v0->GetParamP()->Charge() < 0 ){
1209 //V0 daughter track swapping is required! Note: everything is swapped here... P->N, N->P
1210 Long_t lCorrectNidx = v0->GetPindex();
1211 Long_t lCorrectPidx = v0->GetNindex();
1212 Double32_t lCorrectNmom[3];
1213 Double32_t lCorrectPmom[3];
1214 v0->GetPPxPyPz( lCorrectNmom[0], lCorrectNmom[1], lCorrectNmom[2] );
1215 v0->GetNPxPyPz( lCorrectPmom[0], lCorrectPmom[1], lCorrectPmom[2] );
1216
1217 AliExternalTrackParam lCorrectParamN(
1218 v0->GetParamP()->GetX() ,
1219 v0->GetParamP()->GetAlpha() ,
1220 v0->GetParamP()->GetParameter() ,
1221 v0->GetParamP()->GetCovariance()
1222 );
1223 AliExternalTrackParam lCorrectParamP(
1224 v0->GetParamN()->GetX() ,
1225 v0->GetParamN()->GetAlpha() ,
1226 v0->GetParamN()->GetParameter() ,
1227 v0->GetParamN()->GetCovariance()
1228 );
1229 lCorrectParamN.SetMostProbablePt( v0->GetParamP()->GetMostProbablePt() );
1230 lCorrectParamP.SetMostProbablePt( v0->GetParamN()->GetMostProbablePt() );
1231
1232 //Get Variables___________________________________________________
1233 Double_t lDcaV0Daughters = v0 -> GetDcaV0Daughters();
1234 Double_t lCosPALocal = v0 -> GetV0CosineOfPointingAngle();
1235 Bool_t lOnFlyStatusLocal = v0 -> GetOnFlyStatus();
1236
1237 //Create Replacement Object_______________________________________
1238 AliESDv0 *v0correct = new AliESDv0(lCorrectParamN,lCorrectNidx,lCorrectParamP,lCorrectPidx);
1239 v0correct->SetDcaV0Daughters ( lDcaV0Daughters );
1240 v0correct->SetV0CosineOfPointingAngle ( lCosPALocal );
1241 v0correct->ChangeMassHypothesis ( kK0Short );
1242 v0correct->SetOnFlyStatus ( lOnFlyStatusLocal );
1243
1244 //Reverse Cluster info..._________________________________________
1245 v0correct->SetClusters( v0->GetClusters( 1 ), v0->GetClusters ( 0 ) );
1246
1247 *v0 = *v0correct;
1248 //Proper cleanup..._______________________________________________
1249 v0correct->Delete();
1250 v0correct = 0x0;
1251
1252 //Just another cross-check and output_____________________________
1253 if( v0->GetParamN()->Charge() > 0 && v0->GetParamP()->Charge() < 0 ) {
1254 AliWarning("Found Swapped Charges, tried to correct but something FAILED!");
1255 }else{
1256 //AliWarning("Found Swapped Charges and fixed.");
1257 }
1258 //________________________________________________________________
1259 }else{
1260 //Don't touch it! ---
1261 //Printf("Ah, nice. Charges are already ordered...");
1262 }
1263 return;
1264}