PWGLF/QATasks/AliAnalysisTaskQAMultistrange.cxx

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