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
 105   if(nvars!=fnVarsForOpt) {
 106     printf("AliRDHFCutsLctoV0::GetCutsVarsForOpt: wrong number of variables\n");
 107     return;
 108   }
 109
 110   AliAODRecoCascadeHF *dd = (AliAODRecoCascadeHF*)d;
 111
 112   // Get the v0 and all daughter tracks
 113   AliAODTrack *bachelor_track = dd->GetBachelor();
 114   AliAODv0 *v0 = dd->Getv0();
 115   AliAODTrack *v0positive_track = dd->Getv0PositiveTrack();
 116   AliAODTrack *v0negative_track = dd->Getv0NegativeTrack();
 117
 118   Int_t iter=-1;
 119   // cut on cascade mass, if k0s + p
 120   if(fVarsForOpt[0]){
 121     iter++;
 122     vars[iter]=dd->InvMassLctoK0sP();
 123   }
 124   // cut on cascade mass, if lambda + pi
 125   if(fVarsForOpt[1]){
 126     iter++;
 127     vars[iter]=dd->InvMassLctoLambdaPi();
 128   }
 129
 130   // cut on v0 mass if k0s
 131   if(fVarsForOpt[2]){
 132     iter++;
 133     vars[iter]=v0->MassK0Short();
 134   }
 135
 136   // cut on v0 mass if lambda
 137   // ----------------------------- pb with anti-lambda?? --------->>>>>>>>
 138   if(fVarsForOpt[3]){
 139     iter++;
 140     vars[iter]=v0->MassLambda();
 141   }
 142
 143   // cut on v0-positive min pt
 144   if(fVarsForOpt[4]){
 145     iter++;
 146     vars[iter]=v0positive_track->Pt();
 147   }
 148
 149   // cut on v0-negative min pt
 150   if(fVarsForOpt[5]){
 151     iter++;
 152     vars[iter]=v0negative_track->Pt();
 153   }
 154
 155   // cut bachelor min pt
 156   if(fVarsForOpt[6]){
 157     iter++;
 158     vars[iter]=bachelor_track->Pt();
 159   }
 160
 161   // cut on v0 dca
 162   if(fVarsForOpt[7]){
 163     iter++;
 164     vars[iter]=v0->GetDCA();
 165   }
 166
 167   // cut on cascade dca
 168   if(fVarsForOpt[8]){
 169     iter++;
 170     vars[iter]=dd->GetDCA();
 171   }
 172
 173   return;
 174 }
 175 //---------------------------------------------------------------------------
 176 Int_t AliRDHFCutsLctoV0::IsSelected(TObject* obj,Int_t selectionLevel) {
 177   //
 178   // Apply selection
 179   //
 180
 181   if(!fCutsRD){
 182     cout<<"Cut matrice not inizialized. Exit..."<<endl;
 183     return 0;
 184   }
 185   //PrintAll();
 186   AliAODRecoCascadeHF* d=(AliAODRecoCascadeHF*)obj;
 187
 188   if(!d){
 189     cout<<"AliAODRecoCascadeHF null"<<endl;
 190     return 0;
 191   }
 192
 193
 194   // selection on daughter tracks
 195   if(selectionLevel==AliRDHFCuts::kAll ||
 196      selectionLevel==AliRDHFCuts::kTracks) {
 197     if(!AreDaughtersSelected(d)) return 0;
 198   }
 199
 200
 201   // Get the v0 and all daughter tracks
 202   AliAODTrack *bachelor_track = d->GetBachelor();
 203   AliAODv0 *v0 = d->Getv0();
 204   AliAODTrack *v0positive_track = d->Getv0PositiveTrack();
 205   AliAODTrack *v0negative_track = d->Getv0NegativeTrack();
 206
 207 //   // If reading ESDv0, return false
 208 //   if ( !d->Getv0() || !d->Getv0PositiveTrack() || !d->Getv0NegativeTrack() )
 209 //     { AliInfo(Form("Not adapted for ESDv0s, return false...")); return false; }
 210
 211   Int_t returnvalue=1;
 212
 213   // selection on candidate
 214   if(selectionLevel==AliRDHFCuts::kAll ||
 215      selectionLevel==AliRDHFCuts::kCandidate) {
 216
 217     Double_t pt=d->Pt();
 218
 219     Int_t ptbin=PtBin(pt);
 220
 221     Double_t mLck0sp,mLcLpi;
 222     Int_t okLck0sp=1,okLcLpi=1;
 223
 224     Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
 225     Double_t mk0sPDG = TDatabasePDG::Instance()->GetParticle(310)->Mass();
 226     Double_t mLPDG = TDatabasePDG::Instance()->GetParticle(3122)->Mass();
 227
 228     // k0s + p
 229     double mk0s = v0->MassK0Short();
 230     mLck0sp = d->InvMassLctoK0sP();
 231
 232     // lambda + pi
 233     double mlambda = v0->MassLambda();
 234     double malambda = v0->MassAntiLambda();
 235     mLcLpi = d->InvMassLctoLambdaPi();
 236
 237     // cut on Lc mass
 238     //   with k0s p hypothesis
 239     if(TMath::Abs(mLck0sp-mLcPDG)>fCutsRD[GetGlobalIndex(0,ptbin)]) {
 240       okLck0sp = 0;
 241       AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to lambda_c into k0s+p cut",mLck0sp));
 242     }
 243     //   with Lambda pi hypothesis
 244     if(TMath::Abs(mLcLpi-mLcPDG)>fCutsRD[GetGlobalIndex(1,ptbin)]) {
 245       okLcLpi = 0;
 246       AliDebug(4,Form(" cascade mass is %2.2e and does not correspond to lambda_c into lambda+pi cut",mLcLpi));
 247     }
 248
 249     // cuts on the v0 mass
 250     if(TMath::Abs(mk0s-mk0sPDG)>fCutsRD[GetGlobalIndex(2,ptbin)]) {
 251       okLck0sp = 0;
 252       AliDebug(4,Form(" v0 mass is %2.2e and does not correspond to k0s cut",mk0s));
 253     }
 254     if( TMath::Abs(mlambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] &&
 255         TMath::Abs(malambda-mLPDG)>fCutsRD[GetGlobalIndex(3,ptbin)] ) {
 256       okLcLpi = 0;
 257       AliDebug(4,Form(" v0 mass is %2.2e and does not correspond to lambda cut",mlambda));
 258     }
 259
 260     if(!okLck0sp && !okLcLpi) return 0;
 261
 262     // cuts on the minimum pt of the tracks
 263     if(TMath::Abs(bachelor_track->Pt()) < fCutsRD[GetGlobalIndex(4,ptbin)]) {
 264       AliDebug(4,Form(" bachelor track Pt=%2.2e > %2.2e",bachelor_track->Pt(),fCutsRD[GetGlobalIndex(4,ptbin)]));
 265       return 0;
 266     }
 267     if(TMath::Abs(v0positive_track->Pt()) < fCutsRD[GetGlobalIndex(5,ptbin)]) {
 268       AliDebug(4,Form(" v0 positive track Pt=%2.2e > %2.2e",v0positive_track->Pt(),fCutsRD[GetGlobalIndex(5,ptbin)]));
 269       return 0;
 270     }
 271     if(TMath::Abs(v0negative_track->Pt()) < fCutsRD[GetGlobalIndex(6,ptbin)]) {
 272       AliDebug(4,Form(" v0 negative track Pt=%2.2e > %2.2e",v0negative_track->Pt(),fCutsRD[GetGlobalIndex(6,ptbin)]));
 273       return 0;
 274     }
 275
 276     // cut on the v0 dca
 277     if(TMath::Abs(v0->DcaV0Daughters()) > fCutsRD[GetGlobalIndex(7,ptbin)]) {
 278       AliDebug(4,Form(" v0 daughters DCA = %2.2e > %2.2e",v0->DcaV0Daughters(),fCutsRD[GetGlobalIndex(7,ptbin)]));
 279       return 0;
 280     }
 281
 282     // cut on the cascade dca
 283     if( TMath::Abs(d->GetDCA(0))>fCutsRD[GetGlobalIndex(8,ptbin)] ||
 284         TMath::Abs(v0->DcaPosToPrimVertex())>fCutsRD[GetGlobalIndex(8,ptbin)] ||
 285         TMath::Abs(v0->DcaNegToPrimVertex())>fCutsRD[GetGlobalIndex(8,ptbin)] ) {
 286       AliDebug(4,Form(" cascade tracks DCA at primary vertex don't pass the cut"));
 287       return 0;
 288     }
 289
 290     if(okLck0sp) returnvalue=1; //cuts passed as Lc -> k0s + p
 291     if(okLcLpi) returnvalue=2; //cuts passed as Lc-> lambda + pi
 292     if(okLck0sp && okLcLpi) returnvalue=3; //cuts passed as both  Lc -> k0s + p; Lc-> lambda + pi
 293
 294   }
 295
 296   return returnvalue;
 297 }
 298 //---------------------------------------------------------------------------