PWGHF/vertexingHF/AliRDHFCutsLctoV0.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 /////////////////////////////////////////////////////////////
  19 //
  20 // Class for cuts on AOD reconstructed Lc->V0+X
  21 //
  22 // Modified by A.De Caro - decaro@sa.infn.it
  23 //
  24 /////////////////////////////////////////////////////////////
  25
  26 #include <TDatabasePDG.h>
  27 #include <Riostream.h>
  28
  29 #include "AliRDHFCutsLctoV0.h"
  30 #include "AliAODRecoCascadeHF.h"
  31 #include "AliAODTrack.h"
  32 #include "AliESDtrack.h"
  33 #include "AliESDVertex.h"
  34 #include "AliAODVertex.h"
  35 #include "AliAODv0.h"
  36 #include "AliESDv0.h"
  37
  38 using std::cout;
  39 using std::endl;
  40
  41 ClassImp(AliRDHFCutsLctoV0)
  42
  43 //--------------------------------------------------------------------------
  44   AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const char* name, Short_t /*v0channel*/) :
  45   AliRDHFCuts(name),
  46   fPidSelectionFlag(0),
  47   fPidHFV0pos(0),
  48   fPidHFV0neg(0),
  49   fV0daughtersCuts(0),
  50   fV0Type(0)
  51 {
  52   //
  53   // Default Constructor
  54   //
  55
  56   const Int_t nvars=10;
  57   SetNVars(nvars);
  58   TString varNames[nvars]={"inv. mass if K0S [GeV/c2]",
  59                        "inv. mass if Lambda [GeV/c2]",
  60                        "inv. mass V0 if K0S [GeV/c2]",
  61                        "inv. mass V0 if Lambda [GeV/c2]",
  62                        "pT min bachelor track [GeV/c]",
  63                        "pT min V0-positive track [GeV/c]",
  64                        "pT min V0-negative track [GeV/c]",
  65                        "dca cascade cut [cm]",
  66                        "dca V0 cut [cm]",
  67                "V0 type"
  68                         };
  69
  70   Bool_t isUpperCut[nvars]={kTRUE,
  71                         kTRUE,
  72                         kTRUE,
  73                         kTRUE,
  74                         kFALSE,
  75                         kFALSE,
  76                         kFALSE,
  77                         kTRUE,
  78                         kTRUE,
  79             kTRUE
  80                         };
  81   SetVarNames(nvars,varNames,isUpperCut);
  82   Bool_t forOpt[nvars]={kFALSE,
  83                     kFALSE,
  84                     kTRUE,
  85                     kTRUE,
  86                     kTRUE,
  87                     kTRUE,
  88                     kTRUE,
  89                     kTRUE,
  90                     kTRUE,
  91             kTRUE
  92                     };
  93   SetVarsForOpt(nvars,forOpt); // It was 5: why only 5? And which ones?
  94
  95   Float_t limits[2]={0,999999999.};
  96   SetPtBins(2,limits);
  97
  98   /*
  99   switch (v0channel) {
 100   case 0:
 101     fV0channel = 0x0001;
 102     break;
 103   case 1:
 104     fV0channel = 0x0002;
 105     break;
 106   case 2:
 107     fV0channel = 0x0004;
 108     break;
 109   }
 110   */
 111
 112 }
 113 //--------------------------------------------------------------------------
 114 AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const AliRDHFCutsLctoV0 &source) :
 115   AliRDHFCuts(source),
 116   fPidSelectionFlag(0),
 117   fPidHFV0pos(0),
 118   fPidHFV0neg(0),
 119   fV0daughtersCuts(0),
 120   fV0Type(0)
 121     /*
 122                        fV0channel(source.fV0channel)*/
 123 {
 124   //
 125   // Copy constructor
 126   //
 127
 128   if (source.fPidHFV0pos) fPidHFV0pos = new AliAODPidHF(*(source.fPidHFV0pos));
 129   else fPidHFV0pos = new AliAODPidHF();
 130   if (source.fPidHFV0neg) fPidHFV0neg = new AliAODPidHF(*(source.fPidHFV0neg));
 131   else fPidHFV0neg = new AliAODPidHF();
 132
 133   if (source.fV0daughtersCuts) fV0daughtersCuts = new AliESDtrackCuts(*(source.fV0daughtersCuts));
 134   else fV0daughtersCuts = new AliESDtrackCuts();
 135
 136 }
 137 //--------------------------------------------------------------------------
 138 AliRDHFCutsLctoV0 &AliRDHFCutsLctoV0::operator=(const AliRDHFCutsLctoV0 &source)
 139 {
 140   //
 141   // assignment operator
 142   //
 143
 144   if (this != &source) {
 145
 146     AliRDHFCuts::operator=(source);
 147     fPidSelectionFlag = source.fPidSelectionFlag;
 148     delete fPidHFV0pos;
 149     fPidHFV0pos = new AliAODPidHF(*(source.fPidHFV0pos));
 150     delete fPidHFV0neg;
 151     fPidHFV0neg = new AliAODPidHF(*(source.fPidHFV0neg));
 152
 153     delete fV0daughtersCuts;
 154     fV0daughtersCuts = new AliESDtrackCuts(*(source.fV0daughtersCuts));
 155
 156     fV0Type  = source.fV0Type;
 157
 158   }
 159
 160   return *this;
 161 }
 162
 163
 164 //---------------------------------------------------------------------------
 165 AliRDHFCutsLctoV0::~AliRDHFCutsLctoV0() {
 166  //
 167  //  // Default Destructor
 168  //
 169
 170  if (fPidHFV0pos) {
 171   delete fPidHFV0pos;
 172   fPidHFV0pos=0;
 173  }
 174  if (fPidHFV0neg) {
 175   delete fPidHFV0neg;
 176   fPidHFV0neg=0;
 177  }
 178
 179  if (fV0daughtersCuts) {
 180   delete fV0daughtersCuts;
 181   fV0daughtersCuts=0;
 182  }
 183
 184 }
 185
 186 //---------------------------------------------------------------------------
 187 void AliRDHFCutsLctoV0::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
 188   //
 189   // Fills in vars the values of the variables
 190   //
 191
 192   if (pdgdaughters[0]==-9999) return; // dummy
 193
 194   if (nvars!=fnVarsForOpt) {
 195     printf("AliRDHFCutsLctoV0::GetCutsVarsForOpt: wrong number of variables\n");
 196     return;
 197   }
 198
 199   AliAODRecoCascadeHF *dd = (AliAODRecoCascadeHF*)d;
 200
 201   // Get the v0 and all daughter tracks
 202   AliAODTrack *bachelorTrack = (AliAODTrack*)dd->GetBachelor();
 203   AliAODv0 *v0 = (AliAODv0*)dd->Getv0();
 204   AliAODTrack *v0positiveTrack = (AliAODTrack*)dd->Getv0PositiveTrack();
 205   AliAODTrack *v0negativeTrack = (AliAODTrack*)dd->Getv0NegativeTrack();
 206
 207   Int_t iter=-1;
 208   // cut on cascade mass, if K0S + p
 209   if (fVarsForOpt[0]) {
 210     iter++;
 211     vars[iter]=dd->InvMassLctoK0sP();
 212   }
 213   // cut on cascade mass, if Lambda + pi
 214   if (fVarsForOpt[1]) {
 215     iter++;
 216     vars[iter]=dd->InvMassLctoLambdaPi();
 217   }
 218
 219   // cut on V0 mass if K0S
 220   if (fVarsForOpt[2]) {
 221     iter++;
 222     vars[iter]=v0->MassK0Short();
 223   }
 224
 225   // cut on V0 mass if Lambda
 226   // ----------------------------- pb with anti-lambda?? --------->>>>>>>>
 227   if (fVarsForOpt[3]) {
 228
 229     if (bachelorTrack->Charge()==1) {
 230       iter++;
 231       vars[iter]=v0->MassLambda();
 232     } else if (bachelorTrack->Charge()==-1) {
 233       iter++;
 234       vars[iter]=v0->MassAntiLambda();
 235     }
 236
 237   }
 238
 239   // cut bachelor min pt
 240   if (fVarsForOpt[4]) {
 241     iter++;
 242     vars[iter]=bachelorTrack->Pt();
 243   }
 244
 245   // cut on V0-positive min pt
 246   if (fVarsForOpt[5]) {
 247     iter++;
 248     vars[iter]=v0positiveTrack->Pt();
 249   }
 250
 251   // cut on V0-negative min pt
 252   if (fVarsForOpt[6]) {
 253     iter++;
 254     vars[iter]=v0negativeTrack->Pt();
 255   }
 256
 257   // cut on cascade dca
 258   if (fVarsForOpt[7]) {
 259     iter++;
 260     vars[iter]=dd->GetDCA(); // prong-to-prong DCA
 261   }
 262
 263   // cut on V0 dca
 264   if (fVarsForOpt[8]) {
 265     iter++;
 266     vars[iter]=v0->GetDCA(); // prong-to-prong DCA
 267   }
 268
 269   return;
 270 }
 271 //---------------------------------------------------------------------------
 272 Int_t AliRDHFCutsLctoV0::IsSelected(TObject* obj,Int_t selectionLevel) {
 273   //
 274   // Apply selection
 275   //
 276
 277   if (!fCutsRD) {
 278     cout<<"Cut matrice not inizialized. Exit..."<<endl;
 279     return 0;
 280   }
 281
 282   //PrintAll();
 283
 284   AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
 285   if (!d) {
 286     AliDebug(2,"AliAODRecoCascadeHF null");
 287     return 0;
 288   }
 289
 290   // Get the bachelor track
 291   AliAODTrack *bachelorTrack = (AliAODTrack*)d->GetBachelor();
 292   if (!bachelorTrack) {
 293     AliDebug(2,"No bachelor object");
 294     return 0;
 295   }
 296
 297   // not used
 298   //if ( fUseTrackSelectionWithFilterBits &&
 299   //!(bachelorTrack->TestFilterMask(BIT(4))) ) return 0;
 300
 301   // Get V0
 302   AliAODv0 *v0 = (AliAODv0*)d->Getv0();
 303   if (!v0) {
 304     AliDebug(2,"No v0 object");
 305     return 0;
 306   }
 307
 308
 309
 310   // Get the V0 daughter tracks
 311   AliAODTrack *v0positiveTrack = (AliAODTrack*)d->Getv0PositiveTrack();
 312   AliAODTrack *v0negativeTrack = (AliAODTrack*)d->Getv0NegativeTrack();
 313   if (!v0positiveTrack || !v0negativeTrack ) {
 314     AliDebug(2,"No V0 daughters' objects");
 315     return 0;
 316   }
 317
 318   // selection on daughter tracks
 319   if (selectionLevel==AliRDHFCuts::kAll ||
 320       selectionLevel==AliRDHFCuts::kTracks) {
 321
 322     if (fIsCandTrackSPDFirst && d->Pt()<fMaxPtCandTrackSPDFirst) {
 323       if (!bachelorTrack->HasPointOnITSLayer(0)) return 0;
 324     }
 325     if (fTrackCuts && fV0daughtersCuts) {
 326       AliAODVertex *vAOD = (AliAODVertex*)d->GetPrimaryVtx();
 327       Double_t pos[3]; vAOD->GetXYZ(pos);
 328       Double_t cov[6]; vAOD->GetCovarianceMatrix(cov);
 329       const AliESDVertex vESD(pos,cov,100.,100);
 330       if ( !(IsDaughterSelected(bachelorTrack,&vESD,fTrackCuts)) ||
 331            !(IsDaughterSelected(v0negativeTrack,&vESD,fV0daughtersCuts)) ||
 332            !(IsDaughterSelected(v0positiveTrack,&vESD,fV0daughtersCuts)) ) return 0;
 333     }
 334     //if (!AreDaughtersSelected(d)) return 0;
 335   }
 336
 337   Bool_t okLck0sp=kTRUE, okLcLpi=kTRUE, okLcLBarpi=kTRUE;
 338   Bool_t okK0spipi=kTRUE, okLppi=kTRUE, okLBarpip=kTRUE;
 339
 340   // selection on candidate
 341   if (selectionLevel==AliRDHFCuts::kAll ||
 342       selectionLevel==AliRDHFCuts::kCandidate) {
 343
 344     Double_t pt = d->Pt();
 345     Int_t ptbin = PtBin(pt);
 346
 347     Double_t mLcPDG  = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
 348     Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
 349     Double_t mLPDG   = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
 350
 351     // K0S + p
 352     Double_t mk0s    = v0->MassK0Short();
 353     Double_t mLck0sp = d->InvMassLctoK0sP();
 354
 355     // Lambda + pi
 356     Double_t mlambda  = v0->MassLambda();
 357     Double_t malambda = v0->MassAntiLambda();
 358     Double_t mLcLpi   = d->InvMassLctoLambdaPi();
 359
 360     // cut on Lc mass with K0S+p hypothesis
 361     if (TMath::Abs(mLck0sp-mLcPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) {
 362       okLck0sp = kFALSE;
 363       AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to Lambda_c into K0S+p cut",mLck0sp));
 364     }
 365
 366     // cuts on the V0 mass: K0S case
 367     if (TMath::Abs(mk0s-mk0sPDG)>fCutsRD[GetGlobalIndex(2,ptbin)]) {
 368       okK0spipi = kFALSE;
 369       AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to K0S cut",mk0s));
 370     }
 371
 372     // cut on Lc mass with Lambda+pi hypothesis
 373     if (TMath::Abs(mLcLpi-mLcPDG)>fCutsRD[GetGlobalIndex(1,ptbin)]) {
 374       okLcLpi = kFALSE;
 375       okLcLBarpi = kFALSE;
 376       AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to Lambda_c into Lambda+pi cut",mLcLpi));
 377     }
 378
 379     // cuts on the V0 mass: Lambda/LambdaBar case
 380     if ( TMath::Abs(mlambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] ) {
 381       okLppi = kFALSE;
 382       AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to LambdaBar cut",mlambda));
 383     }
 384
 385     if ( TMath::Abs(malambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] ) {
 386       okLBarpip = kFALSE;
 387       AliDebug(4,Form(" V0 mass is %2.2e and does not correspond to LambdaBar cut",malambda));
 388     }
 389
 390     okLck0sp   = okLck0sp   && okK0spipi;
 391     okLcLpi    = okLcLpi    && okLppi;
 392     okLcLBarpi = okLcLBarpi && okLBarpip;
 393
 394     if (!okLck0sp && !okLcLpi && !okLcLBarpi) return 0;
 395
 396     // cuts on the minimum pt of the tracks
 397     if (TMath::Abs(bachelorTrack->Pt()) < fCutsRD[GetGlobalIndex(4,ptbin)]) {
 398       AliDebug(4,Form(" bachelor track Pt=%2.2e > %2.2e",bachelorTrack->Pt(),fCutsRD[GetGlobalIndex(4,ptbin)]));
 399       return 0;
 400     }
 401     if (TMath::Abs(v0positiveTrack->Pt()) < fCutsRD[GetGlobalIndex(5,ptbin)]) {
 402       AliDebug(4,Form(" V0-positive track Pt=%2.2e > %2.2e",v0positiveTrack->Pt(),fCutsRD[GetGlobalIndex(5,ptbin)]));
 403       return 0;
 404     }
 405     if (TMath::Abs(v0negativeTrack->Pt()) < fCutsRD[GetGlobalIndex(6,ptbin)]) {
 406       AliDebug(4,Form(" V0-negative track Pt=%2.2e > %2.2e",v0negativeTrack->Pt(),fCutsRD[GetGlobalIndex(6,ptbin)]));
 407       return 0;
 408     }
 409
 410     // cut on cascade dca
 411     //if (TMath::Abs(d->GetDCA()) > fCutsRD[GetGlobalIndex(7,ptbin)]) {
 412     if ( TMath::Abs(d->GetDCA()) > fCutsRD[GetGlobalIndex(7,ptbin)] /*|| // prong-to-prong DCA
 413          TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(7,ptbin)] || // rphi impact params w.r.t. Primary Vtx
 414          TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(7,ptbin)]*/ ) { // rphi impact params w.r.t. Primary Vtx
 415       AliDebug(4,Form(" cascade tracks DCA don't pass the cut"));
 416       return 0;
 417     }
 418
 419     // cut on V0 dca
 420     //if (TMath::Abs(v0->DcaV0Daughters()) > fCutsRD[GetGlobalIndex(8,ptbin)]) { // prong-to-prong DCA
 421     if ( TMath::Abs(v0->GetDCA()) > fCutsRD[GetGlobalIndex(8,ptbin)] /*|| // prong-to-prong DCA
 422          TMath::Abs(v0->DcaV0ToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)] || // V0-to-vertex DCA
 423          TMath::Abs(v0->DcaPosToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)] || // prong-to-vertex DCA
 424          TMath::Abs(v0->DcaNegToPrimVertex()) > fCutsRD[GetGlobalIndex(8,ptbin)]*/ ) { // prong-to-vertex DCA
 425       AliDebug(4,Form(" V0 DCA don't pass the cut"));
 426       return 0;
 427     }
 428
 429   }
 430
 431   Int_t returnvalue = okLck0sp+2*okLcLBarpi+4*okLcLpi;
 432   /*
 433     retvalue case
 434           1  Lc->K0S + p
 435           2  Lc->LambdaBar + pi
 436           3  Lc->K0S + p AND Lc->LambdaBar + pi
 437           4  Lc->Lambda + pi
 438           5  Lc->K0S + p AND Lc->Lambda + pi
 439           6  Lc->LambdaBar + pi AND Lc->Lambda + pi
 440           7  Lc->K0S + p AND Lc->LambdaBar + pi AND Lc->Lambda + pi
 441   */
 442
 443   Int_t returnvaluePID = 7;
 444
 445   // selection on candidate
 446   if (selectionLevel==AliRDHFCuts::kAll ||
 447       //selectionLevel==AliRDHFCuts::kCandidate ||
 448       selectionLevel==AliRDHFCuts::kPID )
 449     returnvaluePID = IsSelectedPID(d);
 450
 451   //if (fUsePID && returnvaluePID==0) return 0;
 452
 453   Int_t returnvalueTot = 0;
 454   if ( fUsePID )
 455     returnvalueTot = CombinePIDCuts(returnvalue,returnvaluePID);
 456   else
 457     returnvalueTot = returnvalue;
 458
 459   return returnvalueTot;
 460
 461 }
 462 //---------------------------------------------------------------------------
 463 Int_t AliRDHFCutsLctoV0::IsSelectedPID(AliAODRecoDecayHF* obj) {
 464
 465   // fPidHF -> PID object for bachelor
 466   // fPidHFV0pos -> PID object for positive V0 daughter
 467   // fPidHFV0neg -> PID object for negative V0 daughter
 468
 469   if (!fUsePID || !obj) return 7; // all hypothesis are valid
 470
 471   AliAODRecoCascadeHF *objD = (AliAODRecoCascadeHF*)obj;
 472
 473   Bool_t isPeriodd = fPidHF->GetOnePad();
 474   Bool_t isMC = fPidHF->GetMC();
 475
 476   if (isPeriodd) {
 477     fPidHFV0pos->SetOnePad(kTRUE);
 478     fPidHFV0neg->SetOnePad(kTRUE);
 479   }
 480   if (isMC) {
 481     fPidHFV0neg->SetMC(kTRUE);
 482     fPidHFV0pos->SetMC(kTRUE);
 483   }
 484
 485   AliAODTrack *bachelor = (AliAODTrack*)objD->GetBachelor();
 486   AliAODTrack *v0Pos = (AliAODTrack*)objD->Getv0PositiveTrack();
 487   AliAODTrack *v0Neg = (AliAODTrack*)objD->Getv0NegativeTrack();
 488
 489   if (!bachelor || !v0Pos || !v0Neg) return 0;
 490
 491   Bool_t okLcK0Sp = kTRUE; // K0S case
 492   Bool_t okLcLambdaBarPi = kTRUE; // LambdaBar case
 493   Bool_t okLcLambdaPi = kTRUE; // Lambda case
 494
 495   CheckPID(bachelor,v0Neg,v0Pos,okLcK0Sp,okLcLambdaBarPi,okLcLambdaPi);
 496
 497   Int_t returnvalue = okLcK0Sp+2*okLcLambdaBarPi+4*okLcLambdaPi;
 498
 499   return returnvalue;
 500 }
 501 //-----------------------
 502 void AliRDHFCutsLctoV0::CheckPID(AliAODTrack *bachelor, AliAODTrack *v0Neg, AliAODTrack *v0Pos,
 503                                  Bool_t &isBachelorID1, Bool_t &isV0NegID2, Bool_t &isV0PosID4) {
 504   // identification strategy
 505
 506   Int_t trackIDtof = -1;
 507   Int_t trackIDtpc = -1;
 508
 509   switch (fPidSelectionFlag) {
 510
 511   case 0:
 512
 513     // identify bachelor
 514     trackIDtof = fPidHF->ApplyPidTOFRaw(bachelor,4);
 515     trackIDtpc = fPidHF->ApplyPidTPCRaw(bachelor,4);
 516     AliDebug(1,Form(" fPidHF->ApplyPidTOFRaw(bachelor,4)=%d fPidHF->ApplyPidTPCRaw(bachelor,4)=%d",trackIDtof,trackIDtpc));
 517     isBachelorID1 = (trackIDtof==4) && (trackIDtpc==4); // K0S case
 518     //Bool_t isBachelorID2 = (fPidHF->ApplyPidTPCRaw(bachelor,2)==2) && (fPidHF->ApplyPidTOFRaw(bachelor,2)==2); // LambdaBar case
 519     //Bool_t isBachelorID4 = isBachelorID2; // Lambda case
 520
 521     // identify V0neg
 522     //Bool_t isV0NegID1 = (fPidHFV0neg->ApplyPidTPCRaw(v0Neg,2)==2) && (fPidHFV0neg->ApplyPidTOFRaw(v0Neg,2)==2); // K0S case
 523     trackIDtof = fPidHFV0neg->ApplyPidTOFRaw(v0Neg,4);
 524     trackIDtpc = fPidHFV0neg->ApplyPidTPCRaw(v0Neg,4);
 525     AliDebug(1,Form(" fPidHFV0neg->ApplyPidTOFRaw(v0Neg,4)=%d fPidHFV0neg->ApplyPidTPCRaw(v0Neg,4)=%d",trackIDtof,trackIDtpc));
 526     isV0NegID2 = (trackIDtof==4) && (trackIDtpc==4); // LambdaBar case
 527     //Bool_t isV0NegID4 = isV0NegID1; // Lambda case
 528
 529     // identify V0pos
 530     //Bool_t isV0PosID1 = (fPidHFV0pos->ApplyPidTPCRaw(v0Pos,2)==2) && (fPidHFV0pos->ApplyPidTOFRaw(v0Pos,2)==2); // K0S case
 531     //Bool_t isV0PosID2 = isV0PosID1; // LambdaBar case
 532     trackIDtof = fPidHFV0pos->ApplyPidTOFRaw(v0Pos,4);
 533     trackIDtpc = fPidHFV0pos->ApplyPidTPCRaw(v0Pos,4);
 534     AliDebug(1,Form(" fPidHFV0pos->ApplyPidTOFRaw(v0Pos,4)=%d fPidHFV0pos->ApplyPidTPCRaw(v0POS,4)=%d",trackIDtof,trackIDtpc));
 535     isV0PosID4 = (trackIDtof==4) && (trackIDtpc==4); // Lambda case
 536
 537     break;
 538   case 1:
 539
 540     // identify bachelor
 541     trackIDtof = fPidHF->ApplyPidTOFRaw(bachelor,4);
 542     trackIDtpc = fPidHF->ApplyPidTPCRaw(bachelor,4);
 543     AliDebug(1,Form(" fPidHF->ApplyPidTOFRaw(bachelor,4)=%d fPidHFV0->ApplyPidTPCRaw(bachelor,4)=%d",trackIDtof,trackIDtpc));
 544     isBachelorID1 = ( trackIDtof==4 );
 545     Bool_t dummy1 = ( !(fPidHF->CheckTOFPIDStatus(bachelor)) && (trackIDtpc==4) &&
 546                       fPidHF->IsExcluded(bachelor,2,2.,"TPC") && fPidHF->IsExcluded(bachelor,3,2.,"TPC") ); // K0S case
 547     isBachelorID1 = isBachelorID1 || dummy1;
 548
 549
 550     // identify V0neg
 551     trackIDtof = fPidHFV0neg->ApplyPidTOFRaw(v0Neg,4);
 552     trackIDtpc = fPidHFV0neg->ApplyPidTPCRaw(v0Neg,4);
 553     AliDebug(1,Form(" fPidHFV0neg->ApplyPidTOFRaw(v0Neg,4)=%d fPidHFV0neg->ApplyPidTPCRaw(v0Neg,4)=%d",trackIDtof,trackIDtpc));
 554     isV0NegID2    = ( trackIDtof==4 );
 555     Bool_t dummy2 = ( !(fPidHFV0neg->CheckTOFPIDStatus(v0Neg)) && (trackIDtpc==4) &&
 556                       fPidHFV0neg->IsExcluded(v0Neg,2,2.,"TPC") && fPidHFV0neg->IsExcluded(v0Neg,3,2.,"TPC") ); // LambdaBar case
 557     isV0NegID2 = isV0NegID2 || dummy2;
 558
 559
 560     // identify V0pos
 561     trackIDtof = fPidHFV0pos->ApplyPidTOFRaw(v0Pos,4);
 562     trackIDtpc = fPidHFV0pos->ApplyPidTPCRaw(v0Pos,4);
 563     AliDebug(1,Form(" fPidHFV0pos->ApplyPidTOFRaw(v0Pos,4)=%d fPidHFV0pos->ApplyPidTPCRaw(v0Pos,4)=%d",trackIDtof,trackIDtpc));
 564     isV0PosID4    = ( trackIDtof==4 );
 565     Bool_t dummy4 = ( !(fPidHFV0pos->CheckTOFPIDStatus(v0Pos)) && (trackIDtpc==4) &&
 566                       fPidHFV0pos->IsExcluded(v0Pos,2,2.,"TPC") && fPidHFV0pos->IsExcluded(v0Pos,3,2.,"TPC") ); // Lambda case
 567     isV0PosID4 = isV0PosID4 || dummy4;
 568
 569
 570     break;
 571
 572   }
 573
 574 }
 575 //----------------
 576 Int_t AliRDHFCutsLctoV0::CombinePIDCuts(Int_t returnvalue, Int_t returnvaluePID) const {
 577   // combine PID with topological cuts
 578
 579  Int_t returnvalueTot=returnvalue&returnvaluePID;
 580
 581  return returnvalueTot;
 582 }
 583
 584 //----------------------------------
 585 Int_t AliRDHFCutsLctoV0::IsSelectedSingleCut(TObject* obj, Int_t selectionLevel, Int_t cutIndex) {
 586   //
 587   // Apply selection on single cut
 588   //
 589
 590   if (!fCutsRD) {
 591     cout<<"Cut matrice not inizialized. Exit..."<<endl;
 592     return 0;
 593   }
 594
 595   AliAODRecoCascadeHF* d = (AliAODRecoCascadeHF*)obj;
 596   if (!d) {
 597     AliDebug(2,"AliAODRecoCascadeHF null");
 598     return 0;
 599   }
 600
 601   // Get the v0 and all daughter tracks
 602   AliAODTrack *bachelorTrack = (AliAODTrack*)d->GetBachelor();
 603   if (!bachelorTrack) {
 604     AliDebug(2,"No bachelor object");
 605     return 0;
 606   }
 607
 608   // not used
 609   //if ( fUseTrackSelectionWithFilterBits &&
 610   //!(bachelorTrack->TestFilterMask(BIT(4))) ) return 0;
 611
 612   AliAODv0 *v0 = (AliAODv0*)d->Getv0();
 613   if (!v0) {
 614     AliDebug(2,"No v0 object");
 615     return 0;
 616   }
 617
 618   // Get the V0 daughter tracks
 619   AliAODTrack *v0positiveTrack = (AliAODTrack*)d->Getv0PositiveTrack();
 620   AliAODTrack *v0negativeTrack = (AliAODTrack*)d->Getv0NegativeTrack();
 621   if (!v0positiveTrack || !v0negativeTrack ) {
 622     AliDebug(2,"No V0 daughters' objects");
 623     return 0;
 624   }
 625
 626   // selection on daughter tracks
 627   if (selectionLevel==AliRDHFCuts::kAll ||
 628       selectionLevel==AliRDHFCuts::kTracks) {
 629
 630     if (fIsCandTrackSPDFirst && d->Pt()<fMaxPtCandTrackSPDFirst) {
 631       if (!bachelorTrack->HasPointOnITSLayer(0)) return 0;
 632     }
 633     if (fTrackCuts && fV0daughtersCuts) {
 634       AliAODVertex *vAOD = (AliAODVertex*)d->GetPrimaryVtx();
 635       Double_t pos[3]; vAOD->GetXYZ(pos);
 636       Double_t cov[6]; vAOD->GetCovarianceMatrix(cov);
 637       const AliESDVertex vESD(pos,cov,100.,100);
 638       if ( !(IsDaughterSelected(bachelorTrack,&vESD,fTrackCuts)) ||
 639            !(IsDaughterSelected(v0negativeTrack,&vESD,fV0daughtersCuts)) ||
 640            !(IsDaughterSelected(v0positiveTrack,&vESD,fV0daughtersCuts)) ) return 0;
 641     }
 642     //if (!AreDaughtersSelected(d)) return 0;
 643   }
 644
 645   Bool_t okLck0sp=kFALSE, okLcLpi=kFALSE, okLcLBarpi=kFALSE;
 646
 647   // selection on candidate
 648   if (selectionLevel==AliRDHFCuts::kAll ||
 649       selectionLevel==AliRDHFCuts::kCandidate) {
 650
 651     Double_t pt = d->Pt();
 652     Int_t ptbin = PtBin(pt);
 653
 654     Double_t mLcPDG  = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
 655     Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
 656     Double_t mLPDG   = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
 657
 658     // K0S + p
 659     Double_t mk0s    = v0->MassK0Short();
 660     Double_t mLck0sp = d->InvMassLctoK0sP();
 661
 662     // Lambda + pi
 663     Double_t mlambda  = v0->MassLambda();
 664     Double_t malambda = v0->MassAntiLambda();
 665     Double_t mLcLpi   = d->InvMassLctoLambdaPi();
 666
 667     switch (cutIndex) {
 668     case 0:
 669       // cut on Lc mass with K0S+p hypothesis
 670       okLck0sp   = TMath::Abs(mLck0sp-mLcPDG)<=fCutsRD[GetGlobalIndex(0,ptbin)];
 671       okLcLpi    = kFALSE;
 672       okLcLBarpi = kFALSE;
 673       break;
 674     case 1:
 675       // cut on Lc mass with Lambda+pi hypothesis
 676       okLck0sp   = kFALSE;
 677       okLcLpi    = TMath::Abs(mLcLpi-mLcPDG)<=fCutsRD[GetGlobalIndex(1,ptbin)];
 678       okLcLBarpi = okLcLpi;
 679       break;
 680     case 2:
 681       // cuts on the V0 mass: K0S case
 682       okLck0sp   = TMath::Abs(mk0s-mk0sPDG)<=fCutsRD[GetGlobalIndex(2,ptbin)];
 683       okLcLpi    = kFALSE;
 684       okLcLBarpi = kFALSE;
 685       break;
 686     case 3:
 687       // cuts on the V0 mass: Lambda/LambdaBar case
 688       okLck0sp   = kFALSE;
 689       okLcLpi    = TMath::Abs(mlambda-mLPDG)<=fCutsRD[GetGlobalIndex(3,ptbin)];
 690       okLcLBarpi = TMath::Abs(malambda-mLPDG)<=fCutsRD[GetGlobalIndex(3,ptbin)];
 691       break;
 692     case 4:
 693       // cuts on the minimum pt of bachelor
 694       okLck0sp   = TMath::Abs(bachelorTrack->Pt())>=fCutsRD[GetGlobalIndex(4,ptbin)];
 695       okLcLpi    = okLck0sp;
 696       okLcLBarpi = okLck0sp;
 697       break;
 698     case 5:
 699       // cuts on the minimum pt of positive V0daughter
 700       okLck0sp   = TMath::Abs(v0positiveTrack->Pt())>=fCutsRD[GetGlobalIndex(5,ptbin)];
 701       okLcLpi    = okLck0sp;
 702       okLcLBarpi = okLck0sp;
 703       break;
 704     case 6:
 705       // cuts on the minimum pt of negative V0daughter
 706       okLck0sp   = TMath::Abs(v0negativeTrack->Pt())>=fCutsRD[GetGlobalIndex(6,ptbin)];
 707       okLcLpi    = okLck0sp;
 708       okLcLBarpi = okLck0sp;
 709       break;
 710     case 7:
 711       // cut on cascade dca
 712       //okLck0sp = TMath::Abs(d->GetDCA(0))<=fCutsRD[GetGlobalIndex(8,ptbin)];
 713       okLck0sp   = TMath::Abs(d->GetDCA())<=fCutsRD[GetGlobalIndex(7,ptbin)] /*&&
 714         TMath::Abs(d->Getd0Prong(0))<=fCutsRD[GetGlobalIndex(7,ptbin)] &&
 715         TMath::Abs(d->Getd0Prong(1))<=fCutsRD[GetGlobalIndex(7,ptbin)]*/;
 716       okLcLpi    = okLck0sp;
 717       okLcLBarpi = okLck0sp;
 718       break;
 719     case 8:
 720       // cut on V0 dca
 721       //okLck0sp   = TMath::Abs(v0->DcaV0Daughters())<=fCutsRD[GetGlobalIndex(7,ptbin)];
 722       okLck0sp   = TMath::Abs(v0->GetDCA())<=fCutsRD[GetGlobalIndex(8,ptbin)] /*&&
 723         TMath::Abs(v0->DcaV0ToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)] &&
 724         TMath::Abs(v0->DcaPosToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)] &&
 725         TMath::Abs(v0->DcaNegToPrimVertex())<=fCutsRD[GetGlobalIndex(8,ptbin)]*/;
 726       okLcLpi    = okLck0sp;
 727       okLcLBarpi = okLck0sp;
 728       break;
 729     }
 730
 731   }
 732
 733   Int_t returnvalue = okLck0sp+2*okLcLBarpi+4*okLcLpi;
 734   /*
 735     retvalue case
 736           1  Lc->K0S + p
 737           2  Lc->LambdaBar + pi
 738           3  Lc->K0S + p AND Lc->LambdaBar + pi
 739           4  Lc->Lambda + pi
 740           5  Lc->K0S + p AND Lc->Lambda + pi
 741           6  Lc->LambdaBar + pi AND Lc->Lambda + pi
 742           7  Lc->K0S + p AND Lc->LambdaBar + pi AND Lc->Lambda + pi
 743   */
 744
 745
 746   /*
 747   Int_t returnvaluePID = 7;
 748
 749   // selection on PID
 750   if (selectionLevel==AliRDHFCuts::kAll ||
 751       //selectionLevel==AliRDHFCuts::kCandidate ||
 752       selectionLevel==AliRDHFCuts::kPID )
 753     returnvaluePID = IsSelectedPID(d);
 754   */
 755
 756   Int_t returnvalueTot = 0;
 757   //if ( fUsePID )
 758   //returnvalueTot = CombinePIDCuts(returnvalue,returnvaluePID);
 759   //else
 760   returnvalueTot = returnvalue;
 761
 762   return returnvalueTot;
 763
 764 }
 765 //----------------------------------
 766 void AliRDHFCutsLctoV0::SetStandardCutsPP2010() {
 767
 768  SetName("LctoV0ProductionCuts");
 769  SetTitle("Production cuts for Lc->V0+bachelor analysis");
 770
 771   AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
 772   esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
 773   //default
 774   esdTrackCuts->SetRequireTPCRefit(kTRUE);
 775   esdTrackCuts->SetRequireITSRefit(kTRUE);
 776   esdTrackCuts->SetMinNClustersITS(0);//(4); // default is 5
 777   esdTrackCuts->SetMinNClustersTPC(70);
 778   //esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
 779   //                                       AliESDtrackCuts::kAny);
 780   // default is kBoth, otherwise kAny
 781   esdTrackCuts->SetMinDCAToVertexXY(0.);
 782   esdTrackCuts->SetPtRange(0.3,1.e10);
 783   //esdTrackCuts->SetEtaRange(-0.8,+0.8);
 784   esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
 785   AddTrackCuts(esdTrackCuts);
 786
 787
 788   AliESDtrackCuts* esdTrackCutsV0daughters=new AliESDtrackCuts();
 789   esdTrackCutsV0daughters->SetRequireSigmaToVertex(kFALSE);
 790   //default
 791   esdTrackCutsV0daughters->SetRequireTPCRefit(kTRUE);
 792   esdTrackCutsV0daughters->SetRequireITSRefit(kFALSE);//(kTRUE);
 793   esdTrackCutsV0daughters->SetMinNClustersITS(0);//(4); // default is 5
 794   esdTrackCutsV0daughters->SetMinNClustersTPC(70);
 795   //esdTrackCutsV0daughters->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
 796   //                                                  AliESDtrackCuts::kAny);
 797   // default is kBoth, otherwise kAny
 798   esdTrackCutsV0daughters->SetMinDCAToVertexXY(0.);
 799   esdTrackCutsV0daughters->SetPtRange(0.,1.e10);
 800   esdTrackCutsV0daughters->SetAcceptKinkDaughters(kFALSE);
 801   AddTrackCutsV0daughters(esdTrackCutsV0daughters);
 802
 803   const Int_t nptbins=1;
 804   Float_t* ptbins;
 805   ptbins=new Float_t[nptbins+1];
 806   ptbins[0]=0.;
 807   ptbins[1]=99999999.;
 808
 809   SetPtBins(nptbins+1,ptbins);
 810   SetPtBins(nptbins+1,ptbins);
 811
 812   const Int_t nvars=9 ;
 813
 814   Float_t** prodcutsval;
 815   prodcutsval=new Float_t*[nvars];
 816   for(Int_t ic=0;ic<nvars;ic++){prodcutsval[ic]=new Float_t[nptbins];}
 817   for(Int_t ipt2=0;ipt2<nptbins;ipt2++){
 818    prodcutsval[0][ipt2]=1.;    // inv. mass if K0S [GeV/c2]
 819    prodcutsval[1][ipt2]=1.;    // inv. mass if Lambda [GeV/c2]
 820    prodcutsval[2][ipt2]=0.05;  // inv. mass V0 if K0S [GeV/c2]
 821    prodcutsval[3][ipt2]=0.05;  // inv. mass V0 if Lambda [GeV/c2]
 822    prodcutsval[4][ipt2]=0.3;   // pT min bachelor track [GeV/c] // AOD by construction
 823    prodcutsval[5][ipt2]=0.;    // pT min V0-positive track [GeV/c]
 824    prodcutsval[6][ipt2]=0.;    // pT min V0-negative track [GeV/c]
 825    prodcutsval[7][ipt2]=1000.; // dca cascade cut [cm]
 826    prodcutsval[8][ipt2]=1000.; // dca V0 cut [nSigma] // it's 1.5 x offline V0s
 827   }
 828   SetCuts(nvars,nptbins,prodcutsval);
 829
 830   SetGlobalIndex(nvars,nptbins);
 831   SetPtBins(nptbins+1,ptbins);
 832
 833
 834   //pid settings
 835   //1. bachelor: default one
 836   AliAODPidHF* pidObjBachelor = new AliAODPidHF();
 837   Double_t sigmasBac[5]={3.,1.,1.,3.,3.}; // 0, 1(A), 2(A) -> TPC; 3 -> TOF; 4 -> ITS
 838   pidObjBachelor->SetSigma(sigmasBac);
 839   pidObjBachelor->SetAsym(kFALSE);
 840   pidObjBachelor->SetMatch(1);
 841   pidObjBachelor->SetTPC(kTRUE);
 842   pidObjBachelor->SetTOF(kTRUE);
 843   pidObjBachelor->SetTOFdecide(kFALSE);
 844   SetPidHF(pidObjBachelor);
 845
 846   //2. V0pos
 847   AliAODPidHF* pidObjV0pos = new AliAODPidHF();
 848   Double_t sigmasV0pos[5]={3.,1.,1.,3.,3.}; // 0, 1(A), 2(A) -> TPC; 3 -> TOF; 4 -> ITS
 849   pidObjV0pos->SetSigma(sigmasV0pos);
 850   pidObjV0pos->SetAsym(kFALSE);
 851   pidObjV0pos->SetMatch(1);
 852   pidObjV0pos->SetTPC(kTRUE);
 853   pidObjV0pos->SetTOF(kTRUE);
 854   pidObjV0pos->SetTOFdecide(kFALSE);
 855   SetPidV0pos(pidObjV0pos);
 856
 857   //2. V0neg
 858   AliAODPidHF* pidObjV0neg = new AliAODPidHF();
 859   Double_t sigmasV0neg[5]={3.,1.,1.,3.,3.}; // 0, 1(A), 2(A) -> TPC; 3 -> TOF; 4 -> ITS
 860   pidObjV0neg->SetSigma(sigmasV0neg);
 861   pidObjV0neg->SetAsym(kFALSE);
 862   pidObjV0neg->SetMatch(1);
 863   pidObjV0neg->SetTPC(kTRUE);
 864   pidObjV0neg->SetTOF(kTRUE);
 865   pidObjV0neg->SetTOFdecide(kFALSE);
 866   SetPidV0neg(pidObjV0neg);
 867
 868   SetUsePID(kFALSE);//(kTRUE);
 869
 870   PrintAll();
 871
 872  for(Int_t iiv=0;iiv<nvars;iiv++){
 873   delete [] prodcutsval[iiv];
 874  }
 875  delete [] prodcutsval;
 876  prodcutsval=NULL;
 877  delete [] ptbins;
 878  ptbins=NULL;
 879
 880
 881  delete pidObjBachelor;
 882  pidObjBachelor=NULL;
 883
 884  delete pidObjV0pos;
 885  pidObjV0pos=NULL;
 886
 887  delete pidObjV0neg;
 888  pidObjV0neg=NULL;
 889
 890  return;
 891 }
 892 //------------------
 893 void AliRDHFCutsLctoV0::SetStandardCutsPbPb2010() {
 894
 895  SetName("LctoV0ProductionCuts");
 896  SetTitle("Production cuts for Lc->V0+bachelor analysis");
 897
 898  SetStandardCutsPP2010();
 899
 900  return;
 901 }
 902 //------------------
 903 void AliRDHFCutsLctoV0::SetStandardCutsPbPb2011() {
 904
 905   // Default 2010 PbPb cut object
 906   SetStandardCutsPbPb2010();
 907
 908   //
 909   // Enable all 2011 PbPb run triggers
 910   //
 911   SetTriggerClass("");
 912   ResetMaskAndEnableMBTrigger();
 913   EnableCentralTrigger();
 914   EnableSemiCentralTrigger();
 915
 916 }
 917 //-----------------------
 918 Int_t AliRDHFCutsLctoV0::GetV0Type(){
 919
 920   const Int_t nvars = this->GetNVars() ;
 921   //Float_t *vArray =GetCuts();
 922   //fV0Type = vArray[nvars-1];
 923   fV0Type = (this->GetCuts())[nvars-1];
 924   //this->GetCuts(vArray);
 925   TString *sVarNames=GetVarNames();
 926
 927   if(sVarNames[nvars-1].Contains("V0 type")) return (Int_t)fV0Type;
 928   else {AliInfo("AliRDHFCutsLctoV0 Last variable is not the Vo type!!!"); return -999;}
 929 }