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: \r
1090                 fEtaCut = 100.;\r
1091                 break;\r
1092         case 1: // 1.4\r
1093                 fEtaCut = 1.4;\r
1094                 break;\r
1095         case 2: // 1.2\r
1096                 fEtaCut = 1.2;\r
1097                 break;\r
1098         case 3: // 0.9\r
1099                 fEtaCut = 0.9;\r
1100                 break;\r
1101         case 4: // 0.8\r
1102                 fEtaCut = 0.8;\r
1103                 break;\r
1104         case 5: // 0.75\r
1105                 fEtaCut = 0.75;\r
1106                 break;\r
1107         default:\r
1108                 cout<<"Warning: EtaCut not defined "<<etaCut<<endl;\r
1109                 return kFALSE;\r
1110         }\r
1111         return kTRUE;\r
1112 }\r
1113 \r
1114 ///________________________________________________________________________\r
1115 Bool_t AliDalitzElectronCuts::SetMaxMomPiondEdxTPCCut(Int_t piMaxMomdedxSigmaCut)\r
1116 {   // Set Cut\r
1117    switch(piMaxMomdedxSigmaCut){\r
1118 \r
1119          case 0: \r
1120                  fPIDMaxPnSigmaAbovePionLineTPC=0.;\r
1121                  break;\r
1122          case 1:  // 100. GeV\r
1123                  fPIDMaxPnSigmaAbovePionLineTPC=100.;\r
1124                  break;\r
1125          case 2:  // 5. GeV\r
1126                  fPIDMaxPnSigmaAbovePionLineTPC=5.;\r
1127                         break;\r
1128          case 3:  // 4. GeV\r
1129                  fPIDMaxPnSigmaAbovePionLineTPC=4.;\r
1130                  break;\r
1131          case 4:  // 3.5 GeV\r
1132                  fPIDMaxPnSigmaAbovePionLineTPC=3.5;\r
1133                  break;\r
1134          case 5:  // 3. GeV\r
1135                  fPIDMaxPnSigmaAbovePionLineTPC=3.;\r
1136                  break;\r
1137          default:\r
1138                  cout<<"Warning: piMaxMomdedxSigmaCut not defined "<<piMaxMomdedxSigmaCut<<endl;\r
1139                  return kFALSE;\r
1140          }\r
1141          return kTRUE;\r
1142 }\r
1143 \r
1144 ///________________________________________________________________________\r
1145 Bool_t AliDalitzElectronCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)\r
1146 {   // Set Cut\r
1147         switch(LowPRejectionSigmaCut){\r
1148         case 0:  //\r
1149                 fDoKaonRejectionLowP=kFALSE;\r
1150                 fDoProtonRejectionLowP=kFALSE;\r
1151                 fDoPionRejectionLowP=kFALSE;\r
1152                 fPIDnSigmaAtLowPAroundKaonLine=0;\r
1153                 fPIDnSigmaAtLowPAroundProtonLine=0;\r
1154                 fPIDnSigmaAtLowPAroundPionLine=0;\r
1155                 break;\r
1156         case 1:  //\r
1157                 fDoKaonRejectionLowP=kTRUE;\r
1158                 fDoProtonRejectionLowP=kTRUE;\r
1159                 fDoPionRejectionLowP=kTRUE;\r
1160                 fPIDnSigmaAtLowPAroundKaonLine=0.5;\r
1161                 fPIDnSigmaAtLowPAroundProtonLine=0.5;\r
1162                 fPIDnSigmaAtLowPAroundPionLine=0.5;\r
1163                 break;\r
1164         case 2:  //\r
1165                 fDoKaonRejectionLowP=kTRUE;\r
1166                 fDoProtonRejectionLowP=kTRUE;\r
1167                 fDoPionRejectionLowP=kTRUE;\r
1168                 fPIDnSigmaAtLowPAroundKaonLine=1;\r
1169                 fPIDnSigmaAtLowPAroundProtonLine=1;\r
1170                 fPIDnSigmaAtLowPAroundPionLine=1;\r
1171                 break;\r
1172         case 3:  //\r
1173                 fDoKaonRejectionLowP=kTRUE;\r
1174                 fDoProtonRejectionLowP=kTRUE;\r
1175                 fDoPionRejectionLowP=kTRUE;\r
1176                 fPIDnSigmaAtLowPAroundKaonLine=1.5;\r
1177                 fPIDnSigmaAtLowPAroundProtonLine=1.5;\r
1178                 fPIDnSigmaAtLowPAroundPionLine=1.5;\r
1179                 break;\r
1180         case 4:  //\r
1181                 fDoKaonRejectionLowP=kTRUE;\r
1182                 fDoProtonRejectionLowP=kTRUE;\r
1183                 fDoPionRejectionLowP=kTRUE;\r
1184                 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1185                 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1186                 fPIDnSigmaAtLowPAroundPionLine=2.0;\r
1187                 break;\r
1188         case 5:  //\r
1189                 fDoKaonRejectionLowP=kTRUE;\r
1190                 fDoProtonRejectionLowP=kTRUE;\r
1191                 fDoPionRejectionLowP=kTRUE;\r
1192                 fPIDnSigmaAtLowPAroundKaonLine=2.0;\r
1193                 fPIDnSigmaAtLowPAroundProtonLine=2.0;\r
1194                 fPIDnSigmaAtLowPAroundPionLine=2.5;\r
1195                 break;\r
1196         case 6:  //\r
1197                 fDoKaonRejectionLowP=kTRUE;\r
1198                 fDoProtonRejectionLowP=kTRUE;\r
1199                 fDoPionRejectionLowP=kTRUE;\r
1200                 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1201                 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1202                 fPIDnSigmaAtLowPAroundPionLine=2.;\r
1203                 break;\r
1204         case 7: //\r
1205                 fDoKaonRejectionLowP=kFALSE;\r
1206                 fDoProtonRejectionLowP=kFALSE;\r
1207                 fDoPionRejectionLowP=kTRUE;\r
1208                 fPIDnSigmaAtLowPAroundKaonLine=0.0;\r
1209                 fPIDnSigmaAtLowPAroundProtonLine=0.0;\r
1210                 fPIDnSigmaAtLowPAroundPionLine=1.0;\r
1211                 break;\r
1212         case 8:\r
1213                 fDoKaonRejectionLowP=kFALSE;\r
1214                 fDoProtonRejectionLowP=kFALSE;\r
1215                 fDoPionRejectionLowP=kTRUE;\r
1216                 fPIDnSigmaAtLowPAroundKaonLine=0.;\r
1217                 fPIDnSigmaAtLowPAroundProtonLine=0.;\r
1218                 fPIDnSigmaAtLowPAroundPionLine=0.5; \r
1219                 break;  \r
1220         default:\r
1221                 cout<<"Warning: LowPRejectionSigmaCut not defined "<<LowPRejectionSigmaCut<<endl;\r
1222                 return kFALSE;\r
1223         }\r
1224         return kTRUE;\r
1225 }\r
1226 \r
1227 ///________________________________________________________________________\r
1228 Bool_t AliDalitzElectronCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){\r
1229     // Set Cut\r
1230         switch(TOFelectronPID){ // RRnewTOF start //////////////////////////////////////////////////////////////////////////\r
1231         case 0: // no cut\r
1232                 fRequireTOF = kFALSE;\r
1233                 fUseTOFpid = kFALSE;\r
1234                 fTofPIDnSigmaBelowElectronLine=-100;\r
1235                 fTofPIDnSigmaAboveElectronLine=100;\r
1236                 break;\r
1237         case 1: // -7,7\r
1238                 fRequireTOF = kFALSE;\r
1239                 fUseTOFpid = kTRUE;\r
1240                 fTofPIDnSigmaBelowElectronLine=-7;\r
1241                 fTofPIDnSigmaAboveElectronLine=7;\r
1242                 break;\r
1243         case 2: // -5,5\r
1244                 fRequireTOF = kFALSE;\r
1245                 fUseTOFpid = kTRUE;\r
1246                 fTofPIDnSigmaBelowElectronLine=-5;\r
1247                 fTofPIDnSigmaAboveElectronLine=5;\r
1248                 break;\r
1249         case 3: // -3,5\r
1250                 fRequireTOF = kFALSE;\r
1251                 fUseTOFpid = kTRUE;\r
1252                 fTofPIDnSigmaBelowElectronLine=-3;\r
1253                 fTofPIDnSigmaAboveElectronLine=5;\r
1254                 break;\r
1255         case 4: // -2,3\r
1256                 fRequireTOF = kFALSE;\r
1257                 fUseTOFpid = kTRUE;\r
1258                 fTofPIDnSigmaBelowElectronLine=-2;\r
1259                 fTofPIDnSigmaAboveElectronLine=3;\r
1260                 break;\r
1261         case 5: // -3, 3 TOF mandatory\r
1262                 fRequireTOF = kTRUE;\r
1263                 fUseTOFpid  = kTRUE;\r
1264                 fTofPIDnSigmaBelowElectronLine= -3;\r
1265                 fTofPIDnSigmaAboveElectronLine=  3;\r
1266                 break;\r
1267         default:\r
1268         cout<<"Warning: TOFElectronCut not defined "<<TOFelectronPID<<endl;\r
1269         return kFALSE;\r
1270     } //////////////////////// RRnewTOF end //////////////////////////////////////////////////////////////////////////\r
1271     return kTRUE;\r
1272 }\r
1273 ///_______________________________________________________________________________\r
1274 \r
1275 Bool_t AliDalitzElectronCuts::SetPsiPairCut(Int_t psiCut) {\r
1276   \r
1277 \r
1278   switch(psiCut) {\r
1279   case 0:\r
1280         fDoPsiPairCut = kFALSE;\r
1281         fPsiPairCut = 10000.; //\r
1282         fDeltaPhiCutMin = -1000.;\r
1283         fDeltaPhiCutMax =  1000.;\r
1284         \r
1285         break;\r
1286   case 1:\r
1287         fDoPsiPairCut = kTRUE;\r
1288         fPsiPairCut = 0.45; // Standard\r
1289         fDeltaPhiCutMin = 0.;\r
1290         fDeltaPhiCutMax = 0.12;\r
1291         break;\r
1292   default:\r
1293       cout<<"Warning: PsiPairCut not defined "<<fPsiPairCut<<endl;\r
1294       return kFALSE;\r
1295   }\r
1296 \r
1297   return kTRUE;\r
1298 }\r
1299 \r
1300 ///_______________________________________________________________________________\r
1301 Bool_t AliDalitzElectronCuts::SetRejectSharedElecGamma(Int_t RCut) {\r
1302   \r
1303 \r
1304   switch(RCut) {\r
1305   case 0:\r
1306         fDoRejectSharedElecGamma = kFALSE;\r
1307         fRadiusCut = 10000; // \r
1308         break;\r
1309   case 1:\r
1310         fDoRejectSharedElecGamma = kTRUE;\r
1311         fRadiusCut = 2.0; // cm \r
1312         break;\r
1313   case 2:\r
1314         fDoRejectSharedElecGamma = kTRUE;\r
1315         fRadiusCut = 3.0; // Standard\r
1316         break;\r
1317   case 3:\r
1318         fDoRejectSharedElecGamma = kTRUE;\r
1319         fRadiusCut = 4.0; // \r
1320         break;\r
1321   case 4:\r
1322         fDoRejectSharedElecGamma = kTRUE;\r
1323         fRadiusCut = 5.0; // \r
1324         break;\r
1325   case 5:\r
1326         fDoRejectSharedElecGamma = kTRUE;\r
1327         fRadiusCut = 10.0; // \r
1328         break;\r
1329   case 6:\r
1330         fDoRejectSharedElecGamma = kTRUE;\r
1331         fRadiusCut = 15.0; // \r
1332         break;\r
1333   default:\r
1334       cout<<"Warning: PsiPairCut not defined "<<fDoRejectSharedElecGamma<<endl;\r
1335       return kFALSE;\r
1336   }\r
1337 \r
1338   return kTRUE;\r
1339 }\r
1340 ///__________________________________________________________________________\r
1341 Bool_t AliDalitzElectronCuts::SetBackgroundScheme(Int_t BackgroundScheme){\r
1342 \r
1343     // Set Cut\r
1344     switch(BackgroundScheme){\r
1345 \r
1346     case 0: //Rotation\r
1347             fBKGMethod = 0;\r
1348             fUseTrackMultiplicityForBG = kFALSE;\r
1349         break;\r
1350     case 1: // mixed event with V0 multiplicity\r
1351             fBKGMethod  = 1;\r
1352             fUseTrackMultiplicityForBG = kFALSE;\r
1353         break;\r
1354     case 2: // mixed event with track multiplicity\r
1355             fUseTrackMultiplicityForBG = kTRUE;\r
1356             fBKGMethod  = 1;\r
1357         break;\r
1358     case 3: //Rotation\r
1359            fUseTrackMultiplicityForBG = kFALSE;\r
1360             fBKGMethod  = 2;\r
1361         break;\r
1362     case 4: //Rotation\r
1363             fUseTrackMultiplicityForBG = kTRUE;\r
1364             fBKGMethod  = 2;\r
1365         break;\r
1366     case 5: fUseTrackMultiplicityForBG = kTRUE;\r
1367             fBKGMethod  = 3;\r
1368         break;\r
1369 \r
1370     default:\r
1371         cout<<"Warning: BackgroundScheme not defined "<<BackgroundScheme<<endl;\r
1372         return kFALSE;\r
1373     }\r
1374     return kTRUE;\r
1375 }\r
1376 \r
1377 ///________________________________________________________________________\r
1378 Bool_t AliDalitzElectronCuts::SetNumberOfRotations(Int_t NumberOfRotations)\r
1379 {   // Set Cut\r
1380     switch(NumberOfRotations){\r
1381     case 0:\r
1382         fnumberOfRotationEventsForBG = 5;\r
1383         break;\r
1384     case 1:\r
1385         fnumberOfRotationEventsForBG = 10;\r
1386         break;\r
1387     case 2:\r
1388         fnumberOfRotationEventsForBG = 15;\r
1389         break;\r
1390     case 3:\r
1391         fnumberOfRotationEventsForBG = 20;\r
1392         break;\r
1393     case 4:\r
1394         fnumberOfRotationEventsForBG = 2;\r
1395         break;\r
1396     case 5:\r
1397         fnumberOfRotationEventsForBG = 50;\r
1398         break;\r
1399     case 6:\r
1400         fnumberOfRotationEventsForBG = 80;\r
1401         break;\r
1402     case 7:\r
1403         fnumberOfRotationEventsForBG = 100;\r
1404         break;\r
1405     default:\r
1406         cout<<"Warning: NumberOfRotations not defined "<<NumberOfRotations<<endl;\r
1407         return kFALSE;\r
1408     }\r
1409     return kTRUE;\r
1410 }\r
1411 ///________________________________________________________________________\r
1412 TString AliDalitzElectronCuts::GetCutNumber(){\r
1413     // returns TString with current cut number\r
1414   TString a(kNCuts);\r
1415   for(Int_t ii=0;ii<kNCuts;ii++){\r
1416         a.Append(Form("%d",fCuts[ii]));\r
1417   }\r
1418   return a;\r
1419 }\r
1420 \r
1421 \r
1422 ///________________________________________________________________________\r
1423 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010PbPb(){\r
1424     //Create and return standard 2010 PbPb cuts\r
1425     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");\r
1426     if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1427         cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}\r
1428     return cuts;\r
1429 }\r
1430 \r
1431 ///________________________________________________________________________\r
1432 AliDalitzElectronCuts* AliDalitzElectronCuts::GetStandardCuts2010pp(){\r
1433     //Create and return standard 2010 PbPb cuts\r
1434     AliDalitzElectronCuts *cuts=new AliDalitzElectronCuts("StandardCuts2010pp","StandardCuts2010pp");\r
1435                                           \r
1436     if(!cuts->InitializeCutsFromCutString("9069640364102")){\r
1437         cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}\r
1438      return cuts;\r
1439 }\r
1440 \r