1 /**************************************************************************
\r
2 * Authors : Antonin Maire, Boris Hippolyte *
\r
3 * Contributors are mentioned in the code where appropriate. *
\r
5 * Permission to use, copy, modify and distribute this software and its *
\r
6 * documentation strictly for non-commercial purposes is hereby granted *
\r
7 * without fee, provided that the above copyright notice appears in all *
\r
8 * copies and that both the copyright notice and this permission notice *
\r
9 * appear in the supporting documentation. The authors make no claims *
\r
10 * about the suitability of this software for any purpose. It is *
\r
11 * provided "as is" without express or implied warranty. *
\r
12 **************************************************************************/
\r
14 //-----------------------------------------------------------------
\r
15 // AliAnalysisTaskCheckCascadepp276 class
\r
17 // Origin AliAnalysisTaskCheckCascade which has four roles :
\r
18 // 1. QAing the Cascades from ESD and AOD
\r
19 // Origin: AliAnalysisTaskESDCheckV0 by Boris Hippolyte Nov2007, hippolyt@in2p3.fr
\r
20 // 2. Prepare the plots which stand as raw material for yield extraction (wi/wo PID)
\r
21 // 3. Supply an AliCFContainer meant to define the optimised topological selections
\r
22 // 4. Rough azimuthal correlation study (Eta, Phi)
\r
23 // Adapted to Cascade : A.Maire Mar2008, antonin.maire@ires.in2p3.fr
\r
24 // Modified : A.Maire Mar2010
\r
26 // Adapted to PbPb analysis: M. Nicassio, maria.nicassio@ba.infn.it
\r
28 // - Physics selection moved to the run.C macro
\r
29 // - Centrality selection added (+ setters) and histos
\r
30 // - flag and setters added (CF container usage, vertex range)
\r
31 // - histo added and histo/container binning changed
\r
32 // - protection in the destructor for CAF usage
\r
33 // - AliWarning disabled
\r
34 // - number of tracklets from AOD also
\r
35 // - automatic settings for PID
\r
37 // - proper time histos/container added (V0 and Cascades)
\r
38 // - cosine PA V0 wrt Xi vertex in the container
\r
40 // - re-run V0's and cascade's vertexers (SetCuts instead SetDefaultCuts!!)
\r
41 // - problems of libraries on Grid --> code copied in the task (from AliRoot v5-10-AN
\r
42 // where new pt dependent V0's cosPA cut implemented by Iouri)
\r
43 // - AOD analysis part completed
\r
46 // Adapted to pp 2.76 analysis: D. Colella, domenico.colella@ba.infn.it
\r
48 // - Physics selection re-moved here (mainly for normalization in the efficiency calcuation)
\r
49 // - Centrality selection deleted
\r
52 //-----------------------------------------------------------------
\r
63 #include <Riostream.h>
\r
68 #include "THnSparse.h"
\r
69 #include "TVector3.h"
\r
70 #include "TCanvas.h"
\r
72 #include "TLegend.h"
\r
75 #include "AliESDEvent.h"
\r
76 #include "AliAODEvent.h"
\r
77 #include "AliV0vertexer.h"
\r
78 #include "AliCascadeVertexer.h"
\r
79 #include "AliESDtrackCuts.h"
\r
80 #include "AliPIDResponse.h"
\r
82 #include "AliESDVZERO.h"
\r
84 #include "AliInputEventHandler.h"
\r
85 #include "AliAnalysisManager.h"
\r
86 #include "AliMCEventHandler.h"
\r
87 #include "AliESDInputHandler.h"
\r
88 #include "AliAODInputHandler.h"
\r
89 #include "AliCFContainer.h"
\r
90 #include "AliMultiplicity.h"
\r
92 #include "AliESDcascade.h"
\r
93 #include "AliAODcascade.h"
\r
94 #include "AliAODTrack.h"
\r
96 #include "AliAnalysisTaskCheckCascadepp276.h"
\r
102 ClassImp(AliAnalysisTaskCheckCascadepp276)
\r
106 //________________________________________________________________________
\r
107 AliAnalysisTaskCheckCascadepp276::AliAnalysisTaskCheckCascadepp276()
\r
108 : AliAnalysisTaskSE(),
\r
109 fAnalysisType ("ESD"),
\r
112 fkRerunV0CascVertexers (0),
\r
113 fkSDDSelectionOn (kTRUE),
\r
114 fkQualityCutZprimVtxPos (kTRUE),
\r
115 fkQualityCutNoTPConlyPrimVtx(kTRUE),
\r
116 fkQualityCutTPCrefit (kTRUE),
\r
117 fkQualityCutnTPCcls (kTRUE),
\r
118 fkQualityCutPileup (kTRUE),
\r
121 fkExtraSelections (0),
\r
124 fMinPtCutOnDaughterTracks (0),
\r
125 fEtaCutOnDaughterTracks (0),
\r
127 // - Plots initialisation
\r
128 fListHistCascade(0),
\r
129 // Cascades multiplicity plots
\r
130 fHistCascadeMultiplicityBeforeAnySel(0),
\r
131 fHistCascadeMultiplicityAfterSDDSel(0),
\r
132 fHistCascadeMultiplicityAfterPhysicsSel(0),
\r
133 fHistCascadeMultiplicityForSelEvtNoTPCOnly(0),
\r
134 fHistCascadeMultiplicityForSelEvtNoTPCOnlyNoPileup(0),
\r
135 fHistCascadeMultiplicityAfterVertexCutSel(0),
\r
136 // Tracks multiplicity plots
\r
137 fHistTrackMultiplicityBeforeAnySel(0),
\r
138 fHistTrackMultiplicityAfterSDDSel(0),
\r
139 fHistTrackMultiplicityAfterPhysicsSel(0),
\r
140 fHistTrackMultiplicityForSelEvtNoTPCOnly(0),
\r
141 fHistTrackMultiplicityForSelEvtNoTPCOnlyNoPileup(0),
\r
142 fHistTrackMultiplicityAfterVertexCutSel(0),
\r
143 // Vertex position plots (BestVertex)
\r
144 fHistPVx(0), fHistPVy(0), fHistPVz(0),
\r
145 fHistPVxAnalysis(0), fHistPVyAnalysis(0), fHistPVzAnalysis(0),
\r
146 // TPC cluster distributions for daughters
\r
147 fHistPosV0TPCClusters(0),
\r
148 fHistNegV0TPCClusters(0),
\r
149 fHistBachTPCClusters(0),
\r
150 // Cut's variables distributions
\r
151 fHistEffMassXi(0),
\r
152 fHistDcaXiDaughters(0),
\r
153 fHistDcaBachToPrimVertex(0),
\r
154 fHistXiCosineOfPointingAngle(0),
\r
156 fHistMassLambdaAsCascDghter(0),
\r
157 fHistDcaV0DaughtersXi(0),
\r
158 fHistDcaV0ToPrimVertexXi(0),
\r
159 fHistV0CosineOfPointingAngleXi(0),
\r
160 fHistV0RadiusXi(0),
\r
161 fHistDcaPosToPrimVertexXi(0),
\r
162 fHistDcaNegToPrimVertexXi(0),
\r
163 // Invariant mass distributions
\r
164 fHistMassXiMinus(0), fHistMassXiPlus(0), fHistMassOmegaMinus(0), fHistMassOmegaPlus(0),
\r
165 // Transverse and total momentum distributions
\r
166 fHistXiTransvMom(0), fHistXiTotMom(0), fHistBachTransvMomXi(0), fHistBachTotMomXi(0),
\r
169 fHistV0toXiCosineOfPointingAngle(0),
\r
170 fHistRapXi(0), fHistRapOmega(0),
\r
171 fHistEtaXi(0), fHistEtaBachXi(0), fHistEtaPosXi(0), fHistEtaNegXi(0),
\r
174 f2dHistArmenteros(0),
\r
175 f2dHistEffMassLambdaVsEffMassXiMinus(0), f2dHistEffMassXiVsEffMassOmegaMinus(0),
\r
176 f2dHistEffMassLambdaVsEffMassXiPlus(0), f2dHistEffMassXiVsEffMassOmegaPlus(0),
\r
177 f2dHistXiRadiusVsEffMassXiMinus(0), f2dHistXiRadiusVsEffMassXiPlus(0),
\r
178 f2dHistXiRadiusVsEffMassOmegaMinus(0), f2dHistXiRadiusVsEffMassOmegaPlus(0),
\r
179 f2dHistTPCdEdxOfCascDghters(0),
\r
180 f2dHistDcaXiDaughtersvsInvMass(0),
\r
181 f2dHistDcaBachToPrimVertexvsInvMass(0),
\r
182 f2dHistXiCosineOfPointingAnglevsInvMass(0),
\r
183 f2dHistMassLambdaAsCascDghtervsInvMass(0),
\r
184 f2dHistDcaV0DaughtersXivsInvMass(0),
\r
185 f2dHistDcaV0ToPrimVertexXivsInvMass(0),
\r
186 // Containers for cuts study
\r
187 fCFContCascadePIDXiMinus(0),
\r
188 fCFContCascadePIDXiPlus(0),
\r
189 fCFContCascadePIDOmegaMinus(0),
\r
190 fCFContCascadePIDOmegaPlus(0),
\r
191 fCFContCascadeCuts(0)
\r
194 // Dummy Constructor
\r
195 for(Int_t iV0selIdx = 0; iV0selIdx < 7; iV0selIdx++ ) { fV0Sels [iV0selIdx ] = -1.; }
\r
196 for(Int_t iCascSelIdx = 0; iCascSelIdx < 8; iCascSelIdx++ ) { fCascSels [iCascSelIdx ] = -1.; }
\r
200 //________________________________________________________________________
\r
201 AliAnalysisTaskCheckCascadepp276::AliAnalysisTaskCheckCascadepp276(const char *name)
\r
202 : AliAnalysisTaskSE(name),
\r
203 fAnalysisType ("ESD"),
\r
204 fESDtrackCuts (0),
\r
206 fkRerunV0CascVertexers (0),
\r
207 fkSDDSelectionOn (kTRUE),
\r
208 fkQualityCutZprimVtxPos (kTRUE),
\r
209 fkQualityCutNoTPConlyPrimVtx(kTRUE),
\r
210 fkQualityCutTPCrefit (kTRUE),
\r
211 fkQualityCutnTPCcls (kTRUE),
\r
212 fkQualityCutPileup (kTRUE),
\r
215 fkExtraSelections (0),
\r
218 fMinPtCutOnDaughterTracks (0),
\r
219 fEtaCutOnDaughterTracks (0),
\r
221 // - Plots initialisation
\r
222 fListHistCascade(0),
\r
224 // Cascades multiplicity plots
\r
225 fHistCascadeMultiplicityBeforeAnySel(0),
\r
226 fHistCascadeMultiplicityAfterSDDSel(0),
\r
227 fHistCascadeMultiplicityAfterPhysicsSel(0),
\r
228 fHistCascadeMultiplicityForSelEvtNoTPCOnly(0),
\r
229 fHistCascadeMultiplicityForSelEvtNoTPCOnlyNoPileup(0),
\r
230 fHistCascadeMultiplicityAfterVertexCutSel(0),
\r
231 // Tracks multiplicity plots
\r
232 fHistTrackMultiplicityBeforeAnySel(0),
\r
233 fHistTrackMultiplicityAfterSDDSel(0),
\r
234 fHistTrackMultiplicityAfterPhysicsSel(0),
\r
235 fHistTrackMultiplicityForSelEvtNoTPCOnly(0),
\r
236 fHistTrackMultiplicityForSelEvtNoTPCOnlyNoPileup(0),
\r
237 fHistTrackMultiplicityAfterVertexCutSel(0),
\r
238 // Vertex position plots (BestVertex)
\r
239 fHistPVx(0), fHistPVy(0), fHistPVz(0),
\r
240 fHistPVxAnalysis(0), fHistPVyAnalysis(0), fHistPVzAnalysis(0),
\r
241 // TPC cluster distributions for daughters
\r
242 fHistPosV0TPCClusters(0), fHistNegV0TPCClusters(0), fHistBachTPCClusters(0),
\r
243 // Cut's variables distributions
\r
245 fHistDcaXiDaughters(0),
\r
246 fHistDcaBachToPrimVertex(0),
\r
247 fHistXiCosineOfPointingAngle(0),
\r
249 fHistMassLambdaAsCascDghter(0),
\r
250 fHistDcaV0DaughtersXi(0),
\r
251 fHistDcaV0ToPrimVertexXi(0),
\r
252 fHistV0CosineOfPointingAngleXi(0),
\r
253 fHistV0RadiusXi(0),
\r
254 fHistDcaPosToPrimVertexXi(0),
\r
255 fHistDcaNegToPrimVertexXi(0),
\r
256 // Invariant mass distributions
\r
257 fHistMassXiMinus(0), fHistMassXiPlus(0), fHistMassOmegaMinus(0), fHistMassOmegaPlus(0),
\r
258 // Transverse and total momentum distributions
\r
259 fHistXiTransvMom(0), fHistXiTotMom(0), fHistBachTransvMomXi(0), fHistBachTotMomXi(0),
\r
262 fHistV0toXiCosineOfPointingAngle(0),
\r
263 fHistRapXi(0), fHistRapOmega(0),
\r
264 fHistEtaXi(0), fHistEtaBachXi(0), fHistEtaPosXi(0), fHistEtaNegXi(0),
\r
267 f2dHistArmenteros(0),
\r
268 f2dHistEffMassLambdaVsEffMassXiMinus(0), f2dHistEffMassXiVsEffMassOmegaMinus(0),
\r
269 f2dHistEffMassLambdaVsEffMassXiPlus(0), f2dHistEffMassXiVsEffMassOmegaPlus(0),
\r
270 f2dHistXiRadiusVsEffMassXiMinus(0), f2dHistXiRadiusVsEffMassXiPlus(0),
\r
271 f2dHistXiRadiusVsEffMassOmegaMinus(0), f2dHistXiRadiusVsEffMassOmegaPlus(0),
\r
272 f2dHistTPCdEdxOfCascDghters(0),
\r
273 f2dHistDcaXiDaughtersvsInvMass(0),
\r
274 f2dHistDcaBachToPrimVertexvsInvMass(0),
\r
275 f2dHistXiCosineOfPointingAnglevsInvMass(0),
\r
276 f2dHistMassLambdaAsCascDghtervsInvMass(0),
\r
277 f2dHistDcaV0DaughtersXivsInvMass(0),
\r
278 f2dHistDcaV0ToPrimVertexXivsInvMass(0),
\r
279 // Containers for cuts study
\r
280 fCFContCascadePIDXiMinus(0),
\r
281 fCFContCascadePIDXiPlus(0),
\r
282 fCFContCascadePIDOmegaMinus(0),
\r
283 fCFContCascadePIDOmegaPlus(0),
\r
284 fCFContCascadeCuts(0)
\r
286 //_____Costructor____
\r
288 // Define input and output slots here
\r
289 // Input slot #0 works with a TChain
\r
290 // DefineInput(0, TChain::Class());
\r
291 // Output slot #1 writes into a TList container (cascade)
\r
292 // default p-p values
\r
293 fV0Sels[0] = 33. ; // max allowed chi2
\r
294 fV0Sels[1] = 0.01; // min allowed impact parameter for the 1st daughter
\r
295 fV0Sels[2] = 0.01; // min allowed impact parameter for the 2nd daughter
\r
296 fV0Sels[3] = 1.5; // max allowed DCA between the daughter tracks
\r
297 fV0Sels[4] = 0.9; // min allowed cosine of V0's pointing angle - This is pT dependent
\r
298 fV0Sels[5] = 0.2; // min radius of the fiducial volume
\r
299 fV0Sels[6] = 200.; // max radius of the fiducial volume
\r
301 fCascSels[0] = 33.; // max allowed chi2 (same as PDC07)
\r
302 fCascSels[1] = 0.01; // min allowed V0 impact parameter
\r
303 fCascSels[2] = 0.008; // "window" around the Lambda mass
\r
304 fCascSels[3] = 0.01; // min allowed bachelor's impact parameter
\r
305 fCascSels[4] = 2.0; // max allowed DCA between the V0 and the bachelor
\r
306 fCascSels[5] = 0.95; // min allowed cosine of the cascade pointing angle
\r
307 fCascSels[6] = 0.2; // min radius of the fiducial volume
\r
308 fCascSels[7] = 100.; // max radius of the fiducial volume
\r
310 // Output slot #0 writes into a TList container (Cascade)
\r
311 DefineOutput(1, TList::Class());
\r
312 DefineOutput(2, AliCFContainer::Class());
\r
313 DefineOutput(3, AliCFContainer::Class());
\r
314 DefineOutput(4, AliCFContainer::Class());
\r
315 DefineOutput(5, AliCFContainer::Class());
\r
316 DefineOutput(6, AliCFContainer::Class());
\r
317 AliLog::SetClassDebugLevel("AliAnalysisTaskCheckCascadepp276",1);
\r
321 //_____Destructor_____
\r
322 AliAnalysisTaskCheckCascadepp276::~AliAnalysisTaskCheckCascadepp276() {
\r
323 // For all TH1, 2, 3 HnSparse and CFContainer are in the fListCascade TList.
\r
324 // They will be deleted when fListCascade is deleted by the TSelector dtor
\r
325 // Because of TList::SetOwner() ...
\r
326 if (fListHistCascade && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fListHistCascade; fListHistCascade = 0x0; }
\r
327 if (fCFContCascadePIDXiMinus && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadePIDXiMinus; fCFContCascadePIDXiMinus = 0x0; }
\r
328 if (fCFContCascadePIDXiPlus && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadePIDXiPlus; fCFContCascadePIDXiPlus = 0x0; }
\r
329 if (fCFContCascadePIDOmegaMinus && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()){ delete fCFContCascadePIDOmegaMinus; fCFContCascadePIDOmegaMinus = 0x0; }
\r
330 if (fCFContCascadePIDOmegaPlus && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadePIDOmegaPlus; fCFContCascadePIDOmegaPlus = 0x0; }
\r
331 if (fCFContCascadeCuts && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadeCuts; fCFContCascadeCuts = 0x0; }
\r
332 if (fESDtrackCuts) { delete fESDtrackCuts; fESDtrackCuts = 0x0; }
\r
336 //________________________________________________________________________
\r
337 void AliAnalysisTaskCheckCascadepp276::UserCreateOutputObjects() {
\r
338 // Create histograms
\r
342 fListHistCascade = new TList();
\r
343 fListHistCascade->SetOwner(); // See http://root.cern.ch/root/html/TCollection.html#TCollection:SetOwner
\r
345 //-----------------------------------------------
\r
346 // Particle Identification Setup (new PID object)
\r
347 //-----------------------------------------------
\r
348 AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
\r
349 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
\r
350 fPIDResponse = inputHandler->GetPIDResponse();
\r
352 // Only used to get the number of primary reconstructed tracks
\r
353 if (fAnalysisType == "ESD" && (! fESDtrackCuts )){
\r
354 fESDtrackCuts = new AliESDtrackCuts();
\r
357 //---------------------------------------------------
\r
358 // Initialize cuts to re-run V0 and cascade vertexers
\r
359 //---------------------------------------------------
\r
360 // Not validated; to be checked
\r
361 fV0Sels[0] = 33. ; // max allowed chi2
\r
362 fV0Sels[1] = 0.01; // min allowed impact parameter for the 1st daughter
\r
363 fV0Sels[2] = 0.01; // min allowed impact parameter for the 2nd daughter
\r
364 fV0Sels[3] = 1.5; // max allowed DCA between the daughter tracks
\r
365 fV0Sels[4] = 0.9; // min allowed cosine of V0's pointing angle
\r
366 fV0Sels[5] = 0.2; // min radius of the fiducial volume
\r
367 fV0Sels[6] = 200.; // max radius of the fiducial volume
\r
369 fCascSels[0] = 33.; // max allowed chi2 (same as PDC07)
\r
370 fCascSels[1] = 0.01; // min allowed V0 impact parameter
\r
371 fCascSels[2] = 0.008; // "window" around the Lambda mass
\r
372 fCascSels[3] = 0.01; // min allowed bachelor's impact parameter
\r
373 fCascSels[4] = 2.0; // max allowed DCA between the V0 and the bachelor
\r
374 fCascSels[5] = 0.95; // min allowed cosine of the cascade pointing angle
\r
375 fCascSels[6] = 0.2; // min radius of the fiducial volume
\r
376 fCascSels[7] = 100.; // max radius of the fiducial volume
\r
378 //----------------------
\r
379 // Initialize the histos
\r
380 //----------------------
\r
382 // - Cascades multiplicity plots
\r
383 if(! fHistCascadeMultiplicityBeforeAnySel) {
\r
384 fHistCascadeMultiplicityBeforeAnySel = new TH1F("fHistCascadeMultiplicityBeforeAnySel",
\r
385 "Cascades per event (before any selections);Nbr of Cascades/Evt;Events",
\r
387 fListHistCascade->Add(fHistCascadeMultiplicityBeforeAnySel);
\r
389 if(! fHistCascadeMultiplicityAfterSDDSel) {
\r
390 fHistCascadeMultiplicityAfterSDDSel = new TH1F("fHistCascadeMultiplicityAfterSDDSel",
\r
391 "Cascades per event (after the SDD selection);Nbr of Cascades/Evt;Events",
\r
393 fListHistCascade->Add(fHistCascadeMultiplicityAfterSDDSel);
\r
395 if(! fHistCascadeMultiplicityAfterPhysicsSel) {
\r
396 fHistCascadeMultiplicityAfterPhysicsSel = new TH1F("fHistCascadeMultiplicityAfterPhysicsSel",
\r
397 "Cascades per event (after physics selection);Nbr of Cascades/Evt;Events",
\r
399 fListHistCascade->Add(fHistCascadeMultiplicityAfterPhysicsSel);
\r
401 if(! fHistCascadeMultiplicityForSelEvtNoTPCOnly) {
\r
402 fHistCascadeMultiplicityForSelEvtNoTPCOnly = new TH1F("fHistCascadeMultiplicityForSelEvtNoTPCOnly",
\r
403 "Cascades per event (for selected events with well-established PV);Nbr of Cascades/Evt;Events",
\r
405 fListHistCascade->Add(fHistCascadeMultiplicityForSelEvtNoTPCOnly);
\r
407 if(! fHistCascadeMultiplicityForSelEvtNoTPCOnlyNoPileup) {
\r
408 fHistCascadeMultiplicityForSelEvtNoTPCOnlyNoPileup = new TH1F("fHistCascadeMultiplicityForSelEvtNoTPCOnlyNoPileup",
\r
409 "Cascades per event (for selected events with well-establisched PV and no pile-up);Nbr of Cascades/Evt;Events",
\r
411 fListHistCascade->Add(fHistCascadeMultiplicityForSelEvtNoTPCOnlyNoPileup);
\r
413 if(! fHistCascadeMultiplicityAfterVertexCutSel) {
\r
414 fHistCascadeMultiplicityAfterVertexCutSel = new TH1F("fHistCascadeMultiplicityAfterVertexCutSel",
\r
415 "Cascades per event (after vertex cut selection);Nbr of Cascades/Evt;Events",
\r
417 fListHistCascade->Add(fHistCascadeMultiplicityAfterVertexCutSel);
\r
419 // - Tracks multiplicity plots
\r
420 if(! fHistTrackMultiplicityBeforeAnySel) {
\r
421 fHistTrackMultiplicityBeforeAnySel = new TH1F("fHistTrackMultiplicityBeforeAnySel",
\r
422 "Tracks per event (before any selections);Nbr of Cascades/Evt;Events",
\r
424 fListHistCascade->Add(fHistTrackMultiplicityBeforeAnySel);
\r
426 if(! fHistTrackMultiplicityAfterSDDSel) {
\r
427 fHistTrackMultiplicityAfterSDDSel = new TH1F("fHistTrackMultiplicityAfterSDDSel",
\r
428 "Tracks per event (after the SDD selection);Nbr of Cascades/Evt;Events",
\r
430 fListHistCascade->Add(fHistTrackMultiplicityAfterSDDSel);
\r
432 if(! fHistTrackMultiplicityAfterPhysicsSel) {
\r
433 fHistTrackMultiplicityAfterPhysicsSel = new TH1F("fHistTrackMultiplicityAfterPhysicsSel",
\r
434 "Tracks per event (after physics selection);Nbr of Cascades/Evt;Events",
\r
436 fListHistCascade->Add(fHistTrackMultiplicityAfterPhysicsSel);
\r
438 if(! fHistTrackMultiplicityForSelEvtNoTPCOnly) {
\r
439 fHistTrackMultiplicityForSelEvtNoTPCOnly = new TH1F("fHistTrackMultiplicityForSelEvtNoTPCOnly",
\r
440 "Tracks per event (for selected events with well-established PV);Nbr of Cascades/Evt;Events",
\r
442 fListHistCascade->Add(fHistTrackMultiplicityForSelEvtNoTPCOnly);
\r
444 if(! fHistTrackMultiplicityForSelEvtNoTPCOnlyNoPileup) {
\r
445 fHistTrackMultiplicityForSelEvtNoTPCOnlyNoPileup = new TH1F("fHistTrackMultiplicityForSelEvtNoTPCOnlyNoPileup",
\r
446 "Tracks per event (for selected events with well-establisched PV and no pile-up);Nbr of Cascades/Evt;Events",
\r
448 fListHistCascade->Add(fHistTrackMultiplicityForSelEvtNoTPCOnlyNoPileup);
\r
450 if(! fHistTrackMultiplicityAfterVertexCutSel) {
\r
451 fHistTrackMultiplicityAfterVertexCutSel = new TH1F("fHistTrackMultiplicityAfterVertexCutSel",
\r
452 "Tracks per event (after vertex cut selection);Nbr of Cascades/Evt;Events",
\r
454 fListHistCascade->Add(fHistTrackMultiplicityAfterVertexCutSel);
\r
456 // - Vertex position plots
\r
458 fHistPVx = new TH1F("fHistPVx", "Best PV position in x; x (cm); Events", 2000, -0.5, 0.5);
\r
459 fListHistCascade->Add(fHistPVx);
\r
462 fHistPVy = new TH1F("fHistPVy", "Best PV position in y; y (cm); Events", 2000, -0.5, 0.5);
\r
463 fListHistCascade->Add(fHistPVy);
\r
466 fHistPVz = new TH1F("fHistPVz", "Best PV position in z; z (cm); Events", 400, -20, 20);
\r
467 fListHistCascade->Add(fHistPVz);
\r
469 if(! fHistPVxAnalysis ){
\r
470 fHistPVxAnalysis = new TH1F("fHistPVxAnalysis", "Best PV position in x (after events selections); x (cm); Events", 2000, -0.5, 0.5);
\r
471 fListHistCascade->Add(fHistPVxAnalysis);
\r
473 if(! fHistPVyAnalysis ){
\r
474 fHistPVyAnalysis = new TH1F("fHistPVyAnalysis", "Best PV position in y (after events selections); y (cm); Events", 2000, -0.5, 0.5);
\r
475 fListHistCascade->Add(fHistPVyAnalysis);
\r
477 if(! fHistPVzAnalysis ){
\r
478 fHistPVzAnalysis = new TH1F("fHistPVzAnalysis", "Best PV position in z (after events selections); z (cm); Events", 400, -20, 20);
\r
479 fListHistCascade->Add(fHistPVzAnalysis);
\r
481 // - TPC clusetr sdistributions for daughters (histos for events containing at least ONE CASCADE)
\r
482 if(! fHistPosV0TPCClusters ){
\r
483 fHistPosV0TPCClusters = new TH1F("fHistPosV0TPCClusters", "TPC clusters for Pos. V0 daughter track, in Casc; Nbr of TPC clusters (V0 Pos.); Track counts", 165, 0.0, 165.0);
\r
484 fListHistCascade->Add(fHistPosV0TPCClusters);
\r
486 if(! fHistNegV0TPCClusters ){
\r
487 fHistNegV0TPCClusters = new TH1F("fHistNegV0TPCClusters", "TPC clusters for Neg. V0 daughter track, in Casc; Nbr of TPC clusters (V0 Neg.); Track counts", 165, 0.0, 165.0);
\r
488 fListHistCascade->Add(fHistNegV0TPCClusters);
\r
490 if(! fHistBachTPCClusters ){
\r
491 fHistBachTPCClusters = new TH1F("fHistBachTPCClusters", "TPC clusters for Bachelor track; Nbr of TPC clusters (Bach); Track counts", 165, 0.0, 165.0);
\r
492 fListHistCascade->Add(fHistBachTPCClusters);
\r
494 // - Cut's variables distributions (typical histos for cascades): as example only for the Xi (both particle and anti-particle)
\r
495 if(! fHistEffMassXi) {
\r
496 fHistEffMassXi = new TH1F("fHistEffMassXi", "Xi candidates; Invariant Mass (GeV/c^{2}); Counts", 400, 1.2, 2.0);
\r
497 fListHistCascade->Add(fHistEffMassXi);
\r
499 if(! fHistDcaXiDaughters ){
\r
500 fHistDcaXiDaughters = new TH1F("fHistDcaXiDaughters", "DCA between Xi daughters; DCA (cm); Counts", 210, 0., 2.1);
\r
501 fListHistCascade->Add(fHistDcaXiDaughters);
\r
503 if(! fHistDcaBachToPrimVertex) {
\r
504 fHistDcaBachToPrimVertex = new TH1F("fHistDcaBachToPrimVertex", "Impact parameter of Bach. to Prim. Vertex; DCA (cm); Counts", 250, 0., 0.25);
\r
505 fListHistCascade->Add(fHistDcaBachToPrimVertex);
\r
507 if(! fHistXiCosineOfPointingAngle) {
\r
508 fHistXiCosineOfPointingAngle = new TH1F("fHistXiCosineOfPointingAngle", "Cosine of Xi Pointing Angle; Cos (Xi Point.Angl); Counts", 601, 0.94, 1.0001);
\r
509 fListHistCascade->Add(fHistXiCosineOfPointingAngle);
\r
511 if(! fHistXiRadius ){
\r
512 fHistXiRadius = new TH1F("fHistXiRadius", "Cascade decay transv. radius; r (cm); Counts" , 2050, 0., 205.0);
\r
513 fListHistCascade->Add(fHistXiRadius);
\r
515 if(! fHistMassLambdaAsCascDghter) {
\r
516 fHistMassLambdaAsCascDghter = new TH1F("fHistMassLambdaAsCascDghter", "#Lambda associated to cascade candidates; Eff. Mass (GeV/c^{2}); Counts", 300, 1.0, 1.3);
\r
517 fListHistCascade->Add(fHistMassLambdaAsCascDghter);
\r
519 if(! fHistDcaV0DaughtersXi) {
\r
520 fHistDcaV0DaughtersXi = new TH1F("fHistDcaV0DaughtersXi", "DCA between V0 daughters, in cascade; DCA (cm); Counts", 320, 0., 1.6);
\r
521 fListHistCascade->Add(fHistDcaV0DaughtersXi);
\r
523 if(! fHistDcaV0ToPrimVertexXi) {
\r
524 fHistDcaV0ToPrimVertexXi = new TH1F("fHistDcaV0ToPrimVertexXi", "Impact parameter of V0 to Prim. Vertex, in cascade; DCA (cm); Counts", 200, 0., 1.);
\r
525 fListHistCascade->Add(fHistDcaV0ToPrimVertexXi);
\r
527 if(! fHistV0CosineOfPointingAngleXi) {
\r
528 fHistV0CosineOfPointingAngleXi = new TH1F("fHistV0CosineOfPointingAngleXi", "Cosine of V0 Pointing Angle, in cascade; Cos(V0 Point. Angl); Counts", 201, 0.8, 1.001);
\r
529 fListHistCascade->Add(fHistV0CosineOfPointingAngleXi);
\r
531 if(! fHistV0RadiusXi) {
\r
532 fHistV0RadiusXi = new TH1F("fHistV0RadiusXi", "V0 decay radius, in cascade; radius (cm); Counts", 2050, 0., 205.0);
\r
533 fListHistCascade->Add(fHistV0RadiusXi);
\r
535 if(! fHistDcaPosToPrimVertexXi) {
\r
536 fHistDcaPosToPrimVertexXi = new TH1F("fHistDcaPosToPrimVertexXi", "Impact parameter of V0 pos daughter to Prim. Vertex; DCA (cm); Counts", 300, 0, 3);
\r
537 fListHistCascade->Add(fHistDcaPosToPrimVertexXi);
\r
539 if(! fHistDcaNegToPrimVertexXi) {
\r
540 fHistDcaNegToPrimVertexXi = new TH1F("fHistDcaNegToPrimVertexXi", "Impact parameter of V0 neg daughter to Prim. Vertex; DCA (cm); Counts", 300, 0, 3);
\r
541 fListHistCascade->Add(fHistDcaNegToPrimVertexXi);
\r
543 // - Effective mass histos for cascades.
\r
545 if(! fHistMassXiMinus) {
\r
546 fHistMassXiMinus = new TH1F("fHistMassXiMinus", "#Xi^{-} candidates; M( #Lambda , #pi^{-} ) (GeV/c^{2});Counts", 400, 1.2, 2.0);
\r
547 fListHistCascade->Add(fHistMassXiMinus);
\r
549 if(! fHistMassXiPlus) {
\r
550 fHistMassXiPlus = new TH1F("fHistMassXiPlus", "#Xi^{+} candidates; M( #bar{#Lambda}^{0} , #pi^{+} ) (GeV/c^{2});Counts", 400, 1.2, 2.0);
\r
551 fListHistCascade->Add(fHistMassXiPlus);
\r
553 if(! fHistMassOmegaMinus) {
\r
554 fHistMassOmegaMinus = new TH1F("fHistMassOmegaMinus", "#Omega^{-} candidates; M( #Lambda , K^{-} ) (GeV/c^{2});Counts", 500, 1.5, 2.5);
\r
555 fListHistCascade->Add(fHistMassOmegaMinus);
\r
557 if(! fHistMassOmegaPlus) {
\r
558 fHistMassOmegaPlus = new TH1F("fHistMassOmegaPlus", "#Omega^{+} candidates;M( #bar{#Lambda}^{0} , K^{+} ) (GeV/c^{2}); Counts", 500, 1.5, 2.5);
\r
559 fListHistCascade->Add(fHistMassOmegaPlus);
\r
561 // - Transverse and total momentum distributions
\r
562 if(! fHistXiTransvMom ){
\r
563 fHistXiTransvMom = new TH1F("fHistXiTransvMom", "#Xi transverse momentum (cand. around the mass peak); p_{t}(#Xi) (GeV/c); Counts", 100, 0.0, 10.0);
\r
564 fListHistCascade->Add(fHistXiTransvMom);
\r
566 if(! fHistXiTotMom ){
\r
567 fHistXiTotMom = new TH1F("fHistXiTotMom", "#Xi momentum norm (cand. around the mass peak); p_{tot}(#Xi) (GeV/c); Counts", 150, 0.0, 15.0);
\r
568 fListHistCascade->Add(fHistXiTotMom);
\r
570 if(! fHistBachTransvMomXi ){
\r
571 fHistBachTransvMomXi = new TH1F("fHistBachTransvMomXi", "#Xi Bach. transverse momentum (cand. around the mass peak); p_{t}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0);
\r
572 fListHistCascade->Add(fHistBachTransvMomXi);
\r
574 if(! fHistBachTotMomXi ){
\r
575 fHistBachTotMomXi = new TH1F("fHistBachTotMomXi", "#Xi Bach. momentum norm (cand. around the mass peak); p_{tot}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0);
\r
576 fListHistCascade->Add(fHistBachTotMomXi);
\r
578 // - Others QA plots
\r
580 if(! fHistChargeXi ){
\r
581 fHistChargeXi = new TH1F("fHistChargeXi", "Charge of Xi candidates; Sign; Counts", 5, -2.0, 3.0);
\r
582 fListHistCascade->Add(fHistChargeXi);
\r
584 if(! fHistV0toXiCosineOfPointingAngle) {
\r
585 fHistV0toXiCosineOfPointingAngle = new TH1F("fHistV0toXiCosineOfPointingAngle", "Cos. of V0 Ptng Angl / Xi vtx ; Cos(V0 Point. Angl / Xi vtx); Counts", 1101, 0.89, 1.0001);
\r
586 fListHistCascade->Add(fHistV0toXiCosineOfPointingAngle);
\r
589 fHistRapXi = new TH1F("fHistRapXi", "Rapidity of #Xi candidates (around the mass peak); y; Counts", 20, -1.0, 1.0);
\r
590 fListHistCascade->Add(fHistRapXi);
\r
592 if(! fHistRapOmega ){
\r
593 fHistRapOmega = new TH1F("fHistRapOmega", "Rapidity of #Omega candidates (around the mass peak); y; Counts", 20, -1.0, 1.0);
\r
594 fListHistCascade->Add(fHistRapOmega);
\r
597 fHistEtaXi = new TH1F("fHistEtaXi", "Pseudo-rap. of #Xi candidates (around the mass peak); #eta; Counts", 20, -1.0, 1.0);
\r
598 fListHistCascade->Add(fHistEtaXi);
\r
600 if(! fHistEtaBachXi){
\r
601 fHistEtaBachXi = new TH1F("fHistEtaBachXi", "Pseudo-rap. of #Xi bachelor; #eta; Counts", 40, -2.0, 2.0);
\r
602 fListHistCascade->Add(fHistEtaBachXi);
\r
604 if(! fHistEtaPosXi){
\r
605 fHistEtaPosXi = new TH1F("fHistEtaPosXi", "Pseudo-rap. of #Xi positive meson daughter; #eta; Counts", 40, -2.0, 2.0);
\r
606 fListHistCascade->Add(fHistEtaPosXi);
\r
608 if(! fHistEtaNegXi){
\r
609 fHistEtaNegXi = new TH1F("fHistEtaNegXi", "Pseudo-rap. of #Xi negative meson daughter; #eta; Counts", 40, -2.0, 2.0);
\r
610 fListHistCascade->Add(fHistEtaNegXi);
\r
612 if(! fHistThetaXi ){
\r
613 fHistThetaXi = new TH1F("fHistThetaXi", "#theta of #Xi candidates (around the mass peak); #theta (deg); Counts", 180, 0., 180.0);
\r
614 fListHistCascade->Add(fHistThetaXi);
\r
617 fHistPhiXi = new TH1F("fHistPhiXi", "#phi of #Xi candidates (around the mass peak); #phi (deg); Counts", 360, 0., 360.);
\r
618 fListHistCascade->Add(fHistPhiXi);
\r
620 if(! f2dHistArmenteros) {
\r
621 f2dHistArmenteros = new TH2F("f2dHistArmenteros", "#alpha_{Arm}(casc. cand.) Vs Pt_{Arm}(casc. cand.); #alpha_{Arm}; Pt_{Arm} (GeV/c)", 140, -1.2, 1.2, 300, 0., 0.3);
\r
622 fListHistCascade->Add(f2dHistArmenteros);
\r
625 if(! f2dHistEffMassLambdaVsEffMassXiMinus) {
\r
626 f2dHistEffMassLambdaVsEffMassXiMinus = new TH2F("f2dHistEffMassLambdaVsEffMassXiMinus", "M_{#Lambda} Vs M_{#Xi^{-} candidates}; Inv. M_{#Lambda^{0}} (GeV/c^{2}); M( #Lambda , #pi^{-} ) (GeV/c^{2})", 300, 1.1, 1.13, 400, 1.2, 2.0);
\r
627 fListHistCascade->Add(f2dHistEffMassLambdaVsEffMassXiMinus);
\r
629 if(! f2dHistEffMassXiVsEffMassOmegaMinus) {
\r
630 f2dHistEffMassXiVsEffMassOmegaMinus = new TH2F("f2dHistEffMassXiVsEffMassOmegaMinus", "M_{#Xi^{-} candidates} Vs M_{#Omega^{-} candidates}; M( #Lambda , #pi^{-} ) (GeV/c^{2}); M( #Lambda , K^{-} ) (GeV/c^{2})", 400, 1.2, 2.0, 500, 1.5, 2.5);
\r
631 fListHistCascade->Add(f2dHistEffMassXiVsEffMassOmegaMinus);
\r
633 if(! f2dHistEffMassLambdaVsEffMassXiPlus) {
\r
634 f2dHistEffMassLambdaVsEffMassXiPlus = new TH2F("f2dHistEffMassLambdaVsEffMassXiPlus", "M_{#Lambda} Vs M_{#Xi^{+} candidates}; Inv. M_{#Lambda^{0}} (GeV/c^{2}); M( #Lambda , #pi^{+} ) (GeV/c^{2})", 300, 1.1, 1.13, 400, 1.2, 2.0);
\r
635 fListHistCascade->Add(f2dHistEffMassLambdaVsEffMassXiPlus);
\r
637 if(! f2dHistEffMassXiVsEffMassOmegaPlus) {
\r
638 f2dHistEffMassXiVsEffMassOmegaPlus = new TH2F("f2dHistEffMassXiVsEffMassOmegaPlus", "M_{#Xi^{+} candidates} Vs M_{#Omega^{+} candidates}; M( #Lambda , #pi^{+} ) (GeV/c^{2}); M( #Lambda , K^{+} ) (GeV/c^{2})", 400, 1.2, 2.0, 500, 1.5, 2.5);
\r
639 fListHistCascade->Add(f2dHistEffMassXiVsEffMassOmegaPlus);
\r
641 if(! f2dHistXiRadiusVsEffMassXiMinus) {
\r
642 f2dHistXiRadiusVsEffMassXiMinus = new TH2F("f2dHistXiRadiusVsEffMassXiMinus", "Transv. R_{Xi Decay} Vs M_{#Xi^{-} candidates}; r_{cascade} (cm); M( #Lambda , #pi^{-} ) (GeV/c^{2})", 450, 0., 45.0, 400, 1.2, 2.0);
\r
643 fListHistCascade->Add(f2dHistXiRadiusVsEffMassXiMinus);
\r
645 if(! f2dHistXiRadiusVsEffMassXiPlus) {
\r
646 f2dHistXiRadiusVsEffMassXiPlus = new TH2F("f2dHistXiRadiusVsEffMassXiPlus", "Transv. R_{Xi Decay} Vs M_{#Xi^{+} candidates}; r_{cascade} (cm); M( #Lambda , #pi^{+} ) (GeV/c^{2})", 450, 0., 45.0, 400, 1.2, 2.0);
\r
647 fListHistCascade->Add(f2dHistXiRadiusVsEffMassXiPlus);
\r
649 if(! f2dHistXiRadiusVsEffMassOmegaMinus) {
\r
650 f2dHistXiRadiusVsEffMassOmegaMinus = new TH2F("f2dHistXiRadiusVsEffMassOmegaMinus", "Transv. R_{Xi Decay} Vs M_{#Omega^{-} candidates}; r_{cascade} (cm); M( #Lambda , K^{-} ) (GeV/c^{2}) ", 450, 0., 45.0, 500, 1.5, 2.5);
\r
651 fListHistCascade->Add(f2dHistXiRadiusVsEffMassOmegaMinus);
\r
653 if(! f2dHistXiRadiusVsEffMassOmegaPlus) {
\r
654 f2dHistXiRadiusVsEffMassOmegaPlus = new TH2F("f2dHistXiRadiusVsEffMassOmegaPlus", "Transv. R_{Xi Decay} Vs M_{#Omega^{+} candidates}; r_{cascade} (cm); M( #Lambda , K^{+} ) (GeV/c^{2}) ", 450, 0., 45.0, 500, 1.5, 2.5);
\r
655 fListHistCascade->Add(f2dHistXiRadiusVsEffMassOmegaPlus);
\r
657 if(! f2dHistTPCdEdxOfCascDghters){
\r
658 f2dHistTPCdEdxOfCascDghters = new TH2F("f2dHistTPCdEdxOfCascDghters", "TPC dE/dx of the cascade daughters; charge x || #vec{p}_{TPC inner wall}(Casc. daughter) || (GeV/c); TPC signal (ADC)", 2000, -10.0, 10.0, 450, 0., 900.);
\r
659 fListHistCascade->Add(f2dHistTPCdEdxOfCascDghters);
\r
661 if(! f2dHistDcaXiDaughtersvsInvMass){
\r
662 f2dHistDcaXiDaughtersvsInvMass = new TH2F("f2dHistDcaXiDaughtersvsInvMass", "DCA between Xi Daughters; DCA (cm); Number of Cascades", 100, 0., 0.5, 400, 1.2, 2.0);
\r
663 fListHistCascade->Add(f2dHistDcaXiDaughtersvsInvMass);
\r
665 if(! f2dHistDcaBachToPrimVertexvsInvMass) {
\r
666 f2dHistDcaBachToPrimVertexvsInvMass = new TH2F("f2dHistDcaBachToPrimVertexvsInvMass", "DCA of Bach. to Prim. Vertex; DCA (cm); Number of Cascades", 250, 0., 0.25, 400, 1.2, 2.0);
\r
667 fListHistCascade->Add(f2dHistDcaBachToPrimVertexvsInvMass);
\r
669 if(! f2dHistXiCosineOfPointingAnglevsInvMass){
\r
670 f2dHistXiCosineOfPointingAnglevsInvMass = new TH2F("f2dHistXiCosineOfPointingAnglevsInvMass", "Cosine of Xi Pointing Angle; Cos (Xi Point.Angl); Number of Xis", 200, 0.99, 1.0, 400, 1.2, 2.0);
\r
671 fListHistCascade->Add(f2dHistXiCosineOfPointingAnglevsInvMass);
\r
673 if(! f2dHistMassLambdaAsCascDghtervsInvMass){
\r
674 f2dHistMassLambdaAsCascDghtervsInvMass = new TH2F("f2dHistMassLambdaAsCascDghtervsInvMass","#Lambda associated to Casc. candidates; Eff. Mass (GeV/c^{2}); Counts", 300, 1.00, 1.3, 400, 1.2, 2.0);
\r
675 fListHistCascade->Add(f2dHistMassLambdaAsCascDghtervsInvMass);
\r
677 if(! f2dHistDcaV0DaughtersXivsInvMass){
\r
678 f2dHistDcaV0DaughtersXivsInvMass = new TH2F("f2dHistDcaV0DaughtersXivsInvMass", "DCA between V0 daughters, in cascade; DCA (cm); Number of V0s", 120, 0., 0.6, 400, 1.2, 2.0);
\r
679 fListHistCascade->Add(f2dHistDcaV0DaughtersXivsInvMass);
\r
681 if(! f2dHistDcaV0ToPrimVertexXivsInvMass){
\r
682 f2dHistDcaV0ToPrimVertexXivsInvMass = new TH2F("f2dHistDcaV0ToPrimVertexXivsInvMass", "DCA of V0 to Prim. Vertex, in cascade; DCA (cm); Number of Cascades", 200, 0., 1., 400, 1.2, 2.0);
\r
683 fListHistCascade->Add(f2dHistDcaV0ToPrimVertexXivsInvMass);
\r
685 // - CFContainer PID study Xi minus
\r
686 if(!fCFContCascadePIDXiMinus) {
\r
687 const Int_t lNbSteps = 7 ;
\r
688 const Int_t lNbVariables = 3 ;
\r
689 //Array for the number of bins in each dimension :
\r
690 Int_t lNbBinsPerVar[3] = {0};
\r
691 lNbBinsPerVar[0] = 100;
\r
692 lNbBinsPerVar[1] = 800;
\r
693 lNbBinsPerVar[2] = 22;
\r
694 if (fkSDDSelectionOn) {
\r
695 if (fwithSDD) fCFContCascadePIDXiMinus = new AliCFContainer(Form("fCFContCascadePIDXiMinus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDon",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Xi^{-} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
696 else if (!fwithSDD) fCFContCascadePIDXiMinus = new AliCFContainer(Form("fCFContCascadePIDXiMinus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDoff",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Xi^{-} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
697 } else if (!fkSDDSelectionOn) fCFContCascadePIDXiMinus = new AliCFContainer(Form("fCFContCascadePIDXiMinus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_woSDD",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Xi^{-} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
698 //Setting the bin limits
\r
699 fCFContCascadePIDXiMinus->SetBinLimits(0, 0.0 , 10.0 ); // Pt(Cascade)
\r
700 fCFContCascadePIDXiMinus->SetBinLimits(1, 1.2 , 2.0 ); // Xi Effective mass
\r
701 fCFContCascadePIDXiMinus->SetBinLimits(2, -1.1 , 1.1 ); // Rapidity
\r
702 //Setting the step title : one per PID case
\r
703 fCFContCascadePIDXiMinus->SetStepTitle(0, "No PID");
\r
704 fCFContCascadePIDXiMinus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
\r
705 fCFContCascadePIDXiMinus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
\r
706 fCFContCascadePIDXiMinus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
\r
707 fCFContCascadePIDXiMinus->SetStepTitle(4, "Comb. PID / Bachelor");
\r
708 fCFContCascadePIDXiMinus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
\r
709 fCFContCascadePIDXiMinus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
\r
710 //Setting the variable title, per axis
\r
711 fCFContCascadePIDXiMinus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
\r
712 fCFContCascadePIDXiMinus->SetVarTitle(1, "M( #Lambda , #pi^{-} ) (GeV/c^{2})");
\r
713 fCFContCascadePIDXiMinus->SetVarTitle(2, "Y_{#Xi}");
\r
714 fListHistCascade->Add(fCFContCascadePIDXiMinus);
\r
716 // - CFContainer PID study Xi plus
\r
717 if (!fCFContCascadePIDXiPlus) {
\r
718 const Int_t lNbSteps = 7 ;
\r
719 const Int_t lNbVariables = 3 ;
\r
720 //Array for the number of bins in each dimension :
\r
721 Int_t lNbBinsPerVar[3] = {0};
\r
722 lNbBinsPerVar[0] = 100;
\r
723 lNbBinsPerVar[1] = 800;
\r
724 lNbBinsPerVar[2] = 22;
\r
725 if (fkSDDSelectionOn) {
\r
726 if (fwithSDD) fCFContCascadePIDXiPlus = new AliCFContainer(Form("fCFContCascadePIDXiPlus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDon",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Xi^{+} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
727 else if (!fwithSDD) fCFContCascadePIDXiPlus = new AliCFContainer(Form("fCFContCascadePIDXiPlus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDoff",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Xi^{+} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
728 } else if (!fkSDDSelectionOn) fCFContCascadePIDXiPlus = new AliCFContainer(Form("fCFContCascadePIDXiPlus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_woSDD",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Xi^{+} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
729 //Setting the bin limits
\r
730 fCFContCascadePIDXiPlus->SetBinLimits(0, 0.0 , 10.0 ); // Pt(Cascade)
\r
731 fCFContCascadePIDXiPlus->SetBinLimits(1, 1.2 , 2.0 ); // Xi Effective mass
\r
732 fCFContCascadePIDXiPlus->SetBinLimits(2, -1.1 , 1.1 ); // Rapidity
\r
733 //Setting the step title : one per PID case
\r
734 fCFContCascadePIDXiPlus->SetStepTitle(0, "No PID");
\r
735 fCFContCascadePIDXiPlus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
\r
736 fCFContCascadePIDXiPlus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
\r
737 fCFContCascadePIDXiPlus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
\r
738 fCFContCascadePIDXiPlus->SetStepTitle(4, "Comb. PID / Bachelor");
\r
739 fCFContCascadePIDXiPlus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
\r
740 fCFContCascadePIDXiPlus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
\r
741 //Setting the variable title, per axis
\r
742 fCFContCascadePIDXiPlus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
\r
743 fCFContCascadePIDXiPlus->SetVarTitle(1, "M( #Lambda , #pi^{+} ) (GeV/c^{2})");
\r
744 fCFContCascadePIDXiPlus->SetVarTitle(2, "Y_{#Xi}");
\r
745 fListHistCascade->Add(fCFContCascadePIDXiPlus);
\r
747 // - CFContainer PID study Omega minus
\r
748 if(!fCFContCascadePIDOmegaMinus) {
\r
749 const Int_t lNbSteps = 7 ;
\r
750 const Int_t lNbVariables = 3 ;
\r
751 //Array for the number of bins in each dimension :
\r
752 Int_t lNbBinsPerVar[3] = {0};
\r
753 lNbBinsPerVar[0] = 100;
\r
754 lNbBinsPerVar[1] = 1000;
\r
755 lNbBinsPerVar[2] = 22;
\r
756 if (fkSDDSelectionOn) {
\r
757 if (fwithSDD) fCFContCascadePIDOmegaMinus = new AliCFContainer(Form("fCFContCascadePIDOmegaMinus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDon",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Omega^{-} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
758 else if (!fwithSDD) fCFContCascadePIDOmegaMinus = new AliCFContainer(Form("fCFContCascadePIDOmegaMinus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDoff",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Omega^{-} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
759 } else if (!fkSDDSelectionOn) fCFContCascadePIDOmegaMinus = new AliCFContainer(Form("fCFContCascadePIDOmegaMinus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_woSDD",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Omega^{-} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
760 //Setting the bin limits
\r
761 fCFContCascadePIDOmegaMinus->SetBinLimits(0, 0.0 , 10.0 ); // Pt(Cascade)
\r
762 fCFContCascadePIDOmegaMinus->SetBinLimits(1, 1.5 , 2.5 ); // Omega Effective mass
\r
763 fCFContCascadePIDOmegaMinus->SetBinLimits(2, -1.1 , 1.1 ); // Rapidity
\r
764 //Setting the step title : one per PID case
\r
765 fCFContCascadePIDOmegaMinus->SetStepTitle(0, "No PID");
\r
766 fCFContCascadePIDOmegaMinus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
\r
767 fCFContCascadePIDOmegaMinus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
\r
768 fCFContCascadePIDOmegaMinus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
\r
769 fCFContCascadePIDOmegaMinus->SetStepTitle(4, "Comb. PID / Bachelor");
\r
770 fCFContCascadePIDOmegaMinus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
\r
771 fCFContCascadePIDOmegaMinus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
\r
772 //Setting the variable title, per axis
\r
773 fCFContCascadePIDOmegaMinus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
\r
774 fCFContCascadePIDOmegaMinus->SetVarTitle(1, "M( #Lambda , K^{-} ) (GeV/c^{2})");
\r
775 fCFContCascadePIDOmegaMinus->SetVarTitle(2, "Y_{#Omega}");
\r
776 fListHistCascade->Add(fCFContCascadePIDOmegaMinus);
\r
778 // - CFContainer PID study Omega plus
\r
779 if(!fCFContCascadePIDOmegaPlus) {
\r
780 const Int_t lNbSteps = 7 ;
\r
781 const Int_t lNbVariables = 3 ;
\r
782 //Array for the number of bins in each dimension :
\r
783 Int_t lNbBinsPerVar[3] = {0};
\r
784 lNbBinsPerVar[0] = 100;
\r
785 lNbBinsPerVar[1] = 1000;
\r
786 lNbBinsPerVar[2] = 22;
\r
787 if (fkSDDSelectionOn) {
\r
788 if (fwithSDD) fCFContCascadePIDOmegaPlus = new AliCFContainer(Form("fCFContCascadePIDOmegaPlus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDon",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Omega^{+} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
789 else if (!fwithSDD) fCFContCascadePIDOmegaPlus = new AliCFContainer(Form("fCFContCascadePIDOmegaPlus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDoff",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Omega^{+} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
790 } else if (!fkSDDSelectionOn) fCFContCascadePIDOmegaPlus = new AliCFContainer(Form("fCFContCascadePIDOmegaPlus_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_woSDD",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Pt_{cascade} Vs M_{#Omega^{+} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
\r
791 //Setting the bin limits
\r
792 fCFContCascadePIDOmegaPlus->SetBinLimits(0, 0.0 , 10.0 ); // Pt(Cascade)
\r
793 fCFContCascadePIDOmegaPlus->SetBinLimits(1, 1.5 , 2.5 ); // Omega Effective mass
\r
794 fCFContCascadePIDOmegaPlus->SetBinLimits(2, -1.1 , 1.1 ); // Rapidity
\r
795 //Setting the step title : one per PID case
\r
796 fCFContCascadePIDOmegaPlus->SetStepTitle(0, "No PID");
\r
797 fCFContCascadePIDOmegaPlus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
\r
798 fCFContCascadePIDOmegaPlus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
\r
799 fCFContCascadePIDOmegaPlus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
\r
800 fCFContCascadePIDOmegaPlus->SetStepTitle(4, "Comb. PID / Bachelor");
\r
801 fCFContCascadePIDOmegaPlus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
\r
802 fCFContCascadePIDOmegaPlus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
\r
803 //Setting the variable title, per axis
\r
804 fCFContCascadePIDOmegaPlus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
\r
805 fCFContCascadePIDOmegaPlus->SetVarTitle(1, "M( #Lambda , K^{+} ) (GeV/c^{2})");
\r
806 fCFContCascadePIDOmegaPlus->SetVarTitle(2, "Y_{#Omega}");
\r
807 fListHistCascade->Add(fCFContCascadePIDOmegaPlus);
\r
809 // - CFContainer: towards the optimisation of topological selections
\r
810 if(! fCFContCascadeCuts) {
\r
811 // Container meant to store all the relevant distributions corresponding to the cut variables.
\r
812 // NB: overflow/underflow of variables on which we want to cut later should be 0!!!
\r
813 const Int_t lNbSteps = 4 ;
\r
814 const Int_t lNbVariables = 19 ;
\r
815 //Array for the number of bins in each dimension :
\r
816 Int_t lNbBinsPerVar[lNbVariables] = {0};
\r
817 lNbBinsPerVar[0] = 25; //DcaCascDaughters : [0.0,2.4,3.0] -> Rec.Cut = 2.0;
\r
818 lNbBinsPerVar[1] = 25; //DcaBachToPrimVertex : [0.0,0.24,100.0] -> Rec.Cut = 0.01;
\r
819 lNbBinsPerVar[2] = 60; //CascCosineOfPointingAngle : [0.94,1.0] -> Rec.Cut = 0.95;
\r
820 lNbBinsPerVar[3] = 40; //CascRadius : [0.0,3.9,1000.0] -> Rec.Cut = 0.2;
\r
821 lNbBinsPerVar[4] = 30; //InvMassLambdaAsCascDghter : [1.1,1.3] -> Rec.Cut = 0.008;
\r
822 lNbBinsPerVar[5] = 20; //DcaV0Daughters : [0.0,2.0] -> Rec.Cut = 1.5;
\r
823 lNbBinsPerVar[6] = 201; //V0CosineOfPointingAngleToXi : [0.89,1.0] -> No Rec.Cut;
\r
824 lNbBinsPerVar[7] = 40; //V0Radius : [0.0,3.9,1000.0] -> Rec.Cut = 0.2;
\r
825 lNbBinsPerVar[8] = 40; //DcaV0ToPrimVertex : [0.0,0.39,110.0] -> Rec.Cut = 0.01;
\r
826 lNbBinsPerVar[9] = 25; //DcaPosToPrimVertex : [0.0,0.24,100.0] -> Rec.Cut = 0.01;
\r
827 lNbBinsPerVar[10] = 25; //DcaNegToPrimVertex : [0.0,0.24,100.0] -> Rec.Cut = 0.01;
\r
828 lNbBinsPerVar[11] = 150; //InvMassXi : 2-MeV/c2 bins
\r
829 lNbBinsPerVar[12] = 120; //InvMassOmega : 2-MeV/c2 bins
\r
830 lNbBinsPerVar[13] = 100; //XiTransvMom : [0.0,10.0]
\r
831 lNbBinsPerVar[14] = 110; //Y(Xi) : 0.02 in rapidity units
\r
832 lNbBinsPerVar[15] = 110; //Y(Omega) : 0.02 in rapidity units
\r
833 lNbBinsPerVar[16] = 112; //Proper lenght of cascade
\r
834 lNbBinsPerVar[17] = 112; //Proper lenght of V0
\r
835 lNbBinsPerVar[18] = 112; //Distance V0-Xi in transverse plane
\r
836 if (fkSDDSelectionOn) {
\r
837 if (fwithSDD) fCFContCascadeCuts = new AliCFContainer(Form("fCFContCascadeCuts_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDon",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Container for Cascade cuts", lNbSteps, lNbVariables, lNbBinsPerVar);
\r
838 else if (!fwithSDD) fCFContCascadeCuts = new AliCFContainer(Form("fCFContCascadeCuts_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_wSDDoff",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Container for Cascade cuts", lNbSteps, lNbVariables, lNbBinsPerVar);
\r
839 } else if (!fkSDDSelectionOn) fCFContCascadeCuts = new AliCFContainer(Form("fCFContCascadeCuts_minnTPCcls%i_vtxlim%.1f-%.1f_minptdghtrk%.1f_etacutdghtrk%.1f_woSDD",fMinnTPCcls,fVtxRange,fVtxRangeMin,fMinPtCutOnDaughterTracks,fEtaCutOnDaughterTracks),"Container for Cascade cuts", lNbSteps, lNbVariables, lNbBinsPerVar);
\r
840 //Setting the bin limits
\r
841 //0 - DcaXiDaughters
\r
842 Double_t *lBinLim0 = new Double_t[ lNbBinsPerVar[0] + 1 ];
\r
843 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;
\r
844 lBinLim0[ lNbBinsPerVar[0] ] = 3.0;
\r
845 fCFContCascadeCuts -> SetBinLimits(0, lBinLim0);
\r
846 delete [] lBinLim0;
\r
847 //1 - DcaToPrimVertexXi
\r
848 Double_t *lBinLim1 = new Double_t[ lNbBinsPerVar[1] + 1 ];
\r
849 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;
\r
850 lBinLim1[ lNbBinsPerVar[1] ] = 100.0;
\r
851 fCFContCascadeCuts -> SetBinLimits(1, lBinLim1);
\r
852 delete [] lBinLim1;
\r
853 //2 - CascCosineOfPointingAngle
\r
854 fCFContCascadeCuts->SetBinLimits(2, 0.94, 1.);
\r
856 Double_t *lBinLim3 = new Double_t[ lNbBinsPerVar[3]+1 ];
\r
857 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 ;
\r
858 lBinLim3[ lNbBinsPerVar[3] ] = 1000.0;
\r
859 fCFContCascadeCuts -> SetBinLimits(3, lBinLim3 );
\r
860 delete [] lBinLim3;
\r
861 //4 - InvMassLambdaAsCascDghter
\r
862 fCFContCascadeCuts->SetBinLimits(4, 1.1, 1.13);
\r
863 //5 - DcaV0Daughters
\r
864 fCFContCascadeCuts -> SetBinLimits(5, 0., 2.);
\r
865 //6 - V0CosineOfPointingAngle
\r
866 fCFContCascadeCuts -> SetBinLimits(6, 0.8, 1.001);
\r
868 Double_t *lBinLim7 = new Double_t[ lNbBinsPerVar[7] + 1];
\r
869 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;
\r
870 lBinLim7[ lNbBinsPerVar[7] ] = 1000.0;
\r
871 fCFContCascadeCuts -> SetBinLimits(7, lBinLim7);
\r
872 delete [] lBinLim7;
\r
873 //8 - DcaV0ToPrimVertex
\r
874 Double_t *lBinLim8 = new Double_t[ lNbBinsPerVar[8]+1 ];
\r
875 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 ;
\r
876 lBinLim8[ lNbBinsPerVar[8] ] = 100.0;
\r
877 fCFContCascadeCuts -> SetBinLimits(8, lBinLim8 );
\r
878 delete [] lBinLim8;
\r
879 //9 - DcaPosToPrimVertex
\r
880 Double_t *lBinLim9 = new Double_t[ lNbBinsPerVar[9]+1 ];
\r
881 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 ;
\r
882 lBinLim9[ lNbBinsPerVar[9] ] = 100.0;
\r
883 fCFContCascadeCuts -> SetBinLimits(9, lBinLim9 );
\r
884 delete [] lBinLim9;
\r
885 //10 - DcaNegToPrimVertex
\r
886 Double_t *lBinLim10 = new Double_t[ lNbBinsPerVar[10]+1 ];
\r
887 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 ;
\r
888 lBinLim10[ lNbBinsPerVar[10] ] = 100.0;
\r
889 fCFContCascadeCuts -> SetBinLimits(10, lBinLim10 ); // DcaPosToPrimVertexXi : 0.0 to 0.25
\r
890 delete [] lBinLim10;
\r
892 fCFContCascadeCuts->SetBinLimits(11, 1.25, 1.40);
\r
893 //12 - InvMassOmega
\r
894 fCFContCascadeCuts->SetBinLimits(12, 1.62, 1.74);
\r
896 fCFContCascadeCuts->SetBinLimits(13, 0.0, 10.0);
\r
898 fCFContCascadeCuts->SetBinLimits(14, -1.1, 1.1);
\r
900 fCFContCascadeCuts->SetBinLimits(15, -1.1, 1.1);
\r
901 //16 - Proper time of cascade
\r
902 Double_t *lBinLim16 = new Double_t[ lNbBinsPerVar[16]+1 ];
\r
903 for(Int_t i=0; i< lNbBinsPerVar[16];i++) lBinLim16[i] = (Double_t) -1. + (110. + 1.0 ) / (lNbBinsPerVar[16] - 1) * (Double_t) i;
\r
904 lBinLim16[ lNbBinsPerVar[16] ] = 2000.0;
\r
905 fCFContCascadeCuts->SetBinLimits(16, lBinLim16);
\r
906 //17 - Proper time of V0
\r
907 fCFContCascadeCuts->SetBinLimits(17, lBinLim16);
\r
908 //18 - Distance V0-Xi in transverse plane
\r
909 fCFContCascadeCuts->SetBinLimits(18, lBinLim16);
\r
910 // Setting the number of steps : one for each cascade species (Xi-, Xi+ and Omega-, Omega+)
\r
911 fCFContCascadeCuts->SetStepTitle(0, "#Xi^{-} candidates");
\r
912 fCFContCascadeCuts->SetStepTitle(1, "#bar{#Xi}^{+} candidates");
\r
913 fCFContCascadeCuts->SetStepTitle(2, "#Omega^{-} candidates");
\r
914 fCFContCascadeCuts->SetStepTitle(3, "#bar{#Omega}^{+} candidates");
\r
915 // Setting the variable title, per axis
\r
916 fCFContCascadeCuts->SetVarTitle(0, "Dca(cascade daughters) (cm)");
\r
917 fCFContCascadeCuts->SetVarTitle(1, "ImpactParamToPV(bachelor) (cm)");
\r
918 fCFContCascadeCuts->SetVarTitle(2, "cos(cascade PA)");
\r
919 fCFContCascadeCuts->SetVarTitle(3, "R_{2d}(cascade decay) (cm)");
\r
920 fCFContCascadeCuts->SetVarTitle(4, "M_{#Lambda}(as casc dghter) (GeV/c^{2})");
\r
921 fCFContCascadeCuts->SetVarTitle(5, "Dca(V0 daughters) in Xi (cm)");
\r
922 fCFContCascadeCuts->SetVarTitle(6, "cos(V0 PA) to cascade vtx");
\r
923 fCFContCascadeCuts->SetVarTitle(7, "R_{2d}(V0 decay) (cm)");
\r
924 fCFContCascadeCuts->SetVarTitle(8, "ImpactParamToPV(V0) (cm)");
\r
925 fCFContCascadeCuts->SetVarTitle(9, "ImpactParamToPV(Pos) (cm)");
\r
926 fCFContCascadeCuts->SetVarTitle(10, "ImpactParamToPV(Neg) (cm)");
\r
927 fCFContCascadeCuts->SetVarTitle(11, "Inv. Mass(Xi) (GeV/c^{2})");
\r
928 fCFContCascadeCuts->SetVarTitle(12, "Inv. Mass(Omega) (GeV/c^{2})");
\r
929 fCFContCascadeCuts->SetVarTitle(13, "pt(cascade) (GeV/c)");
\r
930 fCFContCascadeCuts->SetVarTitle(14, "Y(Xi)");
\r
931 fCFContCascadeCuts->SetVarTitle(15, "Y(Omega)");
\r
932 fCFContCascadeCuts->SetVarTitle(16, "mL/p (cascade) (cm)");
\r
933 fCFContCascadeCuts->SetVarTitle(17, "mL/p (V0) (cm)");
\r
934 fCFContCascadeCuts->SetVarTitle(18, "Distance V0-Cascade in transverse plane (cm)");
\r
935 fListHistCascade->Add(fCFContCascadeCuts);
\r
938 PostData(1, fListHistCascade);
\r
939 PostData(2, fCFContCascadePIDXiMinus);
\r
940 PostData(3, fCFContCascadePIDXiPlus);
\r
941 PostData(4, fCFContCascadePIDOmegaMinus);
\r
942 PostData(5, fCFContCascadePIDOmegaPlus);
\r
943 PostData(6, fCFContCascadeCuts);
\r
944 } // end UserCreateOutputObjects
\r
947 //________________________________________________________________________
\r
948 void AliAnalysisTaskCheckCascadepp276::UserExec(Option_t *) {
\r
950 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\r
951 // Main loop (called for each event)
\r
952 //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\r
955 //Define variables
\r
956 AliESDEvent *lESDevent = 0x0;
\r
957 AliAODEvent *lAODevent = 0x0;
\r
959 //---------------------
\r
960 //Check the PIDresponse
\r
961 if(!fPIDResponse) {
\r
962 AliError("Cannot get pid response");
\r
966 ///////////////////
\r
967 // EVENT SELECTIONS
\r
968 ///////////////////
\r
970 // 1) SDD selection
\r
971 // 2) Physics selection
\r
972 // 3) Select only looking at events with well-established PV
\r
973 // 4) Pileup selection
\r
976 //----------------------
\r
977 // Before any selections
\r
978 //----------------------
\r
979 //- Define the variables
\r
980 Int_t ncascadesBeforeAnySel = 0;
\r
981 Int_t nTrackMultiplicityBeforeAnySel = 0;
\r
982 if (fAnalysisType == "ESD") {
\r
983 // - Load the InputEvent and check
\r
984 lESDevent = dynamic_cast<AliESDEvent*>( InputEvent() );
\r
986 AliWarning("ERROR: lESDevent not available \n");
\r
989 // - Take the number of cascades and tracks before any events selection
\r
990 ncascadesBeforeAnySel = lESDevent->GetNumberOfCascades();
\r
991 nTrackMultiplicityBeforeAnySel = fESDtrackCuts->GetReferenceMultiplicity(lESDevent,AliESDtrackCuts::kTrackletsITSTPC,0.5);
\r
992 } else if (fAnalysisType == "AOD") {
\r
993 // - Load the InputEvent and check
\r
994 lAODevent = dynamic_cast<AliAODEvent*>( InputEvent() );
\r
996 AliWarning("ERROR: lAODevent not available \n");
\r
999 // - Take the number of cascades and tracks before any events selection
\r
1000 ncascadesBeforeAnySel = lAODevent->GetNumberOfCascades();
\r
1001 nTrackMultiplicityBeforeAnySel = -100; //FIXME: I can't find the equivalent method for the AOD
\r
1003 Printf("Analysis type (ESD or AOD) not specified \n");
\r
1006 // - Fill the plots
\r
1007 fHistCascadeMultiplicityBeforeAnySel->Fill(ncascadesBeforeAnySel);
\r
1008 fHistTrackMultiplicityBeforeAnySel->Fill(nTrackMultiplicityBeforeAnySel);
\r
1013 // - Define the variables
\r
1014 Int_t ncascadesAfterSDDSel = 0;
\r
1015 Int_t nTrackMultiplicityAfterSDDSel = 0;
\r
1016 // - Selection for ESD and AOD
\r
1017 if (fAnalysisType == "ESD") {
\r
1018 if (fkSDDSelectionOn) {
\r
1019 TString trcl = lESDevent->GetFiredTriggerClasses();
\r
1020 //cout<<"Fired Trigger Classes: "<<trcl<<endl;
\r
1022 if(!(trcl.Contains("ALLNOTRD"))) {
\r
1023 cout<<"We are selecting events with SDD turn ON. This event has the SDD turn OFF. => RETURN!! (Exclude it)..."<<endl;
\r
1024 PostData(1, fListHistCascade);
\r
1025 PostData(2, fCFContCascadePIDXiMinus);
\r
1026 PostData(3, fCFContCascadePIDXiPlus);
\r
1027 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1028 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1029 PostData(6, fCFContCascadeCuts);
\r
1032 } else if (!fwithSDD){
\r
1033 if((trcl.Contains("ALLNOTRD"))) {
\r
1034 cout<<"We are selecting events with SDD turn OFF. This event has the SDD turn ON. => RETURN!! (Exclude it)..."<<endl;
\r
1035 PostData(1, fListHistCascade);
\r
1036 PostData(2, fCFContCascadePIDXiMinus);
\r
1037 PostData(3, fCFContCascadePIDXiPlus);
\r
1038 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1039 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1040 PostData(6, fCFContCascadeCuts);
\r
1045 // - Take the number of cascades and tracks after the SDD selection
\r
1046 ncascadesAfterSDDSel = lESDevent->GetNumberOfCascades();
\r
1047 nTrackMultiplicityAfterSDDSel = fESDtrackCuts->GetReferenceMultiplicity(lESDevent,AliESDtrackCuts::kTrackletsITSTPC,0.5);
\r
1048 } else if (fAnalysisType == "AOD") {
\r
1049 if (fkSDDSelectionOn) {
\r
1050 TString trcl = lAODevent->GetFiredTriggerClasses();
\r
1052 if(!(trcl.Contains("ALLNOTRD"))) {
\r
1053 PostData(1, fListHistCascade);
\r
1054 PostData(2, fCFContCascadePIDXiMinus);
\r
1055 PostData(3, fCFContCascadePIDXiPlus);
\r
1056 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1057 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1058 PostData(6, fCFContCascadeCuts);
\r
1059 cout<<"We are selecting events with SDD turn ON. This event has the SDD turn OFF. => RETURN!! (Exclude it)..."<<endl;
\r
1062 } else if (!fwithSDD) {
\r
1063 if((trcl.Contains("ALLNOTRD"))) {
\r
1064 PostData(1, fListHistCascade);
\r
1065 PostData(2, fCFContCascadePIDXiMinus);
\r
1066 PostData(3, fCFContCascadePIDXiPlus);
\r
1067 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1068 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1069 PostData(6, fCFContCascadeCuts);
\r
1070 cout<<"We are selecting events with SDD turn OFF. This event has the SDD turn ON. => RETURN!! (Exclude it)..."<<endl;
\r
1075 // - Take the number of cascades and tracks after the SDD selection
\r
1076 ncascadesAfterSDDSel = lAODevent->GetNumberOfCascades();
\r
1077 nTrackMultiplicityAfterSDDSel = -100; //FIXME: I can't find the equivalent method for the AOD
\r
1079 // - Fill the plots
\r
1080 fHistCascadeMultiplicityAfterSDDSel->Fill(ncascadesAfterSDDSel);
\r
1081 fHistTrackMultiplicityAfterSDDSel->Fill(nTrackMultiplicityAfterSDDSel);
\r
1083 //----------------------------------------------
\r
1084 // Physics selection (+ re-vertexer for the ESD)
\r
1085 //----------------------------------------------
\r
1086 // - Define the variables
\r
1087 Int_t ncascadesAfterPhysicsSel = 0;
\r
1088 Int_t nTrackMultiplicityAfterPhysicsSel = 0;
\r
1089 // - Selection for ESD and AOD
\r
1090 if (fAnalysisType == "ESD") {
\r
1091 UInt_t maskIsSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
\r
1092 Bool_t isSelected = 0;
\r
1093 isSelected = (maskIsSelected & AliVEvent::kMB) == AliVEvent::kMB;
\r
1095 PostData(1, fListHistCascade);
\r
1096 PostData(2, fCFContCascadePIDXiMinus);
\r
1097 PostData(3, fCFContCascadePIDXiPlus);
\r
1098 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1099 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1100 PostData(6, fCFContCascadeCuts);
\r
1101 cout<<"We are selecting the events that past tha Physics Selection. This event does not pass the Physics Selection. => RETURN!! (Exclude it)..."<<endl;
\r
1104 // - Take the number of cascades and tracks after physics selection
\r
1105 ncascadesAfterPhysicsSel = lESDevent->GetNumberOfCascades();
\r
1106 nTrackMultiplicityAfterPhysicsSel = fESDtrackCuts->GetReferenceMultiplicity(lESDevent,AliESDtrackCuts::kTrackletsITSTPC,0.5);
\r
1107 // - Cascade vertexer (ESD)
\r
1108 // Relaunch V0 and Cascade vertexers
\r
1109 if (fkRerunV0CascVertexers) {
\r
1110 lESDevent->ResetCascades();
\r
1111 lESDevent->ResetV0s();
\r
1112 AliV0vertexer *lV0vtxer = new AliV0vertexer();
\r
1113 AliCascadeVertexer *lCascVtxer = new AliCascadeVertexer();
\r
1114 //lV0vtxer->GetCuts(fV0Sels);
\r
1115 //lCascVtxer->GetCuts(fCascSels);
\r
1116 lV0vtxer->SetCuts(fV0Sels); // NB don't use SetDefaultCuts!! because it acts on static variables
\r
1117 lCascVtxer->SetCuts(fCascSels);
\r
1118 lV0vtxer->Tracks2V0vertices(lESDevent);
\r
1119 lCascVtxer->V0sTracks2CascadeVertices(lESDevent);
\r
1120 //delete lV0vtxer;
\r
1121 //delete lCascVtxer;
\r
1123 } else if (fAnalysisType == "AOD") {
\r
1124 UInt_t maskIsSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
\r
1125 Bool_t isSelected = 0;
\r
1126 isSelected = (maskIsSelected & AliVEvent::kMB) == AliVEvent::kMB;
\r
1128 PostData(1, fListHistCascade);
\r
1129 PostData(2, fCFContCascadePIDXiMinus);
\r
1130 PostData(3, fCFContCascadePIDXiPlus);
\r
1131 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1132 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1133 PostData(6, fCFContCascadeCuts);
\r
1134 cout<<"We are selecting the events that past tha Physics Selection. This event does not pass the Physics Selection. => RETURN!! (Exclude it)..."<<endl;
\r
1137 // - Take the number of cascades and tracks after the physics selection
\r
1138 ncascadesAfterPhysicsSel = lAODevent->GetNumberOfCascades();
\r
1139 nTrackMultiplicityAfterPhysicsSel = -100; //FIXME: I can't find the equivalent method for the AOD
\r
1141 // - Fill the plots
\r
1142 fHistCascadeMultiplicityAfterPhysicsSel->Fill(ncascadesAfterPhysicsSel);
\r
1143 fHistTrackMultiplicityAfterPhysicsSel->Fill(nTrackMultiplicityAfterPhysicsSel);
\r
1145 //------------------------------
\r
1146 // Well-established PV selection
\r
1147 //------------------------------
\r
1148 // - Define variables
\r
1149 Int_t ncascadesForSelEvtNoTPCOnly = 0;
\r
1150 Int_t nTrackMultiplicityForSelEvtNoTPCOnly = 0;
\r
1151 // - Selection for ESD and AOD
\r
1152 if (fAnalysisType == "ESD") {
\r
1153 // - Vertex coordinates: get the PVs stored in the ESD found with tracks and SPD
\r
1154 const AliESDVertex *lPrimaryTrackingESDVtx = lESDevent->GetPrimaryVertexTracks();
\r
1155 const AliESDVertex *lPrimarySPDVtx = lESDevent->GetPrimaryVertexSPD();
\r
1156 // - Select only looking at events with well-established PV
\r
1157 if (fkQualityCutNoTPConlyPrimVtx) {
\r
1158 if (!lPrimarySPDVtx->GetStatus() && !lPrimaryTrackingESDVtx->GetStatus() ){
\r
1159 AliWarning("Pb / No SPD prim. vertex nor prim. Tracking vertex ... return !");
\r
1160 PostData(1, fListHistCascade);
\r
1161 PostData(2, fCFContCascadePIDXiMinus);
\r
1162 PostData(3, fCFContCascadePIDXiPlus);
\r
1163 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1164 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1165 PostData(6, fCFContCascadeCuts);
\r
1169 // - Take the number of cascades and tracks after TPConly selection
\r
1170 ncascadesForSelEvtNoTPCOnly = lESDevent->GetNumberOfCascades();
\r
1171 nTrackMultiplicityForSelEvtNoTPCOnly = fESDtrackCuts->GetReferenceMultiplicity(lESDevent,AliESDtrackCuts::kTrackletsITSTPC,0.5);
\r
1172 } else if (fAnalysisType == "AOD") {
\r
1173 // - Vertex coordinates: get the PVs stored in the AOD found with tracks and SPD
\r
1174 const AliAODVertex *lPrimarySPDVtx = lAODevent->GetPrimaryVertexSPD();
\r
1175 const AliAODVertex *lPrimaryTrackingAODVtx = lAODevent->GetPrimaryVertex();
\r
1176 // - Select only looking at events with well-established PV
\r
1177 if (fkQualityCutNoTPConlyPrimVtx) {
\r
1178 if (!lPrimarySPDVtx && !lPrimaryTrackingAODVtx) {
\r
1179 AliWarning("Pb / No SPD prim. vertex nor prim. Tracking vertex ... return !");
\r
1180 PostData(1, fListHistCascade);
\r
1181 PostData(2, fCFContCascadePIDXiMinus);
\r
1182 PostData(3, fCFContCascadePIDXiPlus);
\r
1183 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1184 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1185 PostData(6, fCFContCascadeCuts);
\r
1189 // - Take the number of cascades and tracks after TPConly selection
\r
1190 ncascadesForSelEvtNoTPCOnly = lAODevent->GetNumberOfCascades();
\r
1191 nTrackMultiplicityForSelEvtNoTPCOnly = -100; //FIXME: I can't find the equivalent method for the AOD
\r
1193 // - Fill the plots
\r
1194 fHistCascadeMultiplicityForSelEvtNoTPCOnly->Fill(ncascadesForSelEvtNoTPCOnly);
\r
1195 fHistTrackMultiplicityForSelEvtNoTPCOnly->Fill(nTrackMultiplicityForSelEvtNoTPCOnly);
\r
1197 //----------------
\r
1198 // Pilup selection
\r
1199 //----------------
\r
1200 // - Define variables
\r
1201 Int_t ncascadesForSelEvtNoTPCOnlyNoPileup = 0;
\r
1202 Int_t nTrackMultiplicityForSelEvtNoTPCOnlyNoPileup = 0;
\r
1203 // - Selection for ESD and AOD
\r
1204 if (fAnalysisType == "ESD") {
\r
1205 if (fkQualityCutPileup) {
\r
1206 if(lESDevent->IsPileupFromSPD()){
\r
1207 AliWarning("Pb / Pile-up event ... return!");
\r
1208 PostData(1, fListHistCascade);
\r
1209 PostData(2, fCFContCascadePIDXiMinus);
\r
1210 PostData(3, fCFContCascadePIDXiPlus);
\r
1211 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1212 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1213 PostData(6, fCFContCascadeCuts);
\r
1217 // - Take the number of cascades and tracks after Pileup selection
\r
1218 ncascadesForSelEvtNoTPCOnlyNoPileup = lESDevent->GetNumberOfCascades();
\r
1219 nTrackMultiplicityForSelEvtNoTPCOnlyNoPileup = fESDtrackCuts->GetReferenceMultiplicity(lESDevent,AliESDtrackCuts::kTrackletsITSTPC,0.5);
\r
1220 } else if (fAnalysisType == "AOD") {
\r
1221 if (fkQualityCutPileup) {
\r
1222 if(lAODevent->IsPileupFromSPD()){
\r
1223 AliWarning("Pb / Pile-up event ... return!");
\r
1224 PostData(1, fListHistCascade);
\r
1225 PostData(2, fCFContCascadePIDXiMinus);
\r
1226 PostData(3, fCFContCascadePIDXiPlus);
\r
1227 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1228 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1229 PostData(6, fCFContCascadeCuts);
\r
1233 // - Take the number of cascades and tracks after Pileup selection
\r
1234 ncascadesForSelEvtNoTPCOnlyNoPileup = lAODevent->GetNumberOfCascades();
\r
1235 nTrackMultiplicityForSelEvtNoTPCOnlyNoPileup = -100; //FIXME: I can't find the equivalent method for the AOD
\r
1237 fHistCascadeMultiplicityForSelEvtNoTPCOnlyNoPileup->Fill(ncascadesForSelEvtNoTPCOnlyNoPileup);
\r
1238 fHistTrackMultiplicityForSelEvtNoTPCOnlyNoPileup->Fill(nTrackMultiplicityForSelEvtNoTPCOnlyNoPileup);
\r
1240 //----------------------------------------------------
\r
1241 // Vertex Z position selection (+ magnetic field info)
\r
1242 //----------------------------------------------------
\r
1243 // - Define variables
\r
1244 Double_t lBestPrimaryVtxPos[3] = {-100.0, -100.0, -100.0};
\r
1245 Double_t lMagneticField = -10.;
\r
1246 Double_t tPrimaryVtxPosition[3] = {-100.0, -100.0, -100.0};
\r
1247 Int_t ncascadesAfterVertexSel = 0;
\r
1248 Int_t nTrackMultiplicityAfterVertexSel = 0;
\r
1249 // - Selection for ESD and AOD
\r
1250 if (fAnalysisType == "ESD") {
\r
1251 // - Vertex coordinates: get the best primary vertex available for the event
\r
1252 const AliESDVertex *lPrimaryBestESDVtx = lESDevent->GetPrimaryVertex();
\r
1253 if (!lPrimaryBestESDVtx){
\r
1254 AliWarning("No prim. vertex in ESD... return!");
\r
1255 PostData(1, fListHistCascade);
\r
1256 PostData(2, fCFContCascadePIDXiMinus);
\r
1257 PostData(3, fCFContCascadePIDXiPlus);
\r
1258 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1259 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1260 PostData(6, fCFContCascadeCuts);
\r
1263 lPrimaryBestESDVtx->GetXYZ( lBestPrimaryVtxPos );
\r
1264 // - Fill the vertex plots before any event selection on vertex position
\r
1265 const AliVVertex *primaryVtx = lESDevent->GetPrimaryVertex();
\r
1266 tPrimaryVtxPosition[0] = primaryVtx->GetX();
\r
1267 tPrimaryVtxPosition[1] = primaryVtx->GetY();
\r
1268 tPrimaryVtxPosition[2] = primaryVtx->GetZ();
\r
1269 fHistPVx->Fill( tPrimaryVtxPosition[0] );
\r
1270 fHistPVy->Fill( tPrimaryVtxPosition[1] );
\r
1271 fHistPVz->Fill( tPrimaryVtxPosition[2] );
\r
1272 // - Get magnetic filed info
\r
1273 lMagneticField = lESDevent->GetMagneticField();
\r
1274 //if(TMath::Abs(lMagneticField ) < 10e-6) continue;
\r
1275 // - Selection on the primary vertex Z position
\r
1276 if (fkQualityCutZprimVtxPos) {
\r
1277 if (TMath::Abs(lBestPrimaryVtxPos[2]) > fVtxRange || TMath::Abs(lBestPrimaryVtxPos[2]) < fVtxRangeMin) {
\r
1278 AliWarning("Pb / | Z position of Best Prim Vtx | > 10.0 cm ... return !");
\r
1279 PostData(1, fListHistCascade);
\r
1280 PostData(2, fCFContCascadePIDXiMinus);
\r
1281 PostData(3, fCFContCascadePIDXiPlus);
\r
1282 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1283 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1284 PostData(6, fCFContCascadeCuts);
\r
1288 // - Take the number of cascades and tracks after vertex Z position selection
\r
1289 ncascadesAfterVertexSel = lESDevent->GetNumberOfCascades();
\r
1290 nTrackMultiplicityAfterVertexSel = fESDtrackCuts->GetReferenceMultiplicity(lESDevent,AliESDtrackCuts::kTrackletsITSTPC,0.5);
\r
1291 } else if (fAnalysisType == "AOD") {
\r
1292 // - Vertex coordinates: get the best primary vertex available for the event
\r
1293 const AliAODVertex *lPrimaryBestAODVtx = lAODevent->GetPrimaryVertex();
\r
1294 if (!lPrimaryBestAODVtx){
\r
1295 AliWarning("No prim. vertex in AOD... return!");
\r
1296 PostData(1, fListHistCascade);
\r
1297 PostData(2, fCFContCascadePIDXiMinus);
\r
1298 PostData(3, fCFContCascadePIDXiPlus);
\r
1299 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1300 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1301 PostData(6, fCFContCascadeCuts);
\r
1304 lPrimaryBestAODVtx->GetXYZ( lBestPrimaryVtxPos );
\r
1305 // - Fill the vertex plots before any event selection on vertex position
\r
1306 const AliVVertex *primaryVtx = lAODevent->GetPrimaryVertex();
\r
1307 tPrimaryVtxPosition[0] = primaryVtx->GetX();
\r
1308 tPrimaryVtxPosition[1] = primaryVtx->GetY();
\r
1309 tPrimaryVtxPosition[2] = primaryVtx->GetZ();
\r
1310 fHistPVx->Fill( tPrimaryVtxPosition[0] );
\r
1311 fHistPVy->Fill( tPrimaryVtxPosition[1] );
\r
1312 fHistPVz->Fill( tPrimaryVtxPosition[2] );
\r
1313 // - Get magnetic filed info
\r
1314 lMagneticField = lAODevent->GetMagneticField();
\r
1315 //if(TMath::Abs(lMagneticField ) < 10e-6) continue;
\r
1316 // - Selection on the primary vertex Z position
\r
1317 if (fkQualityCutZprimVtxPos) {
\r
1318 if (TMath::Abs(lBestPrimaryVtxPos[2]) > fVtxRange || TMath::Abs(lBestPrimaryVtxPos[2]) < fVtxRangeMin) {
\r
1319 AliWarning("Pb / | Z position of Best Prim Vtx | > 10.0 cm ... return !");
\r
1320 PostData(1, fListHistCascade);
\r
1321 PostData(2, fCFContCascadePIDXiMinus);
\r
1322 PostData(3, fCFContCascadePIDXiPlus);
\r
1323 PostData(4, fCFContCascadePIDOmegaMinus);
\r
1324 PostData(5, fCFContCascadePIDOmegaPlus);
\r
1325 PostData(6, fCFContCascadeCuts);
\r
1329 // - Take the number of cascades and tracks after vertex Z position selection
\r
1330 ncascadesAfterVertexSel = lAODevent->GetNumberOfCascades();
\r
1331 nTrackMultiplicityAfterVertexSel = -100; //FIXME: I can't find the equivalent method for the AOD
\r
1333 // - Fill the plots
\r
1334 fHistCascadeMultiplicityAfterVertexCutSel->Fill(ncascadesAfterVertexSel);
\r
1335 fHistTrackMultiplicityAfterVertexCutSel->Fill(nTrackMultiplicityAfterVertexSel);
\r
1337 // - Vertex position plots: after any event selections
\r
1338 tPrimaryVtxPosition[0] = -100.0;
\r
1339 tPrimaryVtxPosition[1] = -100.0;
\r
1340 tPrimaryVtxPosition[2] = -100.0;
\r
1341 if (fAnalysisType == "ESD") {
\r
1342 const AliVVertex *primaryVtx = lESDevent->GetPrimaryVertex();
\r
1343 tPrimaryVtxPosition[0] = primaryVtx->GetX();
\r
1344 tPrimaryVtxPosition[1] = primaryVtx->GetY();
\r
1345 tPrimaryVtxPosition[2] = primaryVtx->GetZ();
\r
1346 } else if (fAnalysisType == "AOD") {
\r
1347 const AliVVertex *primaryVtx = lAODevent->GetPrimaryVertex();
\r
1348 tPrimaryVtxPosition[0] = primaryVtx->GetX();
\r
1349 tPrimaryVtxPosition[1] = primaryVtx->GetY();
\r
1350 tPrimaryVtxPosition[2] = primaryVtx->GetZ();
\r
1352 fHistPVxAnalysis->Fill( tPrimaryVtxPosition[0] );
\r
1353 fHistPVyAnalysis->Fill( tPrimaryVtxPosition[1] );
\r
1354 fHistPVzAnalysis->Fill( tPrimaryVtxPosition[2] );
\r
1358 //////////////////////////////
\r
1359 // CASCADE RECONSTRUCTION PART
\r
1360 //////////////////////////////
\r
1364 Int_t ncascades = 0;
\r
1365 if (fAnalysisType == "ESD") ncascades = lESDevent->GetNumberOfCascades();
\r
1366 else if (fAnalysisType == "AOD") ncascades = lAODevent->GetNumberOfCascades();
\r
1368 for (Int_t iXi = 0; iXi < ncascades; iXi++) {// This is the begining of the Cascade loop (ESD or AOD)
\r
1370 // -----------------------------------------------------------------------
\r
1371 // - Initialisation of the local variables that will be needed for ESD/AOD
\r
1373 // - 0th part of initialisation : around primary vertex ...
\r
1374 //Double_t lBestPrimaryVtxRadius3D = -500.0;
\r
1375 // - 1st part of initialisation : variables needed to store AliESDCascade data members
\r
1376 Double_t lEffMassXi = 0.;
\r
1377 Double_t lDcaXiDaughters = -1.;
\r
1378 Double_t lXiCosineOfPointingAngle = -1.;
\r
1379 Double_t lPosXi[3] = { -1000.0, -1000.0, -1000.0 };
\r
1380 Double_t lXiRadius = -1000. ;
\r
1381 // - 2nd part of initialisation : Nbr of clusters within TPC for the 3 daughter cascade tracks
\r
1382 UShort_t lPosTPCClusters = -1; // For ESD only ...
\r
1383 UShort_t lNegTPCClusters = -1; // For ESD only ...
\r
1384 UShort_t lBachTPCClusters = -1; // For ESD only ...
\r
1385 Double_t lInnerWallMomCascDghters[3] = {-100., -100., -100.};
\r
1386 Double_t lTPCSignalCascDghters [3] = {-100., -100., -100.};
\r
1387 // - 3rd part of initialisation : about V0 part in cascades
\r
1388 Double_t lInvMassLambdaAsCascDghter = 0.;
\r
1389 Double_t lDcaV0DaughtersXi = -1.;
\r
1390 Double_t lDcaBachToPrimVertexXi = -1.;
\r
1391 Double_t lDcaV0ToPrimVertexXi = -1.;
\r
1392 Double_t lDcaPosToPrimVertexXi = -1.;
\r
1393 Double_t lDcaNegToPrimVertexXi = -1.;
\r
1394 Double_t lV0CosineOfPointingAngleXi = -1. ;
\r
1395 Double_t lPosV0Xi[3] = { -1000. , -1000., -1000. }; // Position of VO coming from cascade
\r
1396 Double_t lV0RadiusXi = -1000.0;
\r
1397 Double_t lV0quality = 0.;
\r
1398 // - 4th part of initialisation : Effective masses
\r
1399 Double_t lInvMassXiMinus = 0.;
\r
1400 Double_t lInvMassXiPlus = 0.;
\r
1401 Double_t lInvMassOmegaMinus = 0.;
\r
1402 Double_t lInvMassOmegaPlus = 0.;
\r
1403 // - 5th part of initialisation : PID treatment
\r
1404 Bool_t lIsPosInXiProton = kFALSE;
\r
1405 Bool_t lIsPosInXiPion = kFALSE;
\r
1406 Bool_t lIsPosInOmegaProton = kFALSE;
\r
1407 Bool_t lIsPosInOmegaPion = kFALSE;
\r
1408 Bool_t lIsNegInXiProton = kFALSE;
\r
1409 Bool_t lIsNegInXiPion = kFALSE;
\r
1410 Bool_t lIsNegInOmegaProton = kFALSE;
\r
1411 Bool_t lIsNegInOmegaPion = kFALSE;
\r
1412 Bool_t lIsBachelorKaon = kFALSE;
\r
1413 Bool_t lIsBachelorPion = kFALSE;
\r
1414 Bool_t lIsBachelorKaonForTPC = kFALSE;
\r
1415 Bool_t lIsBachelorPionForTPC = kFALSE;
\r
1416 Bool_t lIsNegPionForTPC = kFALSE;
\r
1417 Bool_t lIsPosPionForTPC = kFALSE;
\r
1418 Bool_t lIsNegProtonForTPC = kFALSE;
\r
1419 Bool_t lIsPosProtonForTPC = kFALSE;
\r
1420 // - 6th part of initialisation : extra info for QA
\r
1421 Double_t lXiMomX = 0.;
\r
1422 Double_t lXiMomY = 0.;
\r
1423 Double_t lXiMomZ = 0.;
\r
1424 Double_t lXiTransvMom = 0.;
\r
1425 Double_t lXiTotMom = 0.;
\r
1426 Double_t lV0PMomX = 0.;
\r
1427 Double_t lV0PMomY = 0.;
\r
1428 Double_t lV0PMomZ = 0.;
\r
1429 Double_t lV0NMomX = 0.;
\r
1430 Double_t lV0NMomY = 0.;
\r
1431 Double_t lV0NMomZ = 0.;
\r
1432 Double_t lV0TotMom = 0.;
\r
1433 Double_t lBachMomX = 0.;
\r
1434 Double_t lBachMomY = 0.;
\r
1435 Double_t lBachMomZ = 0.;
\r
1436 Double_t lBachTransvMom = 0.;
\r
1437 Double_t lBachTotMom = 0.;
\r
1438 Double_t lpTrackTransvMom = 0.;
\r
1439 Double_t lnTrackTransvMom = 0.;
\r
1440 Short_t lChargeXi = -2;
\r
1441 Double_t lV0toXiCosineOfPointingAngle = 0.;
\r
1442 Double_t lRapXi = -20.0, lRapOmega = -20.0, lEta = -20.0, lTheta = 360., lPhi = 720.;
\r
1443 Double_t lAlphaXi = -200., lPtArmXi = -200.0;
\r
1444 Double_t etaPos = 0., etaNeg = 0., etaBach = 0.;
\r
1446 if (fAnalysisType == "ESD") {
\r
1448 // -------------------------------------
\r
1449 // - Load the cascades from the handler
\r
1450 AliESDcascade *xi = lESDevent->GetCascade(iXi);
\r
1451 if (!xi) continue;
\r
1453 //----------------------------------------------------------------------------
\r
1454 // - Assigning the necessary variables for specific AliESDcascade data members
\r
1456 xi->ChangeMassHypothesis(lV0quality , 3312); // default working hypothesis: cascade = Xi-decay
\r
1457 lEffMassXi = xi->GetEffMassXi();
\r
1458 lDcaXiDaughters = xi->GetDcaXiDaughters();
\r
1459 lXiCosineOfPointingAngle = xi->GetCascadeCosineOfPointingAngle( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lBestPrimaryVtxPos[2] );
\r
1460 //Take care : the best available vertex should be used (like in AliCascadeVertexer)
\r
1461 xi->GetXYZcascade( lPosXi[0], lPosXi[1], lPosXi[2] );
\r
1462 lXiRadius = TMath::Sqrt( lPosXi[0]*lPosXi[0] + lPosXi[1]*lPosXi[1] );
\r
1464 //-------------------------------------------------------------------------------------------------------------------------------
\r
1465 // - Around the tracks: Bach + V0 (ESD). Necessary variables for ESDcascade data members coming from the ESDv0 part (inheritance)
\r
1466 UInt_t lIdxPosXi = (UInt_t) TMath::Abs( xi->GetPindex() );
\r
1467 UInt_t lIdxNegXi = (UInt_t) TMath::Abs( xi->GetNindex() );
\r
1468 UInt_t lBachIdx = (UInt_t) TMath::Abs( xi->GetBindex() );
\r
1469 //Care track label can be negative in MC production (linked with the track quality)
\r
1470 //However = normally, not the case for track index ...
\r
1471 // - Rejection of a double use of a daughter track (nothing but just a crosscheck of what is done in the cascade vertexer)
\r
1472 if (lBachIdx == lIdxNegXi) { AliWarning("Pb / Idx(Bach. track) = Idx(Neg. track) ... continue!"); continue; }
\r
1473 if (lBachIdx == lIdxPosXi) { AliWarning("Pb / Idx(Bach. track) = Idx(Pos. track) ... continue!"); continue; }
\r
1474 // - Get the track for the daughters
\r
1475 AliESDtrack *pTrackXi = lESDevent->GetTrack( lIdxPosXi );
\r
1476 AliESDtrack *nTrackXi = lESDevent->GetTrack( lIdxNegXi );
\r
1477 AliESDtrack *bachTrackXi = lESDevent->GetTrack( lBachIdx );
\r
1478 if (!pTrackXi || !nTrackXi || !bachTrackXi ) {
\r
1479 AliWarning("ERROR: Could not retrieve one of the 3 ESD daughter tracks of the cascade ...");
\r
1482 // - Get the TPCnumber of cluster for the daughters
\r
1483 lPosTPCClusters = pTrackXi->GetTPCNcls();
\r
1484 lNegTPCClusters = nTrackXi->GetTPCNcls();
\r
1485 lBachTPCClusters = bachTrackXi->GetTPCNcls();
\r
1487 //-------------------------------------
\r
1488 // - Rejection of a poor quality tracks
\r
1489 if (fkQualityCutTPCrefit) {
\r
1490 // - Poor quality related to TPCrefit
\r
1491 ULong_t pStatus = pTrackXi->GetStatus();
\r
1492 ULong_t nStatus = nTrackXi->GetStatus();
\r
1493 ULong_t bachStatus = bachTrackXi->GetStatus();
\r
1494 if ((pStatus&AliESDtrack::kTPCrefit) == 0) { AliWarning("Pb / V0 Pos. track has no TPCrefit ... continue!"); continue; }
\r
1495 if ((nStatus&AliESDtrack::kTPCrefit) == 0) { AliWarning("Pb / V0 Neg. track has no TPCrefit ... continue!"); continue; }
\r
1496 if ((bachStatus&AliESDtrack::kTPCrefit) == 0) { AliWarning("Pb / Bach. track has no TPCrefit ... continue!"); continue; }
\r
1498 if (fkQualityCutnTPCcls) {
\r
1499 // - Poor quality related to TPC clusters
\r
1500 if (lPosTPCClusters < fMinnTPCcls) { AliWarning("Pb / V0 Pos. track has less than 80 TPC clusters ... continue!"); continue; }
\r
1501 if (lNegTPCClusters < fMinnTPCcls) { AliWarning("Pb / V0 Neg. track has less than 80 TPC clusters ... continue!"); continue; }
\r
1502 if (lBachTPCClusters < fMinnTPCcls) { AliWarning("Pb / Bach. track has less than 80 TPC clusters ... continue!"); continue; }
\r
1505 //-----------------------------------
\r
1506 const AliExternalTrackParam *pExtTrack = pTrackXi->GetInnerParam();
\r
1507 const AliExternalTrackParam *nExtTrack = nTrackXi->GetInnerParam();
\r
1508 const AliExternalTrackParam *bachExtTrack = bachTrackXi->GetInnerParam();
\r
1510 lInnerWallMomCascDghters[0] = pExtTrack->GetP() * pExtTrack->Charge();
\r
1511 lTPCSignalCascDghters [0] = pTrackXi->GetTPCsignal();
\r
1514 lInnerWallMomCascDghters[1] = nExtTrack->GetP() * nExtTrack->Charge();
\r
1515 lTPCSignalCascDghters [1] = nTrackXi->GetTPCsignal();
\r
1517 if (bachExtTrack) {
\r
1518 lInnerWallMomCascDghters[2] = bachExtTrack->GetP() * bachExtTrack->Charge();
\r
1519 lTPCSignalCascDghters [2] = bachTrackXi->GetTPCsignal();
\r
1521 etaPos = pTrackXi->Eta();
\r
1522 etaNeg = nTrackXi->Eta();
\r
1523 etaBach = bachTrackXi->Eta();
\r
1524 lInvMassLambdaAsCascDghter = xi->GetEffMass(); //This value shouldn't change, whatever the working hyp. is : Xi-, Xi+, Omega-, Omega+
\r
1525 lDcaV0DaughtersXi = xi->GetDcaV0Daughters();
\r
1526 lV0CosineOfPointingAngleXi = xi->GetV0CosineOfPointingAngle(lBestPrimaryVtxPos[0],
\r
1527 lBestPrimaryVtxPos[1],
\r
1528 lBestPrimaryVtxPos[2] );
\r
1529 lDcaV0ToPrimVertexXi = xi->GetD( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lBestPrimaryVtxPos[2] );
\r
1530 lDcaBachToPrimVertexXi = TMath::Abs( bachTrackXi->GetD( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lMagneticField ) ); //Note: AliExternalTrackParam::GetD returns an algebraic value ...
\r
1531 xi->GetXYZ( lPosV0Xi[0], lPosV0Xi[1], lPosV0Xi[2] );
\r
1532 lV0RadiusXi = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0] + lPosV0Xi[1]*lPosV0Xi[1] );
\r
1533 lDcaPosToPrimVertexXi = TMath::Abs( pTrackXi ->GetD( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lMagneticField ) );
\r
1534 lDcaNegToPrimVertexXi = TMath::Abs( nTrackXi ->GetD( lBestPrimaryVtxPos[0], lBestPrimaryVtxPos[1], lMagneticField ) );
\r
1536 //-----------------------------------------
\r
1537 // - Extra-selection for cascade candidates
\r
1538 if (fkExtraSelections) { //in AliCascadeVertexer
\r
1539 if (lDcaXiDaughters > 0.3) continue;
\r
1540 if (lXiCosineOfPointingAngle < 0.999 ) continue;
\r
1541 if (lDcaV0ToPrimVertexXi < 0.05) continue;
\r
1542 if (lDcaBachToPrimVertexXi < 0.03) continue;
\r
1543 //if (TMath::Abs(lInvMassLambdaAsCascDghter-1.11568) > 0.006 ) continue;
\r
1544 if (lDcaV0DaughtersXi > 1.) continue;
\r
1545 if (lV0CosineOfPointingAngleXi < 0.998) continue;
\r
1546 if (lDcaPosToPrimVertexXi < 0.1) continue;
\r
1547 if (lDcaNegToPrimVertexXi < 0.1) continue;
\r
1548 if (lXiRadius < .9) continue;
\r
1549 //if (lXiRadius > 100) continue;
\r
1550 if (lV0RadiusXi < 0.9) continue;
\r
1551 //if (lV0RadiusXi > 100) continue;
\r
1554 //----------------------------------------------------------------------------------------------------
\r
1555 // - Around effective masses. Change mass hypotheses to cover all the possibilities: Xi-/+, Omega -/+
\r
1556 if ( bachTrackXi->Charge() < 0 ) {
\r
1557 //Calculate the effective mass of the Xi- candidate: Xi- hyp. (pdg code 3312)
\r
1559 xi->ChangeMassHypothesis(lV0quality , 3312);
\r
1560 lInvMassXiMinus = xi->GetEffMassXi();
\r
1561 //Calculate the effective mass of the Xi- candidate: Omega- hyp. (pdg code 3334)
\r
1563 xi->ChangeMassHypothesis(lV0quality , 3334);
\r
1564 lInvMassOmegaMinus = xi->GetEffMassXi();
\r
1565 //Back to "default" hyp. (Xi-)
\r
1567 xi->ChangeMassHypothesis(lV0quality , 3312);
\r
1568 } // end if negative bachelor
\r
1569 if ( bachTrackXi->Charge() > 0 ) {
\r
1570 //Calculate the effective mass of the Xi- candidate: Xi+ hyp. (pdg code -3312)
\r
1572 xi->ChangeMassHypothesis(lV0quality , -3312);
\r
1573 lInvMassXiPlus = xi->GetEffMassXi();
\r
1574 //Calculate the effective mass of the Xi- candidate: Omega+ hyp. (pdg code -3334)
\r
1576 xi->ChangeMassHypothesis(lV0quality , -3334);
\r
1577 lInvMassOmegaPlus = xi->GetEffMassXi();
\r
1578 //Back to "default" hyp. (Xi-)
\r
1580 xi->ChangeMassHypothesis(lV0quality , -3312);
\r
1581 } // end if positive bachelor
\r
1583 //--------------------------------
\r
1584 // - PID on the daughter tracks
\r
1585 // - Combined PID -> removed, add when will be used
\r
1587 // - TPC PID : 3-sigma bands on Bethe-Bloch curve
\r
1589 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 4) lIsBachelorKaonForTPC = kTRUE;
\r
1590 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 4) lIsBachelorPionForTPC = kTRUE;
\r
1591 //Negative V0 daughter
\r
1592 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kPion )) < 4) lIsNegPionForTPC = kTRUE;
\r
1593 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kProton )) < 4) lIsNegProtonForTPC = kTRUE;
\r
1594 //Positive V0 daughter
\r
1595 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kPion )) < 4) lIsPosPionForTPC = kTRUE;
\r
1596 if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 4) lIsPosProtonForTPC = kTRUE;
\r
1598 const AliExternalTrackParam *pInnerWallTrackXi = pTrackXi ->GetInnerParam();
\r
1599 const AliExternalTrackParam *nInnerWallTrackXi = nTrackXi ->GetInnerParam();
\r
1600 const AliExternalTrackParam *bachInnerWallTrackXi = bachTrackXi ->GetInnerParam();
\r
1601 if (pInnerWallTrackXi && nInnerWallTrackXi && bachInnerWallTrackXi ) {
\r
1602 Double_t pMomInnerWall = pInnerWallTrackXi ->GetP();
\r
1603 Double_t nMomInnerWall = nInnerWallTrackXi ->GetP();
\r
1604 Double_t bachMomInnerWall = bachInnerWallTrackXi->GetP();
\r
1606 if (TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 3) lIsBachelorPionForTPC = kTRUE;
\r
1607 if (bachMomInnerWall < 0.350 && TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 5) lIsBachelorKaonForTPC = kTRUE;
\r
1608 if (bachMomInnerWall > 0.350 && TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 3) lIsBachelorKaonForTPC = kTRUE;
\r
1609 //Negative V0 daughter
\r
1610 if (TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kPion )) < 3 ) lIsNegPionForTPC = kTRUE;
\r
1611 if (nMomInnerWall < 0.6 && TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kProton ) ) < 5 ) lIsNegProtonForTPC = kTRUE;
\r
1612 if (nMomInnerWall > 0.6 && TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kProton ) ) < 3 ) lIsNegProtonForTPC = kTRUE;
\r
1613 //Positive V0 daughter
\r
1614 if (TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kPion )) < 3 ) lIsPosPionForTPC = kTRUE;
\r
1615 if (pMomInnerWall < 0.6 && TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 5) lIsPosProtonForTPC = kTRUE;
\r
1616 if (pMomInnerWall > 0.6 && TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 3) lIsPosProtonForTPC = kTRUE;
\r
1619 //---------------------------------
\r
1620 // - Extra info for QA (ESD)
\r
1621 // Miscellaneous pieces of info that may help regarding data quality assessment.
\r
1622 // Cascade transverse and total momentum
\r
1623 xi->GetPxPyPz( lXiMomX, lXiMomY, lXiMomZ );
\r
1624 lXiTransvMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY );
\r
1625 lXiTotMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY + lXiMomZ*lXiMomZ );
\r
1626 // V0 total momentum
\r
1627 xi->GetNPxPyPz(lV0NMomX,lV0NMomY,lV0NMomZ);
\r
1628 xi->GetPPxPyPz(lV0PMomX,lV0PMomY,lV0PMomZ);
\r
1629 lV0TotMom = TMath::Sqrt(TMath::Power(lV0NMomX+lV0PMomX,2) + TMath::Power(lV0NMomY+lV0PMomY,2) + TMath::Power(lV0NMomZ+lV0PMomZ,2));
\r
1630 // Bachelor total momentum
\r
1631 xi->GetBPxPyPz( lBachMomX, lBachMomY, lBachMomZ );
\r
1632 lBachTransvMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY );
\r
1633 lBachTotMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY + lBachMomZ*lBachMomZ );
\r
1634 lnTrackTransvMom = TMath::Sqrt( lV0NMomX*lV0NMomX + lV0NMomY*lV0NMomY );
\r
1635 lpTrackTransvMom = TMath::Sqrt( lV0PMomX*lV0PMomX + lV0PMomY*lV0PMomY );
\r
1636 lChargeXi = xi->Charge();
\r
1637 lV0toXiCosineOfPointingAngle = xi->GetV0CosineOfPointingAngle( lPosXi[0], lPosXi[1], lPosXi[2] );
\r
1638 lRapXi = xi->RapXi();
\r
1639 lRapOmega = xi->RapOmega();
\r
1641 lTheta = xi->Theta()*180.0/TMath::Pi();
\r
1642 lPhi = xi->Phi()*180.0/TMath::Pi();
\r
1643 lAlphaXi = xi->AlphaXi();
\r
1644 lPtArmXi = xi->PtArmXi();
\r
1645 // Extra-cut = Anti-splitting cut for lambda daughters
\r
1646 Bool_t kAntiSplittingLambda = kFALSE;
\r
1647 if (kAntiSplittingLambda) { // not used
\r
1648 Double_t lNMomX = 0., lNMomY = 0., lNMomZ = 0.;
\r
1649 Double_t lPMomX = 0., lPMomY = 0., lPMomZ = 0.;
\r
1650 xi->GetPPxPyPz(lPMomX, lPMomY, lPMomZ);
\r
1651 xi->GetNPxPyPz(lNMomX, lNMomY, lNMomZ);
\r
1652 if ( xi->Charge() < 0) {// Xi- or Omega-
\r
1653 if (TMath::Abs(lBachTransvMom - TMath::Sqrt( lNMomX*lNMomX + lNMomY*lNMomY ) ) < 0.075) continue;
\r
1654 } else { //Xi+ or Omega+
\r
1655 if(TMath::Abs(lBachTransvMom - TMath::Sqrt( lPMomX*lPMomX + lPMomY*lPMomY ) ) < 0.075) continue;
\r
1659 } // end of ESD treatment
\r
1661 else if (fAnalysisType == "AOD") {
\r
1663 // -------------------------------------
\r
1664 // - Load the cascades from the handler
\r
1665 const AliAODcascade *xi = lAODevent->GetCascade(iXi);
\r
1666 if (!xi) continue;
\r
1668 //----------------------------------------------------------------------------
\r
1669 // - Assigning the necessary variables for specific AliESDcascade data members
\r
1670 lEffMassXi = xi->MassXi(); // default working hypothesis : cascade = Xi- decay
\r
1671 lDcaXiDaughters = xi->DcaXiDaughters();
\r
1672 lXiCosineOfPointingAngle = xi->CosPointingAngleXi( lBestPrimaryVtxPos[0],
\r
1673 lBestPrimaryVtxPos[1],
\r
1674 lBestPrimaryVtxPos[2] );
\r
1675 lPosXi[0] = xi->DecayVertexXiX();
\r
1676 lPosXi[1] = xi->DecayVertexXiY();
\r
1677 lPosXi[2] = xi->DecayVertexXiZ();
\r
1678 lXiRadius = TMath::Sqrt( lPosXi[0]*lPosXi[0] + lPosXi[1]*lPosXi[1] );
\r
1680 //-------------------------------------------------------------------------------------------------------------------------------
\r
1681 // - Around the tracks: Bach + V0 (ESD). Necessary variables for ESDcascade data members coming from the ESDv0 part (inheritance)
\r
1682 AliAODTrack *pTrackXi = dynamic_cast<AliAODTrack*>( xi->GetDaughter(0) );
\r
1683 AliAODTrack *nTrackXi = dynamic_cast<AliAODTrack*>( xi->GetDaughter(1) );
\r
1684 AliAODTrack *bachTrackXi = dynamic_cast<AliAODTrack*>( xi->GetDecayVertexXi()->GetDaughter(0) );
\r
1685 if (!pTrackXi || !nTrackXi || !bachTrackXi ) {
\r
1686 AliWarning("ERROR: Could not retrieve one of the 3 AOD daughter tracks of the cascade ...");
\r
1689 UInt_t lIdxPosXi = (UInt_t) TMath::Abs( pTrackXi->GetID() );
\r
1690 UInt_t lIdxNegXi = (UInt_t) TMath::Abs( nTrackXi->GetID() );
\r
1691 UInt_t lBachIdx = (UInt_t) TMath::Abs( bachTrackXi->GetID() );
\r
1692 // Care track label can be negative in MC production (linked with the track quality)
\r
1693 // However = normally, not the case for track index ...
\r
1694 // - Rejection of a double use of a daughter track (nothing but just a crosscheck of what is done in the cascade vertexer)
\r
1695 if (lBachIdx == lIdxNegXi) { AliWarning("Pb / Idx(Bach. track) = Idx(Neg. track) ... continue!"); continue; }
\r
1696 if (lBachIdx == lIdxPosXi) { AliWarning("Pb / Idx(Bach. track) = Idx(Pos. track) ... continue!"); continue; }
\r
1697 // - Get the TPCnumber of cluster for the daughters
\r
1698 lPosTPCClusters = pTrackXi->GetTPCNcls(); // FIXME: Is this ok? or something like in LambdaK0PbPb task AOD?
\r
1699 lNegTPCClusters = nTrackXi->GetTPCNcls();
\r
1700 lBachTPCClusters = bachTrackXi->GetTPCNcls();
\r
1702 //-------------------------------------
\r
1703 // - Rejection of a poor quality tracks
\r
1704 if (fkQualityCutTPCrefit) {
\r
1705 // - Poor quality related to TPCrefit
\r
1706 if (!(pTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning("Pb / V0 Pos. track has no TPCrefit ... continue!"); continue; }
\r
1707 if (!(nTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning("Pb / V0 Neg. track has no TPCrefit ... continue!"); continue; }
\r
1708 if (!(bachTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning("Pb / Bach. track has no TPCrefit ... continue!"); continue; }
\r
1710 if (fkQualityCutnTPCcls) {
\r
1711 // - Poor quality related to TPC clusters
\r
1712 if (lPosTPCClusters < fMinnTPCcls) { //AliWarning("Pb / V0 Pos. track has less than 80 TPC clusters ... continue!");
\r
1714 if (lNegTPCClusters < fMinnTPCcls) { //AliWarning("Pb / V0 Neg. track has less than 80 TPC clusters ... continue!");
\r
1716 if (lBachTPCClusters < fMinnTPCcls) { //AliWarning("Pb / Bach. track has less than 80 TPC clusters ... continue!");
\r
1720 //---------------------------------------
\r
1721 // - Around the tracks: Bach + V0 (AOD). Necessary variables for AODcascade data members coming from the AODv0 part (inheritance)
\r
1722 etaPos = pTrackXi->Eta();
\r
1723 etaNeg = nTrackXi->Eta();
\r
1724 etaBach = bachTrackXi->Eta();
\r
1725 lChargeXi = xi->ChargeXi();
\r
1726 if ( lChargeXi < 0) lInvMassLambdaAsCascDghter = xi->MassLambda();
\r
1727 else lInvMassLambdaAsCascDghter = xi->MassAntiLambda();
\r
1728 lDcaV0DaughtersXi = xi->DcaV0Daughters();
\r
1729 lDcaV0ToPrimVertexXi = xi->DcaV0ToPrimVertex();
\r
1730 lDcaBachToPrimVertexXi = xi->DcaBachToPrimVertex();
\r
1731 lPosV0Xi[0] = xi->DecayVertexV0X();
\r
1732 lPosV0Xi[1] = xi->DecayVertexV0Y();
\r
1733 lPosV0Xi[2] = xi->DecayVertexV0Z();
\r
1734 lV0RadiusXi = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0] + lPosV0Xi[1]*lPosV0Xi[1] );
\r
1735 lV0CosineOfPointingAngleXi = xi->CosPointingAngle( lBestPrimaryVtxPos );
\r
1736 lDcaPosToPrimVertexXi = xi->DcaPosToPrimVertex();
\r
1737 lDcaNegToPrimVertexXi = xi->DcaNegToPrimVertex();
\r
1739 //----------------------------------------------------------------------------------------------------
\r
1740 // - Around effective masses. Change mass hypotheses to cover all the possibilities: Xi-/+, Omega -/+
\r
1741 if ( lChargeXi < 0 ) lInvMassXiMinus = xi->MassXi();
\r
1742 if ( lChargeXi > 0 ) lInvMassXiPlus = xi->MassXi();
\r
1743 if ( lChargeXi < 0 ) lInvMassOmegaMinus = xi->MassOmega();
\r
1744 if ( lChargeXi > 0 ) lInvMassOmegaPlus = xi->MassOmega();
\r
1746 //--------------------------------
\r
1747 // - PID on the daughter tracks
\r
1748 // - Combined PID -> removed, add when will be used
\r
1750 // - TPC PID : 3-sigma bands on Bethe-Bloch curve
\r
1752 if(TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 4) lIsBachelorKaonForTPC = kTRUE;
\r
1753 if(TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 4) lIsBachelorPionForTPC = kTRUE;
\r
1754 //Negative V0 daughter
\r
1755 if(TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kPion )) < 4) lIsNegPionForTPC = kTRUE;
\r
1756 if(TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kProton )) < 4) lIsNegProtonForTPC = kTRUE;
\r
1757 //Positive V0 daughter
\r
1758 if(TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kPion )) < 4) lIsPosPionForTPC = kTRUE;
\r
1759 if(TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 4) lIsPosProtonForTPC = kTRUE;
\r
1761 //---------------------------------
\r
1762 // - Extra info for QA (AOD)
\r
1763 // Miscellaneous pieces of info that may help regarding data quality assessment.
\r
1764 // Cascade transverse and total momentum
\r
1765 lXiMomX = xi->MomXiX();
\r
1766 lXiMomY = xi->MomXiY();
\r
1767 lXiMomZ = xi->MomXiZ();
\r
1768 lXiTransvMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY );
\r
1769 lXiTotMom = TMath::Sqrt( lXiMomX*lXiMomX + lXiMomY*lXiMomY + lXiMomZ*lXiMomZ );
\r
1770 Double_t lV0MomX = xi->MomV0X();
\r
1771 Double_t lV0MomY = xi->MomV0Y();
\r
1772 Double_t lV0MomZ = xi->MomV0Z();
\r
1773 lV0TotMom = TMath::Sqrt(TMath::Power(lV0MomX,2)+TMath::Power(lV0MomY,2)+TMath::Power(lV0MomZ,2));
\r
1774 lBachMomX = xi->MomBachX();
\r
1775 lBachMomY = xi->MomBachY();
\r
1776 lBachMomZ = xi->MomBachZ();
\r
1777 lBachTransvMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY );
\r
1778 lBachTotMom = TMath::Sqrt( lBachMomX*lBachMomX + lBachMomY*lBachMomY + lBachMomZ*lBachMomZ );
\r
1779 lV0NMomX = xi->MomNegX();
\r
1780 lV0NMomY = xi->MomNegY();
\r
1781 lV0PMomX = xi->MomPosX();
\r
1782 lV0PMomY = xi->MomPosY();
\r
1783 lnTrackTransvMom = TMath::Sqrt( lV0NMomX*lV0NMomX + lV0NMomY*lV0NMomY );
\r
1784 lpTrackTransvMom = TMath::Sqrt( lV0PMomX*lV0PMomX + lV0PMomY*lV0PMomY );
\r
1785 lV0toXiCosineOfPointingAngle = xi->CosPointingAngle( xi->GetDecayVertexXi() );
\r
1786 lRapXi = xi->RapXi();
\r
1787 lRapOmega = xi->RapOmega();
\r
1788 lEta = xi->Eta(); // Will not work ! need a method Pz(), Py() Px()
\r
1789 lTheta = xi->Theta() *180.0/TMath::Pi(); // in AODcascade.
\r
1790 lPhi = xi->Phi() *180.0/TMath::Pi(); // Here, we will get eta, theta, phi for the V0 ...
\r
1791 lAlphaXi = xi->AlphaXi();
\r
1792 lPtArmXi = xi->PtArmXi();
\r
1794 } // end of AOD treatment
\r
1796 // Cut on pt of the three daughter tracks
\r
1797 if (lBachTransvMom<fMinPtCutOnDaughterTracks) continue;
\r
1798 if (lpTrackTransvMom<fMinPtCutOnDaughterTracks) continue;
\r
1799 if (lnTrackTransvMom<fMinPtCutOnDaughterTracks) continue;
\r
1801 // Cut on pseudorapidity of the three daughter tracks
\r
1802 if (TMath::Abs(etaBach)>fEtaCutOnDaughterTracks) continue;
\r
1803 if (TMath::Abs(etaPos)>fEtaCutOnDaughterTracks) continue;
\r
1804 if (TMath::Abs(etaNeg)>fEtaCutOnDaughterTracks) continue;
\r
1807 //----------------------------------
\r
1808 // Calculate proper lenght for cascade
\r
1809 Double_t cascadeMass = 0.;
\r
1810 if ( ( (lChargeXi<0) && lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) ||
\r
1811 ( (lChargeXi>0) && lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC ) ) cascadeMass = 1.321;
\r
1812 if ( ( (lChargeXi<0) && lIsBachelorKaonForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) ||
\r
1813 ( (lChargeXi>0) && lIsBachelorKaonForTPC && lIsNegProtonForTPC && lIsPosPionForTPC ) ) cascadeMass = 1.672;
\r
1814 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));
\r
1815 if (lXiTotMom!=0) lctau = lctau*cascadeMass/lXiTotMom;
\r
1818 //-------------------------------------------------
\r
1819 // Calculate proper lenght for Lambda (reconstructed)
\r
1820 Float_t lambdaMass = 1.115683; // PDG mass
\r
1821 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));
\r
1822 Float_t lctauV0 = -1.;
\r
1823 if (lV0TotMom!=0) lctauV0 = distV0Xi*lambdaMass/lV0TotMom;
\r
1824 Float_t distTV0Xi = TMath::Sqrt(TMath::Power((lPosV0Xi[0]-lPosXi[0]),2)+TMath::Power((lPosV0Xi[1]-lPosXi[1]),2));
\r
1828 if(lChargeXi < 0&& lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) {
\r
1829 if (lXiTransvMom>2.&&lXiTransvMom<4.&&(lInvMassXiMinus<1.322&&lInvMassXiMinus>1.320)&&(lXiRadius<8.&&lXiRadius>3.)) {
\r
1830 // FIXME : Just to know which file is currently open : locate the file containing Xi
\r
1831 cout << "Name of the file containing Xi candidate(s) :"
\r
1832 << CurrentFileName()
\r
1833 << " / entry: " << Entry()
\r
1834 << " / in file: " << lESDevent->GetEventNumberInFile() // <- Cvetan / From Mihaela: AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->GetTree()->GetReadEntry();
\r
1835 << " AliESDcascade number " << iXi
\r
1836 << " : mass(Xi-) = " << lInvMassXiMinus
\r
1837 << " / charge = " << lChargeXi
\r
1838 << " / pt(Casc) = " << lXiTransvMom
\r
1839 << " / Decay 2d R(Xi) = " << lXiRadius
\r
1843 if(lChargeXi < 0&& lIsBachelorKaonForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) {
\r
1844 if (lXiTransvMom>2&&lXiTransvMom<4&&(lInvMassOmegaMinus<1.674&&lInvMassOmegaMinus>1.670)&&(lXiRadius<8.&&lXiRadius>3.)) {
\r
1845 cout << "Name of the file containing Omega candidate(s) :"
\r
1846 << CurrentFileName()
\r
1847 << " / entry: " << Entry()
\r
1848 << " / in file: " << lESDevent->GetEventNumberInFile() // <- Cvetan / From Mihaela: AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->GetTree()->GetReadEntry();
\r
1849 << " AliESDcascade number " << iXi
\r
1850 << " : mass(Omega-) = " << lInvMassOmegaMinus
\r
1851 << " / charge = " << lChargeXi
\r
1852 << " / pt(Casc) = " << lXiTransvMom
\r
1853 << " / Decay 2d R(Xi) = " << lXiRadius
\r
1861 fHistPosV0TPCClusters->Fill( lPosTPCClusters );
\r
1862 fHistNegV0TPCClusters->Fill( lNegTPCClusters );
\r
1863 fHistBachTPCClusters->Fill( lBachTPCClusters );
\r
1864 f2dHistTPCdEdxOfCascDghters->Fill( lInnerWallMomCascDghters[0] , lTPCSignalCascDghters[0] );
\r
1865 f2dHistTPCdEdxOfCascDghters->Fill( lInnerWallMomCascDghters[1] , lTPCSignalCascDghters[1] );
\r
1866 f2dHistTPCdEdxOfCascDghters->Fill( lInnerWallMomCascDghters[2] , lTPCSignalCascDghters[2] );
\r
1868 //----------------
\r
1869 //Plot with PID on
\r
1870 if ( ( (lChargeXi<0) && lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) ||
\r
1871 ( (lChargeXi>0) && lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC ) ) {
\r
1873 // with this condition, it could happen that a cascade candidate satisfies the wrong requirement,
\r
1874 // e.g. one looks at a Xi- candidate for which lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC = kFALSE
\r
1875 // Expectation: it should be excluded, but lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC = kTRUE
\r
1876 // then this bad Xi-candidate will contribute anyway (OR condition).
\r
1877 // Hence: the extra condition on the sign of the Cascade
\r
1878 //if (TMath::Abs( lInvMassXiMinus-1.3217 ) < 0.010 || TMath::Abs( lInvMassXiPlus-1.3217 ) < 0.010)
\r
1879 fHistEffMassXi->Fill( lEffMassXi );
\r
1880 fHistDcaXiDaughters->Fill( lDcaXiDaughters ); // Flag CascadeVtxer: Cut Variable e
\r
1881 fHistDcaBachToPrimVertex->Fill( lDcaBachToPrimVertexXi ); // Flag CascadeVtxer: Cut Variable d
\r
1882 fHistXiCosineOfPointingAngle->Fill( lXiCosineOfPointingAngle ); // Flag CascadeVtxer: Cut Variable f
\r
1883 fHistXiRadius->Fill( lXiRadius ); // Flag CascadeVtxer: Cut Variable g+h
\r
1884 fHistMassLambdaAsCascDghter->Fill( lInvMassLambdaAsCascDghter ); // Flag CascadeVtxer: Cut Variable c
\r
1885 fHistDcaV0DaughtersXi->Fill( lDcaV0DaughtersXi );
\r
1886 fHistV0CosineOfPointingAngleXi->Fill( lV0CosineOfPointingAngleXi );
\r
1887 fHistV0RadiusXi->Fill( lV0RadiusXi );
\r
1888 fHistDcaV0ToPrimVertexXi->Fill( lDcaV0ToPrimVertexXi ); // Flag CascadeVtxer: Cut Variable b
\r
1889 fHistDcaPosToPrimVertexXi->Fill( lDcaPosToPrimVertexXi );
\r
1890 fHistDcaNegToPrimVertexXi->Fill( lDcaNegToPrimVertexXi );
\r
1891 fHistChargeXi->Fill( lChargeXi );
\r
1892 fHistV0toXiCosineOfPointingAngle->Fill( lV0toXiCosineOfPointingAngle );
\r
1893 if ( TMath::Abs( lInvMassXiMinus-1.3217 ) < 0.012 || TMath::Abs( lInvMassXiPlus-1.3217 ) < 0.012) { // One InvMass should be different from 0
\r
1894 fHistXiTransvMom->Fill( lXiTransvMom );
\r
1895 fHistXiTotMom->Fill( lXiTotMom );
\r
1896 fHistBachTransvMomXi->Fill( lBachTransvMom );
\r
1897 fHistBachTotMomXi->Fill( lBachTotMom );
\r
1898 fHistRapXi->Fill( lRapXi );
\r
1899 fHistEtaXi->Fill( lEta );
\r
1900 if (lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC) {
\r
1901 fHistEtaBachXi->Fill( etaBach );
\r
1902 fHistEtaPosXi->Fill( etaPos );
\r
1903 fHistEtaNegXi->Fill( etaNeg );
\r
1905 fHistThetaXi->Fill( lTheta );
\r
1906 fHistPhiXi->Fill( lPhi );
\r
1908 if ( TMath::Abs( lInvMassOmegaMinus-1.672 ) < 0.012 || TMath::Abs( lInvMassOmegaPlus-1.672 ) < 0.012 ) { // One InvMass should be different from 0
\r
1909 fHistRapOmega->Fill( lRapOmega );
\r
1911 f2dHistArmenteros->Fill( lAlphaXi, lPtArmXi );
\r
1912 } // end with PID ...
\r
1914 //-----------------------
\r
1915 // - Invariant mass plots
\r
1917 if ( lChargeXi < 0 ) {
\r
1918 fHistMassXiMinus->Fill( lInvMassXiMinus );
\r
1919 fHistMassOmegaMinus->Fill( lInvMassOmegaMinus );
\r
1920 f2dHistDcaXiDaughtersvsInvMass->Fill(lDcaXiDaughters,lInvMassXiMinus);
\r
1921 f2dHistDcaBachToPrimVertexvsInvMass->Fill(lDcaBachToPrimVertexXi,lInvMassXiMinus);
\r
1922 f2dHistXiCosineOfPointingAnglevsInvMass->Fill(lXiCosineOfPointingAngle,lInvMassXiMinus);
\r
1923 f2dHistMassLambdaAsCascDghtervsInvMass->Fill(lInvMassLambdaAsCascDghter,lInvMassXiMinus);
\r
1924 f2dHistDcaV0DaughtersXivsInvMass->Fill(lDcaV0DaughtersXi,lInvMassXiMinus);
\r
1925 f2dHistDcaV0ToPrimVertexXivsInvMass->Fill(lDcaV0ToPrimVertexXi,lInvMassXiMinus);
\r
1927 if ( lChargeXi > 0 ) {
\r
1928 fHistMassXiPlus->Fill( lInvMassXiPlus );
\r
1929 fHistMassOmegaPlus->Fill( lInvMassOmegaPlus );
\r
1932 if ( lChargeXi < 0 ) {
\r
1933 f2dHistEffMassLambdaVsEffMassXiMinus->Fill( lInvMassLambdaAsCascDghter, lInvMassXiMinus );
\r
1934 f2dHistEffMassXiVsEffMassOmegaMinus ->Fill( lInvMassXiMinus, lInvMassOmegaMinus );
\r
1935 f2dHistXiRadiusVsEffMassXiMinus ->Fill( lXiRadius, lInvMassXiMinus );
\r
1936 f2dHistXiRadiusVsEffMassOmegaMinus ->Fill( lXiRadius, lInvMassOmegaMinus );
\r
1938 f2dHistEffMassLambdaVsEffMassXiPlus ->Fill( lInvMassLambdaAsCascDghter, lInvMassXiPlus );
\r
1939 f2dHistEffMassXiVsEffMassOmegaPlus ->Fill( lInvMassXiPlus, lInvMassOmegaPlus );
\r
1940 f2dHistXiRadiusVsEffMassXiPlus ->Fill( lXiRadius, lInvMassXiPlus);
\r
1941 f2dHistXiRadiusVsEffMassOmegaPlus ->Fill( lXiRadius, lInvMassOmegaPlus );
\r
1944 //---------------------------------------------
\r
1945 // - Filling the AliCFContainers related to PID
\r
1946 Double_t lContainerPIDVars[3] = {0.0};
\r
1948 if ( lChargeXi < 0 ) {
\r
1949 lContainerPIDVars[0] = lXiTransvMom;
\r
1950 lContainerPIDVars[1] = lInvMassXiMinus;
\r
1951 lContainerPIDVars[2] = lRapXi;
\r
1953 fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 0); // No PID
\r
1955 if ( lIsBachelorPionForTPC ) fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
\r
1956 if ( lIsBachelorPionForTPC && lIsPosProtonForTPC ) fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
\r
1957 if ( lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
\r
1959 if ( lIsBachelorPion ) fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
\r
1960 if ( lIsBachelorPion && lIsPosInXiProton ) fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
\r
1961 if (lIsBachelorPion && lIsPosInXiProton && lIsNegInXiPion ) fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
\r
1963 lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.;
\r
1965 if ( lChargeXi > 0 ) {
\r
1966 lContainerPIDVars[0] = lXiTransvMom;
\r
1967 lContainerPIDVars[1] = lInvMassXiPlus;
\r
1968 lContainerPIDVars[2] = lRapXi;
\r
1970 fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 0); // No PID
\r
1972 if ( lIsBachelorPionForTPC ) fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
\r
1973 if ( lIsBachelorPionForTPC && lIsNegProtonForTPC ) fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
\r
1974 if ( lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC ) fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
\r
1976 if ( lIsBachelorPion ) fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
\r
1977 if ( lIsBachelorPion && lIsNegInXiProton ) fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
\r
1978 if (lIsBachelorPion && lIsNegInXiProton && lIsPosInXiPion ) fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
\r
1980 lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.;
\r
1982 if ( lChargeXi < 0 ) {
\r
1983 lContainerPIDVars[0] = lXiTransvMom;
\r
1984 lContainerPIDVars[1] = lInvMassOmegaMinus;
\r
1985 lContainerPIDVars[2] = lRapOmega;
\r
1987 fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 0); // No PID
\r
1989 if ( lIsBachelorKaonForTPC ) fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
\r
1990 if ( lIsBachelorKaonForTPC && lIsPosProtonForTPC ) fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
\r
1991 if ( lIsBachelorKaonForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
\r
1993 if ( lIsBachelorKaon ) fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
\r
1994 if ( lIsBachelorKaon && lIsPosInOmegaProton ) fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
\r
1995 if (lIsBachelorKaon && lIsPosInOmegaProton && lIsNegInOmegaPion ) fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
\r
1997 lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.;
\r
1999 if ( lChargeXi > 0 ) {
\r
2000 lContainerPIDVars[0] = lXiTransvMom;
\r
2001 lContainerPIDVars[1] = lInvMassOmegaPlus;
\r
2002 lContainerPIDVars[2] = lRapOmega;
\r
2004 fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 0); // No PID
\r
2006 if ( lIsBachelorKaonForTPC )
\r
2007 fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
\r
2008 if( lIsBachelorKaonForTPC &&
\r
2009 lIsNegProtonForTPC )
\r
2010 fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
\r
2011 if ( lIsBachelorKaonForTPC &&
\r
2012 lIsNegProtonForTPC &&
\r
2013 lIsPosPionForTPC )
\r
2014 fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
\r
2016 if ( lIsBachelorKaon )
\r
2017 fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
\r
2018 if ( lIsBachelorKaon &&
\r
2019 lIsNegInOmegaProton )
\r
2020 fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
\r
2021 if (lIsBachelorKaon &&
\r
2022 lIsNegInOmegaProton &&
\r
2023 lIsPosInOmegaPion )
\r
2024 fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
\r
2027 //--------------------------------------------------------------------
\r
2028 // Filling the AliCFContainer (optimisation of topological selections)
\r
2029 Double_t lContainerCutVars[19] = {0.0};
\r
2031 lContainerCutVars[0] = lDcaXiDaughters;
\r
2032 lContainerCutVars[1] = lDcaBachToPrimVertexXi;
\r
2033 lContainerCutVars[2] = lXiCosineOfPointingAngle;
\r
2034 lContainerCutVars[3] = lXiRadius;
\r
2035 lContainerCutVars[4] = lInvMassLambdaAsCascDghter;
\r
2036 lContainerCutVars[5] = lDcaV0DaughtersXi;
\r
2037 lContainerCutVars[6] = lV0toXiCosineOfPointingAngle;
\r
2038 lContainerCutVars[7] = lV0RadiusXi;
\r
2039 lContainerCutVars[8] = lDcaV0ToPrimVertexXi;
\r
2040 lContainerCutVars[9] = lDcaPosToPrimVertexXi;
\r
2041 lContainerCutVars[10] = lDcaNegToPrimVertexXi;
\r
2042 lContainerCutVars[13] = lXiTransvMom;
\r
2043 lContainerCutVars[16] = lctau;
\r
2044 lContainerCutVars[17] = lctauV0;
\r
2045 lContainerCutVars[18] = distTV0Xi;
\r
2047 if ( lChargeXi < 0 ) {
\r
2048 lContainerCutVars[11] = lInvMassXiMinus;
\r
2049 lContainerCutVars[12] = lInvMassOmegaMinus;
\r
2050 lContainerCutVars[14] = lRapXi;
\r
2051 lContainerCutVars[15] = -1.;
\r
2052 if (lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC) fCFContCascadeCuts->Fill(lContainerCutVars,0); // for Xi-
\r
2053 lContainerCutVars[11] = lInvMassXiMinus;
\r
2054 lContainerCutVars[12] = lInvMassOmegaMinus;
\r
2055 lContainerCutVars[14] = -1.;
\r
2056 lContainerCutVars[15] = lRapOmega;
\r
2057 if (lIsBachelorKaonForTPC && lIsPosProtonForTPC && lIsNegPionForTPC) fCFContCascadeCuts->Fill(lContainerCutVars,2); // for Omega-
\r
2059 lContainerCutVars[11] = lInvMassXiPlus;
\r
2060 lContainerCutVars[12] = lInvMassOmegaPlus;
\r
2061 lContainerCutVars[14] = lRapXi;
\r
2062 lContainerCutVars[15] = -1.;
\r
2063 if (lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC) fCFContCascadeCuts->Fill(lContainerCutVars,1); // for Xi+
\r
2064 lContainerCutVars[11] = lInvMassXiPlus;
\r
2065 lContainerCutVars[12] = lInvMassOmegaPlus;
\r
2066 lContainerCutVars[14] = -1.;
\r
2067 lContainerCutVars[15] = lRapOmega;
\r
2068 if (lIsBachelorKaonForTPC && lIsNegProtonForTPC && lIsPosPionForTPC) fCFContCascadeCuts->Fill(lContainerCutVars,3); // for Omega+
\r
2070 } //end of the Cascade loop (ESD or AOD)
\r
2072 // Post output data.
\r
2073 PostData(1, fListHistCascade);
\r
2074 PostData(2, fCFContCascadePIDXiMinus);
\r
2075 PostData(3, fCFContCascadePIDXiPlus);
\r
2076 PostData(4, fCFContCascadePIDOmegaMinus);
\r
2077 PostData(5, fCFContCascadePIDOmegaPlus);
\r
2078 PostData(6, fCFContCascadeCuts);
\r
2081 //________________________________________________________________________
\r
2082 Int_t AliAnalysisTaskCheckCascadepp276::DoESDTrackWithTPCrefitMultiplicity(const AliESDEvent *lESDevent) {
\r
2083 // Checking the number of tracks with TPCrefit for each event
\r
2084 // Needed for a rough assessment of the event multiplicity
\r
2086 Int_t nTrackWithTPCrefitMultiplicity = 0;
\r
2087 for (Int_t iTrackIdx = 0; iTrackIdx < (InputEvent())->GetNumberOfTracks(); iTrackIdx++) {
\r
2088 AliESDtrack *esdTrack = 0x0;
\r
2089 esdTrack = lESDevent->GetTrack( iTrackIdx );
\r
2090 if (!esdTrack) { AliWarning("Pb / Could not retrieve one track within the track loop for TPCrefit check ..."); continue; }
\r
2092 ULong_t lTrackStatus = esdTrack->GetStatus();
\r
2093 if ((lTrackStatus&AliESDtrack::kTPCrefit) == 0) continue;
\r
2094 else nTrackWithTPCrefitMultiplicity++;
\r
2096 // The goal here is to get a better assessment of the event multiplicity.
\r
2097 // (InputEvent())->GetNumberOfTracks() takes into account ITS std alone tracks + global tracks
\r
2098 // This may introduce a bias. Hence the number of TPC refit tracks.
\r
2099 // Note : the event multiplicity = analysis on its own... See Jacek's or Jan Fiete's analysis on dN/d(eta)
\r
2101 } // end loop over all event tracks
\r
2102 return nTrackWithTPCrefitMultiplicity;
\r
2106 //________________________________________________________________________
\r
2107 void AliAnalysisTaskCheckCascadepp276::Terminate(Option_t *)
\r
2109 // Draw result to the screen
\r
2110 // Called once at the end of the query
\r
2112 /* TList *cRetrievedList = 0x0;
\r
2113 cRetrievedList = (TList*)GetOutputData(1);
\r
2114 if(!cRetrievedList){
\r
2115 AliWarning("ERROR - AliAnalysisTaskCheckCascadepp276: ouput data container list not available\n"); return;
\r
2117 fHistTrackMultiplicity = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistTrackMultiplicity") );
\r
2118 if (!fHistTrackMultiplicity) {
\r
2119 AliWarning("ERROR - AliAnalysisTaskCheckCascadepp276: fHistTrackMultiplicity not available\n"); return;
\r
2121 fHistMassXiMinus = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassXiMinus") );
\r
2122 if (!fHistMassXiMinus) {
\r
2123 AliWarning("ERROR - AliAnalysisTaskCheckCascadepp276: fHistMassXiMinus not available\n"); return;
\r
2125 fHistMassXiPlus = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassXiPlus") );
\r
2126 if (!fHistMassXiPlus) {
\r
2127 AliWarning("ERROR - AliAnalysisTaskCheckCascadepp276: fHistMassXiPlus not available\n"); return;
\r
2129 fHistMassOmegaMinus = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassOmegaMinus") );
\r
2130 if (!fHistMassOmegaMinus) {
\r
2131 AliWarning("ERROR - AliAnalysisTaskCheckCascadepp276: fHistMassOmegaMinus not available\n"); return;
\r
2133 fHistMassOmegaPlus = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassOmegaPlus") );
\r
2134 if (!fHistMassOmegaPlus) {
\r
2135 AliWarning("ERROR - AliAnalysisTaskCheckCascadepp276: fHistMassOmegaPlus not available\n"); return;
\r
2138 TCanvas *canCheckCascade = new TCanvas("AliAnalysisTaskCheckCascadep276","CheckCascade overview",10,10,1010,660);
\r
2139 canCheckCascade->Divide(2,2);
\r
2141 canCheckCascade->cd(1);
\r
2142 canCheckCascade->cd(1)->SetLogy();
\r
2143 fHistTrackMultiplicity->SetMarkerStyle(kFullStar);
\r
2144 fHistTrackMultiplicity->GetXaxis()->SetLabelFont(42);
\r
2145 fHistTrackMultiplicity->GetYaxis()->SetLabelFont(42);
\r
2146 fHistTrackMultiplicity->SetTitleFont(42, "xy");
\r
2147 fHistTrackMultiplicity->GetXaxis()->SetTitleOffset(1.1);
\r
2148 fHistTrackMultiplicity->DrawCopy("H");
\r
2150 canCheckCascade->cd(2);
\r
2151 fHistMassXiMinus ->SetMarkerStyle(kFullCircle);
\r
2152 fHistMassXiMinus ->SetMarkerSize(0.5);
\r
2153 fHistMassXiMinus ->GetXaxis()->SetLabelFont(42);
\r
2154 fHistMassXiMinus ->GetYaxis()->SetLabelFont(42);
\r
2155 fHistMassXiMinus ->SetTitleFont(42, "xy");
\r
2156 fHistMassXiMinus ->GetXaxis()->SetTitleOffset(1.1);
\r
2157 fHistMassXiMinus ->GetYaxis()->SetTitleOffset(1.3);
\r
2158 //fHistMassXiMinus->Rebin(2);
\r
2159 fHistMassXiMinus ->GetXaxis()->SetRangeUser(1.24, 1.42);
\r
2160 fHistMassXiMinus ->DrawCopy("E");
\r
2162 fHistMassXiPlus ->SetMarkerStyle(kOpenCircle);
\r
2163 fHistMassXiPlus ->SetMarkerColor(kRed+2);
\r
2164 fHistMassXiPlus ->SetLineColor(kRed+2);
\r
2165 fHistMassXiPlus ->SetMarkerSize(0.5);
\r
2166 //fHistMassXiPlus ->Rebin(2);
\r
2167 fHistMassXiPlus ->DrawCopy("ESAME");
\r
2170 TLegend *legendXi =new TLegend(0.67,0.34,0.97,0.54);
\r
2171 legendXi->SetTextFont(42);
\r
2172 legendXi->SetTextSize(0.05);
\r
2173 legendXi->SetFillColor(kWhite);
\r
2174 legendXi->AddEntry( fHistMassXiMinus,"#Xi^{-} candidates","lp");
\r
2175 legendXi->AddEntry( fHistMassXiPlus,"#Xi^{+} candidates","lp");
\r
2179 canCheckCascade->cd(3);
\r
2180 fHistMassOmegaPlus ->SetMarkerStyle(kOpenCircle);
\r
2181 fHistMassOmegaPlus ->SetMarkerColor(kRed+2);
\r
2182 fHistMassOmegaPlus ->SetLineColor(kRed+2);
\r
2183 fHistMassOmegaPlus ->SetMarkerSize(0.5);
\r
2184 fHistMassOmegaPlus ->GetXaxis()->SetLabelFont(42);
\r
2185 fHistMassOmegaPlus ->GetYaxis()->SetLabelFont(42);
\r
2186 fHistMassOmegaPlus ->SetTitleFont(42, "xy");
\r
2187 fHistMassOmegaPlus ->GetXaxis()->SetTitleOffset(1.1);
\r
2188 fHistMassOmegaPlus ->GetYaxis()->SetTitleOffset(1.25);
\r
2189 //fHistMassOmegaPlus ->Rebin(2);
\r
2190 fHistMassOmegaPlus ->GetXaxis()->SetRangeUser(1.6, 1.84);
\r
2191 fHistMassOmegaPlus ->DrawCopy("E");
\r
2193 fHistMassOmegaMinus->SetMarkerStyle(kFullCircle);
\r
2194 fHistMassOmegaMinus->SetMarkerSize(0.5);
\r
2195 //fHistMassOmegaMinus->Rebin(2);
\r
2196 fHistMassOmegaMinus->DrawCopy("ESAME");
\r
2199 TLegend *legendOmega = new TLegend(0.67,0.34,0.97,0.54);
\r
2200 legendOmega->SetTextFont(42);
\r
2201 legendOmega->SetTextSize(0.05);
\r
2202 legendOmega->SetFillColor(kWhite);
\r
2203 legendOmega->AddEntry( fHistMassOmegaMinus,"#Omega^{-} candidates","lp");
\r
2204 legendOmega->AddEntry( fHistMassOmegaPlus,"#Omega^{+} candidates","lp");
\r
2205 legendOmega->Draw();
\r
git://git.uio.no / u / mrichter / AliRoot.git / blob