PWGGA/GammaConv/AliDalitzElectronCuts.cxx

   1 \r
   2 /**************************************************************************\r
   3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
   4  *                                                                        *\r
   5  * Authors: Svein Lindal, Daniel Lohner                                   *\r
   6  * Version 1.0                                                            *\r
   7  *                                                                        *\r
   8  * Permission to use, copy, modify and distribute this software and its   *\r
   9  * documentation strictly for non-commercial purposes is hereby granted   *\r
  10  * without fee, provided that the above copyright notice appears in all   *\r
  11  * copies and that both the copyright notice and this permission notice   *\r
  12  * appear in the supporting documentation. The authors make no claims     *\r
  13  * about the suitability of this software for any purpose. It is          *\r
  14  * provided "as is" without express or implied warranty.                  *\r
  15  **************************************************************************/\r
  16 \r
  17 ////////////////////////////////////////////////\r
  18 //--------------------------------------------- \r
  19 // Class handling all kinds of selection cuts for\r
  20 // Gamma Conversion analysis\r
  21 //---------------------------------------------\r
  22 ////////////////////////////////////////////////\r
  23 \r
  24 \r
  25 #include "AliDalitzElectronCuts.h"\r
  26 #include "AliAODConversionPhoton.h"\r
  27 #include "AliKFVertex.h"\r
  28 #include "AliAODTrack.h"\r
  29 #include "AliESDtrack.h"\r
  30 #include "AliAnalysisManager.h"\r
  31 #include "AliInputEventHandler.h"\r
  32 #include "AliMCEventHandler.h"\r
  33 #include "AliAODHandler.h"\r
  34 #include "AliPIDResponse.h"\r
  35 #include "TH1.h"\r
  36 #include "TH2.h"\r
  37 #include "AliStack.h"\r
  38 #include "TObjString.h"\r
  39 #include "AliAODEvent.h"\r
  40 #include "AliESDEvent.h"\r
  41 #include "TList.h"\r
  42 class iostream;\r
  43 \r
  44 using namespace std;\r
  45 \r
  46 ClassImp(AliDalitzElectronCuts)\r
  47 \r
  48 \r
  49 const char* AliDalitzElectronCuts::fgkCutNames[AliDalitzElectronCuts::kNCuts] = {\r
  50 "GoodId",\r
  51 "ededxSigmaITSCut",\r
  52 "ededxSigmaTPCCut",\r
  53 "pidedxSigmaTPCCut",\r
  54 "piMinMomdedxSigmaTPCCut",\r
  55 "piMaxMomdedxSigmaTPCCut",\r
  56 "LowPRejectionSigmaCut",\r
  57 "kTOFelectronPID",\r
  58 "clsITSCut",\r
  59 "clsTPCCut",\r
  60 "EtaCut",\r
  61 "PsiPair",\r
  62 "RejectSharedElecGamma",\r
  63 "BackgroundScheme",\r
  64 "NumberOfRotations",\r
  65 "PtCut",\r
  66 "DCAcut",\r
  67 "MassCut",\r
  68 };\r
  69 \r
  70 //________________________________________________________________________\r
  71 AliDalitzElectronCuts::AliDalitzElectronCuts(const char *name,const char *title) : AliAnalysisCuts(name,title),\r
  72     fHistograms(NULL),\r
  73     fPIDResponse(NULL),\r
  74     fesdTrackCuts(NULL),\r
  75     fEtaCut(0.9),\r
  76     fEtaShift(0.0),\r
  77     fDoEtaCut(kFALSE),\r
  78     fPtCut(0.0),\r
  79     fRadiusCut(1000.0),\r
  80     fPsiPairCut(0.45),\r
  81     fDeltaPhiCutMin(0.),\r
  82     fDeltaPhiCutMax(0.12),\r
  83     fMinClsTPC(0), // minimum clusters in the TPC\r
  84     fMinClsTPCToF(0), // minimum clusters to findable clusters\r
  85     fDodEdxSigmaITSCut(kFALSE),\r
  86     fDodEdxSigmaTPCCut(kTRUE),\r
  87     fDoTOFsigmaCut(kFALSE), // RRnewTOF\r
  88     fDoRejectSharedElecGamma(kFALSE),\r
  89     fDoPsiPairCut(kFALSE),\r
  90     fPIDnSigmaAboveElectronLineITS(100),\r
  91     fPIDnSigmaBelowElectronLineITS(-100),\r
  92     fPIDnSigmaAboveElectronLineTPC(100),\r
  93     fPIDnSigmaBelowElectronLineTPC(-100),\r
  94     fPIDnSigmaAbovePionLineTPC(0),\r
  95     fPIDnSigmaAbovePionLineTPCHighPt(-100),\r
  96     fTofPIDnSigmaAboveElectronLine(100), // RRnewTOF\r
  97     fTofPIDnSigmaBelowElectronLine(-100), // RRnewTOF\r
  98     fPIDMinPnSigmaAbovePionLineTPC(0),\r
  99     fPIDMaxPnSigmaAbovePionLineTPC(0),\r
 100     fDoKaonRejectionLowP(kFALSE),\r
 101     fDoProtonRejectionLowP(kFALSE),\r
 102     fDoPionRejectionLowP(kFALSE),\r
 103     fPIDnSigmaAtLowPAroundKaonLine(0),\r
 104     fPIDnSigmaAtLowPAroundProtonLine(0),\r
 105     fPIDnSigmaAtLowPAroundPionLine(0),\r
 106     fPIDMinPKaonRejectionLowP(1.5),\r
 107     fPIDMinPProtonRejectionLowP(2.0),\r
 108     fPIDMinPPionRejectionLowP(0.5),\r
 109     fUseCorrectedTPCClsInfo(kFALSE),\r
 110     fUseTOFpid(kFALSE),\r
 111     fRequireTOF(kFALSE),\r
 112     fUseTrackMultiplicityForBG(kFALSE),\r
 113     fBKGMethod(0),\r
 114     fnumberOfRotationEventsForBG(0),\r
 115     fDoMassCut(kFALSE),\r
 116     fMassCutLowPt(999.),\r
 117     fMassCutHighPt(999.),\r
 118     fMassCutPtMin(-100.0),\r
 119     fCutString(NULL),\r
 120     hCutIndex(NULL),\r
 121     hdEdxCuts(NULL),\r
 122     hITSdEdxbefore(NULL),\r
 123     hITSdEdxafter(NULL),\r
 124     hTPCdEdxbefore(NULL),\r
 125     hTPCdEdxafter(NULL),\r
 126     hTPCdEdxSignalbefore(NULL),\r
 127     hTPCdEdxSignalafter(NULL),\r
 128     hTOFbefore(NULL),\r
 129     hTOFafter(NULL),\r
 130     hTrackDCAxyPtbefore(NULL),\r
 131     hTrackDCAxyPtafter(NULL),\r
 132     hTrackDCAzPtbefore(NULL),\r
 133     hTrackDCAzPtafter(NULL),\r
 134     hTrackNFindClsPtTPCbefore(NULL),\r
 135     hTrackNFindClsPtTPCafter(NULL)\r
 136    {\r
 137     InitPIDResponse();\r
 138     for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=0;}\r
 139     fCutString=new TObjString((GetCutNumber()).Data());\r
 140 \r
 141    //fesdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");\r
 142    // Using standard function for setting Cuts\r
 143     Bool_t selectPrimaries=kFALSE;\r
 144     fesdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);\r
 145 }\r
 146 \r
 147 //________________________________________________________________________\r
 148 AliDalitzElectronCuts::~AliDalitzElectronCuts() {\r
 149     // Destructor\r
 150   //Deleting fHistograms leads to seg fault it it's added to output collection of a task\r
 151   // if(fHistograms)\r
 152   //    delete fHistograms;\r
 153   // fHistograms = NULL;\r
 154 \r
 155    if(fCutString != NULL){\r
 156       delete fCutString;\r
 157       fCutString = NULL;\r
 158    }\r
 159 \r
 160 \r
 161 }\r
 162 \r
 163 //________________________________________________________________________\r
 164 void AliDalitzElectronCuts::InitCutHistograms(TString name, Bool_t preCut,TString cutNumber){\r
 165 \r
 166     // Initialize Cut Histograms for QA (only initialized and filled if function is called)\r
 167 \r
 168      TString cutName = "";\r
 169     \r
 170      if( cutNumber==""){\r
 171          cutName = GetCutNumber().Data();\r
 172      }\r
 173      else {\r
 174             cutName = cutNumber.Data();\r
 175      } \r
 176 \r
 177     if(fHistograms != NULL){\r
 178         delete fHistograms;\r
 179         fHistograms=NULL;\r
 180     }\r
 181     if(fHistograms==NULL){\r
 182         fHistograms=new TList();\r
 183         if(name=="")fHistograms->SetName(Form("ElectronCuts_%s",cutName.Data()));\r
 184         else fHistograms->SetName(Form("%s_%s",name.Data(),cutName.Data()));\r
 185     }\r
 186 \r
 187 \r
 188     hCutIndex=new TH1F(Form("IsElectronSelected %s",cutName.Data()),"IsElectronSelected",10,-0.5,9.5);\r
 189     hCutIndex->GetXaxis()->SetBinLabel(kElectronIn+1,"in");\r
 190     hCutIndex->GetXaxis()->SetBinLabel(kNoTracks+1,"no tracks");\r
 191     hCutIndex->GetXaxis()->SetBinLabel(kTrackCuts+1,"Track cuts");\r
 192     hCutIndex->GetXaxis()->SetBinLabel(kdEdxCuts+1,"dEdx");\r
 193     hCutIndex->GetXaxis()->SetBinLabel(kElectronOut+1,"out");\r
 194     fHistograms->Add(hCutIndex);\r
 195 \r
 196 \r
 197 \r
 198     // dEdx Cuts\r
 199     hdEdxCuts=new TH1F(Form("dEdxCuts %s",cutName.Data()),"dEdxCuts",10,-0.5,9.5);\r
 200     hdEdxCuts->GetXaxis()->SetBinLabel(1,"in");\r
 201     hdEdxCuts->GetXaxis()->SetBinLabel(2,"ITSelectron");\r
 202     hdEdxCuts->GetXaxis()->SetBinLabel(3,"TPCelectron");\r
 203     hdEdxCuts->GetXaxis()->SetBinLabel(4,"TPCpion");\r
 204     hdEdxCuts->GetXaxis()->SetBinLabel(5,"TPCpionhighp");\r
 205     hdEdxCuts->GetXaxis()->SetBinLabel(6,"TPCkaonlowprej");\r
 206     hdEdxCuts->GetXaxis()->SetBinLabel(7,"TPCprotonlowprej");\r
 207     hdEdxCuts->GetXaxis()->SetBinLabel(8,"TPCpionlowprej");\r
 208     hdEdxCuts->GetXaxis()->SetBinLabel(9,"TOFelectron");\r
 209     hdEdxCuts->GetXaxis()->SetBinLabel(10,"out");\r
 210     fHistograms->Add(hdEdxCuts);\r
 211     \r
 212 \r
 213 \r
 214     TAxis *AxisBeforeITS  = NULL;\r
 215     TAxis *AxisBeforedEdx = NULL;\r
 216     TAxis *AxisBeforeTOF  = NULL;\r
 217     TAxis *AxisBeforedEdxSignal = NULL;\r
 218 \r
 219     if(preCut){\r
 220 \r
 221 \r
 222        hITSdEdxbefore=new TH2F(Form("Electron_ITS_before %s",cutName.Data()),"ITS dEdx electron before" ,150,0.05,20,400,-10,10);\r
 223        fHistograms->Add(hITSdEdxbefore);\r
 224        AxisBeforeITS = hITSdEdxbefore->GetXaxis();\r
 225 \r
 226        hTPCdEdxbefore=new TH2F(Form("Electron_dEdx_before %s",cutName.Data()),"dEdx electron before" ,150,0.05,20,400,-10,10);\r
 227        fHistograms->Add(hTPCdEdxbefore);\r
 228        AxisBeforedEdx = hTPCdEdxbefore->GetXaxis();\r
 229 \r
 230        hTPCdEdxSignalbefore=new TH2F(Form("Electron_dEdxSignal_before %s",cutName.Data()),"dEdx electron signal before" ,150,0.05,20.0,800,0.0,200);\r
 231        fHistograms->Add(hTPCdEdxSignalbefore);\r
 232        AxisBeforedEdxSignal = hTPCdEdxSignalbefore->GetXaxis();\r
 233 \r
 234        hTOFbefore=new TH2F(Form("Electron_TOF_before %s",cutName.Data()),"TOF electron before" ,150,0.05,20,400,-6,10);\r
 235        fHistograms->Add(hTOFbefore);\r
 236        AxisBeforeTOF = hTOFbefore->GetXaxis();\r
 237        \r
 238        hTrackDCAxyPtbefore = new TH2F(Form("hTrack_DCAxy_Pt_before %s",cutName.Data()),"DCAxy Vs Pt of tracks before",800,-4.0,4.0,400,0.,10.);\r
 239        fHistograms->Add(hTrackDCAxyPtbefore);   \r
 240        \r
 241        hTrackDCAzPtbefore  = new TH2F(Form("hTrack_DCAz_Pt_before %s",cutName.Data()), "DCAz  Vs Pt of tracks before",800,-4.0,4.0,400,0.,10.);\r
 242        fHistograms->Add(hTrackDCAzPtbefore); \r
 243        \r
 244        hTrackNFindClsPtTPCbefore = new TH2F(Form("hTrack_NFindCls_Pt_TPC_before %s",cutName.Data()),"Track: N Findable Cls TPC Vs Pt before",100,0,1,400,0.,10.);\r
 245        fHistograms->Add(hTrackNFindClsPtTPCbefore); \r
 246         \r
 247        \r
 248 \r
 249     }\r
 250 \r
 251 \r
 252     hITSdEdxafter=new TH2F(Form("Electron_ITS_after %s",cutName.Data()),"ITS dEdx electron after" ,150,0.05,20,400, -10,10);\r
 253     fHistograms->Add(hITSdEdxafter);\r
 254 \r
 255     hTPCdEdxafter=new TH2F(Form("Electron_dEdx_after %s",cutName.Data()),"dEdx electron after" ,150,0.05,20,400, -10,10);\r
 256     fHistograms->Add(hTPCdEdxafter);\r
 257 \r
 258     hTPCdEdxSignalafter=new TH2F(Form("Electron_dEdxSignal_after %s",cutName.Data()),"dEdx electron signal after" ,150,0.05,20.0,800,0.0,200);\r
 259     fHistograms->Add(hTPCdEdxSignalafter);\r
 260 \r
 261     hTOFafter=new TH2F(Form("Electron_TOF_after %s",cutName.Data()),"TOF electron after" ,150,0.05,20,400,-6,10);\r
 262     fHistograms->Add(hTOFafter);\r
 263       \r
 264     hTrackDCAxyPtafter  = new TH2F(Form("hTrack_DCAxy_Pt_after %s",cutName.Data()),"DCAxy Vs Pt of tracks after",800,-4.0,4.0,400,0.,10.);\r
 265     fHistograms->Add(hTrackDCAxyPtafter); \r
 266     \r
 267     hTrackDCAzPtafter  = new TH2F(Form("hTrack_DCAz_Pt_after %s",cutName.Data()), "DCAz Vs Pt of tracks  after",800,-4.0,4.0,400,0.,10.);\r
 268     fHistograms->Add(hTrackDCAzPtafter); \r
 269     \r
 270     hTrackNFindClsPtTPCafter = new TH2F(Form("hTrack_NFindCls_Pt_TPC_after %s",cutName.Data()),"Track: N Findable Cls TPC Vs Pt after",100,0,1,400,0.,10.);\r
 271     fHistograms->Add(hTrackNFindClsPtTPCafter); \r
 272     \r
 273     \r
 274 \r
 275     TAxis *AxisAfter = hTPCdEdxafter->GetXaxis(); \r
 276     Int_t bins = AxisAfter->GetNbins();\r
 277     Double_t from = AxisAfter->GetXmin();\r
 278     Double_t to = AxisAfter->GetXmax();\r
 279     Double_t *newBins = new Double_t[bins+1];\r
 280     newBins[0] = from;\r
 281     Double_t factor = TMath::Power(to/from, 1./bins);\r
 282     for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];\r
 283     AxisAfter->Set(bins, newBins);\r
 284     AxisAfter = hTOFafter->GetXaxis(); \r
 285     AxisAfter->Set(bins, newBins);\r
 286     AxisAfter = hITSdEdxafter->GetXaxis();\r
 287     AxisAfter->Set(bins,newBins); \r
 288     AxisAfter = hTPCdEdxSignalafter->GetXaxis();\r
 289     AxisAfter->Set(bins,newBins);\r
 290     \r
 291     if(preCut){\r
 292        AxisBeforeITS->Set(bins, newBins);\r
 293        AxisBeforedEdx->Set(bins, newBins);\r
 294        AxisBeforedEdxSignal->Set(bins,newBins);\r
 295        AxisBeforeTOF->Set(bins, newBins);\r
 296        \r
 297     }\r
 298     delete [] newBins;\r
 299 \r
 300         \r
 301     // Event Cuts and Info\r
 302 }\r
 303 \r
 304 \r
 305 //________________________________________________________________________\r
 306 Bool_t AliDalitzElectronCuts::InitPIDResponse(){\r
 307 \r
 308 // Set Pointer to AliPIDResponse\r
 309 \r
 310   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();\r
 311 \r
 312   if(man) {\r
 313 \r
 314     AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());\r
 315     fPIDResponse = (AliPIDResponse*)inputHandler->GetPIDResponse();\r
 316     if(fPIDResponse)return kTRUE;\r
 317 \r
 318   }\r
 319 \r
 320   return kFALSE;\r
 321 }\r
 322 ///________________________________________________________________________\r
 323 Bool_t AliDalitzElectronCuts::ElectronIsSelectedMC(Int_t labelParticle,AliStack *fMCStack)\r
 324 {   \r
 325         if( labelParticle < 0 || labelParticle >= fMCStack->GetNtrack() ) return kFALSE;\r
 326         if( fMCStack->IsPhysicalPrimary(labelParticle) == kFALSE ) return kFALSE; //Ask Ana\r
 327 \r
 328         TParticle* particle = fMCStack->Particle(labelParticle);\r
 329 \r
 330         if( TMath::Abs( particle->GetPdgCode() ) != 11 )  return kFALSE;\r
 331         \r
 332         if( fDoEtaCut ){\r
 333           if( particle->Eta() > (fEtaCut + fEtaShift) || particle->Eta() < (-fEtaCut + fEtaShift) )\r
 334           return kFALSE;\r
 335         }\r
 336         \r
 337 \r
 338 return kTRUE;\r
 339 }\r
 340 \r
 341 \r
 342 ///________________________________________________________________________\r
 343 Bool_t AliDalitzElectronCuts::ElectronIsSelected(AliESDtrack* lTrack)\r
 344 {\r
 345     //Selection of Reconstructed electrons\r
 346     \r
 347     \r
 348     Float_t b[2];\r
 349     Float_t bCov[3];\r
 350     lTrack->GetImpactParameters(b,bCov);\r
 351    \r
 352     if (bCov[0]<=0 || bCov[2]<=0) {\r
 353         AliDebug(1, "Estimated b resolution lower or equal zero!");\r
 354         bCov[0]=0; bCov[2]=0;\r
 355     }\r
 356     \r
 357     \r
 358 \r
 359     Float_t dcaToVertexXY = b[0];\r
 360     Float_t dcaToVertexZ  = b[1];\r
 361     Double_t clsToF = GetNFindableClustersTPC(lTrack);\r
 362    \r
 363    if( hTrackDCAxyPtbefore) hTrackDCAxyPtbefore->Fill(dcaToVertexXY,lTrack->Pt());\r
 364    if( hTrackDCAzPtbefore ) hTrackDCAzPtbefore->Fill( dcaToVertexZ, lTrack->Pt());\r
 365    if( hTrackNFindClsPtTPCbefore ) hTrackNFindClsPtTPCbefore->Fill( clsToF, lTrack->Pt());\r
 366    \r
 367    \r
 368 \r
 369     if(hCutIndex)hCutIndex->Fill(kElectronIn);\r
 370 \r
 371     if (lTrack == NULL){\r
 372       if(hCutIndex)hCutIndex->Fill(kNoTracks);\r
 373          return kFALSE;  \r
 374     }   \r
 375        \r
 376     if ( ! lTrack->GetConstrainedParam() ){\r
 377         return kFALSE;\r
 378     }\r
 379     AliVTrack * track = dynamic_cast<AliVTrack*>(lTrack);\r
 380 \r
 381 \r
 382     // Track Cuts\r
 383     if( !TrackIsSelected(lTrack) ){\r
 384          if(hCutIndex)hCutIndex->Fill(kTrackCuts);\r
 385          return kFALSE;\r
 386     }\r
 387 \r
 388 \r
 389     // dEdx Cuts\r
 390     if( ! dEdxCuts( track ) ) {\r
 391          if(hCutIndex)hCutIndex->Fill(kdEdxCuts);\r
 392          return kFALSE;\r
 393 \r
 394     }\r
 395 \r
 396     //Electron passed the cuts\r
 397     if(hCutIndex)hCutIndex->Fill(kElectronOut);\r
 398     \r
 399     if( hTrackDCAxyPtafter)        hTrackDCAxyPtafter->Fill(dcaToVertexXY,lTrack->Pt());\r
 400     if( hTrackDCAzPtafter )        hTrackDCAzPtafter->Fill(dcaToVertexZ,lTrack->Pt());\r
 401     if( hTrackNFindClsPtTPCafter ) hTrackNFindClsPtTPCafter->Fill( clsToF, lTrack->Pt());\r
 402 \r
 403 \r
 404     return kTRUE;\r
 405 }\r
 406 \r
 407 ///________________________________________________________________________\r
 408 Bool_t AliDalitzElectronCuts::TrackIsSelected(AliESDtrack* lTrack) {\r
 409     // Track Selection for Photon Reconstruction\r
 410     \r
 411          \r
 412     Double_t clsToF = GetNFindableClustersTPC(lTrack);\r
 413     \r
 414 \r
 415     if( ! fesdTrackCuts->AcceptTrack(lTrack) ){\r
 416 \r
 417         return kFALSE;\r
 418     }\r
 419     \r
 420     if( fDoEtaCut ) {\r
 421       if(  lTrack->Eta() > (fEtaCut + fEtaShift) || lTrack->Eta() < (-fEtaCut + fEtaShift) ) {\r
 422         return kFALSE;\r
 423       }\r
 424    }\r
 425    \r
 426    \r
 427    if( lTrack->Pt() < fPtCut ) {\r
 428      \r
 429         return kFALSE;\r
 430         \r
 431    }\r
 432 \r
 433     /*if( lTrack->GetNcls(1) < fMinClsTPC ) {\r
 434 \r
 435         return kFALSE;\r
 436     }*/\r
 437 \r
 438         //Findable clusters\r
 439 \r
 440         /*Double_t clsToF=0;\r
 441 \r
 442 \r
 443             if (!fUseCorrectedTPCClsInfo ){\r
 444                 if(lTrack->GetTPCNclsF()!=0){\r
 445 \r
 446                 clsToF = (Double_t)lTrack->GetNcls(1)/(Double_t)lTrack->GetTPCNclsF();\r
 447                 }// Ncluster/Nfindablecluster\r
 448             }\r
 449           else {\r
 450 \r
 451               //clsToF = lTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));\r
 452               clsToF = lTrack->GetTPCClusterInfo(2,1); //NOTE ask friederike\r
 453               \r
 454           }*/\r
 455 \r
 456 \r
 457     if( clsToF < fMinClsTPCToF){\r
 458     return kFALSE;\r
 459     }\r
 460 \r
 461     \r
 462 \r
 463    return kTRUE;\r
 464 }\r
 465 ///________________________________________________________________________\r
 466 Bool_t AliDalitzElectronCuts::dEdxCuts(AliVTrack *fCurrentTrack){\r
 467 \r
 468     // Electron Identification Cuts for Photon reconstruction\r
 469 \r
 470     if(!fPIDResponse){  InitPIDResponse();  }// Try to reinitialize PID Response\r
 471     if(!fPIDResponse){  AliError("No PID Response"); return kFALSE;}// if still missing fatal error\r
 472 \r
 473 \r
 474 \r
 475     //cout<<"dEdxCuts: //////////////////////////////////////////////////////////////////////////"<<endl;\r
 476 \r
 477 \r
 478 \r
 479     Int_t cutIndex=0;\r
 480 \r
 481     if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 482     if(hITSdEdxbefore)hITSdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));\r
 483     if(hTPCdEdxbefore)hTPCdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));\r
 484     if(hTPCdEdxSignalbefore)hTPCdEdxSignalbefore->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));\r
 485 \r
 486 \r
 487     cutIndex++;\r
 488 \r
 489 \r
 490                 if( fDodEdxSigmaITSCut == kTRUE ){\r
 491 \r
 492 \r
 493                         if( fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineITS ||\r
 494                                         fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)> fPIDnSigmaAboveElectronLineITS ){\r
 495                                 \r
 496                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 497                                 return kFALSE;\r
 498       }\r
 499                         \r
 500                 }\r
 501                 \r
 502                 if(hITSdEdxafter)hITSdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));\r
 503                 \r
 504                 \r
 505                 cutIndex++;\r
 506                 \r
 507                 \r
 508                 if(fDodEdxSigmaTPCCut == kTRUE){\r
 509                         \r
 510                         \r
 511       // TPC Electron Line\r
 512       if( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineTPC ||\r
 513                                         fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaAboveElectronLineTPC){\r
 514                                 \r
 515                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 516                                 return kFALSE;\r
 517       }\r
 518       cutIndex++;\r
 519                         \r
 520       // TPC Pion Line\r
 521                         if( fCurrentTrack->P()>fPIDMinPnSigmaAbovePionLineTPC && fCurrentTrack->P()<fPIDMaxPnSigmaAbovePionLineTPC ){\r
 522                                 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC     &&\r
 523                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC &&\r
 524                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPC){\r
 525                                         \r
 526                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 527                                         return kFALSE;\r
 528                                 }\r
 529                         }\r
 530                         cutIndex++;\r
 531                         \r
 532                         // High Pt Pion rej\r
 533                         if( fCurrentTrack->P()>fPIDMaxPnSigmaAbovePionLineTPC ){\r
 534                                 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC &&\r
 535                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC&&\r
 536                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPCHighPt){\r
 537                                         \r
 538                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 539                                         return kFALSE;\r
 540                                 }\r
 541                         }\r
 542                         \r
 543                         cutIndex++;\r
 544                 }\r
 545 \r
 546                 else{ cutIndex+=3; }\r
 547 \r
 548 \r
 549                 if(   fDoKaonRejectionLowP == kTRUE   ){\r
 550 \r
 551                         if( fCurrentTrack->P() < fPIDMinPKaonRejectionLowP ){\r
 552                                 \r
 553                                 if( TMath::Abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kKaon))<fPIDnSigmaAtLowPAroundKaonLine){\r
 554                                         \r
 555                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 556                                         \r
 557                                         return kFALSE;\r
 558                                 }\r
 559                         }\r
 560                 }\r
 561                 cutIndex++;\r
 562                 \r
 563                 if(   fDoProtonRejectionLowP == kTRUE    ){\r
 564                         \r
 565                         if( fCurrentTrack->P()  < fPIDMinPProtonRejectionLowP ){\r
 566                                 if( TMath::Abs(   fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kProton))<fPIDnSigmaAtLowPAroundProtonLine){\r
 567                                         \r
 568                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 569                                         return kFALSE;\r
 570                                 }\r
 571                         }\r
 572                 }\r
 573                 cutIndex++;\r
 574                 \r
 575                 if(fDoPionRejectionLowP == kTRUE){\r
 576                         if( fCurrentTrack->P() < fPIDMinPPionRejectionLowP ){\r
 577                                 if( TMath::Abs( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)) < fPIDnSigmaAtLowPAroundPionLine ){\r
 578                                         \r
 579                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 580                                         return kFALSE;\r
 581                                 }\r
 582                         }\r
 583                 }\r
 584                 cutIndex++;\r
 585                 \r
 586                 \r
 587                 if( ( fCurrentTrack->GetStatus() & AliESDtrack::kTOFpid ) && ( !( fCurrentTrack->GetStatus() & AliESDtrack::kTOFmismatch) ) ){\r
 588                         if(hTOFbefore) hTOFbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));\r
 589                         if(fUseTOFpid){\r
 590         if(fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)>fTofPIDnSigmaAboveElectronLine ||\r
 591            fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)<fTofPIDnSigmaBelowElectronLine ){\r
 592                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 593                                         return kFALSE;\r
 594         }\r
 595                         }\r
 596                         if(hTOFafter)hTOFafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));\r
 597                 }\r
 598                 else if ( fRequireTOF == kTRUE ) {\r
 599                         \r
 600                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 601                         return kFALSE;\r
 602                 }\r
 603                 cutIndex++;\r
 604                 \r
 605                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 606                 if(hTPCdEdxafter)hTPCdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));\r
 607                 if(hTPCdEdxSignalafter)hTPCdEdxSignalafter->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));\r
 608                 \r
 609                 return kTRUE;\r
 610 }\r
 611 ///________________________________________________________________________\r
 612 \r
 613 \r
 614 AliVTrack *AliDalitzElectronCuts::GetTrack(AliVEvent * event, Int_t label){\r
 615     //Returns pointer to the track with given ESD label\r
 616     //(Important for AOD implementation, since Track array in AOD data is different\r
 617     //from ESD array, but ESD tracklabels are stored in AOD Tracks)\r
 618 \r
 619   AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);\r
 620   if(esdEvent) {\r
 621         if(label > event->GetNumberOfTracks() ) return NULL;\r
 622         AliESDtrack * track = esdEvent->GetTrack(label);\r
 623         return track;\r
 624         \r
 625   } else { \r
 626         for(Int_t ii=0; ii<event->GetNumberOfTracks(); ii++) {\r
 627           AliVTrack * track = dynamic_cast<AliVTrack*>(event->GetTrack(ii));\r
 628           \r
 629           if(track) { \r
 630                 if(track->GetID() == label) {\r
 631                   return track;\r
 632                 }\r
 633           }\r
 634         }\r
 635     }\r
 636   \r
 637   cout << "track not found " << label << " " << event->GetNumberOfTracks() << endl;\r
 638   return NULL;\r
 639 }\r
 640 ///________________________________________________________________________\r
 641 Bool_t AliDalitzElectronCuts::RejectSharedElecGamma(TList *photons, Int_t indexEle){\r
 642 \r
 643 \r
 644      for(Int_t i = 0;i<photons->GetEntries();i++){\r
 645 \r
 646       AliAODConversionPhoton *photonComp = (AliAODConversionPhoton*) photons->At(i);\r
 647 \r
 648       Int_t posLabel = photonComp->GetTrackLabelPositive();\r
 649       Int_t negLabel = photonComp->GetTrackLabelNegative();\r
 650 \r
 651       if( (photonComp->GetConversionRadius() < fRadiusCut) && (posLabel == indexEle || negLabel == indexEle) ){\r
 652         return kFALSE;\r
 653       }\r
 654      }\r
 655 \r
 656    return kTRUE;\r
 657 }\r
 658 Bool_t AliDalitzElectronCuts::MassCut(Double_t pi0CandidatePt , Double_t vphotonCandidateMass){\r
 659   \r
 660         if( pi0CandidatePt < fMassCutPtMin ){\r
 661           \r
 662               if( vphotonCandidateMass < fMassCutLowPt ){\r
 663                     return kTRUE;\r
 664               }\r
 665                 \r
 666         }\r
 667         else{\r
 668           \r
 669                if( vphotonCandidateMass < fMassCutHighPt ){\r
 670                     return kTRUE;\r
 671                }\r
 672               \r
 673         }\r
 674         \r
 675         return kFALSE;\r
 676           \r
 677 }\r
 678 \r
 679 Double_t AliDalitzElectronCuts::GetNFindableClustersTPC(AliESDtrack* lTrack){\r
 680   \r
 681   \r
 682   Double_t clsToF=0;\r
 683 \r
 684 \r
 685     if ( !fUseCorrectedTPCClsInfo ){\r
 686         if(lTrack->GetTPCNclsF()!=0){\r
 687 \r
 688               clsToF = (Double_t)lTrack->GetNcls(1)/(Double_t)lTrack->GetTPCNclsF();\r
 689         }// Ncluster/Nfindablecluster\r
 690     }\r
 691     else {\r
 692 \r
 693               //clsToF = lTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));\r
 694               clsToF = lTrack->GetTPCClusterInfo(2,1); //NOTE ask friederike\r
 695                 \r
 696     }\r
 697   \r
 698   return clsToF;\r
 699    \r
 700 }\r
 701 \r
 702 /*\r
 703 Double_t AliDalitzElectronCuts::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg )\r
 704 {\r
 705 //\r
 706 // This angle is a measure for the contribution of the opening in polar\r
 707 // direction ??0 to the opening angle ?? Pair\r
 708 //\r
 709 // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC\r
 710 //      Master Thesis. Thorsten Dahms. 2005\r
 711 // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf\r
 712 //\r
 713         Double_t momPos[3];\r
 714         Double_t momNeg[3];\r
 715         if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );\r
 716         if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );\r
 717 \r
 718         TVector3 posDaughter;\r
 719         TVector3 negDaughter;\r
 720 \r
 721         posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );\r
 722         negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );\r
 723 \r
 724         Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();\r
 725         Double_t openingAngle =  posDaughter.Angle( negDaughter );  //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );\r
 726 \r
 727         if( openingAngle < 1e-20 ) return 0.;\r
 728 \r
 729         Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );\r
 730 \r
 731         return psiAngle;\r
 732 }*/\r
 733 \r
 734 Bool_t AliDalitzElectronCuts::IsFromGammaConversion( Double_t psiPair, Double_t deltaPhi )\r
 735 {\r
 736 //\r
 737 // Returns true if it is a gamma conversion according to psi pair value\r
 738 //\r
 739         return ( (deltaPhi > fDeltaPhiCutMin  &&  deltaPhi < fDeltaPhiCutMax) &&\r
 740         TMath::Abs(psiPair) < ( fPsiPairCut - fPsiPairCut/fDeltaPhiCutMax * deltaPhi ) );\r
 741 }\r
 742 \r
 743 ///________________________________________________________________________\r
 744 Bool_t AliDalitzElectronCuts::UpdateCutString(cutIds cutID, Int_t value) {\r
 745 ///Update the cut string (if it has been created yet)\r
 746 \r
 747   if(fCutString && fCutString->GetString().Length() == kNCuts) {\r
 748 //         cout << "Updating cut id in spot number " << cutID << " to " << value << endl;\r
 749         fCutString->SetString(GetCutNumber());\r
 750   } else {\r
 751 //         cout << "fCutString not yet initialized, will not be updated" << endl;\r
 752         return kFALSE;\r
 753   }\r
 754  // cout << fCutString->GetString().Data() << endl;\r
 755   return kTRUE;\r
 756 }\r
 757 \r
 758 ///________________________________________________________________________\r
 759 Bool_t AliDalitzElectronCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {\r
 760    // Initialize Cuts from a given Cut string\r
 761 \r
 762 //   out<<"Set Cut Number: "<<analysisCutSelection.Data()<<endl;\r
 763   AliInfo(Form("Set ElectronCuts Number: %s",analysisCutSelection.Data()));\r
 764   \r
 765   if(analysisCutSelection.Length()!=kNCuts) {\r
 766         AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));\r
 767         return kFALSE;\r
 768   }\r
 769   if(!analysisCutSelection.IsDigit()){\r
 770         AliError("Cut selection contains characters");\r
 771         return kFALSE;\r
 772   }\r
 773   \r
 774   const char *cutSelection = analysisCutSelection.Data();\r
 775   #define ASSIGNARRAY(i)        fCuts[i] = cutSelection[i] - '0'\r
 776   for(Int_t ii=0;ii<kNCuts;ii++){\r
 777       ASSIGNARRAY(ii);\r
 778   }\r
 779 \r
 780   // TestFlag\r
 781   if(fCuts[0] !=9){\r
 782     AliError("Analysis Cut Selection does not start with 9");\r
 783         PrintCuts();\r
 784     return kFALSE;\r
 785   }\r
 786 \r
 787   // Set Individual Cuts\r
 788   for(Int_t ii=0;ii<kNCuts;ii++){\r
 789       if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;\r
 790   }\r
 791 \r
 792   //PrintCuts();\r
 793 \r
 794     return kTRUE;\r
 795 }\r
 796 ///________________________________________________________________________\r
 797 Bool_t AliDalitzElectronCuts::SetCut(cutIds cutID, const Int_t value) {\r
 798   ///Set individual cut ID\r
 799 \r
 800   //cout << "Updating cut  " << fgkCutNames[cutID] << " (" << cutID << ") to " << value << endl;\r
 801 \r
 802   switch (cutID) {\r
 803   case kgoodId:\r
 804         fCuts[kgoodId] = value;\r
 805         if(value != 9) {\r
 806           cout << "Error:: First value of cut string is wrong, aborting!!" << endl;\r
 807           return kFALSE;\r
 808         } else {\r
 809           return kTRUE;\r
 810         }\r
 811 \r
 812   case kededxSigmaITSCut:\r
 813         if( SetITSdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented \r
 814           fCuts[kededxSigmaITSCut] = value;\r
 815           UpdateCutString(cutID, value);\r
 816           return kTRUE;\r
 817         } else return kFALSE;\r
 818 \r
 819         case kededxSigmaTPCCut:\r
 820                 if( SetTPCdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented \r
 821                         fCuts[kededxSigmaTPCCut] = value;\r
 822                         UpdateCutString(cutID, value);\r
 823                         return kTRUE;\r
 824                 } else return kFALSE;\r
 825                 \r
 826   case kpidedxSigmaTPCCut:\r
 827                 if( SetTPCdEdxCutPionLine(value)) { //NOTE SetITSdEdxCutPionLine: To be implemented\r
 828                         fCuts[kpidedxSigmaTPCCut] = value;\r
 829                         UpdateCutString(cutID, value);\r
 830                         return kTRUE;\r
 831                 } else return kFALSE;\r
 832                 \r
 833   case kpiMinMomdedxSigmaTPCCut:\r
 834                 if( SetMinMomPiondEdxTPCCut(value)) {\r
 835                         fCuts[kpiMinMomdedxSigmaTPCCut] = value;\r
 836                         UpdateCutString(cutID, value);\r
 837                         return kTRUE;\r
 838                 } else return kFALSE;\r
 839                 \r
 840   case kpiMaxMomdedxSigmaTPCCut:\r
 841                 if( SetMaxMomPiondEdxTPCCut(value)) {\r
 842                         fCuts[kpiMaxMomdedxSigmaTPCCut] = value;\r
 843                         UpdateCutString(cutID, value);\r
 844                         return kTRUE;\r
 845                 } else return kFALSE;\r
 846                 \r
 847   case kLowPRejectionSigmaCut:\r
 848                 if( SetLowPRejectionCuts(value) ) {\r
 849                         fCuts[kLowPRejectionSigmaCut] = value;\r
 850                         UpdateCutString(cutID, value);\r
 851                         return kTRUE;\r
 852                 } else return kFALSE;\r
 853                 \r
 854                 \r
 855   case kTOFelectronPID:\r
 856                 if( SetTOFElectronPIDCut(value)) {\r
 857                         fCuts[kTOFelectronPID] = value;\r
 858                         UpdateCutString(cutID, value);\r
 859                         return kTRUE;\r
 860                 } else return kFALSE;\r
 861   case kclsITSCut:\r
 862                 if( SetITSClusterCut(value) ) {\r
 863                         fCuts[kclsITSCut] = value;\r
 864                         UpdateCutString(cutID, value);\r
 865                         return kTRUE;                   \r
 866                 } else return kFALSE;\r
 867   case kclsTPCCut:\r
 868                 if( SetTPCClusterCut(value)) {\r
 869                         fCuts[kclsTPCCut] = value;\r
 870                         UpdateCutString(cutID, value);\r
 871                         return kTRUE;\r
 872                 } else return kFALSE;\r
 873                 \r
 874   case ketaCut:\r
 875                 if( SetEtaCut(value)) {\r
 876                         fCuts[ketaCut] = value;\r
 877                         UpdateCutString(cutID, value);\r
 878                         return kTRUE;\r
 879                 } else return kFALSE;\r
 880   case kptCut:  \r
 881                 if( SetPtCut(value)) {\r
 882                         fCuts[kptCut] = value;\r
 883                         UpdateCutString(cutID, value);\r
 884                         return kTRUE;\r
 885                 } else return kFALSE;\r
 886     \r
 887   case kDCACut:\r
 888                 if( SetDCACut(value)) {\r
 889                         fCuts[kDCACut] = value;\r
 890                         UpdateCutString(cutID, value);\r
 891                         return kTRUE;\r
 892                 } else return kFALSE;\r
 893               \r
 894               \r
 895         case kPsiPair:\r
 896                 if( SetPsiPairCut(value)) {\r
 897                         fCuts[kPsiPair] = value;\r
 898                         UpdateCutString(cutID, value);\r
 899                         return kTRUE;\r
 900                 } else return kFALSE;\r
 901                 \r
 902   case kRejectSharedElecGamma:\r
 903                 if( SetRejectSharedElecGamma(value)) {\r
 904                         fCuts[kRejectSharedElecGamma] = value;\r
 905                         UpdateCutString(cutID, value);\r
 906           return kTRUE;\r
 907                 } else return kFALSE;\r
 908                 \r
 909   case kBackgroundScheme:\r
 910                 if( SetBackgroundScheme(value)) {\r
 911                         fCuts[kBackgroundScheme] = value;\r
 912                         UpdateCutString(cutID, value);\r
 913                         return kTRUE;\r
 914                 } else return kFALSE;\r
 915 \r
 916   case kNumberOfRotations:\r
 917                 if( SetNumberOfRotations(value)) {\r
 918                         fCuts[kNumberOfRotations] = value;\r
 919                         UpdateCutString(cutID, value);\r
 920                         return kTRUE;\r
 921                 } else return kFALSE;\r
 922                 \r
 923   case kmassCut:\r
 924                 if( SetMassCut(value)) {\r
 925                         fCuts[kmassCut] = value;\r
 926                         UpdateCutString(cutID, value);\r
 927                         return kTRUE;\r
 928                 } else return kFALSE;\r
 929                 \r
 930   case kNCuts:\r
 931                 cout << "Error:: Cut id out of range"<< endl;\r
 932                 return kFALSE;\r
 933   }\r
 934         \r
 935   cout << "Error:: Cut id " << cutID << " not recognized "<< endl;\r
 936   return kFALSE;\r
 937 \r
 938   //PrintCuts();\r
 939   \r
 940 }\r
 941 \r
 942 ///________________________________________________________________________\r
 943 \r
 944 void AliDalitzElectronCuts::PrintCuts() {\r
 945     // Print out current Cut Selection\r
 946   for(Int_t ic = 0; ic < kNCuts; ic++) {\r
 947         printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);\r
 948   }\r
 949 \r
 950 }\r
 951 \r
 952 ///________________________________________________________________________\r
 953 Bool_t AliDalitzElectronCuts::SetITSdEdxCutElectronLine(Int_t ededxSigmaCut)\r
 954 {   // Set Cut\r
 955 \r
 956         switch(ededxSigmaCut){\r
 957 \r
 958         case 0: \r
 959                 fDodEdxSigmaITSCut = kFALSE;\r
 960                 fPIDnSigmaBelowElectronLineITS=-100;\r
 961                 fPIDnSigmaAboveElectronLineITS= 100;\r
 962                 break;\r
 963         case 1: // -10,10\r
 964                 fDodEdxSigmaITSCut = kTRUE;\r
 965                 fPIDnSigmaBelowElectronLineITS=-10;\r
 966                 fPIDnSigmaAboveElectronLineITS=10;\r
 967                 break;\r
 968         case 2: // -6,7\r
 969                 fDodEdxSigmaITSCut = kTRUE;\r
 970                 fPIDnSigmaBelowElectronLineITS=-6;\r
 971                 fPIDnSigmaAboveElectronLineITS=7;\r
 972                 break;\r
 973         case 3: // -5,5\r
 974                 fDodEdxSigmaITSCut = kTRUE;\r
 975                 fPIDnSigmaBelowElectronLineITS=-5;\r
 976                 fPIDnSigmaAboveElectronLineITS=5;\r
 977                 break;\r
 978         case 4: // -4,5\r
 979                 fDodEdxSigmaITSCut = kTRUE;\r
 980                 fPIDnSigmaBelowElectronLineITS=-4;\r
 981                 fPIDnSigmaAboveElectronLineITS=5;\r
 982                 break;\r
 983         case 5: // -3,5\r
 984                 fDodEdxSigmaITSCut = kTRUE;\r
 985                 fPIDnSigmaBelowElectronLineITS=-3;\r
 986                 fPIDnSigmaAboveElectronLineITS=5;\r
 987                 break;\r
 988         case 6: // -4,4\r
 989                 fDodEdxSigmaITSCut = kTRUE;\r
 990                 fPIDnSigmaBelowElectronLineITS=-4;\r
 991                 fPIDnSigmaAboveElectronLineITS=4;\r
 992                 break;\r
 993         case 7: // -2.5,4\r
 994                 fDodEdxSigmaITSCut = kTRUE;\r
 995                 fPIDnSigmaBelowElectronLineITS=-2.5;\r
 996                 fPIDnSigmaAboveElectronLineITS=4;\r
 997                 break;\r
 998         case 8: // -2,3.5\r
 999                 fDodEdxSigmaITSCut = kTRUE;\r
1000                 fPIDnSigmaBelowElectronLineITS=-2;\r
1001                 fPIDnSigmaAboveElectronLineITS=3.5;\r
1002                 break;\r
1003         default:\r
1004                 cout<<"Warning: ITSdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;\r
1005                 return kFALSE;\r
1006     \r
1007         }\r
1008         return kTRUE;\r
1009 }\r
1010 \r
1011 ///________________________________________________________________________\r
1012 Bool_t AliDalitzElectronCuts::SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut)\r
1013 {   // Set Cut\r
1014         switch(ededxSigmaCut){\r
1015 \r
1016         case 0: fDodEdxSigmaTPCCut = kFALSE;\r
1017                 fPIDnSigmaBelowElectronLineTPC=-10;\r
1018                 fPIDnSigmaAboveElectronLineTPC=10;\r
1019                 break;\r
1020         case 1: // -10,10\r
1021                 fDodEdxSigmaTPCCut = kTRUE;\r
1022                 fPIDnSigmaBelowElectronLineTPC=-10;\r
1023                 fPIDnSigmaAboveElectronLineTPC=10;\r
1024                 break;\r
1025         case 2: // -6,7\r
1026                 fDodEdxSigmaTPCCut = kTRUE;\r
1027                 fPIDnSigmaBelowElectronLineTPC=-6;\r
1028                 fPIDnSigmaAboveElectronLineTPC=7;\r
1029                 break;\r
1030         case 3: // -5,5\r
1031                 fDodEdxSigmaTPCCut = kTRUE;\r
1032                 fPIDnSigmaBelowElectronLineTPC=-5;\r
1033                 fPIDnSigmaAboveElectronLineTPC=5;\r
1034                 break;\r
1035         case 4: // -4,5\r
1036                 fDodEdxSigmaTPCCut = kTRUE;\r
1037                 fPIDnSigmaBelowElectronLineTPC=-4;\r
1038                 fPIDnSigmaAboveElectronLineTPC=5;\r
1039                 break;  \r
1040         case 5: // -3,5\r
1041                 fDodEdxSigmaTPCCut = kTRUE;\r
1042                 fPIDnSigmaBelowElectronLineTPC=-3;\r
1043                 fPIDnSigmaAboveElectronLineTPC=5;\r
1044                 break;\r
1045         case 6: // -4,4\r
1046                 fDodEdxSigmaTPCCut = kTRUE;\r
1047                 fPIDnSigmaBelowElectronLineTPC=-4;\r
1048                 fPIDnSigmaAboveElectronLineTPC=4;\r
1049                 break;\r
1050         case 7: // -2.5,4\r
1051                 fDodEdxSigmaTPCCut = kTRUE;\r
1052                 fPIDnSigmaBelowElectronLineTPC=-2.5;\r
1053                 fPIDnSigmaAboveElectronLineTPC=4;\r
1054                 break;\r
1055         case 8: // -2,3.5\r
1056                 fDodEdxSigmaTPCCut = kTRUE;\r
1057                 fPIDnSigmaBelowElectronLineTPC=-2;\r
1058                 fPIDnSigmaAboveElectronLineTPC=3.5;\r
1059                 break;\r
1060         default:\r
1061                 cout<<"Warning: TPCdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;\r
1062                 return kFALSE;\r
1063     \r
1064         }\r
1065         return kTRUE;\r
1066 }\r
1067 \r
1068 ///________________________________________________________________________\r
1069 Bool_t AliDalitzElectronCuts::SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut)\r
1070 {   // Set Cut\r
1071 \r
1072         switch(pidedxSigmaCut){\r
1073                 \r
1074         case 0: fPIDnSigmaAbovePionLineTPC= 0;\r
1075                 fPIDnSigmaAbovePionLineTPCHighPt=-100;\r
1076                 break;\r
1077         case 1:  // -10\r
1078                 fPIDnSigmaAbovePionLineTPC=3.0;              //Update Sep-05-2013 from -10 to 3\r
1079                 fPIDnSigmaAbovePionLineTPCHighPt=-10;        \r
1080                 break;\r
1081         case 2:  // 1\r
1082                 fPIDnSigmaAbovePionLineTPC=-1;\r
1083                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1084                 break;\r
1085         case 3:   // 0\r
1086                 fPIDnSigmaAbovePionLineTPC=0;\r
1087                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1088                 break;\r
1089         case 4:  // 1\r
1090                 fPIDnSigmaAbovePionLineTPC=1;\r
1091                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1092                 break;\r
1093         case 5:  // 1\r
1094                 fPIDnSigmaAbovePionLineTPC=2.;\r
1095                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1096                 break;\r
1097         case 6:  // 1\r
1098                 fPIDnSigmaAbovePionLineTPC=2.5;\r
1099                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1100                 break;\r
1101         case 7:\r
1102                 fPIDnSigmaAbovePionLineTPC = 2.0; // We need a bit less tight cut on dE/dx //Updated from 3.0 and -10 to +2.0 , +2.0 \r
1103                 fPIDnSigmaAbovePionLineTPCHighPt = 2.0;\r
1104                 break;\r
1105         case 8:  // 1\r
1106                 fPIDnSigmaAbovePionLineTPC = 1.5;   // Updated May-16-2013 from 3.5 and -10 to +1.5, +1\r
1107                 fPIDnSigmaAbovePionLineTPCHighPt = 1.0;\r
1108                 break;\r
1109         case 9:  // 1\r
1110                 fPIDnSigmaAbovePionLineTPC=1.5;\r
1111                 fPIDnSigmaAbovePionLineTPCHighPt=-1.0;\r
1112                 break;\r
1113         default:\r
1114                 cout<<"Warning: pidedxSigmaCut not defined "<<pidedxSigmaCut<<endl;\r
1115                 return kFALSE;\r
1116         }\r
1117         return kTRUE;\r
1118 }\r
1119 \r
1120 ///________________________________________________________________________\r
1121 Bool_t AliDalitzElectronCuts::SetMinMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut)\r
1122 {   // Set Cut\r
1123         switch(piMomdedxSigmaCut){\r
1124                 \r
1125         case 0: fPIDMinPnSigmaAbovePionLineTPC=0.;\r
1126                 break;\r
1127         case 1:  // 50.0 GeV\r
1128                 fPIDMinPnSigmaAbovePionLineTPC=50.;\r
1129                 break;\r
1130         case 2:  // 20.0 GeV\r
1131                 fPIDMinPnSigmaAbovePionLineTPC=20.;\r
1132                 break;\r
1133         case 3:  // 1.5 GeV\r
1134                 fPIDMinPnSigmaAbovePionLineTPC=1.5;\r
1135                 break;\r
1136         case 4:  // 1. GeV\r
1137                 fPIDMinPnSigmaAbovePionLineTPC=1.;\r
1138                 break;  \r
1139         case 5:  // 0.5 GeV\r
1140                 fPIDMinPnSigmaAbovePionLineTPC=0.5;\r
1141                 break;\r
1142         case 6:  // 0.4 GeV\r
1143                 fPIDMinPnSigmaAbovePionLineTPC=0.4;\r
1144                 break;    \r
1145         case 7:  // 0.3 GeV\r
1146                 fPIDMinPnSigmaAbovePionLineTPC=0.3;\r
1147                 break;\r
1148         case 8:  // 0.25 GeV\r
1149                 fPIDMinPnSigmaAbovePionLineTPC=0.25;\r
1150                 break;\r
1151         default:\r
1152                 cout<<"Warning: piMomdedxSigmaCut not defined "<<piMomdedxSigmaCut<<endl;\r
1153                 return kFALSE;\r
1154         }\r
1155         return kTRUE;\r
1156 }\r
1157 ///________________________________________________________________________\r
1158 Bool_t AliDalitzElectronCuts::SetITSClusterCut(Int_t clsITSCut){\r
1159 \r
1160     \r
1161         if( !fesdTrackCuts ) {\r
1162 \r
1163                 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;\r
1164                 return kFALSE;\r
1165         }\r
1166 \r
1167         switch(clsITSCut){\r
1168 \r
1169         case 0: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);\r
1170                 break;\r
1171         case 1: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);\r
1172                 break;  //1 hit first layer of SPD\r
1173         case 2: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1174                 break; //1 hit in any layer of SPD\r
1175         case 3: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);\r
1176                 fesdTrackCuts->SetMinNClustersITS(4);\r
1177                 // 4 hits in total in the ITS. At least 1 hit in the first layer of SPD  \r
1178                 break;\r
1179         case 4: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1180                 fesdTrackCuts->SetMinNClustersITS(3);\r
1181                 // 3 hits in total in the ITS. At least 1 hit in any layer of SPD\r
1182                 break;\r
1183         case 5: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1184                 fesdTrackCuts->SetMinNClustersITS(4);\r
1185                 // 4 hits in total in the ITS. At least 1 hit in any layer of SPD\r
1186                 break;\r
1187         case 6: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1188                 fesdTrackCuts->SetMinNClustersITS(5);\r
1189                 // 5 hits in total in the ITS. At least 1 hit in any layer of SPD\r
1190                 break;\r
1191         default:\r
1192                 cout<<"Warning: clsITSCut not defined "<<clsITSCut<<endl;\r
1193                 return kFALSE;\r
1194         }\r
1195         \r
1196 return kTRUE;\r
1197 }\r
1198 \r
1199 ///________________________________________________________________________\r
1200 Bool_t AliDalitzElectronCuts::SetTPCClusterCut(Int_t clsTPCCut)\r
1201 {   // Set Cut\r
1202         switch(clsTPCCut){\r
1203         case 0: // 0\r
1204                 fMinClsTPC= 0.;\r
1205                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1206                 break;\r
1207         case 1:  // 70\r
1208                 fMinClsTPC= 70.;\r
1209                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1210                 break;\r
1211         case 2:  // 80\r
1212                 fMinClsTPC= 80.;\r
1213                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1214                 break;\r
1215         case 3:  // 100\r
1216                 fMinClsTPC= 100.;\r
1217                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1218                 break;\r
1219         case 4:  // 0% of findable clusters\r
1220                 fMinClsTPC= 70.;  \r
1221                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1222                 fMinClsTPCToF= 0.0;\r
1223                 fUseCorrectedTPCClsInfo=0;\r
1224                 break;\r
1225         case 5:  // 35% of findable clusters\r
1226                 fMinClsTPC = 70.;  \r
1227                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1228                 fMinClsTPCToF= 0.35;\r
1229                 fUseCorrectedTPCClsInfo=0;\r
1230                 break;\r
1231         case 6:  // 60% of findable clusters\r
1232                 fMinClsTPC= 70.;  \r
1233                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1234                 fMinClsTPCToF= 0.6;\r
1235                 fUseCorrectedTPCClsInfo=0;\r
1236                 break;\r
1237         case 7:  // 70% of findable clusters\r
1238                 fMinClsTPC= 70.;  \r
1239                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1240                 fMinClsTPCToF= 0.7;\r
1241                 fUseCorrectedTPCClsInfo=0;\r
1242                 break;\r
1243         case 8: fMinClsTPC = 0.;  \r
1244                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1245                 fMinClsTPCToF= 0.35;\r
1246                 fUseCorrectedTPCClsInfo=0;\r
1247                 break;\r
1248           \r
1249         default:\r
1250                 cout<<"Warning: clsTPCCut not defined "<<clsTPCCut<<endl;\r
1251                 return kFALSE;\r
1252         }\r
1253         return kTRUE;\r
1254 }\r
1255 \r
1256 ///________________________________________________________________________\r
1257 Bool_t AliDalitzElectronCuts::SetEtaCut(Int_t etaCut)\r
1258 { \r
1259   // Set eta Cut\r
1260         switch(etaCut){\r
1261         case 0: \r
1262                 fEtaCut = 100.;\r
1263                 fDoEtaCut = kFALSE;\r
1264                 break;\r
1265         case 1: // 1.4\r
1266                 fEtaCut = 1.4;\r
1267                 fDoEtaCut = kTRUE;\r
1268                 break;\r
1269         case 2: // 1.2\r
1270                 fEtaCut = 1.2;\r
1271                 fDoEtaCut = kTRUE;\r
1272                 break;\r
1273         case 3: // 0.9\r
1274                 fEtaCut = 0.9;\r
1275                 fDoEtaCut = kTRUE;\r
1276                 break;\r
1277         case 4: // 0.8\r
1278                 fEtaCut = 0.8;\r
1279                 fDoEtaCut = kTRUE;\r
1280                 break;\r
1281         case 5: // 0.75\r
1282                 fEtaCut = 0.75;\r
1283                 fDoEtaCut = kTRUE;\r
1284                 break;\r
1285         case 6: //0.6\r
1286                 fEtaCut = 0.6; //changed from 0.4 to 0.6 2013.06.10\r
1287                 fDoEtaCut = kTRUE;\r
1288                 break;\r
1289         case 7: //0.5\r
1290                 fEtaCut = 0.5; //changed from 0.3 to 0.5 2013.06.10\r
1291                 fDoEtaCut = kTRUE;\r
1292                 break;\r
1293         case 8: fEtaCut = 0.4;\r
1294                 fDoEtaCut = kTRUE;\r
1295                 break;\r
1296         default:\r
1297                 cout<<"Warning: EtaCut not defined "<<etaCut<<endl;\r
1298                 return kFALSE;\r
1299         }\r
1300         return kTRUE;\r
1301 }\r
1302 \r
1303 ///________________________________________________________________________\r
1304 Bool_t AliDalitzElectronCuts::SetPtCut(Int_t ptCut)\r
1305 { \r
1306         // Set Pt Cut\r
1307          //0.1GeV, 0.125 GeV, 0.15 GeV\r
1308   \r
1309         switch(ptCut){\r
1310           \r
1311         case 0: fPtCut = 0.075;         \r
1312                 break;\r
1313         case 1:  // 0.1\r
1314                 fPtCut  = 0.1;  \r
1315                 break;\r
1316         case 2:  // 0.125 GeV\r
1317                 fPtCut  = 0.125;                \r
1318                 break;\r
1319         case 3: // 0.15 GeV\r
1320                 fPtCut  = 0.15;\r
1321                 break;\r
1322         default:\r
1323                 cout<<"Warning: PtCut not defined "<<ptCut<<endl;\r
1324                 return kFALSE;\r
1325         }\r
1326         return kTRUE;\r
1327 }\r
1328 \r
1329 \r
1330 ///________________________________________________________________________\r
1331 Bool_t AliDalitzElectronCuts::SetDCACut(Int_t dcaCut)\r
1332 { \r
1333   // Set DCA Cut\r
1334   \r
1335         if( !fesdTrackCuts ) {\r
1336 \r
1337                 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;\r
1338                 return kFALSE;\r
1339         }\r
1340   \r
1341         switch(dcaCut){\r
1342           \r
1343         case 0: \r
1344                 //Open cuts//\r
1345                 fesdTrackCuts->SetMaxDCAToVertexZ(1000);\r
1346                 fesdTrackCuts->SetMaxDCAToVertexXY(1000);\r
1347                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1348                 break;\r
1349                \r
1350         case 1: \r
1351                 fesdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");\r
1352                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1353                 \r
1354                 break;\r
1355         case 2: fesdTrackCuts->SetMaxDCAToVertexZ(2);\r
1356                 fesdTrackCuts->SetMaxDCAToVertexXY(1);\r
1357                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1358                 break; \r
1359                 \r
1360         default:\r
1361                 cout<<"Warning: dcaCut not defined "<<dcaCut<<endl;\r
1362                 return kFALSE;\r
1363         }\r
1364         return kTRUE;\r
1365 }\r
1366 \r
1367 \r
1368 \r
1369 \r
1370 ///________________________________________________________________________\r
1371 Bool_t AliDalitzElectronCuts::SetMaxMomPiondEdxTPCCut(Int_t piMaxMomdedxSigmaCut)\r
1372 {   // Set Cut\r
1373    switch(piMaxMomdedxSigmaCut){\r
1374 \r
1375          case 0: \r
1376                  fPIDMaxPnSigmaAbovePionLineTPC=0.;\r
1377                  break;\r
1378          case 1:  // 100. GeV\r
1379                  fPIDMaxPnSigmaAbovePionLineTPC=100.;\r
1380                  break;\r
1381          case 2:  // 5. GeV\r
1382                  fPIDMaxPnSigmaAbovePionLineTPC=5.;\r
1383                         break;\r
1384          case 3:  // 4. GeV\r
1385                  fPIDMaxPnSigmaAbovePionLineTPC=4.;\r
1386                  break;\r
1387          case 4:  // 3.5 GeV\r
1388                  fPIDMaxPnSigmaAbovePionLineTPC=3.5;\r
1389                  break;\r
1390          case 5:  // 3. GeV\r
1391                  fPIDMaxPnSigmaAbovePionLineTPC=3.;\r
1392                  break;\r
1393          default:\r
1394                  cout<<"Warning: piMaxMomdedxSigmaCut not defined "<<piMaxMomdedxSigmaCut<<endl;\r
1395                  return kFALSE;\r
1396          }\r
1397          return kTRUE;\r
1398 }\r
1399 \r
1400 ///________________________________________________________________________\r
1401 Bool_t AliDalitzElectronCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)\r
1402 {   // Set Cut\r
1403         switch(LowPRejectionSigmaCut){\r
1404         case 0:  //\r
1405                 fDoKaonRejectionLowP=kFALSE;\r
1406                 fDoProtonRejectionLowP=kFALSE;\r
1407                 fDoPionRejectionLowP=kFALSE;\r
1408                 fPIDnSigmaAtLowPAroundKaonLine=0;\r
1409                 fPIDnSigmaAtLowPAroundProtonLine=0;\r
1410                 fPIDnSigmaAtLowPAroundPionLine=0;\r
1411                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1412                 break;\r
1413         case 1:  //\r
1414                 fDoKaonRejectionLowP=kTRUE;\r
1415                 fDoProtonRejectionLowP=kTRUE;\r
1416                 fDoPionRejectionLowP=kTRUE;\r
1417                 fPIDnSigmaAtLowPAroundKaonLine=0.5;\r
1418                 fPIDnSigmaAtLowPAroundProtonLine=0.5;\r
1419                 fPIDnSigmaAtLowPAroundPionLine=0.5;\r
1420                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1421                 break;\r
1422         case 2:  //\r
1423                 fDoKaonRejectionLowP=kTRUE;\r
1424                 fDoProtonRejectionLowP=kTRUE;\r
1425                 fDoPionRejectionLowP=kTRUE;\r
1426                 fPIDnSigmaAtLowPAroundKaonLine=1.0;\r
1427                 fPIDnSigmaAtLowPAroundProtonLine=1.0;\r
1428                 fPIDnSigmaAtLowPAroundPionLine=1.0;\r
1429                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1430                 break;\r
1431         case 3:  //\r
1432                 fDoKaonRejectionLowP=kTRUE;\r
1433                 fDoProtonRejectionLowP=kTRUE;\r
1434                 fDoPionRejectionLowP=kTRUE;\r
1435                 fPIDnSigmaAtLowPAroundKaonLine=1.5;\r
1436                 fPIDnSigmaAtLowPAroundProtonLine=1.5;\r
1437                 fPIDnSigmaAtLowPAroundPionLine=1.5;\r
1438                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1439                 break;\r
1440         case 4:  //\r
1441                 fDoKaonRejectionLowP=kTRUE;\r
1442                 fDoProtonRejectionLowP=kTRUE;\r
1443                 fDoPionRejectionLowP=kTRUE;\r
1444                 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1445                 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1446                 fPIDnSigmaAtLowPAroundPionLine=2.0;\r
1447                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1448                 break;\r
1449         case 5:  //\r
1450                 fDoKaonRejectionLowP=kTRUE;\r
1451                 fDoProtonRejectionLowP=kTRUE;\r
1452                 fDoPionRejectionLowP=kTRUE;\r
1453                 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1454                 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1455                 fPIDnSigmaAtLowPAroundPionLine=2.5;\r
1456                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1457                 break;\r
1458         case 6:  //\r
1459                 fDoKaonRejectionLowP=kTRUE;\r
1460                 fDoProtonRejectionLowP=kTRUE;\r
1461                 fDoPionRejectionLowP=kTRUE;\r
1462                 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1463                 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1464                 fPIDnSigmaAtLowPAroundPionLine=2.;\r
1465                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1466                 break;\r
1467         case 7: //\r
1468                 fDoKaonRejectionLowP=kFALSE;\r
1469                 fDoProtonRejectionLowP=kFALSE;\r
1470                 fDoPionRejectionLowP=kTRUE;\r
1471                 fPIDnSigmaAtLowPAroundKaonLine=0.0;\r
1472                 fPIDnSigmaAtLowPAroundProtonLine=0.0;\r
1473                 fPIDnSigmaAtLowPAroundPionLine=1.0;\r
1474                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1475                 break;\r
1476         case 8:\r
1477                 fDoKaonRejectionLowP=kFALSE;\r
1478                 fDoProtonRejectionLowP=kFALSE;\r
1479                 fDoPionRejectionLowP=kTRUE;\r
1480                 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1481                 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1482                 fPIDnSigmaAtLowPAroundPionLine=0.5; \r
1483                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1484                 break;  \r
1485         default:\r
1486                 cout<<"Warning: LowPRejectionSigmaCut not defined "<<LowPRejectionSigmaCut<<endl;\r
1487                 return kFALSE;\r
1488         }\r
1489         return kTRUE;\r
1490 }\r
1491 \r
1492 ///________________________________________________________________________\r
1493 Bool_t AliDalitzElectronCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){\r
1494     // Set Cut\r
1495         switch(TOFelectronPID){ // RRnewTOF start //////////////////////////////////////////////////////////////////////////\r
1496         case 0: // no cut\r
1497                 fRequireTOF = kFALSE;\r
1498                 fUseTOFpid = kFALSE;\r
1499                 fTofPIDnSigmaBelowElectronLine=-100;\r
1500                 fTofPIDnSigmaAboveElectronLine=100;\r
1501                 break;\r
1502         case 1: // -7,7\r
1503                 fRequireTOF = kFALSE;\r
1504                 fUseTOFpid = kTRUE;\r
1505                 fTofPIDnSigmaBelowElectronLine=-7;\r
1506                 fTofPIDnSigmaAboveElectronLine=7;\r
1507                 break;\r
1508         case 2: // -5,5\r
1509                 fRequireTOF = kFALSE;\r
1510                 fUseTOFpid = kTRUE;\r
1511                 fTofPIDnSigmaBelowElectronLine=-5;\r
1512                 fTofPIDnSigmaAboveElectronLine=5;\r
1513                 break;\r
1514         case 3: // -3,5\r
1515                 fRequireTOF = kFALSE;\r
1516                 fUseTOFpid = kTRUE;\r
1517                 fTofPIDnSigmaBelowElectronLine=-3;\r
1518                 fTofPIDnSigmaAboveElectronLine=5;\r
1519                 break;\r
1520         case 4: // -2,3\r
1521                 fRequireTOF = kFALSE;\r
1522                 fUseTOFpid = kTRUE;\r
1523                 fTofPIDnSigmaBelowElectronLine=-2;\r
1524                 fTofPIDnSigmaAboveElectronLine=3;\r
1525                 break;\r
1526         case 5: // -3, 3 TOF mandatory\r
1527                 fRequireTOF = kTRUE;\r
1528                 fUseTOFpid  = kTRUE;\r
1529                 fTofPIDnSigmaBelowElectronLine= -3;\r
1530                 fTofPIDnSigmaAboveElectronLine=  3;\r
1531                 break;\r
1532         default:\r
1533         cout<<"Warning: TOFElectronCut not defined "<<TOFelectronPID<<endl;\r
1534         return kFALSE;\r
1535     } //////////////////////// RRnewTOF end //////////////////////////////////////////////////////////////////////////\r
1536     return kTRUE;\r
1537 }\r
1538 ///_______________________________________________________________________________\r
1539 \r
1540 Bool_t AliDalitzElectronCuts::SetPsiPairCut(Int_t psiCut) {\r
1541   \r
1542 \r
1543   switch(psiCut) {\r
1544   case 0:\r
1545         fDoPsiPairCut = kFALSE;\r
1546         fPsiPairCut = 10000.; //\r
1547         fDeltaPhiCutMin = -1000.;\r
1548         fDeltaPhiCutMax =  1000.;\r
1549         \r
1550         break;\r
1551   case 1:\r
1552         fDoPsiPairCut = kTRUE;\r
1553         fPsiPairCut = 0.45; // Standard\r
1554         fDeltaPhiCutMin = 0.;\r
1555         fDeltaPhiCutMax = 0.12;\r
1556         break;\r
1557   case 2:\r
1558         fDoPsiPairCut = kTRUE;\r
1559         fPsiPairCut = 0.60; \r
1560         fDeltaPhiCutMin = 0.;\r
1561         fDeltaPhiCutMax = 0.12;\r
1562         break;\r
1563     \r
1564   default:\r
1565       cout<<"Warning: PsiPairCut not defined "<<fPsiPairCut<<endl;\r
1566       return kFALSE;\r
1567   }\r
1568 \r
1569   return kTRUE;\r
1570 }\r
1571 \r
1572 ///_______________________________________________________________________________\r
1573 Bool_t AliDalitzElectronCuts::SetRejectSharedElecGamma(Int_t RCut) {\r
1574   \r
1575 \r
1576   switch(RCut) {\r
1577   case 0:\r
1578         fDoRejectSharedElecGamma = kFALSE;\r
1579         fRadiusCut = 10000; // \r
1580         break;\r
1581   case 1:\r
1582         fDoRejectSharedElecGamma = kTRUE;\r
1583         fRadiusCut = 2.0; // cm \r
1584         break;\r
1585   case 2:\r
1586         fDoRejectSharedElecGamma = kTRUE;\r
1587         fRadiusCut = 3.0; // Standard\r
1588         break;\r
1589   case 3:\r
1590         fDoRejectSharedElecGamma = kTRUE;\r
1591         fRadiusCut = 4.0; // \r
1592         break;\r
1593   case 4:\r
1594         fDoRejectSharedElecGamma = kTRUE;\r
1595         fRadiusCut = 5.0; // \r
1596         break;\r
1597   case 5:\r
1598         fDoRejectSharedElecGamma = kTRUE;\r
1599         fRadiusCut = 10.0; // \r
1600         break;\r
1601   case 6:\r
1602         fDoRejectSharedElecGamma = kTRUE;\r
1603         fRadiusCut = 15.0; // \r
1604         break;\r
1605   default:\r
1606       cout<<"Warning: PsiPairCut not defined "<<fDoRejectSharedElecGamma<<endl;\r
1607       return kFALSE;\r
1608   }\r
1609 \r
1610   return kTRUE;\r
1611 }\r
1612 ///__________________________________________________________________________\r
1613 Bool_t AliDalitzElectronCuts::SetBackgroundScheme(Int_t BackgroundScheme){\r
1614 \r
1615     // Set Cut\r
1616     switch(BackgroundScheme){\r
1617 \r
1618     case 0: //Rotation\r
1619             fBKGMethod = 0;\r
1620             fUseTrackMultiplicityForBG = kFALSE;\r
1621         break;\r
1622     case 1: // mixed event with V0 multiplicity\r
1623             fBKGMethod  = 1;\r
1624             fUseTrackMultiplicityForBG = kFALSE;\r
1625         break;\r
1626     case 2: // mixed event with track multiplicity\r
1627             fUseTrackMultiplicityForBG = kTRUE;\r
1628             fBKGMethod  = 1;\r
1629         break;\r
1630     case 3: //Rotation\r
1631            fUseTrackMultiplicityForBG = kFALSE;\r
1632             fBKGMethod  = 2;\r
1633         break;\r
1634     case 4: //Rotation\r
1635             fUseTrackMultiplicityForBG = kTRUE;\r
1636             fBKGMethod  = 2;\r
1637         break;\r
1638     case 5: fUseTrackMultiplicityForBG = kTRUE;\r
1639             fBKGMethod  = 3;\r
1640         break;\r
1641 \r
1642     default:\r
1643         cout<<"Warning: BackgroundScheme not defined "<<BackgroundScheme<<endl;\r
1644         return kFALSE;\r
1645     }\r
1646     return kTRUE;\r
1647 }\r
1648 \r
1649 ///________________________________________________________________________\r
1650 Bool_t AliDalitzElectronCuts::SetNumberOfRotations(Int_t NumberOfRotations)\r
1651 {   // Set Cut\r
1652     switch(NumberOfRotations){\r
1653     case 0:\r
1654         fnumberOfRotationEventsForBG = 5;\r
1655         break;\r
1656     case 1:\r
1657         fnumberOfRotationEventsForBG = 10;\r
1658         break;\r
1659     case 2:\r
1660         fnumberOfRotationEventsForBG = 15;\r
1661         break;\r
1662     case 3:\r
1663         fnumberOfRotationEventsForBG = 20;\r
1664         break;\r
1665     case 4:\r
1666         fnumberOfRotationEventsForBG = 2;\r
1667         break;\r
1668     case 5:\r
1669         fnumberOfRotationEventsForBG = 50;\r
1670         break;\r
1671     case 6:\r
1672         fnumberOfRotationEventsForBG = 80;\r
1673         break;\r
1674     case 7:\r
1675         fnumberOfRotationEventsForBG = 100;\r
1676         break;\r
1677     default:\r
1678         cout<<"Warning: NumberOfRotations not defined "<<NumberOfRotations<<endl;\r
1679         return kFALSE;\r
1680     }\r
1681     return kTRUE;\r
1682 }\r
1683 \r
1684 \r
1685 \r
1686 ///________________________________________________________________________\r
1687 Bool_t AliDalitzElectronCuts::SetMassCut(Int_t massCut)\r
1688 {   // Set Cut\r
1689     switch(massCut){\r
1690       \r
1691     case 0:\r
1692                         \r
1693                         fMassCutPtMin  = -999.; //GeV\r
1694                         fMassCutLowPt  =  999.; //GeV/c^2\r
1695                         fMassCutHighPt =  999.; //GeV/c^2\r
1696                         fDoMassCut = kFALSE;   \r
1697                         break;\r
1698     case 1:\r
1699                         //fMassCut = 0.135;             //GeV/c^2\r
1700                         fMassCutPtMin  = -999.; //GeV\r
1701                         fMassCutLowPt  = 0.135; //GeV/c^2\r
1702                         fMassCutHighPt = 0.135; //GeV/c^2\r
1703                         fDoMassCut = kTRUE;\r
1704                         break; \r
1705     case 2:\r
1706                         //fMassCut = 0.100;     //GeV/c^2\r
1707                         fMassCutPtMin  = -999.; //GeV\r
1708                         fMassCutLowPt  = 0.100; //GeV/c^2\r
1709                         fMassCutHighPt = 0.100; //GeV/c^2\r
1710                         fDoMassCut = kTRUE;\r
1711                         break;\r
1712     case 3:\r
1713                         //fMassCut = 0.075;     //GeV/c^2\r
1714                         fMassCutPtMin  = -999.; //GeV\r
1715                         fMassCutLowPt  = 0.075; //GeV/c^2\r
1716                         fMassCutHighPt = 0.075; //GeV/c^2\r
1717                         fDoMassCut = kTRUE;\r
1718                         break;\r
1719     case 4:\r
1720                         //fMassCut = 0.050;     //GeV/c^2\r
1721                         fMassCutPtMin  = -999.; //GeV\r
1722                         fMassCutLowPt  = 0.050; //GeV/c^2\r
1723                         fMassCutHighPt = 0.050; //GeV/c^2\r
1724                         fDoMassCut = kTRUE;\r
1725                         break;\r
1726     case 5:\r
1727                         \r
1728                         fMassCutPtMin  = -999.; //GeV\r
1729                         fMassCutLowPt  = 0.035; //GeV/c^2\r
1730                         fMassCutHighPt = 0.035; //GeV/c^2\r
1731                         fDoMassCut = kTRUE;\r
1732                         break;\r
1733     case 6:\r
1734                         fMassCutPtMin  = -999.; //GeV\r
1735                         fMassCutLowPt  = 0.015; //GeV/c^2\r
1736                         fMassCutHighPt = 0.015; //GeV/c^2\r
1737                         fDoMassCut = kTRUE;\r
1738                         break;\r
1739     case 7:             fMassCutPtMin  = 1.0;   //GeV\r
1740                         fMassCutLowPt  = 0.015; //GeV/c^2\r
1741                         fMassCutHighPt = 0.035; //GeV/c^2\r
1742                         fDoMassCut = kTRUE;\r
1743                         break;\r
1744     default:\r
1745                         cout<<"Warning: MassCut not defined "<<massCut<<endl;\r
1746                         return kFALSE;\r
1747     }\r
1748     return kTRUE;\r
1749 }\r
1750 \r
1751 ///________________________________________________________________________\r
1752 TString AliDalitzElectronCuts::GetCutNumber(){\r
1753     // returns TString with current cut number\r
1754   TString a(kNCuts);\r
1755   for(Int_t ii=0;ii<kNCuts;ii++){\r
1756         a.Append(Form("%d",fCuts[ii]));\r
1757   }\r
1758   return a;\r
1759 }\r
1760 \r
1761 \r
1762 ///________________________________________________________________________\r
1763 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010PbPb(){\r
1764     //Create and return standard 2010 PbPb cuts\r
1765     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");\r
1766     if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1767         cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}\r
1768     return cuts;\r
1769 }\r
1770 \r
1771 ///________________________________________________________________________\r
1772 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010pp(){\r
1773     //Create and return standard 2010 PbPb cuts\r
1774     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010pp","StandardCuts2010pp");\r
1775                                           \r
1776     if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1777         cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}\r
1778      return cuts;\r
1779 }\r
1780 \r