PWG3/vertexingHF/AliRDHFCutsLctoV0.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /////////////////////////////////////////////////////////////
  17 //
  18 // Class for cuts on AOD reconstructed Lc->pKpi
  19 //
  20 /////////////////////////////////////////////////////////////
  21
  22 #include <TDatabasePDG.h>
  23 #include <Riostream.h>
  24
  25 #include "AliRDHFCutsLctoV0.h"
  26 #include "AliAODRecoCascadeHF.h"
  27 #include "AliAODTrack.h"
  28 #include "AliESDtrack.h"
  29 #include "AliAODv0.h"
  30 #include "AliESDv0.h"
  31
  32 ClassImp(AliRDHFCutsLctoV0)
  33
  34 //--------------------------------------------------------------------------
  35 AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const char* name) :
  36 AliRDHFCuts(name)
  37 {
  38   //
  39   // Default Constructor
  40   //
  41   Int_t nvars=9;
  42   SetNVars(nvars);
  43   TString varNames[9]={"inv. mass if K0s [GeV]",
  44                        "inv. mass if Lambda [GeV]",
  45                        "inv. mass V0 if K0s [GeV]",
  46                        "inv. mass V0 if Lambda [GeV]",
  47                        "pT min bachelor track [GeV/c]",
  48                        "pT min V0-positive track [GeV/c]",
  49                        "pT min V0-negative track [GeV/c]",
  50                        "dca cascade cut (cm)",
  51                        "dca V0 cut (cm)"};
  52
  53   Bool_t isUpperCut[9]={kTRUE,
  54                         kTRUE,
  55                         kTRUE,
  56                         kTRUE,
  57                         kFALSE,
  58                         kFALSE,
  59                         kFALSE,
  60                         kTRUE,
  61                         kTRUE};
  62   SetVarNames(nvars,varNames,isUpperCut);
  63   Bool_t forOpt[9]={kFALSE,
  64                     kFALSE,
  65                     kFALSE,
  66                     kFALSE,
  67                     kFALSE,
  68                     kFALSE,
  69                     kFALSE,
  70                     kFALSE,
  71                     kFALSE};
  72   SetVarsForOpt(5,forOpt);
  73   Float_t limits[2]={0,999999999.};
  74   SetPtBins(2,limits);
  75 }
  76 //--------------------------------------------------------------------------
  77 AliRDHFCutsLctoV0::AliRDHFCutsLctoV0(const AliRDHFCutsLctoV0 &source) :
  78   AliRDHFCuts(source)
  79 {
  80   //
  81   // Copy constructor
  82   //
  83
  84 }
  85 //--------------------------------------------------------------------------
  86 AliRDHFCutsLctoV0 &AliRDHFCutsLctoV0::operator=(const AliRDHFCutsLctoV0 &source)
  87 {
  88   //
  89   // assignment operator
  90   //
  91   if(&source == this) return *this;
  92
  93   AliRDHFCuts::operator=(source);
  94
  95   return *this;
  96 }
  97
  98
  99 //---------------------------------------------------------------------------
 100 void AliRDHFCutsLctoV0::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
 101   //
 102   // Fills in vars the values of the variables
 103   //
 104   if(pdgdaughters[0]==-9999) return; // dummy
 105
 106
 107   if(nvars!=fnVarsForOpt) {
 108     printf("AliRDHFCutsLctoV0::GetCutsVarsForOpt: wrong number of variables\n");
 109     return;
 110   }
 111
 112   AliAODRecoCascadeHF *dd = (AliAODRecoCascadeHF*)d;
 113
 114   // Get the v0 and all daughter tracks
 115   AliAODTrack *bachelor_track = dd->GetBachelor();
 116   AliAODv0 *v0 = dd->Getv0();
 117   AliAODTrack *v0positive_track = dd->Getv0PositiveTrack();
 118   AliAODTrack *v0negative_track = dd->Getv0NegativeTrack();
 119
 120   Int_t iter=-1;
 121   // cut on cascade mass, if k0s + p
 122   if(fVarsForOpt[0]){
 123     iter++;
 124     vars[iter]=dd->InvMassLctoK0sP();
 125   }
 126   // cut on cascade mass, if lambda + pi
 127   if(fVarsForOpt[1]){
 128     iter++;
 129     vars[iter]=dd->InvMassLctoLambdaPi();
 130   }
 131
 132   // cut on v0 mass if k0s
 133   if(fVarsForOpt[2]){
 134     iter++;
 135     vars[iter]=v0->MassK0Short();
 136   }
 137
 138   // cut on v0 mass if lambda
 139   // ----------------------------- pb with anti-lambda?? --------->>>>>>>>
 140   if(fVarsForOpt[3]){
 141     iter++;
 142     vars[iter]=v0->MassLambda();
 143   }
 144
 145   // cut on v0-positive min pt
 146   if(fVarsForOpt[4]){
 147     iter++;
 148     vars[iter]=v0positive_track->Pt();
 149   }
 150
 151   // cut on v0-negative min pt
 152   if(fVarsForOpt[5]){
 153     iter++;
 154     vars[iter]=v0negative_track->Pt();
 155   }
 156
 157   // cut bachelor min pt
 158   if(fVarsForOpt[6]){
 159     iter++;
 160     vars[iter]=bachelor_track->Pt();
 161   }
 162
 163   // cut on v0 dca
 164   if(fVarsForOpt[7]){
 165     iter++;
 166     vars[iter]=v0->GetDCA();
 167   }
 168
 169   // cut on cascade dca
 170   if(fVarsForOpt[8]){
 171     iter++;
 172     vars[iter]=dd->GetDCA();
 173   }
 174
 175   return;
 176 }
 177 //---------------------------------------------------------------------------
 178 Int_t AliRDHFCutsLctoV0::IsSelected(TObject* obj,Int_t selectionLevel) {
 179   //
 180   // Apply selection
 181   //
 182
 183   if(!fCutsRD){
 184     cout<<"Cut matrice not inizialized. Exit..."<<endl;
 185     return 0;
 186   }
 187   //PrintAll();
 188   AliAODRecoCascadeHF* d=(AliAODRecoCascadeHF*)obj;
 189
 190   if(!d){
 191     cout<<"AliAODRecoCascadeHF null"<<endl;
 192     return 0;
 193   }
 194
 195
 196   // selection on daughter tracks
 197   if(selectionLevel==AliRDHFCuts::kAll ||
 198      selectionLevel==AliRDHFCuts::kTracks) {
 199     if(!AreDaughtersSelected(d)) return 0;
 200   }
 201
 202
 203   // Get the v0 and all daughter tracks
 204   AliAODTrack *bachelor_track = d->GetBachelor();
 205   AliAODv0 *v0 = d->Getv0();
 206   AliAODTrack *v0positive_track = d->Getv0PositiveTrack();
 207   AliAODTrack *v0negative_track = d->Getv0NegativeTrack();
 208
 209 //   // If reading ESDv0, return false
 210 //   if ( !d->Getv0() || !d->Getv0PositiveTrack() || !d->Getv0NegativeTrack() )
 211 //     { AliInfo(Form("Not adapted for ESDv0s, return false...")); return false; }
 212
 213   Int_t returnvalue=1;
 214
 215   // selection on candidate
 216   if(selectionLevel==AliRDHFCuts::kAll ||
 217      selectionLevel==AliRDHFCuts::kCandidate) {
 218
 219     Double_t pt=d->Pt();
 220
 221     Int_t ptbin=PtBin(pt);
 222
 223     Double_t mLck0sp,mLcLpi;
 224     Int_t okLck0sp=1,okLcLpi=1;
 225
 226     Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
 227     Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
 228     Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
 229
 230     // k0s + p
 231     double mk0s = v0->MassK0Short();
 232     mLck0sp = d->InvMassLctoK0sP();
 233
 234     // lambda + pi
 235     double mlambda = v0->MassLambda();
 236     double malambda = v0->MassAntiLambda();
 237     mLcLpi = d->InvMassLctoLambdaPi();
 238
 239     // cut on Lc mass
 240     //   with k0s p hypothesis
 241     if(TMath::Abs(mLck0sp-mLcPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) {
 242       okLck0sp = 0;
 243       AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to lambda_c into k0s+p cut",mLck0sp));
 244     }
 245     //   with Lambda pi hypothesis
 246     if(TMath::Abs(mLcLpi-mLcPDG)>fCutsRD[GetGlobalIndex(1,ptbin)]) {
 247       okLcLpi = 0;
 248       AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to lambda_c into lambda+pi cut",mLcLpi));
 249     }
 250
 251     // cuts on the v0 mass
 252     if(TMath::Abs(mk0s-mk0sPDG)>fCutsRD[GetGlobalIndex(2,ptbin)]) {
 253       okLck0sp = 0;
 254       AliDebug(4,Form(" v0 mass is %2.2e and does not correspond to k0s cut",mk0s));
 255     }
 256     if( TMath::Abs(mlambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] &&
 257         TMath::Abs(malambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] ) {
 258       okLcLpi = 0;
 259       AliDebug(4,Form(" v0 mass is %2.2e and does not correspond to lambda cut",mlambda));
 260     }
 261
 262     if(!okLck0sp && !okLcLpi) return 0;
 263
 264     // cuts on the minimum pt of the tracks
 265     if(TMath::Abs(bachelor_track->Pt()) < fCutsRD[GetGlobalIndex(4,ptbin)]) {
 266       AliDebug(4,Form(" bachelor track Pt=%2.2e > %2.2e",bachelor_track->Pt(),fCutsRD[GetGlobalIndex(4,ptbin)]));
 267       return 0;
 268     }
 269     if(TMath::Abs(v0positive_track->Pt()) < fCutsRD[GetGlobalIndex(5,ptbin)]) {
 270       AliDebug(4,Form(" v0 positive track Pt=%2.2e > %2.2e",v0positive_track->Pt(),fCutsRD[GetGlobalIndex(5,ptbin)]));
 271       return 0;
 272     }
 273     if(TMath::Abs(v0negative_track->Pt()) < fCutsRD[GetGlobalIndex(6,ptbin)]) {
 274       AliDebug(4,Form(" v0 negative track Pt=%2.2e > %2.2e",v0negative_track->Pt(),fCutsRD[GetGlobalIndex(6,ptbin)]));
 275       return 0;
 276     }
 277
 278     // cut on the v0 dca
 279     if(TMath::Abs(v0->DcaV0Daughters()) > fCutsRD[GetGlobalIndex(7,ptbin)]) {
 280       AliDebug(4,Form(" v0 daughters DCA = %2.2e > %2.2e",v0->DcaV0Daughters(),fCutsRD[GetGlobalIndex(7,ptbin)]));
 281       return 0;
 282     }
 283
 284     // cut on the cascade dca
 285     if( TMath::Abs(d->GetDCA(0))>fCutsRD[GetGlobalIndex(8,ptbin)] ||
 286         TMath::Abs(v0->DcaPosToPrimVertex())>fCutsRD[GetGlobalIndex(8,ptbin)] ||
 287         TMath::Abs(v0->DcaNegToPrimVertex())>fCutsRD[GetGlobalIndex(8,ptbin)] ) {
 288       AliDebug(4,Form(" cascade tracks DCA at primary vertex don't pass the cut"));
 289       return 0;
 290     }
 291
 292     if(okLck0sp) returnvalue=1; //cuts passed as Lc -> k0s + p
 293     if(okLcLpi) returnvalue=2; //cuts passed as Lc-> lambda + pi
 294     if(okLck0sp && okLcLpi) returnvalue=3; //cuts passed as both  Lc -> k0s + p; Lc-> lambda + pi
 295
 296   }
 297
 298   return returnvalue;
 299 }
 300 //---------------------------------------------------------------------------