AliIsolationCut
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 24 Jul 2011 20:57:38 +0000 (20:57 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 24 Jul 2011 20:57:38 +0000 (20:57 +0000)
 - Remove comented code lines
AliMCAnalysisUtils
  - Provide vertex of MC particles, for conversion photon studies
AliAnaPi0EbE
  - Cut on cluster pair time added
  - New histograms/code for shower shape studies added
  - Correct the loops maximum indeces
  - Cosmetics
AliAnaPi0
  - Cut on cluster pair time added
AliAnaPhoton
  - Conversion photon search, histograms with approx distance to conversion vetex
  - Shower Shape histograms, to swich on on demand

PWG4/PartCorrBase/AliIsolationCut.cxx
PWG4/PartCorrBase/AliMCAnalysisUtils.cxx
PWG4/PartCorrBase/AliMCAnalysisUtils.h
PWG4/PartCorrDep/AliAnaPhoton.cxx
PWG4/PartCorrDep/AliAnaPhoton.h
PWG4/PartCorrDep/AliAnaPi0.cxx
PWG4/PartCorrDep/AliAnaPi0.h
PWG4/PartCorrDep/AliAnaPi0EbE.cxx
PWG4/PartCorrDep/AliAnaPi0EbE.h

index 6ee3497..ad2891d 100755 (executable)
@@ -180,12 +180,7 @@ void  AliIsolationCut::MakeIsolationCut(TObjArray * const plCTS,  TObjArray * co
   //Check neutral particles in cone.  
   if(plNe && (fPartInCone==kOnlyNeutral || fPartInCone==kNeutralAndCharged)){
          
-    //Get vertex for photon momentum calculation
-    //Double_t vertex2[] = {0,0,0} ; //vertex second AOD input ;
-    //if(reader->GetDataType()!= AliCaloTrackReader::kMC) 
-    //{
-      //if(reader->GetSecondInputAODTree()) reader->GetSecondInputAODVertex(vertex2);
-    //}
+
     TLorentzVector mom ;
     for(Int_t ipr = 0;ipr < plNe->GetEntries() ; ipr ++ ){
       AliVCluster * calo = (AliVCluster *)(plNe->At(ipr)) ;
@@ -201,15 +196,7 @@ void  AliIsolationCut::MakeIsolationCut(TObjArray * const plCTS,  TObjArray * co
       
       if(calo->GetNTracksMatched() > 0) continue ; 
       
-      //Input from second AOD?
-      //Int_t input = 0;
-      //      if     (pCandidate->GetDetector() == "EMCAL" && reader->GetAODEMCALNormalInputEntries() <= ipr) input = 1 ;
-      //      else if(pCandidate->GetDetector() == "PHOS"  && reader->GetAODPHOSNormalInputEntries()  <= ipr) input = 1;
-      
-      //Get Momentum vector, 
-      //if     (input == 0) 
       calo->GetMomentum(mom,reader->GetVertex(evtIndex)) ;//Assume that come from vertex in straight line
-      //else if(input == 1) calo->GetMomentum(mom,vertex2);//Assume that come from vertex in straight line  
       
       pt   = mom.Pt();
       eta  = mom.Eta();
@@ -224,7 +211,7 @@ void  AliIsolationCut::MakeIsolationCut(TObjArray * const plCTS,  TObjArray * co
         nfrac     = -1;
         coneptsum = -1;
         isolated  = kFALSE;
-       leading = kFALSE;
+        leading   = kFALSE;
         if(bFillAOD){
           if(reftracks){  
             reftracks  ->Clear();
index 8759522..ea50544 100755 (executable)
@@ -30,6 +30,7 @@
 #include <TList.h>
 #include "TParticle.h"
 #include "TDatabasePDG.h"
+#include "TVector3.h"
 
 //---- ANALYSIS system ----
 #include "AliMCAnalysisUtils.h"
@@ -47,30 +48,6 @@ fJetsList(new TList), fMCGenerator("PYTHIA")
 {
   //Ctor
 }
-/*
- //____________________________________________________________________________
- AliMCAnalysisUtils::AliMCAnalysisUtils(const AliMCAnalysisUtils & mcutils) :   
- TObject(mcutils), fCurrentEvent(mcutils.fCurrentEvent), fDebug(mcutils.fDebug),
- fJetsList(new TList), fMCGenerator(mcutils.fMCGenerator)
- {
- // cpy ctor
- }
- */
-
-//_________________________________________________________________________
-//AliMCAnalysisUtils & AliMCAnalysisUtils::operator = (const AliMCAnalysisUtils & mcutils)
-//{
-//  // assignment operator
-//  
-//  if(&mcutils == this) return *this;
-//  fCurrentEvent = mcutils.fCurrentEvent ;
-//  fDebug        = mcutils.fDebug;
-//  fJetsList     = mcutils.fJetsList;
-//  fMCGenerator  = mcutils.fMCGenerator;
-//  
-//  return *this; 
-//}
 
 //____________________________________________________________________________
 AliMCAnalysisUtils::~AliMCAnalysisUtils() 
@@ -107,7 +84,7 @@ Int_t AliMCAnalysisUtils::CheckOrigin(const Int_t * label, const Int_t nlabels,
 
 //_________________________________________________________________________
 Int_t AliMCAnalysisUtils::CheckCommonAncestor(const Int_t index1, const Int_t index2, AliCaloTrackReader* reader, 
-                                              Int_t & ancPDG, Int_t & ancStatus, TLorentzVector & momentum) {
+                                              Int_t & ancPDG, Int_t & ancStatus, TLorentzVector & momentum, TVector3 & prodVertex) {
   //Check the first common ancestor of 2 clusters, given the most likely labels of the primaries generating such clusters.
   Int_t label1[100];
   Int_t label2[100];
@@ -189,6 +166,7 @@ Int_t AliMCAnalysisUtils::CheckCommonAncestor(const Int_t index1, const Int_t in
             ancPDG    = mom->GetPdgCode();
             ancStatus = mom->GetStatus();
             momentum.SetPxPyPzE(mom->Px(),mom->Py(),mom->Pz(),mom->E());
+            prodVertex.SetXYZ(mom->Xv(),mom->Yv(),mom->Zv());
           }
         }
         else {
@@ -197,6 +175,7 @@ Int_t AliMCAnalysisUtils::CheckCommonAncestor(const Int_t index1, const Int_t in
             ancPDG    = mom->GetPdgCode();
             ancStatus = mom->GetStatusCode();
             mom->Momentum(momentum);
+            prodVertex.SetXYZ(mom->Vx(),mom->Vy(),mom->Vz());
           }
         }
         //First ancestor found, end the loops
index 958a7ee..debdff3 100755 (executable)
@@ -17,6 +17,7 @@
 #include <TObject.h>
 #include <TString.h> 
 class TList ;
+class TVector3;
 
 //--- AliRoot system ---
 class AliCaloTrackReader ;
@@ -45,7 +46,7 @@ class AliMCAnalysisUtils : public TObject {
        
        //Check only the label of the most significant particle
   Int_t   CheckCommonAncestor(const Int_t index1, const Int_t index2, AliCaloTrackReader* reader, 
-                              Int_t & ancPDG, Int_t & ancStatus, TLorentzVector & momentum) ;
+                              Int_t & ancPDG, Int_t & ancStatus, TLorentzVector & momentum, TVector3 & v) ;
        Int_t   CheckOrigin(const Int_t label, AliCaloTrackReader * reader, const Int_t input) ;
        //Check the label of the most significant particle but do checks on the rest of the contributing labels
        Int_t   CheckOrigin(const Int_t *label, const Int_t nlabels, AliCaloTrackReader * reader, const Int_t input) ;
index 0eaf92d..8580b30 100755 (executable)
@@ -53,14 +53,25 @@ ClassImp(AliAnaPhoton)
   AliAnaPhoton::AliAnaPhoton() : 
     AliAnaPartCorrBaseClass(), fCalorimeter(""), 
     fMinDist(0.),fMinDist2(0.),fMinDist3(0.),fRejectTrackMatch(0),
-    fTimeCutMin(-1), fTimeCutMax(9999999), fNCellsCut(0),
+    fTimeCutMin(-1), fTimeCutMax(9999999), fNCellsCut(0), fFillSSHistograms(kFALSE),
     fCheckConversion(kFALSE), fRemoveConvertedPair(kFALSE), fAddConvertedPairsToAOD(kFALSE), fMassCut(0),
     fConvAsymCut(1.), fConvDEtaCut(2.),fConvDPhiMinCut(-1.), fConvDPhiMaxCut(7.), 
-    //fhVertex(0), 
-    fhNtraNclu(0), fhNCellsPt(0),
+    // Histograms
+    fhNtraNclu(0), fhNCellsE(0),  
+    //Shower shape histograms
+    fhNCellsLam0LowE(0),  fhNCellsLam1LowE(0),  fhNCellsDispLowE(0),  
+    fhNCellsLam0HighE(0), fhNCellsLam1HighE(0), fhNCellsDispHighE(0),
+    fhEtaLam0(0),         fhPhiLam0(0), 
+    fhLam1Lam0LowE(0),    fhLam1Lam0HighE(0), 
+    fhLam0E(0),           fhLam1E(0),
+    // Spectra histograms
     fhEPhoton(0),      fhPtPhoton(0),  fhPhiPhoton(0),  fhEtaPhoton(0),  fhEtaPhiPhoton(0), fhEtaPhi05Photon(0),
+    // Conversion histograms
     fhPtPhotonConv(0), fhEtaPhiPhotonConv(0),fhEtaPhi05PhotonConv(0),
     fhConvDeltaEta(0), fhConvDeltaPhi(0),    fhConvDeltaEtaPhi(0), fhConvAsym(0),     fhConvPt(0),
+    fhConvDistEta(0),  fhConvDistEn(0),      fhConvDistMass(0),     
+    fhConvDistEtaCutEta(0),  fhConvDistEnCutEta(0),       fhConvDistMassCutEta(0),
+    fhConvDistEtaCutMass(0), fhConvDistEnCutMass(0), fhConvDistEtaCutAsy(0), fhConvDistEnCutAsy(0), 
     //MC
     fhDeltaE(0), fhDeltaPt(0),fhRatioE(0), fhRatioPt(0),fh2E(0),fh2Pt(0),
     fhPtMCPhoton(0),fhPhiMCPhoton(0),fhEtaMCPhoton(0), 
@@ -77,7 +88,8 @@ ClassImp(AliAnaPhoton)
     fhConvDeltaEtaMCConversion(0),  fhConvDeltaPhiMCConversion(0),  fhConvDeltaEtaPhiMCConversion(0),  fhConvAsymMCConversion(0),  fhConvPtMCConversion(0),  fhConvDispersionMCConversion(0), fhConvM02MCConversion(0),
     fhConvDeltaEtaMCAntiNeutron(0), fhConvDeltaPhiMCAntiNeutron(0), fhConvDeltaEtaPhiMCAntiNeutron(0), fhConvAsymMCAntiNeutron(0), fhConvPtMCAntiNeutron(0), fhConvDispersionMCAntiNeutron(0),fhConvM02MCAntiNeutron(0),
     fhConvDeltaEtaMCAntiProton(0),  fhConvDeltaPhiMCAntiProton(0),  fhConvDeltaEtaPhiMCAntiProton(0),  fhConvAsymMCAntiProton(0),  fhConvPtMCAntiProton(0),  fhConvDispersionMCAntiProton(0), fhConvM02MCAntiProton(0),
-    fhConvDeltaEtaMCString(0),      fhConvDeltaPhiMCString(0),      fhConvDeltaEtaPhiMCString(0),      fhConvAsymMCString(0),      fhConvPtMCString(0),      fhConvDispersionMCString(0),     fhConvM02MCString(0)
+    fhConvDeltaEtaMCString(0),      fhConvDeltaPhiMCString(0),      fhConvDeltaEtaPhiMCString(0),      fhConvAsymMCString(0),      fhConvPtMCString(0),      fhConvDispersionMCString(0),     fhConvM02MCString(0),
+    fhConvDistMCConversion(0),      fhConvDistMCConversionCuts(0)
 {
   //default ctor
   
@@ -91,6 +103,69 @@ AliAnaPhoton::~AliAnaPhoton()
 
 }
 
+//__________________________________________________________________
+Bool_t  AliAnaPhoton::ClusterSelected(AliVCluster* calo, TLorentzVector mom) 
+{
+  //Select clusters if they pass different cuts
+  if(GetDebug() > 2) 
+    printf("AliAnaPhoton::ClusterSelected() Current Event %d; Before selection : E %2.2f, pT %2.2f, Ecl %2.2f, phi %2.2f, eta %2.2f\n",
+           GetReader()->GetEventNumber(),
+           mom.E(), mom.Pt(),calo->E(),mom.Phi()*TMath::RadToDeg(),mom.Eta());
+  
+  //.......................................
+  //If too small or big energy, skip it
+  if(mom.E() < GetMinEnergy() || mom.E() > GetMaxEnergy() ) return kFALSE ; 
+  if(GetDebug() > 2) printf("\t Cluster %d Pass E Cut \n",calo->GetID());
+  
+  //.......................................
+  // TOF cut, BE CAREFUL WITH THIS CUT
+  Double_t tof = calo->GetTOF()*1e9;
+  if(tof < fTimeCutMin || tof > fTimeCutMax) return kFALSE;
+  if(GetDebug() > 2)  printf("\t Cluster %d Pass Time Cut \n",calo->GetID());
+  
+  //.......................................
+  if(calo->GetNCells() <= fNCellsCut && GetReader()->GetDataType() != AliCaloTrackReader::kMC) return kFALSE;
+  if(GetDebug() > 2) printf("\t Cluster %d Pass NCell Cut \n",calo->GetID());
+  
+  //.......................................
+  //Check acceptance selection
+  if(IsFiducialCutOn()){
+    Bool_t in = GetFiducialCut()->IsInFiducialCut(mom,fCalorimeter) ;
+    if(! in ) return kFALSE ;
+  }
+  if(GetDebug() > 2) printf("Fiducial cut passed \n");
+  
+  //.......................................
+  //Skip matched clusters with tracks
+  if(fRejectTrackMatch){
+    if(IsTrackMatched(calo)) {
+      if(GetDebug() > 2) printf("\t Reject track-matched clusters\n");
+      return kFALSE ;
+    }
+    else  
+      if(GetDebug() > 2)  printf(" Track-matching cut passed \n");
+  }// reject matched clusters
+  
+  //.......................................
+  //Check Distance to Bad channel, set bit.
+  Double_t distBad=calo->GetDistanceToBadChannel() ; //Distance to bad channel
+  if(distBad < 0.) distBad=9999. ; //workout strange convension dist = -1. ;
+  if(distBad < fMinDist) {//In bad channel (PHOS cristal size 2.2x2.2 cm), EMCAL ( cell units )
+    return kFALSE ;
+  }
+  else if(GetDebug() > 2) printf("\t Bad channel cut passed %4.2f > %2.2f \n",distBad, fMinDist);
+  //printf("Cluster %d Pass Bad Dist Cut \n",icalo);
+
+  if(GetDebug() > 0) 
+    printf("AliAnaPhoton::ClusterSelected() Current Event %d; After  selection : E %2.2f, pT %2.2f, Ecl %2.2f, phi %2.2f, eta %2.2f\n",
+           GetReader()->GetEventNumber(), 
+           mom.E(), mom.Pt(),calo->E(),mom.Phi()*TMath::RadToDeg(),mom.Eta());
+  
+  //All checks passed, cluster selected
+  return kTRUE;
+    
+}
+
 //________________________________________________________________________
 TObjString *  AliAnaPhoton::GetAnalysisCuts()
 {      
@@ -146,22 +221,84 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
   Float_t phimin = GetHistoPhiMin();
   Float_t etamin = GetHistoEtaMin();   
   
-  //Histograms of highest Photon identified in Event
-//  fhVertex  = new TH3D ("Vertex","vertex position", 20,-10.,10., 20,-10.,10., 80,-40.,40.); 
-//  fhVertex->SetXTitle("X");
-//  fhVertex->SetYTitle("Y");
-//  fhVertex->SetZTitle("Z");
-//  outputContainer->Add(fhVertex);
-  
   fhNtraNclu  = new TH2F ("hNtracksNcluster","# of tracks vs # of clusters", 500,0,500, 500,0,500); 
   fhNtraNclu->SetXTitle("# of tracks");
   fhNtraNclu->SetYTitle("# of clusters");
   outputContainer->Add(fhNtraNclu);
   
-  fhNCellsPt  = new TH2F ("hNCellsPt","# of cells in cluster vs E of clusters", nptbins,ptmin, ptmax, 100,0,100); 
-  fhNCellsPt->SetXTitle("p_{T} (GeV/c)");
-  fhNCellsPt->SetYTitle("# of cells in cluster");
-  outputContainer->Add(fhNCellsPt);  
+  
+  fhNCellsE  = new TH2F ("hNCellsE","# of cells in cluster vs E of clusters", 100,0, 20, 20,0,20); 
+  fhNCellsE->SetXTitle("E (GeV)");
+  fhNCellsE->SetYTitle("# of cells in cluster");
+  outputContainer->Add(fhNCellsE);  
+
+  if(fFillSSHistograms){
+    
+    fhNCellsLam0LowE  = new TH2F ("hNCellsLam0LowE","# of cells in cluster vs #lambda_{0}, E < 2 GeV", 20,0, 20, 200,0,1); 
+    fhNCellsLam0LowE->SetXTitle("N Cells");
+    fhNCellsLam0LowE->SetYTitle("#lambda_{0}");
+    outputContainer->Add(fhNCellsLam0LowE);  
+    
+    
+    fhNCellsLam0HighE  = new TH2F ("hNCellsLam0HighE","# of cells in cluster vs #lambda_{0}, E > 2 GeV", 20,0, 20, 200,0,1); 
+    fhNCellsLam0HighE->SetXTitle("N Cells");
+    fhNCellsLam0HighE->SetYTitle("#lambda_{0}");
+    outputContainer->Add(fhNCellsLam0HighE);  
+    
+    fhNCellsLam1LowE  = new TH2F ("hNCellsLam1LowE","# of cells in cluster vs #lambda_{1}, E < 2 GeV", 20,0, 20, 200,0,1); 
+    fhNCellsLam1LowE->SetXTitle("N Cells");
+    fhNCellsLam1LowE->SetYTitle("#lambda_{0}");
+    outputContainer->Add(fhNCellsLam1LowE);  
+    
+    fhNCellsLam1HighE  = new TH2F ("hNCellsLam1HighE","# of cells in cluster vs #lambda_{1}, E > 2 GeV", 20,0, 20, 200,0,1); 
+    fhNCellsLam1HighE->SetXTitle("N Cells");
+    fhNCellsLam1HighE->SetYTitle("#lambda_{0}");
+    outputContainer->Add(fhNCellsLam1HighE);  
+    
+    
+    fhNCellsDispLowE  = new TH2F ("hNCellsDispLowE","# of cells in cluster vs dispersion, E < 2 GeV", 20,0, 20, 200,0,2); 
+    fhNCellsDispLowE->SetXTitle("N Cells");
+    fhNCellsDispLowE->SetYTitle("dispersion");
+    outputContainer->Add(fhNCellsDispLowE);  
+    
+    fhNCellsDispHighE  = new TH2F ("hNCellsDispHighE","# of cells in cluster vs dispersion, E > 2 GeV", 20,0, 20, 200,0,2); 
+    fhNCellsDispHighE->SetXTitle("N Cells");
+    fhNCellsDispHighE->SetYTitle("dispersion");
+    outputContainer->Add(fhNCellsDispHighE);  
+    
+    fhEtaLam0  = new TH2F ("hEtaLam0","#eta vs #lambda_{0}",200,-0.8,0.8,  200,0,1); 
+    fhEtaLam0->SetYTitle("#lambda_{0}");
+    fhEtaLam0->SetXTitle("#eta");
+    outputContainer->Add(fhEtaLam0);  
+    
+    fhPhiLam0  = new TH2F ("hPhiLam0","#phi vs #lambda_{0}", 200,80*TMath::DegToRad(),120*TMath::DegToRad(),  200,0,1); 
+    fhPhiLam0->SetYTitle("#lambda_{0}");
+    fhPhiLam0->SetXTitle("#phi");
+    outputContainer->Add(fhPhiLam0);  
+    
+    
+    fhLam1Lam0LowE  = new TH2F ("hLam1Lam0LowE","#lambda_{0} vs #lambda_{1} in cluster of E < 2 GeV",  200,0,1,  200,0,1); 
+    fhLam1Lam0LowE->SetYTitle("#lambda_{0}");
+    fhLam1Lam0LowE->SetXTitle("#lambda_{1}");
+    outputContainer->Add(fhLam1Lam0LowE);  
+    
+    
+    fhLam1Lam0HighE  = new TH2F ("hLam1Lam0HighE","#lambda_{0} vs #lambda_{1} in cluster of E > 2 GeV",  200,0,1,  200,0,1); 
+    fhLam1Lam0HighE->SetYTitle("#lambda_{0}");
+    fhLam1Lam0HighE->SetXTitle("#lambda_{1}");
+    outputContainer->Add(fhLam1Lam0HighE);  
+    
+    
+    fhLam0E  = new TH2F ("hLam0E","#lambda_{0} vs E",  100,0, 20,  200,0,1); 
+    fhLam0E->SetYTitle("#lambda_{0}");
+    fhLam0E->SetXTitle("E (GeV)");
+    outputContainer->Add(fhLam0E);  
+    
+    fhLam1E  = new TH2F ("hLam1E","#lambda_{1} vs E",  100,0, 20,  200,0,1); 
+    fhLam1E->SetYTitle("#lambda_{1}");
+    fhLam1E->SetXTitle("E (GeV)");
+    outputContainer->Add(fhLam1E);  
+  }
   
   fhEPhoton  = new TH1F("hEPhoton","Number of #gamma over calorimeter vs energy",nptbins,ptmin,ptmax); 
   fhEPhoton->SetYTitle("N");
@@ -247,6 +384,67 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
     fhConvPt->SetYTitle("Pair p_{T} (GeV/c)");
     fhConvPt->SetXTitle("Pair Mass (GeV/c^2)");
     outputContainer->Add(fhConvPt) ;
+    
+    fhConvDistEta  = new TH2F
+    ("hConvDistEta","distance to conversion vertex",100,-0.7,0.7,100,0.,5.); 
+    fhConvDistEta->SetXTitle("#eta");
+    fhConvDistEta->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistEta) ;
+    
+    fhConvDistEn  = new TH2F
+    ("hConvDistEn","distance to conversion vertex",nptbins,ptmin,ptmax,100,0.,5.); 
+    fhConvDistEn->SetXTitle("E (GeV)");
+    fhConvDistEn->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistEn) ;
+
+    fhConvDistMass  = new TH2F
+    ("hConvDistMass","distance to conversion vertex",100,0,fMassCut,100,0.,5.); 
+    fhConvDistMass->SetXTitle("m (GeV/c^2)");
+    fhConvDistMass->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistMass) ;
+    
+    fhConvDistEtaCutEta  = new TH2F
+    ("hConvDistEtaCutEta","distance to conversion vertex, dEta < 0.05",100,-0.7,0.7,100,0.,5.); 
+    fhConvDistEtaCutEta->SetXTitle("#eta");
+    fhConvDistEtaCutEta->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistEtaCutEta) ;
+    
+    fhConvDistEnCutEta  = new TH2F
+    ("hConvDistEnCutEta","distance to conversion vertex, dEta < 0.05",nptbins,ptmin,ptmax,100,0.,5.); 
+    fhConvDistEnCutEta->SetXTitle("E (GeV)");
+    fhConvDistEnCutEta->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistEnCutEta) ;
+    
+    fhConvDistMassCutEta  = new TH2F
+    ("hConvDistMassCutEta","distance to conversion vertex, dEta < 0.05",100,0,fMassCut,100,0.,5.); 
+    fhConvDistMassCutEta->SetXTitle("m (GeV/c^2)");
+    fhConvDistMassCutEta->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistMassCutEta) ;
+    
+    fhConvDistEtaCutMass  = new TH2F
+    ("hConvDistEtaCutMass","distance to conversion vertex, dEta < 0.05, m < 10 MeV",100,-0.7,0.7,100,0.,5.); 
+    fhConvDistEtaCutMass->SetXTitle("#eta");
+    fhConvDistEtaCutMass->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistEtaCutMass) ;
+    
+    fhConvDistEnCutMass  = new TH2F
+    ("hConvDistEnCutMass","distance to conversion vertex, dEta < 0.05, m < 10 MeV",nptbins,ptmin,ptmax,100,0.,5.); 
+    fhConvDistEnCutMass->SetXTitle("E (GeV)");
+    fhConvDistEnCutMass->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistEnCutMass) ;
+
+    fhConvDistEtaCutAsy  = new TH2F
+    ("hConvDistEtaCutAsy","distance to conversion vertex, dEta < 0.05, m < 10 MeV, A < 0.1",100,-0.7,0.7,100,0.,5.); 
+    fhConvDistEtaCutAsy->SetXTitle("#eta");
+    fhConvDistEtaCutAsy->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistEtaCutAsy) ;
+    
+    fhConvDistEnCutAsy  = new TH2F
+    ("hConvDistEnCutAsy","distance to conversion vertex, dEta < 0.05, m < 10 MeV, A < 0.1",nptbins,ptmin,ptmax,100,0.,5.); 
+    fhConvDistEnCutAsy->SetXTitle("E (GeV)");
+    fhConvDistEnCutAsy->SetYTitle(" distance (m)");
+    outputContainer->Add(fhConvDistEnCutAsy) ;
+    
   }
   
   if(IsDataMC()){
@@ -646,7 +844,20 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
       ("hConvM02MCString","p_{T} of selected conversion pairs from string",100,0.,1.,100,0.,1.); 
       fhConvM02MCString->SetYTitle("M02 cluster 1");
       fhConvM02MCString->SetXTitle("M02 cluster 2");
-      outputContainer->Add(fhConvM02MCString) ;       
+      outputContainer->Add(fhConvM02MCString) ; 
+      
+      fhConvDistMCConversion  = new TH2F
+      ("hConvDistMCConversion","calculated conversion distance vs real vertes for MC conversion",100,0.,5.,100,0.,5.); 
+      fhConvDistMCConversion->SetYTitle("distance");
+      fhConvDistMCConversion->SetXTitle("vertex R");
+      outputContainer->Add(fhConvDistMCConversion) ; 
+      
+      fhConvDistMCConversionCuts  = new TH2F
+      ("hConvDistMCConversionCuts","calculated conversion distance vs real vertes for MC conversion, deta < 0.05, m < 10 MeV, asym < 0.1",100,0.,5.,100,0.,5.); 
+      fhConvDistMCConversionCuts->SetYTitle("distance");
+      fhConvDistMCConversionCuts->SetXTitle("vertex R");
+      outputContainer->Add(fhConvDistMCConversionCuts) ; 
+      
     }
     
   }//Histos with MC
@@ -748,7 +959,7 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
          
          AliVCluster * calo =  (AliVCluster*) (pl->At(icalo)); 
     //printf("calo %d, %f\n",icalo,calo->E());
-    
+
     //Get the index where the cluster comes, to retrieve the corresponding vertex
     Int_t evtIndex = 0 ; 
     if (GetMixedEvent()) {
@@ -781,59 +992,8 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     //--------------------------------------
     // Cluster selection
     //--------------------------------------
-    if(GetDebug() > 2) 
-      printf("AliAnaPhoton::MakeAnalysisFillAOD() Current Event %d; Before selection : E %2.2f, pT %2.2f, Ecl %2.2f, phi %2.2f, eta %2.2f\n",
-             GetReader()->GetEventNumber(),
-             mom.E(), mom.Pt(),calo->E(),mom.Phi()*TMath::RadToDeg(),mom.Eta());
-    //.......................................
-    //If too small or big pt, skip it
-    if(mom.E() < GetMinPt() || mom.E() > GetMaxPt() ) continue ; 
-    if(GetDebug() > 2) printf("\t Cluster %d Pass E Cut \n",icalo);
-    
-    //.......................................
-    // TOF cut, BE CAREFUL WITH THIS CUT
-    Double_t tof = calo->GetTOF()*1e9;
-    if(tof < fTimeCutMin || tof > fTimeCutMax) continue;
-         if(GetDebug() > 2)  printf("\t Cluster %d Pass Time Cut \n",icalo);
-    
-    //.......................................
-    if(calo->GetNCells() <= fNCellsCut && GetReader()->GetDataType() != AliCaloTrackReader::kMC) continue;
-    if(GetDebug() > 2) printf("\t Cluster %d Pass NCell Cut \n",icalo);
-    
-    //.......................................
-    //Check acceptance selection
-    if(IsFiducialCutOn()){
-      Bool_t in = GetFiducialCut()->IsInFiducialCut(mom,fCalorimeter) ;
-      if(! in ) continue ;
-    }
-    if(GetDebug() > 2) printf("Fiducial cut passed \n");
-    
-    //.......................................
-    //Skip matched clusters with tracks
-    if(fRejectTrackMatch){
-      if(IsTrackMatched(calo)) {
-        if(GetDebug() > 2) printf("\t Reject track-matched clusters\n");
-        continue ;
-      }
-      else  
-        if(GetDebug() > 2)  printf(" Track-matching cut passed \n");
-    }// reject matched clusters
-    
-    //.......................................
-    //Check Distance to Bad channel, set bit.
-    Double_t distBad=calo->GetDistanceToBadChannel() ; //Distance to bad channel
-    if(distBad < 0.) distBad=9999. ; //workout strange convension dist = -1. ;
-    if(distBad < fMinDist) {//In bad channel (PHOS cristal size 2.2x2.2 cm), EMCAL ( cell units )
-      continue ;
-    }
-    else if(GetDebug() > 2) printf("\t Bad channel cut passed %4.2f > %2.2f \n",distBad, fMinDist);
-    
-    if(GetDebug() > 0) 
-      printf("AliAnaPhoton::MakeAnalysisFillAOD() Current Event %d; After  selection : E %2.2f, pT %2.2f, Ecl %2.2f, phi %2.2f, eta %2.2f\n",
-             GetReader()->GetEventNumber(), 
-             mom.E(), mom.Pt(),calo->E(),mom.Phi()*TMath::RadToDeg(),mom.Eta());
     
+    if(!ClusterSelected(calo,mom)) continue;
     
     //----------------------------
     //Create AOD for analysis
@@ -844,15 +1004,14 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     //Set the indeces of the original caloclusters (MC, ID), and calorimeter  
     Int_t label = calo->GetLabel();
     aodph.SetLabel(label);
-    //aodph.SetInputFileIndex(input);    
+    //aodph.SetInputFileIndex(input);   
     aodph.SetCaloLabel(calo->GetID(),-1);
     aodph.SetDetector(fCalorimeter);
-    //printf("Index %d, Id %d\n",icalo, calo->GetID());
-
-    //printf("Cluster %d Pass Bad Dist Cut \n",icalo);
+    //printf("Index %d, Id %d, iaod %d\n",icalo, calo->GetID(),GetOutputAODBranch()->GetEntriesFast());
 
     //...............................................
     //Set bad channel distance bit
+    Double_t distBad=calo->GetDistanceToBadChannel() ; //Distance to bad channel
     if     (distBad > fMinDist3) aodph.SetDistToBad(2) ;
     else if(distBad > fMinDist2) aodph.SetDistToBad(1) ; 
     else                         aodph.SetDistToBad(0) ;
@@ -934,6 +1093,7 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
         //printf("Check Conversion indeces %d and %d\n",icalo,jcalo);
         AliVCluster * calo2 =  (AliVCluster*) (pl->At(jcalo));              //Get cluster kinematics
         
+        
         //Mixed event, get index of event
         Int_t evtIndex2 = 0 ; 
         if (GetMixedEvent()) {
@@ -949,10 +1109,17 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
           calo2->GetMomentum(mom2,vertex) ;
         }
         
-        //Check only certain regions
-        Bool_t in2 = kTRUE;
-        if(IsFiducialCutOn()) in2 =  GetFiducialCut()->IsInFiducialCut(mom2,fCalorimeter) ;
-        if(!in2) continue;      
+        //--------------------------------------
+        // Cluster selection
+        //--------------------------------------
+        
+        if(!ClusterSelected(calo2,mom2)) continue;  
+        
+        //................................................
+        // Get TOF of each cluster in pair, calculate difference if small, 
+        // take this pair. Way to reject clusters from hadrons (or pileup?)
+        Double_t t12diff = calo2->GetTOF()-calo->GetTOF()*1e9;
+        if(TMath::Abs(t12diff) > GetPairTimeCut()) continue;
         
         //................................................
         //Get mass of pair, if small, take this pair.
@@ -962,12 +1129,21 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
           aodph.SetTagged(kFALSE);
           id2 = calo2->GetID();
           indexConverted[icalo]=kTRUE;
-          indexConverted[jcalo]=kTRUE;
-          
+          indexConverted[jcalo]=kTRUE; 
           Float_t asymmetry = TMath::Abs(mom.E()-mom2.E())/(mom.E()+mom2.E());
           Float_t dPhi      = mom.Phi()-mom2.Phi();
           Float_t dEta      = mom.Eta()-mom2.Eta();  
           
+          //...............................................
+          //Fill few histograms with kinematics of the pair
+          //FIXME, move all this to MakeAnalysisFillHistograms ...
+          
+          fhConvDeltaEta   ->Fill( pairM, dPhi      );
+          fhConvDeltaPhi   ->Fill( pairM, dEta      );
+          fhConvAsym       ->Fill( pairM, asymmetry );
+          fhConvDeltaEtaPhi->Fill( dEta , dPhi      );
+          fhConvPt         ->Fill( pairM, (mom+mom2).Pt());          
+          
           //Estimate conversion distance, T. Awes, M. Ivanov
           //Under the assumption that the pair has zero mass, and that each electron 
           //of the pair has the same momentum, they will each have the same bend radius 
@@ -978,32 +1154,50 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
           //as d = sqrt(R^2 -(R-y)^2) = sqrt(2Ry - y^2). And since R>>y we can write as 
           //d = sqrt(E*L/1.5) where E is the cluster energy and L is the distance in cm between 
           //the clusters.
-//          Float_t pos1[3];
-//          calo->GetPosition(pos1); 
-//          Float_t pos2[3];
-//          calo2->GetPosition(pos2); 
-//          Float_t l = TMath::Sqrt((pos1[0]-pos2[0])*(pos1[0]-pos2[0])+
-//                                  (pos1[1]-pos2[1])*(pos1[1]-pos2[1])+
-//                                  (pos1[2]-pos2[2])*(pos1[2]-pos2[2]));
-//          
-//          Float_t convDist  = TMath::Sqrt(mom.E() *l/1.5);
-//          Float_t convDist2 = TMath::Sqrt(mom2.E()*l/1.5);
-//          printf("l = %f, e1 = %f, d1=%f, e2 = %f, d2=%f\n",l,mom.E(),convDist,mom2.E(),convDist2);
+          Float_t pos1[3];
+          calo->GetPosition(pos1); 
+          Float_t pos2[3];
+          calo2->GetPosition(pos2); 
+          Float_t clustDist = TMath::Sqrt((pos1[0]-pos2[0])*(pos1[0]-pos2[0])+
+                                  (pos1[1]-pos2[1])*(pos1[1]-pos2[1])+
+                                  (pos1[2]-pos2[2])*(pos1[2]-pos2[2]));
+          
+          Float_t convDist  = TMath::Sqrt(mom.E() *clustDist*0.01/0.15);
+          Float_t convDist2 = TMath::Sqrt(mom2.E()*clustDist*0.01/0.15);
+          //printf("l = %f, e1 = %f, d1=%f, e2 = %f, d2=%f\n",clustDist,mom.E(),convDist,mom2.E(),convDist2);
           if(GetDebug() > 2)
             printf("AliAnaPhoton::MakeAnalysisFillAOD(): Pair with mass %2.3f < %2.3f, %1.2f < dPhi %2.2f < %2.2f, dEta %f < %2.2f, asymmetry %2.2f< %2.2f; \n    cluster1 id %d, e %2.3f  SM %d, eta %2.3f, phi %2.3f ; \n    cluster2 id %d, e %2.3f, SM %d,eta %2.3f, phi %2.3f\n",
                    pairM,fMassCut,fConvDPhiMinCut, dPhi, fConvDPhiMaxCut, dEta, fConvDEtaCut, asymmetry, fConvAsymCut,
                    calo->GetID(),calo->E(),GetCaloUtils()->GetModuleNumber(calo), mom.Eta(), mom.Phi(),
                    id2, calo2->E(), GetCaloUtils()->GetModuleNumber(calo2),mom2.Eta(), mom2.Phi());
           
-          //...............................................
-          //Fill few histograms with kinematics of the pair
-          //FIXME, move all this to MakeAnalysisFillHistograms ...
-
-          fhConvDeltaEta   ->Fill( pairM, dPhi      );
-          fhConvDeltaPhi   ->Fill( pairM, dEta      );
-          fhConvAsym       ->Fill( pairM, asymmetry );
-          fhConvDeltaEtaPhi->Fill( dEta , dPhi      );
-          fhConvPt         ->Fill( pairM, (mom+mom2).Pt());
+          fhConvDistEta ->Fill(mom .Eta(), convDist );
+          fhConvDistEta ->Fill(mom2.Eta(), convDist2);
+          fhConvDistEn  ->Fill(mom .E(), convDist );
+          fhConvDistEn  ->Fill(mom2.E(), convDist2);        
+          fhConvDistMass->Fill((mom+mom2).M(), convDist );
+          //dEta cut
+          if(dEta<0.05){
+            fhConvDistEtaCutEta ->Fill(mom .Eta(), convDist );
+            fhConvDistEtaCutEta ->Fill(mom2.Eta(), convDist2);
+            fhConvDistEnCutEta  ->Fill(mom .E(),   convDist );
+            fhConvDistEnCutEta  ->Fill(mom2.E(),   convDist2);        
+            fhConvDistMassCutEta->Fill((mom+mom2).M(), convDist );
+            //mass cut
+            if(pairM<0.01){//10 MeV
+              fhConvDistEtaCutMass ->Fill(mom .Eta(), convDist );
+              fhConvDistEtaCutMass ->Fill(mom2.Eta(), convDist2);
+              fhConvDistEnCutMass  ->Fill(mom .E(),   convDist );
+              fhConvDistEnCutMass  ->Fill(mom2.E(),   convDist2);        
+              // asymmetry cut
+              if(asymmetry<0.1){
+                fhConvDistEtaCutAsy ->Fill(mom .Eta(), convDist );
+                fhConvDistEtaCutAsy ->Fill(mom2.Eta(), convDist2);
+                fhConvDistEnCutAsy  ->Fill(mom .E(),   convDist );
+                fhConvDistEnCutAsy  ->Fill(mom2.E(),   convDist2); 
+              }//asymmetry cut
+            }//mass cut            
+          }//dEta cut
           
           //...............................................
           //Select pairs in a eta-phi window
@@ -1023,8 +1217,9 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
             Int_t ancPDG    = 0;
             Int_t ancStatus = 0;
             TLorentzVector momentum;
+            TVector3 prodVertex;
             Int_t ancLabel  = GetMCAnalysisUtils()->CheckCommonAncestor(calo->GetLabel(), calo2->GetLabel(), 
-                                                                        GetReader(), ancPDG, ancStatus, momentum);
+                                                                        GetReader(), ancPDG, ancStatus, momentum, prodVertex);
             
             // printf("AliAnaPhoton::MakeAnalysisFillHistograms() - Common ancestor label %d, pdg %d, name %s, status %d; \n",
             //                          ancLabel,ancPDG,TDatabasePDG::Instance()->GetParticle(ancPDG)->GetName(),ancStatus);
@@ -1039,6 +1234,13 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
                 fhConvPtMCConversion         ->Fill( pairM, (mom+mom2).Pt());
                 fhConvDispersionMCConversion ->Fill( calo->GetDispersion(), calo2->GetDispersion());
                 fhConvM02MCConversion        ->Fill( calo->GetM02(), calo2->GetM02());
+                fhConvDistMCConversion       ->Fill( convDist , prodVertex.Mag() );
+                fhConvDistMCConversion       ->Fill( convDist2, prodVertex.Mag() );
+                
+                if(dEta<0.05 && pairM<0.01 && asymmetry<0.1){
+                  fhConvDistMCConversionCuts->Fill( convDist , prodVertex.Mag() );
+                  fhConvDistMCConversionCuts->Fill( convDist2, prodVertex.Mag() );
+                }
 
               }              
             }
@@ -1118,7 +1320,26 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     //printf("\t \t added single cluster %d\n",icalo);
          
     //FIXME, this to MakeAnalysisFillHistograms ...
-    fhNCellsPt->Fill(aodph.Pt(),calo->GetNCells());
+    fhNCellsE->Fill(aodph.E(),calo->GetNCells());
+    if(fFillSSHistograms){
+      if(calo->E()<2){
+        fhNCellsLam0LowE->Fill(calo->GetNCells(),calo->GetM02());
+        fhNCellsLam1LowE->Fill(calo->GetNCells(),calo->GetM20());
+        fhNCellsDispLowE->Fill(calo->GetNCells(),calo->GetDispersion());
+        fhLam1Lam0LowE  ->Fill(calo->GetM20(),   calo->GetM02());
+      }
+      else {
+        fhNCellsLam0HighE->Fill(calo->GetNCells(),calo->GetM02());
+        fhNCellsLam1HighE->Fill(calo->GetNCells(),calo->GetM20());
+        fhNCellsDispHighE->Fill(calo->GetNCells(),calo->GetDispersion());
+        fhLam1Lam0HighE  ->Fill(calo->GetM20(),   calo->GetM02());
+      }
+      
+      fhEtaLam0->Fill(aodph.Eta(), calo->GetM02());
+      fhPhiLam0->Fill(aodph.Phi(), calo->GetM02());
+      fhLam0E  ->Fill(aodph.E(),   calo->GetM02());
+      fhLam1E  ->Fill(aodph.E(),   calo->GetM20());
+    }
     
     //Add AOD with photon object to aod branch
     AddAODParticle(aodph);
index 65c941d..c1e092c 100755 (executable)
@@ -43,11 +43,11 @@ class AliAnaPhoton : public AliAnaPartCorrBaseClass {
   //---------------------------------------
   // General analysis frame methods
   //---------------------------------------
-
+  
   TObjString * GetAnalysisCuts();
   
   TList      * GetCreateOutputObjects();
-
+  
   void         Init();
 
   void         InitParameters();
@@ -61,56 +61,62 @@ class AliAnaPhoton : public AliAnaPartCorrBaseClass {
   //---------------------------------------
   // Analysis parameters setters getters
   //---------------------------------------
-
-  TString GetCalorimeter()                  const {return fCalorimeter ; }
-  void    SetCalorimeter(TString  & det)          {fCalorimeter = det  ; }
+  
+  Bool_t       ClusterSelected(AliVCluster* cl, TLorentzVector mom) ;
+  
+  TString      GetCalorimeter()                 const { return fCalorimeter ; }
+  void         SetCalorimeter(TString  & det)         { fCalorimeter = det  ; }
+  
+  void         SwitchOnSSHistogramsFill()             { fFillSSHistograms = kTRUE  ; }
+  void         SwitchOffSSHistogramsFill()            { fFillSSHistograms = kFALSE ; }  
   
   // ** Cluster selection methods **
   
-  void    SetMinDistanceToBadChannel(Float_t m1, Float_t m2, Float_t m3) {
-    fMinDist = m1;
-    fMinDist2 = m2;
-    fMinDist3 = m3;
+  void         SetMinDistanceToBadChannel(Float_t m1, Float_t m2, Float_t m3) {
+                fMinDist = m1; fMinDist2 = m2; fMinDist3 = m3;
   }
 
-  void     SetTimeCut(Double_t min, Double_t max) {fTimeCutMin = min; fTimeCutMax = max ; }
-  Double_t GetTimeCutMin()                  const {return fTimeCutMin ; }
-  Double_t GetTimeCutMax()                  const {return fTimeCutMax ; }      
+  void         SetTimeCut(Double_t min, Double_t max) { fTimeCutMin = min; 
+                                                        fTimeCutMax = max  ; }
+  Double_t     GetTimeCutMin()                  const { return fTimeCutMin ; }
+  Double_t     GetTimeCutMax()                  const { return fTimeCutMax ; } 
        
-  void     SetNCellCut(Int_t n)                   {fNCellsCut = n    ; }
-  Double_t GetNCellCut()                    const {return fNCellsCut ; }
+  void         SetNCellCut(Int_t n)                   { fNCellsCut = n    ; }
+  Double_t     GetNCellCut()                    const { return fNCellsCut ; }
+  
+  Bool_t       IsTrackMatchRejectionOn()        const { return fRejectTrackMatch   ; }
+  void         SwitchOnTrackMatchRejection()          { fRejectTrackMatch = kTRUE  ; }
+  void         SwitchOffTrackMatchRejection()         { fRejectTrackMatch = kFALSE ; }  
   
-  Bool_t   IsTrackMatchRejectionOn()        const {return fRejectTrackMatch   ; }
-  void     SwitchOnTrackMatchRejection()          {fRejectTrackMatch = kTRUE  ; }
-  void     SwitchOffTrackMatchRejection()         {fRejectTrackMatch = kFALSE ; }  
-
   // ** Conversion pair analysis **
   
-  Float_t  GetMassCut()                     const { return fMassCut           ; }
-  void     SetMassCut(Float_t m)                  { fMassCut    = m           ; }
+  Float_t      GetMassCut()                     const { return fMassCut           ; }
+  void         SetMassCut(Float_t m)                  { fMassCut    = m           ; }
   
-  Bool_t   IsCheckConversionOn()            const { return fCheckConversion   ; }
-  void     SwitchOnConversionChecker()            { fCheckConversion = kTRUE  ; }
-  void     SwitchOffConversionChecker()           { fCheckConversion = kFALSE ; }  
+  Bool_t       IsCheckConversionOn()            const { return fCheckConversion   ; }
+  void         SwitchOnConversionChecker()            { fCheckConversion = kTRUE  ; }
+  void         SwitchOffConversionChecker()           { fCheckConversion = kFALSE ; }  
        
-  Bool_t   AreConvertedPairsInAOD()         const { return fAddConvertedPairsToAOD   ; }
-  void     SwitchOnAdditionConvertedPairsToAOD()  { fAddConvertedPairsToAOD = kTRUE  ; fCheckConversion = kTRUE ; }
-  void     SwitchOffAdditionConvertedPairsToAOD() { fAddConvertedPairsToAOD = kFALSE ; }  
+  Bool_t       AreConvertedPairsInAOD()         const { return fAddConvertedPairsToAOD   ; }
+  void         SwitchOnAdditionConvertedPairsToAOD()  { fAddConvertedPairsToAOD = kTRUE  ; 
+                                                        fCheckConversion        = kTRUE  ; }
+  void         SwitchOffAdditionConvertedPairsToAOD() { fAddConvertedPairsToAOD = kFALSE ; }  
        
-  Bool_t   AreConvertedPairsRemoved()       const { return fRemoveConvertedPair      ; }
-  void     SwitchOnConvertedPairsRemoval()        { fRemoveConvertedPair  = kTRUE    ; fCheckConversion = kTRUE ; }
-  void     SwitchOffConvertedPairsRemoval()       { fRemoveConvertedPair  = kFALSE   ; }    
+  Bool_t       AreConvertedPairsRemoved()       const { return fRemoveConvertedPair      ; }
+  void         SwitchOnConvertedPairsRemoval()        { fRemoveConvertedPair  = kTRUE    ; 
+                                                        fCheckConversion      = kTRUE    ; }
+  void         SwitchOffConvertedPairsRemoval()       { fRemoveConvertedPair  = kFALSE   ; }    
   
-  void     SetConvAsymCut(Float_t c)              { fConvAsymCut = c    ; }
-  Float_t  GetConvAsymCut()                 const { return fConvAsymCut ; }
+  void         SetConvAsymCut(Float_t c)              { fConvAsymCut = c    ; }
+  Float_t      GetConvAsymCut()                 const { return fConvAsymCut ; }
   
-  void     SetConvDEtaCut(Float_t c)              { fConvDEtaCut = c    ; }
-  Float_t  GetConvDEtaCut()                 const { return fConvDEtaCut ; }
+  void         SetConvDEtaCut(Float_t c)              { fConvDEtaCut = c    ; }
+  Float_t      GetConvDEtaCut()                 const { return fConvDEtaCut ; }
   
-  void     SetConvDPhiCut(Float_t min, Float_t max)  { fConvDPhiMinCut = min ;  
-                                                       fConvDPhiMaxCut = max ; }
-  Float_t  GetConvDPhiMinCut()              const { return fConvDPhiMinCut ; }
-  Float_t  GetConvDPhiMaxCut()              const { return fConvDPhiMaxCut ; }
+  void         SetConvDPhiCut(Float_t min, Float_t max)  { fConvDPhiMinCut = min ;  
+                                                           fConvDPhiMaxCut = max ; }
+  Float_t      GetConvDPhiMinCut()              const { return fConvDPhiMinCut ; }
+  Float_t      GetConvDPhiMaxCut()              const { return fConvDPhiMaxCut ; }
 
   private:
  
@@ -122,10 +128,11 @@ class AliAnaPhoton : public AliAnaPartCorrBaseClass {
   Double_t fTimeCutMin  ;                // Remove clusters/cells with time smaller than this value, in ns
   Double_t fTimeCutMax  ;                // Remove clusters/cells with time larger than this value, in ns
   Int_t    fNCellsCut ;                  // Accept for the analysis clusters with more than fNCellsCut cells
+  Bool_t   fFillSSHistograms ;           // Fill shower shape histograms
   
   //Conversion pairs selection cuts
   Bool_t   fCheckConversion;             // Combine pairs of clusters with mass close to 0
-  Bool_t   fRemoveConvertedPair;         // Combine pairs of clusters with mass close to 0
+  Bool_t   fRemoveConvertedPair;         // Remove conversion pairs
   Bool_t   fAddConvertedPairsToAOD;      // Put Converted pairs in AOD
   Float_t  fMassCut;                     // Mass cut for the conversion pairs selection  
   Float_t  fConvAsymCut;                 // Select conversion pairs when asymmetry is smaller than cut
@@ -135,7 +142,22 @@ class AliAnaPhoton : public AliAnaPartCorrBaseClass {
 
   //Histograms 
   TH2F * fhNtraNclu;                     //! track multiplicity distribution vs cluster multiplicity
-  TH2F * fhNCellsPt;                     //! number of cells in cluster vs pt 
+  TH2F * fhNCellsE;                      //! number of cells in cluster vs E 
+  //Shower shape
+  TH2F * fhNCellsLam0LowE;               //! number of cells in cluster vs lambda0
+  TH2F * fhNCellsLam1LowE;               //! number of cells in cluster vs lambda1
+  TH2F * fhNCellsDispLowE;               //! number of cells in cluster vs dispersion
+  TH2F * fhNCellsLam0HighE;              //! number of cells in cluster vs lambda0, E>2
+  TH2F * fhNCellsLam1HighE;              //! number of cells in cluster vs lambda1, E>2
+  TH2F * fhNCellsDispHighE;              //! number of cells in cluster vs dispersion, E>2
+  TH2F * fhEtaLam0;                      //! cluster eta vs lambda0, E<2
+  TH2F * fhPhiLam0;                      //! cluster phi vs lambda0, E<2
+  TH2F * fhLam1Lam0LowE;                 //! cluster lambda1 vs lambda0, E<2
+  TH2F * fhLam1Lam0HighE;                //! cluster lambda1 vs lambda0, E>2
+  TH2F * fhLam0E;                        //! cluster lambda0 vs  E
+  TH2F * fhLam1E;                        //! cluster lambda1 vs  E
+
+  
   TH1F * fhEPhoton    ;                  //! Number of identified photon vs energy
   TH1F * fhPtPhoton   ;                  //! Number of identified photon vs transerse momentum 
   TH2F * fhPhiPhoton  ;                  //! Azimuthal angle of identified  photon vs transerse momentum 
@@ -152,6 +174,18 @@ class AliAnaPhoton : public AliAnaPartCorrBaseClass {
   TH2F * fhConvDeltaEtaPhi;              //! Small mass photons, correlation in phi and eta
   TH2F * fhConvAsym;                     //! Small mass photons, correlation in energy asymmetry
   TH2F * fhConvPt;                       //! Small mass photons, pT of pair
+  
+  //Vertex distance
+  TH2F * fhConvDistEta;                   //! Approx distance to vertex vs cluster Eta 
+  TH2F * fhConvDistEn;                    //! Approx distance to vertex vs Energy
+  TH2F * fhConvDistMass;                  //! Approx distance to vertex vs Mass
+  TH2F * fhConvDistEtaCutEta;             //! Approx distance to vertex vs cluster Eta, dEta < 0.05 
+  TH2F * fhConvDistEnCutEta;              //! Approx distance to vertex vs Energy, dEta < 0.05
+  TH2F * fhConvDistMassCutEta;            //! Approx distance to vertex vs Mass, dEta < 0.05
+  TH2F * fhConvDistEtaCutMass;            //! Approx distance to vertex vs cluster Eta, dEta < 0.05, m < 10 MeV 
+  TH2F * fhConvDistEnCutMass;             //! Approx distance to vertex vs Energy, dEta < 0.05, m < 10 MeV
+  TH2F * fhConvDistEtaCutAsy;             //! Approx distance to vertex vs cluster Eta, dEta < 0.05, m < 10 MeV, A < 0.1
+  TH2F * fhConvDistEnCutAsy;              //! Approx distance to vertex vs energy, dEta < 0.05, m < 10 MeV, A < 0.1
 
   //Fill MC dependent histograms
   TH1F * fhDeltaE  ;                     //! MC-Reco E distribution      
@@ -242,8 +276,10 @@ class AliAnaPhoton : public AliAnaPartCorrBaseClass {
   TH2F * fhConvPtMCString;               //! Small mass cluster pairs, pt of pairs, origin of both clusters is string
   TH2F * fhConvDispersionMCString;       //! Small mass cluster pairs, dispersion of cluster 1 vs cluster 2, origin of both clusters is string
   TH2F * fhConvM02MCString;              //! Small mass cluster pairs, m02 of cluster 1 vs cluster 2, origin of both clusters is string
+  TH2F * fhConvDistMCConversion;         //! Calculated conversion distance vs real distance to vertex       
+  TH2F * fhConvDistMCConversionCuts;     //! Calculated conversion distance vs real distance to vertex       
 
-   ClassDef(AliAnaPhoton,11)
+   ClassDef(AliAnaPhoton,13)
 
 } ;
  
index 20f3f31..32d94b6 100755 (executable)
@@ -1346,8 +1346,9 @@ void AliAnaPi0::FillMCVersusRecDataHistograms(const Int_t index1,  const Int_t i
   Int_t ancPDG    = 0;
   Int_t ancStatus = 0;
   TLorentzVector ancMomentum;
+  TVector3 prodVertex;
   Int_t ancLabel  = GetMCAnalysisUtils()->CheckCommonAncestor(index1, index2, 
-                                                              GetReader(), ancPDG, ancStatus,ancMomentum);
+                                                              GetReader(), ancPDG, ancStatus,ancMomentum, prodVertex);
   
   Int_t momindex  = -1;
   Int_t mompdg    = -1;
@@ -1702,6 +1703,11 @@ void AliAnaPi0::MakeAnalysisFillHistograms()
   Int_t curRPBin        = 0 ; 
   Int_t curZvertBin     = 0 ;
   
+  //Get shower shape information of clusters
+  TObjArray *clusters = 0;
+  if     (fCalorimeter="EMCAL") clusters = GetEMCALClusters();
+  else if(fCalorimeter="PHOS" ) clusters = GetPHOSClusters() ;
+  
   //---------------------------------
   //First loop on photons/clusters
   //---------------------------------
@@ -1822,12 +1828,30 @@ void AliAnaPi0::MakeAnalysisFillHistograms()
     //Get (Super)Module number of this cluster
     module1 = GetModuleNumber(p1);
     
+    
+    //Get original cluster time,
+    AliVCluster *cluster1 = 0; 
+    Bool_t bFound1        = kFALSE;
+    Int_t caloLabel1      = p1->GetCaloLabel(0);
+    Bool_t iclus1         = -1;
+    for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++){
+      AliVCluster *cluster= dynamic_cast<AliVCluster*> (clusters->At(iclus));
+      if(cluster){
+        if     (cluster->GetID()==caloLabel1) {
+          bFound1  = kTRUE  ;
+          cluster1 = cluster;
+          iclus1   = iclus;
+        }
+      }      
+      if(bFound1) break;
+    }// calorimeter clusters loop
+    
     //---------------------------------
     //Second loop on photons/clusters
     //---------------------------------
     for(Int_t i2=i1+1; i2<nPhot; i2++){
       AliAODPWG4Particle * p2 = (AliAODPWG4Particle*) (GetInputAODBranch()->At(i2)) ;
-      
+    
       //In case of mixing frame, check we are not in the same event as the first cluster
       Int_t evtIndex2 = GetEventIndex(p2, vert) ; 
       if ( evtIndex2 == -1 )
@@ -1836,7 +1860,41 @@ void AliAnaPi0::MakeAnalysisFillHistograms()
         continue ;    
       if (GetMixedEvent() && (evtIndex1 == evtIndex2))
         continue ;
+    
+      
+      //Check if time of clusters is similar
+      AliVCluster *cluster2 = 0; 
+      Bool_t bFound2        = kFALSE;
+      Int_t caloLabel2      = p2->GetCaloLabel(0);
+      for(Int_t iclus = iclus1+1; iclus < clusters->GetEntriesFast(); iclus++){
+        AliVCluster *cluster= dynamic_cast<AliVCluster*> (clusters->At(iclus));
+        if(cluster){
+          if(cluster->GetID()==caloLabel2) {
+            bFound2  = kTRUE  ;
+            cluster2 = cluster;
+          }          
+        }      
+        if(bFound2) break;
+      }// calorimeter clusters loop
+      
+      Float_t tof1  = -1;
+      if(cluster1 && bFound1){
+        tof1  = cluster1->GetTOF()*1e9;
+      }
+      else printf("cluster1 not available: calo label %d / %d, cluster ID %d\n",
+                   p1->GetCaloLabel(0),(GetReader()->GetInputEvent())->GetNumberOfCaloClusters()-1,cluster1->GetID());
+      
+      
+      Float_t tof2  = -1;
+      if(cluster2 && bFound2){
+        tof2  = cluster2->GetTOF()*1e9;
+      }
+      else printf("cluster1 not available: calo label %d / %d, cluster ID %d\n",
+                  p2->GetCaloLabel(0),(GetReader()->GetInputEvent())->GetNumberOfCaloClusters()-1,cluster2->GetID());
+      
       
+      Double_t t12diff = tof1-tof2;
+      if(TMath::Abs(t12diff) > GetPairTimeCut()) continue;
       //printf("AliAnaPi0::MakeAnalysisFillHistograms(): Photon 2 Evt %d  Vertex : %f,%f,%f\n",evtIndex2, GetVertex(evtIndex2)[0] ,GetVertex(evtIndex2)[1],GetVertex(evtIndex2)[2]);
  
       //Get the momentum of this cluster
index 0bf9043..48356fc 100755 (executable)
@@ -256,7 +256,7 @@ class AliAnaPi0 : public AliAnaPartCorrBaseClass {
   TH2D *  fhRePtAsym    ;           //! REAL two-photon pt vs asymmetry
   TH2D *  fhRePtAsymPi0 ;           //! REAL two-photon pt vs asymmetry, close to pi0 mass
   TH2D *  fhRePtAsymEta ;           //! REAL two-photon pt vs asymmetry, close to eta mass
-
+  
   //Centrality, Event plane bins
   TH3D * fhEvents;                  //! Number of events per centrality, RP, zbin
   TH1D * fhCentrality;              //! Histogram with centrality bins with at least one pare
index a5cd29f..14e7fec 100755 (executable)
@@ -54,8 +54,15 @@ AliAnaPartCorrBaseClass(),  fAnaType(kIMCalo),fCalorimeter(""),
 fMinDist(0.),fMinDist2(0.),fMinDist3(0.),      
 fInputAODGammaConv(0x0),fInputAODGammaConvName(""),
 fHistoSSBins(100), fHistoSSMax(5), fHistoSSMin(0),
-fhPtPi0(0), /*fhPtEtaPhiPi0(0),fhPtEtaPhiBkg(0), */
-fhPtDispPi0(0), fhPtDispBkg(0), /*fhPtLambdaPi0(0), fhPtLambdaBkg(0),*/
+fhPtPi0(0), fhEPi0(0), fhEEtaPhiPi0(0),
+fhEDispPi0(0), fhEDispBkg(0), 
+fhELambda0Pi0(0), fhELambda0Bkg(0),
+fhELambda1Pi0(0), fhELambda1Bkg(0),
+fhELambdaPi0EtaCen(0),fhELambdaPi0EtaMid(0),fhELambdaPi0EtaBor(0),
+fhClusterPairDiffTimeE(0),fhClusterPairDiffTimeAsy(0),
+//MC histos
+fhELambdaPhNoConv(0),fhELambdaConvPhotons(0),fhELambdaElectrons(0),
+fhELambdaPi0NoPh(0),fhELambdaOtherParts(0),
 fhPtMCNoPi0(0),fhPhiMCNoPi0(0),fhEtaMCNoPi0(0), 
 fhPtMCPi0(0),fhPhiMCPi0(0),fhEtaMCPi0(0)
 {
@@ -121,52 +128,91 @@ TList *  AliAnaPi0EbE::GetCreateOutputObjects()
   Int_t nphibins = GetHistoPhiBins();          Float_t phimax = GetHistoPhiMax();          Float_t phimin = GetHistoPhiMin();
   Int_t netabins = GetHistoEtaBins();          Float_t etamax = GetHistoEtaMax();          Float_t etamin = GetHistoEtaMin();
   Int_t ssbins   = GetHistoShowerShapeBins();  Float_t ssmax  = GetHistoShowerShapeMax();  Float_t ssmin  = GetHistoShowerShapeMin();
-
+  
   fhPtPi0  = new TH1F("hPtPi0","Number of identified  #pi^{0} decay",nptbins,ptmin,ptmax); 
   fhPtPi0->SetYTitle("N");
   fhPtPi0->SetXTitle("p_{T #pi^{0}}(GeV/c)");
   outputContainer->Add(fhPtPi0) ; 
+    
+  fhEPi0  = new TH1F("hEPi0","Number of identified  #pi^{0} decay",nptbins,ptmin,ptmax); 
+  fhEPi0->SetYTitle("N");
+  fhEPi0->SetXTitle("E  #pi^{0}(GeV)");
+  outputContainer->Add(fhEPi0) ; 
   
-//   fhPtEtaPhiPi0  = new TH3F
-//   ("hPtEtaPhiPi0","Selected #pi^{0} pairs: #p_{T} vs #eta vs #phi}",nptbins,ptmin,ptmax,netabins,etamin,etamax, nphibins,phimin,phimax); 
-//   fhPtEtaPhiPi0->SetZTitle("#phi");
-//   fhPtEtaPhiPi0->SetYTitle("#eta");
-//   fhPtEtaPhiPi0->SetXTitle("p_{T} (GeV/c)");
-//   outputContainer->Add(fhPtEtaPhiPi0) ; 
+  fhEEtaPhiPi0  = new TH3F
+  ("hEEtaPhiPi0","Selected #pi^{0} pairs: E vs #eta vs #phi",nptbins,ptmin,ptmax,netabins,etamin,etamax, nphibins,phimin,phimax); 
+  fhEEtaPhiPi0->SetZTitle("#phi");
+  fhEEtaPhiPi0->SetYTitle("#eta");
+  fhEEtaPhiPi0->SetXTitle("E (GeV)");
+  outputContainer->Add(fhEEtaPhiPi0) ; 
   
-//   fhPtEtaPhiBkg  = new TH3F
-//   ("hPtEtaPhiBkg","Rejected #pi^{0} pairs: #p_{T} vs #eta vs #phi}",nptbins,ptmin,ptmax,netabins,etamin,etamax, nphibins,phimin,phimax); 
-//   fhPtEtaPhiBkg->SetZTitle("#phi");
-//   fhPtEtaPhiBkg->SetYTitle("#eta");
-//   fhPtEtaPhiBkg->SetXTitle("p_{T} (GeV/c)");
-//   outputContainer->Add(fhPtEtaPhiBkg) ; 
+  ////////
   
   if(fAnaType == kIMCalo){
-    fhPtDispPi0  = new TH2F
-    ("hPtDispPi0","Selected #pi^{0} pairs: #p_{T} vs dispersion}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
-    fhPtDispPi0->SetYTitle("dispersion");
-    fhPtDispPi0->SetXTitle("p_{T} (GeV/c)");
-    outputContainer->Add(fhPtDispPi0) ; 
-    
-    fhPtDispBkg  = new TH2F
-    ("hPtDispBkg","Rejected #pi^{0} pairs: #p_{T} vs dispersion}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
-    fhPtDispBkg->SetYTitle("dispersion");
-    fhPtDispBkg->SetXTitle("p_{T} (GeV/c)");
-    outputContainer->Add(fhPtDispBkg) ; 
-    
-//     fhPtLambdaPi0  = new TH3F
-//     ("hPtLambdaPi0","Selected #pi^{0} pairs: #p_{T} vs #lambda_{0} vs #lambda_{1}}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax, ssbins,ssmin,ssmax); 
-//     fhPtLambdaPi0->SetZTitle("#lambda_{1}");
-//     fhPtLambdaPi0->SetYTitle("#lambda_{0}");
-//     fhPtLambdaPi0->SetXTitle("p_{T} (GeV/c)");
-//     outputContainer->Add(fhPtLambdaPi0) ; 
-    
-//     fhPtLambdaBkg  = new TH3F
-//     ("hPtLambdaBkg","Rejected #pi^{0} pairs: #p_{T} vs #lambda_{0} vs #lambda_{1}}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax, ssbins,ssmin,ssmax); 
-//     fhPtLambdaBkg->SetZTitle("#lambda_{1}");
-//     fhPtLambdaBkg->SetYTitle("#lambda_{0}");
-//     fhPtLambdaBkg->SetXTitle("p_{T} (GeV/c)");
-//     outputContainer->Add(fhPtLambdaBkg) ; 
+    
+    fhEDispPi0  = new TH2F
+    ("hEDispPi0","Selected #pi^{0} pairs: E vs dispersion",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhEDispPi0->SetYTitle("dispersion");
+    fhEDispPi0->SetXTitle("E (GeV)");
+    outputContainer->Add(fhEDispPi0) ; 
+    
+    fhEDispBkg  = new TH2F
+    ("hEDispBkg","Rejected #pi^{0} pairs: E vs dispersion",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhEDispBkg->SetYTitle("dispersion");
+    fhEDispBkg->SetXTitle("E (GeV)");
+    outputContainer->Add(fhEDispBkg) ; 
+    
+    fhELambda0Pi0  = new TH2F
+    ("hELambda0Pi0","Selected #pi^{0} pairs: E vs #lambda_{0}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhELambda0Pi0->SetYTitle("#lambda_{0}");
+    fhELambda0Pi0->SetXTitle("E (GeV)");
+    outputContainer->Add(fhELambda0Pi0) ; 
+    
+    fhELambda0Bkg  = new TH2F
+    ("hELambda0Bkg","Rejected #pi^{0} pairs: E vs #lambda_{0}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhELambda0Bkg->SetYTitle("#lambda_{0}");
+    fhELambda0Bkg->SetXTitle("E (GeV)");
+    outputContainer->Add(fhELambda0Bkg) ; 
+
+    fhELambda1Pi0  = new TH2F
+    ("hELambda1Pi0","Selected #pi^{0} pairs: E vs #lambda_{1}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhELambda1Pi0->SetYTitle("#lambda_{1}");
+    fhELambda1Pi0->SetXTitle("E (GeV)");
+    outputContainer->Add(fhELambda1Pi0) ; 
+    
+    fhELambda1Bkg  = new TH2F
+    ("hELambda1Bkg","Rejected #pi^{0} pairs: E vs #lambda_{1}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhELambda1Bkg->SetYTitle("#lambda_{1}");
+    fhELambda1Bkg->SetXTitle("E (GeV)");
+    outputContainer->Add(fhELambda1Bkg) ; 
+    
+    fhELambdaPi0EtaCen  = new TH2F
+    ("hELambdaPi0EtaCen","Selected #pi^{0} pairs: E vs #lambda_{0}, |#eta < 0.2|",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhELambdaPi0EtaCen->SetYTitle("#lambda_{0}");
+    fhELambdaPi0EtaCen->SetXTitle("E (GeV)");
+    outputContainer->Add(fhELambdaPi0EtaCen) ; 
+    
+    fhELambdaPi0EtaMid  = new TH2F
+    ("hELambdaPi0EtaMid","Selected #pi^{0} pairs: E vs #lambda_{0}, |0.2< #eta < 0.5|",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhELambdaPi0EtaMid->SetYTitle("#lambda_{0}");
+    fhELambdaPi0EtaMid->SetXTitle("E (GeV)");
+    outputContainer->Add(fhELambdaPi0EtaMid) ; 
+    
+    fhELambdaPi0EtaBor  = new TH2F
+    ("hELambdaPi0EtaBor","Selected #pi^{0} pairs: E vs #lambda_{0}, |#eta > 0.5|",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+    fhELambdaPi0EtaBor->SetYTitle("#lambda_{0}");
+    fhELambdaPi0EtaBor->SetXTitle("E (GeV)");
+    outputContainer->Add(fhELambdaPi0EtaBor) ; 
+    
+    fhClusterPairDiffTimeE = new TH2F("hClusterPairDiffTimeE","cluster pair time difference vs E",nptbins,ptmin,ptmax, 200,-100,100);
+    fhClusterPairDiffTimeE->SetXTitle("E_{pair} (GeV)");
+    fhClusterPairDiffTimeE->SetYTitle("#Delta t (ns)");
+    outputContainer->Add(fhClusterPairDiffTimeE);
+    
+    fhClusterPairDiffTimeAsy = new TH2F("hClusterPairDiffTime","cluster pair time difference vs pair asymmetry",100,0,1, 200,-100,100);
+    fhClusterPairDiffTimeAsy->SetXTitle("Asymmetry");
+    fhClusterPairDiffTimeAsy->SetYTitle("#Delta t (ns)");
+    outputContainer->Add(fhClusterPairDiffTimeAsy);    
     
   }// Invariant mass analysis in calorimeters only
   
@@ -208,6 +254,46 @@ TList *  AliAnaPi0EbE::GetCreateOutputObjects()
       fhEtaMCNoPi0->SetXTitle("p_{T #pi^{0}} (GeV/c)");
       outputContainer->Add(fhEtaMCNoPi0) ;
       
+      if(fAnaType == kIMCalo){
+        
+        fhELambdaPhNoConv  = new TH2F
+        ("hELambdaPhNoConv","Selected #pi^{0} pairs (Really photons and not conversion): E vs #lambda_{0} vs #lambda_{1}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+        fhELambdaPhNoConv->SetZTitle("#lambda_{1}");
+        fhELambdaPhNoConv->SetYTitle("#lambda_{0}");
+        fhELambdaPhNoConv->SetXTitle("E (GeV)");
+        outputContainer->Add(fhELambdaPhNoConv) ; 
+        
+        
+        fhELambdaConvPhotons  = new TH2F
+        ("hELambdaConvPhotons","Selected #pi^{0} pairs (Converted photons): E vs #lambda_{0} vs #lambda_{1}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+        fhELambdaConvPhotons->SetZTitle("#lambda_{1}");
+        fhELambdaConvPhotons->SetYTitle("#lambda_{0}");
+        fhELambdaConvPhotons->SetXTitle("E (GeV)");
+        outputContainer->Add(fhELambdaConvPhotons) ; 
+        
+        fhELambdaElectrons  = new TH2F
+        ("hELambdaElectrons","Selected #pi^{0} pairs(Electrons ): E vs #lambda_{0} vs #lambda_{1}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+        fhELambdaElectrons->SetZTitle("#lambda_{1}");
+        fhELambdaElectrons->SetYTitle("#lambda_{0}");
+        fhELambdaElectrons->SetXTitle("E (GeV)");
+        outputContainer->Add(fhELambdaElectrons) ; 
+        
+        fhELambdaPi0NoPh  = new TH2F
+        ("hELambdaPi0NoPh","Selected #pi^{0} pairs(Pi0s instead of photons): E vs #lambda_{0} vs #lambda_{1}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+        fhELambdaPi0NoPh->SetZTitle("#lambda_{1}");
+        fhELambdaPi0NoPh->SetYTitle("#lambda_{0}");
+        fhELambdaPi0NoPh->SetXTitle("E (GeV)");
+        outputContainer->Add(fhELambdaPi0NoPh) ; 
+        
+        fhELambdaOtherParts  = new TH2F
+        ("hELambdaOtherParts","Selected #pi^{0} pairs (Other parts): E vs #lambda_{0} vs #lambda_{1}",nptbins,ptmin,ptmax,ssbins,ssmin,ssmax); 
+        fhELambdaOtherParts->SetZTitle("#lambda_{1}");
+        fhELambdaOtherParts->SetYTitle("#lambda_{0}");
+        fhELambdaOtherParts->SetXTitle("E (GeV)");
+        outputContainer->Add(fhELambdaOtherParts) ; 
+        
+      }//kIMCalo
+      
     }
   }//Histos with MC
   
@@ -270,16 +356,39 @@ void  AliAnaPi0EbE::MakeInvMassInCalorimeter()
     abort();
   }
   
-  for(Int_t iphoton = 0; iphoton < GetInputAODBranch()->GetEntriesFast(); iphoton++){
+  for(Int_t iphoton = 0; iphoton < GetInputAODBranch()->GetEntriesFast()-1; iphoton++){
     AliAODPWG4Particle * photon1 =  (AliAODPWG4Particle*) (GetInputAODBranch()->At(iphoton));
     
+    //Vertex cut in case of mixed events
     Int_t evtIndex1 = 0 ; 
     if(GetMixedEvent())
       evtIndex1 = GetMixedEvent()->EventIndexForCaloCluster(photon1->GetCaloLabel(0)) ;
     if(TMath::Abs(GetVertex(evtIndex1)[2]) > GetZvertexCut()) continue ;  //vertex cut
     mom1 = *(photon1->Momentum());
     
-    for(Int_t jphoton = iphoton+1; jphoton < GetInputAODBranch()->GetEntriesFast()-1; jphoton++){
+    //Get shower shape information of clusters
+    TObjArray *clusters = 0;
+    if     (fCalorimeter="EMCAL") clusters = GetEMCALClusters();
+    else if(fCalorimeter="PHOS" ) clusters = GetPHOSClusters() ;
+    
+    //Get original cluster, to recover some information
+    AliVCluster *cluster1 = 0; //(GetReader()->GetInputEvent())->GetCaloCluster(photon1->GetCaloLabel(0));
+    Bool_t bFound1        = kFALSE;
+    Int_t caloLabel1      = photon1->GetCaloLabel(0);
+    Bool_t iclus1         = -1;
+    for(Int_t iclus = 0; iclus < clusters->GetEntriesFast(); iclus++){
+      AliVCluster *cluster= dynamic_cast<AliVCluster*> (clusters->At(iclus));
+      if(cluster){
+        if     (cluster->GetID()==caloLabel1) {
+          bFound1  = kTRUE  ;
+          cluster1 = cluster;
+          iclus1   = iclus;
+        }
+      }      
+      if(bFound1) break;
+    }// calorimeter clusters loop
+    
+    for(Int_t jphoton = iphoton+1; jphoton < GetInputAODBranch()->GetEntriesFast(); jphoton++){
       
       AliAODPWG4Particle * photon2 =  (AliAODPWG4Particle*) (GetInputAODBranch()->At(jphoton));
       Int_t evtIndex2 = 0 ; 
@@ -289,10 +398,63 @@ void  AliAnaPi0EbE::MakeInvMassInCalorimeter()
         continue ; 
       if(TMath::Abs(GetVertex(evtIndex2)[2]) > GetZvertexCut()) continue ;  //vertex cut
       mom2 = *(photon2->Momentum());
+      
       //Int_t input = -1;      //if -1 photons come from different files, not a pi0
       //if(photon1->GetInputFileIndex() == photon2->GetInputFileIndex()) 
         //input = photon1->GetInputFileIndex();
       
+      AliVCluster *cluster2 = 0; //(GetReader()->GetInputEvent())->GetCaloCluster(photon2->GetCaloLabel(0));
+      Bool_t bFound2        = kFALSE;
+      Int_t caloLabel2      = photon2->GetCaloLabel(0);
+      for(Int_t iclus = iclus1+1; iclus < clusters->GetEntriesFast(); iclus++){
+        AliVCluster *cluster= dynamic_cast<AliVCluster*> (clusters->At(iclus));
+        if(cluster){
+          if(cluster->GetID()==caloLabel2) {
+            bFound2  = kTRUE  ;
+            cluster2 = cluster;
+          }          
+        }      
+        if(bFound2) break;
+      }// calorimeter clusters loop
+      
+      //Photon/Cluster 1
+      Float_t e1    = photon1->E();
+      Float_t eta1  = photon1->Eta();
+
+      Float_t tof1  = -1;
+      Float_t disp1 = -1;
+      Float_t l01   = -1;
+      Float_t l11   = -1; 
+      if(cluster1 && bFound1){
+        disp1 = cluster1->GetDispersion();
+        l11   = cluster1->GetM20();
+        l01   = cluster1->GetM02();
+        tof1  = cluster1->GetTOF()*1e9;
+      }else printf("cluster1 not available: calo label %d / %d, cluster ID %d\n",
+                    photon2->GetCaloLabel(0),(GetReader()->GetInputEvent())->GetNumberOfCaloClusters()-1,cluster1->GetID());
+      
+      //Photon/Cluster 2
+      Float_t e2    = photon2->E();
+      Float_t eta2  = photon2->Eta();
+      Float_t disp2 = -1;
+      Float_t tof2  = -1;
+      Float_t l02   = -1;
+      Float_t l12   = -1; 
+      if(cluster2 && bFound2){
+        disp2 = cluster2->GetDispersion();
+        l12   = cluster2->GetM20();
+        l02   = cluster2->GetM02();
+        tof2  = cluster2->GetTOF()*1e9;
+      }else printf("cluster2 not available: calo label %d / %d, cluster ID %d\n",
+                   photon2->GetCaloLabel(0),(GetReader()->GetInputEvent())->GetNumberOfCaloClusters()-1,cluster2->GetID());    
+      
+      //Select clusters with good time window difference
+      Double_t t12diff = tof1-tof2;
+      Float_t asymmetry = TMath::Abs(e1-e2)/(e1+e2);
+      fhClusterPairDiffTimeE  ->Fill(e1+e2,    t12diff);
+      fhClusterPairDiffTimeAsy->Fill(asymmetry,t12diff);
+      if(TMath::Abs(t12diff) > GetPairTimeCut()) continue;
+      
       //Select good pair (good phi, pt cuts, aperture and invariant mass)
       if(GetNeutralMesonSelection()->SelectPair(mom1, mom2))
       {
@@ -346,14 +508,82 @@ void  AliAnaPi0EbE::MakeInvMassInCalorimeter()
         //Fill some histograms about shower shape
         if(GetReader()->GetDataType()!=AliCaloTrackReader::kMC){
           //Photon1 
-          AliVCluster *cluster1 = (GetReader()->GetInputEvent())->GetCaloCluster(photon1->GetCaloLabel(0)); 
-          fhPtDispPi0  ->Fill(photon1->Pt(), cluster1->GetDispersion());    
-//           fhPtLambdaPi0->Fill(photon1->Pt(), cluster1->GetM20(), cluster1->GetM02());    
+          
+          //printf("Signal Cl1: e %f, pt %f, disp %f, l1 %f, l0 %f, eta %f, phi %f \n",
+          //       e,pt,disp,l1,l0,photon2->Eta(),photon2->Phi());
+          
+          fhEDispPi0   ->Fill(e1, disp1);   
+          fhELambda0Pi0->Fill(e1, l01  );  
+          fhELambda1Pi0->Fill(e1, l11  );  
+
+          if(TMath::Abs(eta1)<0.2){
+            fhELambdaPi0EtaCen->Fill(e1, l01);
+          }
+          else if (TMath::Abs(eta1)>0.2 && TMath::Abs(eta1)<0.5){
+            fhELambdaPi0EtaMid->Fill(e1, l01);
+          } 
+          else {
+            fhELambdaPi0EtaBor->Fill(e1, l01);
+          }
+          
           //Photon2
-          AliVCluster *cluster2 = (GetReader()->GetInputEvent())->GetCaloCluster(photon2->GetCaloLabel(0));        
-          fhPtDispPi0  ->Fill(photon2->Pt(), cluster2->GetDispersion());    
-//           fhPtLambdaPi0->Fill(photon2->Pt(), cluster2->GetM20(), cluster2->GetM02());  
-        }
+          //printf("Signal Cl2: e %f, pt %f, disp %f, l1 %f, l0 %f, eta %f, phi %f \n",e
+          //     ,pt,disp,l1,l0,photon2->Eta(),photon2->Phi());
+          
+          fhEDispPi0   ->Fill(e2, disp2);   
+          fhELambda0Pi0->Fill(e2, l02  ); 
+          fhELambda1Pi0->Fill(e2, l12  ); 
+          
+          if(TMath::Abs(eta2)<0.2){
+            fhELambdaPi0EtaCen->Fill(e2, l02);
+          }
+          else if (TMath::Abs(eta2)>0.2 && TMath::Abs(eta2)<0.5){
+            fhELambdaPi0EtaMid->Fill(e2, l02);
+          } 
+          else {
+            fhELambdaPi0EtaBor->Fill(e2, l02);
+          }
+          
+          if(IsDataMC()) {
+            //Photon1
+            if( GetMCAnalysisUtils()->CheckTagBit(tag1,AliMCAnalysisUtils::kMCPhoton) && !GetMCAnalysisUtils()->CheckTagBit(tag1,AliMCAnalysisUtils::kMCConversion) ){
+              fhELambdaPhNoConv->Fill(e1, l01);
+            }//photon   no conversion
+            else if  ( GetMCAnalysisUtils()->CheckTagBit(tag1,AliMCAnalysisUtils::kMCElectron)){
+              fhELambdaElectrons->Fill(e1, l01);
+            }//electron
+            else if  ( GetMCAnalysisUtils()->CheckTagBit(tag1,AliMCAnalysisUtils::kMCConversion) && GetMCAnalysisUtils()->CheckTagBit(tag1,AliMCAnalysisUtils::kMCConversion) ){
+              fhELambdaConvPhotons->Fill(e1, l01);
+            }//convesion photon
+            
+            else if  ( GetMCAnalysisUtils()->CheckTagBit(tag1,AliMCAnalysisUtils::kMCPi0)  ){
+              fhELambdaPi0NoPh->Fill(e1, l01);
+            }//pi0
+            else {
+              fhELambdaOtherParts->Fill(e1, l01);
+            }//other particules 
+            
+            //Photon 2
+            if( GetMCAnalysisUtils()->CheckTagBit(tag2,AliMCAnalysisUtils::kMCPhoton) && !GetMCAnalysisUtils()->CheckTagBit(tag2,AliMCAnalysisUtils::kMCConversion) ){
+              fhELambdaPhNoConv->Fill(e2, l02);
+            }//photon   no conversion
+            else if  ( GetMCAnalysisUtils()->CheckTagBit(tag2,AliMCAnalysisUtils::kMCElectron)){
+              fhELambdaElectrons->Fill(e2, l02);
+            }//electron
+            else if  ( GetMCAnalysisUtils()->CheckTagBit(tag2,AliMCAnalysisUtils::kMCConversion) && GetMCAnalysisUtils()->CheckTagBit(tag2,AliMCAnalysisUtils::kMCConversion) ){
+              fhELambdaConvPhotons->Fill(e2, l02);
+            }//convesion photon
+            
+            else if  ( GetMCAnalysisUtils()->CheckTagBit(tag2,AliMCAnalysisUtils::kMCPi0)  ){
+              fhELambdaPi0NoPh->Fill(e2, l02);
+            }//pi0
+            else {
+              fhELambdaOtherParts->Fill(e2, l02);
+            }//other particules 
+          }//is datamc
+          
+        }//MC histograms
+
         //Create AOD for analysis
         mom = mom1+mom2;
         AliAODPWG4Particle pi0 = AliAODPWG4Particle(mom);
@@ -369,18 +599,27 @@ void  AliAnaPi0EbE::MakeInvMassInCalorimeter()
       else{
         Float_t phi = (mom1+mom2).Phi();
         if(phi < 0) phi+=TMath::TwoPi();
-//         fhPtEtaPhiBkg ->Fill((mom1+mom2).Pt(),(mom1+mom2).Eta(),(mom1+mom2).Phi());
         
         //Fill some histograms about shower shape
         if(GetReader()->GetDataType()!=AliCaloTrackReader::kMC){
           //Photon1
-          AliVCluster *cluster1 = (GetReader()->GetInputEvent())->GetCaloCluster(photon1->GetCaloLabel(0));        
-          fhPtDispBkg  ->Fill(photon1->Pt(), cluster1->GetDispersion());    
-//           fhPtLambdaBkg->Fill(photon1->Pt(), cluster1->GetM20(), cluster1->GetM02());    
+          
+          //printf("Bkg Cl1: e %f, pt %f, disp %f, l1 %f, l0 %f, eta %f, phi %f \n",
+          //       e,pt,disp,l1,l0,photon2->Eta(),photon2->Phi());
+          
+          fhEDispBkg   ->Fill(e1, disp1);   
+          fhELambda0Bkg->Fill(e1, l01  );  
+          fhELambda1Bkg->Fill(e1, l11  );  
+           
           //Photon2
-          AliVCluster *cluster2 = (GetReader()->GetInputEvent())->GetCaloCluster(photon2->GetCaloLabel(0));        
-          fhPtDispBkg  ->Fill(photon2->Pt(), cluster2->GetDispersion());    
-//           fhPtLambdaBkg->Fill(photon2->Pt(), cluster2->GetM20(), cluster2->GetM02()); 
+          
+          //printf("Bkg Cl2: e %f, pt %f, disp %f, l1 %f, l0 %f, eta %f, phi %f \n",
+          //e,pt,disp,l1,l0,photon2->Eta(),photon2->Phi());
+          
+          fhEDispBkg   ->Fill(e2, disp2);   
+          fhELambda0Bkg->Fill(e2, l02  );  
+          fhELambda1Bkg->Fill(e2, l12  );  
+   
         }
         
       }//bkg pair
@@ -423,7 +662,7 @@ void  AliAnaPi0EbE::MakeInvMassInCalorimeterAndCTS()
       printf("AliAnaPi0EbE::MakeInvMassInCalorimeterAndCTS() - No input gamma conversions in AOD branch with name < %s >, STOP\n",fInputAODGammaConvName.Data());
       abort(); 
     }
-    for(Int_t jphoton = iphoton+1; jphoton < fInputAODGammaConv->GetEntriesFast()-1; jphoton++){
+    for(Int_t jphoton = 0; jphoton < fInputAODGammaConv->GetEntriesFast(); jphoton++){
       AliAODPWG4Particle * photon2 =  (AliAODPWG4Particle*) (fInputAODGammaConv->At(jphoton));
       if(GetMixedEvent())
         evtIndex = GetMixedEvent()->EventIndexForCaloCluster(photon2->GetCaloLabel(0)) ;
@@ -661,13 +900,15 @@ void  AliAnaPi0EbE::MakeAnalysisFillHistograms()
     if(IsCaloPIDOn() && pdg != AliCaloPID::kPi0) continue;              
     
     //Fill pi0 histograms 
-    Float_t pt  = pi0->Pt();
-    Float_t phi = pi0->Phi();
+    Float_t ener  = pi0->E();
+    Float_t pt    = pi0->Pt();
+    Float_t phi   = pi0->Phi();
     if(phi < 0) phi+=TMath::TwoPi();
     Float_t eta = pi0->Eta();
     
-    fhPtPi0       ->Fill(pt);
-//     fhPtEtaPhiPi0 ->Fill(pt,eta,phi);
+    fhPtPi0      ->Fill(pt);
+    fhEPi0       ->Fill(ener);
+    fhEEtaPhiPi0 ->Fill(ener,eta,phi);
     
     if(IsDataMC()){
       if((GetReader()->GetDataType() == AliCaloTrackReader::kMC && fAnaType!=kSSCalo) || 
index 7b2899c..28ed79f 100755 (executable)
@@ -34,50 +34,45 @@ class AliAnaPi0EbE : public AliAnaPartCorrBaseClass {
   AliAnaPi0EbE & operator = (const AliAnaPi0EbE & g) ;//cpy assignment
 
  public:  
-
-  enum anaTypes {kIMCalo, kSSCalo, kIMCaloTracks};
        
+  //General
   TObjString * GetAnalysisCuts();
   TList      * GetCreateOutputObjects();
   
-  void Init();
-  void InitParameters();
-  
-  void MakeAnalysisFillAOD()  ;
-  void MakeAnalysisFillHistograms() ; 
-  
-  void MakeInvMassInCalorimeter() ;
-  void MakeInvMassInCalorimeterAndCTS() ;
-  void MakeShowerShapeIdentification() ;
+  void         Init();
+  void         InitParameters();
+  void         Print(const Option_t * opt) const;
+
+  void         MakeAnalysisFillAOD()  ;
+  void         MakeAnalysisFillHistograms() ; 
   
-  void Print(const Option_t * opt)const;
+  // Main
+  void         MakeInvMassInCalorimeter() ;
+  void         MakeInvMassInCalorimeterAndCTS() ;
+  void         MakeShowerShapeIdentification() ;
   
-  anaTypes GetAnalysisType()   const {return fAnaType ; }
-  void SetAnalysisType(anaTypes ana)    {fAnaType = ana ; }
+  //Setters Getters
+  enum anaTypes {kIMCalo, kSSCalo, kIMCaloTracks};
+  anaTypes     GetAnalysisType()                     const { return fAnaType               ; }
+  void         SetAnalysisType(anaTypes ana)               { fAnaType = ana                ; }
   
-  TString GetInputAODGammaConvName()   const {return fInputAODGammaConvName ; }
-  void SetInputAODGammaConvName(TString name)    {fInputAODGammaConvName = name ; }    
+  TString      GetInputAODGammaConvName()            const { return fInputAODGammaConvName ; }
+  void         SetInputAODGammaConvName(TString name)      { fInputAODGammaConvName = name ; } 
   
   //Only for pi0 SS identification case
-  void SetCalorimeter(TString & det)    {fCalorimeter = det ; }
+  void         SetCalorimeter(TString & det)               { fCalorimeter = det            ; }
   
-  void SetMinDistanceToBadChannel(Float_t m1, Float_t m2, Float_t m3) {
-    fMinDist = m1;
-    fMinDist2 = m2;
-    fMinDist3 = m3;
-  }
+  void         SetMinDistanceToBadChannel(Float_t m1, Float_t m2, Float_t m3) {
+                fMinDist = m1; fMinDist2 = m2; fMinDist3 = m3                              ; }
   
   //Histograms range
   
-  virtual void SetHistoShowerShapeRangeAndNBins(Float_t min, Float_t max, Int_t n) {
-               fHistoSSBins  = n ;
-               fHistoSSMax   = max ;
-               fHistoSSMin   = min ;
-       }
+  void         SetHistoShowerShapeRangeAndNBins(Float_t min, Float_t max, Int_t n) {
+                           fHistoSSBins  = n ; fHistoSSMax   = max ; fHistoSSMin   = min              ; }
        
-       Int_t   GetHistoShowerShapeBins()  const { return fHistoSSBins ; }
-       Float_t GetHistoShowerShapeMin()   const { return fHistoSSMin ; }
-       Float_t GetHistoShowerShapeMax()   const { return fHistoSSMax ; }       
+       Int_t        GetHistoShowerShapeBins()             const { return fHistoSSBins ; }
+       Float_t      GetHistoShowerShapeMin()              const { return fHistoSSMin ; }
+       Float_t      GetHistoShowerShapeMax()              const { return fHistoSSMax ; }       
   
   
  private:
@@ -85,38 +80,55 @@ class AliAnaPi0EbE : public AliAnaPartCorrBaseClass {
   anaTypes fAnaType; //Select analysis type
   
   //Only for pi0 SS identification case, kSSCalo
-  TString fCalorimeter ; // Calorimeter where the gamma is searched;
-  Float_t fMinDist ;     // Minimal distance to bad channel to accept cluster
-  Float_t fMinDist2;     // Cuts on Minimal distance to study acceptance evaluation
-  Float_t fMinDist3;     // One more cut on distance used for acceptance-efficiency study
+  TString        fCalorimeter ;      // Calorimeter where the gamma is searched;
+  Float_t        fMinDist ;          // Minimal distance to bad channel to accept cluster
+  Float_t        fMinDist2;          // Cuts on Minimal distance to study acceptance evaluation
+  Float_t        fMinDist3;          // One more cut on distance used for acceptance-efficiency study
   
   //Only for combination of calorimeter and conversion photons, kIMCaloTracks
-  TClonesArray * fInputAODGammaConv; //AOD array with conversion photons reconstructed in CTS
-  TString fInputAODGammaConvName;    //Name of AOD branch with conversion photons
+  TClonesArray * fInputAODGammaConv;     //! AOD array with conversion photons reconstructed in CTS
+  TString        fInputAODGammaConvName; //  Name of AOD branch with conversion photons
   
   //Histograms
-  Int_t   fHistoSSBins;            // Shower Shape parameter histogram number of bins
-  Float_t fHistoSSMax;             // Shower Shape parameter position maximum value
-  Float_t fHistoSSMin;             // Shower Shape parameter position minimum value
+  Int_t          fHistoSSBins;       // Shower Shape parameter histogram number of bins
+  Float_t        fHistoSSMax;        // Shower Shape parameter position maximum value
+  Float_t        fHistoSSMin;        // Shower Shape parameter position minimum value
          
-  TH1F * fhPtPi0   ;         //! Number of identified  pi0
-/*   TH3F * fhPtEtaPhiPi0  ;    //! pt vs eta phi of identified  pi0 */
-/*   TH3F * fhPtEtaPhiBkg  ;    //! pt vs eta phi of discarded pairs   */
-  TH2F * fhPtDispPi0 ;       //! pt vs disp of pi0 pairs
-  TH2F * fhPtDispBkg ;       //! pt vs disp of discarded pairs
-/*   TH3F * fhPtLambdaPi0 ;     //! pt vs lambda0 vs lambda1 of pi0 pairs */
-/*   TH3F * fhPtLambdaBkg ;     //! pt vs lambda0 vs lambda1 of discarded pairs */
+  TH1F         * fhPtPi0  ;          //! Number of identified  pi0 vs pT
+  TH1F         * fhEPi0   ;          //! Number of identified  pi0 vs E
+  TH3F         * fhEEtaPhiPi0  ;     //! E vs eta phi of identified  pi0 
+  TH2F         * fhEDispPi0 ;        //! E vs disp of pi0 pairs
+  TH2F         * fhEDispBkg ;        //! E vs disp of discarded pairs
+  TH2F         * fhELambda0Pi0 ;     //! E vs lambda0 of pi0 pairs 
+  TH2F         * fhELambda0Bkg ;     //! E vs lambda0 of discarded pairs 
+  TH2F         * fhELambda1Pi0 ;     //! E vs lambda1 of pi0 pairs 
+  TH2F         * fhELambda1Bkg ;     //! E vs lambda1 of discarded pairs 
+  
+  TH2F         * fhELambdaPi0EtaCen ; //! E vs lambda0 of pi0 pairs, |eta| < 0.2 
+  TH2F         * fhELambdaPi0EtaMid ; //! E vs lambda0 of pi0 pairs, 0.2 < |eta| < 0.5  
+  TH2F         * fhELambdaPi0EtaBor ; //! E vs lambda0 of pi0 pairs |eta| > 0.5 
 
-  //MC
-  TH1F * fhPtMCNoPi0;   //! Number of identified pi0, not coming from pi0
-  TH2F * fhPhiMCNoPi0;  //! Phi of identified pi0, not coming from pi0
-  TH2F * fhEtaMCNoPi0;  //! eta of identified  pi0, not coming from pi0
-  TH1F * fhPtMCPi0;     //! Number of identified pi0, coming from pi0
-  TH2F * fhPhiMCPi0;    //! Phi of identified pi0, coming from pi0
-  TH2F * fhEtaMCPi0;    //! eta of identified pi0, coming from pi0
-  
-  ClassDef(AliAnaPi0EbE,2)
-    } ;
+  TH2F         * fhClusterPairDiffTimeE;   //! Pair of clusters time difference vs E
+  TH2F         * fhClusterPairDiffTimeAsy; //! Pair of clusters time difference vs Asymmetry
+  
+  //MC histograms
+  
+  TH2F         * fhELambdaPhNoConv ;    //! E vs lambda0 of pi0 pairs(Really photons not conversion)
+  TH2F         * fhELambdaConvPhotons ; //! E vs lambda0 of pi0 pairs  (converted photons)
+  TH2F         * fhELambdaElectrons ;   //! E vs lambda0 of pi0 pairs (Electrons)
+  TH2F         * fhELambdaPi0NoPh ;     //! E vs lambda0 of pi0 pairs(Son pi0s) 
+  TH2F         * fhELambdaOtherParts ;  //! E vs lambda0 vs pi0 pairs (other particles)
+    
+  TH1F         * fhPtMCNoPi0;        //! Number of identified pi0, not coming from pi0
+  TH2F         * fhPhiMCNoPi0;       //! Phi of identified pi0, not coming from pi0
+  TH2F         * fhEtaMCNoPi0;       //! eta of identified  pi0, not coming from pi0
+  TH1F         * fhPtMCPi0;          //! Number of identified pi0, coming from pi0
+  TH2F         * fhPhiMCPi0;         //! Phi of identified pi0, coming from pi0
+  TH2F         * fhEtaMCPi0;         //! eta of identified pi0, coming from pi0
+  
+  
+  ClassDef(AliAnaPi0EbE,4)
+} ;
 
 
 #endif //ALIANAPI0EBE_H