PWG3/vertexingHF/AliRDHFCutsDplustoKpipi.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 D+->Kpipi
  21 //
  22 // Author: R. Bala, bala@to.infn.it
  23 //         G. Ortona, ortona@to.infn.it
  24 /////////////////////////////////////////////////////////////
  25
  26 #include <TDatabasePDG.h>
  27 #include <Riostream.h>
  28
  29 #include "AliAODPidHF.h"
  30 #include "AliRDHFCutsDplustoKpipi.h"
  31 #include "AliAODRecoDecayHF3Prong.h"
  32 #include "AliAODTrack.h"
  33 #include "AliESDtrack.h"
  34
  35
  36 ClassImp(AliRDHFCutsDplustoKpipi)
  37
  38 //--------------------------------------------------------------------------
  39 AliRDHFCutsDplustoKpipi::AliRDHFCutsDplustoKpipi(const char* name) :
  40 AliRDHFCuts(name),
  41   fUseStrongPid(0),
  42   fMaxPtStrongPid(0.),
  43   fMaxPtStrongPidK(0.),
  44   fMaxPtStrongPidpi(0.),
  45   fUseImpParProdCorrCut(kFALSE)
  46 {
  47   //
  48   // Default Constructor
  49   //
  50   Int_t nvars=14;
  51   SetNVars(nvars);
  52   TString varNames[14]={"inv. mass [GeV]",
  53                         "pTK [GeV/c]",
  54                         "pTPi [GeV/c]",
  55                         "d0K [cm]   lower limit!",
  56                         "d0Pi [cm]  lower limit!",
  57                         "dist12 (cm)",
  58                         "sigmavert (cm)",
  59                         "dist prim-sec (cm)",
  60                         "pM=Max{pT1,pT2,pT3} (GeV/c)",
  61                         "cosThetaPoint",
  62                         "Sum d0^2 (cm^2)",
  63                         "dca cut (cm)",
  64                         "dec len XY (cm)",
  65                         "cosThetaPointXY"};
  66   Bool_t isUpperCut[14]={kTRUE,
  67                          kFALSE,
  68                          kFALSE,
  69                          kFALSE,
  70                          kFALSE,
  71                          kFALSE,
  72                          kTRUE,
  73                          kFALSE,
  74                          kFALSE,
  75                          kFALSE,
  76                          kFALSE,
  77                          kTRUE,
  78                          kFALSE,
  79                          kFALSE};
  80   SetVarNames(nvars,varNames,isUpperCut);
  81   Bool_t forOpt[14]={kFALSE,
  82                      kFALSE,
  83                      kFALSE,
  84                      kFALSE,
  85                      kFALSE,
  86                      kFALSE,
  87                      kTRUE,
  88                      kTRUE,
  89                      kTRUE,
  90                      kTRUE,
  91                      kTRUE,
  92                      kFALSE,
  93                      kTRUE,
  94                      kTRUE};
  95   SetVarsForOpt(7,forOpt);
  96   Float_t limits[2]={0,999999999.};
  97   SetPtBins(2,limits);
  98   if(fPidHF)delete fPidHF;
  99   fPidHF=new AliAODPidHF();
 100   Double_t plim[2]={0.6,0.8};
 101   Double_t nsigma[5]={2.,1.,2.,3.,0.};
 102
 103   fPidHF->SetPLimit(plim);
 104   fPidHF->SetAsym(kTRUE);
 105   fPidHF->SetSigma(nsigma);
 106   fPidHF->SetMatch(1);
 107   fPidHF->SetTPC(1);
 108   fPidHF->SetTOF(1);
 109   fPidHF->SetITS(0);
 110   fPidHF->SetTRD(0);
 111   fPidHF->SetCompat(kTRUE);
 112
 113
 114 }
 115
 116
 117
 118
 119
 120
 121
 122
 123 //--------------------------------------------------------------------------
 124 AliRDHFCutsDplustoKpipi::AliRDHFCutsDplustoKpipi(const AliRDHFCutsDplustoKpipi &source) :
 125   AliRDHFCuts(source),
 126   fUseStrongPid(source.fUseStrongPid),
 127   fMaxPtStrongPid(source.fMaxPtStrongPid),
 128   fMaxPtStrongPidK(source.fMaxPtStrongPidK),
 129   fMaxPtStrongPidpi(source.fMaxPtStrongPidpi),
 130   fUseImpParProdCorrCut(source.fUseImpParProdCorrCut)
 131 {
 132   //
 133   // Copy constructor
 134   //
 135
 136 }
 137 //--------------------------------------------------------------------------
 138 AliRDHFCutsDplustoKpipi &AliRDHFCutsDplustoKpipi::operator=(const AliRDHFCutsDplustoKpipi &source)
 139 {
 140   //
 141   // assignment operator
 142   //
 143   if(&source == this) return *this;
 144
 145   AliRDHFCuts::operator=(source);
 146
 147   fUseStrongPid=source.fUseStrongPid;
 148   fMaxPtStrongPid=source.fMaxPtStrongPid;
 149   fMaxPtStrongPidK=source.fMaxPtStrongPidK;
 150   fMaxPtStrongPidpi=source.fMaxPtStrongPidpi;
 151   fUseImpParProdCorrCut=source.fUseImpParProdCorrCut;
 152
 153   return *this;
 154 }
 155 //
 156
 157
 158 //---------------------------------------------------------------------------
 159 void AliRDHFCutsDplustoKpipi::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters,AliAODEvent *aod) {
 160   //
 161   // Fills in vars the values of the variables
 162   //
 163
 164
 165   if(nvars!=fnVarsForOpt) {
 166     printf("AliRDHFCutsDplustoKpipi::GetCutsVarsForOpt: wrong number of variables\n");
 167     return;
 168   }
 169
 170   AliAODRecoDecayHF3Prong *dd = (AliAODRecoDecayHF3Prong*)d;
 171
 172   //recalculate vertex w/o daughters
 173   Bool_t cleanvtx=kFALSE;
 174   AliAODVertex *origownvtx=0x0;
 175   if(fRemoveDaughtersFromPrimary) {
 176     if(dd->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*dd->GetOwnPrimaryVtx());
 177     cleanvtx=kTRUE;
 178     if(!RecalcOwnPrimaryVtx(dd,aod)) {
 179       CleanOwnPrimaryVtx(dd,aod,origownvtx);
 180       cleanvtx=kFALSE;
 181     }
 182   }
 183
 184   Int_t iter=-1;
 185   if(fVarsForOpt[0]){
 186     iter++;
 187     vars[iter]=dd->InvMassDplus();
 188   }
 189   if(fVarsForOpt[1]){
 190     iter++;
 191     for(Int_t iprong=0;iprong<3;iprong++){
 192       if(TMath::Abs(pdgdaughters[iprong])==321) {
 193         vars[iter]=dd->PtProng(iprong);
 194       }
 195     }
 196   }
 197   if(fVarsForOpt[2]){
 198     iter++;
 199     Float_t minPtDau=1000000.0;
 200     for(Int_t iprong=0;iprong<3;iprong++){
 201       if(TMath::Abs(pdgdaughters[iprong])==211) {
 202         if(dd->PtProng(iprong)<minPtDau){
 203           minPtDau=dd->PtProng(iprong);
 204         }
 205       }
 206     }
 207     vars[iter]=minPtDau;
 208   }
 209   if(fVarsForOpt[3]){
 210     iter++;
 211     for(Int_t iprong=0;iprong<3;iprong++){
 212       if(TMath::Abs(pdgdaughters[iprong])==321) {
 213         vars[iter]=dd->Getd0Prong(iprong);
 214       }
 215     }
 216   }
 217   if(fVarsForOpt[4]){
 218     iter++;
 219     Float_t minImpParDau=1000000.0;
 220     for(Int_t iprong=0;iprong<3;iprong++){
 221       if(TMath::Abs(pdgdaughters[iprong])==211) {
 222         if(dd->Getd0Prong(iprong)<minImpParDau){
 223           minImpParDau=dd->Getd0Prong(iprong);
 224         }
 225       }
 226     }
 227    vars[iter]=minImpParDau;
 228   }
 229   if(fVarsForOpt[5]){
 230     iter++;
 231     Float_t dist12 = dd->GetDist12toPrim();
 232     Float_t dist23 = dd->GetDist23toPrim();
 233     if(dist12<dist23)vars[iter]=dist12;
 234     else vars[iter]=dist23;
 235   }
 236   if(fVarsForOpt[6]){
 237     iter++;
 238     vars[iter]=dd->GetSigmaVert(aod);
 239   }
 240   if(fVarsForOpt[7]){
 241     iter++;
 242     vars[iter] = dd->DecayLength();
 243   }
 244   if(fVarsForOpt[8]){
 245     iter++;
 246     Float_t ptmax=0;
 247     for(Int_t i=0;i<3;i++){
 248       if(dd->PtProng(i)>ptmax)ptmax=dd->PtProng(i);
 249     }
 250     vars[iter]=ptmax;
 251   }
 252   if(fVarsForOpt[9]){
 253     iter++;
 254     vars[iter]=dd->CosPointingAngle();
 255   }
 256   if(fVarsForOpt[10]){
 257     iter++;
 258     vars[iter]=dd->Getd0Prong(0)*dd->Getd0Prong(0)+dd->Getd0Prong(1)*dd->Getd0Prong(1)+dd->Getd0Prong(2)*dd->Getd0Prong(2);
 259   }
 260   if(fVarsForOpt[11]){
 261     iter++;
 262     Float_t maxDCA=0;
 263     for(Int_t iprong=0;iprong<3;iprong++){
 264       if(dd->GetDCA(iprong)<maxDCA){
 265         maxDCA=dd->GetDCA(iprong);
 266       }
 267     }
 268     vars[iter]=maxDCA;
 269   }
 270   if(fVarsForOpt[12]){
 271     iter++;
 272     vars[iter]=dd->NormalizedDecayLengthXY()*dd->P()/dd->Pt();
 273   }
 274   if(fVarsForOpt[13]){
 275     iter++;
 276     vars[iter]=dd->CosPointingAngleXY();
 277   }
 278
 279   if(cleanvtx)CleanOwnPrimaryVtx(dd,aod,origownvtx);
 280
 281   return;
 282 }
 283 //---------------------------------------------------------------------------
 284 Bool_t AliRDHFCutsDplustoKpipi::IsInFiducialAcceptance(Double_t pt, Double_t y) const
 285 {
 286   //
 287   // Checking if Dplus is in fiducial acceptance region
 288   //
 289
 290   if(pt > 5.) {
 291     // applying cut for pt > 5 GeV
 292     AliDebug(2,Form("pt of D+ = %f (> 5), cutting at |y| < 0.8",pt));
 293     if (TMath::Abs(y) > 0.8) return kFALSE;
 294
 295   } else {
 296     // appliying smooth cut for pt < 5 GeV
 297     Double_t maxFiducialY = -0.2/15*pt*pt+1.9/15*pt+0.5;
 298     Double_t minFiducialY = 0.2/15*pt*pt-1.9/15*pt-0.5;
 299     AliDebug(2,Form("pt of D+ = %f (< 5), cutting  according to the fiducial zone [%f, %f]\n",pt,minFiducialY,maxFiducialY));
 300     if (y < minFiducialY || y > maxFiducialY) return kFALSE;
 301   }
 302
 303   return kTRUE;
 304 }
 305
 306 //---------------------------------------------------------------------------
 307 Int_t AliRDHFCutsDplustoKpipi::IsSelectedPID(AliAODRecoDecayHF *rd)
 308 {
 309   //
 310   // PID selection, returns 3 if accepted, 0 if not accepted
 311   //
 312   if(!fUsePID || !rd) return 3;
 313   //if(fUsePID)printf("i am inside the pid \n");
 314   Int_t nkaons=0;
 315   Int_t nNotKaons=0;
 316   Int_t sign= rd->GetCharge();
 317   for(Int_t daught=0;daught<3;daught++){
 318     AliAODTrack *track=(AliAODTrack*)rd->GetDaughter(daught);
 319     Int_t isPion=fPidHF->MakeRawPid(track,AliPID::kPion);
 320     Int_t isKaon=fPidHF->MakeRawPid(track,AliPID::kKaon);
 321     Int_t isProton=fPidHF->MakeRawPid(track,AliPID::kProton);
 322
 323     if(isProton>0 &&  isKaon<0  && isPion<0) return 0;
 324     if(isKaon>0 && isPion<0) nkaons++;
 325     if(isKaon<0) nNotKaons++;
 326     if(sign==track->Charge()){//pions
 327       if(isPion<0)return 0;
 328       if(rd->Pt()<fMaxPtStrongPid && isPion<=0 && fUseStrongPid&2 && track->Pt()<fMaxPtStrongPidpi)return 0;
 329     }
 330     else{//kaons
 331       if(isKaon<0)return 0;
 332         if(rd->Pt()<fMaxPtStrongPid && isKaon<=0 && fUseStrongPid&1&& track->Pt()<fMaxPtStrongPidK)return 0;
 333     }
 334   }
 335
 336   if(nkaons>1)return 0;
 337   if(nNotKaons==3)return 0;
 338
 339   return 3;
 340 }
 341
 342
 343 //---------------------------------------------------------------------------
 344 Int_t AliRDHFCutsDplustoKpipi::IsSelected(TObject* obj,Int_t selectionLevel, AliAODEvent* aod) {
 345   //
 346   // Apply selection, returns 3 if accepted, 0 if not accepted
 347   //
 348
 349
 350   fIsSelectedCuts=0;
 351   fIsSelectedPID=0;
 352
 353   if(!fCutsRD){
 354     cout<<"Cut matrix not inizialized. Exit..."<<endl;
 355     return 0;
 356   }
 357   //PrintAll();
 358   AliAODRecoDecayHF3Prong* d=(AliAODRecoDecayHF3Prong*)obj;
 359
 360
 361   if(!d){
 362     cout<<"AliAODRecoDecayHF3Prong null"<<endl;
 363     return 0;
 364   }
 365
 366   if(fKeepSignalMC) if(IsSignalMC(d,aod,411)) return 3;
 367
 368   // PID selection
 369   Int_t returnvaluePID=3;
 370   Int_t returnvalueCuts=3;
 371
 372   Double_t pt=d->Pt();
 373   if(pt<fMinPtCand) return 0;
 374   if(pt>fMaxPtCand) return 0;
 375
 376   if(d->HasBadDaughters()) return 0;
 377
 378   // selection on candidate
 379   if(selectionLevel==AliRDHFCuts::kAll ||
 380      selectionLevel==AliRDHFCuts::kCandidate) {
 381
 382     //recalculate vertex w/o daughters
 383     AliAODVertex *origownvtx=0x0;
 384     if(fRemoveDaughtersFromPrimary) {
 385       if(d->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*d->GetOwnPrimaryVtx());
 386       if(!RecalcOwnPrimaryVtx(d,aod)) {
 387         CleanOwnPrimaryVtx(d,aod,origownvtx);
 388         return 0;
 389       }
 390     }
 391
 392     Int_t ptbin=PtBin(pt);
 393     if (ptbin==-1) {
 394       CleanOwnPrimaryVtx(d,aod,origownvtx);
 395       return 0;
 396     }
 397
 398     Double_t mDplusPDG = TDatabasePDG::Instance()->GetParticle(411)->Mass();
 399     Double_t mDplus=d->InvMassDplus();
 400     if(TMath::Abs(mDplus-mDplusPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 401
 402     //2track cuts
 403     if(d->GetDist12toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]|| d->GetDist23toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 404
 405     Double_t sum2=d->Getd0Prong(0)*d->Getd0Prong(0)+d->Getd0Prong(1)*d->Getd0Prong(1)+d->Getd0Prong(2)*d->Getd0Prong(2);
 406     if(sum2<fCutsRD[GetGlobalIndex(10,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 407
 408     if(fUseImpParProdCorrCut){
 409       if(d->Getd0Prong(0)*d->Getd0Prong(1)<0. && d->Getd0Prong(2)*d->Getd0Prong(1)<0.) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 410     }
 411
 412
 413     //DCA
 414     for(Int_t i=0;i<3;i++) if(d->GetDCA(i)>fCutsRD[GetGlobalIndex(11,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 415
 416     if(d->Pt2Prong(1) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] || TMath::Abs(d->Getd0Prong(1))<fCutsRD[GetGlobalIndex(3,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}//Kaon
 417
 418     if(d->Pt2Prong(0) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] || TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(4,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}//Pion1
 419
 420     if(d->Pt2Prong(2) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] || TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(4,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}//Pion2
 421
 422     if(d->Pt2Prong(0)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] && d->Pt2Prong(1)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] && d->Pt2Prong(2)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 423
 424     if(d->DecayLength2()<fCutsRD[GetGlobalIndex(7,ptbin)]*fCutsRD[GetGlobalIndex(7,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 425
 426     if(d->CosPointingAngle()< fCutsRD[GetGlobalIndex(9,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 427
 428     if(d->NormalizedDecayLengthXY()*d->P()/pt<fCutsRD[GetGlobalIndex(12,ptbin)]){CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 429
 430     if(d->CosPointingAngleXY()<fCutsRD[GetGlobalIndex(13,ptbin)]){CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 431
 432     //sec vert
 433     Double_t sigmavert=d->GetSigmaVert(aod);
 434     if(sigmavert>fCutsRD[GetGlobalIndex(6,ptbin)]) {CleanOwnPrimaryVtx(d,aod,origownvtx); return 0;}
 435
 436     // unset recalculated primary vertex when not needed any more
 437     CleanOwnPrimaryVtx(d,aod,origownvtx);
 438
 439     fIsSelectedCuts=returnvalueCuts;
 440
 441     //if(!returnvalueCuts) return 0; // returnvalueCuts cannot be 0 here
 442   }
 443
 444   if(selectionLevel==AliRDHFCuts::kAll ||
 445      selectionLevel==AliRDHFCuts::kCandidate ||
 446      selectionLevel==AliRDHFCuts::kPID) {
 447     returnvaluePID = IsSelectedPID(d);
 448     fIsSelectedPID=returnvaluePID;
 449   }
 450   if(returnvaluePID==0)return 0;
 451
 452   // selection on daughter tracks
 453   if(selectionLevel==AliRDHFCuts::kAll ||
 454      selectionLevel==AliRDHFCuts::kTracks) {
 455     if(!AreDaughtersSelected(d)) return 0;
 456   }
 457
 458
 459
 460
 461   return 3;
 462 }
 463
 464
 465
 466
 467 //---------------------------------------------------------------------------
 468
 469
 470 void AliRDHFCutsDplustoKpipi::SetStandardCutsPP2010() {
 471   //
 472   //STANDARD CUTS USED FOR 2010 pp analysis
 473   //
 474
 475   SetName("DplustoKpipiCutsStandard");
 476   SetTitle("Standard Cuts for D+ analysis");
 477
 478   // PILE UP REJECTION
 479   SetOptPileup(AliRDHFCuts::kRejectPileupEvent);
 480
 481   // EVENT CUTS
 482   SetMinVtxContr(1);
 483
 484   AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
 485   esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
 486   //default
 487   esdTrackCuts->SetRequireTPCRefit(kTRUE);
 488   esdTrackCuts->SetRequireITSRefit(kTRUE);
 489   //esdTrackCuts->SetMinNClustersITS(4); // default is 5
 490   esdTrackCuts->SetMinNClustersTPC(70);
 491   esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
 492                                          AliESDtrackCuts::kAny);
 493   // default is kBoth, otherwise kAny
 494   esdTrackCuts->SetMinDCAToVertexXY(0.);
 495   esdTrackCuts->SetPtRange(0.3,1.e10);
 496
 497   AddTrackCuts(esdTrackCuts);
 498
 499
 500   const Int_t nptbins =15;
 501   const Int_t nvars=14;
 502   Float_t ptbins[nptbins+1];
 503   ptbins[0]=0.;
 504   ptbins[1]=1;
 505   ptbins[2]=2.;
 506   ptbins[3]=3.;
 507   ptbins[4]=4.;
 508   ptbins[5]=5.;
 509   ptbins[6]=6.;
 510   ptbins[7]=7.;
 511   ptbins[8]=8.;
 512   ptbins[9]=9.;
 513   ptbins[10]=10.;
 514   ptbins[11]=12.;
 515   ptbins[12]=14.;
 516   ptbins[13]=16.;
 517   ptbins[14]=24.;
 518   ptbins[15]=99999.;
 519
 520
 521   Float_t** anacutsval;
 522   anacutsval=new Float_t*[nvars];
 523
 524   for(Int_t ic=0;ic<nvars;ic++){anacutsval[ic]=new Float_t[nptbins];}
 525
 526   //Double_t cutsDplus[12]={0.2,0.4,0.4,0.,0.,0.01,0.06,0.02,0.,0.85,0.,10000000000.};
 527   for(Int_t ipt=0;ipt<nptbins;ipt++){
 528     anacutsval[0][ipt]=0.2;
 529     anacutsval[3][ipt]=0.;
 530     anacutsval[4][ipt]=0.;
 531     anacutsval[5][ipt]=0.01;
 532     anacutsval[11][ipt]=10000000000.;
 533     }
 534
 535   anacutsval[1][0]=0.3;
 536   anacutsval[1][1]=0.4;
 537   anacutsval[1][2]=0.4;
 538   anacutsval[2][0]=0.3;
 539   anacutsval[2][1]=0.3;
 540   anacutsval[2][2]=0.4;
 541   for(Int_t ipt=3;ipt<nptbins;ipt++){
 542     anacutsval[1][ipt]=0.4;
 543     anacutsval[2][ipt]=0.4;
 544   }
 545
 546   anacutsval[6][0]=0.022100;
 547   anacutsval[6][1]=0.022100;
 548   anacutsval[6][2]=0.034;
 549   anacutsval[6][3]=0.020667;
 550   anacutsval[6][4]=0.020667;
 551   anacutsval[6][5]=0.023333;
 552
 553
 554   anacutsval[7][0]=0.08;
 555   anacutsval[7][1]=0.08;
 556   anacutsval[7][2]=0.09;
 557   anacutsval[7][3]=0.095;
 558   anacutsval[7][4]=0.095;
 559
 560   anacutsval[8][0]=0.5;
 561   anacutsval[8][1]=0.5;
 562   anacutsval[8][2]=1.0;
 563   anacutsval[8][3]=0.5;
 564   anacutsval[8][4]=0.5;
 565
 566
 567   anacutsval[9][0]=0.97;
 568   anacutsval[9][1]=0.936;
 569   anacutsval[9][2]=0.95;
 570   anacutsval[9][3]=0.95;
 571   anacutsval[9][4]= 0.95;
 572   anacutsval[9][5]=0.92;
 573   anacutsval[9][6]=0.92;
 574   anacutsval[9][7]=0.92;
 575   anacutsval[9][8]=0.92;
 576   anacutsval[9][9]=0.90;
 577  for(Int_t ipt=10;ipt<nptbins;ipt++){
 578    anacutsval[9][ipt]=0.90;
 579  }
 580
 581
 582   anacutsval[10][0]=0.0055;
 583   anacutsval[10][1]=0.0055;
 584   anacutsval[10][2]= 0.0028;
 585   anacutsval[10][3]=0.000883;
 586   anacutsval[10][4]=0.000883;
 587
 588
 589   for(Int_t ipt=5;ipt<nptbins;ipt++){
 590     anacutsval[6][ipt]=0.02333;
 591     anacutsval[7][ipt]=0.115;
 592     anacutsval[8][ipt]=0.5;
 593     anacutsval[10][ipt]=0.000883;
 594     }
 595
 596   anacutsval[12][0]=8;
 597   anacutsval[12][1]=8;
 598
 599   anacutsval[13][0]=0.98;
 600   anacutsval[13][1]=0.98;
 601   for(Int_t ipt=2;ipt<nptbins;ipt++){
 602     anacutsval[12][ipt]=0.;
 603     anacutsval[13][ipt]=0.;
 604  }
 605
 606
 607
 608   SetGlobalIndex(nvars,nptbins);
 609   SetPtBins(nptbins+1,ptbins);
 610   SetCuts(nvars,nptbins,anacutsval);
 611   SetUsePID(kTRUE);
 612   SetRemoveDaughtersFromPrim(kTRUE);
 613
 614   PrintAll();
 615
 616   for(Int_t iic=0;iic<nvars;iic++){delete [] anacutsval[iic];}
 617   delete [] anacutsval;
 618   anacutsval=NULL;
 619
 620   return;
 621 }
 622
 623
 624 void AliRDHFCutsDplustoKpipi::SetStandardCutsPbPb2010() {
 625   //
 626   //STANDARD CUTS USED FOR 2010 Pb Pb analysis.... not optimized yet
 627   //
 628
 629   SetName("DplustoKpipiCutsStandard");
 630   SetTitle("Standard Cuts for D+ analysis in PbPb2010 run");
 631
 632   // PILE UP REJECTION
 633   //SetOptPileup(AliRDHFCuts::kRejectPileupEvent);
 634
 635   // EVENT CUTS
 636   SetMinVtxContr(1);
 637
 638
 639   AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
 640   esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
 641   //default
 642   esdTrackCuts->SetRequireTPCRefit(kTRUE);
 643   esdTrackCuts->SetRequireITSRefit(kTRUE);
 644   //esdTrackCuts->SetMinNClustersITS(4); // default is 5
 645   esdTrackCuts->SetMinNClustersTPC(70);
 646   esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
 647                                          AliESDtrackCuts::kAny);
 648   // default is kBoth, otherwise kAny
 649   esdTrackCuts->SetMinDCAToVertexXY(0.);
 650   esdTrackCuts->SetPtRange(0.8,1.e10);
 651
 652   AddTrackCuts(esdTrackCuts);
 653
 654   const Int_t nptbins=10;
 655   Float_t* ptbins;
 656   ptbins=new Float_t[nptbins+1];
 657
 658   ptbins[0]=0.;
 659   ptbins[1]=1.;
 660   ptbins[2]=2.;
 661   ptbins[3]=3.;
 662   ptbins[4]=4.;
 663   ptbins[5]=5.;
 664   ptbins[6]=6.;
 665   ptbins[7]=8.;
 666   ptbins[8]=12.;
 667   ptbins[9]=16.;
 668   ptbins[10]=24.;
 669   const Int_t nvars=14;
 670
 671   Float_t** anacutsval;
 672   anacutsval=new Float_t*[nvars];
 673
 674   for(Int_t ic=0;ic<nvars;ic++){anacutsval[ic]=new Float_t[nptbins];}
 675   //Double_t cutsDplus[12]={0.2,0.4,0.4,0.,0.,0.01,0.06,0.02,0.,0.85,0.,10000000000.};
 676
 677   for(Int_t ipt=0;ipt<nptbins;ipt++){
 678     anacutsval[0][ipt]=0.2;
 679     anacutsval[1][ipt]=0.8;
 680     anacutsval[2][ipt]=0.8;
 681     anacutsval[3][ipt]=0.;
 682     anacutsval[4][ipt]=0.;
 683     anacutsval[5][ipt]=0.01;
 684     anacutsval[11][ipt]=10000000000.;
 685     anacutsval[12][ipt]=0.;
 686     anacutsval[13][ipt]=0.;
 687   }
 688   anacutsval[1][5]=0.9;
 689
 690   anacutsval[6][0]=0.022100;
 691   anacutsval[6][1]=0.022100;
 692   anacutsval[6][2]=0.034;
 693   anacutsval[6][3]=0.020667;
 694   anacutsval[6][4]=0.020667;
 695   anacutsval[6][5]=0.023333;
 696
 697   anacutsval[7][0]=0.08;
 698   anacutsval[7][1]=0.08;
 699   anacutsval[7][2]=0.17;
 700   anacutsval[7][3]=0.14;
 701   anacutsval[7][4]=0.14;
 702   anacutsval[7][5]=0.19;
 703
 704   anacutsval[8][0]=0.8;
 705   anacutsval[8][1]=0.8;
 706   anacutsval[8][2]=1.1;
 707   anacutsval[8][3]=0.5;
 708   anacutsval[8][4]=0.5;
 709   anacutsval[8][5]=0.5;
 710
 711   anacutsval[9][0]=0.995;
 712   anacutsval[9][1]=0.995;
 713   anacutsval[9][2]=0.997;
 714   anacutsval[9][3]=0.998;
 715   anacutsval[9][4]=0.998;
 716   anacutsval[9][5]=0.995;
 717
 718   anacutsval[10][0]=0.0055;
 719   anacutsval[10][1]=0.0055;
 720   anacutsval[10][2]= 0.0028;
 721   anacutsval[10][3]=0.000883;
 722   anacutsval[10][4]=0.000883;
 723   anacutsval[10][5]=0.000883;
 724
 725   anacutsval[12][5]=12.;
 726   anacutsval[13][5]=0.998571;
 727   anacutsval[12][6]=10.;
 728   anacutsval[13][6]=0.997143;
 729
 730   for(Int_t ipt=6;ipt<nptbins;ipt++){
 731     anacutsval[6][ipt]=0.02333;
 732     anacutsval[7][ipt]=0.19;
 733     anacutsval[8][ipt]=2.0;
 734     anacutsval[9][ipt]=0.997;
 735     anacutsval[10][ipt]=0.000883;
 736   }
 737   anacutsval[7][6]=0.14;
 738   anacutsval[9][6]=0.995;
 739
 740   SetPtBins(nptbins+1,ptbins);
 741   SetCuts(nvars,nptbins,anacutsval);
 742   SetUsePID(kTRUE);
 743   SetMinCentrality(1E-10);
 744   SetMaxCentrality(20.);
 745   SetUseCentrality(AliRDHFCuts::kCentV0M);
 746   SetRemoveDaughtersFromPrim(kFALSE);
 747
 748   PrintAll();
 749
 750   for(Int_t iic=0;iic<nvars;iic++){delete [] anacutsval[iic];}
 751   delete [] anacutsval;
 752   anacutsval=NULL;
 753
 754   delete [] ptbins;
 755   ptbins=NULL;
 756
 757   return;
 758 }
 759