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