PWGGA/GammaConv/AliDalitzElectronCuts.cxx

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