PWGGA/GammaConv/AliCaloPhotonCuts.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                                                                *
   4  * Authors: Friederike Bock, Baldo Sahlmueller                                *
   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 all kinds of selection cuts for
  19 // Photon from EMCAL clusters
  20 //---------------------------------------------
  21 ////////////////////////////////////////////////
  22
  23 #include "AliCaloPhotonCuts.h"
  24 #include "AliAnalysisManager.h"
  25 #include "AliInputEventHandler.h"
  26 #include "AliMCEventHandler.h"
  27 #include "AliAODHandler.h"
  28 #include "TH1.h"
  29 #include "TH2.h"
  30 #include "TF1.h"
  31 #include "AliStack.h"
  32 #include "AliAODConversionMother.h"
  33 #include "TObjString.h"
  34 #include "AliAODEvent.h"
  35 #include "AliESDEvent.h"
  36 #include "AliCentrality.h"
  37 #include "TList.h"
  38 #include "TFile.h"
  39 #include "AliLog.h"
  40 #include "AliV0ReaderV1.h"
  41 #include "AliAODMCParticle.h"
  42 #include "AliAODMCHeader.h"
  43
  44 class iostream;
  45
  46 using namespace std;
  47
  48 ClassImp(AliCaloPhotonCuts)
  49
  50
  51 const char* AliCaloPhotonCuts::fgkCutNames[AliCaloPhotonCuts::kNCuts] = {
  52         "ClusterType",                  //0
  53         "EtaMin",                               //1
  54         "EtaMax",                               //2
  55         "PhiMin",                               //3
  56         "PhiMax",                               //4
  57         "DistanceToBadChannel", //5
  58         "Timing",                               //6
  59         "TrackMatching",                //7
  60         "ExoticCell",                   //8
  61         "MinEnergy",                    //9
  62         "MinNCells",                    //10
  63         "MinM02",                               //11
  64         "MaxM02",                               //12
  65         "MinM20",                               //13
  66         "MaxM20",                               //14
  67         "MaximumDispersion",    //15
  68         "NLM"                                   //16
  69 };
  70
  71
  72 //________________________________________________________________________
  73 AliCaloPhotonCuts::AliCaloPhotonCuts(const char *name,const char *title) :
  74         AliAnalysisCuts(name,title),
  75         fHistograms(NULL),
  76         fClusterType(0),
  77         fMinEtaCut(-10),
  78         fMaxEtaCut(10),
  79         fMinPhiCut(-10000),
  80         fMaxPhiCut(-10000),
  81         fMinDistanceToBadChannel(0),
  82         fMaxTimeDiff(10e10),
  83         fMinDistTrackToCluster(0),
  84         fExoticCell(0),
  85         fMinEnergy(0),
  86         fMinNCells(0),
  87         fMaxM02(1000),
  88         fMinM02(0),
  89         fMaxM20(1000),
  90         fMinM20(0),
  91         fMaxDispersion(1000),
  92         fMinNLM(0),
  93         fMaxNLM(1000),
  94         fCutString(NULL),
  95         fHistCutIndex(NULL),
  96         fHistAcceptanceCuts(NULL),
  97         fHistClusterIdentificationCuts(NULL),
  98         fHistClusterEtavsPhiBeforeAcc(NULL),
  99         fHistClusterEtavsPhiAfterAcc(NULL),
 100         fHistClusterEtavsPhiAfterQA(NULL),
 101         fHistDistanceToBadChannelBeforeAcc(NULL),
 102         fHistDistanceToBadChannelAfterAcc(NULL),
 103         fHistClusterTimevsEBeforeQA(NULL),
 104         fHistClusterTimevsEAfterQA(NULL),
 105         fHistExoticCellBeforeQA(NULL),
 106         fHistExoticCellAfterQA(NULL),
 107         fHistDistanceTrackToClusterBeforeQA(NULL),
 108         fHistDistanceTrackToClusterAfterQA(NULL),
 109         fHistEnergyOfClusterBeforeQA(NULL),
 110         fHistEnergyOfClusterAfterQA(NULL),
 111         fHistNCellsBeforeQA(NULL),
 112         fHistNCellsAfterQA(NULL),
 113         fHistM02BeforeQA(NULL),
 114         fHistM02AfterQA(NULL),
 115         fHistM20BeforeQA(NULL),
 116         fHistM20AfterQA(NULL),
 117         fHistDispersionBeforeQA(NULL),
 118         fHistDispersionAfterQA(NULL),
 119         fHistNLMBeforeQA(NULL),
 120         fHistNLMAfterQA(NULL)
 121 {
 122    for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=0;}
 123    fCutString=new TObjString((GetCutNumber()).Data());
 124 }
 125
 126 //________________________________________________________________________
 127 AliCaloPhotonCuts::AliCaloPhotonCuts(const AliCaloPhotonCuts &ref) :
 128    AliAnalysisCuts(ref),
 129         fHistograms(NULL),
 130         fClusterType(ref.fClusterType),
 131         fMinEtaCut(ref.fMinEtaCut),
 132         fMaxEtaCut(ref.fMaxEtaCut),
 133         fMinPhiCut(ref.fMinPhiCut),
 134         fMaxPhiCut(ref.fMaxPhiCut),
 135         fMinDistanceToBadChannel(ref.fMinDistanceToBadChannel),
 136         fMaxTimeDiff(ref.fMaxTimeDiff),
 137         fMinDistTrackToCluster(ref.fMinDistTrackToCluster),
 138         fExoticCell(ref.fExoticCell),
 139         fMinEnergy(ref.fMinEnergy),
 140         fMinNCells(ref.fMinNCells),
 141         fMaxM02(ref.fMaxM02),
 142         fMinM02(ref.fMinM02),
 143         fMaxM20(ref.fMaxM20),
 144         fMinM20(ref.fMinM20),
 145         fMaxDispersion(ref.fMaxDispersion),
 146         fMinNLM(ref.fMinNLM),
 147         fMaxNLM(ref.fMaxNLM),
 148         fCutString(NULL),
 149         fHistCutIndex(NULL),
 150         fHistAcceptanceCuts(NULL),
 151         fHistClusterIdentificationCuts(NULL),
 152         fHistClusterEtavsPhiBeforeAcc(NULL),
 153         fHistClusterEtavsPhiAfterAcc(NULL),
 154         fHistClusterEtavsPhiAfterQA(NULL),
 155         fHistDistanceToBadChannelBeforeAcc(NULL),
 156         fHistDistanceToBadChannelAfterAcc(NULL),
 157         fHistClusterTimevsEBeforeQA(NULL),
 158         fHistClusterTimevsEAfterQA(NULL),
 159         fHistExoticCellBeforeQA(NULL),
 160         fHistExoticCellAfterQA(NULL),
 161         fHistDistanceTrackToClusterBeforeQA(NULL),
 162         fHistDistanceTrackToClusterAfterQA(NULL),
 163         fHistEnergyOfClusterBeforeQA(NULL),
 164         fHistEnergyOfClusterAfterQA(NULL),
 165         fHistNCellsBeforeQA(NULL),
 166         fHistNCellsAfterQA(NULL),
 167         fHistM02BeforeQA(NULL),
 168         fHistM02AfterQA(NULL),
 169         fHistM20BeforeQA(NULL),
 170         fHistM20AfterQA(NULL),
 171         fHistDispersionBeforeQA(NULL),
 172         fHistDispersionAfterQA(NULL),
 173         fHistNLMBeforeQA(NULL),
 174         fHistNLMAfterQA(NULL)
 175 {
 176    // Copy Constructor
 177    for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=ref.fCuts[jj];}
 178    fCutString=new TObjString((GetCutNumber()).Data());
 179
 180 }
 181
 182
 183 //________________________________________________________________________
 184 AliCaloPhotonCuts::~AliCaloPhotonCuts() {
 185    // Destructor
 186    //Deleting fHistograms leads to seg fault it it's added to output collection of a task
 187    // if(fHistograms)
 188    //    delete fHistograms;
 189    // fHistograms = NULL;
 190    if(fCutString != NULL){
 191       delete fCutString;
 192       fCutString = NULL;
 193    }
 194 }
 195
 196 //________________________________________________________________________
 197 void AliCaloPhotonCuts::InitCutHistograms(TString name){
 198
 199         // Initialize Cut Histograms for QA (only initialized and filled if function is called)
 200         TH1::AddDirectory(kFALSE);
 201
 202         if(fHistograms != NULL){
 203                 delete fHistograms;
 204                 fHistograms=NULL;
 205         }
 206         if(fHistograms==NULL){
 207                 fHistograms=new TList();
 208                 fHistograms->SetOwner(kTRUE);
 209                 if(name=="")fHistograms->SetName(Form("CaloCuts_%s",GetCutNumber().Data()));
 210                 else fHistograms->SetName(Form("%s_%s",name.Data(),GetCutNumber().Data()));
 211         }
 212
 213         // IsPhotonSelected
 214         fHistCutIndex=new TH1F(Form("IsPhotonSelected %s",GetCutNumber().Data()),"IsPhotonSelected",5,-0.5,4.5);
 215         fHistCutIndex->GetXaxis()->SetBinLabel(kPhotonIn+1,"in");
 216         fHistCutIndex->GetXaxis()->SetBinLabel(kDetector+1,"detector");
 217         fHistCutIndex->GetXaxis()->SetBinLabel(kAcceptance+1,"acceptance");
 218         fHistCutIndex->GetXaxis()->SetBinLabel(kClusterQuality+1,"cluster QA");
 219         fHistCutIndex->GetXaxis()->SetBinLabel(kPhotonOut+1,"out");
 220         fHistograms->Add(fHistCutIndex);
 221
 222         // Acceptance Cuts
 223         fHistAcceptanceCuts=new TH1F(Form("AcceptanceCuts %s",GetCutNumber().Data()),"AcceptanceCuts",5,-0.5,4.5);
 224         fHistAcceptanceCuts->GetXaxis()->SetBinLabel(1,"in");
 225         fHistAcceptanceCuts->GetXaxis()->SetBinLabel(2,"eta");
 226         fHistAcceptanceCuts->GetXaxis()->SetBinLabel(3,"phi");
 227         fHistAcceptanceCuts->GetXaxis()->SetBinLabel(4,"distance to bad channel");
 228         fHistAcceptanceCuts->GetXaxis()->SetBinLabel(5,"out");
 229         fHistograms->Add(fHistAcceptanceCuts);
 230
 231         // Cluster Cuts
 232         fHistClusterIdentificationCuts =new TH1F(Form("ClusterQualityCuts %s",GetCutNumber().Data()),"ClusterQualityCuts",10,-0.5,9.5);
 233         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(1,"in");
 234         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(2,"timing");
 235         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(3,"track matching");
 236         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(4,"Exotics");
 237         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(5,"minimum energy");
 238         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(6,"M02");
 239         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(7,"M20");
 240         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(8,"dispersion");
 241         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(9,"NLM");
 242         fHistClusterIdentificationCuts->GetXaxis()->SetBinLabel(10,"out");
 243         fHistograms->Add(fHistClusterIdentificationCuts);
 244
 245         // Acceptance related histogramms
 246         fHistClusterEtavsPhiBeforeAcc=new TH2F(Form("EtaPhi_beforeAcceptance %s",GetCutNumber().Data()),"EtaPhi_beforeAcceptance",462,-TMath::Pi(),TMath::Pi(),110,-0.7,0.7);
 247         fHistograms->Add(fHistClusterEtavsPhiBeforeAcc);
 248         fHistClusterEtavsPhiAfterAcc=new TH2F(Form("EtaPhi_afterAcceptance %s",GetCutNumber().Data()),"EtaPhi_afterAcceptance",462,-TMath::Pi(),TMath::Pi(),110,-0.7,0.7);
 249         fHistograms->Add(fHistClusterEtavsPhiAfterAcc);
 250         fHistClusterEtavsPhiAfterQA=new TH2F(Form("EtaPhi_afterClusterQA %s",GetCutNumber().Data()),"EtaPhi_afterClusterQA",462,-TMath::Pi(),TMath::Pi(),110,-0.7,0.7);
 251         fHistograms->Add(fHistClusterEtavsPhiAfterQA);
 252         fHistDistanceToBadChannelBeforeAcc = new TH1F(Form("DistanceToBadChannel_beforeAcceptance %s",GetCutNumber().Data()),"DistanceToBadChannel_beforeAcceptance",200,0,40);
 253         fHistograms->Add(fHistDistanceToBadChannelBeforeAcc);
 254         fHistDistanceToBadChannelAfterAcc = new TH1F(Form("DistanceToBadChannel_afterAcceptance %s",GetCutNumber().Data()),"DistanceToBadChannel_afterAcceptance",200,0,40);
 255         fHistograms->Add(fHistDistanceToBadChannelAfterAcc);
 256
 257         // Cluster quality related histograms
 258         fHistClusterTimevsEBeforeQA=new TH2F(Form("ClusterTimeVsE_beforeClusterQA %s",GetCutNumber().Data()),"ClusterTimeVsE_beforeClusterQA",400,-10e-6,10e-6,100,0.,40);
 259         fHistograms->Add(fHistClusterTimevsEBeforeQA);
 260         fHistClusterTimevsEAfterQA=new TH2F(Form("ClusterTimeVsE_afterClusterQA %s",GetCutNumber().Data()),"ClusterTimeVsE_afterClusterQA",400,-10e-6,10e-6,100,0.,40);
 261         fHistograms->Add(fHistClusterTimevsEAfterQA);
 262         fHistExoticCellBeforeQA=new TH2F(Form("ExoticCell_beforeClusterQA %s",GetCutNumber().Data()),"ExoticCell_beforeClusterQA",400,0,40,50,0.75,1);
 263         fHistograms->Add(fHistExoticCellBeforeQA);
 264         fHistExoticCellAfterQA=new TH2F(Form("ExoticCell_afterClusterQA %s",GetCutNumber().Data()),"ExoticCell_afterClusterQA",400,0,40,50,0.75,1);
 265         fHistograms->Add(fHistExoticCellAfterQA);
 266         fHistDistanceTrackToClusterBeforeQA = new TH1F(Form("DistanceToTrack_beforeClusterQA %s",GetCutNumber().Data()),"DistanceToTrack_beforeClusterQA",200,0,40);
 267         fHistograms->Add(fHistDistanceTrackToClusterBeforeQA);
 268         fHistDistanceTrackToClusterAfterQA = new TH1F(Form("DistanceToTrack_afterClusterQA %s",GetCutNumber().Data()),"DistanceToTrack_afterClusterQA",200,0,40);
 269         fHistograms->Add(fHistDistanceTrackToClusterAfterQA);
 270         fHistEnergyOfClusterBeforeQA = new TH1F(Form("EnergyOfCluster_beforeClusterQA %s",GetCutNumber().Data()),"EnergyOfCluster_beforeClusterQA",300,0,30);
 271         fHistograms->Add(fHistEnergyOfClusterBeforeQA);
 272         fHistEnergyOfClusterAfterQA = new TH1F(Form("EnergyOfCluster_afterClusterQA %s",GetCutNumber().Data()),"EnergyOfCluster_afterClusterQA",300,0,30);
 273         fHistograms->Add(fHistEnergyOfClusterAfterQA);
 274         fHistNCellsBeforeQA = new TH1F(Form("NCellPerCluster_beforeClusterQA %s",GetCutNumber().Data()),"NCellPerCluster_beforeClusterQA",50,0,50);
 275         fHistograms->Add(fHistNCellsBeforeQA);
 276         fHistNCellsAfterQA = new TH1F(Form("NCellPerCluster_afterClusterQA %s",GetCutNumber().Data()),"NCellPerCluster_afterClusterQA",50,0,50);
 277         fHistograms->Add(fHistNCellsAfterQA);
 278         fHistM02BeforeQA = new TH1F(Form("M02_beforeClusterQA %s",GetCutNumber().Data()),"M02_beforeClusterQA",100,0,5);
 279         fHistograms->Add(fHistM02BeforeQA);
 280         fHistM02AfterQA = new TH1F(Form("M02_afterClusterQA %s",GetCutNumber().Data()),"M02_afterClusterQA",100,0,5);
 281         fHistograms->Add(fHistM02AfterQA);
 282         fHistM20BeforeQA = new TH1F(Form("M20_beforeClusterQA %s",GetCutNumber().Data()),"M20_beforeClusterQA",100,0,2.5);
 283         fHistograms->Add(fHistM20BeforeQA);
 284         fHistM20AfterQA = new TH1F(Form("M20_afterClusterQA %s",GetCutNumber().Data()),"M20_afterClusterQA",100,0,2.5);
 285         fHistograms->Add(fHistM20AfterQA);
 286         fHistDispersionBeforeQA = new TH1F(Form("Dispersion_beforeClusterQA %s",GetCutNumber().Data()),"Dispersion_beforeClusterQA",100,0,4);
 287         fHistograms->Add(fHistDispersionBeforeQA);
 288         fHistDispersionAfterQA = new TH1F(Form("Dispersion_afterClusterQA %s",GetCutNumber().Data()),"Dispersion_afterClusterQA",100,0,4);
 289         fHistograms->Add(fHistDispersionAfterQA);
 290         fHistNLMBeforeQA = new TH1F(Form("NLM_beforeClusterQA %s",GetCutNumber().Data()),"NLM_beforeClusterQA",10,0,10);
 291         fHistograms->Add(fHistNLMBeforeQA);
 292         fHistNLMAfterQA = new TH1F(Form("NLM_afterClusterQA %s",GetCutNumber().Data()),"NLM_afterClusterQA",10,0,10);
 293         fHistograms->Add(fHistNLMAfterQA);
 294
 295         TH1::AddDirectory(kTRUE);
 296 }
 297
 298 /*
 299 ///________________________________________________________________________
 300 Bool_t AliCaloPhotonCuts::ClusterIsSelectedMC(TParticle *particle,AliStack *fMCStack,Bool_t checkForConvertedGamma){
 301    // MonteCarlo Photon Selection
 302
 303    if(!fMCStack)return kFALSE;
 304
 305    if (particle->GetPdgCode() == 22){
 306
 307
 308      if( particle->Eta() > (fEtaCut) || particle->Eta() < (-fEtaCut) )
 309          return kFALSE;
 310       if(fEtaCutMin>-0.1){
 311          if( particle->Eta() < (fEtaCutMin) && particle->Eta() > (-fEtaCutMin) )
 312             return kFALSE;
 313       }
 314
 315       if(particle->GetMother(0) >-1 && fMCStack->Particle(particle->GetMother(0))->GetPdgCode() == 22){
 316          return kFALSE; // no photon as mothers!
 317       }
 318
 319       if(particle->GetMother(0) >= fMCStack->GetNprimary()){
 320          return kFALSE; // the gamma has a mother, and it is not a primary particle
 321       }
 322
 323       if(!checkForConvertedGamma) return kTRUE; // return in case of accepted gamma
 324
 325       // looking for conversion gammas (electron + positron from pairbuilding (= 5) )
 326       TParticle* ePos = NULL;
 327       TParticle* eNeg = NULL;
 328
 329       if(particle->GetNDaughters() >= 2){
 330          for(Int_t daughterIndex=particle->GetFirstDaughter();daughterIndex<=particle->GetLastDaughter();daughterIndex++){
 331             TParticle *tmpDaughter = fMCStack->Particle(daughterIndex);
 332             if(tmpDaughter->GetUniqueID() == 5){
 333                if(tmpDaughter->GetPdgCode() == 11){
 334                   eNeg = tmpDaughter;
 335                } else if(tmpDaughter->GetPdgCode() == -11){
 336                   ePos = tmpDaughter;
 337                }
 338             }
 339          }
 340       }
 341
 342       if(ePos == NULL || eNeg == NULL){ // means we do not have two daughters from pair production
 343          return kFALSE;
 344       }
 345
 346       if(ePos->Pt()<fSinglePtCut || eNeg->Pt()<fSinglePtCut){
 347          return kFALSE; // no reconstruction below the Pt cut
 348       }
 349
 350       if( ePos->Eta() > (fEtaCut) || ePos->Eta() < (-fEtaCut) ||
 351           eNeg->Eta() > (fEtaCut) || eNeg->Eta() < (-fEtaCut) )
 352          return kFALSE;
 353
 354       if(fEtaCutMin > -0.1){
 355          if( (ePos->Eta() < (fEtaCutMin) && ePos->Eta() > (-fEtaCutMin)) ||
 356              (eNeg->Eta() < (fEtaCutMin) && eNeg->Eta() > (-fEtaCutMin)) )
 357             return kFALSE;
 358       }
 359
 360       if(ePos->R()>fMaxR){
 361          return kFALSE; // cuts on distance from collision point
 362       }
 363
 364       if(abs(ePos->Vz()) > fMaxZ){
 365          return kFALSE;  // outside material
 366       }
 367       if(abs(eNeg->Vz()) > fMaxZ){
 368          return kFALSE;  // outside material
 369       }
 370
 371       if( ePos->R() <= ((abs(ePos->Vz()) * fLineCutZRSlope) - fLineCutZValue)){
 372          return kFALSE;  // line cut to exclude regions where we do not reconstruct
 373       } else if ( fEtaCutMin != -0.1 &&   ePos->R() >= ((abs(ePos->Vz()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
 374          return kFALSE;
 375       }
 376
 377       if( eNeg->R() <= ((abs(eNeg->Vz()) * fLineCutZRSlope) - fLineCutZValue)){
 378          return kFALSE; // line cut to exclude regions where we do not reconstruct
 379       } else if ( fEtaCutMin != -0.1 &&   eNeg->R() >= ((abs(eNeg->Vz()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
 380          return kFALSE;
 381       }
 382
 383       return kTRUE;
 384       //if(AcceptanceCut(particle,ePos,eNeg))return kTRUE;
 385    }
 386    return kFALSE;
 387 }
 388 ///________________________________________________________________________
 389 Bool_t AliCaloPhotonCuts::ClusterIsSelectedAODMC(AliAODMCParticle *particle,TClonesArray *aodmcArray,Bool_t checkForConvertedGamma){
 390    // MonteCarlo Photon Selection
 391
 392    if(!aodmcArray)return kFALSE;
 393
 394    if (particle->GetPdgCode() == 22){
 395       if( particle->Eta() > (fEtaCut) || particle->Eta() < (-fEtaCut) )
 396          return kFALSE;
 397       if(fEtaCutMin>-0.1){
 398          if( particle->Eta() < (fEtaCutMin) && particle->Eta() > (-fEtaCutMin) )
 399             return kFALSE;
 400       }
 401
 402       if(particle->GetMother() > -1){
 403          if((static_cast<AliAODMCParticle*>(aodmcArray->At(particle->GetMother())))->GetPdgCode() == 22){
 404             return kFALSE; // no photon as mothers!
 405          }
 406          if(!(static_cast<AliAODMCParticle*>(aodmcArray->At(particle->GetMother()))->IsPrimary())){
 407             return kFALSE; // the gamma has a mother, and it is not a primary particle
 408          }
 409       }
 410
 411       if(!checkForConvertedGamma) return kTRUE; // return in case of accepted gamma
 412
 413       // looking for conversion gammas (electron + positron from pairbuilding (= 5) )
 414       AliAODMCParticle* ePos = NULL;
 415       AliAODMCParticle* eNeg = NULL;
 416
 417       if(particle->GetNDaughters() >= 2){
 418          for(Int_t daughterIndex=particle->GetDaughter(0);daughterIndex<=particle->GetDaughter(1);daughterIndex++){
 419             AliAODMCParticle *tmpDaughter = static_cast<AliAODMCParticle*>(aodmcArray->At(daughterIndex));
 420             if(!tmpDaughter) continue;
 421             if(((tmpDaughter->GetMCProcessCode())) == 5){    // STILL A BUG IN ALIROOT >>8 HAS TPO BE REMOVED AFTER FIX
 422                if(tmpDaughter->GetPdgCode() == 11){
 423                   eNeg = tmpDaughter;
 424                } else if(tmpDaughter->GetPdgCode() == -11){
 425                   ePos = tmpDaughter;
 426                }
 427             }
 428          }
 429       }
 430
 431       if(ePos == NULL || eNeg == NULL){ // means we do not have two daughters from pair production
 432          return kFALSE;
 433       }
 434
 435       if(ePos->Pt()<fSinglePtCut || eNeg->Pt()<fSinglePtCut){
 436          return kFALSE; // no reconstruction below the Pt cut
 437       }
 438
 439       if( ePos->Eta() > (fEtaCut) || ePos->Eta() < (-fEtaCut) ||
 440           eNeg->Eta() > (fEtaCut) || eNeg->Eta() < (-fEtaCut) )
 441          return kFALSE;
 442
 443       if(fEtaCutMin > -0.1){
 444          if( (ePos->Eta() < (fEtaCutMin) && ePos->Eta() > (-fEtaCutMin)) ||
 445              (eNeg->Eta() < (fEtaCutMin) && eNeg->Eta() > (-fEtaCutMin)) )
 446             return kFALSE;
 447       }
 448
 449       Double_t rPos = sqrt( (ePos->Xv()*ePos->Xv()) + (ePos->Yv()*ePos->Yv()) );
 450       Double_t rNeg = sqrt( (eNeg->Xv()*eNeg->Xv()) + (eNeg->Yv()*eNeg->Yv()) );
 451
 452       if(rPos>fMaxR){
 453          return kFALSE; // cuts on distance from collision point
 454       }
 455       if(abs(ePos->Zv()) > fMaxZ){
 456          return kFALSE;  // outside material
 457       }
 458       if(abs(eNeg->Zv()) > fMaxZ){
 459          return kFALSE;  // outside material
 460       }
 461
 462       if( rPos <= ((abs(ePos->Zv()) * fLineCutZRSlope) - fLineCutZValue)){
 463          return kFALSE;  // line cut to exclude regions where we do not reconstruct
 464       } else if ( fEtaCutMin != -0.1 &&   rPos >= ((abs(ePos->Zv()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
 465          return kFALSE;
 466       }
 467
 468       if( rNeg <= ((abs(eNeg->Zv()) * fLineCutZRSlope) - fLineCutZValue)){
 469          return kFALSE; // line cut to exclude regions where we do not reconstruct
 470       } else if ( fEtaCutMin != -0.1 &&   rNeg >= ((abs(eNeg->Zv()) * fLineCutZRSlopeMin) - fLineCutZValueMin)){
 471          return kFALSE;
 472       }
 473
 474       return kTRUE;
 475       //if(AcceptanceCut(particle,ePos,eNeg))return kTRUE;
 476    }
 477    return kFALSE;
 478 }*/
 479
 480
 481
 482 ///________________________________________________________________________
 483 // This function selects the clusters based on their quality criteria
 484 ///________________________________________________________________________
 485 Bool_t AliCaloPhotonCuts::ClusterQualityCuts(AliVCluster* cluster, AliVEvent *event, Bool_t isMC)
 486 {   // Specific Photon Cuts
 487
 488         Int_t cutIndex = 0;
 489         if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex);
 490         cutIndex++;
 491
 492
 493         // Fill Histos before Cuts
 494         if(fHistClusterTimevsEBeforeQA) fHistClusterTimevsEBeforeQA->Fill(cluster->GetTOF(), cluster->E());
 495 //      if(fHistExoticCellBeforeQA) fHistExoticCellBeforeQA->Fill(cluster->E(), );
 496         if(fHistDistanceTrackToClusterBeforeQA) fHistDistanceTrackToClusterBeforeQA->Fill(cluster->GetEmcCpvDistance());
 497         if(fHistEnergyOfClusterBeforeQA) fHistEnergyOfClusterBeforeQA->Fill(cluster->E());
 498         if(fHistNCellsBeforeQA) fHistNCellsBeforeQA->Fill(cluster->GetNCells());
 499         if(fHistM02BeforeQA) fHistM02BeforeQA->Fill(cluster->GetM02());
 500         if(fHistM20BeforeQA) fHistM20BeforeQA->Fill(cluster->GetM20());
 501         if(fHistDispersionBeforeQA) fHistDispersionBeforeQA->Fill(cluster->GetDispersion());
 502 //      if(fHistNLMBeforeQA) fHistNLMBeforeQA->Fill(cluster->GetNExMax());
 503
 504         // Check wether timing is ok
 505         if(abs(cluster->GetTOF()) > fMaxTimeDiff && !isMC){
 506                 if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //1
 507                 return kFALSE;
 508         }
 509         cutIndex++; //2, next cut
 510
 511         // Minimum distance to track
 512         if(cluster->GetEmcCpvDistance() < fMinDistTrackToCluster){
 513                 if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //2
 514                 return kFALSE;
 515         }
 516         cutIndex++;//3, next cut
 517
 518         // exotic cell cut --IMPLEMENT LATER---
 519 //      if(!AcceptanceCuts(photon)){
 520 //              if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //3
 521 //              return kFALSE;
 522 //      }
 523         cutIndex++; //4, next cut
 524
 525         // minimum cell energy cut
 526         if(cluster->E() < fMinEnergy){
 527                 if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //4
 528                 return kFALSE;
 529         }
 530         cutIndex++; //5, next cut
 531
 532         // minimum number of cells
 533         if(cluster->GetNCells() < fMinNCells) {
 534                 if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //5
 535                 return kFALSE;
 536         }
 537         cutIndex++; //6, next cut
 538
 539         // M02 cut
 540         if( cluster->GetM02()< fMinM02 || cluster->GetM02() > fMaxM02 ) {
 541                 if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //6
 542                 return kFALSE;
 543         }
 544         cutIndex++; //7, next cut
 545
 546         // M20 cut
 547         if( cluster->GetM20()< fMinM20 || cluster->GetM20() > fMaxM20 ) {
 548                 if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //7
 549                 return kFALSE;
 550         }
 551         cutIndex++; //8, next cut
 552
 553         // dispersion cut
 554         if( cluster->GetDispersion()> fMaxDispersion) {
 555                 if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //8
 556                 return kFALSE;
 557         }
 558         cutIndex++; //9, next cut
 559
 560         // NLM cut --IMPLEMENT LATER---
 561         if( cluster->GetDispersion()> fMaxDispersion) {
 562                 if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //9
 563                 return kFALSE;
 564         }
 565         cutIndex++; //9, next cut
 566
 567         // DONE with selecting photons
 568         if(fHistClusterIdentificationCuts)fHistClusterIdentificationCuts->Fill(cutIndex); //10
 569
 570         // Histos after Cuts
 571         Double_t vertex[3] = {0};
 572         event->GetPrimaryVertex()->GetXYZ(vertex);
 573         // TLorentzvector with cluster
 574         TLorentzVector clusterVector;
 575         cluster->GetMomentum(clusterVector,vertex);
 576         Double_t etaCluster = clusterVector.Eta();
 577         Double_t phiCluster = clusterVector.Phi();
 578
 579         if(fHistClusterEtavsPhiAfterQA) fHistClusterEtavsPhiAfterQA->Fill(phiCluster,etaCluster);
 580         if(fHistClusterTimevsEAfterQA) fHistClusterTimevsEAfterQA->Fill(cluster->GetTOF(), cluster->E());
 581 //      if(fHistExoticCellAfterQA) fHistExoticCellAfterQA->Fill(cluster->E(), );
 582         if(fHistDistanceTrackToClusterAfterQA) fHistDistanceTrackToClusterAfterQA->Fill(cluster->GetEmcCpvDistance());
 583         if(fHistEnergyOfClusterAfterQA) fHistEnergyOfClusterAfterQA->Fill(cluster->E());
 584         if(fHistNCellsAfterQA) fHistNCellsAfterQA->Fill(cluster->GetNCells());
 585         if(fHistM02AfterQA) fHistM02AfterQA->Fill(cluster->GetM02());
 586         if(fHistM20AfterQA) fHistM20AfterQA->Fill(cluster->GetM20());
 587         if(fHistDispersionAfterQA) fHistDispersionAfterQA->Fill(cluster->GetDispersion());
 588 //      if(fHistNLMBeforeQA) fHistNLMAfterQA->Fill(cluster->GetNExMax());
 589
 590         return kTRUE;
 591
 592 }
 593
 594
 595 ///________________________________________________________________________
 596 Bool_t AliCaloPhotonCuts::ClusterIsSelected(AliVCluster *cluster, AliVEvent * event, Bool_t isMC)
 597 {
 598         //Selection of Reconstructed photon clusters with Calorimeters
 599
 600         FillClusterCutIndex(kPhotonIn);
 601
 602         Double_t vertex[3] = {0};
 603         event->GetPrimaryVertex()->GetXYZ(vertex);
 604         // TLorentzvector with cluster
 605         TLorentzVector clusterVector;
 606         cluster->GetMomentum(clusterVector,vertex);
 607         Double_t etaCluster = clusterVector.Eta();
 608         Double_t phiCluster = clusterVector.Phi();
 609
 610         // Histos before cuts
 611         if(fHistClusterEtavsPhiBeforeAcc) fHistClusterEtavsPhiBeforeAcc->Fill(phiCluster,etaCluster);
 612
 613         // Cluster Selection - 0= accept any calo cluster
 614         if (fClusterType > 0){
 615                 //Select EMCAL cluster
 616                 if (fClusterType == 1 && !cluster->IsEMCAL()){
 617                         FillClusterCutIndex(kDetector);
 618                 }
 619                 //Select PHOS cluster
 620                 if (fClusterType == 2 && !cluster->IsPHOS()){
 621                         FillClusterCutIndex(kDetector);
 622                 }
 623         }
 624
 625         // Acceptance Cuts
 626         if(!AcceptanceCuts(cluster,event)){
 627                 FillClusterCutIndex(kAcceptance);
 628                 return kFALSE;
 629         }
 630         // Cluster Quality Cuts
 631         if(!ClusterQualityCuts(cluster,event,isMC)){
 632                 FillClusterCutIndex(kClusterQuality);
 633                 return kFALSE;
 634         }
 635
 636         // Photon passed cuts
 637         FillClusterCutIndex(kPhotonOut);
 638         return kTRUE;
 639 }
 640
 641
 642 ///________________________________________________________________________
 643 Bool_t AliCaloPhotonCuts::AcceptanceCuts(AliVCluster *cluster, AliVEvent* event)
 644 {
 645    // Exclude certain areas for photon reconstruction
 646
 647         Int_t cutIndex=0;
 648         if(fHistAcceptanceCuts)fHistAcceptanceCuts->Fill(cutIndex);
 649         cutIndex++;
 650
 651
 652         Double_t vertex[3] = {0};
 653         event->GetPrimaryVertex()->GetXYZ(vertex);
 654         // TLorentzvector with cluster
 655         TLorentzVector clusterVector;
 656         cluster->GetMomentum(clusterVector,vertex);
 657         Double_t etaCluster = clusterVector.Eta();
 658         Double_t phiCluster = clusterVector.Phi();
 659
 660         // check eta range
 661         if (fMinEtaCut !=-10 && fMaxEtaCut !=10 ){
 662                 if (etaCluster < fMinEtaCut || etaCluster > fMaxEtaCut){
 663                         if(fHistAcceptanceCuts)fHistAcceptanceCuts->Fill(cutIndex);
 664                         return kFALSE;
 665                 }
 666         }
 667         cutIndex++;
 668
 669         // check phi range
 670         if (fMinPhiCut !=-10000 && fMaxPhiCut !=-10000 ){
 671                 if (phiCluster < fMinPhiCut || phiCluster > fMaxEtaCut){
 672                         if(fHistAcceptanceCuts)fHistAcceptanceCuts->Fill(cutIndex);
 673                         return kFALSE;
 674                 }
 675         }
 676         cutIndex++;
 677
 678         // check distance to bad channel
 679         if (cluster->GetDistanceToBadChannel() < fMinDistanceToBadChannel){
 680                 if(fHistAcceptanceCuts)fHistAcceptanceCuts->Fill(cutIndex);
 681                 return kFALSE;
 682         }
 683
 684         if(fHistAcceptanceCuts)fHistAcceptanceCuts->Fill(cutIndex);
 685
 686         // Histos after cuts
 687         if(fHistClusterEtavsPhiAfterAcc) fHistClusterEtavsPhiAfterAcc->Fill(phiCluster,etaCluster);
 688
 689         return kTRUE;
 690 }
 691
 692 ///________________________________________________________________________
 693 Bool_t AliCaloPhotonCuts::UpdateCutString() {
 694    ///Update the cut string (if it has been created yet)
 695
 696    if(fCutString && fCutString->GetString().Length() == kNCuts) {
 697       fCutString->SetString(GetCutNumber());
 698    } else {
 699       return kFALSE;
 700    }
 701    return kTRUE;
 702 }
 703
 704 ///________________________________________________________________________
 705 Bool_t AliCaloPhotonCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {
 706         // Initialize Cuts from a given Cut string
 707         AliInfo(Form("Set CaloCut Number: %s",analysisCutSelection.Data()));
 708         if(analysisCutSelection.Length()!=kNCuts) {
 709                 AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));
 710                 return kFALSE;
 711         }
 712         if(!analysisCutSelection.IsDigit()){
 713                 AliError("Cut selection contains characters");
 714                 return kFALSE;
 715         }
 716
 717         const char *cutSelection = analysisCutSelection.Data();
 718         #define ASSIGNARRAY(i)  fCuts[i] = cutSelection[i] - '0'
 719         for(Int_t ii=0;ii<kNCuts;ii++){
 720                 ASSIGNARRAY(ii);
 721         }
 722
 723         // Set Individual Cuts
 724         for(Int_t ii=0;ii<kNCuts;ii++){
 725                 if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;
 726         }
 727         PrintCutsWithValues();
 728         return kTRUE;
 729 }
 730
 731 ///________________________________________________________________________
 732 Bool_t AliCaloPhotonCuts::SetCut(cutIds cutID, const Int_t value) {
 733         ///Set individual cut ID
 734
 735         switch (cutID) {
 736
 737                 case kClusterType:
 738                         if( SetClusterTypeCut(value)) {
 739                                 fCuts[kClusterType] = value;
 740                                 UpdateCutString();
 741                                 return kTRUE;
 742                         } else return kFALSE;
 743
 744                 case kEtaMin:
 745                         if( SetMinEtaCut(value)) {
 746                                 fCuts[kEtaMin] = value;
 747                                 UpdateCutString();
 748                                 return kTRUE;
 749                         } else return kFALSE;
 750
 751                 case kEtaMax:
 752                         if( SetMaxEtaCut(value)) {
 753                                 fCuts[kEtaMax] = value;
 754                                 UpdateCutString();
 755                                 return kTRUE;
 756                         } else return kFALSE;
 757
 758                 case kPhiMin:
 759                         if( SetMinPhiCut(value)) {
 760                                 fCuts[kPhiMin] = value;
 761                                 UpdateCutString();
 762                                 return kTRUE;
 763                         } else return kFALSE;
 764
 765                 case kPhiMax:
 766                         if( SetMaxPhiCut(value)) {
 767                                 fCuts[kPhiMax] = value;
 768                                 UpdateCutString();
 769                                 return kTRUE;
 770                         } else return kFALSE;
 771
 772                 case kDistanceToBadChannel:
 773                         if( SetDistanceToBadChannelCut(value)) {
 774                                 fCuts[kDistanceToBadChannel] = value;
 775                                 UpdateCutString();
 776                                 return kTRUE;
 777                         } else return kFALSE;
 778
 779                 case kTiming:
 780                         if( SetTimingCut(value)) {
 781                                 fCuts[kTiming] = value;
 782                                 UpdateCutString();
 783                                 return kTRUE;
 784                         } else return kFALSE;
 785
 786                 case kTrackMatching:
 787                         if( SetTrackMatchingCut(value)) {
 788                                 fCuts[kTrackMatching] = value;
 789                                 UpdateCutString();
 790                                 return kTRUE;
 791                         } else return kFALSE;
 792
 793                 case kExoticCell:
 794                         if( SetExoticCellCut(value)) {
 795                                 fCuts[kExoticCell] = value;
 796                                 UpdateCutString();
 797                                 return kTRUE;
 798                         } else return kFALSE;
 799
 800                 case kMinEnery:
 801                         if( SetMinEnergyCut(value)) {
 802                                 fCuts[kMinEnery] = value;
 803                                 UpdateCutString();
 804                                 return kTRUE;
 805                         } else return kFALSE;
 806
 807                 case kNMinCells:
 808                         if( SetMinNCellsCut(value)) {
 809                                 fCuts[kNMinCells] = value;
 810                                 UpdateCutString();
 811                                 return kTRUE;
 812                         } else return kFALSE;
 813
 814                 case kMinM02:
 815                         if( SetMinM02(value)) {
 816                                 fCuts[kMinM02] = value;
 817                                 UpdateCutString();
 818                                 return kTRUE;
 819                         } else return kFALSE;
 820
 821                 case kMaxM02:
 822                         if( SetMaxM02(value)) {
 823                                 fCuts[kMaxM02] = value;
 824                                 UpdateCutString();
 825                                 return kTRUE;
 826                         } else return kFALSE;
 827
 828                 case kMinM20:
 829                         if( SetMinM20(value)) {
 830                                 fCuts[kMinM20] = value;
 831                                 UpdateCutString();
 832                                 return kTRUE;
 833                         } else return kFALSE;
 834
 835                 case kMaxM20:
 836                         if( SetMaxM20(value)) {
 837                                 fCuts[kMaxM20] = value;
 838                                 UpdateCutString();
 839                                 return kTRUE;
 840                         } else return kFALSE;
 841
 842                 case kDispersion:
 843                         if( SetDispersion(value)) {
 844                                 fCuts[kDispersion] = value;
 845                                 UpdateCutString();
 846                                 return kTRUE;
 847                         } else return kFALSE;
 848
 849                 case kNLM:
 850                         if( SetNLM(value)) {
 851                                 fCuts[kNLM] = value;
 852                                 UpdateCutString();
 853                                 return kTRUE;
 854                         } else return kFALSE;
 855
 856                 case kNCuts:
 857                         AliError("Cut id out of range");
 858                         return kFALSE;
 859         }
 860
 861         AliError("Cut id %d not recognized");
 862         return kFALSE;
 863
 864
 865 }
 866 ///________________________________________________________________________
 867 void AliCaloPhotonCuts::PrintCuts() {
 868    // Print out current Cut Selection
 869    for(Int_t ic = 0; ic < kNCuts; ic++) {
 870       printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);
 871    }
 872 }
 873
 874 void AliCaloPhotonCuts::PrintCutsWithValues() {
 875         // Print out current Cut Selection with value
 876         printf("Acceptance cuts: \n");
 877         printf("\t%3.2f < eta_{cluster} < %3.2f\n", fMinEtaCut, fMaxEtaCut );
 878         printf("\t%3.2f < phi_{cluster} < %3.2f\n", fMinPhiCut, fMaxPhiCut );
 879         printf("\tmin distance to bad channel > %3.2f\n", fMinDistanceToBadChannel );
 880
 881         printf("Cluster Quality cuts: \n");
 882         printf("\t time difference < %3.2f\n", fMaxTimeDiff );
 883         printf("\t min distance to track > %3.2f\n", fMinDistTrackToCluster );
 884     printf("\t E_{cluster} > %3.2f\n", fMinEnergy );
 885         printf("\t %3.2f < M02 < %3.2f\n", fMinM02, fMaxM02 );
 886
 887 }
 888
 889 // EMCAL acceptance 2011
 890 // 1.39626, 3.125 (phi)
 891 // -0.66687,,0.66465
 892
 893
 894 ///________________________________________________________________________
 895 Bool_t AliCaloPhotonCuts::SetClusterTypeCut(Int_t clusterType)
 896 {   // Set Cut
 897         switch(clusterType){
 898         case 0: // all clusters
 899                 fClusterType=0;
 900                 break;
 901         case 1: // EMCAL clusters
 902                 fClusterType=1;
 903                 break;
 904         case 2: // PHOS clusters
 905                 fClusterType=2;
 906                 break;
 907         default:
 908                 AliError(Form("ClusterTypeCut not defined %d",clusterType));
 909                 return kFALSE;
 910         }
 911         return kTRUE;
 912 }
 913
 914 //___________________________________________________________________
 915 Bool_t AliCaloPhotonCuts::SetMinEtaCut(Int_t minEta)
 916 {
 917         switch(minEta){
 918         case 0:
 919                 fMinEtaCut=-0.6687;
 920                 break;
 921         case 1:
 922                 fClusterType=-0.5;
 923                 break;
 924         case 2:
 925                 fClusterType=-2;
 926                 break;
 927         default:
 928                 AliError(Form("MinEta Cut not defined %d",minEta));
 929                 return kFALSE;
 930         }
 931         return kTRUE;
 932 }
 933
 934
 935 //___________________________________________________________________
 936 Bool_t AliCaloPhotonCuts::SetMaxEtaCut(Int_t maxEta)
 937 {
 938         switch(maxEta){
 939         case 0:
 940                 fMaxEtaCut=0.66465;
 941                 break;
 942         case 1:
 943                 fMaxEtaCut=0.5;
 944                 break;
 945         case 2:
 946                 fMaxEtaCut=2;
 947                 break;
 948         default:
 949                 AliError(Form("MaxEta Cut not defined %d",maxEta));
 950                 return kFALSE;
 951         }
 952         return kTRUE;
 953 }
 954
 955 //___________________________________________________________________
 956 Bool_t AliCaloPhotonCuts::SetMinPhiCut(Int_t minPhi)
 957 {
 958         switch(minPhi){
 959         case 0:
 960                 fMinPhiCut=-10000;
 961                 break;
 962         case 1:
 963                 fMinPhiCut=1.39626;
 964                 break;
 965         default:
 966                 AliError(Form("MinPhi Cut not defined %d",minPhi));
 967                 return kFALSE;
 968         }
 969         return kTRUE;
 970 }
 971
 972 //___________________________________________________________________
 973 Bool_t AliCaloPhotonCuts::SetMaxPhiCut(Int_t maxPhi)
 974 {
 975         switch(maxPhi){
 976         case 0:
 977                 fMaxPhiCut=-10000;
 978                 break;
 979         case 1:
 980                 fMaxPhiCut=3.125;
 981                 break;
 982         default:
 983                 AliError(Form("Max Phi Cut not defined %d",maxPhi));
 984                 return kFALSE;
 985         }
 986         return kTRUE;
 987 }
 988
 989 //___________________________________________________________________
 990 Bool_t AliCaloPhotonCuts::SetDistanceToBadChannelCut(Int_t distanceToBadChannel)
 991 {
 992         switch(distanceToBadChannel){
 993         case 0:
 994                 fMinDistanceToBadChannel=0;
 995                 break;
 996         case 1:
 997                 fMinDistanceToBadChannel=5;
 998                 break;
 999         default:
1000                 AliError(Form("minimum distance to bad channel Cut not defined %d",distanceToBadChannel));
1001                 return kFALSE;
1002         }
1003         return kTRUE;
1004 }
1005
1006 //___________________________________________________________________
1007 Bool_t AliCaloPhotonCuts::SetTimingCut(Int_t timing)
1008 {
1009         switch(timing){
1010         case 0:
1011                 fMaxTimeDiff=500;
1012                 break;
1013         case 1:
1014                 fMaxTimeDiff=10e-7; //1000ns
1015                 break;
1016         case 2:
1017                 fMaxTimeDiff=50e-8; //500ns
1018                 break;
1019         case 3:
1020                 fMaxTimeDiff=20e-8; //200ns
1021                 break;
1022         case 4:
1023                 fMaxTimeDiff=10e-8; //100ns
1024                 break;
1025         case 5:
1026                 fMaxTimeDiff=50e-9; //50ns
1027                 break;
1028
1029         default:
1030                 AliError(Form("Timing Cut not defined %d",timing));
1031                 return kFALSE;
1032         }
1033         return kTRUE;
1034 }
1035
1036 //___________________________________________________________________
1037 Bool_t AliCaloPhotonCuts::SetTrackMatchingCut(Int_t trackMatching)
1038 {
1039         switch(trackMatching){
1040         case 0:
1041                 fMinDistTrackToCluster=0;
1042                 break;
1043         case 1:
1044                 fMinDistTrackToCluster=5;
1045                 break;
1046         default:
1047                 AliError(Form("Track Matching Cut not defined %d",trackMatching));
1048                 return kFALSE;
1049         }
1050         return kTRUE;
1051 }
1052
1053 //___________________________________________________________________
1054 Bool_t AliCaloPhotonCuts::SetExoticCellCut(Int_t exoticCell)
1055 {
1056         switch(exoticCell){
1057         case 0:
1058                 fExoticCell=0;
1059                 break;
1060         case 1:
1061                 fExoticCell=5;
1062                 break;
1063         default:
1064                 AliError(Form("Exotic cell Cut not defined %d",exoticCell));
1065                 return kFALSE;
1066         }
1067         return kTRUE;
1068 }
1069
1070 //___________________________________________________________________
1071 Bool_t AliCaloPhotonCuts::SetMinEnergyCut(Int_t minEnergy)
1072 {
1073         switch(minEnergy){
1074         case 0:
1075                 fMinEnergy=0;
1076                 break;
1077         case 1:
1078                 fMinEnergy=0.05;
1079                 break;
1080         case 2:
1081                 fMinEnergy=0.1;
1082                 break;
1083         case 3:
1084                 fMinEnergy=0.15;
1085                 break;
1086         case 4:
1087                 fMinEnergy=0.2;
1088                 break;
1089         case 5:
1090                 fMinEnergy=0.3;
1091                 break;
1092         case 6:
1093                 fMinEnergy=0.5;
1094                 break;
1095         case 7:
1096                 fMinEnergy=0.75;
1097                 break;
1098         case 8:
1099                 fMinEnergy=1.;
1100                 break;
1101         case 9:
1102                 fMinEnergy=1.25;
1103                 break;
1104         default:
1105                 AliError(Form("Minimum Energy Cut not defined %d",minEnergy));
1106                 return kFALSE;
1107         }
1108         return kTRUE;
1109 }
1110
1111 //___________________________________________________________________
1112 Bool_t AliCaloPhotonCuts::SetMinNCellsCut(Int_t minNCells)
1113 {
1114         switch(minNCells){
1115         case 0:
1116                 fMinNCells=0;
1117                 break;
1118         case 1:
1119                 fMinNCells=1;
1120                 break;
1121         case 2:
1122                 fMinNCells=2;
1123                 break;
1124         case 3:
1125                 fMinNCells=3;
1126                 break;
1127         case 4:
1128                 fMinNCells=4;
1129                 break;
1130         case 5:
1131                 fMinNCells=5;
1132                 break;
1133         case 6:
1134                 fMinNCells=6;
1135                 break;
1136
1137         default:
1138                 AliError(Form("Min N cells Cut not defined %d",minNCells));
1139                 return kFALSE;
1140         }
1141         return kTRUE;
1142 }
1143
1144 //___________________________________________________________________
1145 Bool_t AliCaloPhotonCuts::SetMaxM02(Int_t maxM02)
1146 {
1147         switch(maxM02){
1148         case 0:
1149                 fMaxM02=100;
1150                 break;
1151         case 1:
1152                 fMaxM02=1.;
1153                 break;
1154         case 2:
1155                 fMaxM02=0.7;
1156                 break;
1157         case 3:
1158                 fMaxM02=0.5;
1159                 break;
1160         case 4:
1161                 fMaxM02=0.4;
1162                 break;
1163
1164         default:
1165                 AliError(Form("Max M02 Cut not defined %d",maxM02));
1166                 return kFALSE;
1167         }
1168         return kTRUE;
1169 }
1170
1171 //___________________________________________________________________
1172 Bool_t AliCaloPhotonCuts::SetMinM02(Int_t minM02)
1173 {
1174         switch(minM02){
1175         case 0:
1176                 fMinM02=0;
1177                 break;
1178         case 1:
1179                 fMinM02=0.002;
1180                 break;
1181         default:
1182                 AliError(Form("Min M02 not defined %d",minM02));
1183                 return kFALSE;
1184         }
1185         return kTRUE;
1186 }
1187
1188 //___________________________________________________________________
1189 Bool_t AliCaloPhotonCuts::SetMaxM20(Int_t maxM20)
1190 {
1191         switch(maxM20){
1192         case 0:
1193                 fMaxM20=100;
1194                 break;
1195         case 1:
1196                 fMaxM20=0.5;
1197                 break;
1198         default:
1199                 AliError(Form("Max M20 Cut not defined %d",maxM20));
1200                 return kFALSE;
1201         }
1202         return kTRUE;
1203 }
1204
1205 //___________________________________________________________________
1206 Bool_t AliCaloPhotonCuts::SetMinM20(Int_t minM20)
1207 {
1208         switch(minM20){
1209         case 0:
1210                 fMinM20=0;
1211                 break;
1212         case 1:
1213                 fMinM20=0.002;
1214                 break;
1215         default:
1216                 AliError(Form("Min M20 Cut not defined %d",minM20));
1217                 return kFALSE;
1218         }
1219         return kTRUE;
1220 }
1221
1222 //___________________________________________________________________
1223 Bool_t AliCaloPhotonCuts::SetDispersion(Int_t dispersion)
1224 {
1225         switch(dispersion){
1226         case 0:
1227                 fMaxDispersion =100;
1228                 break;
1229         case 1:
1230                 fMaxDispersion=2.;
1231                 break;
1232         default:
1233                 AliError(Form("Maximum Dispersion Cut not defined %d",dispersion));
1234                 return kFALSE;
1235         }
1236         return kTRUE;
1237 }
1238
1239 //___________________________________________________________________
1240 Bool_t AliCaloPhotonCuts::SetNLM(Int_t nlm)
1241 {
1242         switch(nlm){
1243         case 0:
1244                 fMinNLM =0;
1245                 fMaxNLM =100;
1246                 break;
1247         case 1:
1248                 fMinNLM =0;
1249                 fMaxNLM =1;
1250                 break;
1251         default:
1252                 AliError(Form("NLM Cut not defined %d",nlm));
1253                 return kFALSE;
1254         }
1255         return kTRUE;
1256 }
1257
1258 ///________________________________________________________________________
1259 TString AliCaloPhotonCuts::GetCutNumber(){
1260    // returns TString with current cut number
1261    TString a(kNCuts);
1262    for(Int_t ii=0;ii<kNCuts;ii++){
1263       a.Append(Form("%d",fCuts[ii]));
1264    }
1265    return a;
1266 }
1267
1268