PWG3/vertexingHF/AliRDHFCutsD0toKpi.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 /////////////////////////////////////////////////////////////
  17 //
  18 // Class for cuts on AOD reconstructed D0->Kpi
  19 //
  20 // Author: A.Dainese, andrea.dainese@pd.infn.it
  21 /////////////////////////////////////////////////////////////
  22
  23 #include <TDatabasePDG.h>
  24 #include <Riostream.h>
  25
  26 #include "AliRDHFCutsD0toKpi.h"
  27 #include "AliAODRecoDecayHF2Prong.h"
  28 #include "AliAODTrack.h"
  29 #include "AliESDtrack.h"
  30
  31 ClassImp(AliRDHFCutsD0toKpi)
  32
  33 //--------------------------------------------------------------------------
  34 AliRDHFCutsD0toKpi::AliRDHFCutsD0toKpi() :
  35 AliRDHFCuts()
  36 {
  37   //
  38   // Default Constructor
  39   //
  40   Int_t nvars=9;
  41   SetNVars(nvars);
  42   TString varNames[9]={"inv. mass [GeV]",
  43                        "dca [cm]",
  44                        "cosThetaStar",
  45                        "pTK [GeV/c]",
  46                        "pTPi [GeV/c]",
  47                        "d0K [cm]",
  48                        "d0Pi [cm]",
  49                        "d0d0 [cm^2]",
  50                        "cosThetaPoint"};
  51   Bool_t isUpperCut[9]={kTRUE,
  52                         kTRUE,
  53                         kTRUE,
  54                         kFALSE,
  55                         kFALSE,
  56                         kTRUE,
  57                         kTRUE,
  58                         kTRUE,
  59                         kFALSE};
  60   SetVarNames(nvars,varNames,isUpperCut);
  61   Bool_t forOpt[9]={kFALSE,
  62                     kTRUE,
  63                     kTRUE,
  64                     kFALSE,
  65                     kFALSE,
  66                     kFALSE,
  67                     kFALSE,
  68                     kTRUE,
  69                     kTRUE};
  70   SetVarsForOpt(4,forOpt);
  71   Float_t limits[2]={0,999999999.};
  72   SetPtBins(2,limits);
  73 }
  74 //--------------------------------------------------------------------------
  75 AliRDHFCutsD0toKpi::AliRDHFCutsD0toKpi(const AliRDHFCutsD0toKpi &source) :
  76   AliRDHFCuts(source)
  77 {
  78   //
  79   // Copy constructor
  80   //
  81
  82 }
  83 //--------------------------------------------------------------------------
  84 AliRDHFCutsD0toKpi &AliRDHFCutsD0toKpi::operator=(const AliRDHFCutsD0toKpi &source)
  85 {
  86   //
  87   // assignment operator
  88   //
  89   if(&source == this) return *this;
  90
  91   AliRDHFCuts::operator=(source);
  92
  93   return *this;
  94 }
  95
  96
  97 //---------------------------------------------------------------------------
  98 void AliRDHFCutsD0toKpi::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
  99   //
 100   // Fills in vars the values of the variables
 101   //
 102
 103   cout<<"Ingetvarforopt"<<endl;
 104   //PrintAll();
 105
 106   if(nvars!=fnVarsForOpt) {
 107     printf("AliRDHFCutsD0toKpi::GetCutsVarsForOpt: wrong number of variables\n");
 108     return;
 109   }
 110
 111   AliAODRecoDecayHF2Prong *dd = (AliAODRecoDecayHF2Prong*)d;
 112  /*
 113   vars[0] = dd->GetDCA();
 114   if(TMath::Abs(pdgdaughters[0])==211) {
 115     vars[1] = dd->CosThetaStarD0();
 116   } else {
 117     vars[1] = dd->CosThetaStarD0bar();
 118   }
 119   vars[2] = dd->Prodd0d0();
 120   vars[3] = dd->CosPointingAngle();
 121
 122   return;
 123 */
 124
 125   //possibile generalizzazione
 126   Int_t iter=-1;
 127   if(fVarsForOpt[0]){
 128     iter++;
 129     if(TMath::Abs(pdgdaughters[0])==211) {
 130       vars[iter]=dd->InvMassD0();
 131     } else {
 132       vars[iter]=dd->InvMassD0bar();
 133     }
 134   }
 135   if(fVarsForOpt[1]){
 136     iter++;
 137     vars[iter]=dd->GetDCA();
 138   }
 139   if(fVarsForOpt[2]){
 140     iter++;
 141     if(TMath::Abs(pdgdaughters[0])==211) {
 142       vars[iter] = dd->CosThetaStarD0();
 143     } else {
 144       vars[iter] = dd->CosThetaStarD0bar();
 145     }
 146   }
 147   if(fVarsForOpt[3]){
 148     iter++;
 149    if(TMath::Abs(pdgdaughters[0])==321) {
 150      vars[iter]=dd->PtProng(0);
 151    }
 152    else{
 153      vars[iter]=dd->PtProng(1);
 154    }
 155   }
 156   if(fVarsForOpt[4]){
 157     iter++;
 158    if(TMath::Abs(pdgdaughters[0])==211) {
 159      vars[iter]=dd->PtProng(0);
 160    }
 161    else{
 162      vars[iter]=dd->PtProng(1);
 163    }
 164   }
 165   if(fVarsForOpt[5]){
 166     iter++;
 167     if(TMath::Abs(pdgdaughters[0])==321) {
 168      vars[iter]=dd->Getd0Prong(0);
 169    }
 170    else{
 171      vars[iter]=dd->Getd0Prong(1);
 172    }
 173   }
 174   if(fVarsForOpt[6]){
 175     iter++;
 176      if(TMath::Abs(pdgdaughters[0])==211) {
 177      vars[iter]=dd->Getd0Prong(0);
 178    }
 179    else{
 180      vars[iter]=dd->Getd0Prong(1);
 181    }
 182   }
 183   if(fVarsForOpt[7]){
 184     iter++;
 185     vars[iter]= dd->Prodd0d0();
 186   }
 187   if(fVarsForOpt[8]){
 188     iter++;
 189     vars[iter]=dd->CosPointingAngle();
 190   }
 191
 192   return;
 193 }
 194 //---------------------------------------------------------------------------
 195 Int_t AliRDHFCutsD0toKpi::IsSelected(TObject* obj,Int_t selectionLevel) {
 196   //
 197   // Apply selection
 198   //
 199
 200   if(!fCutsRD){
 201     cout<<"Cut matrice not inizialized. Exit..."<<endl;
 202     return -1;
 203   }
 204   //PrintAll();
 205   AliAODRecoDecayHF2Prong* d=(AliAODRecoDecayHF2Prong*)obj; // ????
 206
 207   Int_t returnvalue=1;
 208   if(!d){
 209     cout<<"AliAODRecoDecayHF2Prong null"<<endl;
 210     return 0;
 211   }
 212
 213   // selection on daughter tracks
 214   if(selectionLevel==AliRDHFCuts::kAll ||
 215      selectionLevel==AliRDHFCuts::kTracks) {
 216     Int_t ndaughters = d->GetNDaughters();
 217     //cout<<"loop on "<<ndaughters<<"daughters"<<endl;
 218     for(Int_t idg=0; idg<ndaughters; idg++) {
 219       AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(idg);
 220       if(!dgTrack) returnvalue=0;
 221       //printf("charge %d\n",dgTrack->Charge());
 222       if(dgTrack->Charge()==0) continue; // it's not a track, but a V0
 223       // convert to ESD track here
 224       AliESDtrack* esdTrack=new AliESDtrack(dgTrack);
 225
 226       if(!fTrackCuts->IsSelected(esdTrack)) returnvalue=0;//kFALSE;
 227     }
 228     if(!returnvalue) return 0;
 229   }
 230
 231
 232
 233   //cout<<"cand sel? "<<selectionLevel<<" = "<<AliRDHFCuts::kAll<<" or "<<AliRDHFCuts::kCandidate<<endl;
 234
 235   // selection on candidate
 236   if(selectionLevel==AliRDHFCuts::kAll ||
 237      selectionLevel==AliRDHFCuts::kCandidate) {
 238
 239     Double_t pt=d->Pt();
 240
 241     Int_t okD0=0,okD0bar=0;
 242
 243     Int_t ptbin=PtBin(pt);
 244
 245     Double_t mD0,mD0bar,ctsD0,ctsD0bar;
 246     okD0=1; okD0bar=1;
 247
 248     Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass();
 249
 250     if(d->PtProng(1) < fCutsRD[GetGlobalIndex(3,ptbin)] || d->PtProng(0) < fCutsRD[GetGlobalIndex(4,ptbin)]) okD0 = 0;
 251     if(d->PtProng(0) < fCutsRD[GetGlobalIndex(3,ptbin)] || d->PtProng(1) < fCutsRD[GetGlobalIndex(4,ptbin)]) okD0bar = 0;
 252
 253     if(!okD0 && !okD0bar) returnvalue=0;
 254
 255     if(TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(5,ptbin)] ||
 256        TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)]) okD0 = 0;
 257     if(TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)] ||
 258        TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(5,ptbin)]) okD0bar = 0;
 259     if(!okD0 && !okD0bar) returnvalue=0;
 260
 261     if(d->GetDCA() > fCutsRD[GetGlobalIndex(1,ptbin)]) { okD0 = okD0bar = 0; returnvalue=0;
 262     }
 263
 264     d->InvMassD0(mD0,mD0bar);
 265     if(TMath::Abs(mD0-mD0PDG) > fCutsRD[GetGlobalIndex(0,ptbin)]) okD0 = 0;
 266     if(TMath::Abs(mD0bar-mD0PDG) > fCutsRD[GetGlobalIndex(0,ptbin)]) okD0bar = 0;
 267     if(!okD0 && !okD0bar) returnvalue=0;
 268
 269     d->CosThetaStarD0(ctsD0,ctsD0bar);
 270     if(TMath::Abs(ctsD0) > fCutsRD[GetGlobalIndex(2,ptbin)]) okD0 = 0;
 271     if(TMath::Abs(ctsD0bar) > fCutsRD[GetGlobalIndex(2,ptbin)]) okD0bar = 0;
 272     if(!okD0 && !okD0bar) returnvalue=0;
 273
 274     if(d->Prodd0d0() > fCutsRD[GetGlobalIndex(7,ptbin)]) { okD0 = okD0bar = 0; returnvalue=0; }
 275
 276     if(d->CosPointingAngle() < fCutsRD[GetGlobalIndex(8,ptbin)]) { okD0 = okD0bar = 0; returnvalue=0; }
 277
 278
 279
 280     if (okD0) returnvalue=1; //cuts passed as D0
 281     if (okD0bar) returnvalue=2; //cuts passed as D0bar
 282     if (okD0 && okD0bar) returnvalue=3; //cuts passed as D0 and D0bar
 283   }
 284
 285
 286   return returnvalue;
 287
 288 }
 289 //---------------------------------------------------------------------------