PWGHF/vertexingHF/AliRDHFCutsDstoKKpi.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 Ds->KKpi
  21 //
  22 // Author: A.Dainese, andrea.dainese@pd.infn.it
  23 /////////////////////////////////////////////////////////////
  24
  25 #include <TDatabasePDG.h>
  26 #include <Riostream.h>
  27
  28 #include "AliRDHFCutsDstoKKpi.h"
  29 #include "AliAODRecoDecayHF3Prong.h"
  30 #include "AliAODTrack.h"
  31 #include "AliESDtrack.h"
  32
  33 using std::cout;
  34 using std::endl;
  35
  36 ClassImp(AliRDHFCutsDstoKKpi)
  37
  38 //--------------------------------------------------------------------------
  39 AliRDHFCutsDstoKKpi::AliRDHFCutsDstoKKpi(const char* name) :
  40 AliRDHFCuts(name),
  41   fCutOnResonances(kTRUE),
  42   fPidOption(0),
  43   fMaxPtStrongPid(0.),
  44   fMaxPStrongPidK(0.),
  45   fMaxPStrongPidpi(0.),
  46   fDistToMaxProb(0.01),
  47   fBayesThreshold(0.05),
  48   fWeightKKpi(1.),
  49   fWeightpiKK(1.)
  50 {
  51   //
  52   // Default Constructor
  53   //
  54   Int_t nvars=20;
  55   SetNVars(nvars);
  56   TString varNames[20]={"inv. mass [GeV]",
  57                         "pTK [GeV/c]",
  58                         "pTPi [GeV/c]",
  59                         "d0K [cm]",
  60                         "d0Pi [cm]",
  61                         "dist12 [cm]",
  62                         "sigmavert [cm]",
  63                         "decLen [cm]",
  64                         "ptMax [GeV/c]",
  65                         "cosThetaPoint",
  66                         "Sum d0^2 (cm^2)",
  67                         "dca [cm]",
  68                         "inv. mass (Mphi-MKK) [GeV]",
  69                         "inv. mass (MKo*-MKpi) [GeV]",
  70                         "Abs(CosineKpiPhiRFrame)^3",
  71                         "CosPiDsLabFrame",
  72                         "decLenXY [cm]"
  73                         "NormdecLen",
  74                         "NormdecLenXY [cm]",
  75                         "cosThetaPointXY"};
  76
  77   Bool_t isUpperCut[20]={kTRUE,
  78                          kFALSE,
  79                          kFALSE,
  80                          kFALSE,
  81                          kFALSE,
  82                          kFALSE,
  83                          kTRUE,
  84                          kFALSE,
  85                          kFALSE,
  86                          kFALSE,
  87                          kFALSE,
  88                          kTRUE,
  89                          kTRUE,
  90                          kTRUE,
  91                          kFALSE,
  92                          kTRUE,
  93                          kFALSE,
  94                          kFALSE,
  95                          kFALSE,
  96                          kFALSE};
  97   SetVarNames(20,varNames,isUpperCut);
  98   Bool_t forOpt[20]={kFALSE,
  99                     kFALSE,
 100                     kFALSE,
 101                     kFALSE,
 102                     kFALSE,
 103                     kFALSE,
 104                     kTRUE,
 105                     kTRUE,
 106                     kTRUE,
 107                     kTRUE,
 108                     kTRUE,
 109                     kFALSE,
 110                     kTRUE,
 111                     kTRUE,
 112                     kFALSE,
 113                     kFALSE,
 114                     kTRUE,
 115                     kTRUE,
 116                     kTRUE,
 117                     kTRUE};
 118
 119   SetVarsForOpt(11,forOpt);
 120   Float_t limits[2]={0,999999999.};
 121   SetPtBins(2,limits);
 122   if(fPidHF)delete fPidHF;
 123   fPidHF=new AliAODPidHF();
 124   Double_t plim[2]={0.6,0.8};
 125   Double_t nsigma[5]={2.,1.,2.,3.,0.};
 126
 127   fPidHF->SetPLimit(plim);
 128   fPidHF->SetAsym(kTRUE);
 129   fPidHF->SetSigma(nsigma);
 130   fPidHF->SetMatch(1);
 131   fPidHF->SetTPC(1);
 132   fPidHF->SetTOF(1);
 133   fPidHF->SetITS(0);
 134   fPidHF->SetTRD(0);
 135   fPidHF->SetCompat(kTRUE);
 136
 137 }
 138 //--------------------------------------------------------------------------
 139 AliRDHFCutsDstoKKpi::AliRDHFCutsDstoKKpi(const AliRDHFCutsDstoKKpi &source) :
 140   AliRDHFCuts(source),
 141   fCutOnResonances(source.fCutOnResonances),
 142   fPidOption(source.fPidOption),
 143   fMaxPtStrongPid(source.fMaxPtStrongPid),
 144   fMaxPStrongPidK(source.fMaxPStrongPidK),
 145   fMaxPStrongPidpi(source.fMaxPStrongPidpi),
 146   fDistToMaxProb(source.fDistToMaxProb),
 147   fBayesThreshold(source.fBayesThreshold),
 148   fWeightKKpi(source.fWeightKKpi),
 149   fWeightpiKK(source.fWeightpiKK)
 150 {
 151   //
 152   // Copy constructor
 153   //
 154
 155 }
 156 //--------------------------------------------------------------------------
 157 AliRDHFCutsDstoKKpi &AliRDHFCutsDstoKKpi::operator=(const AliRDHFCutsDstoKKpi &source)
 158 {
 159   //
 160   // assignment operator
 161   //
 162   if(&source == this) return *this;
 163
 164   AliRDHFCuts::operator=(source);
 165
 166   fCutOnResonances=source.fCutOnResonances;
 167   fPidOption=source.fPidOption;
 168   fMaxPtStrongPid=source.fMaxPtStrongPid;
 169   fMaxPStrongPidK=source.fMaxPStrongPidK;
 170   fMaxPStrongPidpi=source.fMaxPStrongPidpi;
 171   fDistToMaxProb=source.fDistToMaxProb;
 172   fBayesThreshold=source.fBayesThreshold;
 173   fWeightKKpi=source.fWeightKKpi;
 174   fWeightpiKK=source.fWeightpiKK;
 175
 176   return *this;
 177 }
 178
 179
 180 //---------------------------------------------------------------------------
 181 void AliRDHFCutsDstoKKpi::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters,AliAODEvent *aod) {
 182   //
 183   // Fills in vars the values of the variables
 184   //
 185
 186   if(nvars!=fnVarsForOpt) {
 187     printf("AliRDHFCutsDstoKKpi::GetCutsVarsForOpt: wrong number of variables\n");
 188     return;
 189   }
 190
 191   AliAODRecoDecayHF3Prong *dd = (AliAODRecoDecayHF3Prong*)d;
 192
 193   //recalculate vertex w/o daughters
 194   Bool_t cleanvtx=kFALSE;
 195   AliAODVertex *origownvtx=0x0;
 196   if(fRemoveDaughtersFromPrimary) {
 197     if(dd->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*dd->GetOwnPrimaryVtx());
 198     cleanvtx=kTRUE;
 199     if(!RecalcOwnPrimaryVtx(dd,aod)) {
 200       CleanOwnPrimaryVtx(dd,aod,origownvtx);
 201       cleanvtx=kFALSE;
 202     }
 203   }
 204
 205   Int_t iter=-1;
 206   if(fVarsForOpt[0]){
 207     iter++;
 208     if(TMath::Abs(pdgdaughters[0])==321){
 209       vars[iter]=dd->InvMassDsKKpi();
 210     }else{
 211       vars[iter]=dd->InvMassDspiKK();
 212     }
 213   }
 214   if(fVarsForOpt[1]){
 215     iter++;
 216     Float_t minPtDau=99999.;
 217     for(Int_t iprong=0;iprong<3;iprong++){
 218       if(TMath::Abs(pdgdaughters[iprong])==321 &&
 219          dd->PtProng(iprong)<minPtDau) minPtDau=dd->PtProng(iprong);
 220     }
 221     vars[iter]=minPtDau;
 222   }
 223   if(fVarsForOpt[2]){
 224     iter++;
 225     for(Int_t iprong=0;iprong<3;iprong++){
 226       if(TMath::Abs(pdgdaughters[iprong])==211) {
 227         vars[iter]=dd->PtProng(iprong);
 228       }
 229     }
 230   }
 231   if(fVarsForOpt[3]){
 232     iter++;
 233     Float_t minImpParDau=99999.;
 234     for(Int_t iprong=0;iprong<3;iprong++){
 235       if(TMath::Abs(pdgdaughters[iprong])==321 &&
 236          dd->Getd0Prong(iprong)<minImpParDau) minImpParDau=dd->Getd0Prong(iprong);
 237     }
 238     vars[iter]=minImpParDau;
 239   }
 240   if(fVarsForOpt[4]){
 241     iter++;
 242     for(Int_t iprong=0;iprong<3;iprong++){
 243       if(TMath::Abs(pdgdaughters[iprong])==211) {
 244         vars[iter]=dd->Getd0Prong(iprong);
 245       }
 246     }
 247   }
 248   if(fVarsForOpt[5]){
 249     iter++;
 250     Float_t minDistPair=TMath::Min(dd->GetDist12toPrim(),dd->GetDist23toPrim());
 251     vars[iter]=minDistPair;
 252   }
 253   if(fVarsForOpt[6]){
 254     iter++;
 255     vars[iter]=dd->GetSigmaVert(aod);
 256   }
 257   if(fVarsForOpt[7]){
 258     iter++;
 259     vars[iter] = dd->DecayLength();
 260   }
 261   if(fVarsForOpt[8]){
 262     iter++;
 263     Float_t ptmax=0;
 264     for(Int_t i=0;i<3;i++){
 265       if(dd->PtProng(i)>ptmax)ptmax=dd->PtProng(i);
 266     }
 267     vars[iter]=ptmax;
 268   }
 269   if(fVarsForOpt[9]){
 270     iter++;
 271     vars[iter]=dd->CosPointingAngle();
 272   }
 273   if(fVarsForOpt[10]){
 274     iter++;
 275     vars[iter]=dd->Getd0Prong(0)*dd->Getd0Prong(0)+dd->Getd0Prong(1)*dd->Getd0Prong(1)+dd->Getd0Prong(2)*dd->Getd0Prong(2);
 276   }
 277   if(fVarsForOpt[11]){
 278     iter++;
 279     Float_t maxDCA=0.;
 280     for(Int_t i=0;i<3;i++){
 281       if(d->GetDCA(i)>maxDCA) maxDCA=d->GetDCA(i);
 282     }
 283     vars[iter]=maxDCA;
 284   }
 285   if(fVarsForOpt[12]){
 286     iter++;
 287     Double_t mPDGPhi = TDatabasePDG::Instance()->GetParticle(333)->Mass();
 288     if(TMath::Abs(pdgdaughters[0])==321){
 289
 290       Double_t phimass01=d->InvMass2Prongs(0,1,321,321);
 291        vars[iter]=TMath::Abs(phimass01-mPDGPhi);
 292        // vars[iter]=dd->InvMass2Prongs(0,1,321,321);
 293     }else{
 294       Double_t phimass12=d->InvMass2Prongs(1,2,321,321);
 295        vars[iter]=TMath::Abs(phimass12-mPDGPhi);
 296        // vars[iter]=dd->InvMass2Prongs(1,2,321,321);
 297     }
 298   }
 299   if(fVarsForOpt[13]){
 300     iter++;
 301     Double_t mPDGK0star = TDatabasePDG::Instance()->GetParticle(313)->Mass();
 302     if(TMath::Abs(pdgdaughters[0])==321){
 303
 304       Double_t mass12kpi=d->InvMass2Prongs(1,2,321,211);
 305       vars[iter]=TMath::Abs(mass12kpi-mPDGK0star);
 306       //              vars[iter]=dd->InvMass2Prongs(1,2,321,211);
 307     }else{
 308       Double_t mass01pik=d->InvMass2Prongs(0,1,211,321);
 309       vars[iter]=TMath::Abs(mass01pik-mPDGK0star);
 310       //        vars[iter]=dd->InvMass2Prongs(0,1,211,321);
 311     }
 312   }
 313   if(fVarsForOpt[14]){
 314     iter++;
 315     if(TMath::Abs(pdgdaughters[0])==321){
 316       vars[iter]=dd->CosPiKPhiRFrameKKpi();
 317     }else{
 318       vars[iter]=dd->CosPiKPhiRFramepiKK();
 319     }
 320   }
 321   if(fVarsForOpt[15]){
 322     iter++;
 323     if(TMath::Abs(pdgdaughters[0])==321){
 324       vars[iter]=dd->CosPiDsLabFrameKKpi();
 325     }else{
 326       vars[iter]=dd->CosPiDsLabFramepiKK();
 327     }
 328   }
 329
 330   if(fVarsForOpt[16]){
 331     iter++;
 332     vars[iter]=dd->DecayLengthXY();
 333   }
 334
 335   if(fVarsForOpt[17]){
 336     iter++;
 337     vars[iter]=dd->NormalizedDecayLength();
 338   }
 339
 340   if(fVarsForOpt[18]){
 341     iter++;
 342     vars[iter]=dd->NormalizedDecayLengthXY();
 343   }
 344
 345   if(fVarsForOpt[19]){
 346     iter++;
 347     vars[iter]=dd->CosPointingAngleXY();
 348   }
 349
 350   if(cleanvtx)CleanOwnPrimaryVtx(dd,aod,origownvtx);
 351   return;
 352 }
 353 //---------------------------------------------------------------------------
 354 Bool_t AliRDHFCutsDstoKKpi::IsInFiducialAcceptance(Double_t pt, Double_t y) const
 355 {
 356   //
 357   // Checking if Ds is in fiducial acceptance region
 358   //
 359
 360   if(fMaxRapidityCand>-998.){
 361     if(TMath::Abs(y) > fMaxRapidityCand) return kFALSE;
 362     else return kTRUE;
 363   }
 364
 365   if(pt > 5.) {
 366     // applying cut for pt > 5 GeV
 367     AliDebug(2,Form("pt of Ds = %f (> 5), cutting at |y| < 0.8",pt));
 368     if (TMath::Abs(y) > 0.8) return kFALSE;
 369
 370   } else {
 371     // appliying smooth cut for pt < 5 GeV
 372     Double_t maxFiducialY = -0.2/15*pt*pt+1.9/15*pt+0.5;
 373     Double_t minFiducialY = 0.2/15*pt*pt-1.9/15*pt-0.5;
 374     AliDebug(2,Form("pt of Ds = %f (< 5), cutting  according to the fiducial zone [%f, %f]\n",pt,minFiducialY,maxFiducialY));
 375     if (y < minFiducialY || y > maxFiducialY) return kFALSE;
 376   }
 377
 378   return kTRUE;
 379 }
 380
 381 //---------------------------------------------------------------------------
 382 Int_t AliRDHFCutsDstoKKpi::IsSelectedPIDBayes(AliAODRecoDecayHF *rd) {
 383   Int_t retCode=3;
 384   Bool_t okKKpi=kTRUE;
 385   Bool_t okpiKK=kTRUE;
 386   if(!fUsePID || !rd) return retCode;
 387   if(!fPidHF){
 388     AliWarning("AliAODPidHF not created!");
 389     return retCode;
 390   }
 391   if(fPidOption!=kBayesianMaxProb && fPidOption!=kBayesianThreshold && fPidOption!=kBayesianWeights){
 392     AliWarning("Wrong call to Bayesian PID");
 393     return retCode;
 394   }
 395
 396   AliPIDCombined* copid=fPidHF->GetPidCombined();
 397   copid->SetDetectorMask(AliPIDResponse::kDetTPC | AliPIDResponse::kDetTOF);
 398   AliPIDResponse* pidres=fPidHF->GetPidResponse();
 399   Double_t bayesProb[AliPID::kSPECIES];
 400   Int_t nKaons=0;
 401   Int_t nNotKaons=0;
 402   Int_t sign= rd->GetCharge();
 403   fWeightKKpi=1.;
 404   fWeightpiKK=1.;
 405   for(Int_t iDaught=0; iDaught<3; iDaught++){
 406     AliAODTrack *track=(AliAODTrack*)rd->GetDaughter(iDaught);
 407
 408     Int_t isPion=0;
 409     Int_t isKaon=0;
 410     Int_t isProton=0;
 411     UInt_t usedDet=copid->ComputeProbabilities(track,pidres,bayesProb);
 412     if(usedDet!=0){
 413       if(fPidOption==kBayesianMaxProb){
 414         Double_t maxProb=TMath::MaxElement(AliPID::kSPECIES,bayesProb);
 415         if(TMath::Abs(maxProb-bayesProb[AliPID::kPion])<fDistToMaxProb) isPion=1;
 416         else isPion=-1;
 417         if(TMath::Abs(maxProb-bayesProb[AliPID::kKaon])<fDistToMaxProb) isKaon=1;
 418         else isKaon=-1;
 419         if(TMath::Abs(maxProb-bayesProb[AliPID::kProton])<fDistToMaxProb) isProton=1;
 420         else isProton=-1;
 421       }
 422       if(fPidOption==kBayesianThreshold){
 423         if(bayesProb[AliPID::kPion]>fBayesThreshold) isPion=1;
 424         else isPion=-1;
 425         if(bayesProb[AliPID::kKaon]>fBayesThreshold) isKaon=1;
 426         else isKaon=-1;
 427         if(bayesProb[AliPID::kProton]>fBayesThreshold) isProton=1;
 428         else isProton=-1;
 429       }
 430     }
 431     if(fPidOption==kBayesianWeights){ // store the probabilities in the case kBayesianWeights
 432       if(iDaught==0){
 433         fWeightKKpi*=bayesProb[AliPID::kKaon];
 434         fWeightpiKK*=bayesProb[AliPID::kPion];
 435       }else if(iDaught==1){
 436         fWeightKKpi*=bayesProb[AliPID::kKaon];
 437         fWeightpiKK*=bayesProb[AliPID::kKaon];
 438       }else if(iDaught==2){
 439         fWeightKKpi*=bayesProb[AliPID::kPion];
 440         fWeightpiKK*=bayesProb[AliPID::kKaon];
 441       }
 442     }else{ // selection for the other cases
 443       if(isProton>0 &&  isKaon<0  && isPion<0) return 0;
 444       if(sign!=track->Charge()){// must be kaon
 445         if(isKaon<0) return 0;
 446       }
 447       if(isKaon>0 && isPion<0) nKaons++;
 448       if(isKaon<0) nNotKaons++;
 449       if(iDaught==0){
 450         if(isKaon<0) okKKpi=kFALSE;
 451         if(isPion<0) okpiKK=kFALSE;
 452       }else if(iDaught==2){
 453         if(isKaon<0) okpiKK=kFALSE;
 454         if(isPion<0) okKKpi=kFALSE;
 455       }
 456     }
 457   }
 458   if(fPidOption==kBayesianWeights) return retCode;
 459
 460   if(nKaons>2)return 0;
 461   if(nNotKaons>1) return 0;
 462
 463   if(!okKKpi) retCode-=1;
 464   if(!okpiKK) retCode-=2;
 465
 466   return retCode;
 467 }
 468
 469 //---------------------------------------------------------------------------
 470 Int_t AliRDHFCutsDstoKKpi::IsSelectedPID(AliAODRecoDecayHF *rd) {
 471   // PID selection
 472   // return values: 0->NOT OK, 1->OK as KKpi, 2->OK as piKK, 3->OK as both
 473   Int_t retCode=3;
 474   Bool_t okKKpi=kTRUE;
 475   Bool_t okpiKK=kTRUE;
 476   if(!fUsePID || !rd) return retCode;
 477   if(!fPidHF){
 478     AliWarning("AliAODPidHF not created!");
 479     return retCode;
 480   }
 481   if(fPidOption==kBayesianMaxProb || fPidOption==kBayesianThreshold || fPidOption==kBayesianWeights){
 482     // call method for Bayesian probability
 483     return IsSelectedPIDBayes(rd);
 484   }
 485
 486   Double_t origCompatTOF=fPidHF->GetPCompatTOF();
 487   Double_t origThreshTPC=fPidHF->GetPtThresholdTPC();
 488   if(fPidOption==kStrong){
 489     fPidHF->SetPCompatTOF(999999.);
 490     fPidHF->SetPtThresholdTPC(999999.);
 491   }
 492
 493   Int_t nKaons=0;
 494   Int_t nNotKaons=0;
 495   Int_t sign= rd->GetCharge();
 496   for(Int_t iDaught=0; iDaught<3; iDaught++){
 497     AliAODTrack *track=(AliAODTrack*)rd->GetDaughter(iDaught);
 498
 499     Int_t isPion=fPidHF->MakeRawPid(track,AliPID::kPion);
 500     Int_t isKaon=fPidHF->MakeRawPid(track,AliPID::kKaon);
 501     Int_t isProton=fPidHF->MakeRawPid(track,AliPID::kProton);
 502
 503     if(isProton>0 &&  isKaon<0  && isPion<0){
 504       fPidHF->SetPCompatTOF(origCompatTOF);
 505       fPidHF->SetPtThresholdTPC(origThreshTPC);
 506       return 0;
 507     }
 508     if(sign!=track->Charge()){// must be kaon
 509       if(isKaon<0){
 510         fPidHF->SetPCompatTOF(origCompatTOF);
 511         fPidHF->SetPtThresholdTPC(origThreshTPC);
 512         return 0;
 513       }
 514       if(fPidOption==kStrong && rd->Pt()<fMaxPtStrongPid && isKaon<=0){
 515         fPidHF->SetPCompatTOF(origCompatTOF);
 516         fPidHF->SetPtThresholdTPC(origThreshTPC);
 517         return 0;
 518       }
 519       if(fPidOption==kStrongPDep && rd->Pt()<fMaxPtStrongPid){
 520         if(isKaon<=0 && track->P()<fMaxPStrongPidK) return 0;
 521       }
 522     }
 523
 524     if(isKaon>0 && isPion<0) nKaons++;
 525     if(isKaon<0) nNotKaons++;
 526     if(iDaught==0){
 527       if(isKaon<0) okKKpi=kFALSE;
 528       if(isPion<0) okpiKK=kFALSE;
 529       if(fPidOption==kStrong && rd->Pt()<fMaxPtStrongPid){
 530         if(isKaon<=0) okKKpi=kFALSE;
 531         if(isPion<=0) okpiKK=kFALSE;
 532       }
 533       if(fPidOption==kStrongPDep && rd->Pt()<fMaxPtStrongPid){
 534         if(isKaon<=0 && track->P()<fMaxPStrongPidK) okKKpi=kFALSE;
 535         if(isPion<=0 && track->P()<fMaxPStrongPidpi) okpiKK=kFALSE;
 536       }
 537     }
 538     else if(iDaught==2){
 539       if(isKaon<0) okpiKK=kFALSE;
 540       if(isPion<0) okKKpi=kFALSE;
 541        if(fPidOption==kStrong && rd->Pt()<fMaxPtStrongPid){
 542          if(isKaon<=0) okpiKK=kFALSE;
 543          if(isPion<=0) okKKpi=kFALSE;
 544       }
 545       if(fPidOption==kStrongPDep && rd->Pt()<fMaxPtStrongPid){
 546         if(isKaon<=0 && track->P()<fMaxPStrongPidK) okpiKK=kFALSE;
 547         if(isPion<=0 && track->P()<fMaxPStrongPidpi) okKKpi=kFALSE;
 548       }
 549     }
 550   }
 551
 552   fPidHF->SetPCompatTOF(origCompatTOF);
 553   fPidHF->SetPtThresholdTPC(origThreshTPC);
 554
 555   if(nKaons>2)return 0;
 556   if(nNotKaons>1) return 0;
 557
 558   if(!okKKpi) retCode-=1;
 559   if(!okpiKK) retCode-=2;
 560
 561   return retCode;
 562 }
 563
 564 //---------------------------------------------------------------------------
 565 Int_t AliRDHFCutsDstoKKpi::IsSelected(TObject* obj,Int_t selectionLevel, AliAODEvent* aod) {
 566   //
 567   // Apply selection
 568   //
 569
 570   if(!fCutsRD){
 571     cout<<"Cut matrix not inizialized. Exit..."<<endl;
 572     return 0;
 573   }
 574   //PrintAll();
 575   AliAODRecoDecayHF3Prong* d=(AliAODRecoDecayHF3Prong*)obj;
 576
 577   if(!d){
 578     cout<<"AliAODRecoDecayHF3Prong null"<<endl;
 579     return 0;
 580   }
 581
 582   if(fKeepSignalMC) if(IsSignalMC(d,aod,431)) return 3;
 583
 584   Double_t ptD=d->Pt();
 585   if(ptD<fMinPtCand) return 0;
 586   if(ptD>fMaxPtCand) return 0;
 587
 588   if(fUseTrackSelectionWithFilterBits && d->HasBadDaughters()) return 0;
 589
 590
 591   // selection on daughter tracks
 592   if(selectionLevel==AliRDHFCuts::kAll ||
 593      selectionLevel==AliRDHFCuts::kTracks) {
 594     if(!AreDaughtersSelected(d)) return 0;
 595   }
 596
 597
 598
 599
 600   // selection on candidate
 601   if(selectionLevel==AliRDHFCuts::kAll ||
 602      selectionLevel==AliRDHFCuts::kCandidate) {
 603     //recalculate vertex w/o daughters
 604     AliAODVertex *origownvtx=0x0;
 605     if(fRemoveDaughtersFromPrimary) {
 606       if(d->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*d->GetOwnPrimaryVtx());
 607       if(!RecalcOwnPrimaryVtx(d,aod)) {
 608         CleanOwnPrimaryVtx(d,aod,origownvtx);
 609         return 0;
 610       }
 611     }
 612
 613     Int_t okDsKKpi=1;
 614     Int_t okDspiKK=1;
 615     Int_t okMassPhiKKpi=0;
 616     Int_t okMassPhipiKK=0;
 617     Int_t okMassK0starKKpi=0;
 618     Int_t okMassK0starpiKK=0;
 619     Int_t okDsPhiKKpi=0;
 620     Int_t okDsPhipiKK=0;
 621     Int_t okDsK0starKKpi=0;
 622     Int_t okDsK0starpiKK=0;
 623
 624     Double_t pt=d->Pt();
 625     Int_t ptbin=PtBin(pt);
 626     if (ptbin==-1) {
 627       CleanOwnPrimaryVtx(d,aod,origownvtx);
 628       return 0;
 629     }
 630
 631     Double_t mDsPDG = TDatabasePDG::Instance()->GetParticle(431)->Mass();
 632     Double_t mDsKKpi=d->InvMassDsKKpi();
 633     Double_t mDspiKK=d->InvMassDspiKK();
 634     if(TMath::Abs(mDsKKpi-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDsKKpi = 0;
 635     if(TMath::Abs(mDspiKK-mDsPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) okDspiKK = 0;
 636     if(!okDsKKpi && !okDspiKK){
 637       CleanOwnPrimaryVtx(d,aod,origownvtx);
 638       return 0;
 639     }
 640
 641
 642
 643     // cuts on resonant decays (via Phi or K0*)
 644     if(fCutOnResonances){
 645       Double_t mPhiPDG = TDatabasePDG::Instance()->GetParticle(333)->Mass();
 646       Double_t mK0starPDG = TDatabasePDG::Instance()->GetParticle(313)->Mass();
 647       if(okDsKKpi){
 648         Double_t mass01phi=d->InvMass2Prongs(0,1,321,321);
 649         Double_t mass12K0s=d->InvMass2Prongs(1,2,321,211);
 650         if(TMath::Abs(mass01phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhiKKpi=1;
 651         if(TMath::Abs(mass12K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0starKKpi = 1;
 652         if(!okMassPhiKKpi && !okMassK0starKKpi) okDsKKpi=0;
 653         if(okMassPhiKKpi) okDsPhiKKpi=1;
 654         if(okMassK0starKKpi) okDsK0starKKpi=1;
 655       }
 656       if(okDspiKK){
 657         Double_t mass01K0s=d->InvMass2Prongs(0,1,211,321);
 658         Double_t mass12phi=d->InvMass2Prongs(1,2,321,321);
 659         if(TMath::Abs(mass01K0s-mK0starPDG)<fCutsRD[GetGlobalIndex(13,ptbin)]) okMassK0starpiKK = 1;
 660         if(TMath::Abs(mass12phi-mPhiPDG)<fCutsRD[GetGlobalIndex(12,ptbin)]) okMassPhipiKK=1;
 661         if(!okMassPhipiKK && !okMassK0starpiKK) okDspiKK=0;
 662         if(okMassPhipiKK) okDsPhipiKK=1;
 663         if(okMassK0starpiKK) okDsK0starpiKK=1;
 664       }
 665       if(!okDsKKpi && !okDspiKK){
 666         CleanOwnPrimaryVtx(d,aod,origownvtx);
 667         return 0;
 668       }
 669     }
 670
 671     // Cuts on track pairs
 672     for(Int_t i=0;i<3;i++){
 673       if(d->GetDCA(i)>fCutsRD[GetGlobalIndex(11,ptbin)]){
 674         CleanOwnPrimaryVtx(d,aod,origownvtx);
 675         return 0;
 676       }
 677     }
 678     if(d->GetDist12toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)] ||
 679        d->GetDist23toPrim()<fCutsRD[GetGlobalIndex(5,ptbin)]){
 680       CleanOwnPrimaryVtx(d,aod,origownvtx);
 681       return 0;
 682     }
 683
 684
 685
 686     //single track
 687     if(TMath::Abs(d->Pt2Prong(1)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
 688        TMath::Abs(d->Getd0Prong(1))<fCutsRD[GetGlobalIndex(3,ptbin)]){
 689       CleanOwnPrimaryVtx(d,aod,origownvtx);
 690       return 0;
 691     }
 692
 693     if(okDsKKpi){
 694       if(TMath::Abs(d->Pt2Prong(0)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
 695          TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDsKKpi=0;
 696       if(TMath::Abs(d->Pt2Prong(2)) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] ||
 697          TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDsKKpi=0;
 698     }
 699     if(okDspiKK){
 700       if(TMath::Abs(d->Pt2Prong(0)) < fCutsRD[GetGlobalIndex(2,ptbin)]*fCutsRD[GetGlobalIndex(2,ptbin)] ||
 701          TMath::Abs(d->Getd0Prong(0))<fCutsRD[GetGlobalIndex(4,ptbin)]) okDspiKK=0;
 702       if(TMath::Abs(d->Pt2Prong(2)) < fCutsRD[GetGlobalIndex(1,ptbin)]*fCutsRD[GetGlobalIndex(1,ptbin)] ||
 703          TMath::Abs(d->Getd0Prong(2))<fCutsRD[GetGlobalIndex(3,ptbin)]) okDspiKK=0;
 704     }
 705     if(!okDsKKpi && !okDspiKK){
 706       CleanOwnPrimaryVtx(d,aod,origownvtx);
 707       return 0;
 708     }
 709
 710     // Cuts on candidate triplet
 711
 712
 713     if(d->CosPointingAngle()< fCutsRD[GetGlobalIndex(9,ptbin)]){
 714       CleanOwnPrimaryVtx(d,aod,origownvtx);
 715       return 0;
 716     }
 717
 718     if(d->Pt2Prong(0)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] &&
 719        d->Pt2Prong(1)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)] &&
 720        d->Pt2Prong(2)<fCutsRD[GetGlobalIndex(8,ptbin)]*fCutsRD[GetGlobalIndex(8,ptbin)]) {
 721       CleanOwnPrimaryVtx(d,aod,origownvtx);
 722       return 0;
 723     }
 724
 725     if(d->DecayLength2()<fCutsRD[GetGlobalIndex(7,ptbin)]*fCutsRD[GetGlobalIndex(7,ptbin)]){
 726       CleanOwnPrimaryVtx(d,aod,origownvtx);
 727       return 0;
 728     }
 729
 730
 731     Double_t sum2=d->Getd0Prong(0)*d->Getd0Prong(0)+d->Getd0Prong(1)*d->Getd0Prong(1)+d->Getd0Prong(2)*d->Getd0Prong(2);
 732     if(sum2<fCutsRD[GetGlobalIndex(10,ptbin)]){
 733       CleanOwnPrimaryVtx(d,aod,origownvtx);
 734       return 0;
 735     }
 736
 737
 738     //sec vert
 739     Double_t sigmavert=d->GetSigmaVert(aod);
 740     if(sigmavert>fCutsRD[GetGlobalIndex(6,ptbin)]){
 741       CleanOwnPrimaryVtx(d,aod,origownvtx);
 742       return 0;
 743     }
 744
 745     // decay length XY
 746     if(d->DecayLengthXY()<fCutsRD[GetGlobalIndex(16,ptbin)]){
 747       CleanOwnPrimaryVtx(d,aod,origownvtx);
 748       return 0;
 749     }
 750
 751     //norm decay length
 752     if(d->NormalizedDecayLength()<fCutsRD[GetGlobalIndex(17,ptbin)]){
 753       CleanOwnPrimaryVtx(d,aod,origownvtx);
 754       return 0;
 755     }
 756
 757     //norm decay length XY
 758     if(d->NormalizedDecayLengthXY()<fCutsRD[GetGlobalIndex(18,ptbin)]){
 759       CleanOwnPrimaryVtx(d,aod,origownvtx);
 760       return 0;
 761     }
 762
 763     //cos pointing XY
 764     if(d->CosPointingAngleXY()<fCutsRD[GetGlobalIndex(19,ptbin)]){
 765       CleanOwnPrimaryVtx(d,aod,origownvtx);
 766       return 0;
 767     }
 768
 769
 770     if(okDsKKpi){
 771       Double_t cosPiKPhiRFKKpi=d->CosPiKPhiRFrameKKpi();
 772       Double_t kincutPiKPhiKKpi=TMath::Abs(cosPiKPhiRFKKpi*cosPiKPhiRFKKpi*cosPiKPhiRFKKpi);
 773       if(kincutPiKPhiKKpi<fCutsRD[GetGlobalIndex(14,ptbin)]) okDsKKpi=0;
 774     }
 775     if(okDspiKK){
 776       Double_t cosPiKPhiRFpiKK=d->CosPiKPhiRFramepiKK();
 777       Double_t kincutPiKPhipiKK=TMath::Abs(cosPiKPhiRFpiKK*cosPiKPhiRFpiKK*cosPiKPhiRFpiKK);
 778       if(kincutPiKPhipiKK<fCutsRD[GetGlobalIndex(14,ptbin)]) okDspiKK=0;
 779     }
 780     if(!okDsKKpi && !okDspiKK){
 781       CleanOwnPrimaryVtx(d,aod,origownvtx);
 782       return 0;
 783     }
 784
 785
 786
 787     if(okDsKKpi){
 788       Double_t cosPiDsLabFrameKKpi=d->CosPiDsLabFrameKKpi();
 789       if(cosPiDsLabFrameKKpi>fCutsRD[GetGlobalIndex(15,ptbin)]) okDsKKpi=0;
 790     }
 791     if(okDspiKK){
 792       Double_t cosPiDsLabFramepiKK=d->CosPiDsLabFramepiKK();
 793       if(cosPiDsLabFramepiKK>fCutsRD[GetGlobalIndex(15,ptbin)]) okDspiKK=0;
 794     }
 795     if(!okDsKKpi && !okDspiKK){
 796       CleanOwnPrimaryVtx(d,aod,origownvtx);
 797       return 0;
 798     }
 799
 800      // unset recalculated primary vertex when not needed any more
 801     CleanOwnPrimaryVtx(d,aod,origownvtx);
 802
 803
 804
 805     if(!okDsKKpi){
 806       okDsPhiKKpi=0;
 807       okDsK0starKKpi=0;
 808     }
 809     if(!okDspiKK){
 810       okDsPhipiKK=0;
 811       okDsK0starpiKK=0;
 812     }
 813
 814     // PID selection
 815     Int_t returnvaluePID=3;
 816     if(selectionLevel==AliRDHFCuts::kAll ||
 817        selectionLevel==AliRDHFCuts::kCandidate ||
 818        selectionLevel==AliRDHFCuts::kPID) {
 819       returnvaluePID = IsSelectedPID(d);
 820       fIsSelectedPID=returnvaluePID;
 821     }
 822     if(returnvaluePID==0)return 0;
 823
 824     Bool_t okPidDsKKpi=returnvaluePID&1;
 825     Bool_t okPidDspiKK=returnvaluePID&2;
 826     if(!okPidDsKKpi){
 827       okDsPhiKKpi=0;
 828       okDsK0starKKpi=0;
 829     }
 830     if(!okPidDspiKK){
 831       okDsPhipiKK=0;
 832       okDsK0starpiKK=0;
 833     }
 834
 835     if((okPidDsKKpi && okDsKKpi)||(okPidDspiKK && okDspiKK)){
 836       Int_t returnvalue=0;
 837       if(okDsKKpi) returnvalue+=1;
 838       if(okDspiKK) returnvalue+=2;
 839       if(okDsPhiKKpi) returnvalue+=4;
 840       if(okDsPhipiKK) returnvalue+=8;
 841       if(okDsK0starKKpi) returnvalue+=16;
 842       if(okDsK0starpiKK) returnvalue+=32;
 843       return returnvalue;
 844     }else{
 845       return 0;
 846     }
 847   }
 848   return 15;
 849
 850 }
 851
 852 //--------------------------------------------------------------------------
 853
 854 UInt_t AliRDHFCutsDstoKKpi::GetPIDTrackTPCTOFBitMap(AliAODTrack *track) const{
 855
 856   UInt_t bitmap=0;
 857
 858   Double_t sigmaTPCPionHyp=-999.;
 859   Double_t sigmaTPCKaonHyp=-999.;
 860   Double_t sigmaTPCProtonHyp=-999.;
 861   Double_t sigmaTOFPionHyp=-999.;
 862   Double_t sigmaTOFKaonHyp=-999.;
 863   Double_t sigmaTOFProtonHyp=-999.;
 864
 865   Int_t oksigmaTPCPionHyp=fPidHF->GetnSigmaTPC(track,2,sigmaTPCPionHyp);
 866   Int_t oksigmaTPCKaonHyp=fPidHF->GetnSigmaTPC(track,3,sigmaTPCKaonHyp);
 867   Int_t oksigmaTPCProtonHyp=fPidHF->GetnSigmaTPC(track,4,sigmaTPCProtonHyp);
 868   Int_t oksigmaTOFPionHyp=fPidHF->GetnSigmaTOF(track,2,sigmaTOFPionHyp);
 869   Int_t oksigmaTOFKaonHyp=fPidHF->GetnSigmaTOF(track,3,sigmaTOFKaonHyp);
 870   Int_t oksigmaTOFProtonHyp=fPidHF->GetnSigmaTOF(track,4,sigmaTOFProtonHyp);
 871
 872   sigmaTPCPionHyp=TMath::Abs(sigmaTPCPionHyp);
 873   sigmaTPCKaonHyp=TMath::Abs(sigmaTPCKaonHyp);
 874   sigmaTPCProtonHyp=TMath::Abs(sigmaTPCProtonHyp);
 875   sigmaTOFPionHyp=TMath::Abs(sigmaTOFPionHyp);
 876   sigmaTOFKaonHyp=TMath::Abs(sigmaTOFKaonHyp);
 877   sigmaTOFProtonHyp=TMath::Abs(sigmaTOFProtonHyp);
 878
 879  if (oksigmaTPCPionHyp && sigmaTPCPionHyp>0.){
 880     if (sigmaTPCPionHyp<1.) bitmap+=1<<kTPCPionLess1;
 881     else{
 882       if (sigmaTPCPionHyp<2.) bitmap+=1<<kTPCPionMore1Less2;
 883       else {
 884         if (sigmaTPCPionHyp<3.) bitmap+=1<<kTPCPionMore2Less3;
 885         else bitmap+=1<<kTPCPionMore3;
 886       }
 887     }
 888   }
 889
 890   if (oksigmaTPCKaonHyp && sigmaTPCKaonHyp>0.){
 891     if (sigmaTPCKaonHyp<1.) bitmap+=1<<kTPCKaonLess1;
 892     else{
 893       if (sigmaTPCKaonHyp<2.) bitmap+=1<<kTPCKaonMore1Less2;
 894       else {
 895         if (sigmaTPCKaonHyp<3.) bitmap+=1<<kTPCKaonMore2Less3;
 896         else bitmap+=1<<kTPCKaonMore3;
 897       }
 898     }
 899   }
 900
 901   if (oksigmaTPCProtonHyp && sigmaTPCProtonHyp>0.){
 902     if (sigmaTPCProtonHyp<1.) bitmap+=1<<kTPCProtonLess1;
 903     else{
 904       if (sigmaTPCProtonHyp<2.) bitmap+=1<<kTPCProtonMore1Less2;
 905       else {
 906         if (sigmaTPCProtonHyp<3.) bitmap+=1<<kTPCProtonMore2Less3;
 907         else bitmap+=1<<kTPCProtonMore3;
 908       }
 909     }
 910   }
 911
 912   if (oksigmaTOFPionHyp && sigmaTOFPionHyp>0.){
 913     if (sigmaTOFPionHyp<1.) bitmap+=1<<kTOFPionLess1;
 914     else{
 915       if (sigmaTOFPionHyp<2.) bitmap+=1<<kTOFPionMore1Less2;
 916       else {
 917         if (sigmaTOFPionHyp<3.) bitmap+=1<<kTOFPionMore2Less3;
 918         else bitmap+=1<<kTOFPionMore3;
 919       }
 920     }
 921   }
 922
 923   if (oksigmaTOFKaonHyp && sigmaTOFKaonHyp>0.){
 924     if (sigmaTOFKaonHyp<1.) bitmap+=1<<kTOFKaonLess1;
 925     else{
 926       if (sigmaTOFKaonHyp<2.) bitmap+=1<<kTOFKaonMore1Less2;
 927       else {
 928         if (sigmaTOFKaonHyp<3.) bitmap+=1<<kTOFKaonMore2Less3;
 929         else bitmap+=1<<kTOFKaonMore3;
 930       }
 931     }
 932   }
 933
 934   if (oksigmaTOFProtonHyp && sigmaTOFProtonHyp>0.){
 935     if (sigmaTOFProtonHyp<1.) bitmap+=1<<kTOFProtonLess1;
 936     else{
 937       if (sigmaTOFProtonHyp<2.) bitmap+=1<<kTOFProtonMore1Less2;
 938       else {
 939         if (sigmaTOFProtonHyp<3.) bitmap+=1<<kTOFProtonMore2Less3;
 940         else bitmap+=1<<kTOFProtonMore3;
 941       }
 942     }
 943   }
 944
 945
 946
 947   return bitmap;
 948
 949 }
 950
 951
 952 //---------------------------------------------------------------------------
 953
 954 void AliRDHFCutsDstoKKpi::SetStandardCutsPP2010() {
 955   //
 956   //STANDARD CUTS USED FOR 2010 pp analysis
 957   //
 958
 959   SetName("DstoKKpiCutsStandard");
 960   SetTitle("Standard Cuts for D+s analysis");
 961
 962   // PILE UP REJECTION
 963   SetOptPileup(AliRDHFCuts::kRejectPileupEvent);
 964
 965   // EVENT CUTS
 966   SetMinVtxContr(1);
 967
 968   AliESDtrackCuts* esdTrackCuts=new AliESDtrackCuts();
 969   esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
 970   //default
 971   esdTrackCuts->SetRequireTPCRefit(kTRUE);
 972   esdTrackCuts->SetRequireITSRefit(kTRUE);
 973   //esdTrackCuts->SetMinNClustersITS(4); // default is 5
 974   esdTrackCuts->SetMinNClustersTPC(70);
 975   esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
 976                                          AliESDtrackCuts::kAny);
 977   // default is kBoth, otherwise kAny
 978   esdTrackCuts->SetMinDCAToVertexXY(0.);
 979   esdTrackCuts->SetPtRange(0.3,1.e10);
 980
 981   AddTrackCuts(esdTrackCuts);
 982   delete esdTrackCuts;
 983   esdTrackCuts=NULL;
 984
 985
 986   const Int_t nptbins=4;
 987   Float_t ptbins[nptbins+1];
 988   ptbins[0]=2.;
 989   ptbins[1]=4.;
 990   ptbins[2]=6.;
 991   ptbins[3]=8.;
 992   ptbins[4]=12.;
 993
 994   const Int_t nvars=20;
 995
 996   Float_t** anacutsval;
 997   anacutsval=new Float_t*[nvars];
 998
 999   for(Int_t ic=0;ic<nvars;ic++){anacutsval[ic]=new Float_t[nptbins];}
1000   for(Int_t ipt=0;ipt<nptbins;ipt++){
1001
1002     anacutsval[0][ipt]=0.35;
1003     anacutsval[1][ipt]=0.3;
1004     anacutsval[2][ipt]=0.3;
1005     anacutsval[3][ipt]=0.;
1006     anacutsval[4][ipt]=0.;
1007     anacutsval[5][ipt]=0.005;
1008     anacutsval[8][ipt]=0.;
1009     anacutsval[10][ipt]=0.;
1010     anacutsval[11][ipt]=1000.0;
1011     anacutsval[13][ipt]=0.1;
1012     anacutsval[16][ipt]=0.;
1013     anacutsval[17][ipt]=0.;
1014     anacutsval[18][ipt]=0.;
1015     anacutsval[19][ipt]=-1.;
1016
1017
1018   }
1019
1020   //sigmavertex
1021
1022   anacutsval[6][0]=0.020;
1023   anacutsval[6][1]=0.030;
1024   anacutsval[6][2]=0.030;
1025   anacutsval[6][3]=0.060;
1026
1027   //Decay length
1028
1029   anacutsval[7][0]=0.035;
1030   anacutsval[7][1]=0.035;
1031   anacutsval[7][2]=0.040;
1032   anacutsval[7][3]=0.040;
1033
1034   //cosThetaPoint
1035
1036   anacutsval[9][0]=0.94;
1037   anacutsval[9][1]=0.94;
1038   anacutsval[9][2]=0.94;
1039   anacutsval[9][3]=0.94;
1040
1041   //phi DeltaMass
1042
1043   anacutsval[12][0]=0.0080;
1044   anacutsval[12][1]=0.0050;
1045   anacutsval[12][2]=0.0045;
1046   anacutsval[12][3]=0.0090;
1047
1048   //Kin1
1049
1050   anacutsval[14][0]=0.10;
1051   anacutsval[14][1]=0.05;
1052   anacutsval[14][2]=0.0;
1053   anacutsval[14][3]=0.05;
1054
1055   //Kin2
1056
1057   anacutsval[15][0]=0.95;
1058   anacutsval[15][1]=0.95;
1059   anacutsval[15][2]=1.;
1060   anacutsval[15][3]=0.95;
1061
1062   fPidHF->SetOldPid(kTRUE);
1063   SetUsePID(kTRUE);
1064   SetPidOption(1);
1065   SetMaxPtStrongPid(9999.);
1066   SetGlobalIndex(nvars,nptbins);
1067   SetPtBins(nptbins+1,ptbins);
1068   SetCuts(nvars,nptbins,anacutsval);
1069   SetRemoveDaughtersFromPrim(kTRUE);
1070
1071   PrintAll();
1072
1073   for(Int_t iic=0;iic<nvars;iic++){delete [] anacutsval[iic];}
1074   delete [] anacutsval;
1075   anacutsval=NULL;
1076
1077   return;
1078 }
1079