PWG2/SPECTRA/AliAnalysisTaskCheckCascade.cxx

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