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    \r
 434 \r
 435     if( clsToF < fMinClsTPCToF){\r
 436     return kFALSE;\r
 437     }\r
 438 \r
 439     \r
 440 \r
 441    return kTRUE;\r
 442 }\r
 443 ///________________________________________________________________________\r
 444 Bool_t AliDalitzElectronCuts::dEdxCuts(AliVTrack *fCurrentTrack){\r
 445 \r
 446     // Electron Identification Cuts for Photon reconstruction\r
 447 \r
 448     if(!fPIDResponse){  InitPIDResponse();  }// Try to reinitialize PID Response\r
 449     if(!fPIDResponse){  AliError("No PID Response"); return kFALSE;}// if still missing fatal error\r
 450 \r
 451 \r
 452 \r
 453     //cout<<"dEdxCuts: //////////////////////////////////////////////////////////////////////////"<<endl;\r
 454 \r
 455 \r
 456 \r
 457     Int_t cutIndex=0;\r
 458 \r
 459     if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 460     if(hITSdEdxbefore)hITSdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));\r
 461     if(hTPCdEdxbefore)hTPCdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));\r
 462     if(hTPCdEdxSignalbefore)hTPCdEdxSignalbefore->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));\r
 463 \r
 464 \r
 465     cutIndex++;\r
 466 \r
 467 \r
 468                 if( fDodEdxSigmaITSCut == kTRUE ){\r
 469 \r
 470 \r
 471                         if( fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineITS ||\r
 472                                         fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)> fPIDnSigmaAboveElectronLineITS ){\r
 473                                 \r
 474                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 475                                 return kFALSE;\r
 476       }\r
 477                         \r
 478                 }\r
 479                 \r
 480                 if(hITSdEdxafter)hITSdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));\r
 481                 \r
 482                 \r
 483                 cutIndex++;\r
 484                 \r
 485                 \r
 486                 if(fDodEdxSigmaTPCCut == kTRUE){\r
 487                         \r
 488                         \r
 489       // TPC Electron Line\r
 490       if( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineTPC ||\r
 491                                         fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaAboveElectronLineTPC){\r
 492                                 \r
 493                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 494                                 return kFALSE;\r
 495       }\r
 496       cutIndex++;\r
 497                         \r
 498       // TPC Pion Line\r
 499                         if( fCurrentTrack->P()>fPIDMinPnSigmaAbovePionLineTPC && fCurrentTrack->P()<fPIDMaxPnSigmaAbovePionLineTPC ){\r
 500                                 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC     &&\r
 501                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC &&\r
 502                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPC){\r
 503                                         \r
 504                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 505                                         return kFALSE;\r
 506                                 }\r
 507                         }\r
 508                         cutIndex++;\r
 509                         \r
 510                         // High Pt Pion rej\r
 511                         if( fCurrentTrack->P()>fPIDMaxPnSigmaAbovePionLineTPC ){\r
 512                                 if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC &&\r
 513                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC&&\r
 514                                          fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPCHighPt){\r
 515                                         \r
 516                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 517                                         return kFALSE;\r
 518                                 }\r
 519                         }\r
 520                         \r
 521                         cutIndex++;\r
 522                 }\r
 523 \r
 524                 else{ cutIndex+=3; }\r
 525 \r
 526 \r
 527                 if(   fDoKaonRejectionLowP == kTRUE   ){\r
 528 \r
 529                         if( fCurrentTrack->P() < fPIDMinPKaonRejectionLowP ){\r
 530                                 \r
 531                                 if( TMath::Abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kKaon))<fPIDnSigmaAtLowPAroundKaonLine){\r
 532                                         \r
 533                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 534                                         \r
 535                                         return kFALSE;\r
 536                                 }\r
 537                         }\r
 538                 }\r
 539                 cutIndex++;\r
 540                 \r
 541                 if(   fDoProtonRejectionLowP == kTRUE    ){\r
 542                         \r
 543                         if( fCurrentTrack->P()  < fPIDMinPProtonRejectionLowP ){\r
 544                                 if( TMath::Abs(   fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kProton))<fPIDnSigmaAtLowPAroundProtonLine){\r
 545                                         \r
 546                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 547                                         return kFALSE;\r
 548                                 }\r
 549                         }\r
 550                 }\r
 551                 cutIndex++;\r
 552                 \r
 553                 if(fDoPionRejectionLowP == kTRUE){\r
 554                         if( fCurrentTrack->P() < fPIDMinPPionRejectionLowP ){\r
 555                                 if( TMath::Abs( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)) < fPIDnSigmaAtLowPAroundPionLine ){\r
 556                                         \r
 557                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 558                                         return kFALSE;\r
 559                                 }\r
 560                         }\r
 561                 }\r
 562                 cutIndex++;\r
 563                 \r
 564                 \r
 565                 if( ( fCurrentTrack->GetStatus() & AliESDtrack::kTOFpid ) && ( !( fCurrentTrack->GetStatus() & AliESDtrack::kTOFmismatch) ) ){\r
 566                         if(hTOFbefore) hTOFbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));\r
 567                         if(fUseTOFpid){\r
 568         if(fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)>fTofPIDnSigmaAboveElectronLine ||\r
 569            fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)<fTofPIDnSigmaBelowElectronLine ){\r
 570                                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 571                                         return kFALSE;\r
 572         }\r
 573                         }\r
 574                         if(hTOFafter)hTOFafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));\r
 575                 }\r
 576                 else if ( fRequireTOF == kTRUE ) {\r
 577                         \r
 578                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 579                         return kFALSE;\r
 580                 }\r
 581                 cutIndex++;\r
 582                 \r
 583                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 584                 if(hTPCdEdxafter)hTPCdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));\r
 585                 if(hTPCdEdxSignalafter)hTPCdEdxSignalafter->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));\r
 586                 \r
 587                 return kTRUE;\r
 588 }\r
 589 ///________________________________________________________________________\r
 590 \r
 591 \r
 592 AliVTrack *AliDalitzElectronCuts::GetTrack(AliVEvent * event, Int_t label){\r
 593     //Returns pointer to the track with given ESD label\r
 594     //(Important for AOD implementation, since Track array in AOD data is different\r
 595     //from ESD array, but ESD tracklabels are stored in AOD Tracks)\r
 596 \r
 597   AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);\r
 598   if(esdEvent) {\r
 599         if(label > event->GetNumberOfTracks() ) return NULL;\r
 600         AliESDtrack * track = esdEvent->GetTrack(label);\r
 601         return track;\r
 602         \r
 603   } else { \r
 604         for(Int_t ii=0; ii<event->GetNumberOfTracks(); ii++) {\r
 605           AliVTrack * track = dynamic_cast<AliVTrack*>(event->GetTrack(ii));\r
 606           \r
 607           if(track) { \r
 608                 if(track->GetID() == label) {\r
 609                   return track;\r
 610                 }\r
 611           }\r
 612         }\r
 613     }\r
 614   \r
 615   cout << "track not found " << label << " " << event->GetNumberOfTracks() << endl;\r
 616   return NULL;\r
 617 }\r
 618 ///________________________________________________________________________\r
 619 Bool_t AliDalitzElectronCuts::RejectSharedElecGamma(TList *photons, Int_t indexEle){\r
 620 \r
 621 \r
 622      for(Int_t i = 0;i<photons->GetEntries();i++){\r
 623 \r
 624       AliAODConversionPhoton *photonComp = (AliAODConversionPhoton*) photons->At(i);\r
 625 \r
 626       Int_t posLabel = photonComp->GetTrackLabelPositive();\r
 627       Int_t negLabel = photonComp->GetTrackLabelNegative();\r
 628 \r
 629       if( (photonComp->GetConversionRadius() < fRadiusCut) && (posLabel == indexEle || negLabel == indexEle) ){\r
 630         return kFALSE;\r
 631       }\r
 632      }\r
 633 \r
 634    return kTRUE;\r
 635 }\r
 636 Bool_t AliDalitzElectronCuts::MassCut(Double_t pi0CandidatePt , Double_t vphotonCandidateMass){\r
 637   \r
 638         if( pi0CandidatePt < fMassCutPtMin ){\r
 639           \r
 640               if( vphotonCandidateMass < fMassCutLowPt ){\r
 641                     return kTRUE;\r
 642               }\r
 643                 \r
 644         }\r
 645         else{\r
 646           \r
 647                if( vphotonCandidateMass < fMassCutHighPt ){\r
 648                     return kTRUE;\r
 649                }\r
 650               \r
 651         }\r
 652         \r
 653         return kFALSE;\r
 654           \r
 655 }\r
 656 \r
 657 Double_t AliDalitzElectronCuts::GetNFindableClustersTPC(AliESDtrack* lTrack){\r
 658   \r
 659   \r
 660   Double_t clsToF=0;\r
 661 \r
 662 \r
 663     if ( !fUseCorrectedTPCClsInfo ){\r
 664         if(lTrack->GetTPCNclsF()!=0){\r
 665 \r
 666               clsToF = (Double_t)lTrack->GetNcls(1)/(Double_t)lTrack->GetTPCNclsF();\r
 667         }// Ncluster/Nfindablecluster\r
 668     }\r
 669     else {\r
 670 \r
 671               //clsToF = lTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));\r
 672               clsToF = lTrack->GetTPCClusterInfo(2,0); //NOTE ask friederike\r
 673                 \r
 674     }\r
 675   \r
 676   return clsToF;\r
 677    \r
 678 }\r
 679 \r
 680 /*\r
 681 Double_t AliDalitzElectronCuts::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg )\r
 682 {\r
 683 //\r
 684 // This angle is a measure for the contribution of the opening in polar\r
 685 // direction ??0 to the opening angle ?? Pair\r
 686 //\r
 687 // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC\r
 688 //      Master Thesis. Thorsten Dahms. 2005\r
 689 // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf\r
 690 //\r
 691         Double_t momPos[3];\r
 692         Double_t momNeg[3];\r
 693         if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );\r
 694         if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );\r
 695 \r
 696         TVector3 posDaughter;\r
 697         TVector3 negDaughter;\r
 698 \r
 699         posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );\r
 700         negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );\r
 701 \r
 702         Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();\r
 703         Double_t openingAngle =  posDaughter.Angle( negDaughter );  //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );\r
 704 \r
 705         if( openingAngle < 1e-20 ) return 0.;\r
 706 \r
 707         Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );\r
 708 \r
 709         return psiAngle;\r
 710 }*/\r
 711 \r
 712 Bool_t AliDalitzElectronCuts::IsFromGammaConversion( Double_t psiPair, Double_t deltaPhi )\r
 713 {\r
 714 //\r
 715 // Returns true if it is a gamma conversion according to psi pair value\r
 716 //\r
 717         return ( (deltaPhi > fDeltaPhiCutMin  &&  deltaPhi < fDeltaPhiCutMax) &&\r
 718         TMath::Abs(psiPair) < ( fPsiPairCut - fPsiPairCut/fDeltaPhiCutMax * deltaPhi ) );\r
 719 }\r
 720 \r
 721 ///________________________________________________________________________\r
 722 Bool_t AliDalitzElectronCuts::UpdateCutString(cutIds cutID, Int_t value) {\r
 723 ///Update the cut string (if it has been created yet)\r
 724 \r
 725   if(fCutString && fCutString->GetString().Length() == kNCuts) {\r
 726 //         cout << "Updating cut id in spot number " << cutID << " to " << value << endl;\r
 727         fCutString->SetString(GetCutNumber());\r
 728   } else {\r
 729 //         cout << "fCutString not yet initialized, will not be updated" << endl;\r
 730         return kFALSE;\r
 731   }\r
 732  // cout << fCutString->GetString().Data() << endl;\r
 733   return kTRUE;\r
 734 }\r
 735 \r
 736 ///________________________________________________________________________\r
 737 Bool_t AliDalitzElectronCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {\r
 738    // Initialize Cuts from a given Cut string\r
 739 \r
 740 //   out<<"Set Cut Number: "<<analysisCutSelection.Data()<<endl;\r
 741   AliInfo(Form("Set ElectronCuts Number: %s",analysisCutSelection.Data()));\r
 742   \r
 743   if(analysisCutSelection.Length()!=kNCuts) {\r
 744         AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));\r
 745         return kFALSE;\r
 746   }\r
 747   if(!analysisCutSelection.IsDigit()){\r
 748         AliError("Cut selection contains characters");\r
 749         return kFALSE;\r
 750   }\r
 751   \r
 752   const char *cutSelection = analysisCutSelection.Data();\r
 753   #define ASSIGNARRAY(i)        fCuts[i] = cutSelection[i] - '0'\r
 754   for(Int_t ii=0;ii<kNCuts;ii++){\r
 755       ASSIGNARRAY(ii);\r
 756   }\r
 757 \r
 758   // TestFlag\r
 759   if(fCuts[0] !=9){\r
 760     AliError("Analysis Cut Selection does not start with 9");\r
 761         PrintCuts();\r
 762     return kFALSE;\r
 763   }\r
 764 \r
 765   // Set Individual Cuts\r
 766   for(Int_t ii=0;ii<kNCuts;ii++){\r
 767       if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;\r
 768   }\r
 769 \r
 770   //PrintCuts();\r
 771 \r
 772     return kTRUE;\r
 773 }\r
 774 ///________________________________________________________________________\r
 775 Bool_t AliDalitzElectronCuts::SetCut(cutIds cutID, const Int_t value) {\r
 776   ///Set individual cut ID\r
 777 \r
 778   //cout << "Updating cut  " << fgkCutNames[cutID] << " (" << cutID << ") to " << value << endl;\r
 779 \r
 780   switch (cutID) {\r
 781   case kgoodId:\r
 782         fCuts[kgoodId] = value;\r
 783         if(value != 9) {\r
 784           cout << "Error:: First value of cut string is wrong, aborting!!" << endl;\r
 785           return kFALSE;\r
 786         } else {\r
 787           return kTRUE;\r
 788         }\r
 789 \r
 790   case kededxSigmaITSCut:\r
 791         if( SetITSdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented \r
 792           fCuts[kededxSigmaITSCut] = value;\r
 793           UpdateCutString(cutID, value);\r
 794           return kTRUE;\r
 795         } else return kFALSE;\r
 796 \r
 797         case kededxSigmaTPCCut:\r
 798                 if( SetTPCdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented \r
 799                         fCuts[kededxSigmaTPCCut] = value;\r
 800                         UpdateCutString(cutID, value);\r
 801                         return kTRUE;\r
 802                 } else return kFALSE;\r
 803                 \r
 804   case kpidedxSigmaTPCCut:\r
 805                 if( SetTPCdEdxCutPionLine(value)) { //NOTE SetITSdEdxCutPionLine: To be implemented\r
 806                         fCuts[kpidedxSigmaTPCCut] = value;\r
 807                         UpdateCutString(cutID, value);\r
 808                         return kTRUE;\r
 809                 } else return kFALSE;\r
 810                 \r
 811   case kpiMinMomdedxSigmaTPCCut:\r
 812                 if( SetMinMomPiondEdxTPCCut(value)) {\r
 813                         fCuts[kpiMinMomdedxSigmaTPCCut] = value;\r
 814                         UpdateCutString(cutID, value);\r
 815                         return kTRUE;\r
 816                 } else return kFALSE;\r
 817                 \r
 818   case kpiMaxMomdedxSigmaTPCCut:\r
 819                 if( SetMaxMomPiondEdxTPCCut(value)) {\r
 820                         fCuts[kpiMaxMomdedxSigmaTPCCut] = value;\r
 821                         UpdateCutString(cutID, value);\r
 822                         return kTRUE;\r
 823                 } else return kFALSE;\r
 824                 \r
 825   case kLowPRejectionSigmaCut:\r
 826                 if( SetLowPRejectionCuts(value) ) {\r
 827                         fCuts[kLowPRejectionSigmaCut] = value;\r
 828                         UpdateCutString(cutID, value);\r
 829                         return kTRUE;\r
 830                 } else return kFALSE;\r
 831                 \r
 832                 \r
 833   case kTOFelectronPID:\r
 834                 if( SetTOFElectronPIDCut(value)) {\r
 835                         fCuts[kTOFelectronPID] = value;\r
 836                         UpdateCutString(cutID, value);\r
 837                         return kTRUE;\r
 838                 } else return kFALSE;\r
 839   case kclsITSCut:\r
 840                 if( SetITSClusterCut(value) ) {\r
 841                         fCuts[kclsITSCut] = value;\r
 842                         UpdateCutString(cutID, value);\r
 843                         return kTRUE;                   \r
 844                 } else return kFALSE;\r
 845   case kclsTPCCut:\r
 846                 if( SetTPCClusterCut(value)) {\r
 847                         fCuts[kclsTPCCut] = value;\r
 848                         UpdateCutString(cutID, value);\r
 849                         return kTRUE;\r
 850                 } else return kFALSE;\r
 851                 \r
 852   case ketaCut:\r
 853                 if( SetEtaCut(value)) {\r
 854                         fCuts[ketaCut] = value;\r
 855                         UpdateCutString(cutID, value);\r
 856                         return kTRUE;\r
 857                 } else return kFALSE;\r
 858   case kptCut:  \r
 859                 if( SetPtCut(value)) {\r
 860                         fCuts[kptCut] = value;\r
 861                         UpdateCutString(cutID, value);\r
 862                         return kTRUE;\r
 863                 } else return kFALSE;\r
 864     \r
 865   case kDCACut:\r
 866                 if( SetDCACut(value)) {\r
 867                         fCuts[kDCACut] = value;\r
 868                         UpdateCutString(cutID, value);\r
 869                         return kTRUE;\r
 870                 } else return kFALSE;\r
 871               \r
 872               \r
 873         case kPsiPair:\r
 874                 if( SetPsiPairCut(value)) {\r
 875                         fCuts[kPsiPair] = value;\r
 876                         UpdateCutString(cutID, value);\r
 877                         return kTRUE;\r
 878                 } else return kFALSE;\r
 879                 \r
 880   case kRejectSharedElecGamma:\r
 881                 if( SetRejectSharedElecGamma(value)) {\r
 882                         fCuts[kRejectSharedElecGamma] = value;\r
 883                         UpdateCutString(cutID, value);\r
 884           return kTRUE;\r
 885                 } else return kFALSE;\r
 886                 \r
 887   case kBackgroundScheme:\r
 888                 if( SetBackgroundScheme(value)) {\r
 889                         fCuts[kBackgroundScheme] = value;\r
 890                         UpdateCutString(cutID, value);\r
 891                         return kTRUE;\r
 892                 } else return kFALSE;\r
 893 \r
 894   case kNumberOfRotations:\r
 895                 if( SetNumberOfRotations(value)) {\r
 896                         fCuts[kNumberOfRotations] = value;\r
 897                         UpdateCutString(cutID, value);\r
 898                         return kTRUE;\r
 899                 } else return kFALSE;\r
 900                 \r
 901   case kmassCut:\r
 902                 if( SetMassCut(value)) {\r
 903                         fCuts[kmassCut] = value;\r
 904                         UpdateCutString(cutID, value);\r
 905                         return kTRUE;\r
 906                 } else return kFALSE;\r
 907                 \r
 908   case kNCuts:\r
 909                 cout << "Error:: Cut id out of range"<< endl;\r
 910                 return kFALSE;\r
 911   }\r
 912         \r
 913   cout << "Error:: Cut id " << cutID << " not recognized "<< endl;\r
 914   return kFALSE;\r
 915 \r
 916   //PrintCuts();\r
 917   \r
 918 }\r
 919 \r
 920 ///________________________________________________________________________\r
 921 \r
 922 void AliDalitzElectronCuts::PrintCuts() {\r
 923     // Print out current Cut Selection\r
 924   for(Int_t ic = 0; ic < kNCuts; ic++) {\r
 925         printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);\r
 926   }\r
 927 \r
 928 }\r
 929 \r
 930 ///________________________________________________________________________\r
 931 Bool_t AliDalitzElectronCuts::SetITSdEdxCutElectronLine(Int_t ededxSigmaCut)\r
 932 {   // Set Cut\r
 933 \r
 934         switch(ededxSigmaCut){\r
 935 \r
 936         case 0: \r
 937                 fDodEdxSigmaITSCut = kFALSE;\r
 938                 fPIDnSigmaBelowElectronLineITS=-100;\r
 939                 fPIDnSigmaAboveElectronLineITS= 100;\r
 940                 break;\r
 941         case 1: // -10,10\r
 942                 fDodEdxSigmaITSCut = kTRUE;\r
 943                 fPIDnSigmaBelowElectronLineITS=-10;\r
 944                 fPIDnSigmaAboveElectronLineITS=10;\r
 945                 break;\r
 946         case 2: // -6,7\r
 947                 fDodEdxSigmaITSCut = kTRUE;\r
 948                 fPIDnSigmaBelowElectronLineITS=-6;\r
 949                 fPIDnSigmaAboveElectronLineITS=7;\r
 950                 break;\r
 951         case 3: // -5,5\r
 952                 fDodEdxSigmaITSCut = kTRUE;\r
 953                 fPIDnSigmaBelowElectronLineITS=-5;\r
 954                 fPIDnSigmaAboveElectronLineITS=5;\r
 955                 break;\r
 956         case 4: // -4,5\r
 957                 fDodEdxSigmaITSCut = kTRUE;\r
 958                 fPIDnSigmaBelowElectronLineITS=-4;\r
 959                 fPIDnSigmaAboveElectronLineITS=5;\r
 960                 break;\r
 961         case 5: // -3,5\r
 962                 fDodEdxSigmaITSCut = kTRUE;\r
 963                 fPIDnSigmaBelowElectronLineITS=-3;\r
 964                 fPIDnSigmaAboveElectronLineITS=5;\r
 965                 break;\r
 966         case 6: // -4,4\r
 967                 fDodEdxSigmaITSCut = kTRUE;\r
 968                 fPIDnSigmaBelowElectronLineITS=-4;\r
 969                 fPIDnSigmaAboveElectronLineITS=4;\r
 970                 break;\r
 971         case 7: // -2.5,4\r
 972                 fDodEdxSigmaITSCut = kTRUE;\r
 973                 fPIDnSigmaBelowElectronLineITS=-2.5;\r
 974                 fPIDnSigmaAboveElectronLineITS=4;\r
 975                 break;\r
 976         case 8: // -2,3.5\r
 977                 fDodEdxSigmaITSCut = kTRUE;\r
 978                 fPIDnSigmaBelowElectronLineITS=-2;\r
 979                 fPIDnSigmaAboveElectronLineITS=3.5;\r
 980                 break;\r
 981         default:\r
 982                 cout<<"Warning: ITSdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;\r
 983                 return kFALSE;\r
 984     \r
 985         }\r
 986         return kTRUE;\r
 987 }\r
 988 \r
 989 ///________________________________________________________________________\r
 990 Bool_t AliDalitzElectronCuts::SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut)\r
 991 {   // Set Cut\r
 992         switch(ededxSigmaCut){\r
 993 \r
 994         case 0: fDodEdxSigmaTPCCut = kFALSE;\r
 995                 fPIDnSigmaBelowElectronLineTPC=-10;\r
 996                 fPIDnSigmaAboveElectronLineTPC=10;\r
 997                 break;\r
 998         case 1: // -10,10\r
 999                 fDodEdxSigmaTPCCut = kTRUE;\r
1000                 fPIDnSigmaBelowElectronLineTPC=-10;\r
1001                 fPIDnSigmaAboveElectronLineTPC=10;\r
1002                 break;\r
1003         case 2: // -6,7\r
1004                 fDodEdxSigmaTPCCut = kTRUE;\r
1005                 fPIDnSigmaBelowElectronLineTPC=-6;\r
1006                 fPIDnSigmaAboveElectronLineTPC=7;\r
1007                 break;\r
1008         case 3: // -5,5\r
1009                 fDodEdxSigmaTPCCut = kTRUE;\r
1010                 fPIDnSigmaBelowElectronLineTPC=-5;\r
1011                 fPIDnSigmaAboveElectronLineTPC=5;\r
1012                 break;\r
1013         case 4: // -4,5\r
1014                 fDodEdxSigmaTPCCut = kTRUE;\r
1015                 fPIDnSigmaBelowElectronLineTPC=-4;\r
1016                 fPIDnSigmaAboveElectronLineTPC=5;\r
1017                 break;  \r
1018         case 5: // -3,5\r
1019                 fDodEdxSigmaTPCCut = kTRUE;\r
1020                 fPIDnSigmaBelowElectronLineTPC=-3;\r
1021                 fPIDnSigmaAboveElectronLineTPC=5;\r
1022                 break;\r
1023         case 6: // -4,4\r
1024                 fDodEdxSigmaTPCCut = kTRUE;\r
1025                 fPIDnSigmaBelowElectronLineTPC=-4;\r
1026                 fPIDnSigmaAboveElectronLineTPC=4;\r
1027                 break;\r
1028         case 7: // -2.5,4\r
1029                 fDodEdxSigmaTPCCut = kTRUE;\r
1030                 fPIDnSigmaBelowElectronLineTPC=-2.5;\r
1031                 fPIDnSigmaAboveElectronLineTPC=4;\r
1032                 break;\r
1033         case 8: // -2,3.5\r
1034                 fDodEdxSigmaTPCCut = kTRUE;\r
1035                 fPIDnSigmaBelowElectronLineTPC=-2;\r
1036                 fPIDnSigmaAboveElectronLineTPC=3.5;\r
1037                 break;\r
1038         default:\r
1039                 cout<<"Warning: TPCdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;\r
1040                 return kFALSE;\r
1041     \r
1042         }\r
1043         return kTRUE;\r
1044 }\r
1045 \r
1046 ///________________________________________________________________________\r
1047 Bool_t AliDalitzElectronCuts::SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut)\r
1048 {   // Set Cut\r
1049 \r
1050         switch(pidedxSigmaCut){\r
1051                 \r
1052         case 0: fPIDnSigmaAbovePionLineTPC= 0;\r
1053                 fPIDnSigmaAbovePionLineTPCHighPt=-100;\r
1054                 break;\r
1055         case 1:  // -10\r
1056                 fPIDnSigmaAbovePionLineTPC=3.0;            //Update Sep-05-2013 from -10 to 3\r
1057                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1058                 break;\r
1059         case 2:  // 1\r
1060                 fPIDnSigmaAbovePionLineTPC=2;              //Update Sep-09-2013 from -1  to  2\r
1061                 fPIDnSigmaAbovePionLineTPCHighPt=-1;       //Update Sep-09-2013 from -10 to -1\r
1062                 break;\r
1063         case 3:   // 0\r
1064                 fPIDnSigmaAbovePionLineTPC=2;              //Update Sep-09-2013 from   0 to   2\r
1065                 fPIDnSigmaAbovePionLineTPCHighPt=0;        //Update Sep-09-2013 from -10 to   0\r
1066                 break;\r
1067         case 4:  // 1\r
1068                 fPIDnSigmaAbovePionLineTPC=1;\r
1069                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1070                 break;\r
1071         case 5:  // 1\r
1072                 fPIDnSigmaAbovePionLineTPC=2.;\r
1073                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1074                 break;\r
1075         case 6:  // 1\r
1076                 fPIDnSigmaAbovePionLineTPC=2.5;\r
1077                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
1078                 break;\r
1079         case 7:\r
1080                 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
1081                 fPIDnSigmaAbovePionLineTPCHighPt = 2.0;\r
1082                 break;\r
1083         case 8:  // 1\r
1084                 fPIDnSigmaAbovePionLineTPC = 1.5;   // Updated May-16-2013 from 3.5 and -10 to +1.5, +1\r
1085                 fPIDnSigmaAbovePionLineTPCHighPt = 1.0;\r
1086                 break;\r
1087         case 9:  // 1\r
1088                 fPIDnSigmaAbovePionLineTPC=1.5;\r
1089                 fPIDnSigmaAbovePionLineTPCHighPt=-1.0;\r
1090                 break;\r
1091         default:\r
1092                 cout<<"Warning: pidedxSigmaCut not defined "<<pidedxSigmaCut<<endl;\r
1093                 return kFALSE;\r
1094         }\r
1095         return kTRUE;\r
1096 }\r
1097 \r
1098 ///________________________________________________________________________\r
1099 Bool_t AliDalitzElectronCuts::SetMinMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut)\r
1100 {   // Set Cut\r
1101         switch(piMomdedxSigmaCut){\r
1102                 \r
1103         case 0: fPIDMinPnSigmaAbovePionLineTPC=0.;\r
1104                 break;\r
1105         case 1:  // 50.0 GeV\r
1106                 fPIDMinPnSigmaAbovePionLineTPC=50.;\r
1107                 break;\r
1108         case 2:  // 20.0 GeV\r
1109                 fPIDMinPnSigmaAbovePionLineTPC=20.;\r
1110                 break;\r
1111         case 3:  // 1.5 GeV\r
1112                 fPIDMinPnSigmaAbovePionLineTPC=1.5;\r
1113                 break;\r
1114         case 4:  // 1. GeV\r
1115                 fPIDMinPnSigmaAbovePionLineTPC=1.;\r
1116                 break;  \r
1117         case 5:  // 0.5 GeV\r
1118                 fPIDMinPnSigmaAbovePionLineTPC=0.5;\r
1119                 break;\r
1120         case 6:  // 0.4 GeV\r
1121                 fPIDMinPnSigmaAbovePionLineTPC=0.4;\r
1122                 break;    \r
1123         case 7:  // 0.3 GeV\r
1124                 fPIDMinPnSigmaAbovePionLineTPC=0.3;\r
1125                 break;\r
1126         case 8:  // 0.25 GeV\r
1127                 fPIDMinPnSigmaAbovePionLineTPC=0.25;\r
1128                 break;\r
1129         default:\r
1130                 cout<<"Warning: piMomdedxSigmaCut not defined "<<piMomdedxSigmaCut<<endl;\r
1131                 return kFALSE;\r
1132         }\r
1133         return kTRUE;\r
1134 }\r
1135 ///________________________________________________________________________\r
1136 Bool_t AliDalitzElectronCuts::SetITSClusterCut(Int_t clsITSCut){\r
1137 \r
1138     \r
1139         if( !fesdTrackCuts ) {\r
1140 \r
1141                 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;\r
1142                 return kFALSE;\r
1143         }\r
1144 \r
1145         switch(clsITSCut){\r
1146 \r
1147         case 0: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);\r
1148                 break;\r
1149         case 1: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);\r
1150                 break;  //1 hit first layer of SPD\r
1151         case 2: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1152                 break; //1 hit in any layer of SPD\r
1153         case 3: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);\r
1154                 fesdTrackCuts->SetMinNClustersITS(4);\r
1155                 // 4 hits in total in the ITS. At least 1 hit in the first layer of SPD  \r
1156                 break;\r
1157         case 4: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1158                 fesdTrackCuts->SetMinNClustersITS(3);\r
1159                 // 3 hits in total in the ITS. At least 1 hit in any layer of SPD\r
1160                 break;\r
1161         case 5: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1162                 fesdTrackCuts->SetMinNClustersITS(4);\r
1163                 // 4 hits in total in the ITS. At least 1 hit in any layer of SPD\r
1164                 break;\r
1165         case 6: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1166                 fesdTrackCuts->SetMinNClustersITS(5);\r
1167                 // 5 hits in total in the ITS. At least 1 hit in any layer of SPD\r
1168                 break;\r
1169         default:\r
1170                 cout<<"Warning: clsITSCut not defined "<<clsITSCut<<endl;\r
1171                 return kFALSE;\r
1172         }\r
1173         \r
1174 return kTRUE;\r
1175 }\r
1176 \r
1177 ///________________________________________________________________________\r
1178 Bool_t AliDalitzElectronCuts::SetTPCClusterCut(Int_t clsTPCCut)\r
1179 {   // Set Cut\r
1180         switch(clsTPCCut){\r
1181         case 0: // 0\r
1182                 fMinClsTPC= 0.;\r
1183                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1184                 break;\r
1185         case 1:  // 70\r
1186                 fMinClsTPC= 70.;\r
1187                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1188                 break;\r
1189         case 2:  // 80\r
1190                 fMinClsTPC= 80.;\r
1191                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1192                 break;\r
1193         case 3:  // 100\r
1194                 fMinClsTPC= 100.;\r
1195                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1196                 break;\r
1197         case 4:  // 0% of findable clusters\r
1198                 fMinClsTPC= 70.;  \r
1199                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1200                 fMinClsTPCToF= 0.0;\r
1201                 fUseCorrectedTPCClsInfo=0;\r
1202                 break;\r
1203         case 5:  // 35% of findable clusters\r
1204                 fMinClsTPC = 70.;  \r
1205                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1206                 fMinClsTPCToF= 0.35;\r
1207                 fUseCorrectedTPCClsInfo=0;\r
1208                 break;\r
1209         case 6:  // 60% of findable clusters\r
1210                 fMinClsTPC= 70.;  \r
1211                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1212                 fMinClsTPCToF= 0.6;\r
1213                 fUseCorrectedTPCClsInfo=0;\r
1214                 break;\r
1215         case 7:  // 70% of findable clusters\r
1216                 fMinClsTPC= 70.;  \r
1217                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1218                 fMinClsTPCToF= 0.7;\r
1219                 fUseCorrectedTPCClsInfo=0;\r
1220                 break;\r
1221         case 8: fMinClsTPC = 0.;  \r
1222                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1223                 fMinClsTPCToF= 0.35;\r
1224                 fUseCorrectedTPCClsInfo=0;\r
1225                 break;\r
1226         case 9:  // 35% of findable clusters\r
1227                 fMinClsTPC = 70.;  \r
1228                 fesdTrackCuts->SetMinNClustersTPC(fMinClsTPC);\r
1229                 fMinClsTPCToF= 0.35;\r
1230                 fUseCorrectedTPCClsInfo=1;\r
1231                 break;\r
1232           \r
1233         default:\r
1234                 cout<<"Warning: clsTPCCut not defined "<<clsTPCCut<<endl;\r
1235                 return kFALSE;\r
1236         }\r
1237         return kTRUE;\r
1238 }\r
1239 \r
1240 ///________________________________________________________________________\r
1241 Bool_t AliDalitzElectronCuts::SetEtaCut(Int_t etaCut)\r
1242 { \r
1243   // Set eta Cut\r
1244         switch(etaCut){\r
1245         case 0: \r
1246                 fEtaCut = 100.;\r
1247                 fDoEtaCut = kFALSE;\r
1248                 break;\r
1249         case 1: // 1.4\r
1250                 fEtaCut = 1.4;\r
1251                 fDoEtaCut = kTRUE;\r
1252                 break;\r
1253         case 2: // 1.2\r
1254                 fEtaCut = 1.2;\r
1255                 fDoEtaCut = kTRUE;\r
1256                 break;\r
1257         case 3: // 0.9\r
1258                 fEtaCut = 0.9;\r
1259                 fDoEtaCut = kTRUE;\r
1260                 break;\r
1261         case 4: // 0.8\r
1262                 fEtaCut = 0.8;\r
1263                 fDoEtaCut = kTRUE;\r
1264                 break;\r
1265         case 5: // 0.75\r
1266                 fEtaCut = 0.75;\r
1267                 fDoEtaCut = kTRUE;\r
1268                 break;\r
1269         case 6: //0.6\r
1270                 fEtaCut = 0.6; //changed from 0.4 to 0.6 2013.06.10\r
1271                 fDoEtaCut = kTRUE;\r
1272                 break;\r
1273         case 7: //0.5\r
1274                 fEtaCut = 0.5; //changed from 0.3 to 0.5 2013.06.10\r
1275                 fDoEtaCut = kTRUE;\r
1276                 break;\r
1277         case 8: fEtaCut = 0.4;\r
1278                 fDoEtaCut = kTRUE;\r
1279                 break;\r
1280         default:\r
1281                 cout<<"Warning: EtaCut not defined "<<etaCut<<endl;\r
1282                 return kFALSE;\r
1283         }\r
1284         return kTRUE;\r
1285 }\r
1286 \r
1287 ///________________________________________________________________________\r
1288 Bool_t AliDalitzElectronCuts::SetPtCut(Int_t ptCut)\r
1289 { \r
1290         // Set Pt Cut\r
1291          //0.1GeV, 0.125 GeV, 0.15 GeV\r
1292   \r
1293         switch(ptCut){\r
1294           \r
1295         case 0: fPtCut = 0.075;         \r
1296                 break;\r
1297         case 1:  // 0.1\r
1298                 fPtCut  = 0.1;  \r
1299                 break;\r
1300         case 2:  // 0.125 GeV\r
1301                 fPtCut  = 0.125;                \r
1302                 break;\r
1303         case 3: // 0.15 GeV\r
1304                 fPtCut  = 0.15;\r
1305                 break;\r
1306         default:\r
1307                 cout<<"Warning: PtCut not defined "<<ptCut<<endl;\r
1308                 return kFALSE;\r
1309         }\r
1310         return kTRUE;\r
1311 }\r
1312 \r
1313 \r
1314 ///________________________________________________________________________\r
1315 Bool_t AliDalitzElectronCuts::SetDCACut(Int_t dcaCut)\r
1316 { \r
1317   // Set DCA Cut\r
1318   \r
1319         if( !fesdTrackCuts ) {\r
1320 \r
1321                 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;\r
1322                 return kFALSE;\r
1323         }\r
1324   \r
1325         switch(dcaCut){\r
1326           \r
1327         case 0: \r
1328                 //Open cuts//\r
1329                 fesdTrackCuts->SetMaxDCAToVertexZ(1000);\r
1330                 fesdTrackCuts->SetMaxDCAToVertexXY(1000);\r
1331                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1332                 break;\r
1333                \r
1334         case 1: \r
1335                 fesdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");\r
1336                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1337                 \r
1338                 break;\r
1339         case 2: fesdTrackCuts->SetMaxDCAToVertexZ(2);\r
1340                 fesdTrackCuts->SetMaxDCAToVertexXY(1);\r
1341                 fesdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);\r
1342                 break; \r
1343                 \r
1344         default:\r
1345                 cout<<"Warning: dcaCut not defined "<<dcaCut<<endl;\r
1346                 return kFALSE;\r
1347         }\r
1348         return kTRUE;\r
1349 }\r
1350 \r
1351 \r
1352 \r
1353 \r
1354 ///________________________________________________________________________\r
1355 Bool_t AliDalitzElectronCuts::SetMaxMomPiondEdxTPCCut(Int_t piMaxMomdedxSigmaCut)\r
1356 {   // Set Cut\r
1357    switch(piMaxMomdedxSigmaCut){\r
1358 \r
1359          case 0: \r
1360                  fPIDMaxPnSigmaAbovePionLineTPC=0.;\r
1361                  break;\r
1362          case 1:  // 100. GeV\r
1363                  fPIDMaxPnSigmaAbovePionLineTPC=100.;\r
1364                  break;\r
1365          case 2:  // 5. GeV\r
1366                  fPIDMaxPnSigmaAbovePionLineTPC=5.;\r
1367                         break;\r
1368          case 3:  // 4. GeV\r
1369                  fPIDMaxPnSigmaAbovePionLineTPC=4.;\r
1370                  break;\r
1371          case 4:  // 3.5 GeV\r
1372                  fPIDMaxPnSigmaAbovePionLineTPC=3.5;\r
1373                  break;\r
1374          case 5:  // 3. GeV\r
1375                  fPIDMaxPnSigmaAbovePionLineTPC=3.;\r
1376                  break;\r
1377          default:\r
1378                  cout<<"Warning: piMaxMomdedxSigmaCut not defined "<<piMaxMomdedxSigmaCut<<endl;\r
1379                  return kFALSE;\r
1380          }\r
1381          return kTRUE;\r
1382 }\r
1383 \r
1384 ///________________________________________________________________________\r
1385 Bool_t AliDalitzElectronCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)\r
1386 {   // Set Cut\r
1387         switch(LowPRejectionSigmaCut){\r
1388         case 0:  //\r
1389                 fDoKaonRejectionLowP=kFALSE;\r
1390                 fDoProtonRejectionLowP=kFALSE;\r
1391                 fDoPionRejectionLowP=kFALSE;\r
1392                 fPIDnSigmaAtLowPAroundKaonLine=0;\r
1393                 fPIDnSigmaAtLowPAroundProtonLine=0;\r
1394                 fPIDnSigmaAtLowPAroundPionLine=0;\r
1395                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1396                 break;\r
1397         case 1:  //\r
1398                 fDoKaonRejectionLowP=kTRUE;\r
1399                 fDoProtonRejectionLowP=kTRUE;\r
1400                 fDoPionRejectionLowP=kTRUE;\r
1401                 fPIDnSigmaAtLowPAroundKaonLine=0.5;\r
1402                 fPIDnSigmaAtLowPAroundProtonLine=0.5;\r
1403                 fPIDnSigmaAtLowPAroundPionLine=0.5;\r
1404                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1405                 break;\r
1406         case 2:  //\r
1407                 fDoKaonRejectionLowP=kTRUE;\r
1408                 fDoProtonRejectionLowP=kTRUE;\r
1409                 fDoPionRejectionLowP=kTRUE;\r
1410                 fPIDnSigmaAtLowPAroundKaonLine=1.0;\r
1411                 fPIDnSigmaAtLowPAroundProtonLine=1.0;\r
1412                 fPIDnSigmaAtLowPAroundPionLine=1.0;\r
1413                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1414                 break;\r
1415         case 3:  //\r
1416                 fDoKaonRejectionLowP=kTRUE;\r
1417                 fDoProtonRejectionLowP=kTRUE;\r
1418                 fDoPionRejectionLowP=kTRUE;\r
1419                 fPIDnSigmaAtLowPAroundKaonLine=1.5;\r
1420                 fPIDnSigmaAtLowPAroundProtonLine=1.5;\r
1421                 fPIDnSigmaAtLowPAroundPionLine=1.5;\r
1422                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1423                 break;\r
1424         case 4:  //\r
1425                 fDoKaonRejectionLowP=kTRUE;\r
1426                 fDoProtonRejectionLowP=kTRUE;\r
1427                 fDoPionRejectionLowP=kTRUE;\r
1428                 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1429                 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1430                 fPIDnSigmaAtLowPAroundPionLine=2.0;\r
1431                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1432                 break;\r
1433         case 5:  //\r
1434                 fDoKaonRejectionLowP=kTRUE;\r
1435                 fDoProtonRejectionLowP=kTRUE;\r
1436                 fDoPionRejectionLowP=kTRUE;\r
1437                 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1438                 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1439                 fPIDnSigmaAtLowPAroundPionLine=2.5;\r
1440                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1441                 break;\r
1442         case 6:  //\r
1443                 fDoKaonRejectionLowP=kTRUE;\r
1444                 fDoProtonRejectionLowP=kTRUE;\r
1445                 fDoPionRejectionLowP=kTRUE;\r
1446                 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1447                 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1448                 fPIDnSigmaAtLowPAroundPionLine=2.;\r
1449                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1450                 break;\r
1451         case 7: //\r
1452                 fDoKaonRejectionLowP=kFALSE;\r
1453                 fDoProtonRejectionLowP=kFALSE;\r
1454                 fDoPionRejectionLowP=kTRUE;\r
1455                 fPIDnSigmaAtLowPAroundKaonLine=0.0;\r
1456                 fPIDnSigmaAtLowPAroundProtonLine=0.0;\r
1457                 fPIDnSigmaAtLowPAroundPionLine=1.0;\r
1458                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1459                 break;\r
1460         case 8:\r
1461                 fDoKaonRejectionLowP=kFALSE;\r
1462                 fDoProtonRejectionLowP=kFALSE;\r
1463                 fDoPionRejectionLowP=kTRUE;\r
1464                 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1465                 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1466                 fPIDnSigmaAtLowPAroundPionLine=0.5; \r
1467                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLineTPC;\r
1468                 break;  \r
1469         default:\r
1470                 cout<<"Warning: LowPRejectionSigmaCut not defined "<<LowPRejectionSigmaCut<<endl;\r
1471                 return kFALSE;\r
1472         }\r
1473         return kTRUE;\r
1474 }\r
1475 \r
1476 ///________________________________________________________________________\r
1477 Bool_t AliDalitzElectronCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){\r
1478     // Set Cut\r
1479         switch(TOFelectronPID){ // RRnewTOF start //////////////////////////////////////////////////////////////////////////\r
1480         case 0: // no cut\r
1481                 fRequireTOF = kFALSE;\r
1482                 fUseTOFpid = kFALSE;\r
1483                 fTofPIDnSigmaBelowElectronLine=-100;\r
1484                 fTofPIDnSigmaAboveElectronLine=100;\r
1485                 break;\r
1486         case 1: // -7,7\r
1487                 fRequireTOF = kFALSE;\r
1488                 fUseTOFpid = kTRUE;\r
1489                 fTofPIDnSigmaBelowElectronLine=-7;\r
1490                 fTofPIDnSigmaAboveElectronLine=7;\r
1491                 break;\r
1492         case 2: // -5,5\r
1493                 fRequireTOF = kFALSE;\r
1494                 fUseTOFpid = kTRUE;\r
1495                 fTofPIDnSigmaBelowElectronLine=-5;\r
1496                 fTofPIDnSigmaAboveElectronLine=5;\r
1497                 break;\r
1498         case 3: // -3,5\r
1499                 fRequireTOF = kFALSE;\r
1500                 fUseTOFpid = kTRUE;\r
1501                 fTofPIDnSigmaBelowElectronLine=-3;\r
1502                 fTofPIDnSigmaAboveElectronLine=5;\r
1503                 break;\r
1504         case 4: // -2,3\r
1505                 fRequireTOF = kFALSE;\r
1506                 fUseTOFpid = kTRUE;\r
1507                 fTofPIDnSigmaBelowElectronLine=-2;\r
1508                 fTofPIDnSigmaAboveElectronLine=3;\r
1509                 break;\r
1510         case 5: // -3, 3 TOF mandatory\r
1511                 fRequireTOF = kTRUE;\r
1512                 fUseTOFpid  = kTRUE;\r
1513                 fTofPIDnSigmaBelowElectronLine= -3;\r
1514                 fTofPIDnSigmaAboveElectronLine=  3;\r
1515                 break;\r
1516         default:\r
1517         cout<<"Warning: TOFElectronCut not defined "<<TOFelectronPID<<endl;\r
1518         return kFALSE;\r
1519     } //////////////////////// RRnewTOF end //////////////////////////////////////////////////////////////////////////\r
1520     return kTRUE;\r
1521 }\r
1522 ///_______________________________________________________________________________\r
1523 \r
1524 Bool_t AliDalitzElectronCuts::SetPsiPairCut(Int_t psiCut) {\r
1525   \r
1526 \r
1527   switch(psiCut) {\r
1528   case 0:\r
1529         fDoPsiPairCut = kFALSE;\r
1530         fPsiPairCut = 10000.; //\r
1531         fDeltaPhiCutMin = -1000.;\r
1532         fDeltaPhiCutMax =  1000.;\r
1533         \r
1534         break;\r
1535   case 1:\r
1536         fDoPsiPairCut = kTRUE;\r
1537         fPsiPairCut = 0.45; // Standard\r
1538         fDeltaPhiCutMin = 0.0;\r
1539         fDeltaPhiCutMax = 0.12;\r
1540         break;\r
1541   case 2:\r
1542         fDoPsiPairCut = kTRUE;\r
1543         fPsiPairCut = 0.60; \r
1544         fDeltaPhiCutMin = 0.0;\r
1545         fDeltaPhiCutMax = 0.12;\r
1546         break;\r
1547   case 3:\r
1548         fDoPsiPairCut = kTRUE;\r
1549         fPsiPairCut = 0.52;\r
1550         fDeltaPhiCutMin = 0.0;\r
1551         fDeltaPhiCutMax = 0.12;\r
1552         break;\r
1553     \r
1554   default:\r
1555       cout<<"Warning: PsiPairCut not defined "<<fPsiPairCut<<endl;\r
1556       return kFALSE;\r
1557   }\r
1558 \r
1559   return kTRUE;\r
1560 }\r
1561 \r
1562 ///_______________________________________________________________________________\r
1563 Bool_t AliDalitzElectronCuts::SetRejectSharedElecGamma(Int_t RCut) {\r
1564   \r
1565 \r
1566   switch(RCut) {\r
1567   case 0:\r
1568         fDoRejectSharedElecGamma = kFALSE;\r
1569         fRadiusCut = 10000; // \r
1570         break;\r
1571   case 1:\r
1572         fDoRejectSharedElecGamma = kTRUE;\r
1573         fRadiusCut = 2.0; // cm \r
1574         break;\r
1575   case 2:\r
1576         fDoRejectSharedElecGamma = kTRUE;\r
1577         fRadiusCut = 3.0; // Standard\r
1578         break;\r
1579   case 3:\r
1580         fDoRejectSharedElecGamma = kTRUE;\r
1581         fRadiusCut = 4.0; // \r
1582         break;\r
1583   case 4:\r
1584         fDoRejectSharedElecGamma = kTRUE;\r
1585         fRadiusCut = 5.0; // \r
1586         break;\r
1587   case 5:\r
1588         fDoRejectSharedElecGamma = kTRUE;\r
1589         fRadiusCut = 10.0; // \r
1590         break;\r
1591   case 6:\r
1592         fDoRejectSharedElecGamma = kTRUE;\r
1593         fRadiusCut = 15.0; // \r
1594         break;\r
1595   default:\r
1596       cout<<"Warning: PsiPairCut not defined "<<fDoRejectSharedElecGamma<<endl;\r
1597       return kFALSE;\r
1598   }\r
1599 \r
1600   return kTRUE;\r
1601 }\r
1602 ///__________________________________________________________________________\r
1603 Bool_t AliDalitzElectronCuts::SetBackgroundScheme(Int_t BackgroundScheme){\r
1604 \r
1605     // Set Cut\r
1606     switch(BackgroundScheme){\r
1607 \r
1608     case 0: //Rotation\r
1609             fBKGMethod = 0;\r
1610             fUseTrackMultiplicityForBG = kFALSE;\r
1611         break;\r
1612     case 1: // mixed event with V0 multiplicity\r
1613             fBKGMethod  = 1;\r
1614             fUseTrackMultiplicityForBG = kFALSE;\r
1615         break;\r
1616     case 2: // mixed event with track multiplicity\r
1617             fUseTrackMultiplicityForBG = kTRUE;\r
1618             fBKGMethod  = 1;\r
1619         break;\r
1620     case 3: //Rotation\r
1621            fUseTrackMultiplicityForBG = kFALSE;\r
1622             fBKGMethod  = 2;\r
1623         break;\r
1624     case 4: //Rotation\r
1625             fUseTrackMultiplicityForBG = kTRUE;\r
1626             fBKGMethod  = 2;\r
1627         break;\r
1628     case 5: fUseTrackMultiplicityForBG = kTRUE;\r
1629             fBKGMethod  = 3;\r
1630         break;\r
1631 \r
1632     default:\r
1633         cout<<"Warning: BackgroundScheme not defined "<<BackgroundScheme<<endl;\r
1634         return kFALSE;\r
1635     }\r
1636     return kTRUE;\r
1637 }\r
1638 \r
1639 ///________________________________________________________________________\r
1640 Bool_t AliDalitzElectronCuts::SetNumberOfRotations(Int_t NumberOfRotations)\r
1641 {   // Set Cut\r
1642     switch(NumberOfRotations){\r
1643     case 0:\r
1644         fnumberOfRotationEventsForBG = 5;\r
1645         break;\r
1646     case 1:\r
1647         fnumberOfRotationEventsForBG = 10;\r
1648         break;\r
1649     case 2:\r
1650         fnumberOfRotationEventsForBG = 15;\r
1651         break;\r
1652     case 3:\r
1653         fnumberOfRotationEventsForBG = 20;\r
1654         break;\r
1655     case 4:\r
1656         fnumberOfRotationEventsForBG = 2;\r
1657         break;\r
1658     case 5:\r
1659         fnumberOfRotationEventsForBG = 50;\r
1660         break;\r
1661     case 6:\r
1662         fnumberOfRotationEventsForBG = 80;\r
1663         break;\r
1664     case 7:\r
1665         fnumberOfRotationEventsForBG = 100;\r
1666         break;\r
1667     default:\r
1668         cout<<"Warning: NumberOfRotations not defined "<<NumberOfRotations<<endl;\r
1669         return kFALSE;\r
1670     }\r
1671     return kTRUE;\r
1672 }\r
1673 \r
1674 \r
1675 \r
1676 ///________________________________________________________________________\r
1677 Bool_t AliDalitzElectronCuts::SetMassCut(Int_t massCut)\r
1678 {   // Set Cut\r
1679     switch(massCut){\r
1680       \r
1681     case 0:\r
1682                         \r
1683                         fMassCutPtMin  = -999.; //GeV\r
1684                         fMassCutLowPt  =  999.; //GeV/c^2\r
1685                         fMassCutHighPt =  999.; //GeV/c^2\r
1686                         fDoMassCut = kFALSE;   \r
1687                         break;\r
1688     case 1:\r
1689                         //fMassCut = 0.135;             //GeV/c^2\r
1690                         fMassCutPtMin  = -999.; //GeV\r
1691                         fMassCutLowPt  = 0.135; //GeV/c^2\r
1692                         fMassCutHighPt = 0.135; //GeV/c^2\r
1693                         fDoMassCut = kTRUE;\r
1694                         break; \r
1695     case 2:\r
1696                         //fMassCut = 0.100;     //GeV/c^2\r
1697                         fMassCutPtMin  = -999.; //GeV\r
1698                         fMassCutLowPt  = 0.100; //GeV/c^2\r
1699                         fMassCutHighPt = 0.100; //GeV/c^2\r
1700                         fDoMassCut = kTRUE;\r
1701                         break;\r
1702     case 3:\r
1703                         //fMassCut = 0.075;     //GeV/c^2\r
1704                         fMassCutPtMin  = -999.; //GeV\r
1705                         fMassCutLowPt  = 0.075; //GeV/c^2\r
1706                         fMassCutHighPt = 0.075; //GeV/c^2\r
1707                         fDoMassCut = kTRUE;\r
1708                         break;\r
1709     case 4:\r
1710                         //fMassCut = 0.050;     //GeV/c^2\r
1711                         fMassCutPtMin  = -999.; //GeV\r
1712                         fMassCutLowPt  = 0.050; //GeV/c^2\r
1713                         fMassCutHighPt = 0.050; //GeV/c^2\r
1714                         fDoMassCut = kTRUE;\r
1715                         break;\r
1716     case 5:\r
1717                         \r
1718                         fMassCutPtMin  = -999.; //GeV\r
1719                         fMassCutLowPt  = 0.035; //GeV/c^2\r
1720                         fMassCutHighPt = 0.035; //GeV/c^2\r
1721                         fDoMassCut = kTRUE;\r
1722                         break;\r
1723     case 6:\r
1724                         fMassCutPtMin  = -999.; //GeV\r
1725                         fMassCutLowPt  = 0.015; //GeV/c^2\r
1726                         fMassCutHighPt = 0.015; //GeV/c^2\r
1727                         fDoMassCut = kTRUE;\r
1728                         break;\r
1729     case 7:             fMassCutPtMin  = 1.0;   //GeV\r
1730                         fMassCutLowPt  = 0.015; //GeV/c^2\r
1731                         fMassCutHighPt = 0.035; //GeV/c^2\r
1732                         fDoMassCut = kTRUE;\r
1733                         break;\r
1734     default:\r
1735                         cout<<"Warning: MassCut not defined "<<massCut<<endl;\r
1736                         return kFALSE;\r
1737     }\r
1738     return kTRUE;\r
1739 }\r
1740 \r
1741 ///________________________________________________________________________\r
1742 TString AliDalitzElectronCuts::GetCutNumber(){\r
1743     // returns TString with current cut number\r
1744   TString a(kNCuts);\r
1745   for(Int_t ii=0;ii<kNCuts;ii++){\r
1746         a.Append(Form("%d",fCuts[ii]));\r
1747   }\r
1748   return a;\r
1749 }\r
1750 \r
1751 \r
1752 ///________________________________________________________________________\r
1753 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010PbPb(){\r
1754     //Create and return standard 2010 PbPb cuts\r
1755     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");\r
1756     if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1757         cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}\r
1758     return cuts;\r
1759 }\r
1760 \r
1761 ///________________________________________________________________________\r
1762 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010pp(){\r
1763     //Create and return standard 2010 PbPb cuts\r
1764     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010pp","StandardCuts2010pp");\r
1765                                           \r
1766     if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1767         cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}\r
1768      return cuts;\r
1769 }\r
1770 \r