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 };\r
  66 \r
  67 //________________________________________________________________________\r
  68 AliDalitzElectronCuts::AliDalitzElectronCuts(const char *name,const char *title) : AliAnalysisCuts(name,title),\r
  69     fHistograms(NULL),\r
  70     fPIDResponse(NULL),\r
  71     fesdTrackCuts(NULL),\r
  72     fEtaCut(0.9),\r
  73     fRadiusCut(1000.0),\r
  74     fPsiPairCut(0.45),\r
  75     fDeltaPhiCutMin(0.),\r
  76     fDeltaPhiCutMax(0.12),\r
  77     fMinClsTPC(0), // minimum clusters in the TPC\r
  78     fMinClsTPCToF(0), // minimum clusters to findable clusters\r
  79     fDodEdxSigmaITSCut(kFALSE),\r
  80     fDodEdxSigmaTPCCut(kTRUE),\r
  81     fDoTOFsigmaCut(kFALSE), // RRnewTOF\r
  82     fDoRejectSharedElecGamma(kFALSE),\r
  83     fDoPsiPairCut(kFALSE),\r
  84     fPIDnSigmaAboveElectronLineITS(100),\r
  85     fPIDnSigmaBelowElectronLineITS(-100),\r
  86     fPIDnSigmaAboveElectronLineTPC(100),\r
  87     fPIDnSigmaBelowElectronLineTPC(-100),\r
  88     fPIDnSigmaAbovePionLineTPC(0),\r
  89     fPIDnSigmaAbovePionLineTPCHighPt(-100),\r
  90     fTofPIDnSigmaAboveElectronLine(100), // RRnewTOF\r
  91     fTofPIDnSigmaBelowElectronLine(-100), // RRnewTOF\r
  92     fPIDMinPnSigmaAbovePionLineTPC(0),\r
  93     fPIDMaxPnSigmaAbovePionLineTPC(0),\r
  94     fDoKaonRejectionLowP(kFALSE),\r
  95     fDoProtonRejectionLowP(kFALSE),\r
  96     fDoPionRejectionLowP(kFALSE),\r
  97     fPIDnSigmaAtLowPAroundKaonLine(0),\r
  98     fPIDnSigmaAtLowPAroundProtonLine(0),\r
  99     fPIDnSigmaAtLowPAroundPionLine(0),\r
 100     fPIDMinPKaonRejectionLowP(1.5),\r
 101     fPIDMinPProtonRejectionLowP(2.0),\r
 102     fPIDMinPPionRejectionLowP(0.5),\r
 103     fUseCorrectedTPCClsInfo(kFALSE),\r
 104     fUseTOFpid(kFALSE),\r
 105     fRequireTOF(kFALSE),\r
 106     fUseTrackMultiplicityForBG(kFALSE),\r
 107     fBKGMethod(0),\r
 108     fnumberOfRotationEventsForBG(0),\r
 109     fCutString(NULL),\r
 110     hCutIndex(NULL),\r
 111     hdEdxCuts(NULL),\r
 112     hITSdEdxbefore(NULL),\r
 113     hITSdEdxafter(NULL),\r
 114     hTPCdEdxbefore(NULL),\r
 115     hTPCdEdxafter(NULL),\r
 116     hTPCdEdxSignalbefore(NULL),\r
 117     hTPCdEdxSignalafter(NULL),\r
 118     hTOFbefore(NULL),\r
 119     hTOFafter(NULL)\r
 120    {\r
 121     InitPIDResponse();\r
 122     for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=0;}\r
 123     fCutString=new TObjString((GetCutNumber()).Data());\r
 124 \r
 125    //fesdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");\r
 126    // Using standard function for setting Cuts\r
 127     Bool_t selectPrimaries=kTRUE;\r
 128     fesdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);\r
 129 }\r
 130 \r
 131 //________________________________________________________________________\r
 132 AliDalitzElectronCuts::~AliDalitzElectronCuts() {\r
 133     // Destructor\r
 134   //Deleting fHistograms leads to seg fault it it's added to output collection of a task\r
 135   // if(fHistograms)\r
 136   //    delete fHistograms;\r
 137   // fHistograms = NULL;\r
 138 \r
 139    if(fCutString != NULL){\r
 140       delete fCutString;\r
 141       fCutString = NULL;\r
 142    }\r
 143 \r
 144 \r
 145 }\r
 146 \r
 147 //________________________________________________________________________\r
 148 void AliDalitzElectronCuts::InitCutHistograms(TString name, Bool_t preCut,TString cutNumber){\r
 149 \r
 150     // Initialize Cut Histograms for QA (only initialized and filled if function is called)\r
 151 \r
 152      TString cutName = "";\r
 153     \r
 154      if( cutNumber==""){\r
 155          cutName = GetCutNumber().Data();\r
 156      }\r
 157      else {\r
 158             cutName = cutNumber.Data();\r
 159      } \r
 160 \r
 161     if(fHistograms != NULL){\r
 162         delete fHistograms;\r
 163         fHistograms=NULL;\r
 164     }\r
 165     if(fHistograms==NULL){\r
 166         fHistograms=new TList();\r
 167         if(name=="")fHistograms->SetName(Form("ElectronCuts_%s",cutName.Data()));\r
 168         else fHistograms->SetName(Form("%s_%s",name.Data(),cutName.Data()));\r
 169     }\r
 170 \r
 171 \r
 172     hCutIndex=new TH1F(Form("IsElectronSelected %s",cutName.Data()),"IsElectronSelected",10,-0.5,9.5);\r
 173     hCutIndex->GetXaxis()->SetBinLabel(kElectronIn+1,"in");\r
 174     hCutIndex->GetXaxis()->SetBinLabel(kNoTracks+1,"no tracks");\r
 175     hCutIndex->GetXaxis()->SetBinLabel(kTrackCuts+1,"Track cuts");\r
 176     hCutIndex->GetXaxis()->SetBinLabel(kdEdxCuts+1,"dEdx");\r
 177     hCutIndex->GetXaxis()->SetBinLabel(kElectronOut+1,"out");\r
 178     fHistograms->Add(hCutIndex);\r
 179 \r
 180 \r
 181 \r
 182     // dEdx Cuts\r
 183     hdEdxCuts=new TH1F(Form("dEdxCuts %s",cutName.Data()),"dEdxCuts",10,-0.5,9.5);\r
 184     hdEdxCuts->GetXaxis()->SetBinLabel(1,"in");\r
 185     hdEdxCuts->GetXaxis()->SetBinLabel(2,"ITSelectron");\r
 186     hdEdxCuts->GetXaxis()->SetBinLabel(3,"TPCelectron");\r
 187     hdEdxCuts->GetXaxis()->SetBinLabel(4,"TPCpion");\r
 188     hdEdxCuts->GetXaxis()->SetBinLabel(5,"TPCpionhighp");\r
 189     hdEdxCuts->GetXaxis()->SetBinLabel(6,"TPCkaonlowprej");\r
 190     hdEdxCuts->GetXaxis()->SetBinLabel(7,"TPCprotonlowprej");\r
 191     hdEdxCuts->GetXaxis()->SetBinLabel(8,"TPCpionlowprej");\r
 192     hdEdxCuts->GetXaxis()->SetBinLabel(9,"TOFelectron");\r
 193     hdEdxCuts->GetXaxis()->SetBinLabel(10,"out");\r
 194     fHistograms->Add(hdEdxCuts);\r
 195     \r
 196 \r
 197 \r
 198     TAxis *AxisBeforeITS  = NULL;\r
 199     TAxis *AxisBeforedEdx = NULL;\r
 200     TAxis *AxisBeforeTOF  = NULL;\r
 201     TAxis *AxisBeforedEdxSignal = NULL;\r
 202 \r
 203     if(preCut){\r
 204 \r
 205 \r
 206        hITSdEdxbefore=new TH2F(Form("Electron_ITS_before %s",cutName.Data()),"ITS dEdx electron before" ,150,0.05,20,400,-10,10);\r
 207        fHistograms->Add(hITSdEdxbefore);\r
 208        AxisBeforeITS = hITSdEdxbefore->GetXaxis();\r
 209 \r
 210        hTPCdEdxbefore=new TH2F(Form("Electron_dEdx_before %s",cutName.Data()),"dEdx electron before" ,150,0.05,20,400,-10,10);\r
 211        fHistograms->Add(hTPCdEdxbefore);\r
 212        AxisBeforedEdx = hTPCdEdxbefore->GetXaxis();\r
 213 \r
 214        hTPCdEdxSignalbefore=new TH2F(Form("Electron_dEdxSignal_before %s",cutName.Data()),"dEdx electron signal before" ,150,0.05,20.0,800,0.0,200);\r
 215        fHistograms->Add(hTPCdEdxSignalbefore);\r
 216        AxisBeforedEdxSignal = hTPCdEdxSignalbefore->GetXaxis();\r
 217 \r
 218 \r
 219        hTOFbefore=new TH2F(Form("Electron_TOF_before %s",cutName.Data()),"TOF electron before" ,150,0.05,20,400,-6,10);\r
 220        fHistograms->Add(hTOFbefore);\r
 221        AxisBeforeTOF = hTOFbefore->GetXaxis();\r
 222 \r
 223     }\r
 224 \r
 225 \r
 226     hITSdEdxafter=new TH2F(Form("Electron_ITS_after %s",cutName.Data()),"ITS dEdx electron after" ,150,0.05,20,400, -10,10);\r
 227     fHistograms->Add(hITSdEdxafter);\r
 228 \r
 229     hTPCdEdxafter=new TH2F(Form("Electron_dEdx_after %s",cutName.Data()),"dEdx electron after" ,150,0.05,20,400, -10,10);\r
 230     fHistograms->Add(hTPCdEdxafter);\r
 231 \r
 232     hTPCdEdxSignalafter=new TH2F(Form("Electron_dEdxSignal_after %s",cutName.Data()),"dEdx electron signal after" ,150,0.05,20.0,800,0.0,200);\r
 233     fHistograms->Add(hTPCdEdxSignalafter);\r
 234 \r
 235     hTOFafter=new TH2F(Form("Electron_TOF_after %s",cutName.Data()),"TOF electron after" ,150,0.05,20,400,-6,10);\r
 236     fHistograms->Add(hTOFafter);\r
 237 \r
 238     TAxis *AxisAfter = hTPCdEdxafter->GetXaxis(); \r
 239     Int_t bins = AxisAfter->GetNbins();\r
 240     Double_t from = AxisAfter->GetXmin();\r
 241     Double_t to = AxisAfter->GetXmax();\r
 242     Double_t *newBins = new Double_t[bins+1];\r
 243     newBins[0] = from;\r
 244     Double_t factor = TMath::Power(to/from, 1./bins);\r
 245     for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];\r
 246     AxisAfter->Set(bins, newBins);\r
 247     AxisAfter = hTOFafter->GetXaxis(); \r
 248     AxisAfter->Set(bins, newBins);\r
 249     AxisAfter = hITSdEdxafter->GetXaxis();\r
 250     AxisAfter->Set(bins,newBins); \r
 251     AxisAfter = hTPCdEdxSignalafter->GetXaxis();\r
 252     AxisAfter->Set(bins,newBins);\r
 253     \r
 254     if(preCut){\r
 255        AxisBeforeITS->Set(bins, newBins);\r
 256        AxisBeforedEdx->Set(bins, newBins);\r
 257        AxisBeforedEdxSignal->Set(bins,newBins);\r
 258        AxisBeforeTOF->Set(bins, newBins);\r
 259        \r
 260     }\r
 261     delete [] newBins;\r
 262 \r
 263         \r
 264     // Event Cuts and Info\r
 265 }\r
 266 \r
 267 \r
 268 //________________________________________________________________________\r
 269 Bool_t AliDalitzElectronCuts::InitPIDResponse(){\r
 270 \r
 271 // Set Pointer to AliPIDResponse\r
 272 \r
 273   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();\r
 274 \r
 275   if(man) {\r
 276 \r
 277     AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());\r
 278     fPIDResponse = (AliPIDResponse*)inputHandler->GetPIDResponse();\r
 279     if(fPIDResponse)return kTRUE;\r
 280 \r
 281   }\r
 282 \r
 283   return kFALSE;\r
 284 }\r
 285 ///________________________________________________________________________\r
 286 Bool_t AliDalitzElectronCuts::ElectronIsSelectedMC(Int_t labelParticle,AliStack *fMCStack)\r
 287 {   \r
 288         if( labelParticle < 0 ) return kFALSE;\r
 289         if( fMCStack->IsPhysicalPrimary(labelParticle) == kFALSE ) return kFALSE;\r
 290 \r
 291         TParticle* particle = fMCStack->Particle(labelParticle);\r
 292 \r
 293         if( TMath::Abs( particle->GetPdgCode() ) != 11)  return kFALSE;\r
 294         if( TMath::Abs( particle->Eta() ) > fEtaCut   )  return kFALSE;\r
 295 \r
 296 return kTRUE;\r
 297 }\r
 298 \r
 299 \r
 300 ///________________________________________________________________________\r
 301 Bool_t AliDalitzElectronCuts::ElectronIsSelected(AliESDtrack* lTrack)\r
 302 {\r
 303     //Selection of Reconstructed electrons\r
 304 \r
 305     if(hCutIndex)hCutIndex->Fill(kElectronIn);\r
 306 \r
 307     if (lTrack == NULL){\r
 308       if(hCutIndex)hCutIndex->Fill(kNoTracks);\r
 309          return kFALSE;  \r
 310     }   \r
 311        \r
 312     if ( ! lTrack->GetConstrainedParam() ){\r
 313         return kFALSE;\r
 314     }\r
 315     AliVTrack * track = dynamic_cast<AliVTrack*>(lTrack);\r
 316 \r
 317 \r
 318     // Track Cuts\r
 319     if( !TrackIsSelected(lTrack) ){\r
 320          if(hCutIndex)hCutIndex->Fill(kTrackCuts);\r
 321          return kFALSE;\r
 322     }\r
 323 \r
 324 \r
 325     // dEdx Cuts\r
 326     if( ! dEdxCuts( track ) ) {\r
 327          if(hCutIndex)hCutIndex->Fill(kdEdxCuts);\r
 328          return kFALSE;\r
 329 \r
 330     }\r
 331 \r
 332     //Electron passed the cuts\r
 333     if(hCutIndex)hCutIndex->Fill(kElectronOut);\r
 334 \r
 335 \r
 336     return kTRUE;\r
 337 }\r
 338 \r
 339 ///________________________________________________________________________\r
 340 Bool_t AliDalitzElectronCuts::TrackIsSelected(AliESDtrack* lTrack) {\r
 341     // Track Selection for Photon Reconstruction\r
 342 \r
 343 \r
 344 \r
 345     if( ! fesdTrackCuts->AcceptTrack(lTrack) ){\r
 346 \r
 347         return kFALSE;\r
 348     }\r
 349 \r
 350    if(  TMath::Abs( lTrack->Eta()) > fEtaCut ) {\r
 351 \r
 352         return kFALSE;\r
 353     }\r
 354 \r
 355     if( lTrack->GetNcls(1) < fMinClsTPC ) {\r
 356 \r
 357         return kFALSE;\r
 358     }\r
 359 \r
 360     //Findable clusters\r
 361 \r
 362     Double_t clsToF=0;\r
 363 \r
 364 \r
 365     if (!fUseCorrectedTPCClsInfo ){\r
 366         if(lTrack->GetTPCNclsF()!=0){\r
 367 \r
 368               clsToF = (Double_t)lTrack->GetNcls(1)/(Double_t)lTrack->GetTPCNclsF();\r
 369         }// Ncluster/Nfindablecluster\r
 370     }\r
 371     else {\r
 372 \r
 373               //clsToF = lTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));\r
 374               clsToF = lTrack->GetTPCClusterInfo(2,1); //NOTE ask friederike\r
 375                 \r
 376     }\r
 377 \r
 378 \r
 379     if( clsToF < fMinClsTPCToF){\r
 380     return kFALSE;\r
 381     }\r
 382 \r
 383 \r
 384 \r
 385    return kTRUE;\r
 386 }\r
 387 ///________________________________________________________________________\r
 388 Bool_t AliDalitzElectronCuts::dEdxCuts(AliVTrack *fCurrentTrack){\r
 389 \r
 390     // Electron Identification Cuts for Photon reconstruction\r
 391 \r
 392     if(!fPIDResponse){  InitPIDResponse();  }// Try to reinitialize PID Response\r
 393     if(!fPIDResponse){  AliError("No PID Response"); return kFALSE;}// if still missing fatal error\r
 394 \r
 395 \r
 396 \r
 397     //cout<<"dEdxCuts: //////////////////////////////////////////////////////////////////////////"<<endl;\r
 398 \r
 399 \r
 400 \r
 401     Int_t cutIndex=0;\r
 402 \r
 403     if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 404     if(hITSdEdxbefore)hITSdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));\r
 405     if(hTPCdEdxbefore)hTPCdEdxbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));\r
 406     if(hTPCdEdxSignalbefore)hTPCdEdxSignalbefore->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));\r
 407 \r
 408 \r
 409     cutIndex++;\r
 410 \r
 411 \r
 412   if( fDodEdxSigmaITSCut == kTRUE ){\r
 413 \r
 414 \r
 415         if( fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineITS ||\r
 416                 fPIDResponse->NumberOfSigmasITS(fCurrentTrack,AliPID::kElectron)> fPIDnSigmaAboveElectronLineITS ){\r
 417 \r
 418           if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 419           return kFALSE;\r
 420       }\r
 421      \r
 422   }\r
 423 \r
 424  if(hITSdEdxafter)hITSdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasITS(fCurrentTrack, AliPID::kElectron));\r
 425 \r
 426 \r
 427   cutIndex++;\r
 428 \r
 429 \r
 430   if(fDodEdxSigmaTPCCut == kTRUE){\r
 431 \r
 432 \r
 433       // TPC Electron Line\r
 434       if( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLineTPC ||\r
 435                 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaAboveElectronLineTPC){\r
 436 \r
 437           if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 438           return kFALSE;\r
 439       }\r
 440       cutIndex++;\r
 441 \r
 442       // TPC Pion Line\r
 443         if( fCurrentTrack->P()>fPIDMinPnSigmaAbovePionLineTPC && fCurrentTrack->P()<fPIDMaxPnSigmaAbovePionLineTPC ){\r
 444           if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC     &&\r
 445                  fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC &&\r
 446                  fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPC){\r
 447 \r
 448               if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 449               return kFALSE;\r
 450           }\r
 451         }\r
 452         cutIndex++;\r
 453    \r
 454         // High Pt Pion rej\r
 455         if( fCurrentTrack->P()>fPIDMaxPnSigmaAbovePionLineTPC ){\r
 456           if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLineTPC &&\r
 457                  fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLineTPC&&\r
 458                  fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineTPCHighPt){\r
 459 \r
 460                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 461                 return kFALSE;\r
 462           }\r
 463         }\r
 464 \r
 465         cutIndex++;\r
 466   }\r
 467 \r
 468   else{ cutIndex+=3; }\r
 469 \r
 470 \r
 471   if(   fDoKaonRejectionLowP == kTRUE   ){\r
 472 \r
 473         if( fCurrentTrack->P() < fPIDMinPKaonRejectionLowP ){\r
 474 \r
 475           if( TMath::Abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kKaon))<fPIDnSigmaAtLowPAroundKaonLine){\r
 476 \r
 477               if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 478 \r
 479               return kFALSE;\r
 480           }\r
 481         }\r
 482   }\r
 483   cutIndex++;\r
 484    \r
 485   if(   fDoProtonRejectionLowP == kTRUE    ){\r
 486 \r
 487         if( fCurrentTrack->P()  < fPIDMinPProtonRejectionLowP ){\r
 488           if( TMath::Abs(   fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kProton))<fPIDnSigmaAtLowPAroundProtonLine){\r
 489 \r
 490               if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 491               return kFALSE;\r
 492           }\r
 493         }\r
 494   }\r
 495    cutIndex++;\r
 496    \r
 497   if(fDoPionRejectionLowP == kTRUE){\r
 498         if( fCurrentTrack->P() < fPIDMinPPionRejectionLowP ){\r
 499           if( TMath::Abs( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)) < fPIDnSigmaAtLowPAroundPionLine ){\r
 500 \r
 501               if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 502                 return kFALSE;\r
 503           }\r
 504         }\r
 505   }\r
 506   cutIndex++;\r
 507 \r
 508    \r
 509   if( ( fCurrentTrack->GetStatus() & AliESDtrack::kTOFpid ) && ( !( fCurrentTrack->GetStatus() & AliESDtrack::kTOFmismatch) ) ){\r
 510    if(hTOFbefore) hTOFbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));\r
 511      if(fUseTOFpid){\r
 512         if(fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)>fTofPIDnSigmaAboveElectronLine ||\r
 513            fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)<fTofPIDnSigmaBelowElectronLine ){\r
 514            if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 515            return kFALSE;\r
 516         }\r
 517      }\r
 518      if(hTOFafter)hTOFafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));\r
 519   }\r
 520   else if ( fRequireTOF == kTRUE ) {\r
 521 \r
 522             if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 523             return kFALSE;\r
 524   }\r
 525      cutIndex++;\r
 526 \r
 527   if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);\r
 528   if(hTPCdEdxafter)hTPCdEdxafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));\r
 529   if(hTPCdEdxSignalafter)hTPCdEdxSignalafter->Fill(fCurrentTrack->P(),TMath::Abs(fCurrentTrack->GetTPCsignal()));\r
 530 \r
 531   return kTRUE;\r
 532 }\r
 533 ///________________________________________________________________________\r
 534 \r
 535 \r
 536 AliVTrack *AliDalitzElectronCuts::GetTrack(AliVEvent * event, Int_t label){\r
 537     //Returns pointer to the track with given ESD label\r
 538     //(Important for AOD implementation, since Track array in AOD data is different\r
 539     //from ESD array, but ESD tracklabels are stored in AOD Tracks)\r
 540 \r
 541   AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);\r
 542   if(esdEvent) {\r
 543         if(label > event->GetNumberOfTracks() ) return NULL;\r
 544         AliESDtrack * track = esdEvent->GetTrack(label);\r
 545         return track;\r
 546         \r
 547   } else { \r
 548         for(Int_t ii=0; ii<event->GetNumberOfTracks(); ii++) {\r
 549           AliVTrack * track = dynamic_cast<AliVTrack*>(event->GetTrack(ii));\r
 550           \r
 551           if(track) { \r
 552                 if(track->GetID() == label) {\r
 553                   return track;\r
 554                 }\r
 555           }\r
 556         }\r
 557     }\r
 558   \r
 559   cout << "track not found " << label << " " << event->GetNumberOfTracks() << endl;\r
 560   return NULL;\r
 561 }\r
 562 ///________________________________________________________________________\r
 563 Bool_t AliDalitzElectronCuts::RejectSharedElecGamma(TList *photons, Int_t indexEle){\r
 564 \r
 565 \r
 566      for(Int_t i = 0;i<photons->GetEntries();i++){\r
 567 \r
 568       AliAODConversionPhoton *photonComp = (AliAODConversionPhoton*) photons->At(i);\r
 569 \r
 570       Int_t posLabel = photonComp->GetTrackLabelPositive();\r
 571       Int_t negLabel = photonComp->GetTrackLabelNegative();\r
 572 \r
 573       if( (photonComp->GetConversionRadius() < fRadiusCut) && (posLabel == indexEle || negLabel == indexEle) ){\r
 574         return kFALSE;\r
 575       }\r
 576      }\r
 577 \r
 578    return kTRUE;\r
 579 }\r
 580 /*\r
 581 Double_t AliDalitzElectronCuts::GetPsiPair( const AliESDtrack *trackPos, const AliESDtrack *trackNeg )\r
 582 {\r
 583 //\r
 584 // This angle is a measure for the contribution of the opening in polar\r
 585 // direction ??0 to the opening angle ?? Pair\r
 586 //\r
 587 // Ref. Measurement of photons via conversion pairs with the PHENIX experiment at RHIC\r
 588 //      Master Thesis. Thorsten Dahms. 2005\r
 589 // https://twiki.cern.ch/twiki/pub/ALICE/GammaPhysicsPublications/tdahms_thesis.pdf\r
 590 //\r
 591         Double_t momPos[3];\r
 592         Double_t momNeg[3];\r
 593         if( trackPos->GetConstrainedPxPyPz(momPos) == 0 ) trackPos->GetPxPyPz( momPos );\r
 594         if( trackNeg->GetConstrainedPxPyPz(momNeg) == 0 ) trackNeg->GetPxPyPz( momNeg );\r
 595 \r
 596         TVector3 posDaughter;\r
 597         TVector3 negDaughter;\r
 598 \r
 599         posDaughter.SetXYZ( momPos[0], momPos[1], momPos[2] );\r
 600         negDaughter.SetXYZ( momNeg[0], momNeg[1], momNeg[2] );\r
 601 \r
 602         Double_t deltaTheta = negDaughter.Theta() - posDaughter.Theta();\r
 603         Double_t openingAngle =  posDaughter.Angle( negDaughter );  //TMath::ACos( posDaughter.Dot(negDaughter)/(negDaughter.Mag()*posDaughter.Mag()) );\r
 604 \r
 605         if( openingAngle < 1e-20 ) return 0.;\r
 606 \r
 607         Double_t psiAngle = TMath::ASin( deltaTheta/openingAngle );\r
 608 \r
 609         return psiAngle;\r
 610 }*/\r
 611 \r
 612 Bool_t AliDalitzElectronCuts::IsFromGammaConversion( Double_t psiPair, Double_t deltaPhi )\r
 613 {\r
 614 //\r
 615 // Returns true if it is a gamma conversion according to psi pair value\r
 616 //\r
 617         return ( (deltaPhi > fDeltaPhiCutMin  &&  deltaPhi < fDeltaPhiCutMax) &&\r
 618         TMath::Abs(psiPair) < ( fPsiPairCut - fPsiPairCut/fDeltaPhiCutMax * deltaPhi ) );\r
 619 }\r
 620 \r
 621 ///________________________________________________________________________\r
 622 Bool_t AliDalitzElectronCuts::UpdateCutString(cutIds cutID, Int_t value) {\r
 623 ///Update the cut string (if it has been created yet)\r
 624 \r
 625   if(fCutString && fCutString->GetString().Length() == kNCuts) {\r
 626 //         cout << "Updating cut id in spot number " << cutID << " to " << value << endl;\r
 627         fCutString->SetString(GetCutNumber());\r
 628   } else {\r
 629 //         cout << "fCutString not yet initialized, will not be updated" << endl;\r
 630         return kFALSE;\r
 631   }\r
 632  // cout << fCutString->GetString().Data() << endl;\r
 633   return kTRUE;\r
 634 }\r
 635 \r
 636 ///________________________________________________________________________\r
 637 Bool_t AliDalitzElectronCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {\r
 638    // Initialize Cuts from a given Cut string\r
 639 \r
 640 //   out<<"Set Cut Number: "<<analysisCutSelection.Data()<<endl;\r
 641   if(analysisCutSelection.Length()!=kNCuts) {\r
 642         AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));\r
 643         return kFALSE;\r
 644   }\r
 645   if(!analysisCutSelection.IsDigit()){\r
 646         AliError("Cut selection contains characters");\r
 647         return kFALSE;\r
 648   }\r
 649   \r
 650   const char *cutSelection = analysisCutSelection.Data();\r
 651   #define ASSIGNARRAY(i)        fCuts[i] = cutSelection[i] - '0'\r
 652   for(Int_t ii=0;ii<kNCuts;ii++){\r
 653       ASSIGNARRAY(ii);\r
 654   }\r
 655 \r
 656   // TestFlag\r
 657   if(fCuts[0] !=9){\r
 658     AliError("Analysis Cut Selection does not start with 9");\r
 659         PrintCuts();\r
 660     return kFALSE;\r
 661   }\r
 662 \r
 663   // Set Individual Cuts\r
 664   for(Int_t ii=0;ii<kNCuts;ii++){\r
 665       if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;\r
 666   }\r
 667 \r
 668   //PrintCuts();\r
 669 \r
 670     return kTRUE;\r
 671 }\r
 672 ///________________________________________________________________________\r
 673 Bool_t AliDalitzElectronCuts::SetCut(cutIds cutID, const Int_t value) {\r
 674   ///Set individual cut ID\r
 675 \r
 676   //cout << "Updating cut  " << fgkCutNames[cutID] << " (" << cutID << ") to " << value << endl;\r
 677 \r
 678   switch (cutID) {\r
 679   case kgoodId:\r
 680         fCuts[kgoodId] = value;\r
 681         if(value != 9) {\r
 682           cout << "Error:: First value of cut string is wrong, aborting!!" << endl;\r
 683           return kFALSE;\r
 684         } else {\r
 685           return kTRUE;\r
 686         }\r
 687 \r
 688   case kededxSigmaITSCut:\r
 689         if( SetITSdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented \r
 690           fCuts[kededxSigmaITSCut] = value;\r
 691           UpdateCutString(cutID, value);\r
 692           return kTRUE;\r
 693         } else return kFALSE;\r
 694 \r
 695  case kededxSigmaTPCCut:\r
 696         if( SetTPCdEdxCutElectronLine(value)) { //NOTE SetITSdEdxCutElectronLine: To be implemented \r
 697           fCuts[kededxSigmaTPCCut] = value;\r
 698           UpdateCutString(cutID, value);\r
 699           return kTRUE;\r
 700         } else return kFALSE;\r
 701 \r
 702   case kpidedxSigmaTPCCut:\r
 703         if( SetTPCdEdxCutPionLine(value)) { //NOTE SetITSdEdxCutPionLine: To be implemented\r
 704           fCuts[kpidedxSigmaTPCCut] = value;\r
 705           UpdateCutString(cutID, value);\r
 706           return kTRUE;\r
 707         } else return kFALSE;\r
 708 \r
 709   case kpiMinMomdedxSigmaTPCCut:\r
 710         if( SetMinMomPiondEdxTPCCut(value)) {\r
 711           fCuts[kpiMinMomdedxSigmaTPCCut] = value;\r
 712           UpdateCutString(cutID, value);\r
 713           return kTRUE;\r
 714         } else return kFALSE;\r
 715 \r
 716   case kpiMaxMomdedxSigmaTPCCut:\r
 717         if( SetMaxMomPiondEdxTPCCut(value)) {\r
 718           fCuts[kpiMaxMomdedxSigmaTPCCut] = value;\r
 719           UpdateCutString(cutID, value);\r
 720           return kTRUE;\r
 721         } else return kFALSE;\r
 722 \r
 723   case kLowPRejectionSigmaCut:\r
 724         if( SetLowPRejectionCuts(value) ) {\r
 725           fCuts[kLowPRejectionSigmaCut] = value;\r
 726           UpdateCutString(cutID, value);\r
 727           return kTRUE;\r
 728         } else return kFALSE;\r
 729 \r
 730 \r
 731   case kTOFelectronPID:\r
 732         if( SetTOFElectronPIDCut(value)) {\r
 733           fCuts[kTOFelectronPID] = value;\r
 734           UpdateCutString(cutID, value);\r
 735           return kTRUE;\r
 736         } else return kFALSE;\r
 737   case kclsITSCut:\r
 738         if( SetITSClusterCut(value) ) {\r
 739           fCuts[kclsITSCut] = value;\r
 740           UpdateCutString(cutID, value);\r
 741           return kTRUE;                 \r
 742         } else return kFALSE;\r
 743   case kclsTPCCut:\r
 744         if( SetTPCClusterCut(value)) {\r
 745           fCuts[kclsTPCCut] = value;\r
 746           UpdateCutString(cutID, value);\r
 747           return kTRUE;\r
 748         } else return kFALSE;\r
 749 \r
 750   case ketaCut:\r
 751         if( SetEtaCut(value)) {\r
 752           fCuts[ketaCut] = value;\r
 753           UpdateCutString(cutID, value);\r
 754           return kTRUE;\r
 755         } else return kFALSE;\r
 756    case kPsiPair:\r
 757         if( SetPsiPairCut(value)) {\r
 758           fCuts[kPsiPair] = value;\r
 759           UpdateCutString(cutID, value);\r
 760           return kTRUE;\r
 761         } else return kFALSE;\r
 762 \r
 763   case kRejectSharedElecGamma:\r
 764         if( SetRejectSharedElecGamma(value)) {\r
 765           fCuts[kRejectSharedElecGamma] = value;\r
 766           UpdateCutString(cutID, value);\r
 767           return kTRUE;\r
 768         } else return kFALSE;\r
 769 \r
 770   case kBackgroundScheme:\r
 771         if( SetBackgroundScheme(value)) {\r
 772           fCuts[kBackgroundScheme] = value;\r
 773           UpdateCutString(cutID, value);\r
 774           return kTRUE;\r
 775         } else return kFALSE;\r
 776 \r
 777   case kNumberOfRotations:\r
 778         if( SetNumberOfRotations(value)) {\r
 779           fCuts[kNumberOfRotations] = value;\r
 780           UpdateCutString(cutID, value);\r
 781           return kTRUE;\r
 782         } else return kFALSE;\r
 783 \r
 784   case kNCuts:\r
 785         cout << "Error:: Cut id out of range"<< endl;\r
 786         return kFALSE;\r
 787   }\r
 788 \r
 789   cout << "Error:: Cut id " << cutID << " not recognized "<< endl;\r
 790   return kFALSE;\r
 791 \r
 792   //PrintCuts();\r
 793   \r
 794 }\r
 795 \r
 796 ///________________________________________________________________________\r
 797 \r
 798 void AliDalitzElectronCuts::PrintCuts() {\r
 799     // Print out current Cut Selection\r
 800   for(Int_t ic = 0; ic < kNCuts; ic++) {\r
 801         printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);\r
 802   }\r
 803 \r
 804 }\r
 805 \r
 806 ///________________________________________________________________________\r
 807 Bool_t AliDalitzElectronCuts::SetITSdEdxCutElectronLine(Int_t ededxSigmaCut)\r
 808 {   // Set Cut\r
 809 \r
 810         switch(ededxSigmaCut){\r
 811 \r
 812         case 0: \r
 813                 fDodEdxSigmaITSCut = kFALSE;\r
 814                 fPIDnSigmaBelowElectronLineITS=-100;\r
 815                 fPIDnSigmaAboveElectronLineITS= 100;\r
 816                 break;\r
 817         case 1: // -10,10\r
 818                 fDodEdxSigmaITSCut = kTRUE;\r
 819                 fPIDnSigmaBelowElectronLineITS=-10;\r
 820                 fPIDnSigmaAboveElectronLineITS=10;\r
 821                 break;\r
 822         case 2: // -6,7\r
 823                 fDodEdxSigmaITSCut = kTRUE;\r
 824                 fPIDnSigmaBelowElectronLineITS=-6;\r
 825                 fPIDnSigmaAboveElectronLineITS=7;\r
 826                 break;\r
 827         case 3: // -5,5\r
 828                 fDodEdxSigmaITSCut = kTRUE;\r
 829                 fPIDnSigmaBelowElectronLineITS=-5;\r
 830                 fPIDnSigmaAboveElectronLineITS=5;\r
 831                 break;\r
 832         case 4: // -4,5\r
 833                 fDodEdxSigmaITSCut = kTRUE;\r
 834                 fPIDnSigmaBelowElectronLineITS=-4;\r
 835                 fPIDnSigmaAboveElectronLineITS=5;\r
 836                 break;\r
 837         case 5: // -3,5\r
 838                 fDodEdxSigmaITSCut = kTRUE;\r
 839                 fPIDnSigmaBelowElectronLineITS=-3;\r
 840                 fPIDnSigmaAboveElectronLineITS=5;\r
 841                 break;\r
 842         case 6: // -4,4\r
 843                 fDodEdxSigmaITSCut = kTRUE;\r
 844                 fPIDnSigmaBelowElectronLineITS=-4;\r
 845                 fPIDnSigmaAboveElectronLineITS=4;\r
 846                 break;\r
 847         case 7: // -2.5,4\r
 848                 fDodEdxSigmaITSCut = kTRUE;\r
 849                 fPIDnSigmaBelowElectronLineITS=-2.5;\r
 850                 fPIDnSigmaAboveElectronLineITS=4;\r
 851                 break;\r
 852         case 8: // -2,3.5\r
 853                 fDodEdxSigmaITSCut = kTRUE;\r
 854                 fPIDnSigmaBelowElectronLineITS=-2;\r
 855                 fPIDnSigmaAboveElectronLineITS=3.5;\r
 856                 break;\r
 857         default:\r
 858                 cout<<"Warning: ITSdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;\r
 859                 return kFALSE;\r
 860     \r
 861         }\r
 862         return kTRUE;\r
 863 }\r
 864 \r
 865 ///________________________________________________________________________\r
 866 Bool_t AliDalitzElectronCuts::SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut)\r
 867 {   // Set Cut\r
 868         switch(ededxSigmaCut){\r
 869 \r
 870         case 0: fDodEdxSigmaTPCCut = kFALSE;\r
 871                 fPIDnSigmaBelowElectronLineTPC=-10;\r
 872                 fPIDnSigmaAboveElectronLineTPC=10;\r
 873                 break;\r
 874         case 1: // -10,10\r
 875                 fDodEdxSigmaTPCCut = kTRUE;\r
 876                 fPIDnSigmaBelowElectronLineTPC=-10;\r
 877                 fPIDnSigmaAboveElectronLineTPC=10;\r
 878                 break;\r
 879         case 2: // -6,7\r
 880                 fDodEdxSigmaTPCCut = kTRUE;\r
 881                 fPIDnSigmaBelowElectronLineTPC=-6;\r
 882                 fPIDnSigmaAboveElectronLineTPC=7;\r
 883                 break;\r
 884         case 3: // -5,5\r
 885                 fDodEdxSigmaTPCCut = kTRUE;\r
 886                 fPIDnSigmaBelowElectronLineTPC=-5;\r
 887                 fPIDnSigmaAboveElectronLineTPC=5;\r
 888                 break;\r
 889         case 4: // -4,5\r
 890                 fDodEdxSigmaTPCCut = kTRUE;\r
 891                 fPIDnSigmaBelowElectronLineTPC=-4;\r
 892                 fPIDnSigmaAboveElectronLineTPC=5;\r
 893                 break;  \r
 894         case 5: // -3,5\r
 895                 fDodEdxSigmaTPCCut = kTRUE;\r
 896                 fPIDnSigmaBelowElectronLineTPC=-3;\r
 897                 fPIDnSigmaAboveElectronLineTPC=5;\r
 898                 break;\r
 899         case 6: // -4,4\r
 900                 fDodEdxSigmaTPCCut = kTRUE;\r
 901                 fPIDnSigmaBelowElectronLineTPC=-4;\r
 902                 fPIDnSigmaAboveElectronLineTPC=4;\r
 903                 break;\r
 904         case 7: // -2.5,4\r
 905                 fDodEdxSigmaTPCCut = kTRUE;\r
 906                 fPIDnSigmaBelowElectronLineTPC=-2.5;\r
 907                 fPIDnSigmaAboveElectronLineTPC=4;\r
 908                 break;\r
 909         case 8: // -2,3.5\r
 910                 fDodEdxSigmaTPCCut = kTRUE;\r
 911                 fPIDnSigmaBelowElectronLineTPC=-2;\r
 912                 fPIDnSigmaAboveElectronLineTPC=3.5;\r
 913                 break;\r
 914         default:\r
 915                 cout<<"Warning: TPCdEdxCutElectronLine not defined"<<ededxSigmaCut<<endl;\r
 916                 return kFALSE;\r
 917     \r
 918         }\r
 919         return kTRUE;\r
 920 }\r
 921 \r
 922 ///________________________________________________________________________\r
 923 Bool_t AliDalitzElectronCuts::SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut)\r
 924 {   // Set Cut\r
 925 \r
 926         switch(pidedxSigmaCut){\r
 927                 \r
 928         case 0: fPIDnSigmaAbovePionLineTPC= 0;\r
 929                 fPIDnSigmaAbovePionLineTPCHighPt=-100;\r
 930                 break;\r
 931         case 1:  // -10\r
 932                 fPIDnSigmaAbovePionLineTPC=-10;\r
 933                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
 934                 break;\r
 935         case 2:  // 1\r
 936                 fPIDnSigmaAbovePionLineTPC=-1;\r
 937                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
 938                 break;\r
 939         case 3:   // 0\r
 940                 fPIDnSigmaAbovePionLineTPC=0;\r
 941                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
 942                 break;\r
 943         case 4:  // 1\r
 944                 fPIDnSigmaAbovePionLineTPC=1;\r
 945                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
 946                 break;\r
 947         case 5:  // 1\r
 948                 fPIDnSigmaAbovePionLineTPC=2.;\r
 949                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
 950                 break;\r
 951         case 6:  // 1\r
 952                 fPIDnSigmaAbovePionLineTPC=2.5;\r
 953                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
 954                 break;\r
 955         case 7:\r
 956                 fPIDnSigmaAbovePionLineTPC=3.0; // We need a bit less tight cut on dE/dx\r
 957                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
 958                 break;\r
 959         case 8:  // 1\r
 960                 fPIDnSigmaAbovePionLineTPC=3.5;\r
 961                 fPIDnSigmaAbovePionLineTPCHighPt=-10;\r
 962                 break;\r
 963         case 9:  // 1\r
 964                 fPIDnSigmaAbovePionLineTPC=1.5;\r
 965                 fPIDnSigmaAbovePionLineTPCHighPt=-1.0;\r
 966                 break;\r
 967         default:\r
 968                 cout<<"Warning: pidedxSigmaCut not defined "<<pidedxSigmaCut<<endl;\r
 969                 return kFALSE;\r
 970         }\r
 971         return kTRUE;\r
 972 }\r
 973 \r
 974 ///________________________________________________________________________\r
 975 Bool_t AliDalitzElectronCuts::SetMinMomPiondEdxTPCCut(Int_t piMomdedxSigmaCut)\r
 976 {   // Set Cut\r
 977         switch(piMomdedxSigmaCut){\r
 978                 \r
 979         case 0: fPIDMinPnSigmaAbovePionLineTPC=0.;\r
 980                 break;\r
 981         case 1:  // 50.0 GeV\r
 982                 fPIDMinPnSigmaAbovePionLineTPC=50.;\r
 983                 break;\r
 984         case 2:  // 20.0 GeV\r
 985                 fPIDMinPnSigmaAbovePionLineTPC=20.;\r
 986                 break;\r
 987         case 3:  // 1.5 GeV\r
 988                 fPIDMinPnSigmaAbovePionLineTPC=1.5;\r
 989                 break;\r
 990         case 4:  // 1. GeV\r
 991                 fPIDMinPnSigmaAbovePionLineTPC=1.;\r
 992                 break;  \r
 993         case 5:  // 0.5 GeV\r
 994                 fPIDMinPnSigmaAbovePionLineTPC=0.5;\r
 995                 break;\r
 996         case 6:  // 0.4 GeV\r
 997                 fPIDMinPnSigmaAbovePionLineTPC=0.4;\r
 998                 break;    \r
 999         case 7:  // 0.3 GeV\r
1000                 fPIDMinPnSigmaAbovePionLineTPC=0.3;\r
1001                 break;\r
1002         case 8:  // 0.25 GeV\r
1003                 fPIDMinPnSigmaAbovePionLineTPC=0.25;\r
1004                 break;\r
1005         default:\r
1006                 cout<<"Warning: piMomdedxSigmaCut not defined "<<piMomdedxSigmaCut<<endl;\r
1007                 return kFALSE;\r
1008         }\r
1009         return kTRUE;\r
1010 }\r
1011 ///________________________________________________________________________\r
1012 Bool_t AliDalitzElectronCuts::SetITSClusterCut(Int_t clsITSCut){\r
1013 \r
1014     \r
1015         if( !fesdTrackCuts ) {\r
1016 \r
1017                 cout<<"Warning: AliESDtrackCut is not initialized "<<endl;\r
1018                 return kFALSE;\r
1019         }\r
1020 \r
1021         switch(clsITSCut){\r
1022 \r
1023         case 0: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);\r
1024                 break;\r
1025         case 1: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);\r
1026                 break;  //1 hit first layer of SPD\r
1027         case 2: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1028                 break; //1 hit in any layer of SPD\r
1029         case 3: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kFirst);\r
1030                 fesdTrackCuts->SetMinNClustersITS(4);\r
1031                 // 4 hits in total in the ITS. At least 1 hit in the first layer of SPD  \r
1032                 break;\r
1033         case 4: fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);\r
1034                 fesdTrackCuts->SetMinNClustersITS(3);\r
1035                 // 3 hits in total in the ITS. At least 1 hit in any layer of SPD\r
1036                 break;\r
1037         default:\r
1038                 cout<<"Warning: clsITSCut not defined "<<clsITSCut<<endl;\r
1039                 return kFALSE;\r
1040         }\r
1041         \r
1042 return kTRUE;\r
1043 }\r
1044 \r
1045 ///________________________________________________________________________\r
1046 Bool_t AliDalitzElectronCuts::SetTPCClusterCut(Int_t clsTPCCut)\r
1047 {   // Set Cut\r
1048         switch(clsTPCCut){\r
1049         case 0: // 0\r
1050                 fMinClsTPC= 0.;\r
1051                 break;\r
1052         case 1:  // 70\r
1053                 fMinClsTPC= 70.;\r
1054                 break;\r
1055         case 2:  // 80\r
1056                 fMinClsTPC= 80.;\r
1057                 break;\r
1058         case 3:  // 100\r
1059                 fMinClsTPC= 100.;\r
1060                 break;\r
1061         case 4:  // 0% of findable clusters\r
1062                 fMinClsTPCToF= 0.0;\r
1063                 fUseCorrectedTPCClsInfo=0;\r
1064                 break;\r
1065         case 5:  // 35% of findable clusters\r
1066                 fMinClsTPCToF= 0.35;\r
1067                 fUseCorrectedTPCClsInfo=0;\r
1068                 break;\r
1069         case 6:  // 60% of findable clusters\r
1070                 fMinClsTPCToF= 0.6;\r
1071                 fUseCorrectedTPCClsInfo=0;\r
1072                 break;\r
1073         case 7:  // 70% of findable clusters\r
1074                 fMinClsTPCToF= 0.7;\r
1075                 fUseCorrectedTPCClsInfo=0;\r
1076                 break;\r
1077         default:\r
1078                 cout<<"Warning: clsTPCCut not defined "<<clsTPCCut<<endl;\r
1079                 return kFALSE;\r
1080         }\r
1081         return kTRUE;\r
1082 }\r
1083 \r
1084 ///________________________________________________________________________\r
1085 Bool_t AliDalitzElectronCuts::SetEtaCut(Int_t etaCut)\r
1086 { \r
1087   // Set eta Cut\r
1088         switch(etaCut){\r
1089                 case 0: fEtaCut         = 100.;\r
1090                         break;\r
1091                 case 1: // 1.4\r
1092                         fEtaCut         = 1.4;\r
1093                         break;\r
1094                 case 2: // 1.2\r
1095                         fEtaCut         = 1.2;\r
1096                         break;\r
1097                 case 3: // 0.9\r
1098                         fEtaCut         = 0.9;\r
1099                         break;\r
1100                 case 4: // 0.8\r
1101                         fEtaCut         = 0.8;\r
1102                         break;\r
1103                 case 5: // 0.75\r
1104                         fEtaCut         = 0.75;\r
1105                         break;\r
1106                 default:\r
1107                         cout<<"Warning: EtaCut not defined "<<etaCut<<endl;\r
1108                         return kFALSE;\r
1109     }\r
1110     return kTRUE;\r
1111 }\r
1112 \r
1113 ///________________________________________________________________________\r
1114 Bool_t AliDalitzElectronCuts::SetMaxMomPiondEdxTPCCut(Int_t piMaxMomdedxSigmaCut)\r
1115 {   // Set Cut\r
1116    switch(piMaxMomdedxSigmaCut){\r
1117 \r
1118          case 0: \r
1119                  fPIDMaxPnSigmaAbovePionLineTPC=0.;\r
1120                  break;\r
1121          case 1:  // 100. GeV\r
1122                  fPIDMaxPnSigmaAbovePionLineTPC=100.;\r
1123                  break;\r
1124          case 2:  // 5. GeV\r
1125                  fPIDMaxPnSigmaAbovePionLineTPC=5.;\r
1126                         break;\r
1127          case 3:  // 4. GeV\r
1128                  fPIDMaxPnSigmaAbovePionLineTPC=4.;\r
1129                  break;\r
1130          case 4:  // 3.5 GeV\r
1131                  fPIDMaxPnSigmaAbovePionLineTPC=3.5;\r
1132                  break;\r
1133          case 5:  // 3. GeV\r
1134                  fPIDMaxPnSigmaAbovePionLineTPC=3.;\r
1135                  break;\r
1136          default:\r
1137                  cout<<"Warning: piMaxMomdedxSigmaCut not defined "<<piMaxMomdedxSigmaCut<<endl;\r
1138                  return kFALSE;\r
1139          }\r
1140          return kTRUE;\r
1141 }\r
1142 \r
1143 ///________________________________________________________________________\r
1144 Bool_t AliDalitzElectronCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)\r
1145 {   // Set Cut\r
1146         switch(LowPRejectionSigmaCut){\r
1147         case 0:  //\r
1148                 fDoKaonRejectionLowP=kFALSE;\r
1149                 fDoProtonRejectionLowP=kFALSE;\r
1150                 fDoPionRejectionLowP=kFALSE;\r
1151                 fPIDnSigmaAtLowPAroundKaonLine=0;\r
1152                 fPIDnSigmaAtLowPAroundProtonLine=0;\r
1153                 fPIDnSigmaAtLowPAroundPionLine=0;\r
1154                 break;\r
1155         case 1:  //\r
1156                 fDoKaonRejectionLowP=kTRUE;\r
1157                 fDoProtonRejectionLowP=kTRUE;\r
1158                 fDoPionRejectionLowP=kTRUE;\r
1159                 fPIDnSigmaAtLowPAroundKaonLine=0.5;\r
1160                 fPIDnSigmaAtLowPAroundProtonLine=0.5;\r
1161                 fPIDnSigmaAtLowPAroundPionLine=0.5;\r
1162                 break;\r
1163         case 2:  //\r
1164                 fDoKaonRejectionLowP=kTRUE;\r
1165                 fDoProtonRejectionLowP=kTRUE;\r
1166                 fDoPionRejectionLowP=kTRUE;\r
1167                 fPIDnSigmaAtLowPAroundKaonLine=1;\r
1168                 fPIDnSigmaAtLowPAroundProtonLine=1;\r
1169                 fPIDnSigmaAtLowPAroundPionLine=1;\r
1170                 break;\r
1171         case 3:  //\r
1172                 fDoKaonRejectionLowP=kTRUE;\r
1173                 fDoProtonRejectionLowP=kTRUE;\r
1174                 fDoPionRejectionLowP=kTRUE;\r
1175                 fPIDnSigmaAtLowPAroundKaonLine=1.5;\r
1176                 fPIDnSigmaAtLowPAroundProtonLine=1.5;\r
1177                 fPIDnSigmaAtLowPAroundPionLine=1.5;\r
1178                 break;\r
1179         case 4:  //\r
1180                 fDoKaonRejectionLowP=kTRUE;\r
1181                 fDoProtonRejectionLowP=kTRUE;\r
1182                 fDoPionRejectionLowP=kTRUE;\r
1183                 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1184                 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1185                 fPIDnSigmaAtLowPAroundPionLine=2.0;\r
1186                 break;\r
1187         case 5:  //\r
1188                 fDoKaonRejectionLowP=kTRUE;\r
1189                 fDoProtonRejectionLowP=kTRUE;\r
1190                 fDoPionRejectionLowP=kTRUE;\r
1191                 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1192                 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1193                 fPIDnSigmaAtLowPAroundPionLine=2.5;\r
1194                 break;\r
1195         case 6:  //\r
1196                 fDoKaonRejectionLowP=kTRUE;\r
1197                 fDoProtonRejectionLowP=kTRUE;\r
1198                 fDoPionRejectionLowP=kTRUE;\r
1199                 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1200                 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1201                 fPIDnSigmaAtLowPAroundPionLine=2.;\r
1202                 break;\r
1203         case 7: //\r
1204                 fDoKaonRejectionLowP=kFALSE;\r
1205                 fDoProtonRejectionLowP=kFALSE;\r
1206                 fDoPionRejectionLowP=kTRUE;\r
1207                 fPIDnSigmaAtLowPAroundKaonLine=0.0;\r
1208                 fPIDnSigmaAtLowPAroundProtonLine=0.0;\r
1209                 fPIDnSigmaAtLowPAroundPionLine=1.0;\r
1210                 break;\r
1211         case 8:\r
1212                 fDoKaonRejectionLowP=kFALSE;\r
1213                 fDoProtonRejectionLowP=kFALSE;\r
1214                 fDoPionRejectionLowP=kTRUE;\r
1215                 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1216                 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1217                 fPIDnSigmaAtLowPAroundPionLine=0.5; \r
1218                 break;  \r
1219         default:\r
1220                 cout<<"Warning: LowPRejectionSigmaCut not defined "<<LowPRejectionSigmaCut<<endl;\r
1221                 return kFALSE;\r
1222         }\r
1223         return kTRUE;\r
1224 }\r
1225 \r
1226 ///________________________________________________________________________\r
1227 Bool_t AliDalitzElectronCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){\r
1228     // Set Cut\r
1229         switch(TOFelectronPID){ // RRnewTOF start //////////////////////////////////////////////////////////////////////////\r
1230         case 0: // no cut\r
1231                 fRequireTOF = kFALSE;\r
1232                 fUseTOFpid = kFALSE;\r
1233                 fTofPIDnSigmaBelowElectronLine=-100;\r
1234                 fTofPIDnSigmaAboveElectronLine=100;\r
1235                 break;\r
1236         case 1: // -7,7\r
1237                 fRequireTOF = kFALSE;\r
1238                 fUseTOFpid = kTRUE;\r
1239                 fTofPIDnSigmaBelowElectronLine=-7;\r
1240                 fTofPIDnSigmaAboveElectronLine=7;\r
1241                 break;\r
1242         case 2: // -5,5\r
1243                 fRequireTOF = kFALSE;\r
1244                 fUseTOFpid = kTRUE;\r
1245                 fTofPIDnSigmaBelowElectronLine=-5;\r
1246                 fTofPIDnSigmaAboveElectronLine=5;\r
1247                 break;\r
1248         case 3: // -3,5\r
1249                 fRequireTOF = kFALSE;\r
1250                 fUseTOFpid = kTRUE;\r
1251                 fTofPIDnSigmaBelowElectronLine=-3;\r
1252                 fTofPIDnSigmaAboveElectronLine=5;\r
1253                 break;\r
1254         case 4: // -2,3\r
1255                 fRequireTOF = kFALSE;\r
1256                 fUseTOFpid = kTRUE;\r
1257                 fTofPIDnSigmaBelowElectronLine=-2;\r
1258                 fTofPIDnSigmaAboveElectronLine=3;\r
1259                 break;\r
1260         case 5: // -3, 3 TOF mandatory\r
1261                 fRequireTOF = kTRUE;\r
1262                 fUseTOFpid  = kTRUE;\r
1263                 fTofPIDnSigmaBelowElectronLine= -3;\r
1264                 fTofPIDnSigmaAboveElectronLine=  3;\r
1265                 break;\r
1266         default:\r
1267         cout<<"Warning: TOFElectronCut not defined "<<TOFelectronPID<<endl;\r
1268         return kFALSE;\r
1269     } //////////////////////// RRnewTOF end //////////////////////////////////////////////////////////////////////////\r
1270     return kTRUE;\r
1271 }\r
1272 ///_______________________________________________________________________________\r
1273 \r
1274 Bool_t AliDalitzElectronCuts::SetPsiPairCut(Int_t psiCut) {\r
1275   \r
1276 \r
1277   switch(psiCut) {\r
1278   case 0:\r
1279         fDoPsiPairCut = kFALSE;\r
1280         fPsiPairCut = 10000.; //\r
1281         fDeltaPhiCutMin = -1000.;\r
1282         fDeltaPhiCutMax =  1000.;\r
1283         \r
1284         break;\r
1285   case 1:\r
1286         fDoPsiPairCut = kTRUE;\r
1287         fPsiPairCut = 0.45; // Standard\r
1288         fDeltaPhiCutMin = 0.;\r
1289         fDeltaPhiCutMax = 0.12;\r
1290         break;\r
1291   default:\r
1292       cout<<"Warning: PsiPairCut not defined "<<fPsiPairCut<<endl;\r
1293       return kFALSE;\r
1294   }\r
1295 \r
1296   return kTRUE;\r
1297 }\r
1298 \r
1299 ///_______________________________________________________________________________\r
1300 Bool_t AliDalitzElectronCuts::SetRejectSharedElecGamma(Int_t RCut) {\r
1301   \r
1302 \r
1303   switch(RCut) {\r
1304   case 0:\r
1305         fDoRejectSharedElecGamma = kFALSE;\r
1306         fRadiusCut = 10000; // \r
1307         break;\r
1308   case 1:\r
1309         fDoRejectSharedElecGamma = kTRUE;\r
1310         fRadiusCut = 2.0; // cm \r
1311         break;\r
1312   case 2:\r
1313         fDoRejectSharedElecGamma = kTRUE;\r
1314         fRadiusCut = 3.0; // Standard\r
1315         break;\r
1316   case 3:\r
1317         fDoRejectSharedElecGamma = kTRUE;\r
1318         fRadiusCut = 4.0; // \r
1319         break;\r
1320   case 4:\r
1321         fDoRejectSharedElecGamma = kTRUE;\r
1322         fRadiusCut = 5.0; // \r
1323         break;\r
1324   case 5:\r
1325         fDoRejectSharedElecGamma = kTRUE;\r
1326         fRadiusCut = 10.0; // \r
1327         break;\r
1328   case 6:\r
1329         fDoRejectSharedElecGamma = kTRUE;\r
1330         fRadiusCut = 15.0; // \r
1331         break;\r
1332   default:\r
1333       cout<<"Warning: PsiPairCut not defined "<<fDoRejectSharedElecGamma<<endl;\r
1334       return kFALSE;\r
1335   }\r
1336 \r
1337   return kTRUE;\r
1338 }\r
1339 ///__________________________________________________________________________\r
1340 Bool_t AliDalitzElectronCuts::SetBackgroundScheme(Int_t BackgroundScheme){\r
1341 \r
1342     // Set Cut\r
1343     switch(BackgroundScheme){\r
1344 \r
1345     case 0: //Rotation\r
1346             fBKGMethod = 0;\r
1347             fUseTrackMultiplicityForBG = kFALSE;\r
1348         break;\r
1349     case 1: // mixed event with V0 multiplicity\r
1350             fBKGMethod  = 1;\r
1351             fUseTrackMultiplicityForBG = kFALSE;\r
1352         break;\r
1353     case 2: // mixed event with track multiplicity\r
1354             fUseTrackMultiplicityForBG = kTRUE;\r
1355             fBKGMethod  = 1;\r
1356         break;\r
1357     case 3: //Rotation\r
1358            fUseTrackMultiplicityForBG = kFALSE;\r
1359             fBKGMethod  = 2;\r
1360         break;\r
1361     case 4: //Rotation\r
1362             fUseTrackMultiplicityForBG = kTRUE;\r
1363             fBKGMethod  = 2;\r
1364         break;\r
1365     case 5: fUseTrackMultiplicityForBG = kTRUE;\r
1366             fBKGMethod  = 3;\r
1367         break;\r
1368 \r
1369     default:\r
1370         cout<<"Warning: BackgroundScheme not defined "<<BackgroundScheme<<endl;\r
1371         return kFALSE;\r
1372     }\r
1373     return kTRUE;\r
1374 }\r
1375 \r
1376 ///________________________________________________________________________\r
1377 Bool_t AliDalitzElectronCuts::SetNumberOfRotations(Int_t NumberOfRotations)\r
1378 {   // Set Cut\r
1379     switch(NumberOfRotations){\r
1380     case 0:\r
1381         fnumberOfRotationEventsForBG = 5;\r
1382         break;\r
1383     case 1:\r
1384         fnumberOfRotationEventsForBG = 10;\r
1385         break;\r
1386     case 2:\r
1387         fnumberOfRotationEventsForBG = 15;\r
1388         break;\r
1389     case 3:\r
1390         fnumberOfRotationEventsForBG = 20;\r
1391         break;\r
1392     case 4:\r
1393         fnumberOfRotationEventsForBG = 2;\r
1394         break;\r
1395     case 5:\r
1396         fnumberOfRotationEventsForBG = 50;\r
1397         break;\r
1398     case 6:\r
1399         fnumberOfRotationEventsForBG = 80;\r
1400         break;\r
1401     case 7:\r
1402         fnumberOfRotationEventsForBG = 100;\r
1403         break;\r
1404     default:\r
1405         cout<<"Warning: NumberOfRotations not defined "<<NumberOfRotations<<endl;\r
1406         return kFALSE;\r
1407     }\r
1408     return kTRUE;\r
1409 }\r
1410 ///________________________________________________________________________\r
1411 TString AliDalitzElectronCuts::GetCutNumber(){\r
1412     // returns TString with current cut number\r
1413   TString a(kNCuts);\r
1414   for(Int_t ii=0;ii<kNCuts;ii++){\r
1415         a.Append(Form("%d",fCuts[ii]));\r
1416   }\r
1417   return a;\r
1418 }\r
1419 \r
1420 \r
1421 ///________________________________________________________________________\r
1422 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010PbPb(){\r
1423     //Create and return standard 2010 PbPb cuts\r
1424     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");\r
1425     if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1426         cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}\r
1427     return cuts;\r
1428 }\r
1429 \r
1430 ///________________________________________________________________________\r
1431 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010pp(){\r
1432     //Create and return standard 2010 PbPb cuts\r
1433     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010pp","StandardCuts2010pp");\r
1434                                           \r
1435     if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1436         cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}\r
1437      return cuts;\r
1438 }\r
1439 \r