PWGGA/GammaConv/AliConversionPhotonCuts.cxx

   1 /****************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.   *
   3  *                                                                                                                                                      *
   4  * Authors: Friederike Bock                                                                                                     *
   5  * Version 1.0                                                                                                                          *
   6  *                                                                                                                                                      *
   7  * Permission to use, copy, modify and distribute this software and its         *
   8  * documentation strictly for non-commercial purposes is hereby granted         *
   9  * without fee, provided that the above copyright notice appears in all         *
  10  * copies and that both the copyright notice and this permission notice         *
  11  * appear in the supporting documentation. The authors make no claims           *
  12  * about the suitability of this software for any purpose. It is                        *
  13  * provided "as is" without express or implied warranty.                                        *
  14  ***************************************************************************/
  15
  16 ////////////////////////////////////////////////
  17 //---------------------------------------------
  18 // Class handling photon selection cuts for
  19 // Gamma Conversion analysis
  20 //---------------------------------------------
  21 ////////////////////////////////////////////////
  22
  23 #include "AliConversionPhotonCuts.h"
  24
  25 #include "AliKFVertex.h"
  26 #include "AliAODTrack.h"
  27 #include "AliESDtrack.h"
  28 #include "AliAnalysisManager.h"
  29 #include "AliInputEventHandler.h"
  30 #include "AliMCEventHandler.h"
  31 #include "AliAODHandler.h"
  32 #include "AliPIDResponse.h"
  33 #include "TH1.h"
  34 #include "TH2.h"
  35 #include "TF1.h"
  36 #include "AliStack.h"
  37 #include "AliAODConversionMother.h"
  38 #include "TObjString.h"
  39 #include "AliAODEvent.h"
  40 #include "AliESDEvent.h"
  41 #include "AliCentrality.h"
  42 #include "TList.h"
  43 #include "TFile.h"
  44 #include "AliLog.h"
  45 #include "AliGenCocktailEventHeader.h"
  46 #include "AliGenDPMjetEventHeader.h"
  47 #include "AliGenPythiaEventHeader.h"
  48 #include "AliGenHijingEventHeader.h"
  49 #include "AliTriggerAnalysis.h"
  50 #include "AliV0ReaderV1.h"
  51 #include "AliAODMCParticle.h"
  52 #include "AliAODMCHeader.h"
  53 #include "AliTRDTriggerAnalysis.h"
  54
  55 class iostream;
  56
  57 using namespace std;
  58
  59 ClassImp(AliConversionPhotonCuts)
  60
  61
  62 const char* AliConversionPhotonCuts::fgkCutNames[AliConversionPhotonCuts::kNCuts] = {
  63         "V0FinderType",                         // 0
  64         "EtaCut",                                       // 1
  65         "MinRCut",                                      // 2
  66         "EtaForPhiCut",                         // 3
  67         "MinPhiCut",                            // 4
  68         "MaxPhiCut",                            // 5
  69         "SinglePtCut",                          // 3
  70         "ClsTPCCut",                            // 4
  71         "ededxSigmaCut",                        // 5
  72         "pidedxSigmaCut",                       // 6
  73         "piMomdedxSigmaCut",            // 7
  74         "piMaxMomdedxSigmaCut",         // 8
  75         "LowPRejectionSigmaCut",        // 9
  76         "TOFelectronPID",                       // 10
  77         "QtMaxCut",                                     // 11
  78         "Chi2GammaCut",                         // 12
  79         "PsiPair",                                      // 13
  80         "DoPhotonAsymmetryCut",         // 14
  81         "CosinePointingAngle",          // 15
  82         "SharedElectronCuts",           // 16
  83         "RejectToCloseV0s",             // 17
  84         "DcaRPrimVtx",                          // 18
  85         "DcaZPrimVtx",                          // 19
  86         "EvetPlane"                             // 20
  87 };
  88
  89
  90 //________________________________________________________________________
  91 AliConversionPhotonCuts::AliConversionPhotonCuts(const char *name,const char *title) :
  92         AliAnalysisCuts(name,title),
  93         fHistograms(NULL),
  94         fPIDResponse(NULL),
  95         fMaxR(200),
  96         fMinR(0),
  97         fEtaCut(0.9),
  98         fEtaCutMin(-0.1),
  99         fEtaForPhiCutMin(-10.),
 100         fEtaForPhiCutMax(10.),
 101         fMinPhiCut(0.),
 102         fMaxPhiCut(100.),
 103         fDoShrinkTPCAcceptance(kFALSE),
 104         fPtCut(0.02),
 105         fSinglePtCut(0),
 106         fMaxZ(1000),
 107         fMinClsTPC(0.),
 108         fMinClsTPCToF(0.),
 109         fLineCutZRSlope(0.),
 110         fLineCutZValue(0),
 111         fLineCutZRSlopeMin(0.),
 112         fLineCutZValueMin(0),
 113         fChi2CutConversion(1000),
 114         fPIDProbabilityCutNegativeParticle(0),
 115         fPIDProbabilityCutPositiveParticle(0),
 116         fDodEdxSigmaCut(kTRUE),
 117         fDoTOFsigmaCut(kFALSE),
 118         fPIDTRDEfficiency(1),
 119         fDoTRDPID(kFALSE),
 120         fPIDnSigmaAboveElectronLine(100),
 121         fPIDnSigmaBelowElectronLine(-100),
 122         fTofPIDnSigmaAboveElectronLine(100),
 123         fTofPIDnSigmaBelowElectronLine(-100),
 124         fPIDnSigmaAbovePionLine(0),
 125         fPIDnSigmaAbovePionLineHighPt(-100),
 126         fPIDMinPnSigmaAbovePionLine(0),
 127         fPIDMaxPnSigmaAbovePionLine(0),
 128         fDoKaonRejectionLowP(kFALSE),
 129         fDoProtonRejectionLowP(kFALSE),
 130         fDoPionRejectionLowP(kFALSE),
 131         fPIDnSigmaAtLowPAroundKaonLine(0),
 132         fPIDnSigmaAtLowPAroundProtonLine(0),
 133         fPIDnSigmaAtLowPAroundPionLine(0),
 134         fPIDMinPKaonRejectionLowP(1.5),
 135         fPIDMinPProtonRejectionLowP(2),
 136         fPIDMinPPionRejectionLowP(0),
 137         fDoQtGammaSelection(kTRUE),
 138         fDo2DQt(kFALSE),
 139         fQtMax(100),
 140         fNSigmaMass(0.),
 141         fUseEtaMinCut(kFALSE),
 142         fUseOnFlyV0Finder(kTRUE),
 143         fDoPhotonAsymmetryCut(kTRUE),
 144         fMinPPhotonAsymmetryCut(100.),
 145         fMinPhotonAsymmetry(0.),
 146         fUseCorrectedTPCClsInfo(kFALSE),
 147         fUseTOFpid(kFALSE),
 148         fOpeningAngle(0.005),
 149         fPsiPairCut(10000),
 150         fDo2DPsiPairChi2(kFALSE),
 151         fCosPAngleCut(10000),
 152         fDoToCloseV0sCut(kFALSE),
 153         fminV0Dist(200.),
 154         fDoSharedElecCut(kFALSE),
 155         fDoPhotonQualitySelectionCut(kFALSE),
 156         fPhotonQualityCut(0),
 157         fRandom(0),
 158         fElectronArraySize(500),
 159         fElectronLabelArray(NULL),
 160         fDCAZPrimVtxCut(1000),
 161         fDCARPrimVtxCut(1000),
 162         fInPlaneOutOfPlane(0),
 163         fConversionPointXArray(0.0),
 164         fConversionPointYArray(0.0),
 165         fConversionPointZArray(0.0),
 166         fCutString(NULL),
 167         fIsHeavyIon(0),
 168         hEtaDistV0s(NULL),
 169         hEtaDistV0sAfterdEdxCuts(NULL),
 170         hdEdxCuts(NULL),
 171         hTPCdEdxbefore(NULL),
 172         hTPCdEdxafter(NULL),
 173         hTPCdEdxSigbefore(NULL),
 174         hTPCdEdxSigafter(NULL),
 175         hTOFbefore(NULL),
 176         hTOFSigbefore(NULL),
 177         hTOFSigafter(NULL),
 178         hPsiPairDeltaPhiafter(NULL),
 179         hTrackCuts(NULL),
 180         hPhotonCuts(NULL),
 181         hInvMassbefore(NULL),
 182         hArmenterosbefore(NULL),
 183         hInvMassafter(NULL),
 184         hArmenterosafter(NULL),
 185         hAcceptanceCuts(NULL),
 186         hCutIndex(NULL),
 187         hEventPlanePhi(NULL),
 188         fPreSelCut(kFALSE)
 189 {
 190         InitPIDResponse();
 191         for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=0;}
 192         fCutString=new TObjString((GetCutNumber()).Data());
 193
 194         fElectronLabelArray = new Int_t[fElectronArraySize];
 195 }
 196
 197 //________________________________________________________________________
 198 AliConversionPhotonCuts::AliConversionPhotonCuts(const AliConversionPhotonCuts &ref) :
 199         AliAnalysisCuts(ref),
 200         fHistograms(NULL),
 201         fPIDResponse(NULL),
 202         fMaxR(ref.fMaxR),
 203         fMinR(ref.fMinR),
 204         fEtaCut(ref.fEtaCut),
 205         fEtaCutMin(ref.fEtaCutMin),
 206         fEtaForPhiCutMin(ref.fEtaForPhiCutMin),
 207         fEtaForPhiCutMax(ref.fEtaForPhiCutMax),
 208         fMinPhiCut(ref.fMinPhiCut),
 209         fMaxPhiCut(ref.fMaxPhiCut),
 210         fDoShrinkTPCAcceptance(ref.fDoShrinkTPCAcceptance),
 211         fPtCut(ref.fPtCut),
 212         fSinglePtCut(ref.fSinglePtCut),
 213         fMaxZ(ref.fMaxZ),
 214         fMinClsTPC(ref.fMinClsTPC),
 215         fMinClsTPCToF(ref.fMinClsTPCToF),
 216         fLineCutZRSlope(ref.fLineCutZRSlope),
 217         fLineCutZValue(ref.fLineCutZValue),
 218         fLineCutZRSlopeMin(ref.fLineCutZRSlopeMin),
 219         fLineCutZValueMin(ref.fLineCutZValueMin),
 220         fChi2CutConversion(ref.fChi2CutConversion),
 221         fPIDProbabilityCutNegativeParticle(ref.fPIDProbabilityCutNegativeParticle),
 222         fPIDProbabilityCutPositiveParticle(ref.fPIDProbabilityCutPositiveParticle),
 223         fDodEdxSigmaCut(ref. fDodEdxSigmaCut),
 224         fDoTOFsigmaCut(ref.fDoTOFsigmaCut),
 225         fPIDTRDEfficiency(ref.fPIDTRDEfficiency),
 226         fDoTRDPID(ref.fDoTRDPID),
 227         fPIDnSigmaAboveElectronLine(ref.fPIDnSigmaAboveElectronLine),
 228         fPIDnSigmaBelowElectronLine(ref.fPIDnSigmaBelowElectronLine),
 229         fTofPIDnSigmaAboveElectronLine(ref.fTofPIDnSigmaAboveElectronLine),
 230         fTofPIDnSigmaBelowElectronLine(ref.fTofPIDnSigmaBelowElectronLine),
 231         fPIDnSigmaAbovePionLine(ref.fPIDnSigmaAbovePionLine),
 232         fPIDnSigmaAbovePionLineHighPt(ref.fPIDnSigmaAbovePionLineHighPt),
 233         fPIDMinPnSigmaAbovePionLine(ref.fPIDMinPnSigmaAbovePionLine),
 234         fPIDMaxPnSigmaAbovePionLine(ref.fPIDMaxPnSigmaAbovePionLine),
 235         fDoKaonRejectionLowP(ref.fDoKaonRejectionLowP),
 236         fDoProtonRejectionLowP(ref.fDoProtonRejectionLowP),
 237         fDoPionRejectionLowP(ref.fDoPionRejectionLowP),
 238         fPIDnSigmaAtLowPAroundKaonLine(ref.fPIDnSigmaAtLowPAroundKaonLine),
 239         fPIDnSigmaAtLowPAroundProtonLine(ref.fPIDnSigmaAtLowPAroundProtonLine),
 240         fPIDnSigmaAtLowPAroundPionLine(ref.fPIDnSigmaAtLowPAroundPionLine),
 241         fPIDMinPKaonRejectionLowP(ref.fPIDMinPKaonRejectionLowP),
 242         fPIDMinPProtonRejectionLowP(ref.fPIDMinPProtonRejectionLowP),
 243         fPIDMinPPionRejectionLowP(ref.fPIDMinPPionRejectionLowP),
 244         fDoQtGammaSelection(ref.fDoQtGammaSelection),
 245         fDo2DQt(ref.fDo2DQt),
 246         fQtMax(ref.fQtMax),
 247         fNSigmaMass(ref.fNSigmaMass),
 248         fUseEtaMinCut(ref.fUseEtaMinCut),
 249         fUseOnFlyV0Finder(ref.fUseOnFlyV0Finder),
 250         fDoPhotonAsymmetryCut(ref.fDoPhotonAsymmetryCut),
 251         fMinPPhotonAsymmetryCut(ref.fMinPPhotonAsymmetryCut),
 252         fMinPhotonAsymmetry(ref.fMinPhotonAsymmetry),
 253         fUseCorrectedTPCClsInfo(ref.fUseCorrectedTPCClsInfo),
 254         fUseTOFpid(ref.fUseTOFpid),
 255         fOpeningAngle(ref.fOpeningAngle),
 256         fPsiPairCut(ref.fPsiPairCut),
 257         fDo2DPsiPairChi2(ref.fDo2DPsiPairChi2),
 258         fCosPAngleCut(ref.fCosPAngleCut),
 259         fDoToCloseV0sCut(ref.fDoToCloseV0sCut),
 260         fminV0Dist(ref.fminV0Dist),
 261         fDoSharedElecCut(ref.fDoSharedElecCut),
 262         fDoPhotonQualitySelectionCut(ref.fDoPhotonQualitySelectionCut),
 263         fPhotonQualityCut(ref.fPhotonQualityCut),
 264         fRandom(ref.fRandom),
 265         fElectronArraySize(ref.fElectronArraySize),
 266         fElectronLabelArray(NULL),
 267         fDCAZPrimVtxCut(ref.fDCAZPrimVtxCut),
 268         fDCARPrimVtxCut(ref.fDCAZPrimVtxCut),
 269         fInPlaneOutOfPlane(ref.fInPlaneOutOfPlane),
 270         fConversionPointXArray(ref.fConversionPointXArray),
 271         fConversionPointYArray(ref.fConversionPointYArray),
 272         fConversionPointZArray(ref.fConversionPointZArray),
 273         fCutString(NULL),
 274         fIsHeavyIon(ref.fIsHeavyIon),
 275         hEtaDistV0s(NULL),
 276         hEtaDistV0sAfterdEdxCuts(NULL),
 277         hdEdxCuts(NULL),
 278         hTPCdEdxbefore(NULL),
 279         hTPCdEdxafter(NULL),
 280         hTPCdEdxSigbefore(NULL),
 281         hTPCdEdxSigafter(NULL),
 282         hTOFbefore(NULL),
 283         hTOFSigbefore(NULL),
 284         hTOFSigafter(NULL),
 285         hPsiPairDeltaPhiafter(NULL),
 286         hTrackCuts(NULL),
 287         hPhotonCuts(NULL),
 288         hInvMassbefore(NULL),
 289         hArmenterosbefore(NULL),
 290         hInvMassafter(NULL),
 291         hArmenterosafter(NULL),
 292         hAcceptanceCuts(NULL),
 293         hCutIndex(NULL),
 294         hEventPlanePhi(NULL),
 295         fPreSelCut(ref.fPreSelCut)
 296 {
 297         // Copy Constructor
 298         for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=ref.fCuts[jj];}
 299         fCutString=new TObjString((GetCutNumber()).Data());
 300         fElectronLabelArray = new Int_t[fElectronArraySize];
 301         // dont copy histograms (if you like histograms, call InitCutHistograms())
 302
 303 }
 304
 305
 306 //________________________________________________________________________
 307 AliConversionPhotonCuts::~AliConversionPhotonCuts() {
 308         // Destructor
 309         //Deleting fHistograms leads to seg fault it it's added to output collection of a task
 310         // if(fHistograms)
 311         //    delete fHistograms;
 312         // fHistograms = NULL;
 313         if(fCutString != NULL){
 314                 delete fCutString;
 315                 fCutString = NULL;
 316         }
 317         if(fElectronLabelArray){
 318                 delete fElectronLabelArray;
 319                 fElectronLabelArray = NULL;
 320         }
 321 }
 322
 323 //________________________________________________________________________
 324 void AliConversionPhotonCuts::InitCutHistograms(TString name, Bool_t preCut){
 325
 326         // Initialize Cut Histograms for QA (only initialized and filled if function is called)
 327         TH1::AddDirectory(kFALSE);
 328
 329         if(fHistograms != NULL){
 330                 delete fHistograms;
 331                 fHistograms=NULL;
 332         }
 333         if(fHistograms==NULL){
 334                 fHistograms=new TList();
 335                 fHistograms->SetOwner(kTRUE);
 336                 if(name=="")fHistograms->SetName(Form("ConvCuts_%s",GetCutNumber().Data()));
 337                 else fHistograms->SetName(Form("%s_%s",name.Data(),GetCutNumber().Data()));
 338         }
 339
 340         // IsPhotonSelected
 341         hCutIndex=new TH1F(Form("IsPhotonSelected %s",GetCutNumber().Data()),"IsPhotonSelected",11,-0.5,10.5);
 342         hCutIndex->GetXaxis()->SetBinLabel(kPhotonIn+1,"in");
 343         hCutIndex->GetXaxis()->SetBinLabel(kOnFly+1,"onfly");
 344         hCutIndex->GetXaxis()->SetBinLabel(kNoTracks+1,"no tracks");
 345         hCutIndex->GetXaxis()->SetBinLabel(kdEdxCuts+1,"dEdx");
 346         hCutIndex->GetXaxis()->SetBinLabel(kTrackCuts+1,"Track cuts");
 347         hCutIndex->GetXaxis()->SetBinLabel(kConvPointFail+1,"ConvPoint fail");
 348         hCutIndex->GetXaxis()->SetBinLabel(kPhotonCuts+1,"PhotonCuts");
 349         hCutIndex->GetXaxis()->SetBinLabel(kEventPlane+1,"EventPlane");
 350         hCutIndex->GetXaxis()->SetBinLabel(kPhotonOut+1,"out");
 351         fHistograms->Add(hCutIndex);
 352
 353         // Track Cuts
 354         hTrackCuts=new TH1F(Form("TrackCuts %s",GetCutNumber().Data()),"TrackCuts",9,-0.5,8.5);
 355         hTrackCuts->GetXaxis()->SetBinLabel(1,"in");
 356         hTrackCuts->GetXaxis()->SetBinLabel(2,"likesign");
 357         hTrackCuts->GetXaxis()->SetBinLabel(3,"ntpccl");
 358         hTrackCuts->GetXaxis()->SetBinLabel(4,"acceptance");
 359         hTrackCuts->GetXaxis()->SetBinLabel(5,"singlept");
 360         hTrackCuts->GetXaxis()->SetBinLabel(6,"TPCrefit");
 361         hTrackCuts->GetXaxis()->SetBinLabel(7,"kink");
 362         hTrackCuts->GetXaxis()->SetBinLabel(8,"out");
 363         fHistograms->Add(hTrackCuts);
 364
 365         // Photon Cuts
 366         hPhotonCuts=new TH1F(Form("PhotonCuts %s",GetCutNumber().Data()),"PhotonCuts",15,-0.5,14.5);
 367         hPhotonCuts->GetXaxis()->SetBinLabel(1,"in");
 368         hPhotonCuts->GetXaxis()->SetBinLabel(2,"qtcut");
 369         hPhotonCuts->GetXaxis()->SetBinLabel(3,"chi2");
 370         hPhotonCuts->GetXaxis()->SetBinLabel(4,"acceptance");
 371         hPhotonCuts->GetXaxis()->SetBinLabel(5,"asymmetry");
 372         hPhotonCuts->GetXaxis()->SetBinLabel(6,"pidprob");
 373         hPhotonCuts->GetXaxis()->SetBinLabel(7,"cortpcclinfo");
 374         hPhotonCuts->GetXaxis()->SetBinLabel(8,"PsiPair");
 375         hPhotonCuts->GetXaxis()->SetBinLabel(9,"CosPAngle");
 376         hPhotonCuts->GetXaxis()->SetBinLabel(10,"DCA R");
 377         hPhotonCuts->GetXaxis()->SetBinLabel(11,"DCA Z");
 378         hPhotonCuts->GetXaxis()->SetBinLabel(12,"Photon Quality");
 379         hPhotonCuts->GetXaxis()->SetBinLabel(13,"out");
 380         fHistograms->Add(hPhotonCuts);
 381
 382         if(preCut){
 383                 hInvMassbefore=new TH1F(Form("InvMass_before %s",GetCutNumber().Data()),"InvMass_before",1000,0,0.3);
 384                 fHistograms->Add(hInvMassbefore);
 385                 hArmenterosbefore=new TH2F(Form("Armenteros_before %s",GetCutNumber().Data()),"Armenteros_before",200,-1,1,1000,0,1.);
 386                 fHistograms->Add(hArmenterosbefore);
 387                 hEtaDistV0s = new TH1F(Form("Eta_before %s",GetCutNumber().Data()),"Eta_before",2000,-2,2);
 388                 fHistograms->Add(hEtaDistV0s);
 389
 390         }
 391         hInvMassafter=new TH1F(Form("InvMass_after %s",GetCutNumber().Data()),"InvMass_after",1000,0,0.3);
 392         fHistograms->Add(hInvMassafter);
 393         hArmenterosafter=new TH2F(Form("Armenteros_after %s",GetCutNumber().Data()),"Armenteros_after",200,-1,1,250,0,0.25);
 394         fHistograms->Add(hArmenterosafter);
 395
 396         hAcceptanceCuts=new TH1F(Form("PhotonAcceptanceCuts %s",GetCutNumber().Data()),"PhotonAcceptanceCuts",11,-0.5,10.5);
 397         hAcceptanceCuts->GetXaxis()->SetBinLabel(1,"in");
 398         hAcceptanceCuts->GetXaxis()->SetBinLabel(2,"maxR");
 399         hAcceptanceCuts->GetXaxis()->SetBinLabel(3,"minR");
 400         hAcceptanceCuts->GetXaxis()->SetBinLabel(4,"line");
 401         hAcceptanceCuts->GetXaxis()->SetBinLabel(5,"maxZ");
 402         hAcceptanceCuts->GetXaxis()->SetBinLabel(6,"eta");
 403         hAcceptanceCuts->GetXaxis()->SetBinLabel(7,"phisector");
 404         hAcceptanceCuts->GetXaxis()->SetBinLabel(8,"minpt");
 405         hAcceptanceCuts->GetXaxis()->SetBinLabel(9,"out");
 406         fHistograms->Add(hAcceptanceCuts);
 407
 408         // dEdx Cuts
 409         hdEdxCuts=new TH1F(Form("dEdxCuts %s",GetCutNumber().Data()),"dEdxCuts",10,-0.5,9.5);
 410         hdEdxCuts->GetXaxis()->SetBinLabel(1,"in");
 411         hdEdxCuts->GetXaxis()->SetBinLabel(2,"TPCelectron");
 412         hdEdxCuts->GetXaxis()->SetBinLabel(3,"TPCpion");
 413         hdEdxCuts->GetXaxis()->SetBinLabel(4,"TPCpionhighp");
 414         hdEdxCuts->GetXaxis()->SetBinLabel(5,"TPCkaonlowprej");
 415         hdEdxCuts->GetXaxis()->SetBinLabel(6,"TPCprotonlowprej");
 416         hdEdxCuts->GetXaxis()->SetBinLabel(7,"TPCpionlowprej");
 417         hdEdxCuts->GetXaxis()->SetBinLabel(8,"TOFelectron");
 418         hdEdxCuts->GetXaxis()->SetBinLabel(9,"TRDelectron");
 419         hdEdxCuts->GetXaxis()->SetBinLabel(10,"out");
 420         fHistograms->Add(hdEdxCuts);
 421
 422         TAxis *AxisBeforedEdx = NULL;
 423         TAxis *AxisBeforedEdxSig = NULL;
 424         TAxis *AxisBeforeTOF = NULL;
 425         TAxis *AxisBeforeTOFSig = NULL;
 426         if(preCut){
 427                 hTPCdEdxbefore=new TH2F(Form("Gamma_dEdx_before %s",GetCutNumber().Data()),"dEdx Gamma before" ,150,0.03,20,800,0,200);
 428                 fHistograms->Add(hTPCdEdxbefore);
 429                 AxisBeforedEdx = hTPCdEdxbefore->GetXaxis();
 430                 hTPCdEdxSigbefore=new TH2F(Form("Gamma_dEdxSig_before %s",GetCutNumber().Data()),"dEdx Sigma Gamma before" ,150,0.03,20,400,-10,10);
 431                 fHistograms->Add(hTPCdEdxSigbefore);
 432                 AxisBeforedEdxSig = hTPCdEdxSigbefore->GetXaxis();
 433
 434                 hTOFbefore=new TH2F(Form("Gamma_TOF_before %s",GetCutNumber().Data()),"TOF Gamma before" ,150,0.03,20,11000,-1000,10000);
 435                 fHistograms->Add(hTOFbefore);
 436                 AxisBeforeTOF = hTOFbefore->GetXaxis();
 437                 hTOFSigbefore=new TH2F(Form("Gamma_TOFSig_before %s",GetCutNumber().Data()),"TOF Sigma Gamma before" ,150,0.03,20,400,-6,10);
 438                 fHistograms->Add(hTOFSigbefore);
 439                 AxisBeforeTOFSig = hTOFSigbefore->GetXaxis();
 440
 441         }
 442         hTPCdEdxSigafter=new TH2F(Form("Gamma_dEdxSig_after %s",GetCutNumber().Data()),"dEdx Sigma Gamma after" ,150,0.03,20,400, -10,10);
 443         fHistograms->Add(hTPCdEdxSigafter);
 444
 445         hTPCdEdxafter=new TH2F(Form("Gamma_dEdx_after %s",GetCutNumber().Data()),"dEdx Gamma after" ,150,0.03,20,800,0,200);
 446         fHistograms->Add(hTPCdEdxafter);
 447
 448         hTOFSigafter=new TH2F(Form("Gamma_TOFSig_after %s",GetCutNumber().Data()),"TOF Sigma Gamma after" ,150,0.03,20,400,-6,10);
 449         fHistograms->Add(hTOFSigafter);
 450
 451         hEtaDistV0sAfterdEdxCuts = new TH1F(Form("Eta_afterdEdx %s",GetCutNumber().Data()),"Eta_afterdEdx",2000,-2,2);
 452         fHistograms->Add(hEtaDistV0sAfterdEdxCuts);
 453
 454         hPsiPairDeltaPhiafter=new TH2F(Form("Gamma_PsiPairDeltaPhi_after %s",GetCutNumber().Data()),"Psi Pair vs Delta Phi Gamma after" ,200,-2,2,200,-2,2);
 455         fHistograms->Add(hPsiPairDeltaPhiafter);
 456
 457         TAxis *AxisAfter = hTPCdEdxSigafter->GetXaxis();
 458         Int_t bins = AxisAfter->GetNbins();
 459         Double_t from = AxisAfter->GetXmin();
 460         Double_t to = AxisAfter->GetXmax();
 461         Double_t *newBins = new Double_t[bins+1];
 462         newBins[0] = from;
 463         Double_t factor = TMath::Power(to/from, 1./bins);
 464         for(Int_t i=1; i<=bins; ++i) newBins[i] = factor * newBins[i-1];
 465         AxisAfter->Set(bins, newBins);
 466         AxisAfter = hTOFSigafter->GetXaxis();
 467         AxisAfter->Set(bins, newBins);
 468         AxisAfter = hTPCdEdxafter->GetXaxis();
 469         AxisAfter->Set(bins, newBins);
 470         if(preCut){
 471                 AxisBeforedEdx->Set(bins, newBins);
 472                 AxisBeforeTOF->Set(bins, newBins);
 473                 AxisBeforedEdxSig->Set(bins, newBins);
 474                 AxisBeforeTOFSig->Set(bins, newBins);
 475         }
 476         delete [] newBins;
 477
 478         // Event Cuts and Info
 479         if(!preCut){
 480                 hEventPlanePhi=new TH1F(Form("EventPlaneMinusPhotonAngle %s",GetCutNumber().Data()),"EventPlaneMinusPhotonAngle",360,-TMath::Pi(),TMath::Pi());
 481                 fHistograms->Add(hEventPlanePhi);
 482
 483
 484         }
 485         TH1::AddDirectory(kTRUE);
 486 }
 487
 488 //________________________________________________________________________
 489 Bool_t AliConversionPhotonCuts::InitPIDResponse(){
 490         // Set Pointer to AliPIDResponse
 491
 492         AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 493         if(man) {
 494                 AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 495                 fPIDResponse = (AliPIDResponse*)inputHandler->GetPIDResponse();
 496                 if(fPIDResponse)return kTRUE;
 497
 498         }
 499
 500
 501         return kFALSE;
 502 }
 503
 504 ///________________________________________________________________________
 505 Bool_t AliConversionPhotonCuts::PhotonIsSelectedMC(TParticle *particle,AliStack *fMCStack,Bool_t checkForConvertedGamma){
 506         // MonteCarlo Photon Selection
 507
 508         if(!fMCStack)return kFALSE;
 509
 510         if (particle->GetPdgCode() == 22){
 511
 512
 513                 if( particle->Eta() > (fEtaCut) || particle->Eta() < (-fEtaCut) )
 514                         return kFALSE;
 515                 if(fEtaCutMin>-0.1){
 516                         if( particle->Eta() < (fEtaCutMin) && particle->Eta() > (-fEtaCutMin) )
 517                                 return kFALSE;
 518                 }
 519
 520                 if(particle->GetMother(0) >-1 && fMCStack->Particle(particle->GetMother(0))->GetPdgCode() == 22){
 521                         return kFALSE; // no photon as mothers!
 522                 }
 523
 524                 if(particle->GetMother(0) >= fMCStack->GetNprimary()){
 525                         return kFALSE; // the gamma has a mother, and it is not a primary particle
 526                 }
 527
 528                 if(!checkForConvertedGamma) return kTRUE; // return in case of accepted gamma
 529
 530                 // looking for conversion gammas (electron + positron from pairbuilding (= 5) )
 531                 TParticle* ePos = NULL;
 532                 TParticle* eNeg = NULL;
 533
 534                 if(particle->GetNDaughters() >= 2){
 535                         for(Int_t daughterIndex=particle->GetFirstDaughter();daughterIndex<=particle->GetLastDaughter();daughterIndex++){
 536                                 TParticle *tmpDaughter = fMCStack->Particle(daughterIndex);
 537                                 if(tmpDaughter->GetUniqueID() == 5){
 538                                 if(tmpDaughter->GetPdgCode() == 11){
 539                                         eNeg = tmpDaughter;
 540                                 } else if(tmpDaughter->GetPdgCode() == -11){
 541                                         ePos = tmpDaughter;
 542                                 }
 543                                 }
 544                         }
 545                 }
 546
 547                 if(ePos == NULL || eNeg == NULL){ // means we do not have two daughters from pair production
 548                         return kFALSE;
 549                 }
 550
 551                 if(ePos->Pt()<fSinglePtCut || eNeg->Pt()<fSinglePtCut){
 552                         return kFALSE; // no reconstruction below the Pt cut
 553                 }
 554
 555                 if( ePos->Eta() > (fEtaCut) || ePos->Eta() < (-fEtaCut) ||
 556                         eNeg->Eta() > (fEtaCut) || eNeg->Eta() < (-fEtaCut) )
 557                         return kFALSE;
 558
 559                 if(fEtaCutMin > -0.1){
 560                         if( (ePos->Eta() < (fEtaCutMin) && ePos->Eta() > (-fEtaCutMin)) ||
 561                                 (eNeg->Eta() < (fEtaCutMin) && eNeg->Eta() > (-fEtaCutMin)) )
 562                                 return kFALSE;
 563                 }
 564
 565                 if(ePos->R()>fMaxR){
 566                         return kFALSE; // cuts on distance from collision point
 567                 }
 568
 569                 if(abs(ePos->Vz()) > fMaxZ){
 570                         return kFALSE;  // outside material
 571                 }
 572                 if(abs(eNeg->Vz()) > fMaxZ){
 573                         return kFALSE;  // outside material
 574                 }
 575
 576                 if( ePos->R() <= ((abs(ePos->Vz()) * fLineCutZRSlope) - fLineCutZValue)){
 577                         return kFALSE;  // line cut to exclude regions where we do not reconstruct
 578                 } else if ( fEtaCutMin != -0.1 &&   ePos->R() >= ((abs(ePos->Vz()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
 579                         return kFALSE;
 580                 }
 581
 582                 if( eNeg->R() <= ((abs(eNeg->Vz()) * fLineCutZRSlope) - fLineCutZValue)){
 583                         return kFALSE; // line cut to exclude regions where we do not reconstruct
 584                 } else if ( fEtaCutMin != -0.1 &&   eNeg->R() >= ((abs(eNeg->Vz()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
 585                         return kFALSE;
 586                 }
 587
 588                 return kTRUE;
 589                 //if(AcceptanceCut(particle,ePos,eNeg))return kTRUE;
 590         }
 591         return kFALSE;
 592 }
 593 ///________________________________________________________________________
 594 Bool_t AliConversionPhotonCuts::PhotonIsSelectedAODMC(AliAODMCParticle *particle,TClonesArray *aodmcArray,Bool_t checkForConvertedGamma){
 595         // MonteCarlo Photon Selection
 596
 597         if(!aodmcArray)return kFALSE;
 598
 599         if (particle->GetPdgCode() == 22){
 600                 if( particle->Eta() > (fEtaCut) || particle->Eta() < (-fEtaCut) )
 601                         return kFALSE;
 602                 if(fEtaCutMin>-0.1){
 603                         if( particle->Eta() < (fEtaCutMin) && particle->Eta() > (-fEtaCutMin) )
 604                                 return kFALSE;
 605                 }
 606
 607                 if(particle->GetMother() > -1){
 608                         if((static_cast<AliAODMCParticle*>(aodmcArray->At(particle->GetMother())))->GetPdgCode() == 22){
 609                                 return kFALSE; // no photon as mothers!
 610                         }
 611                         if(!(static_cast<AliAODMCParticle*>(aodmcArray->At(particle->GetMother()))->IsPrimary())){
 612                                 return kFALSE; // the gamma has a mother, and it is not a primary particle
 613                         }
 614                 }
 615
 616                 if(!checkForConvertedGamma) return kTRUE; // return in case of accepted gamma
 617
 618                 // looking for conversion gammas (electron + positron from pairbuilding (= 5) )
 619                 AliAODMCParticle* ePos = NULL;
 620                 AliAODMCParticle* eNeg = NULL;
 621
 622                 if(particle->GetNDaughters() >= 2){
 623                         for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
 624                                 AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(aodmcArray->At(daughterIndex));
 625                                 if(!tmpDaughter) continue;
 626                                 if(((tmpDaughter->GetMCProcessCode())) == 5){    // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
 627                                 if(tmpDaughter->GetPdgCode() == 11){
 628                                         eNeg = tmpDaughter;
 629                                 } else if(tmpDaughter->GetPdgCode() == -11){
 630                                         ePos = tmpDaughter;
 631                                 }
 632                                 }
 633                         }
 634                 }
 635
 636                 if(ePos == NULL || eNeg == NULL){ // means we do not have two daughters from pair production
 637                         return kFALSE;
 638                 }
 639
 640                 if(ePos->Pt()<fSinglePtCut || eNeg->Pt()<fSinglePtCut){
 641                         return kFALSE; // no reconstruction below the Pt cut
 642                 }
 643
 644                 if( ePos->Eta() > (fEtaCut) || ePos->Eta() < (-fEtaCut) ||
 645                         eNeg->Eta() > (fEtaCut) || eNeg->Eta() < (-fEtaCut) )
 646                         return kFALSE;
 647
 648                 if(fEtaCutMin > -0.1){
 649                         if( (ePos->Eta() < (fEtaCutMin) && ePos->Eta() > (-fEtaCutMin)) ||
 650                                 (eNeg->Eta() < (fEtaCutMin) && eNeg->Eta() > (-fEtaCutMin)) )
 651                                 return kFALSE;
 652                 }
 653
 654                 Double_t rPos = sqrt( (ePos->Xv()*ePos->Xv()) + (ePos->Yv()*ePos->Yv()) );
 655                 Double_t rNeg = sqrt( (eNeg->Xv()*eNeg->Xv()) + (eNeg->Yv()*eNeg->Yv()) );
 656
 657                 if(rPos>fMaxR){
 658                         return kFALSE; // cuts on distance from collision point
 659                 }
 660                 if(abs(ePos->Zv()) > fMaxZ){
 661                         return kFALSE;  // outside material
 662                 }
 663                 if(abs(eNeg->Zv()) > fMaxZ){
 664                         return kFALSE;  // outside material
 665                 }
 666
 667                 if( rPos <= ((abs(ePos->Zv()) * fLineCutZRSlope) - fLineCutZValue)){
 668                         return kFALSE;  // line cut to exclude regions where we do not reconstruct
 669                 } else if ( fEtaCutMin != -0.1 &&   rPos >= ((abs(ePos->Zv()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
 670                         return kFALSE;
 671                 }
 672
 673                 if( rNeg <= ((abs(eNeg->Zv()) * fLineCutZRSlope) - fLineCutZValue)){
 674                         return kFALSE; // line cut to exclude regions where we do not reconstruct
 675                 } else if ( fEtaCutMin != -0.1 &&   rNeg >= ((abs(eNeg->Zv()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
 676                         return kFALSE;
 677                 }
 678
 679                 return kTRUE;
 680                 //if(AcceptanceCut(particle,ePos,eNeg))return kTRUE;
 681         }
 682         return kFALSE;
 683 }
 684
 685 ///________________________________________________________________________
 686 Bool_t AliConversionPhotonCuts::PhotonCuts(AliConversionPhotonBase *photon,AliVEvent *event)
 687 {   // Specific Photon Cuts
 688
 689         Int_t cutIndex = 0;
 690         if(hPhotonCuts)hPhotonCuts->Fill(cutIndex);
 691         cutIndex++;
 692
 693         // Fill Histos before Cuts
 694         if(hInvMassbefore)hInvMassbefore->Fill(photon->GetMass());
 695         if(hArmenterosbefore)hArmenterosbefore->Fill(photon->GetArmenterosAlpha(),photon->GetArmenterosQt());
 696
 697         // Gamma selection based on QT from Armenteros
 698         if(fDoQtGammaSelection == kTRUE){
 699                 if(!ArmenterosQtCut(photon)){
 700                         if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //1
 701                         return kFALSE;
 702                 }
 703         }
 704         cutIndex++; //2
 705
 706         // Chi Cut
 707         if(photon->GetChi2perNDF() > fChi2CutConversion || photon->GetChi2perNDF() <=0){
 708                 {
 709                         if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //2
 710                         return kFALSE;
 711                 }
 712         }
 713         cutIndex++;//3
 714
 715         // Reconstruction Acceptance Cuts
 716         if(!AcceptanceCuts(photon)){
 717                 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //3
 718                 return kFALSE;
 719         }
 720
 721         cutIndex++; //4
 722         // Asymmetry Cut
 723         if(fDoPhotonAsymmetryCut == kTRUE){
 724                 if(!AsymmetryCut(photon,event)){
 725                         if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //4
 726                         return kFALSE;
 727                 }
 728         }
 729
 730         //Check the pid probability
 731         cutIndex++; //5
 732         if(!PIDProbabilityCut(photon, event)) {
 733                 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //5
 734                 return kFALSE;
 735         }
 736
 737         cutIndex++; //6
 738         if(!CorrectedTPCClusterCut(photon, event)) {
 739                 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //6
 740                 return kFALSE;
 741         }
 742
 743         Double_t magField = event->GetMagneticField();
 744         if( magField  < 0.0 ){
 745                 magField =  1.0;
 746         } else {
 747                 magField =  -1.0;
 748         }
 749
 750         AliVTrack * electronCandidate = GetTrack(event,photon->GetTrackLabelNegative() );
 751         AliVTrack * positronCandidate = GetTrack(event,photon->GetTrackLabelPositive() );
 752         Double_t deltaPhi = magField * TVector2::Phi_mpi_pi( electronCandidate->Phi()-positronCandidate->Phi());
 753
 754         cutIndex++; //7
 755         if(!PsiPairCut(photon)) {
 756                 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //7
 757                 return kFALSE;
 758         }
 759
 760         cutIndex++; //8
 761         if(!CosinePAngleCut(photon, event)) {
 762                 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //8
 763                 return kFALSE;
 764         }
 765
 766         AliAODConversionPhoton* photonAOD = dynamic_cast<AliAODConversionPhoton*>(photon);
 767         if (photonAOD){
 768                 photonAOD->CalculateDistanceOfClossetApproachToPrimVtx(event->GetPrimaryVertex());
 769
 770                 cutIndex++; //9
 771                 if(photonAOD->GetDCArToPrimVtx() > fDCARPrimVtxCut) { //DCA R cut of photon to primary vertex
 772                         if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //9
 773                         return kFALSE;
 774                 }
 775
 776                 cutIndex++; //10
 777                 if(abs(photonAOD->GetDCAzToPrimVtx()) > fDCAZPrimVtxCut) { //DCA Z cut of photon to primary vertex
 778                         if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //10
 779                         return kFALSE;
 780                 }
 781         } else {
 782                 cutIndex++; //9
 783                 cutIndex++; //10
 784         }
 785         cutIndex++; //11
 786
 787         if (photonAOD){
 788                 UChar_t photonQuality = 0;
 789                         AliAODEvent * aodEvent = dynamic_cast<AliAODEvent*>(event);
 790                         if(aodEvent) {
 791                                 photonQuality = DeterminePhotonQualityAOD(photonAOD, event);
 792                         } else {
 793                                 photonQuality = photonAOD->GetPhotonQuality();
 794                         }
 795                         if (fDoPhotonQualitySelectionCut && photonQuality != fPhotonQualityCut){
 796                                 if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //11
 797                                 return kFALSE;
 798                         }
 799         }
 800         cutIndex++; //12
 801         if(hPhotonCuts)hPhotonCuts->Fill(cutIndex); //11
 802
 803         // Histos after Cuts
 804         if(hInvMassafter)hInvMassafter->Fill(photon->GetMass());
 805         if(hArmenterosafter)hArmenterosafter->Fill(photon->GetArmenterosAlpha(),photon->GetArmenterosQt());
 806         if(hPsiPairDeltaPhiafter)hPsiPairDeltaPhiafter->Fill(deltaPhi,photon->GetPsiPair());
 807         return kTRUE;
 808
 809 }
 810
 811 ///________________________________________________________________________
 812 Bool_t AliConversionPhotonCuts::CorrectedTPCClusterCut(AliConversionPhotonBase *photon, AliVEvent * event)
 813 {   //Cut on corrected TPC Cluster Info
 814
 815         AliVTrack * negTrack = GetTrack(event, photon->GetTrackLabelNegative());
 816         AliVTrack * posTrack = GetTrack(event, photon->GetTrackLabelPositive());
 817
 818         if(!negTrack||!posTrack)return kFALSE;
 819
 820         Double_t negclsToF=0;
 821
 822         if (!fUseCorrectedTPCClsInfo ){
 823                 if(negTrack->GetTPCNclsF()!=0){
 824                         negclsToF = (Double_t)negTrack->GetNcls(1)/(Double_t)negTrack->GetTPCNclsF();}// Ncluster/Nfindablecluster
 825         }
 826         else {
 827                 negclsToF = negTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));
 828         }
 829
 830         Double_t posclsToF = 0.;
 831         if (!fUseCorrectedTPCClsInfo ){
 832                 if(posTrack->GetTPCNclsF()!=0){
 833                         posclsToF = (Double_t)posTrack->GetNcls(1)/(Double_t)posTrack->GetTPCNclsF();
 834                 }
 835         }else{
 836                 posclsToF = posTrack->GetTPCClusterInfo(2,0,GetFirstTPCRow(photon->GetConversionRadius()));
 837         }
 838
 839         if( negclsToF < fMinClsTPCToF || posclsToF < fMinClsTPCToF ){
 840                 return kFALSE;
 841         }
 842
 843         return kTRUE;
 844 }
 845
 846 ///________________________________________________________________________
 847 Bool_t AliConversionPhotonCuts::PhotonIsSelected(AliConversionPhotonBase *photon, AliVEvent * event)
 848 {
 849         //Selection of Reconstructed Photons
 850
 851         FillPhotonCutIndex(kPhotonIn);
 852
 853         if(event->IsA()==AliESDEvent::Class()) {
 854                 if(!SelectV0Finder( ( ((AliESDEvent*)event)->GetV0(photon->GetV0Index()))->GetOnFlyStatus() ) ){
 855                         FillPhotonCutIndex(kOnFly);
 856                         return kFALSE;
 857                 }
 858         }
 859         // else if(event->IsA()==AliAODEvent::Class()) {
 860         //    if(!SelectV0Finder( ( ((AliAODEvent*)event)->GetV0(photon->GetV0Index())) ) ){
 861         //       FillPhotonCutIndex(kOnFly);
 862         //       return kFALSE;
 863         //    }
 864         // }
 865
 866         // Get Tracks
 867         AliVTrack * negTrack = GetTrack(event, photon->GetTrackLabelNegative());
 868         AliVTrack * posTrack = GetTrack(event, photon->GetTrackLabelPositive());
 869
 870         if(!negTrack || !posTrack) {
 871                 FillPhotonCutIndex(kNoTracks);
 872                 return kFALSE;
 873         }
 874         photon->DeterminePhotonQuality(negTrack,posTrack);
 875         // Track Cuts
 876         if(!TracksAreSelected(negTrack, posTrack)){
 877                 FillPhotonCutIndex(kTrackCuts);
 878                 return kFALSE;
 879         }
 880         if (hEtaDistV0s)hEtaDistV0s->Fill(photon->GetPhotonEta());
 881         // dEdx Cuts
 882         if(!dEdxCuts(negTrack) || !dEdxCuts(posTrack)) {
 883                 FillPhotonCutIndex(kdEdxCuts);
 884                 return kFALSE;
 885         }
 886         if (hEtaDistV0sAfterdEdxCuts)hEtaDistV0sAfterdEdxCuts->Fill(photon->GetPhotonEta());
 887         // Photon Cuts
 888         if(!PhotonCuts(photon,event)){
 889                 FillPhotonCutIndex(kPhotonCuts);
 890                 return kFALSE;
 891         }
 892
 893         // Photon passed cuts
 894         FillPhotonCutIndex(kPhotonOut);
 895         return kTRUE;
 896 }
 897
 898 ///________________________________________________________________________
 899 Bool_t AliConversionPhotonCuts::ArmenterosQtCut(AliConversionPhotonBase *photon)
 900 {   // Armenteros Qt Cut
 901         if(fDo2DQt){
 902                 if ( !(TMath::Power(photon->GetArmenterosAlpha()/0.95,2)+TMath::Power(photon->GetArmenterosQt()/fQtMax,2) < 1) ){
 903                         return kFALSE;
 904                 }
 905         } else {
 906                 if(photon->GetArmenterosQt()>fQtMax){
 907                         return kFALSE;
 908                 }
 909         }
 910         return kTRUE;
 911 }
 912
 913
 914 ///________________________________________________________________________
 915 Bool_t AliConversionPhotonCuts::AcceptanceCuts(AliConversionPhotonBase *photon) {
 916         // Exclude certain areas for photon reconstruction
 917
 918         Int_t cutIndex=0;
 919         if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 920         cutIndex++;
 921
 922         if(photon->GetConversionRadius()>fMaxR){ // cuts on distance from collision point
 923                 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 924                 return kFALSE;
 925         }
 926         cutIndex++;
 927
 928         if(photon->GetConversionRadius()<fMinR){ // cuts on distance from collision point
 929                 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 930                 return kFALSE;
 931         }
 932         cutIndex++;
 933
 934         if(photon->GetConversionRadius() <= ((abs(photon->GetConversionZ())*fLineCutZRSlope)-fLineCutZValue)){
 935                 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 936                 return kFALSE;
 937         }
 938         else if (fUseEtaMinCut &&  photon->GetConversionRadius() >= ((abs(photon->GetConversionZ())*fLineCutZRSlopeMin)-fLineCutZValueMin )){
 939                 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 940                 return kFALSE;
 941         }
 942         cutIndex++;
 943
 944         if(abs(photon->GetConversionZ()) > fMaxZ ){ // cuts out regions where we do not reconstruct
 945                 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 946                 return kFALSE;
 947         }
 948         cutIndex++;
 949
 950
 951         if( photon->GetPhotonEta() > (fEtaCut)    || photon->GetPhotonEta() < (-fEtaCut) ){
 952                 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 953                 return kFALSE;
 954         }
 955         if(fEtaCutMin>-0.1){
 956                 if( photon->GetPhotonEta() < (fEtaCutMin) && photon->GetPhotonEta() > (-fEtaCutMin) ){
 957                         if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 958                         return kFALSE;
 959                 }
 960         }
 961         cutIndex++;
 962
 963         if (fDoShrinkTPCAcceptance){
 964                 if(photon->GetPhotonEta() > fEtaForPhiCutMin && photon->GetPhotonEta() < fEtaForPhiCutMax ){
 965                         if (fMinPhiCut < fMaxPhiCut){
 966                                 if( photon->GetPhotonPhi() > fMinPhiCut && photon->GetPhotonPhi() < fMaxPhiCut ) {
 967                                         if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 968                                         return kFALSE;
 969                                 }
 970                         } else {
 971                                 Double_t photonPhi = photon->GetPhotonPhi();
 972                                 if (photon->GetPhotonPhi() < TMath::Pi()) photonPhi = photon->GetPhotonPhi() + 2*TMath::Pi();
 973                                 if( photonPhi > fMinPhiCut && photonPhi < fMaxPhiCut+2*TMath::Pi() ) {
 974                                         if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 975                                         return kFALSE;
 976                                 }
 977                         }
 978                 }
 979         }
 980         cutIndex++;
 981
 982
 983
 984         if(photon->GetPhotonPt()<fPtCut){
 985                 if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 986                 return kFALSE;
 987         }
 988         cutIndex++;
 989
 990         if(hAcceptanceCuts)hAcceptanceCuts->Fill(cutIndex);
 991
 992         return kTRUE;
 993 }
 994
 995
 996 ///________________________________________________________________________
 997 Bool_t AliConversionPhotonCuts::SpecificTrackCuts(AliAODTrack * negTrack, AliAODTrack * posTrack,Int_t &cutIndex) {
 998         // Track Cuts which require AOD/ESD specific implementation
 999
1000         if( !negTrack->IsOn(AliESDtrack::kTPCrefit)  || !posTrack->IsOn(AliESDtrack::kTPCrefit)   )  {
1001                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1002                 return kFALSE;
1003         }
1004         cutIndex++;
1005
1006         AliAODVertex * NegVtxType=negTrack->GetProdVertex();
1007         AliAODVertex * PosVtxType=posTrack->GetProdVertex();
1008         if( (NegVtxType->GetType())==AliAODVertex::kKink || (PosVtxType->GetType())==AliAODVertex::kKink) {
1009                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1010                 return kFALSE;
1011         }
1012         return kTRUE;
1013
1014 }
1015
1016
1017 ///________________________________________________________________________
1018 Bool_t AliConversionPhotonCuts::SpecificTrackCuts(AliESDtrack * negTrack, AliESDtrack * posTrack,Int_t &cutIndex) {
1019         // Track Cuts which require AOD/ESD specific implementation
1020
1021         if( !negTrack->IsOn(AliESDtrack::kTPCrefit)  || !posTrack->IsOn(AliESDtrack::kTPCrefit)   )  {
1022                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1023                 return kFALSE;
1024         }
1025         cutIndex++;
1026
1027         if(negTrack->GetKinkIndex(0) > 0  || posTrack->GetKinkIndex(0) > 0 ) {
1028                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1029                 return kFALSE;
1030         }
1031         return kTRUE;
1032 }
1033
1034
1035
1036 ///________________________________________________________________________
1037 Bool_t AliConversionPhotonCuts::TracksAreSelected(AliVTrack * negTrack, AliVTrack * posTrack) {
1038         // Track Selection for Photon Reconstruction
1039
1040         Int_t cutIndex=0;
1041         if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1042         cutIndex++;
1043
1044         // avoid like sign
1045         if(negTrack->Charge() == posTrack->Charge()) {
1046                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1047                 return kFALSE;
1048         }
1049         cutIndex++;
1050
1051         // Number of TPC Clusters
1052
1053
1054         if( negTrack->GetNcls(1) < fMinClsTPC || posTrack->GetNcls(1) < fMinClsTPC ) {
1055                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1056                 return kFALSE;
1057         }
1058         cutIndex++;
1059
1060         // Acceptance
1061         if( posTrack->Eta() > (fEtaCut) || posTrack->Eta() < (-fEtaCut) ||
1062                 negTrack->Eta() > (fEtaCut) || negTrack->Eta() < (-fEtaCut) ){
1063                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1064                 return kFALSE;
1065         }
1066         if(fEtaCutMin>-0.1){
1067                 if( (posTrack->Eta() < (fEtaCutMin) && posTrack->Eta() > (-fEtaCutMin)) ||
1068                         (negTrack->Eta() < (fEtaCutMin) && negTrack->Eta() > (-fEtaCutMin)) ){
1069                         if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1070                         return kFALSE;
1071                 }
1072         }
1073         cutIndex++;
1074
1075         // Single Pt Cut
1076         if( negTrack->Pt()< fSinglePtCut || posTrack->Pt()< fSinglePtCut){
1077                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1078                 return kFALSE;
1079         }
1080         cutIndex++;
1081
1082         // AOD ESD specific cuts
1083         Bool_t passCuts = kTRUE;
1084
1085         if(negTrack->IsA()==AliAODTrack::Class()) {
1086                 passCuts = passCuts * SpecificTrackCuts(static_cast<AliAODTrack*>(negTrack), static_cast<AliAODTrack*>(posTrack),cutIndex);
1087         } else {
1088                 passCuts = passCuts * SpecificTrackCuts(static_cast<AliESDtrack*>(negTrack), static_cast<AliESDtrack*>(posTrack),cutIndex);
1089         }
1090
1091         if(!passCuts){
1092                 if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1093                 return kFALSE;
1094         }
1095         cutIndex++;
1096
1097         if(hTrackCuts)hTrackCuts->Fill(cutIndex);
1098
1099         return kTRUE;
1100
1101 }
1102
1103 ///________________________________________________________________________
1104 Bool_t AliConversionPhotonCuts::dEdxCuts(AliVTrack *fCurrentTrack){
1105         // Electron Identification Cuts for Photon reconstruction
1106         if(!fPIDResponse){InitPIDResponse();}// Try to reinitialize PID Response
1107         if(!fPIDResponse){AliError("No PID Response"); return kTRUE;}// if still missing fatal error
1108
1109         Int_t cutIndex=0;
1110         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1111         if(hTPCdEdxSigbefore)hTPCdEdxSigbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));
1112         if(hTPCdEdxbefore)hTPCdEdxbefore->Fill(fCurrentTrack->P(),fCurrentTrack->GetTPCsignal());
1113         cutIndex++;
1114
1115         if(fDodEdxSigmaCut == kTRUE){
1116                 // TPC Electron Line
1117                 if( fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaBelowElectronLine ||
1118                         fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaAboveElectronLine){
1119
1120                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1121                         return kFALSE;
1122                 }
1123                 cutIndex++;
1124
1125                 // TPC Pion Line
1126                 if( fCurrentTrack->P()>fPIDMinPnSigmaAbovePionLine && fCurrentTrack->P()<fPIDMaxPnSigmaAbovePionLine ){
1127                         if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLine &&
1128                                 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLine&&
1129                                 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLine){
1130
1131                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1132                                 return kFALSE;
1133                         }
1134                 }
1135                 cutIndex++;
1136
1137                 // High Pt Pion rej
1138                 if( fCurrentTrack->P()>fPIDMaxPnSigmaAbovePionLine ){
1139                         if(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)>fPIDnSigmaBelowElectronLine &&
1140                                 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kElectron)<fPIDnSigmaAboveElectronLine &&
1141                                 fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion)<fPIDnSigmaAbovePionLineHighPt){
1142
1143                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1144                                 return kFALSE;
1145                         }
1146                 }
1147                 cutIndex++;
1148         }
1149         else{cutIndex+=3;}
1150
1151         if(fDoKaonRejectionLowP == kTRUE){
1152                 if(fCurrentTrack->P()<fPIDMinPKaonRejectionLowP ){
1153                         if( abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kKaon))<fPIDnSigmaAtLowPAroundKaonLine){
1154
1155                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1156                                 return kFALSE;
1157                         }
1158                 }
1159         }
1160         cutIndex++;
1161         if(fDoProtonRejectionLowP == kTRUE){
1162                 if( fCurrentTrack->P()<fPIDMinPProtonRejectionLowP ){
1163                         if( abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kProton))<fPIDnSigmaAtLowPAroundProtonLine){
1164
1165                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1166                                 return kFALSE;
1167                         }
1168                 }
1169         }
1170         cutIndex++;
1171
1172         if(fDoPionRejectionLowP == kTRUE){
1173                 if( fCurrentTrack->P()<fPIDMinPPionRejectionLowP ){
1174                         if( abs(fPIDResponse->NumberOfSigmasTPC(fCurrentTrack,AliPID::kPion))<fPIDnSigmaAtLowPAroundPionLine){
1175
1176                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1177                                 return kFALSE;
1178                         }
1179                 }
1180         }
1181         cutIndex++;
1182
1183
1184         // cout<<"Start"<<endl;
1185         // AliPIDResponse::EDetPidStatus status=fPIDResponse->CheckPIDStatus(AliPIDResponse::kTOF,fCurrentTrack);
1186
1187         // if( ( (status & AliVTrack::kTOFout) == AliVTrack::kTOFout ) && ( (status & AliVTrack::kTIME) == AliVTrack::kTIME ))
1188         //    {cout<<"TOF DA"<<endl;}
1189         // if(status == AliPIDResponse::kDetPidOk){
1190         //    Float_t probMis = fPIDResponse->GetTOFMismatchProbability(fCurrentTrack);
1191         //    cout<<"--> "<<probMis<<endl;
1192         //    if(probMis > 0.01){
1193
1194         //    }
1195         // }
1196
1197         if((fCurrentTrack->GetStatus() & AliESDtrack::kTOFpid) && !(fCurrentTrack->GetStatus() & AliESDtrack::kTOFmismatch)){
1198                 if(hTOFbefore){
1199                         Double_t t0 = fPIDResponse->GetTOFResponse().GetStartTime(fCurrentTrack->P());
1200                         Double_t  times[AliPID::kSPECIESC];
1201                         fCurrentTrack->GetIntegratedTimes(times);
1202                         Double_t TOFsignal = fCurrentTrack->GetTOFsignal();
1203                         Double_t dT = TOFsignal - t0 - times[0];
1204                         hTOFbefore->Fill(fCurrentTrack->P(),dT);
1205                 }
1206                 if(hTOFSigbefore) hTOFSigbefore->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));
1207                 if(fUseTOFpid){
1208                         if(fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)>fTofPIDnSigmaAboveElectronLine ||
1209                                 fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron)<fTofPIDnSigmaBelowElectronLine ){
1210                                 if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1211                                 return kFALSE;
1212                         }
1213                 }
1214                 if(hTOFSigafter)hTOFSigafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTOF(fCurrentTrack, AliPID::kElectron));
1215         }
1216         cutIndex++;
1217         // Apply TRD PID
1218         if(fDoTRDPID){
1219                 if(!fPIDResponse->IdentifiedAsElectronTRD(fCurrentTrack,fPIDTRDEfficiency)){
1220                         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1221                         return kFALSE;
1222                 }
1223         }
1224         cutIndex++;
1225
1226         if(hdEdxCuts)hdEdxCuts->Fill(cutIndex);
1227         if(hTPCdEdxSigafter)hTPCdEdxSigafter->Fill(fCurrentTrack->P(),fPIDResponse->NumberOfSigmasTPC(fCurrentTrack, AliPID::kElectron));
1228         if(hTPCdEdxafter)hTPCdEdxafter->Fill(fCurrentTrack->P(),fCurrentTrack->GetTPCsignal());
1229
1230         return kTRUE;
1231 }
1232
1233 ///________________________________________________________________________
1234 Bool_t AliConversionPhotonCuts::AsymmetryCut(AliConversionPhotonBase * photon,AliVEvent *event) {
1235         // Cut on Energy Assymetry
1236
1237         for(Int_t ii=0;ii<2;ii++){
1238
1239                 AliVTrack *track=GetTrack(event,photon->GetTrackLabel(ii));
1240
1241                 if( track->P() > fMinPPhotonAsymmetryCut ){
1242                         Double_t trackNegAsy=0;
1243                         if (photon->GetPhotonP()!=0.){
1244                                 trackNegAsy= track->P()/photon->GetPhotonP();
1245                         }
1246
1247                         if( trackNegAsy<fMinPhotonAsymmetry ||trackNegAsy>(1.- fMinPhotonAsymmetry)){
1248                                 return kFALSE;
1249                         }
1250                 }
1251
1252         }
1253         return kTRUE;
1254 }
1255
1256 ///________________________________________________________________________
1257 AliVTrack *AliConversionPhotonCuts::GetTrack(AliVEvent * event, Int_t label){
1258         //Returns pointer to the track with given ESD label
1259         //(Important for AOD implementation, since Track array in AOD data is different
1260         //from ESD array, but ESD tracklabels are stored in AOD Tracks)
1261
1262         AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);
1263         if(esdEvent) {
1264                 if(label > event->GetNumberOfTracks() ) return NULL;
1265                 AliESDtrack * track = esdEvent->GetTrack(label);
1266                 return track;
1267
1268         } else {
1269                 AliVTrack * track = 0x0;
1270                 if(((AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask("V0ReaderV1"))->AreAODsRelabeled()){
1271                         track = dynamic_cast<AliVTrack*>(event->GetTrack(label));
1272                         return track;
1273                 }
1274                 else{
1275                         for(Int_t ii=0; ii<event->GetNumberOfTracks(); ii++) {
1276                                 track = dynamic_cast<AliVTrack*>(event->GetTrack(ii));
1277                                 if(track){
1278                                 if(track->GetID() == label) {
1279                                         return track;
1280                                 }
1281                                 }
1282                         }
1283                 }
1284         }
1285         //AliDebug(5,(Form("track not found %d %d",label,event->GetNumberOfTracks()));
1286         return NULL;
1287 }
1288
1289 ///________________________________________________________________________
1290 AliESDtrack *AliConversionPhotonCuts::GetESDTrack(AliESDEvent * event, Int_t label){
1291         //Returns pointer to the track with given ESD label
1292         //(Important for AOD implementation, since Track array in AOD data is different
1293         //from ESD array, but ESD tracklabels are stored in AOD Tracks)
1294
1295         if(event) {
1296                 if(label > event->GetNumberOfTracks() ) return NULL;
1297                 AliESDtrack * track = event->GetTrack(label);
1298                 return track;
1299         }
1300         //AliDebug(5,(Form("track not found %d %d",label,event->GetNumberOfTracks()));
1301         return NULL;
1302 }
1303
1304
1305
1306 ///________________________________________________________________________
1307 Bool_t AliConversionPhotonCuts::PIDProbabilityCut(AliConversionPhotonBase *photon, AliVEvent * event){
1308         // Cut on Electron Probability for Photon Reconstruction
1309
1310         AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(event);
1311
1312         if(esdEvent){
1313
1314                 Bool_t iResult=kFALSE;
1315
1316                 Double_t *posProbArray = new Double_t[AliPID::kSPECIES];
1317                 Double_t *negProbArray = new Double_t[AliPID::kSPECIES];
1318
1319                 AliESDtrack* negTrack   = esdEvent->GetTrack(photon->GetTrackLabelNegative());
1320                 AliESDtrack* posTrack   = esdEvent->GetTrack(photon->GetTrackLabelPositive());
1321
1322                 if(negProbArray && posProbArray){
1323
1324                         negTrack->GetTPCpid(negProbArray);
1325                         posTrack->GetTPCpid(posProbArray);
1326
1327                         if(negProbArray[AliPID::kElectron]>=fPIDProbabilityCutNegativeParticle && posProbArray[AliPID::kElectron]>=fPIDProbabilityCutPositiveParticle){
1328                                 iResult=kTRUE;
1329                         }
1330                 }
1331
1332                 delete [] posProbArray;
1333                 delete [] negProbArray;
1334                 return iResult;
1335
1336         } else {
1337                 ///Not possible for AODs
1338                 return kTRUE;
1339         }
1340 }
1341
1342
1343 ///________________________________________________________________________
1344 Bool_t AliConversionPhotonCuts::AcceptanceCut(TParticle *particle, TParticle * ePos,TParticle* eNeg){
1345         // MC Acceptance Cuts
1346         //(Certain areas were excluded for photon reconstruction)
1347
1348         if(particle->R()>fMaxR){
1349                 return kFALSE;}
1350
1351         if(ePos->R()>fMaxR){
1352                 return kFALSE;
1353         }
1354
1355         if(ePos->R()<fMinR){
1356                 return kFALSE;
1357         }
1358
1359         if( ePos->R() <= ((abs(ePos->Vz())*fLineCutZRSlope)-fLineCutZValue)){
1360                 return kFALSE;
1361         }
1362         else if (fUseEtaMinCut &&  ePos->R() >= ((abs(ePos->Vz())*fLineCutZRSlopeMin)-fLineCutZValueMin )){
1363                 return kFALSE;
1364         }
1365
1366         if(abs(eNeg->Vz()) > fMaxZ ){ // cuts out regions where we do not reconstruct
1367                 return kFALSE;
1368         }
1369
1370         if(eNeg->Vz()!=ePos->Vz()||eNeg->R()!=ePos->R()){
1371                 return kFALSE;
1372         }
1373
1374         if(abs(ePos->Vz()) > fMaxZ ){ // cuts out regions where we do not reconstruct
1375                 return kFALSE;
1376         }
1377
1378
1379         if( particle->Eta() > (fEtaCut) || particle->Eta() < (-fEtaCut) ){
1380                 return kFALSE;
1381         }
1382         if( ePos->Eta() > (fEtaCut) || ePos->Eta() < (-fEtaCut) ){
1383                 return kFALSE;
1384         }
1385         if( eNeg->Eta() > (fEtaCut) || eNeg->Eta() < (-fEtaCut) ){
1386                 return kFALSE;
1387         }
1388         if(fEtaCutMin>-0.1){
1389                 if( particle->Eta() < (fEtaCutMin) && particle->Eta() > (-fEtaCutMin) ){
1390                         return kFALSE;
1391                 }
1392                 if( ePos->Eta() < (fEtaCutMin) && ePos->Eta() > (-fEtaCutMin) ){
1393                         return kFALSE;
1394                 }
1395                 if( eNeg->Eta() < (fEtaCutMin) && eNeg->Eta() > (-fEtaCutMin) ){
1396                         return kFALSE;
1397                 }
1398         }
1399
1400         if( ePos->Pt()< fSinglePtCut ||  eNeg->Pt()< fSinglePtCut){
1401                 return kFALSE;
1402         }
1403
1404         if(particle->Pt()<fPtCut){
1405                 return kFALSE;
1406         }
1407
1408         return kTRUE;
1409 }
1410 ///________________________________________________________________________
1411 Bool_t AliConversionPhotonCuts::UpdateCutString() {
1412         ///Update the cut string (if it has been created yet)
1413
1414         if(fCutString && fCutString->GetString().Length() == kNCuts) {
1415                 fCutString->SetString(GetCutNumber());
1416         } else {
1417                 return kFALSE;
1418         }
1419         return kTRUE;
1420 }
1421
1422
1423 ///________________________________________________________________________
1424 Bool_t AliConversionPhotonCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {
1425         // Initialize Cuts from a given Cut string
1426         AliInfo(Form("Set Photoncut Number: %s",analysisCutSelection.Data()));
1427         if(analysisCutSelection.Length()!=kNCuts) {
1428                 AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));
1429                 return kFALSE;
1430         }
1431         if(!analysisCutSelection.IsDigit()){
1432                 AliError("Cut selection contains characters");
1433                 return kFALSE;
1434         }
1435
1436         const char *cutSelection = analysisCutSelection.Data();
1437         #define ASSIGNARRAY(i)  fCuts[i] = cutSelection[i] - '0'
1438         for(Int_t ii=0;ii<kNCuts;ii++){
1439                 ASSIGNARRAY(ii);
1440         }
1441
1442         // Set Individual Cuts
1443         for(Int_t ii=0;ii<kNCuts;ii++){
1444                 if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;
1445         }
1446
1447         PrintCutsWithValues();
1448
1449         return kTRUE;
1450 }
1451 ///________________________________________________________________________
1452 Bool_t AliConversionPhotonCuts::SetCut(cutIds cutID, const Int_t value) {
1453         ///Set individual cut ID
1454
1455         switch (cutID) {
1456
1457                 case kv0FinderType:
1458                         if( SetV0Finder(value)) {
1459                                 fCuts[kv0FinderType] = value;
1460                                 UpdateCutString();
1461                                 return kTRUE;
1462                         } else return kFALSE;
1463
1464                 case ketaCut:
1465                         if( SetEtaCut(value)) {
1466                                 fCuts[ketaCut] = value;
1467                                 UpdateCutString();
1468                                 return kTRUE;
1469                         } else return kFALSE;
1470
1471                 case kRCut:
1472                         if( SetRCut(value)) {
1473                                 fCuts[kRCut] = value;
1474                                 UpdateCutString();
1475                                 return kTRUE;
1476                         } else return kFALSE;
1477
1478                 case kEtaForPhiSector:
1479                         if( SetEtaForPhiCut(value)) {
1480                                 fCuts[kEtaForPhiSector] = value;
1481                                 UpdateCutString();
1482                                 return kTRUE;
1483                         } else return kFALSE;
1484                 case kMinPhiSector:
1485                         if( SetMinPhiSectorCut(value)) {
1486                                 fCuts[kMinPhiSector] = value;
1487                                 UpdateCutString();
1488                                 return kTRUE;
1489                         } else return kFALSE;
1490                 case kMaxPhiSector:
1491                         if( SetMaxPhiSectorCut(value)) {
1492                                 fCuts[kMaxPhiSector] = value;
1493                                 UpdateCutString();
1494                                 return kTRUE;
1495                         } else return kFALSE;
1496
1497                 case ksinglePtCut:
1498                         if( SetSinglePtCut(value)) {
1499                                 fCuts[ksinglePtCut] = value;
1500                                 UpdateCutString();
1501                                 return kTRUE;
1502                         } else return kFALSE;
1503
1504                 case kclsTPCCut:
1505                         if( SetTPCClusterCut(value)) {
1506                                 fCuts[kclsTPCCut] = value;
1507                                 UpdateCutString();
1508                                 return kTRUE;
1509                         } else return kFALSE;
1510
1511                 case kededxSigmaCut:
1512                         if( SetTPCdEdxCutElectronLine(value)) {
1513                                 fCuts[kededxSigmaCut] = value;
1514                                 UpdateCutString();
1515                                 return kTRUE;
1516                         } else return kFALSE;
1517
1518                 case kpidedxSigmaCut:
1519                         if( SetTPCdEdxCutPionLine(value)) {
1520                                 fCuts[kpidedxSigmaCut] = value;
1521                                 UpdateCutString();
1522                                 return kTRUE;
1523                         } else return kFALSE;
1524
1525                 case kpiMomdedxSigmaCut:
1526                         if( SetMinMomPiondEdxCut(value)) {
1527                                 fCuts[kpiMomdedxSigmaCut] = value;
1528                                 UpdateCutString();
1529                                 return kTRUE;
1530                         } else return kFALSE;
1531
1532                 case kpiMaxMomdedxSigmaCut:
1533                         if( SetMaxMomPiondEdxCut(value)) {
1534                                 fCuts[kpiMaxMomdedxSigmaCut] = value;
1535                                 UpdateCutString();
1536                                 return kTRUE;
1537                         } else return kFALSE;
1538
1539                 case kLowPRejectionSigmaCut:
1540                         if( SetLowPRejectionCuts(value)) {
1541                                 fCuts[kLowPRejectionSigmaCut] = value;
1542                                 UpdateCutString();
1543                                 return kTRUE;
1544                         } else return kFALSE;
1545
1546                 case kTOFelectronPID:
1547                         if( SetTOFElectronPIDCut(value)) {
1548                                 fCuts[kTOFelectronPID] = value;
1549                                 UpdateCutString();
1550                                 return kTRUE;
1551                         } else return kFALSE;
1552
1553                 case kQtMaxCut:
1554                         if( SetQtMaxCut(value)) {
1555                                 fCuts[kQtMaxCut] = value;
1556                                 UpdateCutString();
1557                                 return kTRUE;
1558                         } else return kFALSE;
1559
1560
1561                 case kchi2GammaCut:
1562                         if( SetChi2GammaCut(value)) {
1563                                 fCuts[kchi2GammaCut] = value;
1564                                 UpdateCutString();
1565                                 return kTRUE;
1566                         } else return kFALSE;
1567
1568                 case kPsiPair:
1569                         if( SetPsiPairCut(value)) {
1570                                 fCuts[kPsiPair] = value;
1571                                 UpdateCutString();
1572                                 return kTRUE;
1573                         } else return kFALSE;
1574
1575                 case kdoPhotonAsymmetryCut:
1576                         if( SetPhotonAsymmetryCut(value)) {
1577                                 fCuts[kdoPhotonAsymmetryCut] = value;
1578                                 UpdateCutString();
1579                                 return kTRUE;
1580                         } else return kFALSE;
1581
1582                 case kCosPAngle:
1583                         if( SetCosPAngleCut(value)) {
1584                                 fCuts[kCosPAngle] = value;
1585                                 UpdateCutString();
1586                                 return kTRUE;
1587                         } else return kFALSE;
1588
1589                 case kElecShare:
1590                         if( SetSharedElectronCut(value)) {
1591                                 fCuts[kElecShare] = value;
1592                                 UpdateCutString();
1593                                 return kTRUE;
1594                         } else return kFALSE;
1595
1596                 case kToCloseV0s:
1597                         if( SetToCloseV0sCut(value)) {
1598                                 fCuts[kToCloseV0s] = value;
1599                                 UpdateCutString();
1600                                 return kTRUE;
1601                         } else return kFALSE;
1602
1603                 case kDcaRPrimVtx:
1604                         if( SetDCARPhotonPrimVtxCut(value)) {
1605                                 fCuts[kDcaRPrimVtx] = value;
1606                                 UpdateCutString();
1607                                 return kTRUE;
1608                         } else return kFALSE;
1609
1610                 case kDcaZPrimVtx:
1611                         if( SetDCAZPhotonPrimVtxCut(value)) {
1612                                 fCuts[kDcaZPrimVtx] = value;
1613                                 UpdateCutString();
1614                                 return kTRUE;
1615                         } else return kFALSE;
1616
1617                 case kInPlaneOutOfPlane:
1618                         if( SetInPlaneOutOfPlane(value)) {
1619                                 fCuts[kInPlaneOutOfPlane] = value;
1620                                 UpdateCutString();
1621                                 return kTRUE;
1622                         } else return kFALSE;
1623
1624                 case kNCuts:
1625                         AliError("Cut id out of range");
1626                         return kFALSE;
1627         }
1628
1629         AliError("Cut id %d not recognized");
1630         return kFALSE;
1631
1632
1633 }
1634 ///________________________________________________________________________
1635 void AliConversionPhotonCuts::PrintCuts() {
1636    // Print out current Cut Selection
1637    for(Int_t ic = 0; ic < kNCuts; ic++) {
1638       printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);
1639    }
1640 }
1641
1642 void AliConversionPhotonCuts::PrintCutsWithValues() {
1643    // Print out current Cut Selection with value
1644         printf("\nConversion cutnumber \n");
1645         for(Int_t ic = 0; ic < kNCuts; ic++) {
1646                 printf("%d",fCuts[ic]);
1647         }
1648         printf("\n\n");
1649         printf("Electron cuts & Secondary Track Cuts - only track from secondaries enter analysis: \n");
1650         printf("\t no like sign pairs from V0s \n");
1651         if (!fUseCorrectedTPCClsInfo) printf("\t # TPC clusters > %3.2f \n", fMinClsTPC);
1652         if (fEtaCutMin > -0.1) printf("\t %3.2f < eta_{e} < %3.2f\n", fEtaCutMin, fEtaCut );
1653                 else printf("\t eta_{e} < %3.2f\n", fEtaCut );
1654         printf("\t reject: %3.2f < phi < %3.2f with %3.2f < eta < %3.2f  \n", fMinPhiCut, fMaxPhiCut, fEtaForPhiCutMin, fEtaForPhiCutMax);
1655         printf("\t p_{T,e} > %3.2f\n", fSinglePtCut );
1656         printf("\t TPC refit \n");
1657         printf("\t no kinks \n");
1658         printf("\t accept: %3.2f < n sigma_{e,TPC} < %3.2f\n", fPIDnSigmaBelowElectronLine, fPIDnSigmaAboveElectronLine );
1659         printf("\t reject: %3.2f < p_{e,T} < %3.2f, n sigma_{pi,TPC} < %3.2f\n", fPIDMinPnSigmaAbovePionLine, fPIDMaxPnSigmaAbovePionLine, fPIDnSigmaAbovePionLine );
1660         printf("\t reject: p_{e,T} > %3.2f, n sigma_{pi,TPC} < %3.2f\n", fPIDMaxPnSigmaAbovePionLine, fPIDnSigmaAbovePionLineHighPt );
1661         if (fDoPionRejectionLowP) printf("\t reject: p_{e,T} < %3.2f, -%3.2f < n sigma_{pi,TPC} < %3.2f\n", fPIDMinPPionRejectionLowP, fPIDnSigmaAtLowPAroundPionLine, fPIDnSigmaAtLowPAroundPionLine );
1662         if (fDoKaonRejectionLowP) printf("\t reject: -%3.2f < n sigma_{K,TPC} < %3.2f\n", fPIDnSigmaAtLowPAroundKaonLine, fPIDnSigmaAtLowPAroundKaonLine );
1663         if (fDoProtonRejectionLowP) printf("\t reject: -%3.2f < n sigma_{K,TPC} < %3.2f\n", fPIDnSigmaAtLowPAroundProtonLine, fPIDnSigmaAtLowPAroundProtonLine );
1664         if (fUseTOFpid) printf("\t accept: %3.2f < n sigma_{e,TOF} < %3.2f\n", fTofPIDnSigmaBelowElectronLine, fTofPIDnSigmaAboveElectronLine);
1665
1666         printf("Photon cuts: \n");
1667         if (fUseOnFlyV0Finder) printf("\t using Onfly V0 finder \n");
1668         else printf("\t using Offline V0 finder \n");
1669         if (fDo2DQt){
1670                 printf("\t 2 dimensional q_{T} cut applied with maximum of %3.2f \n", fQtMax );
1671         } else {
1672                 printf("\t 1 dimensional q_{T} cut applied with maximum of %3.2f \n", fQtMax );
1673         }
1674         if (fDo2DPsiPairChi2){
1675                 printf("\t 2 dimensional triangle chi^{2} and psi_{pair} cut applied with maximum of chi^{2} = %3.2f and |psi_{pair}| = %3.2f \n", fChi2CutConversion, fPsiPairCut );
1676         } else {
1677                 printf("\t chi^{2} max cut chi^{2} < %3.2f \n", fChi2CutConversion );
1678                 printf("\t psi_{pair} max cut |psi_{pair}| < %3.2f \n", fPsiPairCut );
1679         }
1680         printf("\t %3.2f < R_{conv} < %3.2f\n", fMinR, fMaxR );
1681         printf("\t Z_{conv} < %3.2f\n", fMaxZ );
1682         if (fEtaCutMin > -0.1) printf("\t %3.2f < eta_{conv} < %3.2f\n", fEtaCutMin, fEtaCut );
1683                 else printf("\t eta_{conv} < %3.2f\n", fEtaCut );
1684         if (fDoPhotonAsymmetryCut) printf("\t for p_{T,track} > %3.2f,  A_{gamma} < %3.2f \n", fMinPPhotonAsymmetryCut, fMinPhotonAsymmetry  );
1685         if (fUseCorrectedTPCClsInfo) printf("\t #cluster TPC/ #findable clusters TPC (corrected for radius) > %3.2f\n", fMinClsTPCToF );
1686         printf("\t p_{T,gamma} > %3.2f\n", fPtCut );
1687         printf("\t cos(Theta_{point}) > %3.2f \n", fCosPAngleCut );
1688         printf("\t dca_{R} < %3.2f \n", fDCARPrimVtxCut );
1689         printf("\t dca_{Z} < %3.2f \n", fDCAZPrimVtxCut );
1690         if (fDoPhotonQualitySelectionCut) printf("\t selection based on photon quality with quality %d \n", fPhotonQualityCut );
1691 }
1692
1693 ///________________________________________________________________________
1694 Bool_t AliConversionPhotonCuts::SetV0Finder(Int_t v0FinderType)
1695 {   // Set Cut
1696         switch (v0FinderType){
1697         case 0:  // on fly V0 finder
1698                 cout << "have chosen onfly V0" << endl;
1699                 fUseOnFlyV0Finder=kTRUE;
1700                 break;
1701         case 1:  // offline V0 finder
1702                 cout << "have chosen offline V0" << endl;
1703                 fUseOnFlyV0Finder=kFALSE;
1704                 break;
1705         default:
1706                 AliError(Form(" v0FinderType not defined %d",v0FinderType));
1707                 return kFALSE;
1708         }
1709         return kTRUE;
1710 }
1711
1712 ///________________________________________________________________________
1713 Bool_t AliConversionPhotonCuts::SetEtaCut(Int_t etaCut)
1714 {   // Set Cut
1715
1716         //Set Standard LineCutZValues
1717         fLineCutZValueMin = -2;
1718         fLineCutZValue = 7.;
1719
1720         switch(etaCut){
1721         case 0: // 0.9
1722                 fEtaCut     = 0.9;
1723                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1724                 fEtaCutMin     = -0.1;
1725                 fLineCutZRSlopeMin = 0.;
1726                 break;
1727         case 1:  // 0.6  // changed from 1.2 to 0.6 on 2013.06.10
1728                 fEtaCut     = 0.6;
1729                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1730                 fEtaCutMin     = -0.1;
1731                 fLineCutZRSlopeMin = 0.;
1732                 break;
1733         case 2:  // 1.4
1734                 fEtaCut     = 1.4;
1735                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1736                 fEtaCutMin     = -0.1;
1737                 fLineCutZRSlopeMin = 0.;
1738                 break;
1739         case 3: // 0.65
1740                 fEtaCut     = 0.65;
1741                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1742                 fEtaCutMin     = -0.1;
1743                 fLineCutZRSlopeMin = 0.;
1744                 break;
1745         case 4: // 0.75
1746                 fEtaCut     = 0.75;
1747                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1748                 fEtaCutMin     = -0.1;
1749                 fLineCutZRSlopeMin = 0.;
1750                 break;
1751         case 5: // 0.5
1752                 fEtaCut     = 0.5;
1753                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1754                 fEtaCutMin     = -0.1;
1755                 fLineCutZRSlopeMin = 0.;
1756                 break;
1757         case 6: // 5.
1758                 fEtaCut     = 5.;
1759                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1760                 fEtaCutMin     = -0.1;
1761                 fLineCutZRSlopeMin = 0.;
1762                 break;
1763         case 7:
1764                 if (fIsHeavyIon==1){
1765                         fEtaCut     = 0.7;
1766                         fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1767                         fEtaCutMin     = -0.1;
1768                         fLineCutZRSlopeMin = 0.;
1769                         break;
1770                 } else {
1771                         fEtaCut     = 0.3;
1772                         fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1773                         fEtaCutMin     = -0.1;
1774                         fLineCutZRSlopeMin = 0.;
1775                         break;
1776                 }
1777         // case 8: // 0.1 - 0.8
1778         //    fEtaCut     = 0.9;
1779         //    fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1780         //    fEtaCutMin     = 0.1;
1781         //    fLineCutZRSlopeMin = tan(2*atan(exp(-fEtaCutMin)));
1782         //    break;
1783         case 8: // 0.4
1784                 fEtaCut     = 0.4;
1785                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1786                 fEtaCutMin     = -0.1;
1787                 fLineCutZRSlopeMin = 0.;
1788                 break;
1789         case 9: // 10
1790                 fEtaCut     = 10;
1791                 fLineCutZRSlope = tan(2*atan(exp(-fEtaCut)));
1792                 fEtaCutMin     = -0.1;
1793                 fLineCutZRSlopeMin = 0.;
1794                 break;
1795         default:
1796                 AliError(Form(" EtaCut not defined %d",etaCut));
1797                 return kFALSE;
1798         }
1799         return kTRUE;
1800 }
1801
1802 ///________________________________________________________________________
1803 Bool_t AliConversionPhotonCuts::SetRCut(Int_t RCut){
1804         // Set Cut
1805         switch(RCut){
1806         case 0:
1807                 fMinR=0;
1808                 fMaxR = 180.;
1809                 break;
1810         case 1:
1811                 fMinR=2.8;
1812                 fMaxR = 180.;
1813                 break;
1814         case 2:
1815                 fMinR=5.;
1816                 fMaxR = 180.;
1817                 break;
1818         case 3:
1819                 fMaxR = 70.;
1820                 fMinR = 10.;
1821                 break;
1822         case 4:
1823                 fMaxR = 70.;
1824                 fMinR = 5.;
1825                 break;
1826         case 5:
1827                 fMaxR = 180.;
1828                 fMinR = 10.;
1829                 break;
1830         case 6:
1831                 fMaxR = 180.;
1832                 fMinR = 20.;
1833                 break;
1834         case 7:
1835                 fMaxR = 180.;
1836                 fMinR = 35.; //old 26.
1837                 break;
1838         case 8:
1839                 fMaxR = 180.;
1840                 fMinR = 12.5;
1841                 break;
1842         case 9:
1843                 fMaxR = 180.;
1844                 fMinR = 7.5;
1845                 break;
1846
1847         default:
1848                 AliError("RCut not defined");
1849                 return kFALSE;
1850         }
1851         return kTRUE;
1852 }
1853
1854 ///________________________________________________________________________
1855 Bool_t AliConversionPhotonCuts::SetEtaForPhiCut(Int_t etaPhiCut) {
1856
1857         switch(etaPhiCut) {
1858         case 0: //no specific eta range selected, full eta range
1859                 fEtaForPhiCutMin = -fEtaCut;
1860                 fEtaForPhiCutMax = fEtaCut;
1861                 break;
1862         case 1:  //eta < 0 only
1863                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1864                 fEtaForPhiCutMin = -fEtaCut;
1865                 fEtaForPhiCutMax = 0.;
1866                 break;
1867         case 2://eta > 0 only
1868                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1869                 fEtaForPhiCutMin = 0.;
1870                 fEtaForPhiCutMax = fEtaCut;
1871                 break;
1872         default:
1873                 AliError(Form("EtaForPhiCut not defined %d",etaPhiCut));
1874                 return kFALSE;
1875         }
1876
1877         return kTRUE;
1878 }
1879
1880 ///________________________________________________________________________
1881 // This are exclusion cuts, everything between fMinPhiCut & fMaxPhiCut will be excluded
1882 Bool_t AliConversionPhotonCuts::SetMinPhiSectorCut(Int_t minPhiCut) {
1883
1884         switch(minPhiCut) {
1885         case 0:
1886                 fDoShrinkTPCAcceptance = kFALSE;
1887                 fMinPhiCut = 0;
1888                 break;
1889         case 1:
1890                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1891                 fMinPhiCut = 1.7; //OROC C08
1892                 break;
1893         case 2:
1894                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1895                 fMinPhiCut = 4.4; //EMCal
1896                 break;
1897         case 3:
1898                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1899                 fMinPhiCut = 1.0; //PHOS
1900                 break;
1901         case 4:
1902                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1903                 fMinPhiCut = 3.4; //EMCal tight
1904                 break;
1905
1906         default:
1907                 AliError(Form("MinPhiCut not defined %d",minPhiCut));
1908                 return kFALSE;
1909         }
1910
1911         return kTRUE;
1912 }
1913
1914 ///________________________________________________________________________
1915 // This are exclusion cuts, everything between fMinPhiCut & fMaxPhiCut will be excluded
1916 Bool_t AliConversionPhotonCuts::SetMaxPhiSectorCut(Int_t maxPhiCut) {
1917
1918         switch(maxPhiCut) {
1919         case 0:
1920                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kFALSE;
1921                 fMaxPhiCut = 2*TMath::Pi()+0.00001;
1922                 break;
1923         case 1:
1924                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1925                 fMaxPhiCut = 4.3; //OROC C08
1926                 break;
1927         case 2:
1928                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1929                 fMaxPhiCut = 5.8; //EMCal
1930                 break;
1931         case 3:
1932                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1933                 fMaxPhiCut = 3.0; //PHOS
1934                 break;
1935         case 4:
1936                 if (!fDoShrinkTPCAcceptance) fDoShrinkTPCAcceptance = kTRUE;
1937                 fMaxPhiCut = 1.; //EMCal
1938                 break;
1939
1940         default:
1941                 AliError(Form("MaxPhiCut not defined %d",maxPhiCut));
1942                 return kFALSE;
1943         }
1944
1945         return kTRUE;
1946 }
1947
1948
1949 ///________________________________________________________________________
1950 Bool_t AliConversionPhotonCuts::SetSinglePtCut(Int_t singlePtCut)
1951 {   // Set Cut
1952         switch(singlePtCut){
1953         case 0: // 0.050 GeV
1954                 fSinglePtCut = 0.050;
1955                 break;
1956         case 1:  // 0.100 GeV
1957                 fSinglePtCut = 0.100;
1958                 break;
1959         case 2:  // 0.150 GeV
1960                 fSinglePtCut = 0.150;
1961                 break;
1962         case 3:  // 0.200 GeV
1963                 fSinglePtCut = 0.200;
1964                 break;
1965         case 4:  // 0.075 GeV
1966                 fSinglePtCut = 0.075;
1967                 break;
1968         case 5:  // 0.125 GeV
1969                 fSinglePtCut = 0.125;
1970                 break;
1971         case 6:  // 0.04 GeV
1972                 fSinglePtCut = 0.040;
1973                 break;
1974         case 7:  // 0.0 GeV
1975                 fSinglePtCut = 0.0;
1976                 break;
1977         default:
1978                 AliError(Form("singlePtCut not defined %d",singlePtCut));
1979                 return kFALSE;
1980         }
1981         return kTRUE;
1982 }
1983
1984 ///________________________________________________________________________
1985 Bool_t AliConversionPhotonCuts::SetTPCClusterCut(Int_t clsTPCCut)
1986 {   // Set Cut
1987         switch(clsTPCCut){
1988         case 0: // 0
1989                 fMinClsTPC= 0.;
1990                 break;
1991         case 1:  // 60
1992                 fMinClsTPC= 60.;
1993                 break;
1994         case 2:  // 80
1995                 fMinClsTPC= 80.;
1996                 break;
1997         case 3:  // 100
1998                 fMinClsTPC= 100.;
1999                 break;
2000         case 4:  // 95% of findable clusters
2001                 fMinClsTPCToF= 0.95;
2002                 fUseCorrectedTPCClsInfo=1;
2003                 break;
2004         case 5:  // 0% of findable clusters
2005                 fMinClsTPCToF= 0.0;
2006                 fUseCorrectedTPCClsInfo=1;
2007                 break;
2008         case 6:  // 70% of findable clusters
2009                 fMinClsTPCToF= 0.7;
2010                 fUseCorrectedTPCClsInfo=1;
2011                 break;
2012         case 7:  // 0% of findable clusters
2013                 fMinClsTPCToF= 0.35;
2014                 fUseCorrectedTPCClsInfo=0;
2015                 break;
2016         case 8:
2017                 fMinClsTPCToF= 0.35;
2018                 fUseCorrectedTPCClsInfo=1;
2019                 break;
2020         case 9:
2021                 fMinClsTPCToF= 0.6;
2022                 fUseCorrectedTPCClsInfo=1;
2023                 break;
2024         default:
2025                 AliError(Form("Warning: clsTPCCut not defined %d",clsTPCCut));
2026                 return kFALSE;
2027         }
2028         return kTRUE;
2029 }
2030
2031 ///________________________________________________________________________
2032 Bool_t AliConversionPhotonCuts::SetTPCdEdxCutElectronLine(Int_t ededxSigmaCut)
2033 {   // Set Cut
2034         switch(ededxSigmaCut){
2035         case 0: // -10,10
2036                 fPIDnSigmaBelowElectronLine=-10;
2037                 fPIDnSigmaAboveElectronLine=10;
2038                 break;
2039         case 1: // -5,5
2040                 fPIDnSigmaBelowElectronLine=-5;
2041                 fPIDnSigmaAboveElectronLine=5;
2042                 break;
2043         case 2: // -3,5
2044                 fPIDnSigmaBelowElectronLine=-3;
2045                 fPIDnSigmaAboveElectronLine=5;
2046                 break;
2047         case 3: // -4,5
2048                 fPIDnSigmaBelowElectronLine=-4;
2049                 fPIDnSigmaAboveElectronLine=5;
2050                 break;
2051         case 4: // -6,7
2052                 fPIDnSigmaBelowElectronLine=-6;
2053                 fPIDnSigmaAboveElectronLine=7;
2054                 break;
2055         case 5: // -4,4
2056                 fPIDnSigmaBelowElectronLine=-4;
2057                 fPIDnSigmaAboveElectronLine=4;
2058                 break;
2059         case 6: // -2.5,4
2060                 fPIDnSigmaBelowElectronLine=-2.5;
2061                 fPIDnSigmaAboveElectronLine=4;
2062                 break;
2063         case 7: // -2,3.5
2064                 fPIDnSigmaBelowElectronLine=-2;
2065                 fPIDnSigmaAboveElectronLine=3.5;
2066                 break;
2067         default:
2068                 AliError("TPCdEdxCutElectronLine not defined");
2069                 return kFALSE;
2070
2071         }
2072         return kTRUE;
2073 }
2074
2075 ///________________________________________________________________________
2076 Bool_t AliConversionPhotonCuts::SetTPCdEdxCutPionLine(Int_t pidedxSigmaCut)
2077 {   // Set Cut
2078
2079         switch(pidedxSigmaCut){
2080         case 0:  // -10
2081                 fPIDnSigmaAbovePionLine=-10;
2082                 fPIDnSigmaAbovePionLineHighPt=-10;
2083                 break;
2084         case 1:   // 0
2085                 fPIDnSigmaAbovePionLine=0;
2086                 fPIDnSigmaAbovePionLineHighPt=-10;
2087                 break;
2088         case 2:  // 1
2089                 fPIDnSigmaAbovePionLine=1;
2090                 fPIDnSigmaAbovePionLineHighPt=-10;
2091                 break;
2092         case 3:  // 1
2093                 fPIDnSigmaAbovePionLine=2.5;
2094                 fPIDnSigmaAbovePionLineHighPt=-10;
2095                 break;
2096         case 4:  // 1
2097                 fPIDnSigmaAbovePionLine=0.5;
2098                 fPIDnSigmaAbovePionLineHighPt=-10;
2099                 break;
2100         case 5:  // 1
2101                 fPIDnSigmaAbovePionLine=2.;
2102                 fPIDnSigmaAbovePionLineHighPt=-10;
2103                 break;
2104         case 6:  // 1
2105                 fPIDnSigmaAbovePionLine=2.;
2106                 fPIDnSigmaAbovePionLineHighPt=0.5;
2107                 break;
2108         case 7:  // 1
2109                 fPIDnSigmaAbovePionLine=3.5;
2110                 fPIDnSigmaAbovePionLineHighPt=-10;
2111                 break;
2112         case 8:  // 1
2113                 fPIDnSigmaAbovePionLine=2.;
2114                 fPIDnSigmaAbovePionLineHighPt=1.;
2115                 break;
2116         case 9:
2117                 fPIDnSigmaAbovePionLine=3.0; // We need a bit less tight cut on dE/dx
2118                 fPIDnSigmaAbovePionLineHighPt=-10;
2119                 break;
2120         default:
2121                 AliError(Form("Warning: pidedxSigmaCut not defined %d",pidedxSigmaCut));
2122                 return kFALSE;
2123         }
2124         return kTRUE;
2125 }
2126
2127 ///________________________________________________________________________
2128 Bool_t AliConversionPhotonCuts::SetMinMomPiondEdxCut(Int_t piMomdedxSigmaCut)
2129 {   // Set Cut
2130         switch(piMomdedxSigmaCut){
2131         case 0:  // 0.5 GeV
2132                 fPIDMinPnSigmaAbovePionLine=0.5;
2133                 break;
2134         case 1:  // 1. GeV
2135                 fPIDMinPnSigmaAbovePionLine=1.;
2136                 break;
2137         case 2:  // 1.5 GeV
2138                 fPIDMinPnSigmaAbovePionLine=1.5;
2139                 break;
2140         case 3:  // 20.0 GeV
2141                 fPIDMinPnSigmaAbovePionLine=20.;
2142                 break;
2143         case 4:  // 50.0 GeV
2144                 fPIDMinPnSigmaAbovePionLine=50.;
2145                 break;
2146         case 5:  // 0.3 GeV
2147                 fPIDMinPnSigmaAbovePionLine=0.3;
2148                 break;
2149         case 6:  // 0.25 GeV
2150                 fPIDMinPnSigmaAbovePionLine=0.25;
2151                 break;
2152         case 7:  // 0.4 GeV
2153                 fPIDMinPnSigmaAbovePionLine=0.4;
2154                 break;
2155         case 8:  // 0.2 GeV
2156                 fPIDMinPnSigmaAbovePionLine=0.2;
2157                 break;
2158         default:
2159                 AliError(Form("piMomdedxSigmaCut not defined %d",piMomdedxSigmaCut));
2160                 return kFALSE;
2161         }
2162         return kTRUE;
2163 }
2164
2165 ///________________________________________________________________________
2166 Bool_t AliConversionPhotonCuts::SetMaxMomPiondEdxCut(Int_t piMaxMomdedxSigmaCut)
2167 {   // Set Cut
2168         switch(piMaxMomdedxSigmaCut){
2169         case 0:  // 100. GeV
2170                 fPIDMaxPnSigmaAbovePionLine=100.;
2171                 break;
2172         case 1:  // 5. GeV
2173                 fPIDMaxPnSigmaAbovePionLine=5.;
2174                 break;
2175         case 2:  // 4. GeV
2176                 fPIDMaxPnSigmaAbovePionLine=4.;
2177                 break;
2178         case 3:  // 3.5 GeV
2179                 fPIDMaxPnSigmaAbovePionLine=3.5;
2180                 break;
2181         case 4:  // 3. GeV
2182                 fPIDMaxPnSigmaAbovePionLine=3.;
2183                 break;
2184         case 5:  // 7. GeV
2185                 fPIDMaxPnSigmaAbovePionLine=7.;
2186                 break;
2187         default:
2188                 AliError(Form("piMaxMomdedxSigmaCut not defined %d",piMaxMomdedxSigmaCut));
2189                 return kFALSE;
2190         }
2191         return kTRUE;
2192 }
2193
2194 ///________________________________________________________________________
2195 Bool_t AliConversionPhotonCuts::SetLowPRejectionCuts(Int_t LowPRejectionSigmaCut)
2196 {   // Set Cut
2197         switch(LowPRejectionSigmaCut){
2198         case 0:  //
2199                 fPIDnSigmaAtLowPAroundKaonLine=0;
2200                 fPIDnSigmaAtLowPAroundProtonLine=0;
2201                 fPIDnSigmaAtLowPAroundPionLine=0;
2202                 fDoKaonRejectionLowP = kFALSE;
2203                 fDoProtonRejectionLowP = kFALSE;
2204                 fDoPionRejectionLowP = kFALSE;
2205                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2206                 break;
2207         case 1:  //
2208                 fPIDnSigmaAtLowPAroundKaonLine=0.5;
2209                 fPIDnSigmaAtLowPAroundProtonLine=0.5;
2210                 fPIDnSigmaAtLowPAroundPionLine=0.5;
2211                 fDoKaonRejectionLowP = kTRUE;
2212                 fDoProtonRejectionLowP = kTRUE;
2213                 fDoPionRejectionLowP = kTRUE;
2214                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2215                 break;
2216         case 2:  //
2217                 fPIDnSigmaAtLowPAroundKaonLine=1;
2218                 fPIDnSigmaAtLowPAroundProtonLine=1;
2219                 fPIDnSigmaAtLowPAroundPionLine=1;
2220                 fDoKaonRejectionLowP = kTRUE;
2221                 fDoProtonRejectionLowP = kTRUE;
2222                 fDoPionRejectionLowP = kTRUE;
2223                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2224                 break;
2225         case 3:  //
2226                 fPIDnSigmaAtLowPAroundKaonLine=2.;
2227                 fPIDnSigmaAtLowPAroundProtonLine=2.;
2228                 fPIDnSigmaAtLowPAroundPionLine=2.;
2229                 fDoKaonRejectionLowP = kTRUE;
2230                 fDoProtonRejectionLowP = kTRUE;
2231                 fDoPionRejectionLowP = kTRUE;
2232                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2233                 break;
2234         case 4:  //
2235                 fPIDnSigmaAtLowPAroundKaonLine=0.;
2236                 fPIDnSigmaAtLowPAroundProtonLine=0.;
2237                 fPIDnSigmaAtLowPAroundPionLine=1;
2238                 fDoKaonRejectionLowP = kFALSE;
2239                 fDoProtonRejectionLowP = kFALSE;
2240                 fDoPionRejectionLowP = kTRUE;
2241                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2242                 break;
2243         case 5:  //
2244                 fPIDnSigmaAtLowPAroundKaonLine=0.;
2245                 fPIDnSigmaAtLowPAroundProtonLine=0.;
2246                 fPIDnSigmaAtLowPAroundPionLine=1.5;
2247                 fDoKaonRejectionLowP = kFALSE;
2248                 fDoProtonRejectionLowP = kFALSE;
2249                 fDoPionRejectionLowP = kTRUE;
2250                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2251                 break;
2252         case 6:  //
2253                 fPIDnSigmaAtLowPAroundKaonLine=0.;
2254                 fPIDnSigmaAtLowPAroundProtonLine=0.;
2255                 fPIDnSigmaAtLowPAroundPionLine=2.;
2256                 fDoKaonRejectionLowP = kFALSE;
2257                 fDoProtonRejectionLowP = kFALSE;
2258                 fDoPionRejectionLowP = kTRUE;
2259                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2260                 break;
2261         case 7:  //
2262                 fPIDnSigmaAtLowPAroundKaonLine=0.;
2263                 fPIDnSigmaAtLowPAroundProtonLine=0.;
2264                 fPIDnSigmaAtLowPAroundPionLine=0.5;
2265                 fDoKaonRejectionLowP = kFALSE;
2266                 fDoProtonRejectionLowP = kFALSE;
2267                 fDoPionRejectionLowP = kTRUE;
2268                 fPIDMinPPionRejectionLowP = fPIDMinPnSigmaAbovePionLine;
2269                 break;
2270         default:
2271                 AliError(Form("LowPRejectionSigmaCut not defined %d",LowPRejectionSigmaCut));
2272                 return kFALSE;
2273         }
2274         return kTRUE;
2275 }
2276
2277 ///________________________________________________________________________
2278 Bool_t AliConversionPhotonCuts::SetTOFElectronPIDCut(Int_t TOFelectronPID){
2279    // Set Cut
2280         switch(TOFelectronPID){
2281         case 0: // no cut
2282                 fUseTOFpid = kFALSE;
2283                 fTofPIDnSigmaBelowElectronLine=-100;
2284                 fTofPIDnSigmaAboveElectronLine=100;
2285                 break;
2286         case 1: // -7,7
2287                 fUseTOFpid = kTRUE;
2288                 fTofPIDnSigmaBelowElectronLine=-7;
2289                 fTofPIDnSigmaAboveElectronLine=7;
2290                 break;
2291         case 2: // -5,5
2292                 fUseTOFpid = kTRUE;
2293                 fTofPIDnSigmaBelowElectronLine=-5;
2294                 fTofPIDnSigmaAboveElectronLine=5;
2295                 break;
2296         case 3: // -3,5
2297                 fUseTOFpid = kTRUE;
2298                 fTofPIDnSigmaBelowElectronLine=-3;
2299                 fTofPIDnSigmaAboveElectronLine=5;
2300                 break;
2301         case 4: // -2,3
2302                 fUseTOFpid = kTRUE;
2303                 fTofPIDnSigmaBelowElectronLine=-2;
2304                 fTofPIDnSigmaAboveElectronLine=3;
2305                 break;
2306         case 5: // -3,3
2307                 fUseTOFpid = kTRUE;
2308                 fTofPIDnSigmaBelowElectronLine=-3;
2309                 fTofPIDnSigmaAboveElectronLine=3;
2310                 break;
2311         default:
2312                 AliError(Form("TOFElectronCut not defined %d",TOFelectronPID));
2313                 return kFALSE;
2314         }
2315         return kTRUE;
2316 }
2317
2318 ///________________________________________________________________________
2319 Bool_t AliConversionPhotonCuts::SetQtMaxCut(Int_t QtMaxCut)
2320 {   // Set Cut
2321         switch(QtMaxCut){
2322         case 0: //
2323                 fQtMax=1.;
2324                 fDoQtGammaSelection=kFALSE;
2325                 fDo2DQt=kFALSE;
2326                 break;
2327         case 1:
2328                 fQtMax=0.1;
2329                 fDo2DQt=kFALSE;
2330                 break;
2331         case 2:
2332                 fQtMax=0.07;
2333                 fDo2DQt=kFALSE;
2334                 break;
2335         case 3:
2336                 fQtMax=0.05;
2337                 fDo2DQt=kFALSE;
2338                 break;
2339         case 4:
2340                 fQtMax=0.03;
2341                 fDo2DQt=kFALSE;
2342                 break;
2343         case 5:
2344                 fQtMax=0.02;
2345                 fDo2DQt=kFALSE;
2346                 break;
2347         case 6:
2348                 fQtMax=0.02;
2349                 fDo2DQt=kTRUE;
2350                 break;
2351         case 7:
2352                 fQtMax=0.15;
2353                 fDo2DQt=kFALSE;
2354                 break;
2355         case 8:
2356                 fQtMax=0.05;
2357                 fDo2DQt=kTRUE;
2358                 break;
2359         case 9:
2360                 fQtMax=0.03;
2361                 fDo2DQt=kTRUE;
2362                 break;
2363         default:
2364                 AliError(Form("Warning: QtMaxCut not defined %d",QtMaxCut));
2365                 return kFALSE;
2366         }
2367         return kTRUE;
2368 }
2369
2370 ///________________________________________________________________________
2371 Bool_t AliConversionPhotonCuts::SetChi2GammaCut(Int_t chi2GammaCut)
2372 {   // Set Cut
2373
2374         switch(chi2GammaCut){
2375         case 0: // 100
2376                 fChi2CutConversion = 100.;
2377                 break;
2378         case 1:  // 50
2379                 fChi2CutConversion = 50.;
2380                 break;
2381         case 2:  // 30
2382                 fChi2CutConversion = 30.;
2383                 break;
2384         case 3:
2385                 fChi2CutConversion = 200.;
2386                 break;
2387         case 4:
2388                 fChi2CutConversion = 500.;
2389                 break;
2390         case 5:
2391                 fChi2CutConversion = 100000.;
2392                 break;
2393         case 6:
2394                 fChi2CutConversion = 5.;
2395                 break;
2396         case 7:
2397                 fChi2CutConversion = 10.;
2398                 break;
2399         case 8:
2400                 fChi2CutConversion = 20.;
2401                 break;
2402         case 9:
2403                 fChi2CutConversion = 15.;
2404                 break;
2405         default:
2406                 AliError(Form("Warning: Chi2GammaCut not defined %d",chi2GammaCut));
2407                 return kFALSE;
2408         }
2409         return kTRUE;
2410 }
2411
2412 ///________________________________________________________________________
2413 Bool_t AliConversionPhotonCuts::SetPsiPairCut(Int_t psiCut) {
2414
2415         switch(psiCut) {
2416         case 0:
2417                 fPsiPairCut = 10000; //
2418                 break;
2419         case 1:
2420                 fPsiPairCut = 0.1; //
2421                 break;
2422         case 2:
2423                 fPsiPairCut = 0.05; // Standard
2424                 break;
2425         case 3:
2426                 fPsiPairCut = 0.035; //
2427                 break;
2428         case 4:
2429                 fPsiPairCut = 0.2; //
2430                 break;
2431         case 5:
2432                 fPsiPairCut = 0.1; //
2433                 fDo2DPsiPairChi2 = kTRUE;
2434                 break;
2435         case 6:
2436                 fPsiPairCut = 0.05; //
2437                 fDo2DPsiPairChi2 = kTRUE;
2438                 break;
2439         case 7:
2440                 fPsiPairCut = 0.035; //
2441                 fDo2DPsiPairChi2 = kTRUE;
2442                 break;
2443         case 8:
2444                 fPsiPairCut = 0.2; //
2445                 fDo2DPsiPairChi2 = kTRUE; //
2446                 break;
2447         case 9:
2448                 fPsiPairCut = 0.5; //
2449                 break;
2450         default:
2451                 AliError(Form("PsiPairCut not defined %d",psiCut));
2452                 return kFALSE;
2453         }
2454
2455         return kTRUE;
2456 }
2457
2458 ///________________________________________________________________________
2459 Bool_t AliConversionPhotonCuts::SetPhotonAsymmetryCut(Int_t doPhotonAsymmetryCut){
2460    // Set Cut
2461         switch(doPhotonAsymmetryCut){
2462         case 0:
2463                 fDoPhotonAsymmetryCut=0;
2464                 fMinPPhotonAsymmetryCut=100.;
2465                 fMinPhotonAsymmetry=0.;
2466                 break;
2467         case 1:
2468                 fDoPhotonAsymmetryCut=1;
2469                 fMinPPhotonAsymmetryCut=3.5;
2470                 fMinPhotonAsymmetry=0.04;
2471                 break;
2472         case 2:
2473                 fDoPhotonAsymmetryCut=1;
2474                 fMinPPhotonAsymmetryCut=3.5;
2475                 fMinPhotonAsymmetry=0.06;
2476                 break;
2477         case 3:
2478                 fDoPhotonAsymmetryCut=1;
2479                 fMinPPhotonAsymmetryCut=0.0;
2480                 fMinPhotonAsymmetry=0.05;
2481                 break;
2482         default:
2483                 AliError(Form("PhotonAsymmetryCut not defined %d",doPhotonAsymmetryCut));
2484                 return kFALSE;
2485         }
2486         fCuts[kdoPhotonAsymmetryCut]=doPhotonAsymmetryCut;
2487         return kTRUE;
2488 }
2489
2490 ///________________________________________________________________________
2491 Bool_t AliConversionPhotonCuts::SetCosPAngleCut(Int_t cosCut) {
2492
2493         switch(cosCut){
2494         case 0:
2495                 fCosPAngleCut = -1;
2496                 break;
2497         case 1:
2498                 fCosPAngleCut = 0;
2499                 break;
2500         case 2:
2501                 fCosPAngleCut = 0.5;
2502                 break;
2503         case 3:
2504                 fCosPAngleCut = 0.75;
2505                 break;
2506         case 4:
2507                 fCosPAngleCut = 0.85;
2508                 break;
2509         case 5:
2510                 fCosPAngleCut = 0.88;
2511                 break;
2512         case 6:
2513                 fCosPAngleCut = 0.9;
2514                 break;
2515         case 7:
2516                 fCosPAngleCut = 0.95;
2517                 break;
2518         default:
2519                 AliError(Form("Cosine Pointing Angle cut not defined %d",cosCut));
2520                 return kFALSE;
2521         }
2522
2523         return kTRUE;
2524 }
2525
2526 ///________________________________________________________________________
2527 Bool_t AliConversionPhotonCuts::SetSharedElectronCut(Int_t sharedElec) {
2528
2529                 switch(sharedElec){
2530                 case 0:
2531                         fDoSharedElecCut = kFALSE;
2532                         fDoPhotonQualitySelectionCut = kFALSE;
2533                         fPhotonQualityCut = 0;
2534                         break;
2535                 case 1:
2536                         fDoSharedElecCut = kTRUE;
2537                         fDoPhotonQualitySelectionCut = kFALSE;
2538                         fPhotonQualityCut = 0;
2539                         break;
2540                 case 2:
2541                         fDoSharedElecCut = kFALSE;
2542                         fDoPhotonQualitySelectionCut = kTRUE;
2543                         fPhotonQualityCut = 1;
2544                         break;
2545                 case 3:
2546                         fDoSharedElecCut = kFALSE;
2547                         fDoPhotonQualitySelectionCut = kTRUE;
2548                         fPhotonQualityCut = 2;
2549                         break;
2550                 case 4:
2551                         fDoSharedElecCut = kFALSE;
2552                         fDoPhotonQualitySelectionCut = kTRUE;
2553                         fPhotonQualityCut = 3;
2554                         break;
2555                 default:
2556                         AliError(Form("Shared Electron Cut not defined %d",sharedElec));
2557                         return kFALSE;
2558         }
2559
2560         return kTRUE;
2561 }
2562
2563 ///________________________________________________________________________
2564 Bool_t AliConversionPhotonCuts::SetToCloseV0sCut(Int_t toClose) {
2565
2566         switch(toClose){
2567         case 0:
2568                 fDoToCloseV0sCut = kFALSE;
2569                 fminV0Dist = 250;
2570                 break;
2571         case 1:
2572                 fDoToCloseV0sCut = kTRUE;
2573                 fminV0Dist = 1;
2574                 break;
2575         case 2:
2576                 fDoToCloseV0sCut = kTRUE;
2577                 fminV0Dist = 2;
2578                 break;
2579         case 3:
2580                 fDoToCloseV0sCut = kTRUE;
2581                 fminV0Dist = 3;
2582                 break;
2583         default:
2584                 AliError(Form("Shared Electron Cut not defined %d",toClose));
2585                 return kFALSE;
2586         }
2587         return kTRUE;
2588 }
2589
2590 ///________________________________________________________________________
2591 Bool_t AliConversionPhotonCuts::SetTRDElectronCut(Int_t TRDElectronCut)
2592 {   // Set Cut
2593         switch(TRDElectronCut){
2594         case 0:
2595                 fDoTRDPID=kFALSE;
2596                 break;
2597         case 1:
2598                 fDoTRDPID=kTRUE;
2599                 fPIDTRDEfficiency=0.1;
2600                 break;
2601         case 8:
2602                 fDoTRDPID=kTRUE;
2603                 fPIDTRDEfficiency=0.8;
2604                 break;
2605         case 9:
2606                 fDoTRDPID=kTRUE;
2607                 fPIDTRDEfficiency=0.9;
2608                 break;
2609         default:
2610                 AliError(Form("TRDElectronCut not defined %d",TRDElectronCut));
2611                 return kFALSE;
2612         }
2613
2614         return kTRUE;
2615 }
2616
2617 ///________________________________________________________________________
2618 Bool_t AliConversionPhotonCuts::SetDCAZPhotonPrimVtxCut(Int_t DCAZPhotonPrimVtx){
2619    // Set Cut
2620         switch(DCAZPhotonPrimVtx){
2621         case 0:  //
2622                 fDCAZPrimVtxCut   = 1000;
2623                 break;
2624         case 1:  //
2625                 fDCAZPrimVtxCut   = 10;
2626                 break;
2627         case 2:  //
2628                 fDCAZPrimVtxCut   = 5;
2629                 break;
2630         case 3:  //
2631                 fDCAZPrimVtxCut   = 4;
2632                 break;
2633         case 4:  //
2634                 fDCAZPrimVtxCut   = 3;
2635                 break;
2636         case 5:  //
2637                 fDCAZPrimVtxCut   = 2.5;
2638                 break;
2639         case 6:  //
2640                 fDCAZPrimVtxCut   = 2;
2641                 break;
2642         case 7:  //
2643                 fDCAZPrimVtxCut   = 1.5;
2644                 break;
2645         case 8:  //
2646                 fDCAZPrimVtxCut   = 1;
2647                 break;
2648         case 9:  //
2649                 fDCAZPrimVtxCut   = 0.5;
2650                 break;
2651         default:
2652                 cout<<"Warning: DCAZPhotonPrimVtx not defined "<<DCAZPhotonPrimVtx<<endl;
2653                 return kFALSE;
2654         }
2655         return kTRUE;
2656 }
2657
2658 ///________________________________________________________________________
2659 Bool_t AliConversionPhotonCuts::SetDCARPhotonPrimVtxCut(Int_t DCARPhotonPrimVtx){
2660    // Set Cut
2661         switch(DCARPhotonPrimVtx){
2662         case 0:  //
2663                 fDCARPrimVtxCut   = 1000;
2664                 break;
2665         case 1:  //
2666                 fDCARPrimVtxCut   = 10;
2667                 break;
2668         case 2:  //
2669                 fDCARPrimVtxCut   = 5;
2670                 break;
2671         case 3:  //
2672                 fDCARPrimVtxCut   = 4;
2673                 break;
2674         case 4:  //
2675                 fDCARPrimVtxCut   = 3;
2676                 break;
2677         case 5:  //
2678                 fDCARPrimVtxCut   = 2.5;
2679                 break;
2680         case 6:  //
2681                 fDCARPrimVtxCut   = 2;
2682                 break;
2683         case 7:  //
2684                 fDCARPrimVtxCut   = 1.5;
2685                 break;
2686         case 8:  //
2687                 fDCARPrimVtxCut   = 1;
2688                 break;
2689         case 9:  //
2690                 fDCARPrimVtxCut   = 0.5;
2691                 break;
2692         default:
2693                 cout<<"Warning: DCARPhotonPrimVtx not defined "<<DCARPhotonPrimVtx<<endl;
2694                 return kFALSE;
2695         }
2696         return kTRUE;
2697 }
2698
2699 ///________________________________________________________________________
2700 Bool_t AliConversionPhotonCuts::SetInPlaneOutOfPlane(Int_t inOutPlane){
2701         // Set Cut
2702         switch(inOutPlane){
2703         case 0:  //
2704                 fInPlaneOutOfPlane = 0; // No Event Plane
2705                 break;
2706         case 1:  //
2707                 fInPlaneOutOfPlane = 1; // In-Plane
2708                 break;
2709         case 2:  //
2710                 fInPlaneOutOfPlane = 2; // Out-Of-Plane
2711                 break;
2712         default:
2713                 cout<<"Warning: In-Plane or Out-Of-Plane not defined "<<inOutPlane<<endl;
2714                 return kFALSE;
2715         }
2716         return kTRUE;
2717 }
2718
2719
2720 ///________________________________________________________________________
2721 Int_t AliConversionPhotonCuts::GetFirstTPCRow(Double_t radius){
2722         // Get first TPC row
2723         Int_t firstTPCRow = 0;
2724         Double_t radiusI = 84.8;
2725         Double_t radiusO = 134.6;
2726         Double_t radiusOB = 198.;
2727         Double_t rSizeI = 0.75;
2728         Double_t rSizeO = 1.;
2729         Double_t rSizeOB = 1.5;
2730         Int_t nClsI = 63;
2731         Int_t nClsIO = 127;
2732
2733         if(radius <= radiusI){
2734                 return firstTPCRow;
2735         }
2736         if(radius>radiusI && radius<=radiusO){
2737                 firstTPCRow = (Int_t)((radius-radiusI)/rSizeI);
2738         }
2739         if(radius>radiusO && radius<=radiusOB){
2740                 firstTPCRow = (Int_t)(nClsI+(radius-radiusO)/rSizeO);
2741         }
2742
2743         if(radius>radiusOB){
2744                 firstTPCRow =(Int_t)(nClsIO+(radius-radiusOB)/rSizeOB);
2745         }
2746
2747         return firstTPCRow;
2748 }
2749
2750 ///________________________________________________________________________
2751 Bool_t AliConversionPhotonCuts::CosinePAngleCut(const AliConversionPhotonBase * photon, AliVEvent * event) const {
2752         ///Check if passes cosine of pointing angle cut
2753         if(GetCosineOfPointingAngle(photon, event) < fCosPAngleCut){
2754                 return kFALSE;
2755         }
2756         return kTRUE;
2757 }
2758
2759 ///________________________________________________________________________
2760 Double_t AliConversionPhotonCuts::GetCosineOfPointingAngle( const AliConversionPhotonBase * photon, AliVEvent * event) const{
2761         // calculates the pointing angle of the recalculated V0
2762
2763         Double_t momV0[3] = {0,0,0};
2764         if(event->IsA()==AliESDEvent::Class()){
2765                 AliESDEvent *esdEvent = dynamic_cast<AliESDEvent*>(event);
2766                 if(!esdEvent) return -999;
2767                 AliESDv0 *v0 = esdEvent->GetV0(photon->GetV0Index());
2768                 if(!v0) return -999;
2769                 v0->GetPxPyPz(momV0[0],momV0[1],momV0[2]);
2770         }
2771         if(event->IsA()==AliAODEvent::Class()){
2772                 momV0[0] = photon->GetPx();
2773                 momV0[1] = photon->GetPy();
2774                 momV0[2] = photon->GetPz();
2775         }
2776
2777         //Double_t momV0[3] = { photon->GetPx(), photon->GetPy(), photon->GetPz() }; //momentum of the V0
2778         Double_t PosV0[3] = { photon->GetConversionX() - event->GetPrimaryVertex()->GetX(),
2779                                                         photon->GetConversionY() - event->GetPrimaryVertex()->GetY(),
2780                                                         photon->GetConversionZ() - event->GetPrimaryVertex()->GetZ() }; //Recalculated V0 Position vector
2781
2782         Double_t momV02 = momV0[0]*momV0[0] + momV0[1]*momV0[1] + momV0[2]*momV0[2];
2783         Double_t PosV02 = PosV0[0]*PosV0[0] + PosV0[1]*PosV0[1] + PosV0[2]*PosV0[2];
2784
2785
2786         Double_t cosinePointingAngle = -999;
2787         if(momV02*PosV02 > 0.0)
2788                 cosinePointingAngle = (PosV0[0]*momV0[0] +  PosV0[1]*momV0[1] + PosV0[2]*momV0[2] ) / TMath::Sqrt(momV02 * PosV02);
2789
2790         return cosinePointingAngle;
2791 }
2792
2793 ///________________________________________________________________________
2794 Bool_t AliConversionPhotonCuts::PsiPairCut(const AliConversionPhotonBase * photon) const {
2795
2796         if (fDo2DPsiPairChi2){
2797                 if (abs(photon->GetPsiPair()) < -fPsiPairCut/fChi2CutConversion*photon->GetChi2perNDF() + fPsiPairCut ){
2798                         return kTRUE;
2799                 } else {
2800                         return kFALSE;
2801                 }
2802         } else {
2803                 if(abs(photon->GetPsiPair()) > fPsiPairCut){
2804                         return kFALSE;}
2805                 else{return kTRUE;}
2806         }
2807 }
2808
2809 ///________________________________________________________________________
2810 TString AliConversionPhotonCuts::GetCutNumber(){
2811         // returns TString with current cut number
2812         TString a(kNCuts);
2813         for(Int_t ii=0;ii<kNCuts;ii++){
2814                 a.Append(Form("%d",fCuts[ii]));
2815         }
2816         return a;
2817 }
2818
2819 ///________________________________________________________________________
2820 void AliConversionPhotonCuts::FillElectonLabelArray(AliAODConversionPhoton* photon, Int_t nV0){
2821
2822         Int_t posLabel = photon->GetTrackLabelPositive();
2823         Int_t negLabel = photon->GetTrackLabelNegative();
2824
2825         fElectronLabelArray[nV0*2] = posLabel;
2826         fElectronLabelArray[(nV0*2)+1] = negLabel;
2827 }
2828 ///________________________________________________________________________
2829 Bool_t AliConversionPhotonCuts::RejectSharedElectronV0s(AliAODConversionPhoton* photon, Int_t nV0, Int_t nV0s){
2830
2831         Int_t posLabel = photon->GetTrackLabelPositive();
2832         Int_t negLabel = photon->GetTrackLabelNegative();
2833
2834         for(Int_t i = 0; i<nV0s*2;i++){
2835                 if(i==nV0*2)     continue;
2836                 if(i==(nV0*2)+1) continue;
2837                 if(fElectronLabelArray[i] == posLabel){
2838                         return kFALSE;}
2839                 if(fElectronLabelArray[i] == negLabel){
2840                         return kFALSE;}
2841         }
2842
2843         return kTRUE;
2844 }
2845
2846 ///________________________________________________________________________
2847 Bool_t AliConversionPhotonCuts::RejectToCloseV0s(AliAODConversionPhoton* photon, TList *photons, Int_t nV0){
2848
2849
2850         Double_t posX = photon->GetConversionX();
2851         Double_t posY = photon->GetConversionY();
2852         Double_t posZ = photon->GetConversionZ();
2853
2854         for(Int_t i = 0;i<photons->GetEntries();i++){
2855                 if(nV0 == i) continue;
2856                 AliAODConversionPhoton *photonComp = (AliAODConversionPhoton*) photons->At(i);
2857                 Double_t posCompX = photonComp->GetConversionX();
2858                 Double_t posCompY = photonComp->GetConversionY();
2859                 Double_t posCompZ = photonComp->GetConversionZ();
2860
2861                 Double_t dist = pow((posX - posCompX),2)+pow((posY - posCompY),2)+pow((posZ - posCompZ),2);
2862
2863                 if(dist < fminV0Dist*fminV0Dist){
2864                         if(photon->GetChi2perNDF() < photonComp->GetChi2perNDF()) return kTRUE;
2865                         else {
2866                                 return kFALSE;}
2867                 }
2868
2869         }
2870         return kTRUE;
2871 }
2872
2873
2874 ///________________________________________________________________________
2875 AliConversionPhotonCuts* AliConversionPhotonCuts::GetStandardCuts2010PbPb(){
2876         //Create and return standard 2010 PbPb cuts
2877         AliConversionPhotonCuts *cuts=new AliConversionPhotonCuts("StandardCuts2010PbPb","StandardCuts2010PbPb");
2878         if(!cuts->InitializeCutsFromCutString("04209297002322000000")){
2879                 cout<<"Warning: Initialization of Standardcuts2010PbPb failed"<<endl;}
2880         return cuts;
2881 }
2882
2883 ///________________________________________________________________________
2884 AliConversionPhotonCuts* AliConversionPhotonCuts::GetStandardCuts2010pp(){
2885         //Create and return standard 2010 PbPb cuts
2886         AliConversionPhotonCuts *cuts=new AliConversionPhotonCuts("StandardCuts2010pp","StandardCuts2010pp");
2887         if(!cuts->InitializeCutsFromCutString("00209366300380000000")){
2888                 cout<<"Warning: Initialization of Standardcuts2010pp failed"<<endl;}
2889         return cuts;
2890 }
2891
2892 ///________________________________________________________________________
2893 Bool_t AliConversionPhotonCuts::InPlaneOutOfPlaneCut(Double_t photonPhi, Double_t eventPlaneAngle, Bool_t fill){
2894
2895         //GetPhotonPhi() 0-2 Pi  //eventPlaneAngle -1pi-1pi
2896         eventPlaneAngle=eventPlaneAngle+TMath::Pi();
2897         Double_t gammaToEPAngle = eventPlaneAngle-photonPhi;
2898         if(gammaToEPAngle < 0) gammaToEPAngle=gammaToEPAngle+2*TMath::Pi();
2899         gammaToEPAngle = gammaToEPAngle-TMath::Pi(); // angle from -pi +pi
2900
2901         if(!fInPlaneOutOfPlane){
2902                 if(fill&&hEventPlanePhi)hEventPlanePhi->Fill(gammaToEPAngle);
2903                 return kTRUE;
2904         }
2905         else if(fInPlaneOutOfPlane == 1){
2906                 if(abs(gammaToEPAngle)<=0.25*TMath::Pi() || abs(gammaToEPAngle)>=0.75*TMath::Pi()){
2907                         if(fill&&hEventPlanePhi)hEventPlanePhi->Fill(gammaToEPAngle);
2908                         return kTRUE;
2909                 }
2910                 else return kFALSE;
2911         }
2912         else if(fInPlaneOutOfPlane == 2){
2913                 if(abs(gammaToEPAngle)>0.25*TMath::Pi() && abs(gammaToEPAngle)<0.75*TMath::Pi()){
2914                         if(fill&&hEventPlanePhi)hEventPlanePhi->Fill(gammaToEPAngle);
2915                         return kTRUE;
2916                 }
2917                 else return kFALSE;
2918         }
2919         return kFALSE;
2920 }
2921
2922 ///________________________________________________________________________
2923 UChar_t AliConversionPhotonCuts::DeterminePhotonQualityAOD(AliAODConversionPhoton* photon, AliVEvent* eventDummy){
2924
2925         AliAODTrack * negTrack = static_cast<AliAODTrack*>(GetTrack(eventDummy, photon->GetTrackLabelNegative()));
2926         AliAODTrack * posTrack = static_cast<AliAODTrack*>(GetTrack(eventDummy, photon->GetTrackLabelPositive()));
2927
2928         if(!negTrack || !posTrack) {
2929                         return 0;
2930         }
2931         if(negTrack->Charge() == posTrack->Charge()){
2932                         return 0;
2933         }
2934         Int_t nClusterITSneg = negTrack->GetITSNcls();
2935         Int_t nClusterITSpos = posTrack->GetITSNcls();
2936         //    cout << nClusterITSneg << "\t" << nClusterITSpos <<endl;
2937
2938         if (nClusterITSneg > 1 && nClusterITSpos > 1){
2939                 return 3;
2940         } else if (nClusterITSneg > 1 || nClusterITSpos > 1){
2941                 return 2;
2942         } else {
2943                 return 1;
2944         }
2945         return 0;
2946 }