Add histograms lambda0, time difference in clusters and pt spectra for different...
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 14 Nov 2012 13:41:24 +0000 (13:41 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 14 Nov 2012 13:41:24 +0000 (13:41 +0000)
PWGGA/CaloTrackCorrelations/AliAnaPhoton.cxx
PWGGA/CaloTrackCorrelations/AliAnaPhoton.h

index 4eb9877..1526674 100755 (executable)
@@ -135,8 +135,17 @@ AliAnaPhoton::AliAnaPhoton() :
     fhLambda0DispPhi[i] = 0;
     fhLambda0DispEta[i] = 0;
     
-    fhPtPhotonPileUp[i] = 0;
+    fhPtPileUp       [i] = 0;
+    fhPtChargedPileUp[i] = 0;
+    fhPtPhotonPileUp [i] = 0;
+
+    fhLambda0PileUp       [i] = 0;
+    fhLambda0ChargedPileUp[i] = 0;
     
+    fhClusterTimeDiffPileUp       [i] = 0;
+    fhClusterTimeDiffChargedPileUp[i] = 0;
+    fhClusterTimeDiffPhotonPileUp [i] = 0;
+
     for(Int_t j = 0; j < 6; j++)
     {
       fhMCDispEtaDispPhi[i][j] = 0;
@@ -202,21 +211,139 @@ AliAnaPhoton::AliAnaPhoton() :
 Bool_t  AliAnaPhoton::ClusterSelected(AliVCluster* calo, const TLorentzVector mom, const Int_t nMaxima) 
 {
   //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",
+  
+  Float_t ptcluster = mom.Pt();
+  Float_t ecluster  = mom.E();
+  Float_t l0cluster = calo->GetM02();
+  
+  if(GetDebug() > 2)
+    printf("AliAnaPhoton::ClusterSelected() Current Event %d; Before selection : E %2.2f, pT %2.2f, phi %2.2f, eta %2.2f\n",
            GetReader()->GetEventNumber(),
-           calo->E(), mom.Pt(),calo->E(),mom.Phi()*TMath::RadToDeg(),mom.Eta());
-    
-  fhClusterCuts[1]->Fill(calo->E());
+           ecluster,ptcluster, mom.Phi()*TMath::RadToDeg(),mom.Eta());
+  
+  fhClusterCuts[1]->Fill(ecluster);
   
   //.......................................
   //If too small or big energy, skip it
-  if(calo->E() < GetMinEnergy() || calo->E() > GetMaxEnergy() ) return kFALSE ; 
+  if(ecluster < GetMinEnergy() || ecluster > GetMaxEnergy() ) return kFALSE ; 
   
   if(GetDebug() > 2) printf("\t Cluster %d Pass E Cut \n",calo->GetID());
   
-  fhClusterCuts[2]->Fill(calo->E());
+  fhClusterCuts[2]->Fill(ecluster);
+
+  if(fFillPileUpHistograms)
+  {
+    if(GetReader()->IsPileUpFromSPD())               {fhPtPileUp[0]->Fill(ptcluster); fhLambda0PileUp[0]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromEMCal())             {fhPtPileUp[1]->Fill(ptcluster); fhLambda0PileUp[1]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromSPDOrEMCal())        {fhPtPileUp[2]->Fill(ptcluster); fhLambda0PileUp[2]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromSPDAndEMCal())       {fhPtPileUp[3]->Fill(ptcluster); fhLambda0PileUp[3]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromSPDAndNotEMCal())    {fhPtPileUp[4]->Fill(ptcluster); fhLambda0PileUp[4]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromEMCalAndNotSPD())    {fhPtPileUp[5]->Fill(ptcluster); fhLambda0PileUp[5]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) {fhPtPileUp[6]->Fill(ptcluster); fhLambda0PileUp[6]->Fill(ecluster,l0cluster); }
+    
+    
+    // Get the fraction of the cluster energy that carries the cell with highest energy and its absId
+    AliVCaloCells* cells = 0;
+    if(fCalorimeter == "EMCAL") cells = GetEMCALCells();
+    else                        cells = GetPHOSCells();
+    
+    Float_t maxCellFraction = 0.;
+    Int_t absIdMax = GetCaloUtils()->GetMaxEnergyCell(cells, calo,maxCellFraction);
+
+    Double_t tmax  = cells->GetCellTime(absIdMax);
+    GetCaloUtils()->RecalibrateCellTime(tmax, fCalorimeter, absIdMax,GetReader()->GetInputEvent()->GetBunchCrossNumber());
+    tmax*=1.e9;
+    
+    Bool_t okPhoton = kFALSE;
+    if( GetCaloPID()->GetIdentifiedParticleType(calo)== AliCaloPID::kPhoton) okPhoton = kTRUE;
+
+    Bool_t matched = IsTrackMatched(calo,GetReader()->GetInputEvent());
+    
+    //Loop on cells inside cluster
+    for (Int_t ipos = 0; ipos < calo->GetNCells(); ipos++)
+    {
+      Int_t absId  = calo->GetCellsAbsId()[ipos];
+      if(absId!=absIdMax && cells->GetCellAmplitude(absIdMax) > 0.01)
+      {
+        Double_t time  = cells->GetCellTime(absId);
+        GetCaloUtils()->RecalibrateCellTime(time, fCalorimeter, absId,GetReader()->GetInputEvent()->GetBunchCrossNumber());
+        
+        Float_t diff = (tmax-time*1e9);
+        
+        if(GetReader()->IsPileUpFromSPD())
+        {
+          fhClusterTimeDiffPileUp[0]->Fill(ecluster, diff);
+          if(!matched)
+          {
+            fhClusterTimeDiffChargedPileUp[0]->Fill(ecluster, diff);
+            if(okPhoton)  fhClusterTimeDiffPhotonPileUp[0]->Fill(ecluster, diff);
+          }
+        }
+        
+        if(GetReader()->IsPileUpFromEMCal())
+        {
+          fhClusterTimeDiffPileUp[1]->Fill(ecluster, diff);
+          if(!matched)
+          {
+            fhClusterTimeDiffChargedPileUp[1]->Fill(ecluster, diff);
+            if(okPhoton)  fhClusterTimeDiffPhotonPileUp[1]->Fill(ecluster, diff);
+          }
+        }
 
+        if(GetReader()->IsPileUpFromSPDOrEMCal())
+        {
+          fhClusterTimeDiffPileUp[2]->Fill(ecluster, diff);
+          if(!matched)
+          {
+            fhClusterTimeDiffChargedPileUp[2]->Fill(ecluster, diff);
+            if(okPhoton)  fhClusterTimeDiffPhotonPileUp[2]->Fill(ecluster, diff);
+          }
+        }
+        
+        if(GetReader()->IsPileUpFromSPDAndEMCal())
+        {
+          fhClusterTimeDiffPileUp[3]->Fill(ecluster, diff);
+          if(!matched)
+          {
+            fhClusterTimeDiffChargedPileUp[3]->Fill(ecluster, diff);
+            if(okPhoton)  fhClusterTimeDiffPhotonPileUp[3]->Fill(ecluster, diff);
+          }
+        }
+        
+        if(GetReader()->IsPileUpFromSPDAndNotEMCal())
+        {
+          fhClusterTimeDiffPileUp[4]->Fill(ecluster, diff);
+          if(!matched)
+          {
+            fhClusterTimeDiffChargedPileUp[4]->Fill(ecluster, diff);
+            if(okPhoton)  fhClusterTimeDiffPhotonPileUp[4]->Fill(ecluster, diff);
+          }
+        }
+        
+        if(GetReader()->IsPileUpFromEMCalAndNotSPD())
+        {
+          fhClusterTimeDiffPileUp[5]->Fill(ecluster, diff);
+          if(!matched)
+          {
+            fhClusterTimeDiffChargedPileUp[5]->Fill(ecluster, diff);
+            if(okPhoton)  fhClusterTimeDiffPhotonPileUp[5]->Fill(ecluster, diff);
+          }
+        }
+
+        if(GetReader()->IsPileUpFromNotSPDAndNotEMCal())
+        {
+          fhClusterTimeDiffPileUp[6]->Fill(ecluster, diff);
+          if(!matched)
+          {
+            fhClusterTimeDiffChargedPileUp[6]->Fill(ecluster, diff);
+            if(okPhoton)  fhClusterTimeDiffPhotonPileUp[6]->Fill(ecluster, diff);
+          }
+        }
+      }// Not max
+    }//loop
+    
+  }
+  
   //.......................................
   // TOF cut, BE CAREFUL WITH THIS CUT
   Double_t tof = calo->GetTOF()*1e9;
@@ -224,19 +351,19 @@ Bool_t  AliAnaPhoton::ClusterSelected(AliVCluster* calo, const TLorentzVector mo
   
   if(GetDebug() > 2)  printf("\t Cluster %d Pass Time Cut \n",calo->GetID());
   
-  fhClusterCuts[3]->Fill(calo->E());
+  fhClusterCuts[3]->Fill(ecluster);
 
   //.......................................
   if(calo->GetNCells() <= fNCellsCut && GetReader()->GetDataType() != AliCaloTrackReader::kMC) return kFALSE;
   
   if(GetDebug() > 2) printf("\t Cluster %d Pass NCell Cut \n",calo->GetID());
   
-  fhClusterCuts[4]->Fill(calo->E());
+  fhClusterCuts[4]->Fill(ecluster);
 
   if(nMaxima < fNLMCutMin || nMaxima > fNLMCutMax) return kFALSE ;
   if(GetDebug() > 2) printf(" \t Cluster %d pass NLM %d of out of range \n",calo->GetID(), nMaxima);
 
-  fhClusterCuts[5]->Fill(calo->E());
+  fhClusterCuts[5]->Fill(ecluster);
 
   //.......................................
   //Check acceptance selection
@@ -248,7 +375,7 @@ Bool_t  AliAnaPhoton::ClusterSelected(AliVCluster* calo, const TLorentzVector mo
   
   if(GetDebug() > 2) printf("Fiducial cut passed \n");
   
-  fhClusterCuts[6]->Fill(calo->E());
+  fhClusterCuts[6]->Fill(ecluster);
 
   //.......................................
   //Skip matched clusters with tracks
@@ -267,8 +394,19 @@ Bool_t  AliAnaPhoton::ClusterSelected(AliVCluster* calo, const TLorentzVector mo
       if(GetDebug() > 2)  printf(" Track-matching cut passed \n");
   }// reject matched clusters
   
-  fhClusterCuts[7]->Fill(calo->E());
+  fhClusterCuts[7]->Fill(ecluster);
 
+  if(fFillPileUpHistograms)
+  {
+    if(GetReader()->IsPileUpFromSPD())               {fhPtChargedPileUp[0]->Fill(ptcluster); fhLambda0ChargedPileUp[0]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromEMCal())             {fhPtChargedPileUp[1]->Fill(ptcluster); fhLambda0ChargedPileUp[1]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromSPDOrEMCal())        {fhPtChargedPileUp[2]->Fill(ptcluster); fhLambda0ChargedPileUp[2]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromSPDAndEMCal())       {fhPtChargedPileUp[3]->Fill(ptcluster); fhLambda0ChargedPileUp[3]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromSPDAndNotEMCal())    {fhPtChargedPileUp[4]->Fill(ptcluster); fhLambda0ChargedPileUp[4]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromEMCalAndNotSPD())    {fhPtChargedPileUp[5]->Fill(ptcluster); fhLambda0ChargedPileUp[5]->Fill(ecluster,l0cluster); }
+    if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) {fhPtChargedPileUp[6]->Fill(ptcluster); fhLambda0ChargedPileUp[6]->Fill(ecluster,l0cluster); }
+  }
+  
   //.......................................
   //Check Distance to Bad channel, set bit.
   Double_t distBad=calo->GetDistanceToBadChannel() ; //Distance to bad channel
@@ -279,12 +417,12 @@ Bool_t  AliAnaPhoton::ClusterSelected(AliVCluster* calo, const TLorentzVector mo
   }
   else if(GetDebug() > 2) printf("\t Bad channel cut passed %4.2f > %2.2f \n",distBad, fMinDist);
   
-  fhClusterCuts[8]->Fill(calo->E());
+  fhClusterCuts[8]->Fill(ecluster);
   
   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",
+    printf("AliAnaPhoton::ClusterSelected() Current Event %d; After  selection : E %2.2f, pT %2.2f, phi %2.2f, eta %2.2f\n",
            GetReader()->GetEventNumber(), 
-           calo->E(), mom.Pt(),calo->E(),mom.Phi()*TMath::RadToDeg(),mom.Eta());
+           ecluster, ptcluster,mom.Phi()*TMath::RadToDeg(),mom.Eta());
   
   //All checks passed, cluster selected
   return kTRUE;
@@ -665,8 +803,8 @@ void AliAnaPhoton::FillPileUpHistogramsPerEvent(TObjArray * clusters)
 }
 
 
-//___________________________________________________________________
-void AliAnaPhoton::FillPileUpHistograms(const Float_t energy, const Float_t time) 
+//_________________________________________________________________________________________________
+void AliAnaPhoton::FillPileUpHistograms(const Float_t energy, const Float_t pt, const Float_t time)
 {
   // Fill some histograms to understand pile-up
   if(!fFillPileUpHistograms) return;
@@ -674,6 +812,14 @@ void AliAnaPhoton::FillPileUpHistograms(const Float_t energy, const Float_t time
   //printf("E %f, time %f\n",energy,time);
   AliVEvent * event = GetReader()->GetInputEvent();
   
+  if(GetReader()->IsPileUpFromSPD())               fhPtPhotonPileUp[0]->Fill(pt);
+  if(GetReader()->IsPileUpFromEMCal())             fhPtPhotonPileUp[1]->Fill(pt);
+  if(GetReader()->IsPileUpFromSPDOrEMCal())        fhPtPhotonPileUp[2]->Fill(pt);
+  if(GetReader()->IsPileUpFromSPDAndEMCal())       fhPtPhotonPileUp[3]->Fill(pt);
+  if(GetReader()->IsPileUpFromSPDAndNotEMCal())    fhPtPhotonPileUp[4]->Fill(pt);
+  if(GetReader()->IsPileUpFromEMCalAndNotSPD())    fhPtPhotonPileUp[5]->Fill(pt);
+  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtPhotonPileUp[6]->Fill(pt);
+  
   fhTimeENoCut->Fill(energy,time);
   if(GetReader()->IsPileUpFromSPD())     fhTimeESPD     ->Fill(energy,time);
   if(event->IsPileupFromSPDInMultBins()) fhTimeESPDMulti->Fill(energy,time);
@@ -1827,10 +1973,55 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
     
     for(Int_t i = 0 ; i < 7 ; i++)
     {
+      fhPtPileUp[i]  = new TH1F(Form("hPtPileUp%s",pileUpName[i].Data()),
+                                       Form("Cluster  p_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
+      fhPtPileUp[i]->SetXTitle("p_{T} (GeV/c)");
+      outputContainer->Add(fhPtPileUp[i]);
+      
+      fhPtChargedPileUp[i]  = new TH1F(Form("hPtChargedPileUp%s",pileUpName[i].Data()),
+                                      Form("Charged clusters p_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
+      fhPtChargedPileUp[i]->SetXTitle("p_{T} (GeV/c)");
+      outputContainer->Add(fhPtChargedPileUp[i]);
+
       fhPtPhotonPileUp[i]  = new TH1F(Form("hPtPhotonPileUp%s",pileUpName[i].Data()),
-                                       Form("Selected photon p_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
+                                      Form("Selected photon p_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
       fhPtPhotonPileUp[i]->SetXTitle("p_{T} (GeV/c)");
       outputContainer->Add(fhPtPhotonPileUp[i]);
+      
+      fhClusterTimeDiffPileUp[i]  = new TH2F(Form("hClusterTimeDiffPileUp%s",pileUpName[i].Data()),
+                                Form("Cluster E vs t_{max}-t_{cell} in cluster, %s Pile-Up event",pileUpName[i].Data()),
+                                             nptbins,ptmin,ptmax,200,-100,100);
+      fhClusterTimeDiffPileUp[i]->SetXTitle("E (GeV)");
+      fhClusterTimeDiffPileUp[i]->SetYTitle("t_{max}-t_{cell} (ns)");
+      outputContainer->Add(fhClusterTimeDiffPileUp[i]);
+      
+      fhClusterTimeDiffChargedPileUp[i]  = new TH2F(Form("hClusterTimeDiffChargedPileUp%s",pileUpName[i].Data()),
+                                       Form("Charged clusters E vs t_{max}-t_{cell} in cluster, %s Pile-Up event",pileUpName[i].Data()),
+                                                    nptbins,ptmin,ptmax,200,-100,100);
+      fhClusterTimeDiffChargedPileUp[i]->SetXTitle("E (GeV)");
+      fhClusterTimeDiffChargedPileUp[i]->SetYTitle("t_{max}-t_{cell} (ns)");
+      outputContainer->Add(fhClusterTimeDiffChargedPileUp[i]);
+      
+      fhClusterTimeDiffPhotonPileUp[i]  = new TH2F(Form("hClusterTimeDiffPhotonPileUp%s",pileUpName[i].Data()),
+                                      Form("Selected photon E vs t_{max}-t_{cell} in cluster, %s Pile-Up event",pileUpName[i].Data()),
+                                                   nptbins,ptmin,ptmax,200,-100,100);
+      fhClusterTimeDiffPhotonPileUp[i]->SetXTitle("E (GeV)");
+      fhClusterTimeDiffPhotonPileUp[i]->SetYTitle("t_{max}-t_{cell} (ns)");
+      outputContainer->Add(fhClusterTimeDiffPhotonPileUp[i]);
+
+      fhLambda0PileUp[i]  = new TH2F(Form("hLambda0PileUp%s",pileUpName[i].Data()),
+                                     Form("Cluster E vs #lambda^{2}_{0} in cluster, %s Pile-Up event",pileUpName[i].Data()),
+                                     nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+      fhLambda0PileUp[i]->SetXTitle("E (GeV)");
+      fhLambda0PileUp[i]->SetYTitle("#lambda^{2}_{0}");
+      outputContainer->Add(fhLambda0PileUp[i]);
+      
+      fhLambda0ChargedPileUp[i]  = new TH2F(Form("hLambda0ChargedPileUp%s",pileUpName[i].Data()),
+                                                    Form("Charged clusters E vs #lambda^{2}_{0}in cluster, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax,ssbins,ssmin,ssmax);
+      fhLambda0ChargedPileUp[i]->SetXTitle("E (GeV)");
+      fhLambda0ChargedPileUp[i]->SetYTitle("#lambda^{2}_{0}");
+      outputContainer->Add(fhLambda0ChargedPileUp[i]);
+
     }
     
     fhTimeENoCut  = new TH2F ("hTimeE_NoCut","time of cluster vs E of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
@@ -1851,7 +2042,7 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
     fhTimeNPileUpVertSPD  = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50); 
     fhTimeNPileUpVertSPD->SetYTitle("# vertex ");
     fhTimeNPileUpVertSPD->SetXTitle("time (ns)");
-    outputContainer->Add(fhTimeNPileUpVertSPD);  
+    outputContainer->Add(fhTimeNPileUpVertSPD);
     
     fhTimeNPileUpVertTrack  = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 50,0,50 ); 
     fhTimeNPileUpVertTrack->SetYTitle("# vertex ");
@@ -2484,7 +2675,7 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
       if(aodph.GetIdentifiedParticleType() != AliCaloPID::kPhoton) continue ;                  
       
     }
-    
+
     //...............................................
     // Data, PID check off
     else
@@ -2509,7 +2700,7 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     
     // Fill histograms to undertand pile-up before other cuts applied
     // Remember to relax time cuts in the reader
-    FillPileUpHistograms(calo->E(),calo->GetTOF()*1e9);    
+    FillPileUpHistograms(calo->E(),mom.Pt(),calo->GetTOF()*1e9);
     
     // Add number of local maxima to AOD, method name in AOD to be FIXED
     aodph.SetFiducialArea(nMaxima);
@@ -2567,19 +2758,8 @@ void  AliAnaPhoton::MakeAnalysisFillHistograms()
     fhPtPhoton  ->Fill(ptcluster);
     fhPhiPhoton ->Fill(ptcluster,phicluster);
     fhEtaPhoton ->Fill(ptcluster,etacluster);    
-    if     (ecluster > 0.5)   fhEtaPhiPhoton  ->Fill(etacluster, phicluster);
+    if     (ecluster   > 0.5) fhEtaPhiPhoton  ->Fill(etacluster, phicluster);
     else if(GetMinPt() < 0.5) fhEtaPhi05Photon->Fill(etacluster, phicluster);
-    
-    if(fFillPileUpHistograms)
-    {
-      if(GetReader()->IsPileUpFromSPD())               fhPtPhotonPileUp[0]->Fill(ptcluster);
-      if(GetReader()->IsPileUpFromEMCal())             fhPtPhotonPileUp[1]->Fill(ptcluster);
-      if(GetReader()->IsPileUpFromSPDOrEMCal())        fhPtPhotonPileUp[2]->Fill(ptcluster);
-      if(GetReader()->IsPileUpFromSPDAndEMCal())       fhPtPhotonPileUp[3]->Fill(ptcluster);
-      if(GetReader()->IsPileUpFromSPDAndNotEMCal())    fhPtPhotonPileUp[4]->Fill(ptcluster);
-      if(GetReader()->IsPileUpFromEMCalAndNotSPD())    fhPtPhotonPileUp[5]->Fill(ptcluster);
-      if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtPhotonPileUp[6]->Fill(ptcluster);
-    }
 
     //Get original cluster, to recover some information
     Int_t absID             = 0; 
index cdbd6e1..7f9e808 100755 (executable)
@@ -68,7 +68,7 @@ class AliAnaPhoton : public AliAnaCaloTrackCorrBaseClass {
   void         SwitchOnTMHistoFill()                  { fFillTMHisto      = kTRUE  ; }
   void         SwitchOffTMHistoFill()                 { fFillTMHisto      = kFALSE ; }
 
-  void         FillPileUpHistograms(const Float_t energy, const Float_t time) ;
+  void         FillPileUpHistograms(const Float_t energy, const Float_t pt, const Float_t time) ;
   void         FillPileUpHistogramsPerEvent(TObjArray * clusters) ;
 
   void         SwitchOnFillPileUpHistograms()         { fFillPileUpHistograms = kTRUE  ; }
@@ -287,7 +287,14 @@ class AliAnaPhoton : public AliAnaCaloTrackCorrBaseClass {
   TH2F * fhEOverPTRD[2];                        //! matched track E cluster over P track vs cluster E, after dEdx cut, after and before photon cuts, behind TRD 
 
   // Pile-up
+  TH1F * fhPtPileUp[7];                         //! pT distribution of clusters before any selection
+  TH1F * fhPtChargedPileUp[7];                  //! pT distribution of track matched clusters
   TH1F * fhPtPhotonPileUp[7];                   //! pT distribution of selected photons
+  TH2F * fhLambda0PileUp[7];                    //! E vs M02 distribution of clusters, before any selection
+  TH2F * fhLambda0ChargedPileUp[7];             //! E vs M02 distribution of clusters, track matched clusters
+  TH2F * fhClusterTimeDiffPileUp[7];            //! E vs Time difference inside cluster, before any selection
+  TH2F * fhClusterTimeDiffChargedPileUp[7];     //! E vs Time difference inside cluster for track matched clusters
+  TH2F * fhClusterTimeDiffPhotonPileUp[7];      //! E vs Time difference inside cluster for selected photons
   TH2F * fhTimeENoCut;                          //! time of cluster vs E, no cut
   TH2F * fhTimeESPD;                            //! time of cluster vs E, IsSPDPileUp
   TH2F * fhTimeESPDMulti;                       //! time of cluster vs E, IsSPDPileUpMulti