PWGHF/vertexingHF/AliRDHFCutsXicPlustoXiPiPifromAODtracks.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->p+K0s
  21 //
  22 // Modified by Y.S Watanabe - wyosuke@cns.s.u-tokyo.ac.jp
  23 //
  24 /////////////////////////////////////////////////////////////
  25
  26 #include <Riostream.h>
  27
  28 #include <TDatabasePDG.h>
  29 #include <TMath.h>
  30
  31 #include "AliAnalysisManager.h"
  32 #include "AliInputEventHandler.h"
  33 #include "AliPIDResponse.h"
  34 #include "AliRDHFCutsXicPlustoXiPiPifromAODtracks.h"
  35 #include "AliAODRecoCascadeHF3Prong.h"
  36 #include "AliAODTrack.h"
  37 #include "AliESDtrack.h"
  38 #include "AliESDVertex.h"
  39 #include "AliAODVertex.h"
  40 #include "AliAODv0.h"
  41 #include "AliAODcascade.h"
  42 #include "AliESDv0.h"
  43
  44 using std::cout;
  45 using std::endl;
  46
  47 ClassImp(AliRDHFCutsXicPlustoXiPiPifromAODtracks)
  48
  49 //--------------------------------------------------------------------------
  50 AliRDHFCutsXicPlustoXiPiPifromAODtracks::AliRDHFCutsXicPlustoXiPiPifromAODtracks(const char* name) :
  51   AliRDHFCuts(name),
  52   fPIDStrategy(kNSigmaCuts),
  53   fCombinedPIDThreshold(0.),
  54   fProdTrackPtMin(0.),
  55   fProdTrackEtaRange(9999.),
  56   fProdUseAODFilterBit(kTRUE),
  57   fProdMassTolLambda(0.010),
  58   fProdMassTolXi(0.008),
  59   fProdRfidMinV0(0.6),
  60   fProdRfidMaxV0(100.0),
  61   fProdRfidMinXi(0.6),
  62   fProdRfidMaxXi(100.0),
  63   fProdLikeSignDcaMax(2.0),
  64   fProdRoughMassTol(0.25),
  65   fProdRoughPtMin(0.0),
  66   fnCuts(0),
  67   fnTotalCutBins(1),
  68   fCutsArray(0)
  69 {
  70   //
  71   // Default Constructor
  72   //
  73
  74   const Int_t nvars=13;
  75   SetNVars(nvars);
  76   TString varNames[nvars]={"Xic inv. mass [GeV/c2]",                   //  0
  77                            "Xic Pt [GeV/c]", //1
  78                            "Xi mass Tolrelance [GeV/c2]", //2
  79                            "Lambda mass Tolrelance [GeV/c2]", //3
  80                            "Max DCA pi-pi [cm]", //4
  81                            "Max DCA pi-casc [cm]",//5
  82                            "Max d0 pi [cm]",//6
  83                            "Max d0 Xi [cm]",//7
  84                            "Min d0 Xi-Bach [cm]",//8
  85                            "Min d0 Xi-V0 [cm]",//9
  86                            "Min Xic cosPA ",//10
  87                            "Min DecayLengthXY ",//11
  88                            "Min Bachelor pT"//12
  89   };
  90
  91   Bool_t isUpperCut[nvars]={kTRUE,  //  0
  92                             kFALSE, //1
  93                             kTRUE, //2
  94                             kTRUE, //3
  95                             kTRUE, //4
  96                             kTRUE, //5
  97                             kTRUE, //6
  98                             kTRUE, //7
  99                             kFALSE, //8
 100                             kFALSE, //9
 101                             kFALSE, //10
 102                             kFALSE,//11
 103                             kFALSE //12
 104   };
 105   SetVarNames(nvars,varNames,isUpperCut);
 106   Bool_t forOpt[nvars]={kFALSE, //  0
 107                         kFALSE, //1
 108                         kTRUE, //2
 109                         kTRUE, //3
 110                         kTRUE, //4
 111                         kTRUE, //5
 112                         kTRUE, //6
 113                         kTRUE, //7
 114                         kTRUE, //8
 115                         kTRUE, //9
 116                         kTRUE, //10
 117                         kTRUE, //11
 118                         kTRUE //12
 119   };
 120   SetVarsForOpt(nvars,forOpt);
 121
 122   Float_t limits[2]={0,999999999.};
 123   SetPtBins(2,limits);
 124 }
 125
 126 //--------------------------------------------------------------------------
 127 AliRDHFCutsXicPlustoXiPiPifromAODtracks::AliRDHFCutsXicPlustoXiPiPifromAODtracks(const AliRDHFCutsXicPlustoXiPiPifromAODtracks &source) :
 128   AliRDHFCuts(source),
 129   fPIDStrategy(source.fPIDStrategy),
 130   fCombinedPIDThreshold(source.fCombinedPIDThreshold),
 131   fProdTrackPtMin(source.fProdTrackPtMin),
 132   fProdTrackEtaRange(source.fProdTrackEtaRange),
 133   fProdUseAODFilterBit(source.fProdUseAODFilterBit),
 134   fProdMassTolLambda(source.fProdMassTolLambda),
 135   fProdMassTolXi(source.fProdMassTolXi),
 136   fProdRfidMinV0(source.fProdRfidMinV0),
 137   fProdRfidMaxV0(source.fProdRfidMaxV0),
 138   fProdRfidMinXi(source.fProdRfidMinXi),
 139   fProdRfidMaxXi(source.fProdRfidMaxXi),
 140   fProdLikeSignDcaMax(source.fProdLikeSignDcaMax),
 141   fProdRoughMassTol(source.fProdRoughMassTol),
 142   fProdRoughPtMin(source.fProdRoughPtMin),
 143   fnCuts(source.fnCuts),
 144   fnTotalCutBins(source.fnTotalCutBins),
 145   fCutsArray(0)
 146 {
 147   //
 148   // Copy constructor
 149   //
 150   if(source.fCutsArray) SetCutsArray(source.fnTotalCutBins,source.fCutsArray);
 151 }
 152
 153 //--------------------------------------------------------------------------
 154 AliRDHFCutsXicPlustoXiPiPifromAODtracks &AliRDHFCutsXicPlustoXiPiPifromAODtracks::operator=(const AliRDHFCutsXicPlustoXiPiPifromAODtracks &source)
 155 {
 156   //
 157   // assignment operator
 158   //
 159
 160   if (this != &source) {
 161     AliRDHFCuts::operator=(source);
 162   }
 163
 164   fPIDStrategy = source.fPIDStrategy;
 165   fCombinedPIDThreshold = source.fCombinedPIDThreshold;
 166   fProdUseAODFilterBit = source.fProdUseAODFilterBit;
 167   fProdTrackPtMin = source.fProdTrackPtMin;
 168   fProdTrackEtaRange = source.fProdTrackEtaRange;
 169   fProdMassTolLambda = source.fProdMassTolLambda;
 170   fProdMassTolXi = source.fProdMassTolXi;
 171   fProdRfidMinV0 = source.fProdRfidMinV0;
 172   fProdRfidMaxV0 = source.fProdRfidMaxV0;
 173   fProdRfidMinXi = source.fProdRfidMinXi;
 174   fProdRfidMaxXi = source.fProdRfidMaxXi;
 175   fProdLikeSignDcaMax = source.fProdLikeSignDcaMax;
 176   fProdRoughMassTol = source.fProdRoughMassTol;
 177   fProdRoughPtMin = source.fProdRoughPtMin;
 178   fnCuts = source.fnCuts;
 179   fnTotalCutBins = source.fnCuts;
 180   if(source.fCutsArray) SetCutsArray(source.fnTotalCutBins,source.fCutsArray);
 181
 182   return *this;
 183 }
 184
 185 //---------------------------------------------------------------------------
 186 AliRDHFCutsXicPlustoXiPiPifromAODtracks::~AliRDHFCutsXicPlustoXiPiPifromAODtracks() {
 187   //
 188   //  Default Destructor
 189   //
 190   if(fCutsArray) delete[] fCutsArray;
 191 }
 192
 193 //---------------------------------------------------------------------------
 194 void AliRDHFCutsXicPlustoXiPiPifromAODtracks::GetCutVarsForOpt(AliAODRecoDecayHF *d, Float_t *vars, Int_t nvars, Int_t *pdgdaughters) {
 195   //
 196   // Fills in vars the values of the variables
 197   //
 198
 199   if (pdgdaughters[0]==-9999) return; // dummy
 200
 201   AliAODRecoCascadeHF3Prong* dd=(AliAODRecoCascadeHF3Prong*)d;
 202   if(!dd){
 203     AliDebug(2," No AliAODRecoCascadeHF3Prong object found\n");
 204     return;
 205   }
 206
 207   if (nvars!=fnVarsForOpt) {
 208     AliError("AliRDHFCutsXicPlustoXiPiPifromAODtracks wrong number of variables\n");
 209     return;
 210   }
 211
 212   //Double_t ptD=d->Pt();
 213   //Int_t ptbin=PtBin(ptD);
 214   Int_t iter=-1;
 215
 216   if(fVarsForOpt[0]){
 217     iter++;
 218     Double_t mxicPDG =  TDatabasePDG::Instance()->GetParticle(4232)->Mass();
 219     vars[iter]= TMath::Abs(dd->InvMassPiXiPi()-mxicPDG) ;
 220   }
 221   if(fVarsForOpt[1]){
 222     iter++;
 223     vars[iter]= dd->Pt();
 224   }
 225   if(fVarsForOpt[2]){
 226     iter++;
 227     Double_t mxiPDG =  TDatabasePDG::Instance()->GetParticle(3312)->Mass();
 228     vars[iter]= TMath::Abs(dd->CascMassXi()-mxiPDG);
 229   }
 230   if(fVarsForOpt[3]){
 231     iter++;
 232     Double_t mLPDG =  TDatabasePDG::Instance()->GetParticle(3122)->Mass();
 233     vars[iter]= TMath::Abs(dd->CascMassLambda()-mLPDG);
 234   }
 235   Double_t dca[3];
 236   dd->GetDCAs(dca);
 237   if(fVarsForOpt[4]){
 238     iter++;
 239     vars[iter]= dca[2];
 240   }
 241   if(fVarsForOpt[5]){
 242     iter++;
 243     vars[iter]= dca[0];
 244   }
 245   if(fVarsForOpt[6]){
 246     iter++;
 247     vars[iter]= dd->Getd0Prong(0);
 248   }
 249   if(fVarsForOpt[7]){
 250     iter++;
 251     vars[iter]= dd->Getd0Prong(1);
 252   }
 253   if(fVarsForOpt[8]){
 254     iter++;
 255     vars[iter]= dd->CascDcaBachToPrimVertex();
 256   }
 257   if(fVarsForOpt[9]){
 258     iter++;
 259     vars[iter]= dd->CascDcaV0ToPrimVertex();
 260   }
 261   if(fVarsForOpt[10]){
 262     iter++;
 263     vars[iter]= dd->XicCosPointingAngle();
 264   }
 265   if(fVarsForOpt[11]){
 266     iter++;
 267     vars[iter]= dd->DecayLengthXY();
 268   }
 269   if(fVarsForOpt[12]){
 270     iter++;
 271     vars[iter]= dd->PtProng(0);
 272   }
 273
 274   return;
 275 }
 276 //---------------------------------------------------------------------------
 277 Int_t AliRDHFCutsXicPlustoXiPiPifromAODtracks::IsSelected(TObject* obj,Int_t selectionLevel)
 278 {
 279   //
 280   // Apply selection
 281   //
 282
 283   if (!fCutsRD) {
 284     AliFatal("Cut matrice not inizialized. Exit...");
 285     return 0;
 286   }
 287
 288   AliAODRecoCascadeHF3Prong* d=(AliAODRecoCascadeHF3Prong*)obj;
 289   if(!d){
 290     AliDebug(2," No AliAODRecoCascadeHF3Prong object found\n");
 291     return 0;
 292   }
 293
 294   Double_t ptD=d->Pt();
 295   if(ptD<fMinPtCand) return 0;
 296   if(ptD>fMaxPtCand) return 0;
 297
 298   if (selectionLevel==AliRDHFCuts::kAll ||
 299       selectionLevel==AliRDHFCuts::kTracks) {
 300     //Performed in production stage
 301   }
 302
 303   Int_t returnvalueCuts=1;
 304   // selection on candidate
 305   if (selectionLevel==AliRDHFCuts::kAll ||
 306       selectionLevel==AliRDHFCuts::kCandidate) {
 307
 308     Double_t pt=d->Pt();
 309     Int_t ptbin=PtBin(pt);
 310     if (ptbin==-1) {
 311       return 0;
 312     }
 313     Bool_t okcand=kTRUE;
 314
 315     Double_t mLPDG =  TDatabasePDG::Instance()->GetParticle(3122)->Mass();
 316     Double_t mxiPDG =  TDatabasePDG::Instance()->GetParticle(3312)->Mass();
 317     Double_t mxicPDG =  TDatabasePDG::Instance()->GetParticle(4232)->Mass();
 318     if(TMath::Abs(d->InvMassPiXiPi()-mxicPDG) > fCutsRD[GetGlobalIndex(0,ptbin)])
 319       {
 320         okcand = kFALSE;
 321       }
 322     if(d->Pt()< fCutsRD[GetGlobalIndex(1,ptbin)])
 323       {
 324         okcand = kFALSE;
 325       }
 326     if(TMath::Abs(d->CascMassXi()-mxiPDG) > fCutsRD[GetGlobalIndex(2,ptbin)])
 327       {
 328         okcand = kFALSE;
 329       }
 330     if((TMath::Abs(d->CascMassLambda()-mLPDG) > fCutsRD[GetGlobalIndex(3,ptbin)]) &&(TMath::Abs(d->CascMassAntiLambda()-mLPDG) > fCutsRD[GetGlobalIndex(3,ptbin)]) )
 331       {
 332         okcand = kFALSE;
 333       }
 334     Double_t dca[3];
 335     d->GetDCAs(dca);
 336     if(TMath::Abs(dca[2]) > fCutsRD[GetGlobalIndex(4,ptbin)])
 337       {
 338         okcand = kFALSE;
 339       }
 340     if((TMath::Abs(dca[0]) > fCutsRD[GetGlobalIndex(5,ptbin)]) && (TMath::Abs(dca[1]) > fCutsRD[GetGlobalIndex(5,ptbin)]) )
 341       {
 342         okcand = kFALSE;
 343       }
 344     if((TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)]) && (TMath::Abs(d->Getd0Prong(2)) > fCutsRD[GetGlobalIndex(6,ptbin)]) )
 345       {
 346         okcand = kFALSE;
 347       }
 348     if((TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(7,ptbin)]))
 349       {
 350         okcand = kFALSE;
 351       }
 352     if((TMath::Abs(d->CascDcaBachToPrimVertex()) < fCutsRD[GetGlobalIndex(8,ptbin)]))
 353       {
 354         okcand = kFALSE;
 355       }
 356     if((TMath::Abs(d->CascDcaV0ToPrimVertex()) < fCutsRD[GetGlobalIndex(9,ptbin)]))
 357       {
 358         okcand = kFALSE;
 359       }
 360     if( d->XicCosPointingAngle() < fCutsRD[GetGlobalIndex(10,ptbin)])
 361       {
 362         okcand = kFALSE;
 363       }
 364     if( d->DecayLengthXY() < fCutsRD[GetGlobalIndex(11,ptbin)])
 365       {
 366         okcand = kFALSE;
 367       }
 368     if( d->PtProng(0) < fCutsRD[GetGlobalIndex(12,ptbin)] || d->PtProng(2) < fCutsRD[GetGlobalIndex(12,ptbin)]  )
 369       {
 370         okcand = kFALSE;
 371       }
 372
 373     if(!okcand)  return 0;
 374     returnvalueCuts = 1;
 375   }
 376
 377   Int_t returnvaluePID=1;
 378   if(selectionLevel==AliRDHFCuts::kAll ||
 379      selectionLevel==AliRDHFCuts::kCandidate||
 380      selectionLevel==AliRDHFCuts::kPID) {
 381
 382     switch(fPIDStrategy){
 383     case kNSigmaCuts:
 384       returnvaluePID = IsSelectedPID(d);
 385       break;
 386     case kCombinedCuts:
 387       returnvaluePID = IsSelectedCombinedPID(d);
 388       break;
 389     }
 390   }
 391
 392   Int_t returnvalue = 0;
 393   if(returnvalueCuts==1 && returnvaluePID==1) returnvalue=1;
 394
 395   return returnvalue;
 396 }
 397
 398 //---------------------------------------------------------------------------
 399 Int_t AliRDHFCutsXicPlustoXiPiPifromAODtracks::IsSelectedPID(AliAODRecoDecayHF* obj)
 400 {
 401   //
 402   //  PID selection
 403   //
 404
 405   if(!fUsePID || !obj) return 1;
 406
 407   AliAODRecoCascadeHF3Prong* dd=(AliAODRecoCascadeHF3Prong*)obj;
 408   AliAODTrack *part1 = dd->GetBachelor1();
 409   AliAODTrack *part2 = dd->GetBachelor2();
 410
 411   Int_t returnvalue=1;
 412
 413   if(fPidHF->GetPidResponse()==0x0){
 414     AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
 415     AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();
 416     AliPIDResponse *pidResp=inputHandler->GetPIDResponse();
 417     fPidHF->SetPidResponse(pidResp);
 418   }
 419
 420   Int_t isPion1=fPidHF->MakeRawPid(part1,2);
 421   Int_t isPion2=fPidHF->MakeRawPid(part2,2);
 422
 423   if(isPion1<1) returnvalue = 0;
 424   if(isPion2<1) returnvalue = 0;
 425
 426   return returnvalue;
 427 }
 428
 429 //---------------------------------------------------------------------------
 430 Int_t AliRDHFCutsXicPlustoXiPiPifromAODtracks::IsSelectedCombinedPID(AliAODRecoDecayHF* obj) {
 431   //
 432   //  Combined PID selection
 433   //
 434
 435   if(!fUsePID || !obj) {return 1;}
 436
 437   AliAODRecoCascadeHF3Prong* dd=(AliAODRecoCascadeHF3Prong*)obj;
 438   AliAODTrack *part1 = dd->GetBachelor1();
 439   AliAODTrack *part2 = dd->GetBachelor2();
 440   if(!part1||!part2) return 0;
 441
 442   Int_t returnvalue=1;
 443   Double_t probPion1 = GetPionProbabilityTPCTOF(part1);
 444   Double_t probPion2 = GetPionProbabilityTPCTOF(part2);
 445   if(probPion1<fCombinedPIDThreshold) returnvalue = 0;
 446   if(probPion2<fCombinedPIDThreshold) returnvalue = 0;
 447   return returnvalue;
 448 }
 449
 450 //________________________________________________________________________
 451 Double_t AliRDHFCutsXicPlustoXiPiPifromAODtracks::GetPionProbabilityTPCTOF(AliAODTrack* trk)
 452 {
 453   //
 454   //  Get Pion Probablility
 455   //
 456   //fPidHF->GetPidCombined()->SetDefaultTPCPriors();
 457   fPidHF->GetPidCombined()->SetDetectorMask(AliPIDResponse::kDetTPC+AliPIDResponse::kDetTOF);
 458   Double_t prob1[AliPID::kSPECIES];
 459   UInt_t detUsed1 = fPidHF->GetPidCombined()->ComputeProbabilities(trk, fPidHF->GetPidResponse(), prob1);
 460   if (detUsed1 != (UInt_t)fPidHF->GetPidCombined()->GetDetectorMask() )
 461     {
 462       fPidHF->GetPidCombined()->SetDetectorMask(AliPIDResponse::kDetTPC);
 463       detUsed1 = fPidHF->GetPidCombined()->ComputeProbabilities(trk, fPidHF->GetPidResponse(), prob1);
 464     }
 465   return prob1[AliPID::kPion];
 466 }
 467
 468 //________________________________________________________________________
 469 Bool_t AliRDHFCutsXicPlustoXiPiPifromAODtracks::SingleTrkCuts(AliAODTrack *trk)
 470 {
 471   //
 472   //  Single Track Cut
 473   //
 474
 475   if(trk->GetStatus()&AliESDtrack::kITSpureSA) return kFALSE;
 476   if(!(trk->GetStatus()&AliESDtrack::kITSin)) return kFALSE;
 477
 478   if(fProdUseAODFilterBit && !trk->TestFilterMask(BIT(4))) return kFALSE;
 479   //    if(!fAnalCuts->IsDaughterSelected(trk,fV1,esdTrackCuts)) return kFALSE;
 480   if(fabs(trk->Eta())>fProdTrackEtaRange) return kFALSE;
 481   if(trk->Pt()<fProdTrackPtMin) return kFALSE;
 482
 483   return kTRUE;
 484 }
 485
 486 //________________________________________________________________________
 487 Bool_t AliRDHFCutsXicPlustoXiPiPifromAODtracks::SingleCascadeCuts(AliAODcascade *casc)
 488 {
 489   //
 490   //  Single Cascade Cut
 491   //
 492
 493   if(!casc) return kFALSE;
 494
 495   AliAODTrack *ptrack = (AliAODTrack*) (casc->GetDaughter(0));
 496   AliAODTrack *ntrack = (AliAODTrack*) (casc->GetDaughter(1));
 497   AliAODTrack *btrack = (AliAODTrack*) (casc->GetDecayVertexXi()->GetDaughter(0));
 498
 499   if(!ptrack||!ntrack||!btrack) return kFALSE;
 500
 501   Double_t mLPDG =  TDatabasePDG::Instance()->GetParticle(3122)->Mass();
 502   Double_t mxiPDG =  TDatabasePDG::Instance()->GetParticle(3312)->Mass();
 503
 504   Double_t massLambda = casc->MassLambda();
 505   Double_t massAntiLambda = casc->MassAntiLambda();
 506   if(TMath::Abs(massLambda-mLPDG)>fProdMassTolLambda && TMath::Abs(massAntiLambda-mLPDG)>fProdMassTolLambda)
 507     return kFALSE;
 508
 509   Double_t massXi = casc->MassXi();
 510   if(TMath::Abs(massXi-mxiPDG)>fProdMassTolXi)
 511     return kFALSE;
 512
 513   Double_t lPosXi[3];
 514   lPosXi[0] = casc->DecayVertexXiX();
 515   lPosXi[1] = casc->DecayVertexXiY();
 516   lPosXi[2] = casc->DecayVertexXiZ();
 517   Double_t decayvertXi = TMath::Sqrt(lPosXi[0]*lPosXi[0]+lPosXi[1]*lPosXi[1]);
 518   Double_t lPosV0[3];
 519   lPosV0[0] = casc->DecayVertexV0X();
 520   lPosV0[1] = casc->DecayVertexV0Y();
 521   lPosV0[2] = casc->DecayVertexV0Z();
 522   Double_t decayvertV0 = TMath::Sqrt(lPosV0[0]*lPosV0[0]+lPosV0[1]*lPosV0[1]);
 523
 524   if(decayvertV0<fProdRfidMinV0 || decayvertV0>fProdRfidMaxV0) return kFALSE;
 525   if(decayvertXi<fProdRfidMinXi || decayvertXi>fProdRfidMaxXi) return kFALSE;
 526
 527   return kTRUE;
 528 }
 529
 530 //________________________________________________________________________
 531 Bool_t AliRDHFCutsXicPlustoXiPiPifromAODtracks::SelectWithRoughCuts(AliAODcascade *casc, AliAODTrack *part1, AliAODTrack *part2)
 532 {
 533   //
 534   //  Select With Rough mass and pT cut before object creation
 535   //
 536
 537   //Constants
 538   Double_t mpiPDG =  TDatabasePDG::Instance()->GetParticle(211)->Mass();
 539   Double_t mxiPDG =  TDatabasePDG::Instance()->GetParticle(3312)->Mass();
 540   Double_t mxicPDG =  TDatabasePDG::Instance()->GetParticle(4232)->Mass();
 541
 542   Double_t pxpi1_init = part1->Px();
 543   Double_t pypi1_init = part1->Py();
 544   Double_t pzpi1_init = part1->Pz();
 545   Double_t Epi1_init = sqrt(pxpi1_init*pxpi1_init+pypi1_init*pypi1_init+pzpi1_init*pzpi1_init+mpiPDG*mpiPDG);
 546   Double_t pxpi2_init = part2->Px();
 547   Double_t pypi2_init = part2->Py();
 548   Double_t pzpi2_init = part2->Pz();
 549   Double_t Epi2_init = sqrt(pxpi2_init*pxpi2_init+pypi2_init*pypi2_init+pzpi2_init*pzpi2_init+mpiPDG*mpiPDG);
 550   Double_t pxcasc_init = casc->MomXiX();
 551   Double_t pycasc_init = casc->MomXiY();
 552   Double_t pzcasc_init = casc->MomXiZ();
 553   Double_t Ecasc_init = sqrt(pxcasc_init*pxcasc_init+pycasc_init*pycasc_init+pzcasc_init*pzcasc_init+mxiPDG*mxiPDG);
 554   Double_t pxxic_init = pxpi1_init+pxpi2_init+pxcasc_init;
 555   Double_t pyxic_init = pypi1_init+pypi2_init+pycasc_init;
 556   Double_t pzxic_init = pzpi1_init+pzpi2_init+pzcasc_init;
 557   Double_t Exic_init = Epi1_init+Epi2_init+Ecasc_init;
 558   Double_t xicmass_init = sqrt(Exic_init*Exic_init-pxxic_init*pxxic_init-pyxic_init*pyxic_init-pzxic_init*pzxic_init);
 559
 560   if(xicmass_init<mxicPDG-fProdRoughMassTol || xicmass_init>mxicPDG+fProdRoughMassTol) return kFALSE;
 561   if(sqrt(pxxic_init*pxxic_init+pyxic_init*pyxic_init)<fProdRoughPtMin) return kFALSE;
 562
 563   return kTRUE;
 564 }
 565
 566 //________________________________________________________________________
 567 void AliRDHFCutsXicPlustoXiPiPifromAODtracks::SetCutsArray(Int_t nCuts, Int_t nVars, Int_t nPtBins, Float_t ***cutsArray)
 568 {
 569   //
 570   // store the cuts
 571   //
 572   if (nVars!=fnVars) {
 573     AliError(" wrong number of variables\n");
 574     return;
 575   }
 576   if (nCuts!=fnCuts) {
 577     AliError(" wrong number of cuts\n");
 578     return;
 579   }
 580   if (nPtBins!=fnPtBins) {
 581     AliError(" wrong number of pT bins\n");
 582     return;
 583   }
 584
 585   if(!fCutsArray)
 586     {
 587       fnTotalCutBins = nCuts * nVars * nPtBins;
 588       fCutsArray = new Float_t[fnTotalCutBins];
 589     }
 590
 591   for(Int_t icuts=0;icuts<nCuts;icuts++){
 592     for(Int_t iv=0;iv<nVars;iv++){
 593       for(Int_t ip=0;ip<nPtBins;ip++){
 594         Int_t gid = GetCutArrayID(icuts,iv,ip);
 595         fCutsArray[gid] = cutsArray[icuts][iv][ip];
 596       }
 597     }
 598   }
 599   return;
 600 }
 601
 602 //________________________________________________________________________
 603 void AliRDHFCutsXicPlustoXiPiPifromAODtracks::SetCutsArray(Int_t nTotBins, Float_t *cutsArray)
 604 {
 605   //
 606   // store the cuts
 607   //
 608   if (nTotBins!=fnVars*fnPtBins*fnCuts) {
 609     AliError(" wrong number of variables\n");
 610     return;
 611   }
 612
 613   if(!fCutsArray)
 614     {
 615       fnTotalCutBins = fnCuts * fnVars * fnPtBins;
 616       fCutsArray = new Float_t[fnTotalCutBins];
 617     }
 618
 619   for(Int_t i=0;i<nTotBins;i++){
 620     fCutsArray[i] = cutsArray[i];
 621   }
 622
 623   return;
 624 }
 625
 626 //________________________________________________________________________
 627 void AliRDHFCutsXicPlustoXiPiPifromAODtracks::SetCutsFromArray(Int_t iCuts)
 628 {
 629   //
 630   //  Update fCutsRD
 631   //
 632
 633   Float_t** cutsarray;
 634   cutsarray=new Float_t*[fnVars];
 635   for(Int_t ic=0;ic<fnVars;ic++){cutsarray[ic]=new Float_t[fnPtBins];}
 636
 637   for(Int_t i=0;i<fnVars;i++){
 638     for(Int_t j=0;j<fnPtBins;j++){
 639       Int_t gid = GetCutArrayID(iCuts,i,j);
 640       cutsarray[i][j] = fCutsArray[gid];
 641     }
 642   }
 643   SetCuts(fnVars,fnPtBins,cutsarray);
 644
 645   for(Int_t ic=0;ic<fnVars;ic++){
 646     delete[] cutsarray[ic];
 647   }
 648   delete[] cutsarray;
 649 }
 650
 651 //________________________________________________________________________
 652 Int_t AliRDHFCutsXicPlustoXiPiPifromAODtracks::GetCutArrayID(Int_t ic, Int_t iv, Int_t ip)
 653 {
 654   //
 655   //  Get GlobalIndex of fCutsArray
 656   //
 657   return ic*fnVars*fnPtBins+iv*fnPtBins+ip;
 658 }