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