add histograms to get the custer spectra for different number of pile-up vertices...

diff --git a/PWGGA/CaloTrackCorrelations/AliAnaPhoton.cxx b/PWGGA/CaloTrackCorrelations/AliAnaPhoton.cxx
index e1db8e8307af2b9d589fa1d2f9b85b8cde18a298..797fe89c073e4edf37fcc928456b347cc00d90bd 100755 (executable)
--- a/PWGGA/CaloTrackCorrelations/AliAnaPhoton.cxx
+++ b/PWGGA/CaloTrackCorrelations/AliAnaPhoton.cxx
@@ -132,8 +132,11 @@ AliAnaPhoton::AliAnaPhoton() :
     fhClusterMultSPDPileUp(),             fhClusterMultNoPileUp(),
     fhEtaPhiBC0(0),  fhEtaPhiBCPlus(0),   fhEtaPhiBCMinus(0),
     fhEtaPhiBC0PileUpSPD(0),
-    fhEtaPhiBCPlusPileUpSPD(0),
-    fhEtaPhiBCMinusPileUpSPD(0)
+    fhEtaPhiBCPlusPileUpSPD(0),           fhEtaPhiBCMinusPileUpSPD(0),
+         fhPtNPileUpSPDVtx(0),                 fhPtNPileUpTrkVtx(0),
+    fhPtNPileUpSPDVtxTimeCut(0),          fhPtNPileUpTrkVtxTimeCut(0), 
+    fhPtPhotonNPileUpSPDVtx(0),           fhPtPhotonNPileUpTrkVtx(0),
+    fhPtPhotonNPileUpSPDVtxTimeCut(0),    fhPtPhotonNPileUpTrkVtxTimeCut(0)            
  {
   //default ctor
   
@@ -932,29 +935,82 @@ void AliAnaPhoton::FillAcceptanceHistograms()
 }
 
 //___________________________________________________________________
-void AliAnaPhoton::FillPileUpHistogramsPerEvent(TObjArray * clusters) 
+void AliAnaPhoton::FillPileUpHistogramsPerEvent() 
 {
   // Fill some histograms per event to understand pile-up
   // Open the time cut in the reader to be more meaningful
   
   if(!fFillPileUpHistograms) return;
-    
-  // Loop on clusters, get the maximum energy cluster as reference
-  Int_t nclusters = clusters->GetEntriesFast();
+               
+  AliVEvent * event = GetReader()->GetInputEvent();
+       
+  AliESDEvent* esdEv = dynamic_cast<AliESDEvent*> (event);
+  AliAODEvent* aodEv = dynamic_cast<AliAODEvent*> (event);
+       
+  // N pile up vertices
+  Int_t nVtxSPD = -1;
+  Int_t nVtxTrk = -1;
+  TLorentzVector mom;
+       
+  if      (esdEv)
+  {
+               nVtxSPD = esdEv->GetNumberOfPileupVerticesSPD();
+               nVtxTrk = esdEv->GetNumberOfPileupVerticesTracks();
+  }//ESD
+  else if (aodEv)
+  {
+               nVtxSPD = aodEv->GetNumberOfPileupVerticesSPD();
+               nVtxTrk = aodEv->GetNumberOfPileupVerticesTracks();
+  }//AOD       
+       
+       
+       // Get the appropriate list of clusters 
+       TClonesArray * clusterList = 0;
+       TString  clusterListName   = GetReader()->GetEMCALClusterListName();
+       if     (event->FindListObject(clusterListName))
+               clusterList = dynamic_cast<TClonesArray*> (event->FindListObject(clusterListName));
+       else if(GetReader()->GetOutputEvent())
+               clusterList = dynamic_cast<TClonesArray*> (GetReader()->GetOutputEvent()->FindListObject(clusterListName));
+       
+       // Loop on clusters, get the maximum energy cluster as reference
+  Int_t nclusters = 0; 
+       if(clusterList) nclusters = clusterList->GetEntriesFast();
+       else            nclusters = event->GetNumberOfCaloClusters();
+       
   Int_t   idMax = 0; 
   Float_t  eMax = 0;
-  Float_t  tMax = 0;
+  Float_t  tMax = 0;   
   for(Int_t iclus = 0; iclus < nclusters ; iclus++)
   {
-         AliVCluster * clus =  (AliVCluster*) (clusters->At(iclus));   
-    if(clus->E() > eMax && TMath::Abs(clus->GetTOF()*1e9) < 20)
+               AliVCluster * clus = 0;
+               if(clusterList) clus = (AliVCluster*) (clusterList->At(iclus)); 
+    else            clus = GetReader()->GetInputEvent()->GetCaloCluster(iclus);
+               
+               if(!clus)            continue;
+               
+               if(!clus->IsEMCAL()) continue;
+               
+               Float_t tof = clus->GetTOF()*1e9;
+               if(clus->E() > eMax && TMath::Abs(tof) < 25)
     {
       eMax  = clus->E();
-      tMax  = clus->GetTOF()*1e9;
+                       tMax  = tof;
       idMax = iclus;
     }
+         
+               clus->GetMomentum(mom,GetVertex(0));
+               Float_t pt = mom.Pt();
+         
+               fhPtNPileUpSPDVtx->Fill(pt,nVtxSPD);    
+               fhPtNPileUpTrkVtx->Fill(pt,nVtxTrk);
+       
+               if(TMath::Abs(tof) < 25)
+               { 
+                       fhPtNPileUpSPDVtxTimeCut->Fill(pt,nVtxSPD);     
+                       fhPtNPileUpTrkVtxTimeCut->Fill(pt,nVtxTrk);     
+               }
   }
-
+       
   if(eMax < 5) return;
   
   // Loop again on clusters to compare this max cluster t and the rest of the clusters, if E > 0.3
@@ -965,13 +1021,19 @@ void AliAnaPhoton::FillPileUpHistogramsPerEvent(TObjArray * clusters)
 
   for(Int_t iclus = 0; iclus < nclusters ; iclus++)
   {
-         AliVCluster * clus =  (AliVCluster*) (clusters->At(iclus));   
+               AliVCluster * clus = 0;
+               if(clusterList) clus = (AliVCluster*) (clusterList->At(iclus)); 
+    else            clus = GetReader()->GetInputEvent()->GetCaloCluster(iclus);
+               
+               if(!clus)            continue;
+               
+               if(!clus->IsEMCAL()) continue;
     
     if(clus->E() < 0.3 || iclus==idMax) continue;
     
     Float_t tdiff = TMath::Abs(tMax-clus->GetTOF()*1e9);
     n++;
-    if(tdiff < 20) nOK++;
+    if(tdiff < 25) nOK++;
     else
     {
       n20++;
@@ -1025,31 +1087,40 @@ void AliAnaPhoton::FillPileUpHistograms(Float_t energy, Float_t pt, Float_t time
   AliAODEvent* aodEv = dynamic_cast<AliAODEvent*> (event);
   
   // N pile up vertices
-  Int_t nVerticesSPD    = -1;
-  Int_t nVerticesTracks = -1;
+  Int_t nVtxSPD = -1;
+  Int_t nVtxTrk = -1;
   
   if      (esdEv)
   {
-    nVerticesSPD    = esdEv->GetNumberOfPileupVerticesSPD();
-    nVerticesTracks = esdEv->GetNumberOfPileupVerticesTracks();
+    nVtxSPD = esdEv->GetNumberOfPileupVerticesSPD();
+    nVtxTrk = esdEv->GetNumberOfPileupVerticesTracks();
 
   }//ESD
   else if (aodEv)
   {
-    nVerticesSPD    = aodEv->GetNumberOfPileupVerticesSPD();
-    nVerticesTracks = aodEv->GetNumberOfPileupVerticesTracks();
+    nVtxSPD = aodEv->GetNumberOfPileupVerticesSPD();
+    nVtxTrk = aodEv->GetNumberOfPileupVerticesTracks();
   }//AOD
   
-  fhTimeNPileUpVertSPD  ->Fill(time,nVerticesSPD);
-  fhTimeNPileUpVertTrack->Fill(time,nVerticesTracks);
+  fhTimeNPileUpVertSPD  ->Fill(time,nVtxSPD);
+  fhTimeNPileUpVertTrack->Fill(time,nVtxTrk);
   
+  fhPtPhotonNPileUpSPDVtx->Fill(pt,nVtxSPD);   
+  fhPtPhotonNPileUpTrkVtx->Fill(pt,nVtxTrk);
+       
+  if(TMath::Abs(time) < 25)
+  { 
+        fhPtPhotonNPileUpSPDVtxTimeCut->Fill(pt,nVtxSPD);      
+        fhPtPhotonNPileUpTrkVtxTimeCut->Fill(pt,nVtxTrk);      
+  }
+       
   //printf("Is SPD %d, Is SPD Multi %d, n spd %d, n track %d\n", 
-  //       GetReader()->IsPileUpFromSPD(),event->IsPileupFromSPDInMultBins(),nVerticesSPD,nVerticesTracks);
+  //       GetReader()->IsPileUpFromSPD(),event->IsPileupFromSPDInMultBins(),nVtxSPD,nVtxTrk);
   
   Int_t ncont = -1;
   Float_t z1 = -1, z2 = -1;
   Float_t diamZ = -1;
-  for(Int_t iVert=0; iVert<nVerticesSPD;iVert++)
+  for(Int_t iVert=0; iVert<nVtxSPD;iVert++)
   {
     if      (esdEv)
     {
@@ -2741,12 +2812,12 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
     fhTimeESPDMulti->SetYTitle("time (ns)");
     outputContainer->Add(fhTimeESPDMulti);  
     
-    fhTimeNPileUpVertSPD  = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50); 
+    fhTimeNPileUpVertSPD  = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,20,0,20); 
     fhTimeNPileUpVertSPD->SetYTitle("# vertex ");
     fhTimeNPileUpVertSPD->SetXTitle("time (ns)");
     outputContainer->Add(fhTimeNPileUpVertSPD);
     
-    fhTimeNPileUpVertTrack  = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 50,0,50 ); 
+    fhTimeNPileUpVertTrack  = new TH2F ("hTime_NPileUpVertTracks","time of cluster vs N pile-up Tracks vertex", ntimebins,timemin,timemax, 20,0,20 ); 
     fhTimeNPileUpVertTrack->SetYTitle("# vertex ");
     fhTimeNPileUpVertTrack->SetXTitle("time (ns)");
     outputContainer->Add(fhTimeNPileUpVertTrack);  
@@ -2785,6 +2856,54 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
       outputContainer->Add(fhClusterMultNoPileUp[i]) ;         
     }
     
+       fhPtNPileUpSPDVtx  = new TH2F ("hPt_NPileUpVertSPD","pT of cluster vs N pile-up SPD vertex", 
+                                                                  nptbins,ptmin,ptmax,20,0,20); 
+       fhPtNPileUpSPDVtx->SetYTitle("# vertex ");
+       fhPtNPileUpSPDVtx->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtNPileUpSPDVtx);
+         
+       fhPtNPileUpTrkVtx  = new TH2F ("hPt_NPileUpVertTracks","pT of cluster vs N pile-up Tracks vertex", 
+                                                                  nptbins,ptmin,ptmax, 20,0,20 ); 
+       fhPtNPileUpTrkVtx->SetYTitle("# vertex ");
+       fhPtNPileUpTrkVtx->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtNPileUpTrkVtx);  
+
+       fhPtNPileUpSPDVtxTimeCut  = new TH2F ("hPt_NPileUpVertSPD_TimeCut","pT of cluster vs N pile-up SPD vertex, |tof| < 25 ns", 
+                                                                  nptbins,ptmin,ptmax,20,0,20); 
+       fhPtNPileUpSPDVtxTimeCut->SetYTitle("# vertex ");
+       fhPtNPileUpSPDVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtNPileUpSPDVtxTimeCut);
+         
+       fhPtNPileUpTrkVtxTimeCut  = new TH2F ("hPt_NPileUpVertTracks_TimeCut","pT of cluster vs N pile-up Tracks vertex, |tof| < 25 ns", 
+                                                                                 nptbins,ptmin,ptmax, 20,0,20 ); 
+       fhPtNPileUpTrkVtxTimeCut->SetYTitle("# vertex ");
+       fhPtNPileUpTrkVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtNPileUpTrkVtxTimeCut);  
+         
+       fhPtPhotonNPileUpSPDVtx  = new TH2F ("hPtPhoton_NPileUpVertSPD","pT of cluster vs N pile-up SPD vertex", 
+                                                                        nptbins,ptmin,ptmax,20,0,20); 
+       fhPtPhotonNPileUpSPDVtx->SetYTitle("# vertex ");
+       fhPtPhotonNPileUpSPDVtx->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtPhotonNPileUpSPDVtx);
+         
+       fhPtPhotonNPileUpTrkVtx  = new TH2F ("hPtPhoton_NPileUpVertTracks","pT of cluster vs N pile-up Tracks vertex", 
+                                                                        nptbins,ptmin,ptmax, 20,0,20 ); 
+       fhPtPhotonNPileUpTrkVtx->SetYTitle("# vertex ");
+       fhPtPhotonNPileUpTrkVtx->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtPhotonNPileUpTrkVtx);  
+         
+       fhPtPhotonNPileUpSPDVtxTimeCut  = new TH2F ("hPtPhoton_NPileUpVertSPD_TimeCut","pT of cluster vs N pile-up SPD vertex, |tof| < 25 ns", 
+                                                                        nptbins,ptmin,ptmax,20,0,20); 
+       fhPtPhotonNPileUpSPDVtxTimeCut->SetYTitle("# vertex ");
+       fhPtPhotonNPileUpSPDVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtPhotonNPileUpSPDVtxTimeCut);
+         
+       fhPtPhotonNPileUpTrkVtxTimeCut  = new TH2F ("hPtPhoton_NPileUpVertTracks_TimeCut","pT of cluster vs N pile-up Tracks vertex, |tof| < 25 ns", 
+                                                                                       nptbins,ptmin,ptmax, 20,0,20 ); 
+       fhPtPhotonNPileUpTrkVtxTimeCut->SetYTitle("# vertex ");
+       fhPtPhotonNPileUpTrkVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+       outputContainer->Add(fhPtPhotonNPileUpTrkVtxTimeCut);  
+         
   }
   
   if(IsDataMC())
@@ -3241,7 +3360,7 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
     return;
   }
   
-  FillPileUpHistogramsPerEvent(pl); 
+  FillPileUpHistogramsPerEvent(); 
   
   // Loop on raw clusters before filtering in the reader and fill control histogram
   if((GetReader()->GetEMCALClusterListName()=="" && fCalorimeter=="EMCAL") || fCalorimeter=="PHOS")

diff --git a/PWGGA/CaloTrackCorrelations/AliAnaPhoton.h b/PWGGA/CaloTrackCorrelations/AliAnaPhoton.h
index d9b50ab14e97a72706b0f9a7475c9e37db114f27..bbbebb546d37fbf76f356c2832e28fb9024f6d18 100755 (executable)
--- a/PWGGA/CaloTrackCorrelations/AliAnaPhoton.h
+++ b/PWGGA/CaloTrackCorrelations/AliAnaPhoton.h
@@ -69,7 +69,7 @@ class AliAnaPhoton : public AliAnaCaloTrackCorrBaseClass {
   void         SwitchOffTMHistoFill()                 { fFillTMHisto           = kFALSE ; }
 
   void         FillPileUpHistograms(Float_t energy, Float_t pt, Float_t time) ;
-  void         FillPileUpHistogramsPerEvent(TObjArray * clusters) ;
+  void         FillPileUpHistogramsPerEvent() ;
 
   void         SwitchOnFillPileUpHistograms()         { fFillPileUpHistograms  = kTRUE  ; }
   void         SwitchOffFillPileUpHistograms()        { fFillPileUpHistograms  = kFALSE ; }    
@@ -391,10 +391,20 @@ class AliAnaPhoton : public AliAnaCaloTrackCorrBaseClass {
   TH2F * fhEtaPhiBCPlusPileUpSPD;               //! eta/phi of clusters in BC>0, SPD pile-up
   TH2F * fhEtaPhiBCMinusPileUpSPD;              //! eta/phi of clusters in BC<0, SPD pile-up
 
+  TH2F * fhPtNPileUpSPDVtx;                        //! cluster pt vs number of spd pile-up vertices
+  TH2F * fhPtNPileUpTrkVtx;                     //! cluster pt vs number of track pile-up vertices
+  TH2F * fhPtNPileUpSPDVtxTimeCut;                 //! cluster pt vs number of spd pile-up vertices, time cut +-25 ns
+  TH2F * fhPtNPileUpTrkVtxTimeCut;              //! cluster pt vs number of track pile-up vertices, time cut +- 25 ns  
+
+  TH2F * fhPtPhotonNPileUpSPDVtx;                  //! photon pt vs number of spd pile-up vertices
+  TH2F * fhPtPhotonNPileUpTrkVtx;               //! photon pt vs number of track pile-up vertices
+  TH2F * fhPtPhotonNPileUpSPDVtxTimeCut;        //! photon pt vs number of spd pile-up vertices, time cut +-25 ns
+  TH2F * fhPtPhotonNPileUpTrkVtxTimeCut;        //! photon pt vs number of track pile-up vertices, time cut +- 25 ns           
+       
   AliAnaPhoton(              const AliAnaPhoton & g) ; // cpy ctor
   AliAnaPhoton & operator = (const AliAnaPhoton & g) ; // cpy assignment
   
-  ClassDef(AliAnaPhoton,31)
+  ClassDef(AliAnaPhoton,32)
 
 } ;
  

diff --git a/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx b/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
index 75ff5be2721188c76cdaa192ff901153d4c23a39..4df70f9be05a0744af5fa4cedb96922b93b4190a 100755 (executable)
--- a/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
+++ b/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
@@ -105,7 +105,9 @@ AliAnaPi0EbE::AliAnaPi0EbE() :
     fhTimeENoCut(0),                    fhTimeESPD(0),           fhTimeESPDMulti(0),
     fhTimeNPileUpVertSPD(0),            fhTimeNPileUpVertTrack(0),
     fhTimeNPileUpVertContributors(0),
-    fhTimePileUpMainVertexZDistance(0), fhTimePileUpMainVertexZDiamond(0)
+    fhTimePileUpMainVertexZDistance(0), fhTimePileUpMainVertexZDiamond(0),
+    fhPtNPileUpSPDVtx(0),               fhPtNPileUpTrkVtx(0),
+    fhPtNPileUpSPDVtxTimeCut(0),        fhPtNPileUpTrkVtxTimeCut(0)    
 {
   //default ctor
   
@@ -202,8 +204,8 @@ AliAnaPi0EbE::AliAnaPi0EbE() :
   
 }
 
-//_______________________________________________________________________________
-void AliAnaPi0EbE::FillPileUpHistograms(const Float_t energy, const Float_t time) 
+//_________________________________________________________________________________________________
+void AliAnaPi0EbE::FillPileUpHistograms(const Float_t energy, const Float_t pt, const Float_t time) 
 {
   // Fill some histograms to understand pile-up
   if(!fFillPileUpHistograms) return;
@@ -221,31 +223,40 @@ void AliAnaPi0EbE::FillPileUpHistograms(const Float_t energy, const Float_t time
   AliAODEvent* aodEv = dynamic_cast<AliAODEvent*> (event);
   
   // N pile up vertices
-  Int_t nVerticesSPD    = -1;
-  Int_t nVerticesTracks = -1;
+  Int_t nVtxSPD = -1;
+  Int_t nVtxTrk = -1;
   
   if      (esdEv)
   {
-    nVerticesSPD    = esdEv->GetNumberOfPileupVerticesSPD();
-    nVerticesTracks = esdEv->GetNumberOfPileupVerticesTracks();
+    nVtxSPD = esdEv->GetNumberOfPileupVerticesSPD();
+    nVtxTrk = esdEv->GetNumberOfPileupVerticesTracks();
     
   }//ESD
   else if (aodEv)
   {
-    nVerticesSPD    = aodEv->GetNumberOfPileupVerticesSPD();
-    nVerticesTracks = aodEv->GetNumberOfPileupVerticesTracks();
+    nVtxSPD = aodEv->GetNumberOfPileupVerticesSPD();
+    nVtxTrk = aodEv->GetNumberOfPileupVerticesTracks();
   }//AOD
   
-  fhTimeNPileUpVertSPD  ->Fill(time,nVerticesSPD);
-  fhTimeNPileUpVertTrack->Fill(time,nVerticesTracks);
+  fhTimeNPileUpVertSPD  ->Fill(time,nVtxSPD);
+  fhTimeNPileUpVertTrack->Fill(time,nVtxTrk);
   
+       fhPtNPileUpSPDVtx->Fill(pt,nVtxSPD);    
+       fhPtNPileUpTrkVtx->Fill(pt,nVtxTrk);
+       
+       if(TMath::Abs(time) < 25)
+       { 
+               fhPtNPileUpSPDVtxTimeCut->Fill(pt,nVtxSPD);     
+               fhPtNPileUpTrkVtxTimeCut->Fill(pt,nVtxTrk);     
+       }       
+       
   //printf("Is SPD %d, Is SPD Multi %d, n spd %d, n track %d\n", 
-  //       GetReader()->IsPileUpFromSPD(),event->IsPileupFromSPDInMultBins(),nVerticesSPD,nVerticesTracks);
+  //       GetReader()->IsPileUpFromSPD(),event->IsPileupFromSPDInMultBins(),nVtxSPD,nVtxTracks);
   
   Int_t ncont = -1;
   Float_t z1 = -1, z2 = -1;
   Float_t diamZ = -1;
-  for(Int_t iVert=0; iVert<nVerticesSPD;iVert++)
+  for(Int_t iVert=0; iVert<nVtxSPD;iVert++)
   {
     if      (esdEv)
     {
@@ -1780,7 +1791,30 @@ TList *  AliAnaPi0EbE::GetCreateOutputObjects()
     fhTimePileUpMainVertexZDiamond->SetYTitle("diamond distance Z (cm) ");
     fhTimePileUpMainVertexZDiamond->SetXTitle("time (ns)");
     outputContainer->Add(fhTimePileUpMainVertexZDiamond);  
-    
+               
+               fhPtNPileUpSPDVtx  = new TH2F ("hPt_NPileUpVertSPD","pT of cluster vs N pile-up SPD vertex", 
+                                                                                                                                        nptbins,ptmin,ptmax,20,0,20); 
+               fhPtNPileUpSPDVtx->SetYTitle("# vertex ");
+               fhPtNPileUpSPDVtx->SetXTitle("p_{T} (GeV/c)");
+               outputContainer->Add(fhPtNPileUpSPDVtx);
+         
+               fhPtNPileUpTrkVtx  = new TH2F ("hPt_NPileUpVertTracks","pT of cluster vs N pile-up Tracks vertex", 
+                                                                                                                                        nptbins,ptmin,ptmax, 20,0,20 ); 
+               fhPtNPileUpTrkVtx->SetYTitle("# vertex ");
+               fhPtNPileUpTrkVtx->SetXTitle("p_{T} (GeV/c)");
+               outputContainer->Add(fhPtNPileUpTrkVtx);  
+               
+               fhPtNPileUpSPDVtxTimeCut  = new TH2F ("hPt_NPileUpVertSPD_TimeCut","pT of cluster vs N pile-up SPD vertex, |tof| < 25 ns", 
+                                                                                                                                        nptbins,ptmin,ptmax,20,0,20); 
+               fhPtNPileUpSPDVtxTimeCut->SetYTitle("# vertex ");
+               fhPtNPileUpSPDVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+               outputContainer->Add(fhPtNPileUpSPDVtxTimeCut);
+         
+               fhPtNPileUpTrkVtxTimeCut  = new TH2F ("hPt_NPileUpVertTracks_TimeCut","pT of cluster vs N pile-up Tracks vertex, |tof| < 25 ns", 
+                                                                                                                                                                       nptbins,ptmin,ptmax, 20,0,20 ); 
+               fhPtNPileUpTrkVtxTimeCut->SetYTitle("# vertex ");
+               fhPtNPileUpTrkVtxTimeCut->SetXTitle("p_{T} (GeV/c)");
+               outputContainer->Add(fhPtNPileUpTrkVtxTimeCut); 
   }
   
   //Keep neutral meson selection histograms if requiered
@@ -2129,7 +2163,7 @@ void  AliAnaPi0EbE::MakeInvMassInCalorimeter()
         
         // Fill histograms to undertand pile-up before other cuts applied
         // Remember to relax time cuts in the reader
-        FillPileUpHistograms(mom.E(),((cluster1->GetTOF()+cluster2->GetTOF())*1e9) /2);        
+        FillPileUpHistograms(mom.E(),mom.Pt(),((cluster1->GetTOF()+cluster2->GetTOF())*1e9) /2);        
         
         AliAODPWG4Particle pi0 = AliAODPWG4Particle(mom);
         
@@ -2273,7 +2307,7 @@ void  AliAnaPi0EbE::MakeInvMassInCalorimeterAndCTS()
         
         // Fill histograms to undertand pile-up before other cuts applied
         // Remember to relax time cuts in the reader
-        if(cluster)FillPileUpHistograms(mom.E(),cluster->GetTOF()*1e9);
+        if(cluster)FillPileUpHistograms(mom.E(),mom.Pt(),cluster->GetTOF()*1e9);
         
         AliAODPWG4Particle pi0 = AliAODPWG4Particle(mom);
         
@@ -2508,7 +2542,6 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
       
       fhMCSelectedMassPt     [mcIndex]->Fill(mom.Pt(),mass);
       fhMCSelectedMassSplitPt[mcIndex]->Fill(ptSplit,mass);
-
     }
     
     //-----------------------
@@ -2544,7 +2577,7 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
     Double_t tofcluster   = calo->GetTOF()*1e9;
     Double_t tofclusterUS = TMath::Abs(tofcluster);
 
-    FillPileUpHistograms(calo->E(),tofcluster);
+    FillPileUpHistograms(calo->E(),aodpi0.Pt(),tofcluster);
  
     Int_t id = GetReader()->GetTriggerClusterId();
     if(fFillEMCALBCHistograms && fCalorimeter=="EMCAL" && id >=0 )

diff --git a/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h b/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h
index 56adf2d0c6405c8a1b7c9381d415fba655ec1275..e05b488811360bff9510932a6aee20a76a99fb76 100755 (executable)
--- a/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h
+++ b/PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h
@@ -46,7 +46,7 @@ class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
   
   // Main
   
-  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           FillRejectedClusterHistograms(const TLorentzVector mom, const Int_t mctag);
   
@@ -321,10 +321,15 @@ class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
   TH2F         * fhTimePileUpMainVertexZDistance; //! time of cluster vs difference of z main vertex and pile-up vertex 
   TH2F         * fhTimePileUpMainVertexZDiamond;  //! time of cluster vs difference of z diamond and pile-up vertex 
   
+  TH2F         * fhPtNPileUpSPDVtx;                  //! cluster pt vs number of spd pile-up vertices
+  TH2F         * fhPtNPileUpTrkVtx;               //! cluster pt vs number of track pile-up vertices
+  TH2F         * fhPtNPileUpSPDVtxTimeCut;           //! cluster pt vs number of spd pile-up vertices, time cut +-25 ns
+  TH2F         * fhPtNPileUpTrkVtxTimeCut;        //! cluster pt vs number of track pile-up vertices, time cut +- 25 ns                
+       
   AliAnaPi0EbE(              const AliAnaPi0EbE & pi0ebe) ; // cpy ctor
   AliAnaPi0EbE & operator = (const AliAnaPi0EbE & pi0ebe) ; // cpy assignment
   
-  ClassDef(AliAnaPi0EbE,27)
+  ClassDef(AliAnaPi0EbE,28)
 } ;