PWGLF/STRANGENESS/Cascades/AliAnalysisTaskCheckCascadePbPb.cxx

   1 /**************************************************************************
   2  *  Authors : Antonin Maire, Boris Hippolyte                              *
   3  * Contributors are mentioned in the code where appropriate.              *
   4  *                                                                        *
   5  * Permission to use, copy, modify and distribute this software and its   *
   6  * documentation strictly for non-commercial purposes is hereby granted   *
   7  * without fee, provided that the above copyright notice appears in all   *
   8  * copies and that both the copyright notice and this permission notice   *
   9  * appear in the supporting documentation. The authors make no claims     *
  10  * about the suitability of this software for any purpose. It is          *
  11  * provided "as is" without express or implied warranty.                  *
  12  **************************************************************************/
  13
  14 //-----------------------------------------------------------------
  15 //            AliAnalysisTaskCheckCascadePbPb class
  16 //
  17 //            Origin AliAnalysisTaskCheckCascade which has four roles :
  18 //              1. QAing the Cascades from ESD and AOD
  19 //                 Origin:  AliAnalysisTaskESDCheckV0 by Boris Hippolyte Nov2007, hippolyt@in2p3.fr
  20 //              2. Prepare the plots which stand as raw material for yield extraction (wi/wo PID)
  21 //              3. Supply an AliCFContainer meant to define the optimised topological selections
  22 //              4. Rough azimuthal correlation study (Eta, Phi)
  23 //              Adapted to Cascade : A.Maire Mar2008, antonin.maire@ires.in2p3.fr
  24 //              Modified :           A.Maire Mar2010
  25 //
  26 //              Adapted to PbPb analysis: M. Nicassio, maria.nicassio@ba.infn.it
  27 //               Feb-August2011
  28 //                - Physics selection moved to the run.C macro
  29 //                - Centrality selection added (+ setters)
  30 //                - setters added (vertex range)
  31 //                - histo added and histo/container binning changed
  32 //                - protection in the destructor for CAF usage
  33 //                - AliWarning disabled
  34 //                - automatic settings for PID
  35 //               September2011
  36 //                - proper time histos/container added (V0 and Cascades)
  37 //               November2011
  38 //                - re-run V0's and cascade's vertexers (SetCuts instead of SetDefaultCuts!!)
  39 //               Genuary2012
  40 //                - AOD analysis part completed
  41 //               March2012
  42 //                - min number of TPC clusters for track selection as a parameter
  43 //               July2012
  44 //                - cut on min pt for daughter tracks as a parameter
  45 //-----------------------------------------------------------------
  46
  47 class TTree;
  48 class TParticle;
  49 class TVector3;
  50
  51 class AliESDVertex;
  52 class AliAODVertex;
  53 class AliESDv0;
  54 class AliAODv0;
  55
  56 #include <Riostream.h>
  57 #include "TList.h"
  58 #include "TH1.h"
  59 #include "TH2.h"
  60 #include "TH3.h"
  61 #include "THnSparse.h"
  62 #include "TVector3.h"
  63 #include "TCanvas.h"
  64 #include "TMath.h"
  65 #include "TLegend.h"
  66
  67
  68 #include "AliLog.h"
  69 #include "AliCentrality.h"
  70 #include "AliESDEvent.h"
  71 #include "AliAODEvent.h"
  72 #include "AliV0vertexer.h"
  73 #include "AliCascadeVertexer.h"
  74 #include "AliESDtrackCuts.h"
  75 #include "AliPIDResponse.h"
  76
  77 #include "AliESDVZERO.h"
  78
  79 #include "AliInputEventHandler.h"
  80 #include "AliAnalysisManager.h"
  81 #include "AliMCEventHandler.h"
  82 #include "AliESDInputHandler.h"
  83 #include "AliAODInputHandler.h"
  84 #include "AliCFContainer.h"
  85 #include "AliMultiplicity.h"
  86
  87 #include "AliESDcascade.h"
  88 #include "AliAODcascade.h"
  89 #include "AliAODTrack.h"
  90
  91 #include "AliAnalysisTaskCheckCascadePbPb.h"
  92
  93 ClassImp(AliAnalysisTaskCheckCascadePbPb)
  94
  95
  96
  97 //________________________________________________________________________
  98 AliAnalysisTaskCheckCascadePbPb::AliAnalysisTaskCheckCascadePbPb()
  99   : AliAnalysisTaskSE(), fAnalysisType("ESD"), fESDtrackCuts(0),/*fPaveTextBookKeeping(0),*/
 100     fPIDResponse                (0),
 101     fkRerunV0CascVertexers      (0),
 102     fkQualityCutZprimVtxPos     (kTRUE),
 103     fkQualityCutNoTPConlyPrimVtx(kTRUE),
 104     fkQualityCutTPCrefit        (kTRUE),
 105     fkQualityCutnTPCcls         (kTRUE),
 106     fMinnTPCcls                 (0),
 107     fkExtraSelections           (0),
 108     fCentrLowLim                (0),
 109     fCentrUpLim                 (0),
 110     fCentrEstimator             (0),
 111     fkUseCleaning               (0),
 112     fVtxRange                   (0),
 113     fMinPtCutOnDaughterTracks   (0),
 114
 115
 116         // - Cascade part initialisation
 117     fListHistCascade(0),
 118     fHistEvtsInCentralityBinsvsNtracks(0),
 119     fHistCascadeMultiplicityBeforeEvSel(0),
 120     fHistCascadeMultiplicityForCentrEvt(0), fHistTrackMultiplicityForCentrEvt(0), fHistTPCrefitTrackMultiplicityForCentrEvt(0),
 121     fHistCascadeMultiplicityForSelEvt(0),
 122     fHistPosBestPrimaryVtxXForSelEvt(0), fHistPosBestPrimaryVtxYForSelEvt(0), fHistPosBestPrimaryVtxZForSelEvt(0),
 123     fHistTPCrefitTrackMultiplicityForCascadeEvt(0),
 124     fHistPosV0TPCClusters(0), fHistNegV0TPCClusters(0), fHistBachTPCClusters(0),
 125     fHistVtxStatus(0),
 126
 127     fHistPosTrkgPrimaryVtxXForCascadeEvt(0), fHistPosTrkgPrimaryVtxYForCascadeEvt(0), fHistPosTrkgPrimaryVtxZForCascadeEvt(0), fHistTrkgPrimaryVtxRadius(0),
 128     fHistPosBestPrimaryVtxXForCascadeEvt(0), fHistPosBestPrimaryVtxYForCascadeEvt(0), fHistPosBestPrimaryVtxZForCascadeEvt(0), fHistBestPrimaryVtxRadius(0),
 129     f2dHistTrkgPrimVtxVsBestPrimVtx(0),
 130
 131     fHistEffMassXi(0),  fHistChi2Xi(0),
 132
 133     fHistDcaXiDaughters(0), fHistDcaBachToPrimVertex(0), fHistXiCosineOfPointingAngle(0), fHistXiRadius(0),
 134
 135     fHistMassLambdaAsCascDghter(0),
 136     fHistV0Chi2Xi(0),
 137     fHistDcaV0DaughtersXi(0),
 138     fHistDcaV0ToPrimVertexXi(0),
 139     fHistV0CosineOfPointingAngle(0),
 140     fHistV0RadiusXi(0),
 141     fHistDcaPosToPrimVertexXi(0), fHistDcaNegToPrimVertexXi(0),
 142
 143     fHistMassXiMinus(0), fHistMassXiPlus(0),
 144     fHistMassOmegaMinus(0), fHistMassOmegaPlus(0),
 145     fHistMassWithCombPIDXiMinus(0), fHistMassWithCombPIDXiPlus(0),
 146     fHistMassWithCombPIDOmegaMinus(0), fHistMassWithCombPIDOmegaPlus(0),
 147
 148     fHistXiTransvMom(0),    fHistXiTotMom(0),
 149     fHistBachTransvMomXi(0),   fHistBachTotMomXi(0),
 150     fHistPosTransvMomXi(0), fHistNegTransvMomXi(0),
 151
 152     fHistChargeXi(0),
 153     fHistV0toXiCosineOfPointingAngle(0),
 154
 155     fHistRapXi(0), fHistRapOmega(0), fHistEtaXi(0),
 156     fHistThetaXi(0), fHistPhiXi(0),
 157
 158     f2dHistArmenteros(0),
 159     f2dHistEffMassLambdaVsEffMassXiMinus(0), f2dHistEffMassXiVsEffMassOmegaMinus(0),
 160     f2dHistEffMassLambdaVsEffMassXiPlus(0), f2dHistEffMassXiVsEffMassOmegaPlus(0),
 161     f2dHistXiRadiusVsEffMassXiMinus(0), f2dHistXiRadiusVsEffMassXiPlus(0),
 162     f2dHistXiRadiusVsEffMassOmegaMinus(0), f2dHistXiRadiusVsEffMassOmegaPlus(0),
 163
 164     f2dHistTPCdEdxOfCascDghters(0),
 165
 166 //    f3dHistXiPtVsEffMassVsYXiMinus(0), f3dHistXiPtVsEffMassVsYXiPlus(0),
 167 //    f3dHistXiPtVsEffMassVsYOmegaMinus(0), f3dHistXiPtVsEffMassVsYOmegaPlus(0),
 168
 169     fCFContCascadePIDXiMinus(0),
 170     fCFContCascadePIDXiPlus(0),
 171     fCFContCascadePIDOmegaMinus(0),
 172     fCFContCascadePIDOmegaPlus(0),
 173     fCFContCascadeCuts(0),
 174
 175 //    fHnSpAngularCorrXiMinus(0), fHnSpAngularCorrXiPlus(0),
 176 //    fHnSpAngularCorrOmegaMinus(0), fHnSpAngularCorrOmegaPlus(0),
 177     fV0Ampl(0),
 178
 179     fHistDcaXiDaughtersvsInvMass(0), fHistDcaBachToPrimVertexvsInvMass(0), fHistXiCosineOfPointingAnglevsInvMass(0),
 180     fHistMassLambdaAsCascDghtervsInvMass(0),fHistDcaV0DaughtersXivsInvMass(0),fHistDcaV0ToPrimVertexXivsInvMass(0)
 181
 182
 183 {
 184   // Dummy Constructor
 185         for(Int_t iV0selIdx   = 0; iV0selIdx   < 7; iV0selIdx++   ) { fV0Sels          [iV0selIdx   ] = -1.; }
 186         for(Int_t iCascSelIdx = 0; iCascSelIdx < 8; iCascSelIdx++ ) { fCascSels        [iCascSelIdx ] = -1.; }
 187 }
 188
 189
 190 //________________________________________________________________________
 191 AliAnalysisTaskCheckCascadePbPb::AliAnalysisTaskCheckCascadePbPb(const char *name)
 192   : AliAnalysisTaskSE(name), fAnalysisType("ESD"), fESDtrackCuts(0), /*fPaveTextBookKeeping(0),*/
 193     fPIDResponse                (0),
 194     fkRerunV0CascVertexers      (0),
 195     fkQualityCutZprimVtxPos     (kTRUE),
 196     fkQualityCutNoTPConlyPrimVtx(kTRUE),
 197     fkQualityCutTPCrefit        (kTRUE),
 198     fkQualityCutnTPCcls         (kTRUE),
 199     fMinnTPCcls                 (0),
 200     fkExtraSelections           (0),
 201     fCentrLowLim                (0),
 202     fCentrUpLim                 (0),
 203     fCentrEstimator             (0),
 204     fkUseCleaning               (0),
 205     fVtxRange                   (0),
 206     fMinPtCutOnDaughterTracks   (0),
 207
 208         // - Cascade part initialisation
 209     fListHistCascade(0),
 210     fHistEvtsInCentralityBinsvsNtracks(0),
 211     fHistCascadeMultiplicityBeforeEvSel(0),
 212     fHistCascadeMultiplicityForCentrEvt(0), fHistTrackMultiplicityForCentrEvt(0), fHistTPCrefitTrackMultiplicityForCentrEvt(0),
 213     fHistCascadeMultiplicityForSelEvt(0),
 214     fHistPosBestPrimaryVtxXForSelEvt(0), fHistPosBestPrimaryVtxYForSelEvt(0), fHistPosBestPrimaryVtxZForSelEvt(0),
 215     fHistTPCrefitTrackMultiplicityForCascadeEvt(0),
 216     fHistPosV0TPCClusters(0), fHistNegV0TPCClusters(0), fHistBachTPCClusters(0),
 217     fHistVtxStatus(0),
 218
 219     fHistPosTrkgPrimaryVtxXForCascadeEvt(0), fHistPosTrkgPrimaryVtxYForCascadeEvt(0), fHistPosTrkgPrimaryVtxZForCascadeEvt(0), fHistTrkgPrimaryVtxRadius(0),
 220     fHistPosBestPrimaryVtxXForCascadeEvt(0), fHistPosBestPrimaryVtxYForCascadeEvt(0), fHistPosBestPrimaryVtxZForCascadeEvt(0), fHistBestPrimaryVtxRadius(0),
 221     f2dHistTrkgPrimVtxVsBestPrimVtx(0),
 222
 223     fHistEffMassXi(0),  fHistChi2Xi(0),
 224     fHistDcaXiDaughters(0), fHistDcaBachToPrimVertex(0), fHistXiCosineOfPointingAngle(0), fHistXiRadius(0),
 225
 226     fHistMassLambdaAsCascDghter(0),
 227     fHistV0Chi2Xi(0),
 228     fHistDcaV0DaughtersXi(0),
 229     fHistDcaV0ToPrimVertexXi(0),
 230     fHistV0CosineOfPointingAngle(0),
 231     fHistV0RadiusXi(0),
 232     fHistDcaPosToPrimVertexXi(0), fHistDcaNegToPrimVertexXi(0),
 233
 234     fHistMassXiMinus(0), fHistMassXiPlus(0),
 235     fHistMassOmegaMinus(0), fHistMassOmegaPlus(0),
 236     fHistMassWithCombPIDXiMinus(0), fHistMassWithCombPIDXiPlus(0),
 237     fHistMassWithCombPIDOmegaMinus(0), fHistMassWithCombPIDOmegaPlus(0),
 238
 239     fHistXiTransvMom(0),    fHistXiTotMom(0),
 240     fHistBachTransvMomXi(0),   fHistBachTotMomXi(0),
 241     fHistPosTransvMomXi(0), fHistNegTransvMomXi(0),
 242
 243     fHistChargeXi(0),
 244     fHistV0toXiCosineOfPointingAngle(0),
 245
 246     fHistRapXi(0), fHistRapOmega(0), fHistEtaXi(0),
 247     fHistThetaXi(0), fHistPhiXi(0),
 248
 249     f2dHistArmenteros(0),
 250     f2dHistEffMassLambdaVsEffMassXiMinus(0), f2dHistEffMassXiVsEffMassOmegaMinus(0),
 251     f2dHistEffMassLambdaVsEffMassXiPlus(0), f2dHistEffMassXiVsEffMassOmegaPlus(0),
 252     f2dHistXiRadiusVsEffMassXiMinus(0), f2dHistXiRadiusVsEffMassXiPlus(0),
 253     f2dHistXiRadiusVsEffMassOmegaMinus(0), f2dHistXiRadiusVsEffMassOmegaPlus(0),
 254
 255     f2dHistTPCdEdxOfCascDghters(0),
 256
 257 //    f3dHistXiPtVsEffMassVsYXiMinus(0), f3dHistXiPtVsEffMassVsYXiPlus(0),
 258 //    f3dHistXiPtVsEffMassVsYOmegaMinus(0), f3dHistXiPtVsEffMassVsYOmegaPlus(0),
 259
 260     fCFContCascadePIDXiMinus(0),
 261     fCFContCascadePIDXiPlus(0),
 262     fCFContCascadePIDOmegaMinus(0),
 263     fCFContCascadePIDOmegaPlus(0),
 264     fCFContCascadeCuts(0),
 265
 266 //    fHnSpAngularCorrXiMinus(0), fHnSpAngularCorrXiPlus(0),
 267 //    fHnSpAngularCorrOmegaMinus(0), fHnSpAngularCorrOmegaPlus(0),
 268     fV0Ampl(0),
 269
 270     fHistDcaXiDaughtersvsInvMass(0), fHistDcaBachToPrimVertexvsInvMass(0), fHistXiCosineOfPointingAnglevsInvMass(0),
 271     fHistMassLambdaAsCascDghtervsInvMass(0),fHistDcaV0DaughtersXivsInvMass(0),fHistDcaV0ToPrimVertexXivsInvMass(0)
 272
 273
 274 {
 275   // Constructor
 276
 277   // Define input and output slots here
 278   // Input slot #0 works with a TChain
 279   // DefineInput(0, TChain::Class());
 280   // Output slot #1 writes into a TList container (cascade)
 281         // default Pb-Pb values
 282         fV0Sels[0] =  33.  ;  // max allowed chi2
 283         fV0Sels[1] =   0.1;   // min allowed impact parameter for the 1st daughter
 284         fV0Sels[2] =   0.1;   // min allowed impact parameter for the 2nd daughter
 285         fV0Sels[3] =   1.;    // max allowed DCA between the daughter tracks
 286         fV0Sels[4] =    .998 ;// min allowed cosine of V0's pointing angle
 287         fV0Sels[5] =   0.9 ;  // min radius of the fiducial volume
 288         fV0Sels[6] = 100.  ;    // max radius of the fiducial volume
 289
 290         fCascSels[0] =  33.   ;  // max allowed chi2 (same as PDC07)
 291         fCascSels[1] =   0.05;  // min allowed V0 impact parameter
 292         fCascSels[2] =   0.008;  // "window" around the Lambda mass
 293         fCascSels[3] =   0.03;   // min allowed bachelor's impact parameter           //check cuts
 294         fCascSels[4] =   0.3  ;  // max allowed DCA between the V0 and the bachelor
 295         fCascSels[5] =   0.999 ;// min allowed cosine of the cascade pointing angle
 296         fCascSels[6] =   0.9  ;  // min radius of the fiducial volume
 297         fCascSels[7] = 100.   ;  // max radius of the fiducial volume
 298
 299   // Output slot #0 writes into a TList container (Cascade)
 300   DefineOutput(1, TList::Class());
 301   DefineOutput(2, AliCFContainer::Class());
 302   DefineOutput(3, AliCFContainer::Class());
 303   DefineOutput(4, AliCFContainer::Class());
 304   DefineOutput(5, AliCFContainer::Class());
 305   DefineOutput(6, AliCFContainer::Class());
 306
 307   /*DefineOutput(2, TPaveText::Class());*/
 308   AliLog::SetClassDebugLevel("AliAnalysisTaskCheckCascadePbPb",1); // MN this should (?) enable only AliFatal
 309 }
 310
 311
 312 AliAnalysisTaskCheckCascadePbPb::~AliAnalysisTaskCheckCascadePbPb() {
 313   //
 314   // Destructor
 315   //
 316
 317   // For all TH1, 2, 3 HnSparse and CFContainer are in the fListCascade TList.
 318   // They will be deleted when fListCascade is deleted by the TSelector dtor
 319   // Because of TList::SetOwner() ...
 320
 321   if (fListHistCascade && !AliAnalysisManager::GetAnalysisManager()->IsProofMode())         { delete fListHistCascade;     fListHistCascade = 0x0;    }
 322     if (fCFContCascadePIDXiMinus && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadePIDXiMinus;     fCFContCascadePIDXiMinus = 0x0;  }
 323   if (fCFContCascadePIDXiPlus && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadePIDXiPlus;     fCFContCascadePIDXiPlus = 0x0;  }
 324   if (fCFContCascadePIDOmegaMinus && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadePIDOmegaMinus;     fCFContCascadePIDOmegaMinus = 0x0;  }
 325   if (fCFContCascadePIDOmegaPlus && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadePIDOmegaPlus;     fCFContCascadePIDOmegaPlus = 0x0;  }
 326   if (fCFContCascadeCuts && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { delete fCFContCascadePIDOmegaPlus;     fCFContCascadeCuts = 0x0;  }
 327
 328   if (fESDtrackCuts)         { delete fESDtrackCuts;        fESDtrackCuts = 0x0; }
 329   //if (fPaveTextBookKeeping)     { delete fPaveTextBookKeeping; fPaveTextBookKeeping = 0x0;} // fPaveTextBookKeeping is not strored in the TList
 330 }
 331
 332
 333
 334 //________________________________________________________________________
 335 void AliAnalysisTaskCheckCascadePbPb::UserCreateOutputObjects() {
 336   // Create histograms
 337   // Called once
 338
 339
 340
 341  fListHistCascade = new TList();
 342  fListHistCascade->SetOwner();  // See http://root.cern.ch/root/html/TCollection.html#TCollection:SetOwner
 343
 344  // New PID object
 345  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 346  AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 347  fPIDResponse = inputHandler->GetPIDResponse();
 348
 349  // Only used to get the number of primary reconstructed tracks
 350  if (fAnalysisType == "ESD"&& (! fESDtrackCuts )){
 351    fESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE); // Std definition of primary (see kTRUE argument) tracks for 2010
 352 //   fESDtrackCuts->SetEtaRange(-0.8,+0.8);
 353 //   fESDtrackCuts->SetPtRange(0.15, 1e10);
 354    Printf("CheckCascade - ESDtrackCuts set up to 2010 std ITS-TPC cuts...");
 355  }
 356
 357  // Initialize cuts to re-run V0 and cascade vertexers
 358  fV0Sels[0] =  33.   ;     // max allowed chi2
 359  fV0Sels[1] =   0.1  ;     // min allowed impact parameter for the 1st daughter
 360  fV0Sels[2] =   0.1  ;     // min allowed impact parameter for the 2nd daughter
 361  fV0Sels[3] =   1.   ;     // max allowed DCA between the daughter tracks
 362  fV0Sels[4] =    .998;     // min allowed cosine of V0's pointing angle
 363  fV0Sels[5] =   0.9  ;     // min radius of the fiducial volume
 364  fV0Sels[6] = 100.   ;     // max radius of the fiducial volume
 365
 366  fCascSels[0] =  33.    ;  // max allowed chi2 (not used)
 367  fCascSels[1] =   0.05  ;  // min allowed V0 impact parameter
 368  fCascSels[2] =   0.008 ;  // "window" around the Lambda mass
 369  fCascSels[3] =   0.05  ;  // min allowed bachelor's impact parameter
 370  fCascSels[4] =   0.3   ;  // max allowed DCA between the V0 and the bachelor
 371  fCascSels[5] =   0.9989;  // min allowed cosine of the cascade pointing angle
 372  fCascSels[6] =   0.9   ;  // min radius of the fiducial volume
 373  fCascSels[7] = 100.    ;
 374
 375
 376 /*
 377 if( !fPaveTextBookKeeping){
 378         // FIXME : prepare a field with the AliRoot+root distrib ...
 379
 380         fPaveTextBookKeeping = new TPaveText(0.1, 0.1, 0.9, 0.9,"NDC");
 381         fPaveTextBookKeeping->SetName("fPaveTextBookKeeping");
 382         fPaveTextBookKeeping->SetBorderSize(0);
 383         fPaveTextBookKeeping->SetTextAlign(12);
 384         fPaveTextBookKeeping->SetFillColor(kWhite);
 385         fPaveTextBookKeeping->SetTextFont(42);        // regular Arial or Helvetica,
 386         fPaveTextBookKeeping->SetTextColor(kBlue+4);
 387
 388         fPaveTextBookKeeping->AddText( "Task CHECK CASCADE analysis" );
 389         fPaveTextBookKeeping->AddText("- - - - - - - - - - - ");
 390         fPaveTextBookKeeping->AddText( Form("AnalysisType : %s ", fAnalysisType.Data() ));
 391
 392         else                    fPaveTextBookKeeping->AddText("Colliding system : A-A collisions ");
 393
 394         fPaveTextBookKeeping->AddText("- - - - - - - - - - - ");
 395
 396         if(fkRerunV0CascVertexers){
 397                 fPaveTextBookKeeping->AddText("A.1. With V0 vertexer : ");
 398                 fPaveTextBookKeeping->AddText( Form("  - V0 #chi^{2} _________________ <  %.3f ",               fV0Sels[0] ));
 399                 fPaveTextBookKeeping->AddText( Form("  - DCA(prim. Vtx/ 1^{st} daughter) ___ >  %.3f     cm ",  fV0Sels[1] ));
 400                 fPaveTextBookKeeping->AddText( Form("  - DCA(prim. Vtx/ 2^{nd} daughter) __  >  %.3f     cm",   fV0Sels[2] ));
 401                 fPaveTextBookKeeping->AddText( Form("  - DCA between V0 daughters ___ <  %.3f      cm",         fV0Sels[3] ));
 402                 fPaveTextBookKeeping->AddText( Form("  - cos(V0 pointing angle) _______ >  %.3f ",              fV0Sels[4] ));
 403                 fPaveTextBookKeeping->AddText( Form("  - R_{transv}(V0 decay) ________ >  %.3f             cm", fV0Sels[5] ));
 404                 fPaveTextBookKeeping->AddText( Form("  - R_{transv}(V0 decay) ________ <  %.3f         cm",     fV0Sels[6] ));
 405
 406                 fPaveTextBookKeeping->AddText(" ");
 407
 408                 fPaveTextBookKeeping->AddText("A.2. With Casc. vertexer : ");
 409                 fPaveTextBookKeeping->AddText( Form("  - Casc. #chi^{2} ______________  <  %.3f ",                               fCascSels[0] ));
 410                 fPaveTextBookKeeping->AddText( Form("  - DCA(prim. Vtx/ V0) _________ >  %.3f    cm",                            fCascSels[1] ));
 411                 fPaveTextBookKeeping->AddText( Form("  - | M_{#Lambda}(reco) - M_{#Lambda}(pdg) | _______ <  %.3f    GeV/c^{2}", fCascSels[2] ));
 412                 fPaveTextBookKeeping->AddText( Form("  - DCA(prim. Vtx/ Bach) _______ >  %.3f    cm",                            fCascSels[3] ));
 413                 fPaveTextBookKeeping->AddText( Form("  - DCA between Bach/ #Lambda ______ <  %.3f    cm",                        fCascSels[4] ));
 414                 fPaveTextBookKeeping->AddText( Form("  - cos(Casc. pointing angle) ____ >  %.3f ",                               fCascSels[5] ));
 415                 fPaveTextBookKeeping->AddText( Form("  - R_{transv}(Casc. decay) ______ >  %.3f         cm",                     fCascSels[6] ));
 416                 fPaveTextBookKeeping->AddText( Form("  - R_{transv}(Casc. decay) ______ <  %.3f     cm",                         fCascSels[7] ));
 417         }
 418         else{   fPaveTextBookKeeping->AddText("A. No rerunning of the V0/Casc. vertexers ... See std cuts in (AliRoot+Rec.C) used for this prod. cycle");}
 419
 420         fPaveTextBookKeeping->AddText("- - - - - - - - - - - ");
 421
 422         if(fkQualityCutZprimVtxPos)      fPaveTextBookKeeping->AddText("B. Quality Cut(prim. Vtx z-Pos)    = ON  ");
 423         else                             fPaveTextBookKeeping->AddText("B. Quality Cut(prim. Vtx z-Pos)    = Off ");
 424         if(fkQualityCutNoTPConlyPrimVtx) fPaveTextBookKeeping->AddText("C. Quality Cut(No TPC prim. vtx) = ON  ");
 425         else                             fPaveTextBookKeeping->AddText("C. Quality Cut(No TPC prim. vtx) = Off ");
 426         if(fkQualityCutTPCrefit)         fPaveTextBookKeeping->AddText("D. Quality Cut(TPCrefit)               = ON  ");
 427         else                             fPaveTextBookKeeping->AddText("D. Quality Cut(TPCrefit)               = Off ");
 428         if(fkQualityCutnTPCcls)          fPaveTextBookKeeping->AddText("E. Quality Cut(min n TPC clusters)   = ON  ");
 429         else                             fPaveTextBookKeeping->AddText("E. Quality Cut(min n TPC clusters)   = Off ");
 430         if(fkExtraSelections)            fPaveTextBookKeeping->AddText("F. Extra Analysis Selections         = ON  ");
 431         else                             fPaveTextBookKeeping->AddText("F. Extra Analysis Selections         = Off ");
 432
 433         fPaveTextBookKeeping->AddText("- - - - - - - - - - - ");
 434
 435 }
 436 */
 437
 438         // - General histos
 439         //--------------
 440         // Events in centraity bins
 441         Double_t centBinLimits[12] = {0.,5.,10.,20.,30.,40.,50.,60.,70.,80.,90.,100.};
 442         fHistEvtsInCentralityBinsvsNtracks = new TH2F("fHistEvtsInCentralityBinsvsNtracks","",11,centBinLimits,100,0.,6000.);
 443         fListHistCascade->Add(fHistEvtsInCentralityBinsvsNtracks);
 444
 445 if(! fHistCascadeMultiplicityBeforeEvSel) {
 446         fHistCascadeMultiplicityBeforeEvSel = new TH1F("fHistCascadeMultiplicityBeforeEvSel",
 447                         "Cascades per event (before vertex and centrality selections);Nbr of Cascades/Evt;Events",
 448                         100, 0, 200000);
 449         fListHistCascade->Add(fHistCascadeMultiplicityBeforeEvSel);
 450 }
 451
 452         // - Histos for events passing the trigger selection
 453         //--------------
 454
 455 if(! fHistCascadeMultiplicityForCentrEvt) {
 456         fHistCascadeMultiplicityForCentrEvt = new TH1F("fHistCascadeMultiplicityForCentrEvt",
 457                         "Cascades per event (for triggered evt);Nbr of Cascades/Evt;Events",
 458                         100, 0, 200000);
 459         fListHistCascade->Add(fHistCascadeMultiplicityForCentrEvt);
 460 }
 461
 462
 463 if(! fHistTrackMultiplicityForCentrEvt) {
 464         fHistTrackMultiplicityForCentrEvt = new TH1F("fHistTrackMultiplicityForCentrEvt",
 465                         "Track Multiplicity (for triggered evt);Nbr of tracks/Evt;Events",
 466                         200, 0, 12000);
 467         fListHistCascade->Add(fHistTrackMultiplicityForCentrEvt);
 468 }
 469
 470 if(! fHistTPCrefitTrackMultiplicityForCentrEvt) {
 471         fHistTPCrefitTrackMultiplicityForCentrEvt = new TH1F("fHistTPCrefitTrackMultiplicityForCentrEvt",
 472                         "TPCrefit track Multiplicity (for triggered evt);Nbr of TPCrefit tracks/Evt;Events",
 473                         200, 0, 12000);
 474         fListHistCascade->Add(fHistTPCrefitTrackMultiplicityForCentrEvt);
 475 }
 476
 477         // - Histos for events passing the event selection at the analysis level
 478         //--------------
 479
 480 if(! fHistCascadeMultiplicityForSelEvt) {
 481         fHistCascadeMultiplicityForSelEvt = new TH1F("fHistCascadeMultiplicityForSelEvt",
 482                         "Cascades per event;Nbr of Cascades/Evt;Events",
 483                         100, 0, 200000);
 484         fListHistCascade->Add(fHistCascadeMultiplicityForSelEvt);
 485 }
 486
 487 if(! fHistPosBestPrimaryVtxXForSelEvt ){
 488         fHistPosBestPrimaryVtxXForSelEvt   = new TH1F( "fHistPosBestPrimaryVtxXForSelEvt" , "Best Prim. Vertex Position in x; x (cm); Events" , 360, -0.9, 0.9 );
 489         fListHistCascade->Add(fHistPosBestPrimaryVtxXForSelEvt);
 490 }
 491
 492 if(! fHistPosBestPrimaryVtxYForSelEvt){
 493         fHistPosBestPrimaryVtxYForSelEvt   = new TH1F( "fHistPosBestPrimaryVtxYForSelEvt" , "Best Prim. Vertex Position in y; y (cm); Events" , 360, -0.9, 0.9 );
 494         fListHistCascade->Add(fHistPosBestPrimaryVtxYForSelEvt);
 495 }
 496
 497 if(! fHistPosBestPrimaryVtxZForSelEvt ){
 498         fHistPosBestPrimaryVtxZForSelEvt   = new TH1F( "fHistPosBestPrimaryVtxZForSelEvt" , "Best Prim. Vertex Position in z; z (cm); Events" , 300, -30.0, 30.0 );
 499         fListHistCascade->Add(fHistPosBestPrimaryVtxZForSelEvt);
 500 }
 501
 502
 503
 504
 505         // - Histos for events containing at least ONE CASCADE
 506         //--------------
 507
 508 if(! fHistTPCrefitTrackMultiplicityForCascadeEvt) {
 509         fHistTPCrefitTrackMultiplicityForCascadeEvt = new TH1F("fHistTPCrefitTrackMultiplicityForCascadeEvt",
 510                         "TPCrefit track Multiplicity (for evt with Casc.);Nbr of TPCrefit tracks/Evt with cascade(s);Events",
 511                         200, 0, 20000);
 512         fListHistCascade->Add(fHistTPCrefitTrackMultiplicityForCascadeEvt);
 513 }
 514
 515 if(! fHistPosV0TPCClusters ){
 516         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);
 517         fListHistCascade->Add(fHistPosV0TPCClusters);
 518 }
 519
 520 if(! fHistNegV0TPCClusters ){
 521         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);
 522         fListHistCascade->Add(fHistNegV0TPCClusters);
 523 }
 524
 525 if(! fHistBachTPCClusters ){
 526         fHistBachTPCClusters = new TH1F("fHistBachTPCClusters", "TPC clusters for Bachelor track; Nbr of TPC clusters (Bach); Track counts", 165, 0.0 ,165.0);
 527         fListHistCascade->Add(fHistBachTPCClusters);
 528 }
 529
 530
 531
 532 if(! fHistVtxStatus ){
 533         fHistVtxStatus   = new TH1F( "fHistVtxStatus" , "Does a Trckg Prim.vtx exist ?; true=1 or false=0; Nb of Events" , 4, -1.0, 3.0 );
 534         fListHistCascade->Add(fHistVtxStatus);
 535 }
 536
 537
 538         // - Vertex Positions
 539
 540 if(! fHistPosTrkgPrimaryVtxXForCascadeEvt ){
 541         fHistPosTrkgPrimaryVtxXForCascadeEvt   = new TH1F( "fHistPosTrkgPrimaryVtxXForCascadeEvt" , "Trkg Prim. Vertex Position in x; x (cm); Events" , 120, -0.6, 0.6 );
 542         fListHistCascade->Add(fHistPosTrkgPrimaryVtxXForCascadeEvt);
 543 }
 544
 545
 546 if(! fHistPosTrkgPrimaryVtxYForCascadeEvt){
 547         fHistPosTrkgPrimaryVtxYForCascadeEvt   = new TH1F( "fHistPosTrkgPrimaryVtxYForCascadeEvt" , "Trkg Prim. Vertex Position in y; y (cm); Events" , 120, -0.6, 0.6 );
 548         fListHistCascade->Add(fHistPosTrkgPrimaryVtxYForCascadeEvt);
 549 }
 550
 551 if(! fHistPosTrkgPrimaryVtxZForCascadeEvt ){
 552         fHistPosTrkgPrimaryVtxZForCascadeEvt   = new TH1F( "fHistPosTrkgPrimaryVtxZForCascadeEvt" , "Trkg Prim. Vertex Position in z; z (cm); Events" , 200, -20.0, 20.0 );
 553         fListHistCascade->Add(fHistPosTrkgPrimaryVtxZForCascadeEvt);
 554 }
 555
 556 if(! fHistTrkgPrimaryVtxRadius ){
 557         fHistTrkgPrimaryVtxRadius  = new TH1F( "fHistTrkgPrimaryVtxRadius",  "Trkg Prim. Vertex radius; r (cm); Events" , 150, 0., 15.0 );
 558         fListHistCascade->Add(fHistTrkgPrimaryVtxRadius);
 559 }
 560
 561
 562
 563
 564 if(! fHistPosBestPrimaryVtxXForCascadeEvt ){
 565         fHistPosBestPrimaryVtxXForCascadeEvt   = new TH1F( "fHistPosBestPrimaryVtxXForCascadeEvt" , "Best Prim. Vertex Position in x; x (cm); Events" , 120, -0.6, 0.6 );
 566         fListHistCascade->Add(fHistPosBestPrimaryVtxXForCascadeEvt);
 567 }
 568
 569 if(! fHistPosBestPrimaryVtxYForCascadeEvt){
 570         fHistPosBestPrimaryVtxYForCascadeEvt   = new TH1F( "fHistPosBestPrimaryVtxYForCascadeEvt" , "Best Prim. Vertex Position in y; y (cm); Events" , 120, -0.6, 0.6 );
 571         fListHistCascade->Add(fHistPosBestPrimaryVtxYForCascadeEvt);
 572 }
 573
 574 if(! fHistPosBestPrimaryVtxZForCascadeEvt ){
 575         fHistPosBestPrimaryVtxZForCascadeEvt   = new TH1F( "fHistPosBestPrimaryVtxZForCascadeEvt" , "Best Prim. Vertex Position in z; z (cm); Events" , 200, -20.0, 20.0 );
 576         fListHistCascade->Add(fHistPosBestPrimaryVtxZForCascadeEvt);
 577 }
 578
 579 if(! fHistBestPrimaryVtxRadius ){
 580         fHistBestPrimaryVtxRadius  = new TH1F( "fHistBestPrimaryVtxRadius",  "Best Prim.  vertex radius; r (cm); Events" , 150, 0., 15.0 );
 581         fListHistCascade->Add(fHistBestPrimaryVtxRadius);
 582 }
 583
 584 if(! f2dHistTrkgPrimVtxVsBestPrimVtx) {
 585         f2dHistTrkgPrimVtxVsBestPrimVtx = new TH2F( "f2dHistTrkgPrimVtxVsBestPrimVtx", "r_{Trck Prim. Vtx} Vs r_{Best Prim. Vtx}; r_{Track Vtx} (cm); r_{Best Vtx} (cm)", 150, 0., 15.0, 150, 0., 15.);
 586         fListHistCascade->Add(f2dHistTrkgPrimVtxVsBestPrimVtx);
 587 }
 588
 589
 590
 591
 592 // - Typical histos for cascades
 593
 594
 595 if(! fHistEffMassXi) {
 596      fHistEffMassXi = new TH1F("fHistEffMassXi", "Cascade candidates ; Invariant Mass (GeV/c^{2}) ; Counts", 400, 1.2, 2.0);
 597      fListHistCascade->Add(fHistEffMassXi);
 598 }
 599
 600 if(! fHistChi2Xi ){
 601         fHistChi2Xi = new TH1F("fHistChi2Xi", "Cascade #chi^{2}; #chi^{2}; Number of Cascades", 160, 0, 40);
 602         fListHistCascade->Add(fHistChi2Xi);
 603 }
 604
 605 if(! fHistDcaXiDaughters ){
 606         fHistDcaXiDaughters = new TH1F( "fHistDcaXiDaughters",  "DCA between Xi Daughters; DCA (cm) ; Number of Cascades", 100, 0., 0.5);
 607         fListHistCascade->Add(fHistDcaXiDaughters);
 608 }
 609
 610 if(! fHistDcaBachToPrimVertex) {
 611         fHistDcaBachToPrimVertex = new TH1F("fHistDcaBachToPrimVertex", "DCA of Bach. to Prim. Vertex;DCA (cm);Number of Cascades", 250, 0., 0.25);
 612         fListHistCascade->Add(fHistDcaBachToPrimVertex);
 613 }
 614
 615 if(! fHistXiCosineOfPointingAngle) {
 616         fHistXiCosineOfPointingAngle = new TH1F("fHistXiCosineOfPointingAngle", "Cosine of Xi Pointing Angle; Cos (Xi Point.Angl);Number of Xis", 101, 0.99, 1.0001);
 617         fListHistCascade->Add(fHistXiCosineOfPointingAngle);
 618 }
 619
 620 if(! fHistXiRadius ){
 621         fHistXiRadius  = new TH1F( "fHistXiRadius",  "Casc. decay transv. radius; r (cm); Counts" , 1050, 0., 105.0 );
 622         fListHistCascade->Add(fHistXiRadius);
 623 }
 624
 625
 626 // - Histos about ~ the "V0 part" of the cascade,  coming by inheritance from AliESDv0
 627
 628
 629
 630 if (! fHistMassLambdaAsCascDghter) {
 631      fHistMassLambdaAsCascDghter = new TH1F("fHistMassLambdaAsCascDghter","#Lambda associated to Casc. candidates;Eff. Mass (GeV/c^{2});Counts", 300,1.00,1.3);
 632     fListHistCascade->Add(fHistMassLambdaAsCascDghter);
 633 }
 634
 635 if (! fHistV0Chi2Xi) {
 636         fHistV0Chi2Xi = new TH1F("fHistV0Chi2Xi", "V0 #chi^{2}, in cascade; #chi^{2};Counts", 160, 0, 40);
 637         fListHistCascade->Add(fHistV0Chi2Xi);
 638 }
 639
 640 if (! fHistDcaV0DaughtersXi) {
 641         fHistDcaV0DaughtersXi = new TH1F("fHistDcaV0DaughtersXi", "DCA between V0 daughters, in cascade;DCA (cm);Number of V0s", 240, 0., 1.2);
 642         fListHistCascade->Add(fHistDcaV0DaughtersXi);
 643 }
 644
 645 if (! fHistDcaV0ToPrimVertexXi) {
 646         fHistDcaV0ToPrimVertexXi = new TH1F("fHistDcaV0ToPrimVertexXi", "DCA of V0 to Prim. Vertex, in cascade;DCA (cm);Number of Cascades", 200, 0., 1.);
 647         fListHistCascade->Add(fHistDcaV0ToPrimVertexXi);
 648 }
 649
 650 if (! fHistV0CosineOfPointingAngle) {
 651         fHistV0CosineOfPointingAngle = new TH1F("fHistV0CosineOfPointingAngle", "Cosine of V0 Pointing Angle, in cascade;Cos(V0 Point. Angl); Counts", 200, 0.95, 1.0001);
 652         fListHistCascade->Add(fHistV0CosineOfPointingAngle);
 653 }
 654
 655 if (! fHistV0RadiusXi) {
 656         fHistV0RadiusXi = new TH1F("fHistV0RadiusXi", "V0 decay radius, in cascade; radius (cm); Counts", 1050, 0., 105.0);
 657         fListHistCascade->Add(fHistV0RadiusXi);
 658 }
 659
 660 if (! fHistDcaPosToPrimVertexXi) {
 661         fHistDcaPosToPrimVertexXi = new TH1F("fHistDcaPosToPrimVertexXi", "DCA of V0 pos daughter to Prim. Vertex;DCA (cm);Counts", 300, 0, 3);
 662         fListHistCascade->Add(fHistDcaPosToPrimVertexXi);
 663 }
 664
 665 if (! fHistDcaNegToPrimVertexXi) {
 666         fHistDcaNegToPrimVertexXi = new TH1F("fHistDcaNegToPrimVertexXi", "DCA of V0 neg daughter to Prim. Vertex;DCA (cm);Counts", 300, 0, 3);
 667         fListHistCascade->Add(fHistDcaNegToPrimVertexXi);
 668 }
 669
 670
 671
 672
 673         // - Effective mass histos for cascades.
 674 // By cascade hyp
 675 if (! fHistMassXiMinus) {
 676     fHistMassXiMinus = new TH1F("fHistMassXiMinus","#Xi^{-} candidates;M( #Lambda , #pi^{-} ) (GeV/c^{2});Counts", 400,1.2,2.0);
 677     fListHistCascade->Add(fHistMassXiMinus);
 678 }
 679
 680 if (! fHistMassXiPlus) {
 681     fHistMassXiPlus = new TH1F("fHistMassXiPlus","#Xi^{+} candidates;M( #bar{#Lambda}^{0} , #pi^{+} ) (GeV/c^{2});Counts",400,1.2,2.0);
 682     fListHistCascade->Add(fHistMassXiPlus);
 683 }
 684
 685 if (! fHistMassOmegaMinus) {
 686         fHistMassOmegaMinus = new TH1F("fHistMassOmegaMinus","#Omega^{-} candidates;M( #Lambda , K^{-} ) (GeV/c^{2});Counts", 500,1.5,2.5);
 687     fListHistCascade->Add(fHistMassOmegaMinus);
 688 }
 689
 690 if (! fHistMassOmegaPlus) {
 691         fHistMassOmegaPlus = new TH1F("fHistMassOmegaPlus","#Omega^{+} candidates;M( #bar{#Lambda}^{0} , K^{+} ) (GeV/c^{2});Counts", 500,1.5,2.5);
 692     fListHistCascade->Add(fHistMassOmegaPlus);
 693 }
 694
 695 // By cascade hyp + bachelor PID
 696 if (! fHistMassWithCombPIDXiMinus) {
 697     fHistMassWithCombPIDXiMinus = new TH1F("fHistMassWithCombPIDXiMinus","#Xi^{-} candidates, with Bach. comb. PID;M( #Lambda , #pi^{-} ) (GeV/c^{2});Counts", 400,1.2,2.0);
 698     fListHistCascade->Add(fHistMassWithCombPIDXiMinus);
 699 }
 700
 701 if (! fHistMassWithCombPIDXiPlus) {
 702     fHistMassWithCombPIDXiPlus = new TH1F("fHistMassWithCombPIDXiPlus","#Xi^{+} candidates, with Bach. comb. PID;M( #bar{#Lambda}^{0} , #pi^{+} ) (GeV/c^{2});Counts",400,1.2,2.0);
 703     fListHistCascade->Add(fHistMassWithCombPIDXiPlus);
 704 }
 705
 706 if (! fHistMassWithCombPIDOmegaMinus) {
 707         fHistMassWithCombPIDOmegaMinus = new TH1F("fHistMassWithCombPIDOmegaMinus","#Omega^{-} candidates, with Bach. comb. PID;M( #Lambda , K^{-} ) (GeV/c^{2});Counts", 500,1.5,2.5);
 708     fListHistCascade->Add(fHistMassWithCombPIDOmegaMinus);
 709 }
 710
 711 if (! fHistMassWithCombPIDOmegaPlus) {
 712         fHistMassWithCombPIDOmegaPlus = new TH1F("fHistMassWithCombPIDOmegaPlus","#Omega^{+} candidates, with Bach. comb. PID;M( #bar{#Lambda}^{0} , K^{+} ) (GeV/c^{2});Counts", 500,1.5,2.5);
 713     fListHistCascade->Add(fHistMassWithCombPIDOmegaPlus);
 714 }
 715
 716
 717
 718         // - Complements for QA
 719
 720 if(! fHistXiTransvMom ){
 721         fHistXiTransvMom  = new TH1F( "fHistXiTransvMom" , "#Xi transverse momentum (cand. around the mass peak) ; p_{t}(#Xi) (GeV/c); Counts", 100, 0.0, 10.0);
 722         fListHistCascade->Add(fHistXiTransvMom);
 723 }
 724
 725 if(! fHistXiTotMom ){
 726         fHistXiTotMom  = new TH1F( "fHistXiTotMom" , "#Xi momentum norm (cand. around the mass peak); p_{tot}(#Xi) (GeV/c); Counts", 150, 0.0, 15.0);
 727         fListHistCascade->Add(fHistXiTotMom);
 728 }
 729
 730
 731 if(! fHistBachTransvMomXi ){
 732         fHistBachTransvMomXi  = new TH1F( "fHistBachTransvMomXi" , "#Xi Bach. transverse momentum (cand. around the mass peak) ; p_{t}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0);
 733         fListHistCascade->Add(fHistBachTransvMomXi);
 734 }
 735
 736 if(! fHistBachTotMomXi ){
 737         fHistBachTotMomXi  = new TH1F( "fHistBachTotMomXi" , "#Xi Bach. momentum norm (cand. around the mass peak); p_{tot}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0);
 738         fListHistCascade->Add(fHistBachTotMomXi);
 739 }
 740
 741 if(! fHistPosTransvMomXi ){
 742         fHistPosTransvMomXi  = new TH1F( "fHistPosTransvMomXi" , "#Xi Bach. transverse momentum (cand. around the mass peak) ; p_{t}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0);
 743         fListHistCascade->Add(fHistPosTransvMomXi);
 744 }
 745
 746 if(! fHistNegTransvMomXi ){
 747         fHistNegTransvMomXi  = new TH1F( "fHistNegTransvMomXi" , "#Xi Bach. transverse momentum (cand. around the mass peak) ; p_{t}(Bach.) (GeV/c); Counts", 100, 0.0, 5.0);
 748         fListHistCascade->Add(fHistNegTransvMomXi);
 749 }
 750
 751
 752
 753 if(! fHistChargeXi ){
 754         fHistChargeXi  = new TH1F( "fHistChargeXi" , "Charge of casc. candidates ; Sign ; Counts", 5, -2.0, 3.0);
 755         fListHistCascade->Add(fHistChargeXi);
 756 }
 757
 758
 759 if (! fHistV0toXiCosineOfPointingAngle) {
 760         fHistV0toXiCosineOfPointingAngle = new TH1F("fHistV0toXiCosineOfPointingAngle", "Cos. of V0 Ptng Angl / Xi vtx ;Cos(V0 Point. Angl / Xi vtx); Counts", 200, 0.95, 1.0001);
 761         fListHistCascade->Add(fHistV0toXiCosineOfPointingAngle);
 762 }
 763
 764
 765 if(! fHistRapXi ){
 766         fHistRapXi  = new TH1F( "fHistRapXi" , "Rapidity of #Xi candidates (around the mass peak); y ; Counts", 20, -1.0, 1.0);
 767         fListHistCascade->Add(fHistRapXi);
 768 }
 769
 770 if(! fHistRapOmega ){
 771         fHistRapOmega  = new TH1F( "fHistRapOmega" , "Rapidity of #Omega candidates (around the mass peak); y ; Counts", 20, -1.0, 1.0);
 772         fListHistCascade->Add(fHistRapOmega);
 773 }
 774
 775 if(! fHistEtaXi ){
 776         fHistEtaXi  = new TH1F( "fHistEtaXi" , "Pseudo-rap. of #Xi candidates (around the mass peak) ; #eta ; Counts", 20, -1.0, 1.0);
 777         fListHistCascade->Add(fHistEtaXi);
 778 }
 779
 780 if(! fHistThetaXi ){
 781         fHistThetaXi  = new TH1F( "fHistThetaXi" , "#theta of #Xi candidates (around the mass peak); #theta (deg) ; Counts", 180, 0., 180.0);
 782         fListHistCascade->Add(fHistThetaXi);
 783 }
 784
 785 if(! fHistPhiXi ){
 786         fHistPhiXi  = new TH1F( "fHistPhiXi" , "#phi of #Xi candidates (around the mass peak); #phi (deg) ; Counts", 360, 0., 360.);
 787         fListHistCascade->Add(fHistPhiXi);
 788 }
 789
 790
 791 if(! f2dHistArmenteros) {
 792         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);
 793         fListHistCascade->Add(f2dHistArmenteros);
 794 }
 795
 796 //-------
 797
 798 if(! f2dHistEffMassLambdaVsEffMassXiMinus) {
 799         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);
 800         fListHistCascade->Add(f2dHistEffMassLambdaVsEffMassXiMinus);
 801 }
 802
 803 if(! f2dHistEffMassXiVsEffMassOmegaMinus) {
 804         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);
 805         fListHistCascade->Add(f2dHistEffMassXiVsEffMassOmegaMinus);
 806 }
 807
 808 if(! f2dHistEffMassLambdaVsEffMassXiPlus) {
 809         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);
 810         fListHistCascade->Add(f2dHistEffMassLambdaVsEffMassXiPlus);
 811 }
 812
 813 if(! f2dHistEffMassXiVsEffMassOmegaPlus) {
 814         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);
 815         fListHistCascade->Add(f2dHistEffMassXiVsEffMassOmegaPlus);
 816 }
 817
 818 //-------
 819
 820 if(! f2dHistXiRadiusVsEffMassXiMinus) {
 821         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);
 822         fListHistCascade->Add(f2dHistXiRadiusVsEffMassXiMinus);
 823 }
 824
 825 if(! f2dHistXiRadiusVsEffMassXiPlus) {
 826         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);
 827         fListHistCascade->Add(f2dHistXiRadiusVsEffMassXiPlus);
 828 }
 829
 830 if(! f2dHistXiRadiusVsEffMassOmegaMinus) {
 831         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);
 832         fListHistCascade->Add(f2dHistXiRadiusVsEffMassOmegaMinus);
 833 }
 834
 835 if(! f2dHistXiRadiusVsEffMassOmegaPlus) {
 836         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);
 837         fListHistCascade->Add(f2dHistXiRadiusVsEffMassOmegaPlus);
 838 }
 839
 840 if(! f2dHistTPCdEdxOfCascDghters){
 841         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.);
 842         fListHistCascade->Add(f2dHistTPCdEdxOfCascDghters);
 843 }
 844
 845
 846 if(!fCFContCascadePIDXiMinus)  {
 847   const Int_t  lNbSteps      =  7 ;
 848   const Int_t  lNbVariables  =  4 ;
 849
 850   //array for the number of bins in each dimension :
 851   Int_t lNbBinsPerVar[4] = {0};
 852   lNbBinsPerVar[0] = 100;
 853   lNbBinsPerVar[1] = 800;
 854   lNbBinsPerVar[2] = 22;
 855   lNbBinsPerVar[3] = 11;
 856
 857
 858   fCFContCascadePIDXiMinus = new AliCFContainer("fCFContCascadePIDXiMinus","Pt_{cascade} Vs M_{#Xi^{-} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
 859
 860   //setting the bin limits
 861   fCFContCascadePIDXiMinus->SetBinLimits(0,   0.0  ,  10.0 );   // Pt(Cascade)
 862   fCFContCascadePIDXiMinus->SetBinLimits(1,   1.2  ,   2.0 );   // Xi Effective mass
 863   fCFContCascadePIDXiMinus->SetBinLimits(2,  -1.1  ,   1.1 );   // Rapidity
 864
 865   Double_t *lBinLim3  = new Double_t[ lNbBinsPerVar[3]+1 ];
 866   for(Int_t i=3; i< lNbBinsPerVar[3]+1;i++)   lBinLim3[i]  = (Double_t)(i-1)*10.;
 867   lBinLim3[0] = 0.0;
 868   lBinLim3[1] = 5.0;
 869   lBinLim3[2] = 10.0;
 870   fCFContCascadePIDXiMinus->SetBinLimits(3,  lBinLim3 );       // Centrality
 871
 872   // Setting the step title : one per PID case
 873   fCFContCascadePIDXiMinus->SetStepTitle(0, "No PID");
 874   fCFContCascadePIDXiMinus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
 875   fCFContCascadePIDXiMinus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
 876   fCFContCascadePIDXiMinus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
 877   fCFContCascadePIDXiMinus->SetStepTitle(4, "Comb. PID / Bachelor");
 878   fCFContCascadePIDXiMinus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
 879   fCFContCascadePIDXiMinus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
 880
 881   // Setting the variable title, per axis
 882   fCFContCascadePIDXiMinus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
 883   fCFContCascadePIDXiMinus->SetVarTitle(1, "M( #Lambda , #pi^{-} ) (GeV/c^{2})");
 884   fCFContCascadePIDXiMinus->SetVarTitle(2, "Y_{#Xi}");
 885   fCFContCascadePIDXiMinus->SetVarTitle(3, "Centrality");
 886 }
 887
 888 if (!fCFContCascadePIDXiPlus) {
 889   const Int_t  lNbSteps      =  7 ;
 890   const Int_t  lNbVariables  =  4 ;
 891
 892   //array for the number of bins in each dimension :
 893   Int_t lNbBinsPerVar[4] = {0};
 894   lNbBinsPerVar[0] = 100;
 895   lNbBinsPerVar[1] = 800;
 896   lNbBinsPerVar[2] = 22;
 897   lNbBinsPerVar[3] = 11;
 898
 899   fCFContCascadePIDXiPlus = new AliCFContainer("fCFContCascadePIDXiPlus","Pt_{cascade} Vs M_{#Xi^{+} candidates} Vs Y_{#Xi}", lNbSteps, lNbVariables, lNbBinsPerVar );
 900
 901
 902   //setting the bin limits
 903   fCFContCascadePIDXiPlus->SetBinLimits(0,   0.0  ,  10.0 );    // Pt(Cascade)
 904   fCFContCascadePIDXiPlus->SetBinLimits(1,   1.2  ,   2.0 );    // Xi Effective mass
 905   fCFContCascadePIDXiPlus->SetBinLimits(2,  -1.1  ,   1.1 );    // Rapidity
 906   Double_t *lBinLim3  = new Double_t[ lNbBinsPerVar[3]+1 ];
 907   for(Int_t i=3; i< lNbBinsPerVar[3]+1;i++)   lBinLim3[i]  = (Double_t)(i-1)*10.;
 908   lBinLim3[0] = 0.0;
 909   lBinLim3[1] = 5.0;
 910   lBinLim3[2] = 10.0;
 911   fCFContCascadePIDXiPlus->SetBinLimits(3,lBinLim3);     // Centrality
 912
 913   // Setting the step title : one per PID case
 914   fCFContCascadePIDXiPlus->SetStepTitle(0, "No PID");
 915   fCFContCascadePIDXiPlus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
 916   fCFContCascadePIDXiPlus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
 917   fCFContCascadePIDXiPlus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
 918   fCFContCascadePIDXiPlus->SetStepTitle(4, "Comb. PID / Bachelor");
 919   fCFContCascadePIDXiPlus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
 920   fCFContCascadePIDXiPlus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
 921
 922   // Setting the variable title, per axis
 923   fCFContCascadePIDXiPlus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
 924   fCFContCascadePIDXiPlus->SetVarTitle(1, "M( #Lambda , #pi^{+} ) (GeV/c^{2})");
 925   fCFContCascadePIDXiPlus->SetVarTitle(2, "Y_{#Xi}");
 926   fCFContCascadePIDXiPlus->SetVarTitle(3, "Centrality");
 927 }
 928
 929
 930 if(!fCFContCascadePIDOmegaMinus)  {
 931   const Int_t  lNbSteps      =  7 ;
 932   const Int_t  lNbVariables  =  4 ;
 933
 934   //array for the number of bins in each dimension :
 935   Int_t lNbBinsPerVar[4] = {0};
 936   lNbBinsPerVar[0] = 100;
 937   lNbBinsPerVar[1] = 1000;
 938   lNbBinsPerVar[2] = 22;
 939   lNbBinsPerVar[3] = 11;
 940
 941
 942   fCFContCascadePIDOmegaMinus = new AliCFContainer("fCFContCascadePIDOmegaMinus","Pt_{cascade} Vs M_{#Omega^{-} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
 943
 944
 945   //setting the bin limits
 946   fCFContCascadePIDOmegaMinus->SetBinLimits(0,   0.0  ,  10.0 );        // Pt(Cascade)
 947   fCFContCascadePIDOmegaMinus->SetBinLimits(1,   1.5  ,   2.5 );        // Omega Effective mass
 948   fCFContCascadePIDOmegaMinus->SetBinLimits(2,  -1.1  ,   1.1 );        // Rapidity
 949   Double_t *lBinLim3  = new Double_t[ lNbBinsPerVar[3]+1 ];
 950   for(Int_t i=3; i< lNbBinsPerVar[3]+1;i++)   lBinLim3[i]  = (Double_t)(i-1)*10.;
 951   lBinLim3[0] = 0.0;
 952   lBinLim3[1] = 5.0;
 953   lBinLim3[2] = 10.0;
 954   fCFContCascadePIDOmegaMinus->SetBinLimits(3,lBinLim3);     // Centrality
 955   // Setting the step title : one per PID case
 956   fCFContCascadePIDOmegaMinus->SetStepTitle(0, "No PID");
 957   fCFContCascadePIDOmegaMinus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
 958   fCFContCascadePIDOmegaMinus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
 959   fCFContCascadePIDOmegaMinus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
 960   fCFContCascadePIDOmegaMinus->SetStepTitle(4, "Comb. PID / Bachelor");
 961   fCFContCascadePIDOmegaMinus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
 962   fCFContCascadePIDOmegaMinus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
 963
 964   // Setting the variable title, per axis
 965   fCFContCascadePIDOmegaMinus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
 966   fCFContCascadePIDOmegaMinus->SetVarTitle(1, "M( #Lambda , K^{-} ) (GeV/c^{2})");
 967   fCFContCascadePIDOmegaMinus->SetVarTitle(2, "Y_{#Omega}");
 968   fCFContCascadePIDOmegaMinus->SetVarTitle(3, "Centrality");
 969 }
 970
 971 if(!fCFContCascadePIDOmegaPlus)  {
 972   const Int_t  lNbSteps      =  7 ;
 973   const Int_t  lNbVariables  =  4 ;
 974
 975   //array for the number of bins in each dimension :
 976   Int_t lNbBinsPerVar[4] = {0};
 977   lNbBinsPerVar[0] = 100;
 978   lNbBinsPerVar[1] = 1000;
 979   lNbBinsPerVar[2] = 22;
 980   lNbBinsPerVar[3] = 100;
 981
 982
 983   fCFContCascadePIDOmegaPlus = new AliCFContainer("fCFContCascadePIDOmegaPlus","Pt_{cascade} Vs M_{#Omega^{+} candidates} Vs Y_{#Omega}", lNbSteps, lNbVariables, lNbBinsPerVar );
 984
 985
 986   //setting the bin limits
 987   fCFContCascadePIDOmegaPlus->SetBinLimits(0,   0.0  ,  10.0 ); // Pt(Cascade)
 988   fCFContCascadePIDOmegaPlus->SetBinLimits(1,   1.5  ,   2.5 ); // Omega Effective mass
 989   fCFContCascadePIDOmegaPlus->SetBinLimits(2,  -1.1  ,   1.1 ); // Rapidity
 990   Double_t *lBinLim3  = new Double_t[ lNbBinsPerVar[3]+1 ];
 991   for(Int_t i=3; i< lNbBinsPerVar[3]+1;i++)   lBinLim3[i]  = (Double_t)(i-1)*10.;
 992   lBinLim3[0] = 0.0;
 993   lBinLim3[1] = 5.0;
 994   lBinLim3[2] = 10.0;
 995   fCFContCascadePIDOmegaPlus->SetBinLimits(3,lBinLim3);    // Centrality
 996
 997   // Setting the step title : one per PID case
 998   fCFContCascadePIDOmegaPlus->SetStepTitle(0, "No PID");
 999   fCFContCascadePIDOmegaPlus->SetStepTitle(1, "TPC PID / 4-#sigma cut on Bachelor track");
1000   fCFContCascadePIDOmegaPlus->SetStepTitle(2, "TPC PID / 4-#sigma cut on Bachelor+Baryon tracks");
1001   fCFContCascadePIDOmegaPlus->SetStepTitle(3, "TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks");
1002   fCFContCascadePIDOmegaPlus->SetStepTitle(4, "Comb. PID / Bachelor");
1003   fCFContCascadePIDOmegaPlus->SetStepTitle(5, "Comb. PID / Bachelor+Baryon");
1004   fCFContCascadePIDOmegaPlus->SetStepTitle(6, "Comb. PID / Bachelor+Baryon+Meson");
1005
1006   // Setting the variable title, per axis
1007   fCFContCascadePIDOmegaPlus->SetVarTitle(0, "Pt_{cascade} (GeV/c)");
1008   fCFContCascadePIDOmegaPlus->SetVarTitle(1, "M( #Lambda , K^{+} ) (GeV/c^{2})");
1009   fCFContCascadePIDOmegaPlus->SetVarTitle(2, "Y_{#Omega}");
1010   fCFContCascadePIDOmegaPlus->SetVarTitle(3, "SPD tracklets Multiplicity");
1011 }
1012
1013
1014 // Part 3 : Towards the optimisation of topological selections -------
1015 if(! fCFContCascadeCuts) {
1016
1017         // Container meant to store all the relevant distributions corresponding to the cut variables.
1018         //          - NB overflow/underflow of variables on which we want to cut later should be 0!!!
1019   const Int_t  lNbSteps      =  4 ;
1020   const Int_t  lNbVariables  =  22 ;
1021   //array for the number of bins in each dimension :
1022   Int_t lNbBinsPerVar[lNbVariables] = {0};
1023   lNbBinsPerVar[0]  = 100;
1024   lNbBinsPerVar[1]  = 126;
1025   lNbBinsPerVar[2]  = 24;
1026   lNbBinsPerVar[3]  = 220;
1027   lNbBinsPerVar[4]  = 30;
1028   lNbBinsPerVar[5]  = 50;
1029
1030   lNbBinsPerVar[6]  = 101;
1031
1032   lNbBinsPerVar[7]  = 102;
1033   lNbBinsPerVar[8]  = 101;
1034   lNbBinsPerVar[9]  = 26;
1035   lNbBinsPerVar[10] = 26;
1036
1037   lNbBinsPerVar[11] = 150;  // 75 2-MeV/c2 bins
1038   lNbBinsPerVar[12] = 120;  // 60 2-MeV/c2 bins
1039
1040   lNbBinsPerVar[13] = 100;
1041
1042   lNbBinsPerVar[14] = 44; // 0.05 in rapidity units
1043   lNbBinsPerVar[15] = 44; // 0.05 in rapidity units
1044
1045   lNbBinsPerVar[16] = 20;
1046
1047   lNbBinsPerVar[17] = 11;
1048   lNbBinsPerVar[18] = 100;
1049   lNbBinsPerVar[19] = 112; // Proper time of cascade
1050   lNbBinsPerVar[20] = 112; // Proper time of V0
1051   lNbBinsPerVar[21] = 112; // Distance V0-Xi in transverse plane
1052
1053   fCFContCascadeCuts = new AliCFContainer("fCFContCascadeCuts","Container for Cascade cuts", lNbSteps, lNbVariables, lNbBinsPerVar );
1054
1055
1056   //setting the bin limits
1057
1058   //0
1059   fCFContCascadeCuts->SetBinLimits(0, 0., 2.);                 // DcaXiDaughters : 0.0 to 2.0
1060   //1
1061   Double_t *lBinLim1  = new Double_t[ lNbBinsPerVar[1]+1 ];
1062   lBinLim1[0] = 0.0;
1063   lBinLim1[1] = 0.03;
1064   for(Int_t i=2; i< lNbBinsPerVar[1];i++)   lBinLim1[i]  = (Double_t)0.03   + (5.  - 0.03 )/(lNbBinsPerVar[1]-2)  * (Double_t)(i-1) ;
1065   lBinLim1[ lNbBinsPerVar[1]  ] = 100.0;
1066   fCFContCascadeCuts -> SetBinLimits(1,  lBinLim1 );
1067   delete [] lBinLim1;                                          // DcaBachToPrimVertexXi : 0.0 to 0.5
1068   //2
1069   fCFContCascadeCuts->SetBinLimits(2, .9988, 1.);              // XiCosineOfPointingAngle : 0.99 to 1.0
1070   //3
1071   fCFContCascadeCuts -> SetBinLimits(3, 0., 110.);             // XiRadius : 0.0 to 110.0
1072   //4
1073   fCFContCascadeCuts->SetBinLimits(4, 1.1, 1.13 );             // InvMassLambdaAsCascDghter
1074   //5
1075   fCFContCascadeCuts->SetBinLimits(5, 0., 2.);                 // DcaV0DaughtersXi : 0.0 to 2.0
1076   //6
1077   fCFContCascadeCuts->SetBinLimits(6, .98, 1.0002);            // V0CosineOfPointingAngleXi : 0.99 to 1.0
1078   //7
1079   Double_t *lBinLim7  = new Double_t[ lNbBinsPerVar[7]+1 ];
1080   for(Int_t i=0; i< lNbBinsPerVar[7]-1;i++)   lBinLim7[i]  = (Double_t)0.0   + (100.  - 0.0 )/(lNbBinsPerVar[7]-2)  * (Double_t)i ;
1081   lBinLim7[ lNbBinsPerVar[7]-1] = 200.0;
1082   lBinLim7[ lNbBinsPerVar[7]] = 1000.0;
1083   fCFContCascadeCuts -> SetBinLimits(7,  lBinLim7 );
1084   delete [] lBinLim7;                                          // V0RadiusXi : 0.0 to 100.0
1085   //8
1086   Double_t *lBinLim8  = new Double_t[ lNbBinsPerVar[8]+1 ];
1087   for(Int_t i=0; i< lNbBinsPerVar[8];i++)   lBinLim8[i]  = (Double_t)0.0   + (0.4  - 0.0 )/(lNbBinsPerVar[8]-1)  * (Double_t)i ;
1088   lBinLim8[ lNbBinsPerVar[8]  ] = 100.0;
1089   fCFContCascadeCuts -> SetBinLimits(8,  lBinLim8 );
1090   delete [] lBinLim8;                                          // DcaV0ToPrimVertexXi : 0.0 to 0.4
1091   //9
1092   Double_t *lBinLim9  = new Double_t[ lNbBinsPerVar[9]+1 ];
1093   for(Int_t i=0; i< lNbBinsPerVar[9];i++)   lBinLim9[i]  = (Double_t)0.0   + (0.25  - 0.0 )/(lNbBinsPerVar[9]-1)  * (Double_t)i ;
1094   lBinLim9[ lNbBinsPerVar[9]  ] = 100.0;
1095   fCFContCascadeCuts -> SetBinLimits(9,  lBinLim9 );
1096   delete [] lBinLim9;                                          // DcaPosToPrimVertexXi : 0.0 to 0.25
1097   //10
1098   Double_t *lBinLim10  = new Double_t[ lNbBinsPerVar[10]+1 ];
1099   for(Int_t i=0; i< lNbBinsPerVar[10];i++)   lBinLim10[i]  = (Double_t)0.0   + (0.25  - 0.0 )/(lNbBinsPerVar[10]-1)  * (Double_t)i ;
1100   lBinLim10[ lNbBinsPerVar[10]  ] = 100.0;
1101   fCFContCascadeCuts -> SetBinLimits(10,  lBinLim10 );
1102   delete [] lBinLim10;                                         // DcaNegToPrimVertexXi : 0.0 to 0.25
1103   //11
1104   fCFContCascadeCuts->SetBinLimits(11, 1.25, 1.40);            // InvMassXi
1105   fCFContCascadeCuts->SetBinLimits(12, 1.62, 1.74);            // InvMassOmega
1106   fCFContCascadeCuts->SetBinLimits(13, 0.0, 10.0);             // XiTransvMom
1107   fCFContCascadeCuts->SetBinLimits(14, -1.1, 1.1);             // Y(Xi)
1108   fCFContCascadeCuts->SetBinLimits(15, -1.1, 1.1);             // Y(Omega)
1109   fCFContCascadeCuts->SetBinLimits(16, -10.0, 10.0);           // BestPrimaryVtxPosZ
1110   Double_t *lBinLim17  = new Double_t[ lNbBinsPerVar[17]+1 ];
1111   for(Int_t i=3; i< lNbBinsPerVar[17]+1;i++)   lBinLim17[i]  = (Double_t)(i-1)*10.;
1112   lBinLim17[0] = 0.0;
1113   lBinLim17[1] = 5.0;
1114   lBinLim17[2] = 10.0;
1115   fCFContCascadeCuts -> SetBinLimits(17,  lBinLim17 );         // Centrality
1116   delete [] lBinLim17;
1117   fCFContCascadeCuts->SetBinLimits(18, 0.0, 6000.0);           // ESD track multiplicity
1118
1119   Double_t *lBinLim19  = new Double_t[ lNbBinsPerVar[19]+1 ];
1120   for(Int_t i=0; i< lNbBinsPerVar[19];i++)   lBinLim19[i]  = (Double_t)-1.   + (110.  + 1.0 )/(lNbBinsPerVar[19]-1)  * (Double_t)i ;
1121   lBinLim19[ lNbBinsPerVar[19]  ] = 2000.0;
1122   fCFContCascadeCuts->SetBinLimits(19, lBinLim19);             // Proper time cascade
1123
1124   fCFContCascadeCuts->SetBinLimits(20, lBinLim19);             // Proper time V0
1125
1126   fCFContCascadeCuts->SetBinLimits(21, lBinLim19);             // Distance V0-Xi in tansverse plane
1127   delete [] lBinLim19;
1128   // Setting the number of steps : one for each cascade species (Xi-, Xi+ and Omega-, Omega+)
1129   fCFContCascadeCuts->SetStepTitle(0, "#Xi^{-} candidates");
1130   fCFContCascadeCuts->SetStepTitle(1, "#bar{#Xi}^{+} candidates");
1131   fCFContCascadeCuts->SetStepTitle(2, "#Omega^{-} candidates");
1132   fCFContCascadeCuts->SetStepTitle(3, "#bar{#Omega}^{+} candidates");
1133
1134   // Setting the variable title, per axis
1135   fCFContCascadeCuts->SetVarTitle(0,  "Dca(XiDaughters) (cm)");
1136   fCFContCascadeCuts->SetVarTitle(1,  "Dca(Bach/PrimVertex) (cm)");
1137   fCFContCascadeCuts->SetVarTitle(2,  "cos(Xi pointing angle)");
1138   fCFContCascadeCuts->SetVarTitle(3,  "R_{2d}(Xi decay) (cm)");
1139   fCFContCascadeCuts->SetVarTitle(4,  "M_{#Lambda}(As Casc Dghter) (GeV/c^{2})");
1140   fCFContCascadeCuts->SetVarTitle(5,  "Dca(V0 Daughters) in Xi (cm)");
1141
1142   fCFContCascadeCuts->SetVarTitle(6,  "cos(V0 pointing Angle) in Casc");
1143   fCFContCascadeCuts->SetVarTitle(7,  "R_{2d}(V0 decay) (cm)");
1144   fCFContCascadeCuts->SetVarTitle(8,  "Dca(V0/PrimVertex) (cm)");
1145   fCFContCascadeCuts->SetVarTitle(9,  "Dca(Pos/PrimVertex) (cm)");
1146   fCFContCascadeCuts->SetVarTitle(10, "Dca(Neg/PrimVertex) (cm)");
1147
1148   fCFContCascadeCuts->SetVarTitle(11, "Inv. Mass(Xi) (GeV/c^{2})");
1149   fCFContCascadeCuts->SetVarTitle(12, "Inv. Mass(Omega) (GeV/c^{2})");
1150
1151   fCFContCascadeCuts->SetVarTitle(13, "pt(Casc.) (GeV/c)");
1152
1153   fCFContCascadeCuts->SetVarTitle(14, "Y(Xi)");
1154   fCFContCascadeCuts->SetVarTitle(15, "Y(Omega)");
1155
1156   fCFContCascadeCuts->SetVarTitle(16, "Z-position(BestPrimVtx) (cm)");
1157
1158   fCFContCascadeCuts->SetVarTitle(17, "Centrality");
1159
1160   fCFContCascadeCuts->SetVarTitle(18, "ESD track multiplicity");
1161
1162   fCFContCascadeCuts->SetVarTitle(19, "Proper time cascade");
1163   fCFContCascadeCuts->SetVarTitle(20, "Proper time V0");
1164   fCFContCascadeCuts->SetVarTitle(21, "Distance V0-Xi in transverse plane");
1165
1166 }
1167
1168   fV0Ampl = new TH1F("fV0Ampl","",500,0.,30000);
1169   fListHistCascade->Add(fV0Ampl);
1170
1171
1172   fHistDcaXiDaughtersvsInvMass = new TH2F( "fHistDcaXiDaughtersvsInvMass",  "DCA between Xi Daughters; DCA (cm) ; Number of Cascades", 100, 0., 0.5,400,1.2,2.0);
1173         fListHistCascade->Add(fHistDcaXiDaughtersvsInvMass);
1174   fHistDcaBachToPrimVertexvsInvMass = new TH2F("fHistDcaBachToPrimVertexvsInvMass", "DCA of Bach. to Prim. Vertex;DCA (cm);Number of Cascades", 250, 0., 0.25,400,1.2,2.0);
1175         fListHistCascade->Add(fHistDcaBachToPrimVertexvsInvMass);
1176   fHistXiCosineOfPointingAnglevsInvMass= new TH2F("fHistXiCosineOfPointingAnglevsInvMass", "Cosine of Xi Pointing Angle; Cos (Xi Point.Angl);Number of Xis", 200, 0.99, 1.0,400,1.2,2.0);
1177         fListHistCascade->Add(fHistXiCosineOfPointingAnglevsInvMass);
1178   fHistMassLambdaAsCascDghtervsInvMass= new TH2F("fHistMassLambdaAsCascDghtervsInvMass","#Lambda associated to Casc. candidates;Eff. Mass (GeV/c^{2});Counts", 300,1.00,1.3,400,1.2,2.0);
1179     fListHistCascade->Add(fHistMassLambdaAsCascDghtervsInvMass);
1180   fHistDcaV0DaughtersXivsInvMass = new TH2F("fHistDcaV0DaughtersXivsInvMass", "DCA between V0 daughters, in cascade;DCA (cm);Number of V0s", 120, 0., 0.6,400,1.2,2.0);
1181         fListHistCascade->Add(fHistDcaV0DaughtersXivsInvMass);
1182   fHistDcaV0ToPrimVertexXivsInvMass = new TH2F("fHistDcaV0ToPrimVertexXivsInvMass", "DCA of V0 to Prim. Vertex, in cascade;DCA (cm);Number of Cascades", 200, 0., 1.,400,1.2,2.0);
1183         fListHistCascade->Add(fHistDcaV0ToPrimVertexXivsInvMass);
1184
1185 PostData(1, fListHistCascade);
1186 PostData(2, fCFContCascadePIDXiMinus);
1187 PostData(3, fCFContCascadePIDXiPlus);
1188 PostData(4, fCFContCascadePIDOmegaMinus);
1189 PostData(5, fCFContCascadePIDOmegaPlus);
1190 PostData(6, fCFContCascadeCuts);
1191
1192 /* PostData(2, fPaveTextBookKeeping);*/
1193 }// end UserCreateOutputObjects
1194
1195
1196 //________________________________________________________________________
1197 void AliAnalysisTaskCheckCascadePbPb::UserExec(Option_t *) {
1198   // Main loop
1199   // Called for each event
1200
1201   AliESDEvent *lESDevent = 0x0;
1202   AliAODEvent *lAODevent = 0x0;
1203
1204   if(!fPIDResponse) {
1205      AliError("Cannot get pid response");
1206      return;
1207   }
1208
1209
1210   Int_t    ncascades                      = -1;
1211   Int_t    nTrackMultiplicity             = -1;
1212   Int_t    nTrackWithTPCrefitMultiplicity =  0;
1213 //  Int_t    lSPDTrackletsMultiplicity = -1;
1214
1215   // Primary tracks from ESD/AOD
1216   Float_t lPrimaryTrackMultiplicity = -1.;
1217
1218
1219   Short_t  lStatusTrackingPrimVtx         = -2;
1220   Double_t lTrkgPrimaryVtxPos[3]          = {-100.0, -100.0, -100.0};
1221   Double_t lBestPrimaryVtxPos[3]          = {-100.0, -100.0, -100.0};
1222   Double_t lMagneticField                 = -10.;
1223
1224   AliCentrality* centrality;
1225   AliESDVZERO* esdV0;
1226   AliAODVZERO* aodV0;
1227   Float_t multV0A = 0.;
1228   Float_t multV0C = 0.;
1229
1230   // Connect to the InputEvent
1231   // After these lines, we should have an ESD/AOD event + the number of cascades in it.
1232
1233   // For AOD or ESD ...
1234   nTrackMultiplicity = (InputEvent())->GetNumberOfTracks();
1235
1236   if (fAnalysisType == "ESD") {
1237     lESDevent = dynamic_cast<AliESDEvent*>( InputEvent() );
1238     if (!lESDevent) {
1239       AliWarning("ERROR: lESDevent not available \n");
1240       return;
1241     }
1242
1243     //-------------------------------------------------
1244
1245     // 0 - Trigger management
1246     // NOTE : Check the availability of the proper trigger  --> MN Physics selection moved to runProof  macro
1247
1248     //-------------------------------------------------
1249
1250     // 1 - Cascade vertexer (ESD)
1251     if (fkRerunV0CascVertexers) { // Relaunch V0 and Cascade vertexers
1252
1253       lESDevent->ResetCascades();
1254       lESDevent->ResetV0s();
1255
1256       AliV0vertexer *lV0vtxer = new AliV0vertexer();
1257       AliCascadeVertexer *lCascVtxer = new AliCascadeVertexer();
1258
1259         //lV0vtxer->GetCuts(fV0Sels);
1260         //lCascVtxer->GetCuts(fCascSels);
1261
1262       lV0vtxer->SetCuts(fV0Sels);      // NB don't use SetDefaultCuts!! because it acts on static variables
1263       lCascVtxer->SetCuts(fCascSels);
1264
1265
1266       lV0vtxer->Tracks2V0vertices(lESDevent);
1267       lCascVtxer->V0sTracks2CascadeVertices(lESDevent);
1268
1269       delete lV0vtxer;
1270       delete lCascVtxer;
1271     }// end if(RelaunchV0CascVertexers)
1272
1273     //-------------------------------------------------
1274     ncascades                      = lESDevent->GetNumberOfCascades();
1275     nTrackWithTPCrefitMultiplicity = DoESDTrackWithTPCrefitMultiplicity(lESDevent);
1276
1277 //    const AliMultiplicity *lAliMult = lESDevent->GetMultiplicity();
1278 //    lSPDTrackletsMultiplicity       = lAliMult->GetNumberOfTracklets();
1279
1280     centrality = lESDevent->GetCentrality();
1281     esdV0 = lESDevent->GetVZEROData();
1282     multV0A=esdV0->GetMTotV0A();
1283     multV0C=esdV0->GetMTotV0C();
1284
1285   } else if (fAnalysisType == "AOD") {
1286     lAODevent = dynamic_cast<AliAODEvent*>( InputEvent() );
1287     if (!lAODevent) {
1288       AliWarning("ERROR: lAODevent not available \n");
1289       return;
1290     }
1291     ncascades                      = lAODevent->GetNumberOfCascades();
1292     nTrackWithTPCrefitMultiplicity = 0;
1293     lPrimaryTrackMultiplicity = 0;
1294     for (Int_t itrack = 0; itrack<nTrackMultiplicity; itrack++) {
1295       AliAODTrack* track = lAODevent->GetTrack(itrack);
1296       if (track->TestFilterBit(AliAODTrack::kTrkGlobalNoDCA)) lPrimaryTrackMultiplicity++; // kTrkGlobal tight DCA cut --> mult is much lower than the one selectied with standard cuts in ESDs
1297       if (track->IsOn(AliAODTrack::kTPCrefit)) nTrackWithTPCrefitMultiplicity++;
1298     }
1299
1300 //    lSPDTrackletsMultiplicity = lAODevent->GetTracklets()->GetNumberOfTracklets();
1301
1302     centrality = lAODevent->GetCentrality();
1303     aodV0 = lAODevent->GetVZEROData();
1304     multV0A=aodV0->GetMTotV0A();
1305     multV0C=aodV0->GetMTotV0C();
1306
1307   } else {
1308
1309     Printf("Analysis type (ESD or AOD) not specified \n");
1310     return;
1311
1312   }
1313
1314   fHistCascadeMultiplicityBeforeEvSel->Fill (ncascades);
1315
1316   //  Printf("Centrality percentile V0M for this event %f)\n",  centrality->GetCentralityPercentile("V0M"));
1317   Float_t lcentrality = 0.;
1318
1319   if (fkUseCleaning) lcentrality = centrality->GetCentralityPercentile(fCentrEstimator.Data());
1320   else {
1321     lcentrality = centrality->GetCentralityPercentileUnchecked(fCentrEstimator.Data());
1322     if (centrality->GetQuality()>1) {
1323       PostData(1, fListHistCascade);
1324       PostData(2, fCFContCascadePIDXiMinus);
1325       PostData(3, fCFContCascadePIDXiPlus);
1326       PostData(4, fCFContCascadePIDOmegaMinus);
1327       PostData(5, fCFContCascadePIDOmegaPlus);
1328       PostData(6, fCFContCascadeCuts);
1329
1330       return;
1331     }
1332   }
1333   if (lcentrality<fCentrLowLim||lcentrality>=fCentrUpLim) {
1334     PostData(1, fListHistCascade);
1335     PostData(2, fCFContCascadePIDXiMinus);
1336     PostData(3, fCFContCascadePIDXiPlus);
1337     PostData(4, fCFContCascadePIDOmegaMinus);
1338     PostData(5, fCFContCascadePIDOmegaPlus);
1339     PostData(6, fCFContCascadeCuts);
1340
1341     return;
1342   }
1343
1344   fV0Ampl->Fill(multV0A+multV0C);
1345
1346   //-------------------------------------------------
1347
1348   fHistTrackMultiplicityForCentrEvt         ->Fill( nTrackMultiplicity             );
1349   fHistTPCrefitTrackMultiplicityForCentrEvt ->Fill( nTrackWithTPCrefitMultiplicity );
1350   fHistCascadeMultiplicityForCentrEvt       ->Fill( ncascades                      );
1351
1352   // ---------------------------------------------------------------
1353
1354   // I - Global characteristics of the events + general histos (filled for any selected events and/or for the analysed events)
1355
1356        // - I.Step 1 : Characteristics of the event : prim. Vtx + magnetic field (ESD)
1357        //-------------
1358
1359   if (fAnalysisType == "ESD") {
1360     const AliESDVertex *lPrimaryTrackingESDVtx = lESDevent->GetPrimaryVertexTracks();
1361     // get the vtx stored in ESD found with tracks
1362     lPrimaryTrackingESDVtx->GetXYZ( lTrkgPrimaryVtxPos );
1363
1364     const AliESDVertex *lPrimaryBestESDVtx = lESDevent->GetPrimaryVertex();
1365     // get the best primary vertex available for the event
1366     // As done in AliCascadeVertexer, we keep the one which is the best one available.
1367     // between : Tracking vertex > SPD vertex > TPC vertex > default SPD vertex
1368     // This one will be used for next calculations (DCA essentially)
1369     lPrimaryBestESDVtx->GetXYZ( lBestPrimaryVtxPos );
1370     lStatusTrackingPrimVtx  = lPrimaryTrackingESDVtx->GetStatus();
1371
1372     // FIXME : remove TPC-only primary vertex : retain only events with tracking + SPD vertex
1373     if (fkQualityCutNoTPConlyPrimVtx) {
1374       const AliESDVertex *lPrimarySPDVtx = lESDevent->GetPrimaryVertexSPD();
1375       if (!lPrimarySPDVtx->GetStatus() && !lPrimaryTrackingESDVtx->GetStatus() ){
1376         AliWarning("Pb / No SPD prim. vertex nor prim. Tracking vertex ... return !");
1377         PostData(1, fListHistCascade);
1378         PostData(2, fCFContCascadePIDXiMinus);
1379         PostData(3, fCFContCascadePIDXiPlus);
1380         PostData(4, fCFContCascadePIDOmegaMinus);
1381         PostData(5, fCFContCascadePIDOmegaPlus);
1382         PostData(6, fCFContCascadeCuts);
1383
1384         return;
1385       }
1386     }
1387
1388         // NOTE : For older evts
1389
1390         // As previously done in AliCascadeVertexer, we keep, between both retrieved vertices (SPD or Tracking)
1391         // the one which is the best one available.
1392         // This one will be used for next calculations (DCA essentially)
1393         // At that time, the TPC-only primary vertex was not considered
1394
1395
1396     lMagneticField = lESDevent->GetMagneticField( );
1397     // FIXME if(TMath::Abs(lMagneticField ) < 10e-6) continue;
1398     lPrimaryTrackMultiplicity = fESDtrackCuts->CountAcceptedTracks(lESDevent);
1399   } else if (fAnalysisType == "AOD") {
1400
1401     const AliAODVertex *lPrimaryBestAODVtx = lAODevent->GetPrimaryVertex();
1402     if (!lPrimaryBestAODVtx){
1403         AliWarning("No prim. vertex in AOD... return!");
1404         PostData(1, fListHistCascade);
1405         PostData(2, fCFContCascadePIDXiMinus);
1406         PostData(3, fCFContCascadePIDXiPlus);
1407         PostData(4, fCFContCascadePIDOmegaMinus);
1408         PostData(5, fCFContCascadePIDOmegaPlus);
1409         PostData(6, fCFContCascadeCuts);
1410
1411         return;
1412     }
1413
1414     // get the best primary vertex available for the event GetVertex(0)
1415     // This one will be used for next calculations (DCA essentially)
1416     lPrimaryBestAODVtx->GetXYZ( lBestPrimaryVtxPos );
1417
1418     lStatusTrackingPrimVtx  = -1;
1419     lTrkgPrimaryVtxPos[0]   = -100.0;
1420     lTrkgPrimaryVtxPos[1]   = -100.0;
1421     lTrkgPrimaryVtxPos[2]   = -100.0;
1422     lMagneticField = lAODevent->GetMagneticField();
1423
1424   }
1425
1426   // Quality cut on the z-position of the prim vertex.
1427   if (fkQualityCutZprimVtxPos) {
1428     if (TMath::Abs(lBestPrimaryVtxPos[2]) > fVtxRange ) {
1429       AliWarning("Pb / | Z position of Best Prim Vtx | > 10.0 cm ... return !");
1430       PostData(1, fListHistCascade);
1431       PostData(2, fCFContCascadePIDXiMinus);
1432       PostData(3, fCFContCascadePIDXiPlus);
1433       PostData(4, fCFContCascadePIDOmegaMinus);
1434       PostData(5, fCFContCascadePIDOmegaPlus);
1435       PostData(6, fCFContCascadeCuts);
1436
1437       return;
1438     }
1439   }
1440
1441        // - I.Step 2 : Filling histos that characterize the selected event : x,y,z prim. Vtx distrib. (ESD)
1442        //-------------
1443
1444   fHistCascadeMultiplicityForSelEvt ->Fill( ncascades );
1445   fHistPosBestPrimaryVtxXForSelEvt  ->Fill( lBestPrimaryVtxPos[0] );
1446   fHistPosBestPrimaryVtxYForSelEvt  ->Fill( lBestPrimaryVtxPos[1] );
1447   fHistPosBestPrimaryVtxZForSelEvt  ->Fill( lBestPrimaryVtxPos[2] );
1448
1449   // ---------------------------------------------------------------
1450
1451   fHistEvtsInCentralityBinsvsNtracks->Fill(lcentrality,lPrimaryTrackMultiplicity);
1452
1453
1454
1455   // II - Calculation Part dedicated to Xi vertices
1456
1457   for (Int_t iXi = 0; iXi < ncascades; iXi++) {// This is the begining of the Cascade loop (ESD or AOD)
1458
1459     // -------------------------------------
1460     // II.Init - Initialisation of the local variables that will be needed for ESD/AOD
1461
1462
1463         // - 0th part of initialisation : around primary vertex ...
1464
1465     Double_t lTrkgPrimaryVtxRadius3D = -500.0;
1466     Double_t lBestPrimaryVtxRadius3D = -500.0;
1467
1468         // - 1st part of initialisation : variables needed to store AliESDCascade data members
1469     Double_t lEffMassXi      = 0. ;
1470     Double_t lChi2Xi         = -1. ;
1471     Double_t lDcaXiDaughters = -1. ;
1472     Double_t lXiCosineOfPointingAngle = -1. ;
1473     Double_t lPosXi[3] = { -1000.0, -1000.0, -1000.0 };
1474     Double_t lXiRadius = -1000. ;
1475
1476         // - 2nd part of initialisation : Nbr of clusters within TPC for the 3 daughter cascade tracks
1477     UShort_t    lPosTPCClusters    = -1; // For ESD only ...
1478     UShort_t    lNegTPCClusters    = -1; // For ESD only ...
1479     UShort_t    lBachTPCClusters   = -1; // For ESD only ...
1480
1481     Double_t lInnerWallMomCascDghters[3] = {-100., -100., -100.};
1482     Double_t lTPCSignalCascDghters   [3] = {-100., -100., -100.};
1483
1484
1485         // - 3rd part of initialisation : about V0 part in cascades
1486     Double_t lInvMassLambdaAsCascDghter = 0.;
1487     Double_t lV0Chi2Xi         = -1. ;
1488     Double_t lDcaV0DaughtersXi = -1.;
1489
1490     Double_t lDcaBachToPrimVertexXi = -1., lDcaV0ToPrimVertexXi = -1.;
1491     Double_t lDcaPosToPrimVertexXi  = -1.;
1492     Double_t lDcaNegToPrimVertexXi  = -1.;
1493     Double_t lV0CosineOfPointingAngle = -1. ;
1494     Double_t lV0toXiCosineOfPointingAngle = 0. ;
1495
1496     Double_t lPosV0Xi[3] = { -1000. , -1000., -1000. }; // Position of VO coming from cascade
1497     Double_t lV0RadiusXi = -1000.0;
1498     Double_t lV0quality  = 0.;
1499
1500
1501         // - 4th part of initialisation : Effective masses
1502     Double_t lInvMassXiMinus    = 0.;
1503     Double_t lInvMassXiPlus     = 0.;
1504     Double_t lInvMassOmegaMinus = 0.;
1505     Double_t lInvMassOmegaPlus  = 0.;
1506
1507         // - 5th part of initialisation : PID treatment
1508     Bool_t   lIsPosInXiProton      = kFALSE;
1509     Bool_t   lIsPosInXiPion        = kFALSE;
1510     Bool_t   lIsPosInOmegaProton   = kFALSE;
1511     Bool_t   lIsPosInOmegaPion     = kFALSE;
1512
1513     Bool_t   lIsNegInXiProton      = kFALSE;
1514     Bool_t   lIsNegInXiPion        = kFALSE;
1515     Bool_t   lIsNegInOmegaProton   = kFALSE;
1516     Bool_t   lIsNegInOmegaPion     = kFALSE;
1517
1518     Bool_t   lIsBachelorKaon       = kFALSE;
1519     Bool_t   lIsBachelorPion       = kFALSE;
1520
1521     Bool_t   lIsBachelorKaonForTPC = kFALSE;
1522     Bool_t   lIsBachelorPionForTPC = kFALSE;
1523     Bool_t   lIsNegPionForTPC      = kFALSE;
1524     Bool_t   lIsPosPionForTPC      = kFALSE;
1525     Bool_t   lIsNegProtonForTPC    = kFALSE;
1526     Bool_t   lIsPosProtonForTPC    = kFALSE;
1527
1528         // - 6th part of initialisation : extra info for QA
1529     Double_t lXiMomX       = 0., lXiMomY = 0., lXiMomZ = 0.;
1530     Double_t lXiTransvMom  = 0. ;
1531     Double_t lXiTotMom     = 0. ;
1532
1533     Double_t lV0PMomX       = 0., lV0PMomY = 0., lV0PMomZ = 0.;
1534     Double_t lV0NMomX       = 0., lV0NMomY = 0., lV0NMomZ = 0.;
1535     Double_t lV0TotMom     = 0. ;
1536
1537
1538     Double_t lBachMomX       = 0., lBachMomY  = 0., lBachMomZ   = 0.;
1539     Double_t lBachTransvMom  = 0.;
1540     Double_t lBachTotMom     = 0.;
1541
1542     Double_t lpTrackTransvMom  = 0.;
1543     Double_t lnTrackTransvMom  = 0.;
1544
1545     Short_t  lChargeXi = -2;
1546
1547     Double_t lRapXi   = -20.0, lRapOmega = -20.0,  lEta = -20.0, lTheta = 360., lPhi = 720. ;
1548     Double_t lAlphaXi = -200., lPtArmXi  = -200.0;
1549
1550         // - 7th part of initialisation : variables for the AliCFContainer dedicated to cascade cut optmisiation
1551
1552     if (fAnalysisType == "ESD") {
1553
1554     // -------------------------------------
1555     // II.ESD - Calculation Part dedicated to Xi vertices (ESD)
1556
1557       AliESDcascade *xi = lESDevent->GetCascade(iXi);
1558       if (!xi) continue;
1559
1560
1561                 // - II.Step 1 : around primary vertex
1562                 //-------------
1563       lTrkgPrimaryVtxRadius3D = TMath::Sqrt(  lTrkgPrimaryVtxPos[0] * lTrkgPrimaryVtxPos[0] +
1564                                               lTrkgPrimaryVtxPos[1] * lTrkgPrimaryVtxPos[1] +
1565                                               lTrkgPrimaryVtxPos[2] * lTrkgPrimaryVtxPos[2] );
1566
1567       lBestPrimaryVtxRadius3D = TMath::Sqrt(  lBestPrimaryVtxPos[0] * lBestPrimaryVtxPos[0] +
1568                                               lBestPrimaryVtxPos[1] * lBestPrimaryVtxPos[1] +
1569                                               lBestPrimaryVtxPos[2] * lBestPrimaryVtxPos[2] );
1570
1571
1572
1573                 // - II.Step 2 : Assigning the necessary variables for specific AliESDcascade data members (ESD)
1574                 //-------------
1575       lV0quality = 0.;
1576       xi->ChangeMassHypothesis(lV0quality , 3312); // default working hypothesis : cascade = Xi- decay
1577
1578       lEffMassXi                = xi->GetEffMassXi();
1579       lChi2Xi                   = xi->GetChi2Xi();
1580       lDcaXiDaughters           = xi->GetDcaXiDaughters();
1581       lXiCosineOfPointingAngle  = xi->GetCascadeCosineOfPointingAngle( lBestPrimaryVtxPos[0],
1582                                                                        lBestPrimaryVtxPos[1],
1583                                                                        lBestPrimaryVtxPos[2] );
1584                 // Take care : the best available vertex should be used (like in AliCascadeVertexer)
1585
1586       xi->GetXYZcascade( lPosXi[0],  lPosXi[1], lPosXi[2] );
1587       lXiRadius         = TMath::Sqrt( lPosXi[0]*lPosXi[0]  +  lPosXi[1]*lPosXi[1] );
1588
1589
1590
1591                 // - II.Step 3 : around the tracks : Bach + V0 (ESD)
1592                 // ~ Necessary variables for ESDcascade data members coming from the ESDv0 part (inheritance)
1593                 //-------------
1594
1595       UInt_t lIdxPosXi  = (UInt_t) TMath::Abs( xi->GetPindex() );
1596       UInt_t lIdxNegXi  = (UInt_t) TMath::Abs( xi->GetNindex() );
1597       UInt_t lBachIdx   = (UInt_t) TMath::Abs( xi->GetBindex() );
1598                 // Care track label can be negative in MC production (linked with the track quality)
1599                 // However = normally, not the case for track index ...
1600
1601                 // FIXME : rejection of a double use of a daughter track (nothing but just a crosscheck of what is done in the cascade vertexer)
1602       if (lBachIdx == lIdxNegXi) {
1603         AliWarning("Pb / Idx(Bach. track) = Idx(Neg. track) ... continue!"); continue;
1604       }
1605       if (lBachIdx == lIdxPosXi) {
1606         AliWarning("Pb / Idx(Bach. track) = Idx(Pos. track) ... continue!"); continue;
1607       }
1608
1609       AliESDtrack *pTrackXi             = lESDevent->GetTrack( lIdxPosXi );
1610       AliESDtrack *nTrackXi             = lESDevent->GetTrack( lIdxNegXi );
1611       AliESDtrack *bachTrackXi  = lESDevent->GetTrack( lBachIdx );
1612       if (!pTrackXi || !nTrackXi || !bachTrackXi ) {
1613         AliWarning("ERROR: Could not retrieve one of the 3 ESD daughter tracks of the cascade ...");
1614         continue;
1615       }
1616
1617       lPosTPCClusters   = pTrackXi->GetTPCNcls();
1618       lNegTPCClusters   = nTrackXi->GetTPCNcls();
1619       lBachTPCClusters  = bachTrackXi->GetTPCNcls();
1620
1621                 // FIXME : rejection of a poor quality tracks
1622       if (fkQualityCutTPCrefit) {
1623                 // 1 - Poor quality related to TPCrefit
1624         ULong_t pStatus    = pTrackXi->GetStatus();
1625         ULong_t nStatus    = nTrackXi->GetStatus();
1626         ULong_t bachStatus = bachTrackXi->GetStatus();
1627         if ((pStatus&AliESDtrack::kTPCrefit)    == 0) { AliWarning("Pb / V0 Pos. track has no TPCrefit ... continue!"); continue; }
1628         if ((nStatus&AliESDtrack::kTPCrefit)    == 0) { AliWarning("Pb / V0 Neg. track has no TPCrefit ... continue!"); continue; }
1629         if ((bachStatus&AliESDtrack::kTPCrefit) == 0) { AliWarning("Pb / Bach.   track has no TPCrefit ... continue!"); continue; }
1630       }
1631       if (fkQualityCutnTPCcls) {
1632                 // 2 - Poor quality related to TPC clusters
1633         if (lPosTPCClusters  < fMinnTPCcls) { AliWarning("Pb / V0 Pos. track has less than minn TPC clusters ... continue!"); continue; }
1634         if (lNegTPCClusters  < fMinnTPCcls) { AliWarning("Pb / V0 Neg. track has less than minn TPC clusters ... continue!"); continue; }
1635         if (lBachTPCClusters < fMinnTPCcls) { AliWarning("Pb / Bach.   track has less than minn TPC clusters ... continue!"); continue; }
1636       }
1637
1638       const AliExternalTrackParam *pExtTrack    = pTrackXi    ->GetInnerParam();
1639       const AliExternalTrackParam *nExtTrack    = nTrackXi    ->GetInnerParam();
1640       const AliExternalTrackParam *bachExtTrack = bachTrackXi ->GetInnerParam();
1641
1642       if (pExtTrack) {
1643         lInnerWallMomCascDghters[0] = pExtTrack ->GetP() * pExtTrack ->Charge();
1644         lTPCSignalCascDghters   [0] = pTrackXi  ->GetTPCsignal();
1645       }
1646       if (nExtTrack) {
1647         lInnerWallMomCascDghters[1] = nExtTrack ->GetP() * nExtTrack ->Charge();
1648         lTPCSignalCascDghters   [1] = nTrackXi  ->GetTPCsignal();
1649       }
1650       if (bachExtTrack) {
1651         lInnerWallMomCascDghters[2] = bachExtTrack ->GetP() * bachExtTrack ->Charge();
1652         lTPCSignalCascDghters   [2] = bachTrackXi  ->GetTPCsignal();
1653       }
1654
1655
1656       lInvMassLambdaAsCascDghter        = xi->GetEffMass();
1657                 // This value shouldn't change, whatever the working hyp. is : Xi-, Xi+, Omega-, Omega+
1658       lDcaV0DaughtersXi                 = xi->GetDcaV0Daughters();
1659       lV0Chi2Xi                         = xi->GetChi2V0();
1660
1661       lV0CosineOfPointingAngle  = xi->GetV0CosineOfPointingAngle(lBestPrimaryVtxPos[0],
1662                                                                          lBestPrimaryVtxPos[1],
1663                                                                          lBestPrimaryVtxPos[2] );
1664
1665       lDcaV0ToPrimVertexXi              = xi->GetD( lBestPrimaryVtxPos[0],
1666                                                     lBestPrimaryVtxPos[1],
1667                                                     lBestPrimaryVtxPos[2] );
1668
1669       lDcaBachToPrimVertexXi = TMath::Abs( bachTrackXi->GetD(   lBestPrimaryVtxPos[0],
1670                                                                 lBestPrimaryVtxPos[1],
1671                                                                 lMagneticField  ) );
1672                 // Note : AliExternalTrackParam::GetD returns an algebraic value ...
1673
1674       xi->GetXYZ( lPosV0Xi[0],  lPosV0Xi[1], lPosV0Xi[2] );
1675       lV0RadiusXi               = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0]  +  lPosV0Xi[1]*lPosV0Xi[1] );
1676
1677       lDcaPosToPrimVertexXi     = TMath::Abs( pTrackXi  ->GetD( lBestPrimaryVtxPos[0],
1678                                                                 lBestPrimaryVtxPos[1],
1679                                                                 lMagneticField  )     );
1680
1681       lDcaNegToPrimVertexXi     = TMath::Abs( nTrackXi  ->GetD( lBestPrimaryVtxPos[0],
1682                                                                 lBestPrimaryVtxPos[1],
1683                                                                 lMagneticField  )     );
1684
1685                 // - II.Step 3' : extra-selection for cascade candidates
1686       if (fkExtraSelections) {
1687         // if(lChi2Xi > 2000) continue; // in AliCascadeVertexer
1688         // if(lV0Chi2Xi > 2000) continue; // in AliV0vertexer
1689
1690         if (lDcaXiDaughters > 0.3) continue; // in AliCascadeVertexer
1691         if (lXiCosineOfPointingAngle < 0.999 ) continue; // in AliCascadeVertexer
1692         if (lDcaV0ToPrimVertexXi < 0.05) continue; // in AliCascadeVertexer
1693         if (lDcaBachToPrimVertexXi < 0.03) continue; // in AliCascadeVertexer
1694         // if (TMath::Abs(lInvMassLambdaAsCascDghter-1.11568) > 0.006 ) continue;  // in AliCascadeVertexer
1695
1696         if (lDcaV0DaughtersXi > 1.) continue; // in AliV0vertexer
1697         if (lV0toXiCosineOfPointingAngle < 0.998) continue; // in AliV0vertexer
1698         if (lDcaPosToPrimVertexXi < 0.1) continue; // in AliV0vertexer
1699         if (lDcaNegToPrimVertexXi < 0.1) continue; // in AliV0vertexer
1700
1701
1702         if(lXiRadius < .9) continue; // in AliCascadeVertexer
1703         // if(lXiRadius > 100) continue; // in AliCascadeVertexer
1704         if(lV0RadiusXi < 0.9) continue; // in AliV0vertexer
1705         // if(lV0RadiusXi > 100) continue; // in AliV0vertexer
1706
1707       }
1708
1709
1710
1711                 // - II.Step 4 : around effective masses (ESD)
1712                 // ~ change mass hypotheses to cover all the possibilities :  Xi-/+, Omega -/+
1713                 //-------------
1714
1715
1716       if ( bachTrackXi->Charge() < 0 )  {
1717         lV0quality = 0.;
1718         xi->ChangeMassHypothesis(lV0quality , 3312);
1719                         // Calculate the effective mass of the Xi- candidate.
1720                         // pdg code 3312 = Xi-
1721         lInvMassXiMinus = xi->GetEffMassXi();
1722
1723         lV0quality = 0.;
1724         xi->ChangeMassHypothesis(lV0quality , 3334);
1725                         // Calculate the effective mass of the Xi- candidate.
1726                         // pdg code 3334 = Omega-
1727         lInvMassOmegaMinus = xi->GetEffMassXi();
1728
1729         lV0quality = 0.;
1730         xi->ChangeMassHypothesis(lV0quality , 3312);    // Back to default hyp.
1731       }// end if negative bachelor
1732
1733
1734       if ( bachTrackXi->Charge() >  0 ) {
1735         lV0quality = 0.;
1736         xi->ChangeMassHypothesis(lV0quality , -3312);
1737                         // Calculate the effective mass of the Xi+ candidate.
1738                         // pdg code -3312 = Xi+
1739         lInvMassXiPlus = xi->GetEffMassXi();
1740
1741         lV0quality = 0.;
1742         xi->ChangeMassHypothesis(lV0quality , -3334);
1743                         // Calculate the effective mass of the Xi+ candidate.
1744                         // pdg code -3334  = Omega+
1745         lInvMassOmegaPlus = xi->GetEffMassXi();
1746
1747         lV0quality = 0.;
1748         xi->ChangeMassHypothesis(lV0quality , -3312);   // Back to "default" hyp.
1749       }// end if positive bachelor
1750
1751                 // - II.Step 5 : PID on the daughter tracks
1752                 //-------------
1753 /*
1754         // A - Combined PID */ // removed, add when will be used
1755
1756         // B - TPC PID : 3-sigma bands on Bethe-Bloch curve
1757
1758         // Bachelor
1759       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 4) lIsBachelorKaonForTPC = kTRUE;
1760       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 4) lIsBachelorPionForTPC = kTRUE;
1761
1762         // Negative V0 daughter
1763       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kPion   )) < 4) lIsNegPionForTPC   = kTRUE;
1764       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kProton )) < 4) lIsNegProtonForTPC = kTRUE;
1765
1766         // Positive V0 daughter
1767       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kPion   )) < 4) lIsPosPionForTPC   = kTRUE;
1768       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 4) lIsPosProtonForTPC = kTRUE;
1769
1770       /*
1771       const AliExternalTrackParam *pInnerWallTrackXi    = pTrackXi    ->GetInnerParam();
1772       const AliExternalTrackParam *nInnerWallTrackXi    = nTrackXi    ->GetInnerParam();
1773       const AliExternalTrackParam *bachInnerWallTrackXi = bachTrackXi ->GetInnerParam();
1774       if (pInnerWallTrackXi && nInnerWallTrackXi && bachInnerWallTrackXi ) {
1775
1776         Double_t pMomInnerWall    = pInnerWallTrackXi   ->GetP();
1777         Double_t nMomInnerWall    = nInnerWallTrackXi   ->GetP();
1778         Double_t bachMomInnerWall = bachInnerWallTrackXi->GetP();
1779
1780         // Bachelor
1781         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 3)                              lIsBachelorPionForTPC = kTRUE;
1782         if (bachMomInnerWall < 0.350  && TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 5) lIsBachelorKaonForTPC = kTRUE;
1783         if (bachMomInnerWall > 0.350  && TMath::Abs(fESDpid->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 3) lIsBachelorKaonForTPC = kTRUE;
1784
1785         // Negative V0 daughter
1786         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kPion   )) < 3  )                           lIsNegPionForTPC   = kTRUE;
1787         if (nMomInnerWall < 0.6  && TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kProton ) ) < 5 )   lIsNegProtonForTPC = kTRUE;
1788         if (nMomInnerWall > 0.6  && TMath::Abs(fESDpid->NumberOfSigmasTPC( nTrackXi,AliPID::kProton ) ) < 3 )   lIsNegProtonForTPC = kTRUE;
1789
1790         // Positive V0 daughter
1791         if (TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kPion   )) < 3 )                            lIsPosPionForTPC   = kTRUE;
1792         if (pMomInnerWall < 0.6  && TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 5)     lIsPosProtonForTPC = kTRUE;
1793         if (pMomInnerWall > 0.6  && TMath::Abs(fESDpid->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 3)     lIsPosProtonForTPC = kTRUE;
1794       }
1795       */
1796
1797                 // - II.Step 6 : extra info for QA (ESD)
1798                 // miscellaneous pieces of info that may help regarding data quality assessment.
1799                 //-------------
1800
1801       xi->GetPxPyPz( lXiMomX, lXiMomY, lXiMomZ );
1802       lXiTransvMom      = TMath::Sqrt( lXiMomX*lXiMomX   + lXiMomY*lXiMomY );
1803       lXiTotMom         = TMath::Sqrt( lXiMomX*lXiMomX   + lXiMomY*lXiMomY   + lXiMomZ*lXiMomZ );
1804
1805       xi->GetNPxPyPz(lV0NMomX,lV0NMomY,lV0NMomZ);
1806       xi->GetPPxPyPz(lV0PMomX,lV0PMomY,lV0PMomZ);
1807       lV0TotMom = TMath::Sqrt(TMath::Power(lV0NMomX+lV0PMomX,2)+TMath::Power(lV0NMomY+lV0PMomY,2)+TMath::Power(lV0NMomZ+lV0PMomZ,2));
1808
1809       xi->GetBPxPyPz(  lBachMomX,  lBachMomY,  lBachMomZ );
1810       lBachTransvMom  = TMath::Sqrt( lBachMomX*lBachMomX   + lBachMomY*lBachMomY );
1811       lBachTotMom       = TMath::Sqrt( lBachMomX*lBachMomX   + lBachMomY*lBachMomY  +  lBachMomZ*lBachMomZ  );
1812
1813       lnTrackTransvMom = TMath::Sqrt( lV0NMomX*lV0NMomX   + lV0NMomY*lV0NMomY );
1814       lpTrackTransvMom = TMath::Sqrt( lV0PMomX*lV0PMomX   + lV0PMomY*lV0PMomY );
1815
1816
1817       lChargeXi = xi->Charge();
1818
1819       lV0toXiCosineOfPointingAngle = xi->GetV0CosineOfPointingAngle( lPosXi[0], lPosXi[1], lPosXi[2] );
1820
1821       lRapXi    = xi->RapXi();
1822       lRapOmega = xi->RapOmega();
1823       lEta      = xi->Eta();
1824       lTheta    = xi->Theta() *180.0/TMath::Pi();
1825       lPhi      = xi->Phi()   *180.0/TMath::Pi();
1826       lAlphaXi  = xi->AlphaXi();
1827       lPtArmXi  = xi->PtArmXi();
1828
1829
1830         //FIXME : Extra-cut = Anti-splitting cut for lambda daughters
1831       Bool_t kAntiSplittingLambda = kFALSE;
1832
1833       if (kAntiSplittingLambda) { // not used
1834         Double_t lNMomX = 0., lNMomY = 0., lNMomZ = 0.;
1835         Double_t lPMomX = 0., lPMomY = 0., lPMomZ = 0.;
1836
1837         xi->GetPPxPyPz(lPMomX, lPMomY, lPMomZ);
1838         xi->GetNPxPyPz(lNMomX, lNMomY, lNMomZ);
1839
1840         if ( xi->Charge() < 0) {// Xi- or Omega-
1841           if (TMath::Abs(lBachTransvMom - TMath::Sqrt( lNMomX*lNMomX + lNMomY*lNMomY )  ) < 0.075) continue;
1842         } else {                //Xi+ or Omega+
1843           if(TMath::Abs(lBachTransvMom - TMath::Sqrt( lPMomX*lPMomX + lPMomY*lPMomY ) ) < 0.075) continue;
1844         }
1845       }
1846
1847       //FIXME : Just to know which file is currently open : locate the file containing Xi
1848       // cout << "Name of the file containing Xi candidate(s) :"
1849       //        << CurrentFileName()
1850       //        << " / entry: "     << Entry()
1851       //        << " / in file: "   << lESDevent->GetEventNumberInFile()   // <- Cvetan / From Mihaela: AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->GetTree()->GetReadEntry();
1852       //        << " : mass(Xi) = " << xi->GetEffMassXi()
1853       //        << " / charge = "   << lChargeXi
1854       //        << " / pt(Casc) = " << lXiTransvMom
1855       //        << " / Decay 2d R(Xi) = " << lXiRadius
1856       //        << " / Track Index(Pos)  = " << lIdxPosXi << "/ Nb(TPC clusters) = " << lPosTPCClusters
1857       //        << " / Track Index(Neg)  = " << lIdxNegXi << "/ Nb(TPC clusters) = " << lNegTPCClusters
1858       //        << " / Track Index(Bach) = " << lBachIdx  << "/ Nb(TPC clusters) = " << lBachTPCClusters
1859       //        << endl;
1860
1861
1862     } else if (fAnalysisType == "AOD") {
1863
1864       // II.AOD - Calculation Part dedicated to Xi vertices
1865
1866       const AliAODcascade *xi = lAODevent->GetCascade(iXi);
1867       if (!xi) continue;
1868
1869                 // - II.Step 1 : Characteristics of the event : prim. Vtx + magnetic field (AOD)
1870                 //-------------
1871
1872
1873       lTrkgPrimaryVtxRadius3D = -500. ;
1874       // We don't have the different prim. vertex at the AOD level -> nothing to do.
1875
1876       lBestPrimaryVtxRadius3D = TMath::Sqrt(  lBestPrimaryVtxPos[0] * lBestPrimaryVtxPos[0] +
1877                                               lBestPrimaryVtxPos[1] * lBestPrimaryVtxPos[1] +
1878                                               lBestPrimaryVtxPos[2] * lBestPrimaryVtxPos[2] );
1879
1880
1881                 // - II.Step 2 : Assigning the necessary variables for specific AliAODcascade data members (AOD)
1882                 //-------------
1883
1884       lEffMassXi                = xi->MassXi(); // default working hypothesis : cascade = Xi- decay
1885       lChi2Xi                   = xi->Chi2Xi();
1886       lDcaXiDaughters           = xi->DcaXiDaughters();
1887       lXiCosineOfPointingAngle  = xi->CosPointingAngleXi( lBestPrimaryVtxPos[0],
1888                                                           lBestPrimaryVtxPos[1],
1889                                                           lBestPrimaryVtxPos[2] );
1890                                         // Take care :
1891                                         // the best available vertex should be used (like in AliCascadeVertexer)
1892
1893       lPosXi[0] = xi->DecayVertexXiX();
1894       lPosXi[1] = xi->DecayVertexXiY();
1895       lPosXi[2] = xi->DecayVertexXiZ();
1896       lXiRadius = TMath::Sqrt( lPosXi[0]*lPosXi[0]  +  lPosXi[1]*lPosXi[1] );
1897
1898       AliAODTrack *pTrackXi    = dynamic_cast<AliAODTrack*>( xi->GetDaughter(0) );
1899       AliAODTrack *nTrackXi    = dynamic_cast<AliAODTrack*>( xi->GetDaughter(1) );
1900       AliAODTrack *bachTrackXi = dynamic_cast<AliAODTrack*>( xi->GetDecayVertexXi()->GetDaughter(0) );
1901       if (!pTrackXi || !nTrackXi || !bachTrackXi ) {
1902         AliWarning("ERROR: Could not retrieve one of the 3 AOD daughter tracks of the cascade ...");
1903         continue;
1904       }
1905
1906       UInt_t lIdxPosXi  = (UInt_t) TMath::Abs( pTrackXi->GetID() );
1907       UInt_t lIdxNegXi  = (UInt_t) TMath::Abs( nTrackXi->GetID() );
1908       UInt_t lBachIdx   = (UInt_t) TMath::Abs( bachTrackXi->GetID() );
1909
1910                 // Care track label can be negative in MC production (linked with the track quality)
1911                 // However = normally, not the case for track index ...
1912
1913                 // FIXME : rejection of a double use of a daughter track (nothing but just a crosscheck of what is done in the cascade vertexer)
1914       if (lBachIdx == lIdxNegXi) {
1915         AliWarning("Pb / Idx(Bach. track) = Idx(Neg. track) ... continue!"); continue;
1916       }
1917       if (lBachIdx == lIdxPosXi) {
1918         AliWarning("Pb / Idx(Bach. track) = Idx(Pos. track) ... continue!"); continue;
1919       }
1920
1921       lPosTPCClusters   = pTrackXi->GetTPCNcls(); // FIXME: Is this ok? or something like in LambdaK0PbPb task AOD?
1922       lNegTPCClusters   = nTrackXi->GetTPCNcls();
1923       lBachTPCClusters  = bachTrackXi->GetTPCNcls();
1924
1925                 // Rejection of a poor quality tracks
1926       if (fkQualityCutTPCrefit) {
1927                 // 1 - Poor quality related to TPCrefit
1928         if (!(pTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning("Pb / V0 Pos. track has no TPCrefit ... continue!"); continue; }
1929         if (!(nTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning("Pb / V0 Neg. track has no TPCrefit ... continue!"); continue; }
1930         if (!(bachTrackXi->IsOn(AliAODTrack::kTPCrefit))) { AliWarning("Pb / Bach.   track has no TPCrefit ... continue!"); continue; }
1931       }
1932       if (fkQualityCutnTPCcls) {
1933                 // 2 - Poor quality related to TPC clusters
1934         if (lPosTPCClusters  < fMinnTPCcls) { //AliWarning("Pb / V0 Pos. track has less than minn TPC clusters ... continue!");
1935           continue; }
1936         if (lNegTPCClusters  < fMinnTPCcls) { //AliWarning("Pb / V0 Neg. track has less than minn TPC clusters ... continue!");
1937           continue; }
1938         if (lBachTPCClusters < fMinnTPCcls) { //AliWarning("Pb / Bach.   track has less than minn TPC clusters ... continue!");
1939           continue; }
1940       }
1941
1942
1943                 // - II.Step 3 : around the tracks : Bach + V0 (AOD)
1944                 // ~ Necessary variables for AODcascade data members coming from the AODv0 part (inheritance)
1945                 //-------------
1946
1947       lChargeXi                         = xi->ChargeXi();
1948
1949       if ( lChargeXi < 0)
1950         lInvMassLambdaAsCascDghter      = xi->MassLambda();
1951       else
1952         lInvMassLambdaAsCascDghter      = xi->MassAntiLambda();
1953
1954       lDcaV0DaughtersXi                 = xi->DcaV0Daughters();
1955       lV0Chi2Xi                         = xi->Chi2V0();
1956
1957       lDcaV0ToPrimVertexXi              = xi->DcaV0ToPrimVertex();
1958
1959       lDcaBachToPrimVertexXi            = xi->DcaBachToPrimVertex();
1960
1961
1962       lPosV0Xi[0] = xi->DecayVertexV0X();
1963       lPosV0Xi[1] = xi->DecayVertexV0Y();
1964       lPosV0Xi[2] = xi->DecayVertexV0Z();
1965       lV0RadiusXi       = TMath::Sqrt( lPosV0Xi[0]*lPosV0Xi[0]  +  lPosV0Xi[1]*lPosV0Xi[1] );
1966
1967       lV0CosineOfPointingAngle        = xi->CosPointingAngle( lBestPrimaryVtxPos );
1968
1969       lDcaPosToPrimVertexXi             = xi->DcaPosToPrimVertex();
1970       lDcaNegToPrimVertexXi             = xi->DcaNegToPrimVertex();
1971
1972                 // - II.Step 4 : around effective masses (AOD)
1973                 // ~ change mass hypotheses to cover all the possibilities :  Xi-/+, Omega -/+
1974                 //-------------
1975
1976       if ( lChargeXi < 0 )              lInvMassXiMinus         = xi->MassXi();
1977       if ( lChargeXi > 0 )              lInvMassXiPlus          = xi->MassXi();
1978       if ( lChargeXi < 0 )              lInvMassOmegaMinus      = xi->MassOmega();
1979       if ( lChargeXi > 0 )              lInvMassOmegaPlus       = xi->MassOmega();
1980
1981
1982                 // - II.Step 5 : PID on the daughters
1983                 //-------------
1984
1985         // Combined PID
1986
1987
1988         // TPC PID: 4-sigma bands on Bethe-Bloch curve
1989
1990         // Bachelor
1991       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kKaon)) < 4) lIsBachelorKaonForTPC = kTRUE;
1992       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( bachTrackXi,AliPID::kPion)) < 4) lIsBachelorPionForTPC = kTRUE;
1993
1994         // Negative V0 daughter
1995       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kPion   )) < 4) lIsNegPionForTPC   = kTRUE;
1996       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( nTrackXi,AliPID::kProton )) < 4) lIsNegProtonForTPC = kTRUE;
1997
1998         // Positive V0 daughter
1999       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kPion   )) < 4) lIsPosPionForTPC   = kTRUE;
2000       if (TMath::Abs(fPIDResponse->NumberOfSigmasTPC( pTrackXi,AliPID::kProton )) < 4) lIsPosProtonForTPC = kTRUE;
2001
2002
2003                 // - II.Step 6 : extra info for QA (AOD)
2004                 // miscellaneous pieces onf info that may help regarding data quality assessment.
2005                 //-------------
2006       lXiMomX = xi->MomXiX();
2007       lXiMomY = xi->MomXiY();
2008       lXiMomZ = xi->MomXiZ();
2009       lXiTransvMom      = TMath::Sqrt( lXiMomX*lXiMomX   + lXiMomY*lXiMomY );
2010       lXiTotMom         = TMath::Sqrt( lXiMomX*lXiMomX   + lXiMomY*lXiMomY   + lXiMomZ*lXiMomZ );
2011
2012       Double_t lV0MomX = xi->MomV0X();
2013       Double_t lV0MomY = xi->MomV0Y();
2014       Double_t lV0MomZ = xi->MomV0Z();
2015       lV0TotMom = TMath::Sqrt(TMath::Power(lV0MomX,2)+TMath::Power(lV0MomY,2)+TMath::Power(lV0MomZ,2));
2016
2017       lBachMomX = xi->MomBachX();
2018       lBachMomY = xi->MomBachY();
2019       lBachMomZ = xi->MomBachZ();
2020       lBachTransvMom  = TMath::Sqrt( lBachMomX*lBachMomX   + lBachMomY*lBachMomY );
2021       lBachTotMom       = TMath::Sqrt( lBachMomX*lBachMomX   + lBachMomY*lBachMomY  +  lBachMomZ*lBachMomZ  );
2022
2023       lV0NMomX = xi->MomNegX();
2024       lV0NMomY = xi->MomNegY();
2025       lV0PMomX = xi->MomPosX();
2026       lV0PMomY = xi->MomPosY();
2027
2028       lnTrackTransvMom = TMath::Sqrt( lV0NMomX*lV0NMomX   + lV0NMomY*lV0NMomY );
2029       lpTrackTransvMom = TMath::Sqrt( lV0PMomX*lV0PMomX   + lV0PMomY*lV0PMomY );
2030
2031       lV0toXiCosineOfPointingAngle = xi->CosPointingAngle( xi->GetDecayVertexXi() );
2032
2033       lRapXi    = xi->RapXi();
2034       lRapOmega = xi->RapOmega();
2035       lEta      = xi->Eta();                            // Will not work ! need a method Pz(), Py() Px()
2036       lTheta    = xi->Theta() *180.0/TMath::Pi();       // in AODcascade.
2037       lPhi      = xi->Phi()   *180.0/TMath::Pi();       // Here, we will get eta, theta, phi for the V0 ...
2038       lAlphaXi  = xi->AlphaXi();
2039       lPtArmXi  = xi->PtArmXi();
2040
2041                 // II.Step 7 - Complementary info for monitoring the cascade cut variables
2042         // TPC clusters
2043
2044     }// end of AOD treatment
2045
2046     // Cut on pt of the three daughter tracks
2047     if (lBachTransvMom<fMinPtCutOnDaughterTracks) continue;
2048     if (lpTrackTransvMom<fMinPtCutOnDaughterTracks) continue;
2049     if (lnTrackTransvMom<fMinPtCutOnDaughterTracks) continue;
2050
2051
2052     // Calculate proper time for cascade
2053
2054     Double_t cascadeMass = 0.;
2055
2056     if ( ( (lChargeXi<0) && lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) ||
2057          ( (lChargeXi>0) && lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC )  ) cascadeMass = 1.321;
2058
2059     if ( ( (lChargeXi<0) && lIsBachelorKaonForTPC   && lIsPosProtonForTPC    && lIsNegPionForTPC ) ||
2060          ( (lChargeXi>0) && lIsBachelorKaonForTPC   && lIsNegProtonForTPC    && lIsPosPionForTPC )  ) cascadeMass = 1.672;
2061
2062     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));
2063     if (lXiTotMom!=0)         lctau = lctau*cascadeMass/lXiTotMom;
2064     else lctau = -1.;
2065
2066
2067     // Calculate proper time for Lambda (reconstructed)
2068      Float_t lambdaMass = 1.115683; // PDG mass
2069      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));
2070      Float_t lctauV0 = -1.;
2071      if (lV0TotMom!=0) lctauV0 = distV0Xi*lambdaMass/lV0TotMom;
2072
2073      Float_t distTV0Xi =  TMath::Sqrt(TMath::Power((lPosV0Xi[0]-lPosXi[0]),2)+TMath::Power((lPosV0Xi[1]-lPosXi[1]),2));
2074
2075
2076     // -------------------------------------
2077     // II.Fill - Filling the TH1,2,3Fs, HnSparses, CFContainers, FOR events with CASCADES !
2078     // For AliEVE
2079 /*         if(lChargeXi < 0&& lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) {
2080             if (lXiTransvMom>2.&&lXiTransvMom<4.&&(lInvMassXiMinus<1.322&&lInvMassXiMinus>1.320)&&(lXiRadius<8.&&lXiRadius>3.)) {
2081         //                 // FIXME : Just to know which file is currently open : locate the file containing Xi
2082          cout << "Name of the file containing Xi candidate(s) :"
2083                  << CurrentFileName()
2084                  << " / entry: "     << Entry()
2085                  << " / in file: "   << lESDevent->GetEventNumberInFile()   // <- Cvetan / From Mihaela: AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->GetTree()->GetReadEntry();
2086                  << " AliESDcascade number " << iXi
2087                  << " : mass(Xi-) = " << lInvMassXiMinus
2088                  << " / charge = "   << lChargeXi
2089                  << " / pt(Casc) = " << lXiTransvMom
2090                  << " / Decay 2d R(Xi) = " << lXiRadius
2091                  << endl;
2092           }
2093          }
2094          if(lChargeXi < 0&& lIsBachelorKaonForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) {
2095            if (lXiTransvMom>2&&lXiTransvMom<4&&(lInvMassOmegaMinus<1.674&&lInvMassOmegaMinus>1.670)&&(lXiRadius<8.&&lXiRadius>3.)) {
2096          cout << "Name of the file containing Omega candidate(s) :"
2097                  << CurrentFileName()
2098                  << " / entry: "     << Entry()
2099                  << " / in file: "   << lESDevent->GetEventNumberInFile()   // <- Cvetan / From Mihaela: AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()->GetTree()->GetReadEntry();
2100                  << " AliESDcascade number " << iXi
2101                  << " : mass(Omega-) = " << lInvMassOmegaMinus
2102                  << " / charge = "   << lChargeXi
2103                  << " / pt(Casc) = " << lXiTransvMom
2104                  << " / Decay 2d R(Xi) = " << lXiRadius
2105                  << endl;
2106
2107            }
2108          }
2109 */
2110
2111
2112         // - II.Fill.Step 1      : primary vertex
2113
2114     fHistTPCrefitTrackMultiplicityForCascadeEvt->Fill( nTrackWithTPCrefitMultiplicity );
2115
2116     fHistPosV0TPCClusters           ->Fill( lPosTPCClusters  );
2117     fHistNegV0TPCClusters           ->Fill( lNegTPCClusters  );
2118     fHistBachTPCClusters            ->Fill( lBachTPCClusters );
2119
2120     f2dHistTPCdEdxOfCascDghters     ->Fill( lInnerWallMomCascDghters[0] , lTPCSignalCascDghters[0]  );
2121     f2dHistTPCdEdxOfCascDghters     ->Fill( lInnerWallMomCascDghters[1] , lTPCSignalCascDghters[1]  );
2122     f2dHistTPCdEdxOfCascDghters     ->Fill( lInnerWallMomCascDghters[2] , lTPCSignalCascDghters[2]  );
2123
2124     fHistVtxStatus                  ->Fill( lStatusTrackingPrimVtx   );  // 1 if tracking vtx = ok
2125
2126     if ( lStatusTrackingPrimVtx ) {
2127       fHistPosTrkgPrimaryVtxXForCascadeEvt  ->Fill( lTrkgPrimaryVtxPos[0]    );
2128       fHistPosTrkgPrimaryVtxYForCascadeEvt  ->Fill( lTrkgPrimaryVtxPos[1]    );
2129       fHistPosTrkgPrimaryVtxZForCascadeEvt  ->Fill( lTrkgPrimaryVtxPos[2]    );
2130       fHistTrkgPrimaryVtxRadius             ->Fill( lTrkgPrimaryVtxRadius3D );
2131     }
2132
2133     fHistPosBestPrimaryVtxXForCascadeEvt   ->Fill( lBestPrimaryVtxPos[0]    );
2134     fHistPosBestPrimaryVtxYForCascadeEvt   ->Fill( lBestPrimaryVtxPos[1]    );
2135     fHistPosBestPrimaryVtxZForCascadeEvt   ->Fill( lBestPrimaryVtxPos[2]    );
2136     fHistBestPrimaryVtxRadius              ->Fill( lBestPrimaryVtxRadius3D  );
2137
2138     f2dHistTrkgPrimVtxVsBestPrimVtx->Fill( lTrkgPrimaryVtxRadius3D, lBestPrimaryVtxRadius3D );
2139
2140         // **************************** With PID on ? ... for the signal region ? ************FIXME**************************************
2141     if ( ( (lChargeXi<0) && lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC ) ||
2142          ( (lChargeXi>0) && lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC )  )
2143                 // NOTE :
2144                 // with this condition, it could happen that a cascade candidate satisfies the wrong requirement,
2145                 // e.g. one looks at a Xi- candidate for which lIsBachelorPionForTPC && lIsPosProtonForTPC && lIsNegPionForTPC = kFALSE
2146                 //      Expectation: it should be excluded.
2147                 //      but lIsBachelorPionForTPC && lIsNegProtonForTPC && lIsPosPionForTPC = kTRUE
2148                 //      then this bad Xi-candidate will contribute anyway (OR condition).
2149                 // Hence : the extra condition on the sign of the Cascade
2150                                                                                                  {
2151                 //         if( TMath::Abs( lInvMassXiMinus-1.3217 ) < 0.010 || TMath::Abs( lInvMassXiPlus-1.3217 ) < 0.010)
2152
2153                 // II.Fill.Step 2
2154       fHistEffMassXi                    ->Fill( lEffMassXi               );
2155       fHistChi2Xi                       ->Fill( lChi2Xi                  );     // Flag CascadeVtxer: Cut Variable a
2156       fHistDcaXiDaughters               ->Fill( lDcaXiDaughters          );     // Flag CascadeVtxer: Cut Variable e
2157       fHistDcaBachToPrimVertex          ->Fill( lDcaBachToPrimVertexXi   );     // Flag CascadeVtxer: Cut Variable d
2158       fHistXiCosineOfPointingAngle      ->Fill( lXiCosineOfPointingAngle );     // Flag CascadeVtxer: Cut Variable f
2159       fHistXiRadius                     ->Fill( lXiRadius                );     // Flag CascadeVtxer: Cut Variable g+h
2160
2161
2162                 // II.Fill.Step 3
2163       fHistMassLambdaAsCascDghter       ->Fill( lInvMassLambdaAsCascDghter );   // Flag CascadeVtxer: Cut Variable c
2164       fHistV0Chi2Xi                     ->Fill( lV0Chi2Xi                  );
2165       fHistDcaV0DaughtersXi             ->Fill( lDcaV0DaughtersXi          );
2166       fHistV0CosineOfPointingAngle      ->Fill( lV0CosineOfPointingAngle   );
2167       fHistV0RadiusXi                   ->Fill( lV0RadiusXi                );
2168
2169       fHistDcaV0ToPrimVertexXi  ->Fill( lDcaV0ToPrimVertexXi       );   // Flag CascadeVtxer: Cut Variable b
2170       fHistDcaPosToPrimVertexXi ->Fill( lDcaPosToPrimVertexXi      );
2171       fHistDcaNegToPrimVertexXi ->Fill( lDcaNegToPrimVertexXi      );
2172
2173
2174                 // II.Fill.Step 4 : extra QA info
2175
2176       fHistChargeXi                   ->Fill( lChargeXi      );
2177       fHistV0toXiCosineOfPointingAngle->Fill( lV0toXiCosineOfPointingAngle );
2178
2179       if ( TMath::Abs( lInvMassXiMinus-1.3217 ) < 0.012 || TMath::Abs( lInvMassXiPlus-1.3217 ) < 0.012) {// One InvMass should be different from 0
2180         fHistXiTransvMom        ->Fill( lXiTransvMom   );
2181         fHistXiTotMom           ->Fill( lXiTotMom      );
2182
2183         fHistBachTransvMomXi    ->Fill( lBachTransvMom );
2184         fHistPosTransvMomXi    ->Fill( lpTrackTransvMom );
2185         fHistNegTransvMomXi    ->Fill( lnTrackTransvMom );
2186         fHistBachTotMomXi       ->Fill( lBachTotMom    );
2187
2188         fHistRapXi              ->Fill( lRapXi         );
2189         fHistEtaXi              ->Fill( lEta           );
2190         fHistThetaXi            ->Fill( lTheta         );
2191         fHistPhiXi              ->Fill( lPhi           );
2192       }
2193
2194       if ( TMath::Abs( lInvMassOmegaMinus-1.672 ) < 0.012 || TMath::Abs( lInvMassOmegaPlus-1.672 ) < 0.012 ) {// One InvMass should be different from 0
2195         fHistRapOmega           ->Fill( lRapOmega            );
2196       }
2197
2198       f2dHistArmenteros         ->Fill( lAlphaXi, lPtArmXi   );
2199     }// end with PID ...
2200
2201         // II.Fill.Step 5 : inv mass plots 1D
2202     if ( lChargeXi < 0 ) {
2203       fHistMassXiMinus         ->Fill( lInvMassXiMinus    );
2204       fHistMassOmegaMinus      ->Fill( lInvMassOmegaMinus );
2205       if(lIsBachelorPion)       fHistMassWithCombPIDXiMinus    ->Fill( lInvMassXiMinus    );
2206       if(lIsBachelorKaon)       fHistMassWithCombPIDOmegaMinus ->Fill( lInvMassOmegaMinus );
2207
2208       fHistDcaXiDaughtersvsInvMass->Fill(lDcaXiDaughters,lInvMassXiMinus);
2209       fHistDcaBachToPrimVertexvsInvMass->Fill(lDcaBachToPrimVertexXi,lInvMassXiMinus);
2210       fHistXiCosineOfPointingAnglevsInvMass->Fill(lXiCosineOfPointingAngle,lInvMassXiMinus);
2211       fHistMassLambdaAsCascDghtervsInvMass->Fill(lInvMassLambdaAsCascDghter,lInvMassXiMinus);
2212       fHistDcaV0DaughtersXivsInvMass->Fill(lDcaV0DaughtersXi,lInvMassXiMinus);
2213       fHistDcaV0ToPrimVertexXivsInvMass->Fill(lDcaV0ToPrimVertexXi,lInvMassXiMinus);
2214     }
2215
2216     if ( lChargeXi > 0 ) {
2217       fHistMassXiPlus                  ->Fill( lInvMassXiPlus     );
2218       fHistMassOmegaPlus               ->Fill( lInvMassOmegaPlus  );
2219       if(lIsBachelorPion)       fHistMassWithCombPIDXiPlus     ->Fill( lInvMassXiPlus     );
2220       if(lIsBachelorKaon)       fHistMassWithCombPIDOmegaPlus  ->Fill( lInvMassOmegaPlus  );
2221     }
2222
2223
2224         // II.Fill.Step 6 : inv mass plots 2D, 3D
2225     if ( lChargeXi < 0 ) {
2226       f2dHistEffMassLambdaVsEffMassXiMinus->Fill( lInvMassLambdaAsCascDghter, lInvMassXiMinus );
2227       f2dHistEffMassXiVsEffMassOmegaMinus ->Fill( lInvMassXiMinus, lInvMassOmegaMinus );
2228       f2dHistXiRadiusVsEffMassXiMinus     ->Fill( lXiRadius, lInvMassXiMinus );
2229       f2dHistXiRadiusVsEffMassOmegaMinus  ->Fill( lXiRadius, lInvMassOmegaMinus );
2230 //      f3dHistXiPtVsEffMassVsYXiMinus      ->Fill( lXiTransvMom, lInvMassXiMinus,    lRapXi    );
2231 //      f3dHistXiPtVsEffMassVsYOmegaMinus   ->Fill( lXiTransvMom, lInvMassOmegaMinus, lRapOmega );
2232     } else {
2233       f2dHistEffMassLambdaVsEffMassXiPlus ->Fill( lInvMassLambdaAsCascDghter, lInvMassXiPlus );
2234       f2dHistEffMassXiVsEffMassOmegaPlus  ->Fill( lInvMassXiPlus, lInvMassOmegaPlus );
2235       f2dHistXiRadiusVsEffMassXiPlus      ->Fill( lXiRadius, lInvMassXiPlus);
2236       f2dHistXiRadiusVsEffMassOmegaPlus   ->Fill( lXiRadius, lInvMassOmegaPlus );
2237 //      f3dHistXiPtVsEffMassVsYXiPlus       ->Fill( lXiTransvMom, lInvMassXiPlus,    lRapXi    );
2238 //      f3dHistXiPtVsEffMassVsYOmegaPlus    ->Fill( lXiTransvMom, lInvMassOmegaPlus, lRapOmega );
2239     }
2240
2241         // - Filling the AliCFContainers related to PID
2242
2243     Double_t lContainerPIDVars[4] = {0.0};
2244
2245         // Xi Minus
2246     if ( lChargeXi < 0 ) {
2247       lContainerPIDVars[0] = lXiTransvMom       ;
2248       lContainerPIDVars[1] = lInvMassXiMinus    ;
2249       lContainerPIDVars[2] = lRapXi             ;
2250       lContainerPIDVars[3] = lcentrality;
2251
2252                 // No PID
2253       fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 0); // No PID
2254                 // TPC PID
2255       if ( lIsBachelorPionForTPC  )
2256         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
2257
2258       if ( lIsBachelorPionForTPC &&
2259            lIsPosProtonForTPC     )
2260         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
2261
2262       if ( lIsBachelorPionForTPC &&
2263            lIsPosProtonForTPC    &&
2264            lIsNegPionForTPC       )
2265         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
2266
2267                 // Combined PID
2268       if ( lIsBachelorPion        )
2269         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
2270
2271       if ( lIsBachelorPion       &&
2272            lIsPosInXiProton    )
2273         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
2274
2275       if (lIsBachelorPion     &&
2276           lIsPosInXiProton &&
2277           lIsNegInXiPion    )
2278         fCFContCascadePIDXiMinus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
2279     }
2280
2281     lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.; lContainerPIDVars[3] = 0.;
2282
2283     // Xi Plus
2284     if ( lChargeXi > 0 ) {
2285       lContainerPIDVars[0] = lXiTransvMom       ;
2286       lContainerPIDVars[1] = lInvMassXiPlus     ;
2287       lContainerPIDVars[2] = lRapXi             ;
2288       lContainerPIDVars[3] = lcentrality;
2289
2290                 // No PID
2291       fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 0); // No PID
2292                 // TPC PID
2293       if ( lIsBachelorPionForTPC  )
2294         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
2295
2296       if ( lIsBachelorPionForTPC &&
2297            lIsNegProtonForTPC     )
2298         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
2299
2300       if ( lIsBachelorPionForTPC &&
2301            lIsNegProtonForTPC    &&
2302            lIsPosPionForTPC       )
2303         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
2304
2305                 // Combined PID
2306       if ( lIsBachelorPion        )
2307         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
2308
2309       if ( lIsBachelorPion       &&
2310           lIsNegInXiProton    )
2311         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
2312
2313       if (lIsBachelorPion     &&
2314           lIsNegInXiProton &&
2315           lIsPosInXiPion    )
2316         fCFContCascadePIDXiPlus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
2317     }
2318
2319     lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.; lContainerPIDVars[3] = 0.;
2320
2321         // Omega Minus
2322     if ( lChargeXi < 0 ) {
2323       lContainerPIDVars[0] = lXiTransvMom       ;
2324       lContainerPIDVars[1] = lInvMassOmegaMinus ;
2325       lContainerPIDVars[2] = lRapOmega          ;
2326       lContainerPIDVars[3] = lcentrality;
2327
2328                 // No PID
2329       fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 0); // No PID
2330                 // TPC PID
2331       if ( lIsBachelorKaonForTPC  )
2332         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
2333
2334       if ( lIsBachelorKaonForTPC &&
2335            lIsPosProtonForTPC     )
2336         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
2337
2338       if ( lIsBachelorKaonForTPC &&
2339            lIsPosProtonForTPC    &&
2340            lIsNegPionForTPC       )
2341         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
2342
2343                 // Combined PID
2344       if ( lIsBachelorKaon        )
2345         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
2346
2347       if ( lIsBachelorKaon       &&
2348            lIsPosInOmegaProton    )
2349         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
2350
2351       if (lIsBachelorKaon     &&
2352           lIsPosInOmegaProton &&
2353           lIsNegInOmegaPion    )
2354         fCFContCascadePIDOmegaMinus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
2355     }
2356
2357     lContainerPIDVars[0] = 0.; lContainerPIDVars[1] = 0.; lContainerPIDVars[2] = 0.; lContainerPIDVars[3] = 0.;
2358
2359         // Omega Plus
2360     if ( lChargeXi > 0 ) {
2361       lContainerPIDVars[0] = lXiTransvMom       ;
2362       lContainerPIDVars[1] = lInvMassOmegaPlus ;
2363       lContainerPIDVars[2] = lRapOmega          ;
2364       lContainerPIDVars[3] = lcentrality;
2365
2366                 // No PID
2367       fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 0); // No PID
2368                 // TPC PID
2369       if ( lIsBachelorKaonForTPC  )
2370         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 1); // TPC PID / 4-#sigma cut on Bachelor track
2371
2372       if( lIsBachelorKaonForTPC &&
2373           lIsNegProtonForTPC     )
2374         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 2); // TPC PID / 4-#sigma cut on Bachelor+Baryon tracks
2375
2376       if ( lIsBachelorKaonForTPC &&
2377            lIsNegProtonForTPC    &&
2378            lIsPosPionForTPC       )
2379         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 3); // TPC PID / 4-#sigma cut on Bachelor+Baryon+Meson tracks
2380
2381                 // Combined PID
2382       if ( lIsBachelorKaon        )
2383         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 4); // Comb. PID / Bachelor
2384
2385       if ( lIsBachelorKaon       &&
2386            lIsNegInOmegaProton    )
2387         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 5); // Comb. PID / Bachelor+Baryon
2388
2389       if (lIsBachelorKaon     &&
2390           lIsNegInOmegaProton &&
2391           lIsPosInOmegaPion    )
2392         fCFContCascadePIDOmegaPlus->Fill(lContainerPIDVars, 6); // Comb. PID / Bachelor+Baryon+Meson
2393     }
2394
2395
2396         // II.Fill.Step 7 : filling the AliCFContainer (optimisation of topological selections)
2397        Double_t lContainerCutVars[22] = {0.0};
2398
2399        lContainerCutVars[0]  = lDcaXiDaughters;
2400        lContainerCutVars[1]  = lDcaBachToPrimVertexXi;
2401        lContainerCutVars[2]  = lXiCosineOfPointingAngle;
2402        lContainerCutVars[3]  = lXiRadius;
2403        lContainerCutVars[4]  = lInvMassLambdaAsCascDghter;
2404        lContainerCutVars[5]  = lDcaV0DaughtersXi;
2405        lContainerCutVars[6]  = lV0CosineOfPointingAngle;//lV0toXiCosineOfPointingAngle;
2406        lContainerCutVars[7]  = lV0RadiusXi;
2407        lContainerCutVars[8]  = lDcaV0ToPrimVertexXi;
2408        lContainerCutVars[9]  = lDcaPosToPrimVertexXi;
2409        lContainerCutVars[10] = lDcaNegToPrimVertexXi;
2410
2411        lContainerCutVars[13] = lXiTransvMom;
2412
2413        lContainerCutVars[16] = lBestPrimaryVtxPos[2];
2414        lContainerCutVars[17] = lcentrality;
2415        lContainerCutVars[18] = lPrimaryTrackMultiplicity;
2416 //       lContainerCutVars[19] = lBachTPCClusters;
2417
2418        lContainerCutVars[19] = lctau;
2419        lContainerCutVars[20] = lctauV0;
2420        lContainerCutVars[21] = distTV0Xi;
2421
2422        if ( lChargeXi < 0 ) {
2423          lContainerCutVars[11] = lInvMassXiMinus;
2424          lContainerCutVars[12] = lInvMassOmegaMinus;//1.63;
2425          lContainerCutVars[14] = lRapXi;
2426          lContainerCutVars[15] = -1.;
2427          if ( lIsBachelorPionForTPC   && lIsPosProtonForTPC    && lIsNegPionForTPC )
2428            fCFContCascadeCuts->Fill(lContainerCutVars,0); // for Xi-
2429
2430          lContainerCutVars[11] = lInvMassXiMinus;
2431          lContainerCutVars[12] = lInvMassOmegaMinus;
2432          lContainerCutVars[14] = -1.;
2433          lContainerCutVars[15] = lRapOmega;
2434          if ( lIsBachelorKaonForTPC   && lIsPosProtonForTPC    && lIsNegPionForTPC )
2435            fCFContCascadeCuts->Fill(lContainerCutVars,2); // for Omega-
2436        } else {
2437          lContainerCutVars[11] = lInvMassXiPlus;
2438          lContainerCutVars[12] = lInvMassOmegaPlus;//1.63;
2439          lContainerCutVars[14] = lRapXi;
2440          lContainerCutVars[15] = -1.;
2441          if ( lIsBachelorPionForTPC   && lIsNegProtonForTPC    && lIsPosPionForTPC )
2442            fCFContCascadeCuts->Fill(lContainerCutVars,1); // for Xi+
2443
2444          lContainerCutVars[11] = lInvMassXiPlus;//1.26;
2445          lContainerCutVars[12] = lInvMassOmegaPlus;
2446          lContainerCutVars[14] = -1.;
2447          lContainerCutVars[15] = lRapOmega;
2448          if ( lIsBachelorKaonForTPC   && lIsNegProtonForTPC    && lIsPosPionForTPC )
2449            fCFContCascadeCuts->Fill(lContainerCutVars,3); // for Omega+
2450        }
2451
2452    }// end of the Cascade loop (ESD or AOD)
2453
2454
2455   // Post output data.
2456  PostData(1, fListHistCascade);
2457  PostData(2, fCFContCascadePIDXiMinus);
2458  PostData(3, fCFContCascadePIDXiPlus);
2459  PostData(4, fCFContCascadePIDOmegaMinus);
2460  PostData(5, fCFContCascadePIDOmegaPlus);
2461  PostData(6, fCFContCascadeCuts);
2462 }
2463
2464 //________________________________________________________________________
2465 Int_t AliAnalysisTaskCheckCascadePbPb::DoESDTrackWithTPCrefitMultiplicity(const AliESDEvent *lESDevent) {
2466     // Checking the number of tracks with TPCrefit for each event
2467     // Needed for a rough assessment of the event multiplicity
2468
2469     Int_t nTrackWithTPCrefitMultiplicity = 0;
2470     for (Int_t iTrackIdx = 0; iTrackIdx < (InputEvent())->GetNumberOfTracks(); iTrackIdx++) {
2471       AliESDtrack *esdTrack     = 0x0;
2472       esdTrack  = lESDevent->GetTrack( iTrackIdx );
2473       if (!esdTrack) { AliWarning("Pb / Could not retrieve one track within the track loop for TPCrefit check ..."); continue; }
2474
2475       ULong_t lTrackStatus    = esdTrack->GetStatus();
2476       if ((lTrackStatus&AliESDtrack::kTPCrefit)    == 0) continue;
2477       else nTrackWithTPCrefitMultiplicity++;
2478                     // FIXME :
2479                     // The goal here is to get a better assessment of the event multiplicity.
2480                     // (InputEvent())->GetNumberOfTracks() takes into account ITS std alone tracks + global tracks
2481                     // This may introduce a bias. Hence the number of TPC refit tracks.
2482                     // Note : the event multiplicity = analysis on its own... See Jacek's or Jan Fiete's analysis on dN/d(eta)
2483
2484     }// end loop over all event tracks
2485     return  nTrackWithTPCrefitMultiplicity;
2486 }
2487
2488 //________________________________________________________________________
2489 void AliAnalysisTaskCheckCascadePbPb::Terminate(Option_t *)
2490 {
2491   // Draw result to the screen
2492   // Called once at the end of the query
2493
2494   TList *cRetrievedList = 0x0;
2495          cRetrievedList = (TList*)GetOutputData(1);
2496         if(!cRetrievedList){
2497                 AliWarning("ERROR - AliAnalysisTaskCheckCascadePbPb: ouput data container list not available\n"); return;
2498         }
2499
2500   fHistTrackMultiplicityForCentrEvt = dynamic_cast<TH1F*> (   cRetrievedList->FindObject("fHistTrackMultiplicityForCentrEvt") );
2501   if (!fHistTrackMultiplicityForCentrEvt) {
2502                 AliWarning("ERROR - AliAnalysisTaskCheckCascadePbPb: fHistTrackMultiplicityForCentrEvt not available\n"); return;
2503         }
2504
2505   fHistCascadeMultiplicityForCentrEvt = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistCascadeMultiplicityForCentrEvt") );
2506         if (!fHistCascadeMultiplicityForCentrEvt) {
2507                 AliWarning("ERROR - AliAnalysisTaskCheckCascadePbPb: fHistCascadeMultiplicityForCentrEvt not available\n"); return;
2508         }
2509
2510   fHistMassXiMinus    = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassXiMinus") );
2511         if (!fHistMassXiMinus) {
2512                 AliWarning("ERROR - AliAnalysisTaskCheckCascadePbPb: fHistMassXiMinus not available\n"); return;
2513         }
2514   fHistMassXiPlus     = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassXiPlus") );
2515         if (!fHistMassXiPlus) {
2516                 AliWarning("ERROR - AliAnalysisTaskCheckCascadePbPb: fHistMassXiPlus not available\n"); return;
2517         }
2518   fHistMassOmegaMinus = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassOmegaMinus") );
2519         if (!fHistMassOmegaMinus) {
2520                 AliWarning("ERROR - AliAnalysisTaskCheckCascadePbPb: fHistMassOmegaMinus not available\n"); return;
2521         }
2522   fHistMassOmegaPlus  = dynamic_cast<TH1F*> ( cRetrievedList->FindObject("fHistMassOmegaPlus") );
2523         if (!fHistMassOmegaPlus) {
2524                 AliWarning("ERROR - AliAnalysisTaskCheckCascadePbPb: fHistMassOmegaPlus not available\n"); return;
2525         }
2526
2527   TCanvas *canCheckCascade = new TCanvas("AliAnalysisTaskCheckCascadePbPb","CheckCascade overview",10,10,1010,660);
2528   canCheckCascade->Divide(2,2);
2529
2530   canCheckCascade->cd(1);
2531   canCheckCascade->cd(1)->SetLogy();
2532   fHistTrackMultiplicityForCentrEvt->SetMarkerStyle(kFullStar);
2533   fHistTrackMultiplicityForCentrEvt->GetXaxis()->SetLabelFont(42);
2534   fHistTrackMultiplicityForCentrEvt->GetYaxis()->SetLabelFont(42);
2535   fHistTrackMultiplicityForCentrEvt->SetTitleFont(42, "xy");
2536   fHistTrackMultiplicityForCentrEvt->GetXaxis()->SetTitleOffset(1.1);
2537   fHistTrackMultiplicityForCentrEvt->DrawCopy("H");
2538
2539   canCheckCascade->cd(2);
2540   canCheckCascade->cd(2)->SetLogy();
2541   fHistCascadeMultiplicityForCentrEvt->SetMarkerStyle(kOpenSquare);
2542   fHistCascadeMultiplicityForCentrEvt->GetXaxis()->SetLabelFont(42);
2543   fHistCascadeMultiplicityForCentrEvt->GetYaxis()->SetLabelFont(42);
2544   fHistCascadeMultiplicityForCentrEvt->SetTitleFont(42, "xy");
2545   fHistCascadeMultiplicityForCentrEvt->GetXaxis()->SetTitleOffset(1.1);
2546   fHistCascadeMultiplicityForCentrEvt->DrawCopy("E");
2547
2548   canCheckCascade->cd(3);
2549   fHistMassXiMinus ->SetMarkerStyle(kFullCircle);
2550   fHistMassXiMinus ->SetMarkerSize(0.5);
2551   fHistMassXiMinus ->GetXaxis()->SetLabelFont(42);
2552   fHistMassXiMinus ->GetYaxis()->SetLabelFont(42);
2553   fHistMassXiMinus ->SetTitleFont(42, "xy");
2554   fHistMassXiMinus ->GetXaxis()->SetTitleOffset(1.1);
2555   fHistMassXiMinus ->GetYaxis()->SetTitleOffset(1.3);
2556    // fHistMassXiMinus->Rebin(2);
2557   fHistMassXiMinus ->GetXaxis()->SetRangeUser(1.24, 1.42);
2558   fHistMassXiMinus ->DrawCopy("E");
2559
2560   fHistMassXiPlus ->SetMarkerStyle(kOpenCircle);
2561   fHistMassXiPlus ->SetMarkerColor(kRed+2);
2562   fHistMassXiPlus ->SetLineColor(kRed+2);
2563   fHistMassXiPlus ->SetMarkerSize(0.5);
2564   // fHistMassXiPlus ->Rebin(2);
2565   fHistMassXiPlus ->DrawCopy("ESAME");
2566
2567
2568   TLegend *legendXi =new TLegend(0.67,0.34,0.97,0.54);
2569                 legendXi->SetTextFont(42);
2570                 legendXi->SetTextSize(0.05);
2571                 legendXi->SetFillColor(kWhite);
2572                 legendXi->AddEntry( fHistMassXiMinus,"#Xi^{-} candidates","lp");
2573                 legendXi->AddEntry( fHistMassXiPlus,"#Xi^{+} candidates","lp");
2574                 legendXi->Draw();
2575
2576
2577   canCheckCascade->cd(4);
2578   fHistMassOmegaPlus ->SetMarkerStyle(kOpenCircle);
2579   fHistMassOmegaPlus ->SetMarkerColor(kRed+2);
2580   fHistMassOmegaPlus ->SetLineColor(kRed+2);
2581   fHistMassOmegaPlus ->SetMarkerSize(0.5);
2582   fHistMassOmegaPlus ->GetXaxis()->SetLabelFont(42);
2583   fHistMassOmegaPlus ->GetYaxis()->SetLabelFont(42);
2584   fHistMassOmegaPlus ->SetTitleFont(42, "xy");
2585   fHistMassOmegaPlus ->GetXaxis()->SetTitleOffset(1.1);
2586   fHistMassOmegaPlus ->GetYaxis()->SetTitleOffset(1.25);
2587   // fHistMassOmegaPlus ->Rebin(2);
2588   fHistMassOmegaPlus ->GetXaxis()->SetRangeUser(1.6, 1.84);
2589   fHistMassOmegaPlus ->DrawCopy("E");
2590
2591   fHistMassOmegaMinus->SetMarkerStyle(kFullCircle);
2592   fHistMassOmegaMinus->SetMarkerSize(0.5);
2593   // fHistMassOmegaMinus->Rebin(2);
2594   fHistMassOmegaMinus->DrawCopy("ESAME");
2595
2596
2597    TLegend *legendOmega = new TLegend(0.67,0.34,0.97,0.54);
2598                 legendOmega->SetTextFont(42);
2599                 legendOmega->SetTextSize(0.05);
2600                 legendOmega->SetFillColor(kWhite);
2601                 legendOmega->AddEntry( fHistMassOmegaMinus,"#Omega^{-} candidates","lp");
2602                 legendOmega->AddEntry( fHistMassOmegaPlus,"#Omega^{+} candidates","lp");
2603                 legendOmega->Draw();
2604
2605 }