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