Add histogrmas, for triggered events when the trigger matching criteria is opened...
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Jul 2013 13:37:49 +0000 (13:37 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 16 Jul 2013 13:37:49 +0000 (13:37 +0000)
PWGGA/CaloTrackCorrelations/AliAnaPhoton.cxx
PWGGA/CaloTrackCorrelations/AliAnaPhoton.h
PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.cxx
PWGGA/CaloTrackCorrelations/AliAnaPi0EbE.h

index 76c4eb7..fd9bf34 100755 (executable)
@@ -68,6 +68,8 @@ fhNCellsE(0),                 fhCellsE(0),   // Control histograms
 fhMaxCellDiffClusterE(0),     fhTimePt(0),   // Control histograms
 fhEtaPhi(0),                  fhEtaPhiEMCALBC0(0),
 fhEtaPhiEMCALBC1(0),          fhEtaPhiEMCALBCN(0),
+fhTimeTriggerEMCALBCCluster(0),
+fhTimeTriggerEMCALBCUMCluster(0),
 fhEtaPhiTriggerEMCALBCClusterOverTh(0),
 fhEtaPhiTriggerEMCALBCUMClusterOverTh(0),
 fhEtaPhiTriggerEMCALBCClusterBelowTh1(0),
@@ -88,15 +90,23 @@ fhEtaPhiTriggerEMCALBCBadExoticCluster(0),   fhTimeTriggerEMCALBCBadExoticCluste
 fhEtaPhiTriggerEMCALBCUMBadExoticCluster(0), fhTimeTriggerEMCALBCUMBadExoticCluster(0),
 fhTimeTriggerEMCALBCBadMaxCell(0),           fhTimeTriggerEMCALBCUMBadMaxCell(0),
 fhTimeTriggerEMCALBCBadMaxCellExotic(0),     fhTimeTriggerEMCALBCUMBadMaxCellExotic(0),
-fhEtaPhiTriggerEMCALBCUMReMatchOpenTime (0), fhTimeTriggerEMCALBCUMReMatchOpenTime(0),
-fhEtaPhiTriggerEMCALBCUMReMatchCheckNeigh(0),fhTimeTriggerEMCALBCUMReMatchCheckNeigh(0),
-fhEtaPhiTriggerEMCALBCUMReMatchBoth(0),      fhTimeTriggerEMCALBCUMReMatchBoth(0),
+fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster (0), fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster(0),
+fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster(0),fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster(0),
+fhEtaPhiTriggerEMCALBCUMReMatchBothCluster(0),      fhTimeTriggerEMCALBCUMReMatchBothCluster(0),
+fhTimeTriggerEMCALBC0UMReMatchOpenTime(0),
+fhTimeTriggerEMCALBC0UMReMatchCheckNeigh(0),
+fhTimeTriggerEMCALBC0UMReMatchBoth(0),
+
 fhEtaPhiNoTrigger(0),                        fhTimeNoTrigger(0),
 
 fhEPhoton(0),                 fhPtPhoton(0),
 fhPhiPhoton(0),               fhEtaPhoton(0),
 fhEtaPhiPhoton(0),            fhEtaPhi05Photon(0),
 fhEtaPhiPhotonEMCALBC0(0),    fhEtaPhiPhotonEMCALBC1(0),   fhEtaPhiPhotonEMCALBCN(0),
+fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime(0),
+fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh(0),
+fhTimePhotonTriggerEMCALBC0UMReMatchBoth(0),
+
 fhPtCentralityPhoton(0),      fhPtEventPlanePhoton(0),
 
 // Shower shape histograms
@@ -183,6 +193,7 @@ fhPtPhotonNPileUpSPDVtxTimeCut2(0),   fhPtPhotonNPileUpTrkVtxTimeCut2(0)
     
     fhClusterEFracLongTimePileUp  [i] = 0;
     
+    fhClusterCellTimePileUp       [i] = 0;
     fhClusterTimeDiffPileUp       [i] = 0;
     fhClusterTimeDiffChargedPileUp[i] = 0;
     fhClusterTimeDiffPhotonPileUp [i] = 0;
@@ -227,7 +238,9 @@ fhPtPhotonNPileUpSPDVtxTimeCut2(0),   fhPtPhotonNPileUpTrkVtxTimeCut2(0)
   // Track matching residuals
   for(Int_t i = 0; i < 2; i++)
   {
-    fhTrackMatchedDEta[i] = 0;                fhTrackMatchedDPhi[i] = 0;         fhTrackMatchedDEtaDPhi[i] = 0;
+    fhTrackMatchedDEta   [i] = 0;             fhTrackMatchedDPhi   [i] = 0;         fhTrackMatchedDEtaDPhi   [i] = 0;
+    fhTrackMatchedDEtaNeg[i] = 0;             fhTrackMatchedDPhiNeg[i] = 0;         fhTrackMatchedDEtaDPhiNeg[i] = 0;
+    fhTrackMatchedDEtaPos[i] = 0;             fhTrackMatchedDPhiPos[i] = 0;         fhTrackMatchedDEtaDPhiPos[i] = 0;
     fhTrackMatchedDEtaTRD[i] = 0;             fhTrackMatchedDPhiTRD[i] = 0;
     fhTrackMatchedDEtaMCOverlap[i] = 0;       fhTrackMatchedDPhiMCOverlap[i] = 0;
     fhTrackMatchedDEtaMCNoOverlap[i] = 0;     fhTrackMatchedDPhiMCNoOverlap[i] = 0;
@@ -259,10 +272,7 @@ fhPtPhotonNPileUpSPDVtxTimeCut2(0),   fhPtPhotonNPileUpTrkVtxTimeCut2(0)
     fhTimeTriggerEMCALBCPileUpSPD      [i] = 0 ;
     
     fhEtaPhiTriggerEMCALBCCluster      [i] = 0 ;
-    fhTimeTriggerEMCALBCCluster        [i] = 0 ;
-    fhEtaPhiTriggerEMCALBCUMCluster    [i] = 0 ;
-    fhTimeTriggerEMCALBCUMCluster      [i] = 0 ;
-    
+    fhEtaPhiTriggerEMCALBCUMCluster    [i] = 0 ;    
   }
   
   //Initialize parameters
@@ -304,7 +314,7 @@ Bool_t  AliAnaPhoton::ClusterSelected(AliVCluster* calo, TLorentzVector mom, Int
   
   fhClusterCuts[2]->Fill(ecluster);
   
-  FillClusterPileUpHistograms(calo,matched,ecluster,ptcluster,etacluster,phicluster,l0cluster);
+  FillClusterPileUpHistograms(calo,matched,ptcluster,etacluster,phicluster,l0cluster);
   
   //.......................................
   // TOF cut, BE CAREFUL WITH THIS CUT
@@ -739,7 +749,7 @@ void  AliAnaPhoton::FillEMCALTriggerClusterBCHistograms(const Int_t idcalo, cons
         if(idcalo ==  GetReader()->GetTriggerClusterId())
         {
           fhEtaPhiTriggerEMCALBCCluster[bc+5]->Fill(etacluster, phicluster);
-          fhTimeTriggerEMCALBCCluster[bc+5]  ->Fill(ecluster, tofcluster);
+          fhTimeTriggerEMCALBCCluster        ->Fill(ecluster, tofcluster);
           
           if(bc==0)
           {
@@ -758,10 +768,17 @@ void  AliAnaPhoton::FillEMCALTriggerClusterBCHistograms(const Int_t idcalo, cons
         if(ecluster > 2) fhEtaPhiTriggerEMCALBCUM[bc+5]->Fill(etacluster, phicluster);
         fhTimeTriggerEMCALBCUM[bc+5]->Fill(ecluster, tofcluster);
         
+        if(bc==0)
+        {
+          if(GetReader()->IsTriggerMatchedOpenCuts(0)) fhTimeTriggerEMCALBC0UMReMatchOpenTime   ->Fill(ecluster, tofcluster);
+          if(GetReader()->IsTriggerMatchedOpenCuts(1)) fhTimeTriggerEMCALBC0UMReMatchCheckNeigh ->Fill(ecluster, tofcluster);
+          if(GetReader()->IsTriggerMatchedOpenCuts(2)) fhTimeTriggerEMCALBC0UMReMatchBoth       ->Fill(ecluster, tofcluster);
+        }
+        
         if(idcalo ==  GetReader()->GetTriggerClusterId())
         {
           fhEtaPhiTriggerEMCALBCUMCluster[bc+5]->Fill(etacluster, phicluster);
-          fhTimeTriggerEMCALBCUMCluster[bc+5]  ->Fill(ecluster, tofcluster);
+          fhTimeTriggerEMCALBCUMCluster->Fill(ecluster, tofcluster);
           if(bc==0)
           {
             Float_t threshold = GetReader()->GetEventTriggerThreshold() ;
@@ -774,18 +791,18 @@ void  AliAnaPhoton::FillEMCALTriggerClusterBCHistograms(const Int_t idcalo, cons
             
             if(GetReader()->IsTriggerMatchedOpenCuts(0))
             {
-              fhEtaPhiTriggerEMCALBCUMReMatchOpenTime->Fill(etacluster, phicluster);
-              fhTimeTriggerEMCALBCUMReMatchOpenTime  ->Fill(ecluster, tofcluster);
+              fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster->Fill(etacluster, phicluster);
+              fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster  ->Fill(ecluster, tofcluster);
             }
             if(GetReader()->IsTriggerMatchedOpenCuts(1))
             {
-              fhEtaPhiTriggerEMCALBCUMReMatchCheckNeigh->Fill(etacluster, phicluster);
-              fhTimeTriggerEMCALBCUMReMatchCheckNeigh  ->Fill(ecluster, tofcluster);
+              fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster->Fill(etacluster, phicluster);
+              fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster  ->Fill(ecluster, tofcluster);
             }
             if(GetReader()->IsTriggerMatchedOpenCuts(2))
             {
-              fhEtaPhiTriggerEMCALBCUMReMatchBoth->Fill(etacluster, phicluster);
-              fhTimeTriggerEMCALBCUMReMatchBoth  ->Fill(ecluster, tofcluster);
+              fhEtaPhiTriggerEMCALBCUMReMatchBothCluster->Fill(etacluster, phicluster);
+              fhTimeTriggerEMCALBCUMReMatchBothCluster  ->Fill(ecluster, tofcluster);
             }
             
           }
@@ -844,7 +861,7 @@ void  AliAnaPhoton::FillEMCALTriggerClusterBCHistograms(const Int_t idcalo, cons
 
 //______________________________________________________________________________________________
 void  AliAnaPhoton::FillClusterPileUpHistograms(AliVCluster * calo,       const Bool_t matched,
-                                                const Float_t ecluster,   const Float_t ptcluster,
+                                                const Float_t ptcluster,
                                                 const Float_t etacluster, const Float_t phicluster,
                                                 const Float_t l0cluster)
 {
@@ -869,14 +886,16 @@ void  AliAnaPhoton::FillClusterPileUpHistograms(AliVCluster * calo,       const
   
   Float_t clusterLongTimePt = 0;
   Float_t clusterOKTimePt   = 0;
-  
-  //Loop on cells inside cluster
-  for (Int_t ipos = 0; ipos < calo->GetNCells(); ipos++)
+    
+  //Loop on cells inside cluster, max cell must be over 100 MeV and time in BC=0
+  if(cells->GetCellAmplitude(absIdMax) > 0.1 && TMath::Abs(tmax) < 30)
   {
-    Int_t absId  = calo->GetCellsAbsId()[ipos];
-    //if(absId!=absIdMax && cells->GetCellAmplitude(absIdMax) > 0.01)
-    if(cells->GetCellAmplitude(absIdMax) > 0.1)
+    for (Int_t ipos = 0; ipos < calo->GetNCells(); ipos++)
     {
+      Int_t absId  = calo->GetCellsAbsId()[ipos];
+      
+      if( absId == absIdMax ) continue ;
+      
       Double_t time  = cells->GetCellTime(absId);
       Float_t  amp   = cells->GetCellAmplitude(absId);
       Int_t    bc    = GetReader()->GetInputEvent()->GetBunchCrossNumber();
@@ -888,92 +907,104 @@ void  AliAnaPhoton::FillClusterPileUpHistograms(AliVCluster * calo,       const
       if(GetReader()->IsInTimeWindow(time,amp)) clusterOKTimePt   += amp;
       else                                      clusterLongTimePt += amp;
       
+      if( cells->GetCellAmplitude(absIdMax) < 0.05 ) continue ;
+      
       if(GetReader()->IsPileUpFromSPD())
       {
-        fhClusterTimeDiffPileUp[0]->Fill(ecluster, diff);
+        fhClusterCellTimePileUp[0]->Fill(ptcluster, time);
+        fhClusterTimeDiffPileUp[0]->Fill(ptcluster, diff);
         if(!matched)
         {
-          fhClusterTimeDiffChargedPileUp[0]->Fill(ecluster, diff);
-          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[0]->Fill(ecluster, diff);
+          fhClusterTimeDiffChargedPileUp[0]->Fill(ptcluster, diff);
+          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[0]->Fill(ptcluster, diff);
         }
       }
       
       if(GetReader()->IsPileUpFromEMCal())
       {
-        fhClusterTimeDiffPileUp[1]->Fill(ecluster, diff);
+        fhClusterCellTimePileUp[1]->Fill(ptcluster, time);
+        fhClusterTimeDiffPileUp[1]->Fill(ptcluster, diff);
         if(!matched)
         {
-          fhClusterTimeDiffChargedPileUp[1]->Fill(ecluster, diff);
-          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[1]->Fill(ecluster, diff);
+          fhClusterTimeDiffChargedPileUp[1]->Fill(ptcluster, diff);
+          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[1]->Fill(ptcluster, diff);
         }
       }
       
       if(GetReader()->IsPileUpFromSPDOrEMCal())
       {
-        fhClusterTimeDiffPileUp[2]->Fill(ecluster, diff);
+        fhClusterCellTimePileUp[2]->Fill(ptcluster, time);
+        fhClusterTimeDiffPileUp[2]->Fill(ptcluster, diff);
         if(!matched)
         {
-          fhClusterTimeDiffChargedPileUp[2]->Fill(ecluster, diff);
-          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[2]->Fill(ecluster, diff);
+          fhClusterTimeDiffChargedPileUp[2]->Fill(ptcluster, diff);
+          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[2]->Fill(ptcluster, diff);
         }
       }
       
       if(GetReader()->IsPileUpFromSPDAndEMCal())
       {
-        fhClusterTimeDiffPileUp[3]->Fill(ecluster, diff);
+        fhClusterCellTimePileUp[3]->Fill(ptcluster, time);
+        fhClusterTimeDiffPileUp[3]->Fill(ptcluster, diff);
         if(!matched)
         {
-          fhClusterTimeDiffChargedPileUp[3]->Fill(ecluster, diff);
-          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[3]->Fill(ecluster, diff);
+          fhClusterTimeDiffChargedPileUp[3]->Fill(ptcluster, diff);
+          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[3]->Fill(ptcluster, diff);
         }
       }
       
       if(GetReader()->IsPileUpFromSPDAndNotEMCal())
       {
-        fhClusterTimeDiffPileUp[4]->Fill(ecluster, diff);
+        fhClusterCellTimePileUp[4]->Fill(ptcluster, time);
+        fhClusterTimeDiffPileUp[4]->Fill(ptcluster, diff);
         if(!matched)
         {
-          fhClusterTimeDiffChargedPileUp[4]->Fill(ecluster, diff);
-          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[4]->Fill(ecluster, diff);
+          fhClusterTimeDiffChargedPileUp[4]->Fill(ptcluster, diff);
+          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[4]->Fill(ptcluster, diff);
         }
       }
       
       if(GetReader()->IsPileUpFromEMCalAndNotSPD())
       {
-        fhClusterTimeDiffPileUp[5]->Fill(ecluster, diff);
+        fhClusterCellTimePileUp[5]->Fill(ptcluster, time);
+        fhClusterTimeDiffPileUp[5]->Fill(ptcluster, diff);
         if(!matched)
         {
-          fhClusterTimeDiffChargedPileUp[5]->Fill(ecluster, diff);
-          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[5]->Fill(ecluster, diff);
+          fhClusterTimeDiffChargedPileUp[5]->Fill(ptcluster, diff);
+          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[5]->Fill(ptcluster, diff);
         }
       }
       
       if(GetReader()->IsPileUpFromNotSPDAndNotEMCal())
       {
-        fhClusterTimeDiffPileUp[6]->Fill(ecluster, diff);
+        fhClusterCellTimePileUp[6]->Fill(ptcluster, time);
+        fhClusterTimeDiffPileUp[6]->Fill(ptcluster, diff);
         if(!matched)
         {
-          fhClusterTimeDiffChargedPileUp[6]->Fill(ecluster, diff);
-          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[6]->Fill(ecluster, diff);
+          fhClusterTimeDiffChargedPileUp[6]->Fill(ptcluster, diff);
+          if(okPhoton)  fhClusterTimeDiffPhotonPileUp[6]->Fill(ptcluster, diff);
         }
       }
-    }// Not max
-  }//loop
-  
-  Float_t frac = 0;
-  if(clusterLongTimePt+clusterOKTimePt > 0.001)
-    frac = clusterLongTimePt/(clusterLongTimePt+clusterOKTimePt);
-  //printf("E long %f, E OK %f, Fraction large time %f, E %f\n",clusterLongTimePt,clusterOKTimePt,frac,ecluster);
-  
-  if(GetReader()->IsPileUpFromSPD())               {fhPtPileUp[0]->Fill(ptcluster); fhLambda0PileUp[0]->Fill(ecluster,l0cluster); fhClusterEFracLongTimePileUp[0]->Fill(ecluster,frac);}
-  if(GetReader()->IsPileUpFromEMCal())             {fhPtPileUp[1]->Fill(ptcluster); fhLambda0PileUp[1]->Fill(ecluster,l0cluster); fhClusterEFracLongTimePileUp[1]->Fill(ecluster,frac);}
-  if(GetReader()->IsPileUpFromSPDOrEMCal())        {fhPtPileUp[2]->Fill(ptcluster); fhLambda0PileUp[2]->Fill(ecluster,l0cluster); fhClusterEFracLongTimePileUp[2]->Fill(ecluster,frac);}
-  if(GetReader()->IsPileUpFromSPDAndEMCal())       {fhPtPileUp[3]->Fill(ptcluster); fhLambda0PileUp[3]->Fill(ecluster,l0cluster); fhClusterEFracLongTimePileUp[3]->Fill(ecluster,frac);}
-  if(GetReader()->IsPileUpFromSPDAndNotEMCal())    {fhPtPileUp[4]->Fill(ptcluster); fhLambda0PileUp[4]->Fill(ecluster,l0cluster); fhClusterEFracLongTimePileUp[4]->Fill(ecluster,frac);}
-  if(GetReader()->IsPileUpFromEMCalAndNotSPD())    {fhPtPileUp[5]->Fill(ptcluster); fhLambda0PileUp[5]->Fill(ecluster,l0cluster); fhClusterEFracLongTimePileUp[5]->Fill(ecluster,frac);}
-  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) {fhPtPileUp[6]->Fill(ptcluster); fhLambda0PileUp[6]->Fill(ecluster,l0cluster); fhClusterEFracLongTimePileUp[6]->Fill(ecluster,frac);}
+    }//loop
+    
+    
+    Float_t frac = 0;
+    if(clusterLongTimePt+clusterOKTimePt > 0.001)
+      frac = clusterLongTimePt/(clusterLongTimePt+clusterOKTimePt);
+    //printf("E long %f, E OK %f, Fraction large time %f, E %f\n",clusterLongTimePt,clusterOKTimePt,frac,ptcluster);
+    
+    if(GetReader()->IsPileUpFromSPD())               {fhPtPileUp[0]->Fill(ptcluster); fhLambda0PileUp[0]->Fill(ptcluster,l0cluster); fhClusterEFracLongTimePileUp[0]->Fill(ptcluster,frac);}
+    if(GetReader()->IsPileUpFromEMCal())             {fhPtPileUp[1]->Fill(ptcluster); fhLambda0PileUp[1]->Fill(ptcluster,l0cluster); fhClusterEFracLongTimePileUp[1]->Fill(ptcluster,frac);}
+    if(GetReader()->IsPileUpFromSPDOrEMCal())        {fhPtPileUp[2]->Fill(ptcluster); fhLambda0PileUp[2]->Fill(ptcluster,l0cluster); fhClusterEFracLongTimePileUp[2]->Fill(ptcluster,frac);}
+    if(GetReader()->IsPileUpFromSPDAndEMCal())       {fhPtPileUp[3]->Fill(ptcluster); fhLambda0PileUp[3]->Fill(ptcluster,l0cluster); fhClusterEFracLongTimePileUp[3]->Fill(ptcluster,frac);}
+    if(GetReader()->IsPileUpFromSPDAndNotEMCal())    {fhPtPileUp[4]->Fill(ptcluster); fhLambda0PileUp[4]->Fill(ptcluster,l0cluster); fhClusterEFracLongTimePileUp[4]->Fill(ptcluster,frac);}
+    if(GetReader()->IsPileUpFromEMCalAndNotSPD())    {fhPtPileUp[5]->Fill(ptcluster); fhLambda0PileUp[5]->Fill(ptcluster,l0cluster); fhClusterEFracLongTimePileUp[5]->Fill(ptcluster,frac);}
+    if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) {fhPtPileUp[6]->Fill(ptcluster); fhLambda0PileUp[6]->Fill(ptcluster,l0cluster); fhClusterEFracLongTimePileUp[6]->Fill(ptcluster,frac);}
+    
+    fhEtaPhiBC0->Fill(etacluster,phicluster);
+    if(GetReader()->IsPileUpFromSPD()) fhEtaPhiBC0PileUpSPD    ->Fill(etacluster,phicluster);
+  }
   
-  if(tmax > -25 && tmax < 25) {fhEtaPhiBC0    ->Fill(etacluster,phicluster); if(GetReader()->IsPileUpFromSPD()) fhEtaPhiBC0PileUpSPD    ->Fill(etacluster,phicluster); }
   else if (tmax > 25)         {fhEtaPhiBCPlus ->Fill(etacluster,phicluster); if(GetReader()->IsPileUpFromSPD()) fhEtaPhiBCPlusPileUpSPD ->Fill(etacluster,phicluster); }
   else if (tmax <-25)         {fhEtaPhiBCMinus->Fill(etacluster,phicluster); if(GetReader()->IsPileUpFromSPD()) fhEtaPhiBCMinusPileUpSPD->Fill(etacluster,phicluster); }
 }
@@ -1861,15 +1892,7 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
       fhEtaPhiTriggerEMCALBCCluster[i]->SetYTitle("#phi (rad)");
       fhEtaPhiTriggerEMCALBCCluster[i]->SetXTitle("#eta");
       outputContainer->Add(fhEtaPhiTriggerEMCALBCCluster[i]) ;
-      
-      fhTimeTriggerEMCALBCCluster[i] = new TH2F
-      (Form("hTimeTriggerEMCALBC%d_OnlyTrigger",i-5),
-       Form("trigger cluster time vs E of clusters, Trigger EMCAL-BC=%d",i-5),
-       nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
-      fhTimeTriggerEMCALBCCluster[i]->SetXTitle("E (GeV)");
-      fhTimeTriggerEMCALBCCluster[i]->SetYTitle("time (ns)");
-      outputContainer->Add(fhTimeTriggerEMCALBCCluster[i]);
-      
+            
       fhEtaPhiTriggerEMCALBCUMCluster[i] = new TH2F
       (Form("hEtaPhiTriggerEMCALBC%d_OnlyTrigger_UnMatch",i-5),
        Form("trigger cluster, #eta vs #phi, unmatched trigger EMCAL-BC=%d",i-5),
@@ -1877,16 +1900,22 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
       fhEtaPhiTriggerEMCALBCUMCluster[i]->SetYTitle("#phi (rad)");
       fhEtaPhiTriggerEMCALBCUMCluster[i]->SetXTitle("#eta");
       outputContainer->Add(fhEtaPhiTriggerEMCALBCUMCluster[i]) ;
-      
-      fhTimeTriggerEMCALBCUMCluster[i] = new TH2F
-      (Form("hTimeTriggerEMCALBC%d_OnlyTrigger_UnMatch",i-5),
-       Form("trigger cluster time vs E of clusters, unmatched trigger EMCAL-BC=%d",i-5),
-       nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
-      fhTimeTriggerEMCALBCUMCluster[i]->SetXTitle("E (GeV)");
-      fhTimeTriggerEMCALBCUMCluster[i]->SetYTitle("time (ns)");
-      outputContainer->Add(fhTimeTriggerEMCALBCUMCluster[i]);
     }
     
+    fhTimeTriggerEMCALBCCluster = new TH2F("hTimeTriggerEMCALBC_OnlyTrigger",
+                                           "trigger cluster time vs E of clusters",
+                                           nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimeTriggerEMCALBCCluster->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBCCluster->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBCCluster);
+    
+    fhTimeTriggerEMCALBCUMCluster = new TH2F("hTimeTriggerEMCALBC_OnlyTrigger_UnMatch",
+                                             "trigger cluster time vs E of clusters, unmatched trigger",
+                                             nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimeTriggerEMCALBCUMCluster->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBCUMCluster->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBCUMCluster);
+    
     fhEtaPhiTriggerEMCALBCClusterOverTh = new TH2F
     ("hEtaPhiTriggerEMCALBC0_OnlyTrigger_OverThreshold",
      "trigger cluster E > trigger threshold, #eta vs #phi, Trigger EMCAL-BC=0",
@@ -2177,48 +2206,70 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
     outputContainer->Add(fhEtaPhiNoTrigger) ;
     
     
-    fhEtaPhiTriggerEMCALBCUMReMatchOpenTime = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_OpenTime",
+    fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_OpenTime",
                                                        "cluster E > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch open time",
                                                        netabins,etamin,etamax,nphibins,phimin,phimax);
-    fhEtaPhiTriggerEMCALBCUMReMatchOpenTime->SetYTitle("#phi (rad)");
-    fhEtaPhiTriggerEMCALBCUMReMatchOpenTime->SetXTitle("#eta");
-    outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchOpenTime) ;
+    fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster->SetYTitle("#phi (rad)");
+    fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster->SetXTitle("#eta");
+    outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster) ;
     
-    fhTimeTriggerEMCALBCUMReMatchOpenTime = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_OpenTime",
+    fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_OpenTime",
                                                      "cluster time vs E of clusters, no match, rematch open time",
                                                      nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
-    fhTimeTriggerEMCALBCUMReMatchOpenTime->SetXTitle("E (GeV)");
-    fhTimeTriggerEMCALBCUMReMatchOpenTime->SetYTitle("time (ns)");
-    outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchOpenTime);
+    fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster);
     
     
-    fhEtaPhiTriggerEMCALBCUMReMatchCheckNeigh = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_CheckNeighbours",
+    fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_CheckNeighbours",
                                                          "cluster E > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch with neighbour patches",
                                                          netabins,etamin,etamax,nphibins,phimin,phimax);
-    fhEtaPhiTriggerEMCALBCUMReMatchCheckNeigh->SetYTitle("#phi (rad)");
-    fhEtaPhiTriggerEMCALBCUMReMatchCheckNeigh->SetXTitle("#eta");
-    outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchCheckNeigh) ;
+    fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster->SetYTitle("#phi (rad)");
+    fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster->SetXTitle("#eta");
+    outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster) ;
     
-    fhTimeTriggerEMCALBCUMReMatchCheckNeigh = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_CheckNeighbours",
+    fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_CheckNeighbours",
                                                        "cluster time vs E of clusters, no match, rematch with neigbour parches",
                                                        nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
-    fhTimeTriggerEMCALBCUMReMatchCheckNeigh->SetXTitle("E (GeV)");
-    fhTimeTriggerEMCALBCUMReMatchCheckNeigh->SetYTitle("time (ns)");
-    outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchCheckNeigh);
+    fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster);
     
-    fhEtaPhiTriggerEMCALBCUMReMatchBoth = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_Both",
+    fhEtaPhiTriggerEMCALBCUMReMatchBothCluster = new TH2F("hEtaPhiTriggerEMCALBC0_OnlyTrigger_UnMatch_ReMatch_Both",
                                                    "cluster E > 2 GeV, #eta vs #phi, Trigger EMCAL-BC=0, un match, rematch open time and neighbour",
                                                    netabins,etamin,etamax,nphibins,phimin,phimax);
-    fhEtaPhiTriggerEMCALBCUMReMatchBoth->SetYTitle("#phi (rad)");
-    fhEtaPhiTriggerEMCALBCUMReMatchBoth->SetXTitle("#eta");
-    outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchBoth) ;
+    fhEtaPhiTriggerEMCALBCUMReMatchBothCluster->SetYTitle("#phi (rad)");
+    fhEtaPhiTriggerEMCALBCUMReMatchBothCluster->SetXTitle("#eta");
+    outputContainer->Add(fhEtaPhiTriggerEMCALBCUMReMatchBothCluster) ;
     
-    fhTimeTriggerEMCALBCUMReMatchBoth = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_Both",
+    fhTimeTriggerEMCALBCUMReMatchBothCluster = new TH2F("hTimeTrigger_OnlyTrigger_UnMatch_ReMatch_Both",
                                                  "cluster time vs E of clusters, no match, rematch open time and neigbour",
                                                  nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
-    fhTimeTriggerEMCALBCUMReMatchBoth->SetXTitle("E (GeV)");
-    fhTimeTriggerEMCALBCUMReMatchBoth->SetYTitle("time (ns)");
-    outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchBoth);
+    fhTimeTriggerEMCALBCUMReMatchBothCluster->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBCUMReMatchBothCluster->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBCUMReMatchBothCluster);
+    
+    fhTimeTriggerEMCALBC0UMReMatchOpenTime = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_OpenTime",
+                                                            "cluster time vs E of clusters, no match, rematch open time",
+                                                            nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimeTriggerEMCALBC0UMReMatchOpenTime->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBC0UMReMatchOpenTime->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchOpenTime);
+    
+        
+    fhTimeTriggerEMCALBC0UMReMatchCheckNeigh = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_CheckNeighbours",
+                                                              "cluster time vs E of clusters, no match, rematch with neigbour parches",
+                                                              nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimeTriggerEMCALBC0UMReMatchCheckNeigh->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBC0UMReMatchCheckNeigh->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchCheckNeigh);
+        
+    fhTimeTriggerEMCALBC0UMReMatchBoth = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_Both",
+                                                        "cluster time vs E of clusters, no match, rematch open time and neigbour",
+                                                        nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimeTriggerEMCALBC0UMReMatchBoth->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBC0UMReMatchBoth->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchBoth);
     
   }
   
@@ -2311,6 +2362,29 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
       outputContainer->Add(fhTimePhotonTriggerEMCALBCUM[i]);
       
     }
+    
+    fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime = new TH2F("hTimePhotonTriggerBC0_UnMatch_ReMatch_OpenTime",
+                                                      "cluster time vs E of photons, no match, rematch open time",
+                                                      nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime->SetXTitle("E (GeV)");
+    fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime);
+    
+    
+    fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh = new TH2F("hTimePhotonTriggerBC0_UnMatch_ReMatch_CheckNeighbours",
+                                                        "cluster time vs E of photons, no match, rematch with neigbour parches",
+                                                        nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh->SetXTitle("E (GeV)");
+    fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh);
+    
+    fhTimePhotonTriggerEMCALBC0UMReMatchBoth = new TH2F("hTimePhotonTriggerBC0_UnMatch_ReMatch_Both",
+                                                  "cluster time vs E of photons, no match, rematch open time and neigbour",
+                                                  nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimePhotonTriggerEMCALBC0UMReMatchBoth->SetXTitle("E (GeV)");
+    fhTimePhotonTriggerEMCALBC0UMReMatchBoth->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimePhotonTriggerEMCALBC0UMReMatchBoth);
+
   }
   
   fhNLocMax = new TH2F("hNLocMax","Number of local maxima in cluster",
@@ -2772,6 +2846,13 @@ TList *  AliAnaPhoton::GetCreateOutputObjects()
       fhClusterEFracLongTimePileUp[i]->SetYTitle("E(large time) / E");
       outputContainer->Add(fhClusterEFracLongTimePileUp[i]);
       
+      fhClusterCellTimePileUp[i]  = new TH2F(Form("hClusterCellTimePileUp%s",pileUpName[i].Data()),
+                                             Form("Cluster E vs cell time in cluster, %s Pile-Up event",pileUpName[i].Data()),
+                                             nptbins,ptmin,ptmax,ntimebins,timemin,timemax);
+      fhClusterCellTimePileUp[i]->SetXTitle("E (GeV)");
+      fhClusterCellTimePileUp[i]->SetYTitle("t_{cell} (ns)");
+      outputContainer->Add(fhClusterCellTimePileUp[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);
@@ -3704,6 +3785,13 @@ void  AliAnaPhoton::MakeAnalysisFillAOD()
         {
           if(calo->E() > 2) fhEtaPhiPhotonTriggerEMCALBCUM[bc+5]->Fill(aodph.Eta(), phicluster);
           fhTimePhotonTriggerEMCALBCUM[bc+5]->Fill(calo->E(), calotof);
+          
+          if(bc==0)
+          {
+            if(GetReader()->IsTriggerMatchedOpenCuts(0)) fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime   ->Fill(calo->E(), calotof);
+            if(GetReader()->IsTriggerMatchedOpenCuts(1)) fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh ->Fill(calo->E(), calotof);
+            if(GetReader()->IsTriggerMatchedOpenCuts(2)) fhTimePhotonTriggerEMCALBC0UMReMatchBoth       ->Fill(calo->E(), calotof);
+          }
         }
       }
       else if(TMath::Abs(bc) >= 6)
index 8d0cbfc..bcd8092 100755 (executable)
@@ -72,7 +72,7 @@ class AliAnaPhoton : public AliAnaCaloTrackCorrBaseClass {
   void         SwitchOffTMHistoFill()                 { fFillTMHisto           = kFALSE ; }
 
   void         FillClusterPileUpHistograms(AliVCluster * calo,       const Bool_t matched,
-                                           const Float_t ecluster,   const Float_t ptcluster,
+                                           const Float_t ptcluster,
                                            const Float_t etacluster, const Float_t phicluster,
                                            const Float_t l0cluster);
   
@@ -127,312 +127,321 @@ class AliAnaPhoton : public AliAnaCaloTrackCorrBaseClass {
                     kmcISR = 12,          kmcString = 13                               };  
 
   enum mcPTypes   { kmcPPhoton = 0,       kmcPPi0Decay = 1,       kmcPOtherDecay = 2,  kmcPOther = 3,
-                    kmcPPrompt = 4,       kmcPFragmentation = 5,  kmcPISR = 6           };  
+                    kmcPPrompt = 4,       kmcPFragmentation = 5,  kmcPISR = 6           };
   
   enum mcssTypes  { kmcssPhoton = 0,      kmcssOther = 1,       kmcssPi0 = 2,         
                     kmcssEta = 3,         kmcssConversion = 4,  kmcssElectron = 5       };  
   
   private:
  
-  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
-  Bool_t   fRejectTrackMatch ;           // If PID on, reject clusters which have an associated TPC track
-  Bool_t   fFillTMHisto;                 // Fill track matching plots
-  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
-  Int_t    fNLMCutMin  ;                 // Remove clusters/cells with number of local maxima smaller than this value
-  Int_t    fNLMCutMax  ;                 // Remove clusters/cells with number of local maxima larger than this value
-  Bool_t   fFillSSHistograms ;           // Fill shower shape histograms
-  Bool_t   fFillOnlySimpleSSHisto;       // Fill selected cluster histograms, selected SS histograms
-  Int_t    fNOriginHistograms;           // Fill only NOriginHistograms of the 14 defined types
-  Int_t    fNPrimaryHistograms;          // Fill only NPrimaryHistograms of the 7 defined types
-  Bool_t   fFillPileUpHistograms;        // Fill pile-up related histograms
-  Bool_t   fFillEMCALBCHistograms;       // Fill eta-phi BC dependent histograms
+  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
+  Bool_t   fRejectTrackMatch ;                      // If PID on, reject clusters which have an associated TPC track
+  Bool_t   fFillTMHisto;                            // Fill track matching plots
+  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
+  Int_t    fNLMCutMin  ;                            // Remove clusters/cells with number of local maxima smaller than this value
+  Int_t    fNLMCutMax  ;                            // Remove clusters/cells with number of local maxima larger than this value
+  Bool_t   fFillSSHistograms ;                      // Fill shower shape histograms
+  Bool_t   fFillOnlySimpleSSHisto;                  // Fill selected cluster histograms, selected SS histograms
+  Int_t    fNOriginHistograms;                      // Fill only NOriginHistograms of the 14 defined types
+  Int_t    fNPrimaryHistograms;                     // Fill only NPrimaryHistograms of the 7 defined types
+  Bool_t   fFillPileUpHistograms;                   // Fill pile-up related histograms
+  Bool_t   fFillEMCALBCHistograms;                  // Fill eta-phi BC dependent histograms
   
   //Histograms 
-  TH1F * fhClusterCuts[10];              //! control histogram on the different photon selection cuts
-  TH2F * fhNCellsE;                      //! number of cells in cluster vs E 
-  TH2F * fhCellsE;                       //! energy of cells in cluster vs E of cluster
-  TH2F * fhMaxCellDiffClusterE;          //! Fraction of energy carried by cell with maximum energy
-  TH2F * fhTimePt;                       //! time of photon cluster vs pt
-  
-  TH2F * fhEtaPhi  ;                     //! Pseudorapidity vs Phi of clusters for E > 0.5
-  TH2F * fhEtaPhiEMCALBC0  ;             //! Pseudorapidity vs Phi of clusters for E > 0.5
-  TH2F * fhEtaPhiEMCALBC1  ;             //! Pseudorapidity vs Phi of clusters for E > 0.5
-  TH2F * fhEtaPhiEMCALBCN  ;             //! Pseudorapidity vs Phi of clusters for E > 0.5
-
-  TH2F * fhEtaPhiTriggerEMCALBC[11] ;     //! Pseudorapidity vs Phi of clusters for E > 2
-  TH2F * fhTimeTriggerEMCALBC  [11] ;     //! Time distribution of clusters, when trigger is in a given BC
-  TH2F * fhTimeTriggerEMCALBCPileUpSPD[11]; //! Time distribution of clusters, when trigger is in a given BC, tagged as pile-up SPD
-
-  TH2F * fhEtaPhiTriggerEMCALBCUM[11] ;     //! Pseudorapidity vs Phi of clusters for E > 2, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUM  [11] ;     //! Time distribution of clusters, when trigger is in a given BC, not matched to trigger
-  
-  TH2F * fhEtaPhiTriggerEMCALBCCluster  [11] ; //! Pseudorapidity vs Phi of trigger clusters
-  TH2F * fhTimeTriggerEMCALBCCluster    [11] ; //! Time distribution of clusters, when trigger cluster is in a given BC
-  TH2F * fhEtaPhiTriggerEMCALBCUMCluster[11] ; //! Pseudorapidity vs Phi of highest E cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMCluster  [11] ; //! Time distribution of highest energy cluster in event, when trigger is in a given BC, not
-  
-  TH2F * fhEtaPhiTriggerEMCALBCClusterOverTh     ; //! Pseudorapidity vs Phi of trigger clusters, over nominal threshold
-  TH2F * fhEtaPhiTriggerEMCALBCUMClusterOverTh   ; //! Pseudorapidity vs Phi of highest E cluster  in event, not matched to trigger, over nominal threshold
-  TH2F * fhEtaPhiTriggerEMCALBCClusterBelowTh1   ; //! Pseudorapidity vs Phi of trigger clusters, 1 GeV below nominal threshold
-  TH2F * fhEtaPhiTriggerEMCALBCUMClusterBelowTh1 ; //! Pseudorapidity vs Phi of highest E cluster  in event, not matched to trigger, 2 GeV below nominal threshold
-  TH2F * fhEtaPhiTriggerEMCALBCClusterBelowTh2   ; //! Pseudorapidity vs Phi of trigger clusters, 1 GeV below nominal threshold
-  TH2F * fhEtaPhiTriggerEMCALBCUMClusterBelowTh2 ; //! Pseudorapidity vs Phi of highest E cluster  in event, not matched to trigger, 2 GeV below nominal threshold
-
-  TH2F * fhEtaPhiTriggerEMCALBCExotic            ; //! Pseudorapidity vs Phi of trigger exotic clusters
-  TH2F * fhTimeTriggerEMCALBCExotic              ; //! Time distribution of clusters, when trigger exotic cluster 
-  TH2F * fhEtaPhiTriggerEMCALBCUMExotic          ; //! Pseudorapidity vs Phi of highest E exotic cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMExotic            ; //! Time distribution of highest energy exotic cluster in event, not matched to trigger
-
-  TH2F * fhEtaPhiTriggerEMCALBCBad               ; //! Pseudorapidity vs Phi of trigger exotic clusters
-  TH2F * fhTimeTriggerEMCALBCBad                 ; //! Time distribution of clusters, when trigger exotic 
-  TH2F * fhEtaPhiTriggerEMCALBCUMBad             ; //! Pseudorapidity vs Phi of highest E exotic cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMBad               ; //! Time distribution of highest energy exotic cluster in event, not matched to trigger
-  
-  TH2F * fhEtaPhiTriggerEMCALBCBadExotic         ; //! Pseudorapidity vs Phi of trigger exotic and bad clusters
-  TH2F * fhTimeTriggerEMCALBCBadExotic           ; //! Time distribution of clusters, when trigger exotic and bad cluster 
-  TH2F * fhEtaPhiTriggerEMCALBCUMBadExotic       ; //! Pseudorapidity vs Phi of highest E exotic cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMBadExotic         ; //! Time distribution of highest energy exotic cluster in event, not matched to trigger
-  
-  TH2F * fhEtaPhiTriggerEMCALBCExoticCluster     ; //! Pseudorapidity vs Phi of trigger exotic clusters
-  TH2F * fhTimeTriggerEMCALBCExoticCluster       ; //! Time distribution of clusters, when trigger exotic cluster 
-  TH2F * fhEtaPhiTriggerEMCALBCUMExoticCluster   ; //! Pseudorapidity vs Phi of highest E exotic cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMExoticCluster     ; //! Time distribution of highest energy exotic cluster in event, not matched to trigger
-  
-  TH2F * fhEtaPhiTriggerEMCALBCBadCluster        ; //! Pseudorapidity vs Phi of trigger bad clusters
-  TH2F * fhTimeTriggerEMCALBCBadCluster          ; //! Time distribution of clusters, when trigger bad cluster is in a given BC
-  TH2F * fhEtaPhiTriggerEMCALBCUMBadCluster      ; //! Pseudorapidity vs Phi of highest E bad cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMBadCluster        ; //! Time distribution of highest energy bad cluster in event, when trigger is in a given BC, not
-
-  TH2F * fhEtaPhiTriggerEMCALBCBadExoticCluster  ; //! Pseudorapidity vs Phi of trigger exotic and bad clusters
-  TH2F * fhTimeTriggerEMCALBCBadExoticCluster    ; //! Time distribution of clusters, when trigger exotic and bad cluster 
-  TH2F * fhEtaPhiTriggerEMCALBCUMBadExoticCluster; //! Pseudorapidity vs Phi of highest E exotic and bad cluster in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMBadExoticCluster  ; //! Time distribution of highest energy exotic and bad cluster in event, not matched to trigger
-  
-  TH2F * fhTimeTriggerEMCALBCBadMaxCell          ; //! Time distribution of trigger clusters, when trigger bad max cell
-  TH2F * fhTimeTriggerEMCALBCUMBadMaxCell        ; //! Time distribution of highest energy bad max cell cluster in event, when trigger is not found
-  TH2F * fhTimeTriggerEMCALBCBadMaxCellExotic    ; //! Time distribution of trigger clusters, when trigger exotic cluster with bad max cell
-  TH2F * fhTimeTriggerEMCALBCUMBadMaxCellExotic  ; //! Time distribution of highest energy exotic with bad max cell cluster in event, when trigger is not found
-  
-  TH2F * fhEtaPhiTriggerEMCALBCUMReMatchOpenTime ;  //! Pseudorapidity vs Phi of highest E bad cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMReMatchOpenTime   ;  //! Time distribution of highest energy bad max cell cluster in event, when trigger is not found
-  TH2F * fhEtaPhiTriggerEMCALBCUMReMatchCheckNeigh; //! Pseudorapidity vs Phi of highest E bad cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMReMatchCheckNeigh ;  //! Time distribution of highest energy bad max cell cluster in event, when trigger is not found
-  TH2F * fhEtaPhiTriggerEMCALBCUMReMatchBoth     ;  //! Pseudorapidity vs Phi of highest E bad cluster  in event, not matched to trigger
-  TH2F * fhTimeTriggerEMCALBCUMReMatchBoth       ;  //! Time distribution of highest energy bad max cell cluster in event, when trigger is not found
-  
-  TH2F * fhEtaPhiNoTrigger ;             //! Pseudorapidity vs Phi of highest E exotic cluster  in event, no trigger at all
-  TH2F * fhTimeNoTrigger   ;             //! Time distribution of highest energy exotic cluster in event, no trigger at all
-  
-  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 
-  TH2F * fhEtaPhoton  ;                  //! Pseudorapidity of identified  photon vs transerse momentum 
-  TH2F * fhEtaPhiPhoton  ;               //! Pseudorapidity vs Phi of identified  photon for E > 0.5
-  TH2F * fhEtaPhi05Photon  ;             //! Pseudorapidity vs Phi of identified  photon for E < 0.5
-  TH2F * fhEtaPhiPhotonEMCALBC0  ;       //! Pseudorapidity vs Phi of identified  photon for E > 0.5
-  TH2F * fhEtaPhiPhotonEMCALBC1  ;       //! Pseudorapidity vs Phi of identified  photon for E > 0.5
-  TH2F * fhEtaPhiPhotonEMCALBCN  ;       //! Pseudorapidity vs Phi of identified  photon for E > 0.5
-  TH2F * fhEtaPhiPhotonTriggerEMCALBC[11]; //! Pseudorapidity vs Phi of photons for E > 0.5
-  TH2F * fhTimePhotonTriggerEMCALBC  [11]; //! Time distribution of photons, when trigger is in a given BC
-  TH2F * fhTimePhotonTriggerEMCALBCPileUpSPD[11] ; //! Time distribution of photons, when trigger is in a given BC, tagged as pile-up SPD
-  TH2F * fhEtaPhiPhotonTriggerEMCALBCUM[11]; //! Pseudorapidity vs Phi of photons for E > 2, not matched to trigger
-  TH2F * fhTimePhotonTriggerEMCALBCUM  [11]; //! Time distribution of photons, when trigger is in a given BC, not matched to trigger
-
-  TH2F * fhPtCentralityPhoton    ;       //! centrality  vs photon pT
-  TH2F * fhPtEventPlanePhoton    ;       //! event plane vs photon pT
+  TH1F * fhClusterCuts[10];                         //! control histogram on the different photon selection cuts
+  TH2F * fhNCellsE;                                 //! number of cells in cluster vs E
+  TH2F * fhCellsE;                                  //! energy of cells in cluster vs E of cluster
+  TH2F * fhMaxCellDiffClusterE;                     //! Fraction of energy carried by cell with maximum energy
+  TH2F * fhTimePt;                                  //! time of photon cluster vs pt
+  
+  TH2F * fhEtaPhi  ;                                //! Pseudorapidity vs Phi of clusters for E > 0.5
+  TH2F * fhEtaPhiEMCALBC0  ;                        //! Pseudorapidity vs Phi of clusters for E > 0.5
+  TH2F * fhEtaPhiEMCALBC1  ;                        //! Pseudorapidity vs Phi of clusters for E > 0.5
+  TH2F * fhEtaPhiEMCALBCN  ;                        //! Pseudorapidity vs Phi of clusters for E > 0.5
+
+  TH2F * fhEtaPhiTriggerEMCALBC[11] ;               //! Pseudorapidity vs Phi of clusters for E > 2
+  TH2F * fhTimeTriggerEMCALBC  [11] ;               //! Time distribution of clusters, when trigger is in a given BC
+  TH2F * fhTimeTriggerEMCALBCPileUpSPD[11];         //! Time distribution of clusters, when trigger is in a given BC, tagged as pile-up SPD
+
+  TH2F * fhEtaPhiTriggerEMCALBCUM[11] ;             //! Pseudorapidity vs Phi of clusters for E > 2, not matched to trigger
+  TH2F * fhTimeTriggerEMCALBCUM  [11] ;             //! Time distribution of clusters, when trigger is in a given BC, not matched to trigger
+  
+  TH2F * fhEtaPhiTriggerEMCALBCCluster  [11] ;      //! Pseudorapidity vs Phi of trigger clusters
+  TH2F * fhTimeTriggerEMCALBCCluster ;              //! Time distribution of clusters, when trigger cluster is in a given BC
+  TH2F * fhEtaPhiTriggerEMCALBCUMCluster[11] ;      //! Pseudorapidity vs Phi of highest E cluster  in event, not matched to trigger
+  TH2F * fhTimeTriggerEMCALBCUMCluster ;            //! Time distribution of highest energy cluster in event, when trigger is in a given BC, not
+  
+  TH2F * fhEtaPhiTriggerEMCALBCClusterOverTh     ;  //! Pseudorapidity vs Phi of trigger clusters, over nominal threshold
+  TH2F * fhEtaPhiTriggerEMCALBCUMClusterOverTh   ;  //! Pseudorapidity vs Phi of highest E cluster  in event, not matched to trigger, over nominal threshold
+  TH2F * fhEtaPhiTriggerEMCALBCClusterBelowTh1   ;  //! Pseudorapidity vs Phi of trigger clusters, 1 GeV below nominal threshold
+  TH2F * fhEtaPhiTriggerEMCALBCUMClusterBelowTh1 ;  //! Pseudorapidity vs Phi of highest E cluster  in event, not matched to trigger, 2 GeV below nominal threshold
+  TH2F * fhEtaPhiTriggerEMCALBCClusterBelowTh2   ;  //! Pseudorapidity vs Phi of trigger clusters, 1 GeV below nominal threshold
+  TH2F * fhEtaPhiTriggerEMCALBCUMClusterBelowTh2 ;  //! Pseudorapidity vs Phi of highest E cluster  in event, not matched to trigger, 2 GeV below nominal threshold
+
+  TH2F * fhEtaPhiTriggerEMCALBCExotic            ;  //! Pseudorapidity vs Phi of trigger exotic clusters
+  TH2F * fhTimeTriggerEMCALBCExotic              ;  //! Time distribution of clusters, when trigger exotic cluster 
+  TH2F * fhEtaPhiTriggerEMCALBCUMExotic          ;  //! Pseudorapidity vs Phi of highest E exotic cluster  in event, not matched to trigger
+  TH2F * fhTimeTriggerEMCALBCUMExotic            ;  //! Time distribution of highest energy exotic cluster in event, not matched to trigger
+
+  TH2F * fhEtaPhiTriggerEMCALBCBad               ;  //! Pseudorapidity vs Phi of trigger exotic clusters
+  TH2F * fhTimeTriggerEMCALBCBad                 ;  //! Time distribution of clusters, when trigger exotic 
+  TH2F * fhEtaPhiTriggerEMCALBCUMBad             ;  //! Pseudorapidity vs Phi of highest E exotic cluster  in event, not matched to trigger
+  TH2F * fhTimeTriggerEMCALBCUMBad               ;  //! Time distribution of highest energy exotic cluster in event, not matched to trigger
+  
+  TH2F * fhEtaPhiTriggerEMCALBCBadExotic         ;  //! Pseudorapidity vs Phi of trigger exotic and bad clusters
+  TH2F * fhTimeTriggerEMCALBCBadExotic           ;  //! Time distribution of clusters, when trigger exotic and bad cluster 
+  TH2F * fhEtaPhiTriggerEMCALBCUMBadExotic       ;  //! Pseudorapidity vs Phi of highest E exotic cluster  in event, not matched to trigger
+  TH2F * fhTimeTriggerEMCALBCUMBadExotic         ;  //! Time distribution of highest energy exotic cluster in event, not matched to trigger
+  
+  TH2F * fhEtaPhiTriggerEMCALBCExoticCluster     ;  //! Pseudorapidity vs Phi of trigger exotic clusters
+  TH2F * fhTimeTriggerEMCALBCExoticCluster       ;  //! Time distribution of clusters, when trigger exotic cluster 
+  TH2F * fhEtaPhiTriggerEMCALBCUMExoticCluster   ;  //! Pseudorapidity vs Phi of highest E exotic cluster  in event, not matched to trigger
+  TH2F * fhTimeTriggerEMCALBCUMExoticCluster     ;  //! Time distribution of highest energy exotic cluster in event, not matched to trigger
+  
+  TH2F * fhEtaPhiTriggerEMCALBCBadCluster        ;  //! Pseudorapidity vs Phi of trigger bad clusters
+  TH2F * fhTimeTriggerEMCALBCBadCluster          ;  //! Time distribution of clusters, when trigger bad cluster is in a given BC
+  TH2F * fhEtaPhiTriggerEMCALBCUMBadCluster      ;  //! Pseudorapidity vs Phi of highest E bad cluster  in event, not matched to trigger
+  TH2F * fhTimeTriggerEMCALBCUMBadCluster        ;  //! Time distribution of highest energy bad cluster in event, when trigger is in a given BC, not
+
+  TH2F * fhEtaPhiTriggerEMCALBCBadExoticCluster  ;  //! Pseudorapidity vs Phi of trigger exotic and bad clusters
+  TH2F * fhTimeTriggerEMCALBCBadExoticCluster    ;  //! Time distribution of clusters, when trigger exotic and bad cluster 
+  TH2F * fhEtaPhiTriggerEMCALBCUMBadExoticCluster;  //! Pseudorapidity vs Phi of highest E exotic and bad cluster in event, not matched to trigger
+  TH2F * fhTimeTriggerEMCALBCUMBadExoticCluster  ;  //! Time distribution of highest energy exotic and bad cluster in event, not matched to trigger
+  
+  TH2F * fhTimeTriggerEMCALBCBadMaxCell          ;  //! Time distribution of trigger clusters, when trigger bad max cell
+  TH2F * fhTimeTriggerEMCALBCUMBadMaxCell        ;  //! Time distribution of highest energy bad max cell cluster in event, when trigger is not found
+  TH2F * fhTimeTriggerEMCALBCBadMaxCellExotic    ;  //! Time distribution of trigger clusters, when trigger exotic cluster with bad max cell
+  TH2F * fhTimeTriggerEMCALBCUMBadMaxCellExotic  ;  //! Time distribution of highest energy exotic with bad max cell cluster in event, when trigger is not found
+  
+  TH2F * fhEtaPhiTriggerEMCALBCUMReMatchOpenTimeCluster ;  //! Pseudorapidity vs Phi of highest E bad cluster  in event, not matched to trigger, rematched open time trigger
+  TH2F * fhTimeTriggerEMCALBCUMReMatchOpenTimeCluster   ;  //! Time distribution of highest energy bad max cell cluster in event, when trigger is not found, rematched open time trigger
+  TH2F * fhEtaPhiTriggerEMCALBCUMReMatchCheckNeighCluster; //! Pseudorapidity vs Phi of highest E bad cluster  in event, not matched to trigger, rematched with neigbour patchs
+  TH2F * fhTimeTriggerEMCALBCUMReMatchCheckNeighCluster ;  //! Time distribution of highest energy bad max cell cluster in event, when trigger is not found, rematched with neigbour patchs
+  TH2F * fhEtaPhiTriggerEMCALBCUMReMatchBothCluster;//! Pseudorapidity vs Phi of highest E bad cluster  in event, not matched to trigger, rematched open both
+  TH2F * fhTimeTriggerEMCALBCUMReMatchBothCluster ; //! Time distribution of highest energy bad max cell cluster in event, when trigger is not found, rematched open both
+  
+  TH2F * fhTimeTriggerEMCALBC0UMReMatchOpenTime   ; //! Time distribution of clusters, not matched to trigger, rematched open time trigger
+  TH2F * fhTimeTriggerEMCALBC0UMReMatchCheckNeigh ; //! Time distribution of clusters, not matched to trigger, rematched with neighbour patchs
+  TH2F * fhTimeTriggerEMCALBC0UMReMatchBoth       ; //! Time distribution of clusters, not matched to trigger, rematched open both
+  
+  TH2F * fhEtaPhiNoTrigger ;                        //! Pseudorapidity vs Phi of highest E exotic cluster  in event, no trigger at all
+  TH2F * fhTimeNoTrigger   ;                        //! Time distribution of highest energy exotic cluster in event, no trigger at all
+  
+  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
+  TH2F * fhEtaPhoton  ;                             //! Pseudorapidity of identified  photon vs transerse momentum
+  TH2F * fhEtaPhiPhoton  ;                          //! Pseudorapidity vs Phi of identified  photon for E > 0.5
+  TH2F * fhEtaPhi05Photon  ;                        //! Pseudorapidity vs Phi of identified  photon for E < 0.5
+  TH2F * fhEtaPhiPhotonEMCALBC0  ;                  //! Pseudorapidity vs Phi of identified  photon for E > 0.5
+  TH2F * fhEtaPhiPhotonEMCALBC1  ;                  //! Pseudorapidity vs Phi of identified  photon for E > 0.5
+  TH2F * fhEtaPhiPhotonEMCALBCN  ;                  //! Pseudorapidity vs Phi of identified  photon for E > 0.5
+  TH2F * fhEtaPhiPhotonTriggerEMCALBC[11];          //! Pseudorapidity vs Phi of photons for E > 0.5
+  TH2F * fhTimePhotonTriggerEMCALBC  [11];          //! Time distribution of photons, when trigger is in a given BC
+  TH2F * fhTimePhotonTriggerEMCALBCPileUpSPD[11] ;  //! Time distribution of photons, when trigger is in a given BC, tagged as pile-up SPD
+  TH2F * fhEtaPhiPhotonTriggerEMCALBCUM[11];        //! Pseudorapidity vs Phi of photons for E > 2, not matched to trigger
+  TH2F * fhTimePhotonTriggerEMCALBCUM  [11];        //! Time distribution of photons, when trigger is in a given BC, not matched to trigger
+
+  TH2F * fhTimePhotonTriggerEMCALBC0UMReMatchOpenTime   ;  //! Time distribution of photons in event, when trigger is not found, rematched open time trigger
+  TH2F * fhTimePhotonTriggerEMCALBC0UMReMatchCheckNeigh ;  //! Time distribution of photons in event, when trigger is not found, rematched with neigbour patchs
+  TH2F * fhTimePhotonTriggerEMCALBC0UMReMatchBoth       ;  //! Time distribution of photons in event, when trigger is not found, rematched open both
+
+  TH2F * fhPtCentralityPhoton    ;                  //! centrality  vs photon pT
+  TH2F * fhPtEventPlanePhoton    ;                  //! event plane vs photon pT
   
   //Shower shape
-  TH2F * fhNLocMax;                       //! number of maxima in selected clusters
-
-  TH2F * fhDispE;                         //! cluster dispersion vs E
-  TH2F * fhLam0E;                         //! cluster lambda0 vs  E
-  TH2F * fhLam1E;                         //! cluster lambda1 vs  E  
-
-  TH2F * fhDispETRD;                      //! cluster dispersion vs E, SM covered by TRD
-  TH2F * fhLam0ETRD;                      //! cluster lambda0 vs  E, SM covered by TRD
-  TH2F * fhLam1ETRD;                      //! cluster lambda1 vs  E, SM covered by TRD 
-
-  TH2F * fhDispETM;                       //! cluster dispersion vs E, cut on Track Matching residual
-  TH2F * fhLam0ETM;                       //! cluster lambda0 vs  E, cut on Track Matching residual
-  TH2F * fhLam1ETM;                       //! cluster lambda1 vs  E, cut on Track Matching residual  
-  
-  TH2F * fhDispETMTRD;                    //! cluster dispersion vs E, SM covered by TRD, cut on Track Matching residual
-  TH2F * fhLam0ETMTRD;                    //! cluster lambda0 vs  E, SM covered by TRD, cut on Track Matching residual
-  TH2F * fhLam1ETMTRD;                    //! cluster lambda1 vs  E, SM covered by TRD, cut on Track Matching residual 
-  
-  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 * fhEtaLam0LowE;                   //! cluster eta vs lambda0, E<2
-  TH2F * fhPhiLam0LowE;                   //! cluster phi vs lambda0, E<2
-  TH2F * fhEtaLam0HighE;                  //! cluster eta vs lambda0, E>2
-  TH2F * fhPhiLam0HighE;                  //! cluster phi vs lambda0, E>2
-  TH2F * fhLam0DispLowE;                  //! cluster lambda0 vs dispersion, E<2
-  TH2F * fhLam0DispHighE;                 //! cluster lambda0 vs dispersion, E>2
-  TH2F * fhLam1Lam0LowE;                  //! cluster lambda1 vs lambda0, E<2
-  TH2F * fhLam1Lam0HighE;                 //! cluster lambda1 vs lambda0, E>2
-  TH2F * fhDispLam1LowE;                  //! cluster disp vs lambda1, E<2
-  TH2F * fhDispLam1HighE;                 //! cluster disp vs lambda1, E>2
+  TH2F * fhNLocMax;                                 //! number of maxima in selected clusters
+
+  TH2F * fhDispE;                                   //! cluster dispersion vs E
+  TH2F * fhLam0E;                                   //! cluster lambda0 vs  E
+  TH2F * fhLam1E;                                   //! cluster lambda1 vs  E
+
+  TH2F * fhDispETRD;                                //! cluster dispersion vs E, SM covered by TRD
+  TH2F * fhLam0ETRD;                                //! cluster lambda0 vs  E, SM covered by TRD
+  TH2F * fhLam1ETRD;                                //! cluster lambda1 vs  E, SM covered by TRD
+
+  TH2F * fhDispETM;                                 //! cluster dispersion vs E, cut on Track Matching residual
+  TH2F * fhLam0ETM;                                 //! cluster lambda0 vs  E, cut on Track Matching residual
+  TH2F * fhLam1ETM;                                 //! cluster lambda1 vs  E, cut on Track Matching residual
+  
+  TH2F * fhDispETMTRD;                              //! cluster dispersion vs E, SM covered by TRD, cut on Track Matching residual
+  TH2F * fhLam0ETMTRD;                              //! cluster lambda0 vs  E, SM covered by TRD, cut on Track Matching residual
+  TH2F * fhLam1ETMTRD;                              //! cluster lambda1 vs  E, SM covered by TRD, cut on Track Matching residual
+  
+  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 * fhEtaLam0LowE;                             //! cluster eta vs lambda0, E<2
+  TH2F * fhPhiLam0LowE;                             //! cluster phi vs lambda0, E<2
+  TH2F * fhEtaLam0HighE;                            //! cluster eta vs lambda0, E>2
+  TH2F * fhPhiLam0HighE;                            //! cluster phi vs lambda0, E>2
+  TH2F * fhLam0DispLowE;                            //! cluster lambda0 vs dispersion, E<2
+  TH2F * fhLam0DispHighE;                           //! cluster lambda0 vs dispersion, E>2
+  TH2F * fhLam1Lam0LowE;                            //! cluster lambda1 vs lambda0, E<2
+  TH2F * fhLam1Lam0HighE;                           //! cluster lambda1 vs lambda0, E>2
+  TH2F * fhDispLam1LowE;                            //! cluster disp vs lambda1, E<2
+  TH2F * fhDispLam1HighE;                           //! cluster disp vs lambda1, E>2
     
-  TH2F * fhDispEtaE ;                     //! shower dispersion in eta direction
-  TH2F * fhDispPhiE ;                     //! shower dispersion in phi direction
-  TH2F * fhSumEtaE ;                      //! shower dispersion in eta direction
-  TH2F * fhSumPhiE ;                      //! shower dispersion in phi direction
-  TH2F * fhSumEtaPhiE ;                   //! shower dispersion in eta and phi direction
-  TH2F * fhDispEtaPhiDiffE ;              //! shower dispersion eta - phi
-  TH2F * fhSphericityE ;                  //! shower sphericity in eta vs phi
-  TH2F * fhDispSumEtaDiffE ;              //! difference of 2 eta dispersions
-  TH2F * fhDispSumPhiDiffE ;              //! difference of 2 phi dispersions
-  TH2F * fhDispEtaDispPhi[7] ;            //! shower dispersion in eta direction vs phi direction for 5 E bins [0-2],[2-4],[4-6],[6-10],[> 10]
-  TH2F * fhLambda0DispEta[7] ;            //! shower shape correlation l0 vs disp eta
-  TH2F * fhLambda0DispPhi[7] ;            //! shower shape correlation l0 vs disp phi
+  TH2F * fhDispEtaE ;                               //! shower dispersion in eta direction
+  TH2F * fhDispPhiE ;                               //! shower dispersion in phi direction
+  TH2F * fhSumEtaE ;                                //! shower dispersion in eta direction
+  TH2F * fhSumPhiE ;                                //! shower dispersion in phi direction
+  TH2F * fhSumEtaPhiE ;                             //! shower dispersion in eta and phi direction
+  TH2F * fhDispEtaPhiDiffE ;                        //! shower dispersion eta - phi
+  TH2F * fhSphericityE ;                            //! shower sphericity in eta vs phi
+  TH2F * fhDispSumEtaDiffE ;                        //! difference of 2 eta dispersions
+  TH2F * fhDispSumPhiDiffE ;                        //! difference of 2 phi dispersions
+  TH2F * fhDispEtaDispPhi[7] ;                      //! shower dispersion in eta direction vs phi direction for 5 E bins [0-2],[2-4],[4-6],[6-10],[> 10]
+  TH2F * fhLambda0DispEta[7] ;                      //! shower shape correlation l0 vs disp eta
+  TH2F * fhLambda0DispPhi[7] ;                      //! shower shape correlation l0 vs disp phi
   
   //Fill MC dependent histograms, Origin of this cluster is ...
 
-  TH2F * fhMCDeltaE[14]  ;                      //! MC-Reco E distribution coming from MC particle     
-  TH2F * fhMCDeltaPt[14] ;                      //! MC-Reco pT distribution coming from MC particle
-  TH2F * fhMC2E[14]  ;                          //! E distribution, Reco vs MC coming from MC particle
-  TH2F * fhMC2Pt[14] ;                          //! pT distribution, Reco vs MC coming from MC particle
+  TH2F * fhMCDeltaE[14]  ;                          //! MC-Reco E distribution coming from MC particle
+  TH2F * fhMCDeltaPt[14] ;                          //! MC-Reco pT distribution coming from MC particle
+  TH2F * fhMC2E[14]  ;                              //! E distribution, Reco vs MC coming from MC particle
+  TH2F * fhMC2Pt[14] ;                              //! pT distribution, Reco vs MC coming from MC particle
   
-  TH1F * fhMCE[14];                             //! Number of identified photon vs cluster energy coming from MC particle
-  TH1F * fhMCPt[14];                            //! Number of identified photon vs cluster pT     coming from MC particle
-  TH2F * fhMCPhi[14];                           //! Phi of identified photon coming from MC particle
-  TH2F * fhMCEta[14];                           //! eta of identified photon coming from MC particle
+  TH1F * fhMCE[14];                                 //! Number of identified photon vs cluster energy coming from MC particle
+  TH1F * fhMCPt[14];                                //! Number of identified photon vs cluster pT     coming from MC particle
+  TH2F * fhMCPhi[14];                               //! Phi of identified photon coming from MC particle
+  TH2F * fhMCEta[14];                               //! eta of identified photon coming from MC particle
 
-  TH1F * fhEPrimMC[7];                          //! Number of generated photon vs energy
-  TH1F * fhPtPrimMC[7];                         //! Number of generated photon vs pT   
-  TH2F * fhPhiPrimMC[7];                        //! Phi of generted photon
-  TH2F * fhYPrimMC[7];                          //! Rapidity of generated photon 
+  TH1F * fhEPrimMC[7];                              //! Number of generated photon vs energy
+  TH1F * fhPtPrimMC[7];                             //! Number of generated photon vs pT
+  TH2F * fhPhiPrimMC[7];                            //! Phi of generted photon
+  TH2F * fhYPrimMC[7];                              //! Rapidity of generated photon
   
-  TH1F * fhEPrimMCAcc[7];                       //! Number of generated photon vs energy, in calorimeter acceptance
-  TH1F * fhPtPrimMCAcc[7];                      //! Number of generated photon vs pT, in calorimeter acceptance   
-  TH2F * fhPhiPrimMCAcc[7];                     //! Phi of generted photon, in calorimeter acceptance
-  TH2F * fhYPrimMCAcc[7];                       //! Rapidity of generated photon, in calorimeter acceptance   
+  TH1F * fhEPrimMCAcc[7];                           //! Number of generated photon vs energy, in calorimeter acceptance
+  TH1F * fhPtPrimMCAcc[7];                          //! Number of generated photon vs pT, in calorimeter acceptance
+  TH2F * fhPhiPrimMCAcc[7];                         //! Phi of generted photon, in calorimeter acceptance
+  TH2F * fhYPrimMCAcc[7];                           //! Rapidity of generated photon, in calorimeter acceptance
   
   // Shower Shape MC
 
-  TH2F * fhMCELambda0[6] ;                      //! E vs Lambda0     from MC particle
-  TH2F * fhMCELambda1[6] ;                      //! E vs Lambda1     from MC particle
-  TH2F * fhMCEDispersion[6] ;                   //! E vs Dispersion  from MC particle
-  
-  TH2F * fhMCPhotonELambda0NoOverlap ;          //! E vs Lambda0     from MC photons, no overlap
-  TH2F * fhMCPhotonELambda0TwoOverlap ;         //! E vs Lambda0     from MC photons, 2 particles overlap
-  TH2F * fhMCPhotonELambda0NOverlap ;           //! E vs Lambda0     from MC photons, N particles overlap
-  
-  TH2F * fhMCLambda0vsClusterMaxCellDiffE0[6];  //! Lambda0 vs fraction of energy of max cell for E < 2 GeV
-  TH2F * fhMCLambda0vsClusterMaxCellDiffE2[6];  //! Lambda0 vs fraction of energy of max cell for 2< E < 6 GeV
-  TH2F * fhMCLambda0vsClusterMaxCellDiffE6[6];  //! Lambda0 vs fraction of energy of max cell for E > 6 GeV
-  TH2F * fhMCNCellsvsClusterMaxCellDiffE0[6];   //! NCells  vs fraction of energy of max cell for E < 2
-  TH2F * fhMCNCellsvsClusterMaxCellDiffE2[6];   //! NCells  vs fraction of energy of max cell for 2 < E < 6 GeV
-  TH2F * fhMCNCellsvsClusterMaxCellDiffE6[6];   //! NCells  vs fraction of energy of max cell for E > 6
-  TH2F * fhMCNCellsE[6];                        //! NCells per cluster vs energy
-  TH2F * fhMCMaxCellDiffClusterE[6];            //! Fraction of energy carried by cell with maximum energy
-
-  TH2F * fhMCEDispEta[6] ;                      //! shower dispersion in eta direction
-  TH2F * fhMCEDispPhi[6] ;                      //! shower dispersion in phi direction
-  TH2F * fhMCESumEtaPhi[6] ;                    //! shower dispersion in eta vs phi direction
-  TH2F * fhMCEDispEtaPhiDiff[6] ;               //! shower dispersion in eta -phi direction
-  TH2F * fhMCESphericity[6] ;                   //! shower sphericity, eta vs phi
-  TH2F * fhMCDispEtaDispPhi[7][6] ;             //! shower dispersion in eta direction vs phi direction for 5 E bins [0-2],[2-4],[4-6],[6-10],[> 10]
-  TH2F * fhMCLambda0DispEta[7][6] ;             //! shower shape correlation l0 vs disp eta
-  TH2F * fhMCLambda0DispPhi[7][6] ;             //! shower shape correlation l0 vs disp phi
+  TH2F * fhMCELambda0[6] ;                          //! E vs Lambda0     from MC particle
+  TH2F * fhMCELambda1[6] ;                          //! E vs Lambda1     from MC particle
+  TH2F * fhMCEDispersion[6] ;                       //! E vs Dispersion  from MC particle
+  
+  TH2F * fhMCPhotonELambda0NoOverlap ;              //! E vs Lambda0     from MC photons, no overlap
+  TH2F * fhMCPhotonELambda0TwoOverlap ;             //! E vs Lambda0     from MC photons, 2 particles overlap
+  TH2F * fhMCPhotonELambda0NOverlap ;               //! E vs Lambda0     from MC photons, N particles overlap
+  
+  TH2F * fhMCLambda0vsClusterMaxCellDiffE0[6];      //! Lambda0 vs fraction of energy of max cell for E < 2 GeV
+  TH2F * fhMCLambda0vsClusterMaxCellDiffE2[6];      //! Lambda0 vs fraction of energy of max cell for 2< E < 6 GeV
+  TH2F * fhMCLambda0vsClusterMaxCellDiffE6[6];      //! Lambda0 vs fraction of energy of max cell for E > 6 GeV
+  TH2F * fhMCNCellsvsClusterMaxCellDiffE0[6];       //! NCells  vs fraction of energy of max cell for E < 2
+  TH2F * fhMCNCellsvsClusterMaxCellDiffE2[6];       //! NCells  vs fraction of energy of max cell for 2 < E < 6 GeV
+  TH2F * fhMCNCellsvsClusterMaxCellDiffE6[6];       //! NCells  vs fraction of energy of max cell for E > 6
+  TH2F * fhMCNCellsE[6];                            //! NCells per cluster vs energy
+  TH2F * fhMCMaxCellDiffClusterE[6];                //! Fraction of energy carried by cell with maximum energy
+
+  TH2F * fhMCEDispEta[6] ;                          //! shower dispersion in eta direction
+  TH2F * fhMCEDispPhi[6] ;                          //! shower dispersion in phi direction
+  TH2F * fhMCESumEtaPhi[6] ;                        //! shower dispersion in eta vs phi direction
+  TH2F * fhMCEDispEtaPhiDiff[6] ;                   //! shower dispersion in eta -phi direction
+  TH2F * fhMCESphericity[6] ;                       //! shower sphericity, eta vs phi
+  TH2F * fhMCDispEtaDispPhi[7][6] ;                 //! shower dispersion in eta direction vs phi direction for 5 E bins [0-2],[2-4],[4-6],[6-10],[> 10]
+  TH2F * fhMCLambda0DispEta[7][6] ;                 //! shower shape correlation l0 vs disp eta
+  TH2F * fhMCLambda0DispPhi[7][6] ;                 //! shower shape correlation l0 vs disp phi
 
   //Embedding
-  TH2F * fhEmbeddedSignalFractionEnergy ;       //! Fraction of photon energy of embedded signal vs cluster energy
+  TH2F * fhEmbeddedSignalFractionEnergy ;           //! Fraction of photon energy of embedded signal vs cluster energy
   
-  TH2F * fhEmbedPhotonELambda0FullSignal ;      //!  Lambda0 vs E for embedded photons with more than 90% of the cluster energy
-  TH2F * fhEmbedPhotonELambda0MostlySignal ;    //!  Lambda0 vs E for embedded photons with 90%<fraction<50% 
-  TH2F * fhEmbedPhotonELambda0MostlyBkg ;       //!  Lambda0 vs E for embedded photons with 50%<fraction<10% 
-  TH2F * fhEmbedPhotonELambda0FullBkg ;         //!  Lambda0 vs E for embedded photons with less than 10% of the cluster energy
+  TH2F * fhEmbedPhotonELambda0FullSignal ;          //!  Lambda0 vs E for embedded photons with more than 90% of the cluster energy
+  TH2F * fhEmbedPhotonELambda0MostlySignal ;        //!  Lambda0 vs E for embedded photons with 90%<fraction<50%
+  TH2F * fhEmbedPhotonELambda0MostlyBkg ;           //!  Lambda0 vs E for embedded photons with 50%<fraction<10%
+  TH2F * fhEmbedPhotonELambda0FullBkg ;             //!  Lambda0 vs E for embedded photons with less than 10% of the cluster energy
   
-  TH2F * fhEmbedPi0ELambda0FullSignal ;         //!  Lambda0 vs E for embedded photons with more than 90% of the cluster energy
-  TH2F * fhEmbedPi0ELambda0MostlySignal ;       //!  Lambda0 vs E for embedded photons with 90%<fraction<50% 
-  TH2F * fhEmbedPi0ELambda0MostlyBkg ;          //!  Lambda0 vs E for embedded photons with 50%<fraction<10% 
-  TH2F * fhEmbedPi0ELambda0FullBkg ;            //!  Lambda0 vs E for embedded photons with less than 10% of the cluster energy
+  TH2F * fhEmbedPi0ELambda0FullSignal ;             //!  Lambda0 vs E for embedded photons with more than 90% of the cluster energy
+  TH2F * fhEmbedPi0ELambda0MostlySignal ;           //!  Lambda0 vs E for embedded photons with 90%<fraction<50%
+  TH2F * fhEmbedPi0ELambda0MostlyBkg ;              //!  Lambda0 vs E for embedded photons with 50%<fraction<10%
+  TH2F * fhEmbedPi0ELambda0FullBkg ;                //!  Lambda0 vs E for embedded photons with less than 10% of the cluster energy
   
   // Track Matching
-  TH2F * fhTrackMatchedDEta[2]           ;      //! Eta distance between track and cluster vs cluster E, after and before photon cuts
-  TH2F * fhTrackMatchedDPhi[2]           ;      //! Phi distance between track and cluster vs cluster E, after and before photon cuts
-  TH2F * fhTrackMatchedDEtaDPhi[2]       ;      //! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before
+  TH2F * fhTrackMatchedDEta[2]           ;          //! Eta distance between track and cluster vs cluster E, after and before photon cuts
+  TH2F * fhTrackMatchedDPhi[2]           ;          //! Phi distance between track and cluster vs cluster E, after and before photon cuts
+  TH2F * fhTrackMatchedDEtaDPhi[2]       ;          //! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before
   
-  TH2F * fhTrackMatchedDEtaPos[2]        ;      //! Eta distance between track and cluster vs cluster E, after and before photon cuts
-  TH2F * fhTrackMatchedDPhiPos[2]        ;      //! Phi distance between track and cluster vs cluster E, after and before photon cuts
-  TH2F * fhTrackMatchedDEtaDPhiPos[2]    ;      //! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before
+  TH2F * fhTrackMatchedDEtaPos[2]        ;          //! Eta distance between track and cluster vs cluster E, after and before photon cuts
+  TH2F * fhTrackMatchedDPhiPos[2]        ;          //! Phi distance between track and cluster vs cluster E, after and before photon cuts
+  TH2F * fhTrackMatchedDEtaDPhiPos[2]    ;          //! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before
   
-  TH2F * fhTrackMatchedDEtaNeg[2]        ;      //! Eta distance between track and cluster vs cluster E, after and before photon cuts
-  TH2F * fhTrackMatchedDPhiNeg[2]        ;      //! Phi distance between track and cluster vs cluster E, after and before photon cuts
-  TH2F * fhTrackMatchedDEtaDPhiNeg[2]    ;      //! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before photon cuts
+  TH2F * fhTrackMatchedDEtaNeg[2]        ;          //! Eta distance between track and cluster vs cluster E, after and before photon cuts
+  TH2F * fhTrackMatchedDPhiNeg[2]        ;          //! Phi distance between track and cluster vs cluster E, after and before photon cuts
+  TH2F * fhTrackMatchedDEtaDPhiNeg[2]    ;          //! Eta vs Phi distance between track and cluster, E cluster > 0.5 GeV, after and before photon cuts
   
-  TH2F * fhTrackMatchedDEtaTRD[2]        ;      //! Eta distance between track and cluster vs cluster E, after and before photon cuts, behind TRD
-  TH2F * fhTrackMatchedDPhiTRD[2]        ;      //! Phi distance between track and cluster vs cluster E, after and before photon cuts, behind TRD
+  TH2F * fhTrackMatchedDEtaTRD[2]        ;          //! Eta distance between track and cluster vs cluster E, after and before photon cuts, behind TRD
+  TH2F * fhTrackMatchedDPhiTRD[2]        ;          //! Phi distance between track and cluster vs cluster E, after and before photon cuts, behind TRD
   
-  TH2F * fhTrackMatchedDEtaMCOverlap[2]  ;      //! Eta distance between track and cluster vs cluster E, several particle overlap, after and before photon cuts 
-  TH2F * fhTrackMatchedDPhiMCOverlap[2]  ;      //! Phi distance between track and cluster vs cluster E, several particle overlap, after and before photon cuts 
-  TH2F * fhTrackMatchedDEtaMCNoOverlap[2];      //! Eta distance between track and cluster vs cluster E, not other particle overlap, after and before photon cuts 
-  TH2F * fhTrackMatchedDPhiMCNoOverlap[2];      //! Phi distance between track and cluster vs cluster E, not other particle overlap, after and before photon cuts 
-  TH2F * fhTrackMatchedDEtaMCConversion[2];     //! Eta distance between track and cluster vs cluster E, originated in conversion, after and before photon cuts 
-  TH2F * fhTrackMatchedDPhiMCConversion[2];     //! Phi distance between track and cluster vs cluster E, originated in conversion, after and before photon cuts 
+  TH2F * fhTrackMatchedDEtaMCOverlap[2]  ;          //! Eta distance between track and cluster vs cluster E, several particle overlap, after and before photon cuts 
+  TH2F * fhTrackMatchedDPhiMCOverlap[2]  ;          //! Phi distance between track and cluster vs cluster E, several particle overlap, after and before photon cuts
+  TH2F * fhTrackMatchedDEtaMCNoOverlap[2];          //! Eta distance between track and cluster vs cluster E, not other particle overlap, after and before photon cuts
+  TH2F * fhTrackMatchedDPhiMCNoOverlap[2];          //! Phi distance between track and cluster vs cluster E, not other particle overlap, after and before photon cuts
+  TH2F * fhTrackMatchedDEtaMCConversion[2];         //! Eta distance between track and cluster vs cluster E, originated in conversion, after and before photon cuts 
+  TH2F * fhTrackMatchedDPhiMCConversion[2];         //! Phi distance between track and cluster vs cluster E, originated in conversion, after and before photon cuts 
   
-  TH2F * fhTrackMatchedMCParticle[2];           //! Trace origin of matched particle
-  TH2F * fhdEdx[2];                             //! matched track dEdx vs cluster E, after and before photon cuts 
-  TH2F * fhEOverP[2];                           //! matched track E cluster over P track vs cluster E, after dEdx cut, after and before photon cuts 
-  TH2F * fhEOverPTRD[2];                        //! matched track E cluster over P track vs cluster E, after dEdx cut, after and before photon cuts, behind TRD 
+  TH2F * fhTrackMatchedMCParticle[2];               //! Trace origin of matched particle
+  TH2F * fhdEdx[2];                                 //! matched track dEdx vs cluster E, after and before photon cuts
+  TH2F * fhEOverP[2];                               //! matched track E cluster over P track vs cluster E, after dEdx cut, after and before photon cuts
+  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 * fhClusterEFracLongTimePileUp[7];       //! E vs fraction of cluster energy from cells with large time
-  TH2F * fhTimePtNoCut;                         //! time of cluster vs Pt, no cut
-  TH2F * fhTimePtSPD;                           //! time of cluster vs Pt, IsSPDPileUp
-  TH2F * fhTimePtPhotonNoCut;                   //! time of photon cluster vs Pt, no cut
-  TH2F * fhTimePtPhotonSPD;                     //! time of photon cluster vs Pt, IsSPDPileUp
-  TH2F * fhTimeNPileUpVertSPD;                  //! time of cluster vs n pile-up vertices from SPD
-  TH2F * fhTimeNPileUpVertTrack;                //! time of cluster vs n pile-up vertices from Tracks
-  TH2F * fhTimeNPileUpVertContributors;         //! time of cluster vs n pile-up vertex from SPD contributors
-  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 * fhClusterMultSPDPileUp[4];             //! E max cluster vs event cluster multiplicity, for tmax-tdiff cuts, pile up event
-  TH2F * fhClusterMultNoPileUp[4];              //! E max cluster vs event cluster multiplicity, for tmax-tdiff cuts, not pile up event
-  TH2F * fhEtaPhiBC0;                           //! eta/phi of clusters in BC=0
-  TH2F * fhEtaPhiBCPlus;                        //! eta/phi of clusters in BC>0
-  TH2F * fhEtaPhiBCMinus;                       //! eta/phi of clusters in BC<0
-  TH2F * fhEtaPhiBC0PileUpSPD;                  //! eta/phi of clusters in BC=0, SPD pile-up
-  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 * fhPtNPileUpSPDVtxTimeCut2;                //! cluster pt vs number of spd pile-up vertices, time cut +-75 ns
-  TH2F * fhPtNPileUpTrkVtxTimeCut2;             //! cluster pt vs number of track pile-up vertices, time cut +- 75 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
-  TH2F * fhPtPhotonNPileUpSPDVtxTimeCut2;       //! photon pt vs number of spd pile-up vertices, time cut +-75 ns
-  TH2F * fhPtPhotonNPileUpTrkVtxTimeCut2;       //! photon pt vs number of track pile-up vertices, time cut +- 75 ns
+  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 * fhClusterCellTimePileUp[7];                //! E vs Time inside cluster, before any selection, not max cell
+  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 * fhClusterEFracLongTimePileUp[7];           //! E vs fraction of cluster energy from cells with large time
+  TH2F * fhTimePtNoCut;                             //! time of cluster vs Pt, no cut
+  TH2F * fhTimePtSPD;                               //! time of cluster vs Pt, IsSPDPileUp
+  TH2F * fhTimePtPhotonNoCut;                       //! time of photon cluster vs Pt, no cut
+  TH2F * fhTimePtPhotonSPD;                         //! time of photon cluster vs Pt, IsSPDPileUp
+  TH2F * fhTimeNPileUpVertSPD;                      //! time of cluster vs n pile-up vertices from SPD
+  TH2F * fhTimeNPileUpVertTrack;                    //! time of cluster vs n pile-up vertices from Tracks
+  TH2F * fhTimeNPileUpVertContributors;             //! time of cluster vs n pile-up vertex from SPD contributors
+  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 * fhClusterMultSPDPileUp[4];                 //! E max cluster vs event cluster multiplicity, for tmax-tdiff cuts, pile up event
+  TH2F * fhClusterMultNoPileUp[4];                  //! E max cluster vs event cluster multiplicity, for tmax-tdiff cuts, not pile up event
+  TH2F * fhEtaPhiBC0;                               //! eta/phi of clusters in BC=0
+  TH2F * fhEtaPhiBCPlus;                            //! eta/phi of clusters in BC>0
+  TH2F * fhEtaPhiBCMinus;                           //! eta/phi of clusters in BC<0
+  TH2F * fhEtaPhiBC0PileUpSPD;                      //! eta/phi of clusters in BC=0, SPD pile-up
+  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 * fhPtNPileUpSPDVtxTimeCut2;                    //! cluster pt vs number of spd pile-up vertices, time cut +-75 ns
+  TH2F * fhPtNPileUpTrkVtxTimeCut2;                 //! cluster pt vs number of track pile-up vertices, time cut +- 75 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
+  TH2F * fhPtPhotonNPileUpSPDVtxTimeCut2;           //! photon pt vs number of spd pile-up vertices, time cut +-75 ns
+  TH2F * fhPtPhotonNPileUpTrkVtxTimeCut2;           //! photon pt vs number of track pile-up vertices, time cut +- 75 ns
        
   AliAnaPhoton(              const AliAnaPhoton & g) ; // cpy ctor
   AliAnaPhoton & operator = (const AliAnaPhoton & g) ; // cpy assignment
   
-  ClassDef(AliAnaPhoton,34)
+  ClassDef(AliAnaPhoton,35)
 
 } ;
  
index 61b15f6..9e46abe 100755 (executable)
@@ -62,6 +62,9 @@ fhPt(0),                       fhE(0),
 fhEEta(0),                     fhEPhi(0),
 fhPtEta(0),                    fhPtPhi(0),                   fhEtaPhi(0),
 fhEtaPhiEMCALBC0(0),           fhEtaPhiEMCALBC1(0),          fhEtaPhiEMCALBCN(0),
+fhTimeTriggerEMCALBC0UMReMatchOpenTime(0),
+fhTimeTriggerEMCALBC0UMReMatchCheckNeigh(0),
+fhTimeTriggerEMCALBC0UMReMatchBoth(0),
 fhPtCentrality(),              fhPtEventPlane(0),
 fhPtReject(0),                 fhEReject(0),
 fhEEtaReject(0),               fhEPhiReject(0),              fhEtaPhiReject(0),
@@ -104,7 +107,7 @@ fhdEdx(0),                     fhEOverP(0),                 fhEOverPNoTRD(0),
 // Number of local maxima in cluster
 fhNLocMaxE(0),                 fhNLocMaxPt(0),
 // PileUp
-fhTimeENoCut(0),                    fhTimeESPD(0),           fhTimeESPDMulti(0),
+fhTimePtNoCut(0),                    fhTimePtSPD(0),           fhTimePtSPDMulti(0),
 fhTimeNPileUpVertSPD(0),            fhTimeNPileUpVertTrack(0),
 fhTimeNPileUpVertContributors(0),
 fhTimePileUpMainVertexZDistance(0), fhTimePileUpMainVertexZDiamond(0),
@@ -168,7 +171,7 @@ fhPtNPileUpSPDVtxTimeCut2(0),       fhPtNPileUpTrkVtxTimeCut2(0)
     fhAsymmetryDispEta  [j] = 0;
     fhAsymmetryDispPhi  [j] = 0;
     
-    fhPtPi0PileUp       [j] = 0;
+    fhPtPileUp       [j] = 0;
   }
   
   for(Int_t i = 0; i < 3; i++)
@@ -207,8 +210,8 @@ fhPtNPileUpSPDVtxTimeCut2(0),       fhPtNPileUpTrkVtxTimeCut2(0)
   
 }
 
-//_________________________________________________________________________________________________
-void AliAnaPi0EbE::FillPileUpHistograms(const Float_t energy, const Float_t pt, const Float_t time)
+//_______________________________________________________________________________________________
+void AliAnaPi0EbE::FillPileUpHistograms(const Float_t pt, const Float_t time, AliVCluster * calo)
 {
   // Fill some histograms to understand pile-up
   if(!fFillPileUpHistograms) return;
@@ -216,11 +219,96 @@ void AliAnaPi0EbE::FillPileUpHistograms(const Float_t energy, const Float_t pt,
   //printf("E %f, time %f\n",energy,time);
   AliVEvent * event = GetReader()->GetInputEvent();
   
-  fhTimeENoCut->Fill(energy,time);
-  if(GetReader()->IsPileUpFromSPD())     fhTimeESPD     ->Fill(energy,time);
-  if(event->IsPileupFromSPDInMultBins()) fhTimeESPDMulti->Fill(energy,time);
+  fhTimePtNoCut->Fill(pt,time);
+  if(GetReader()->IsPileUpFromSPD())     
   
-  if(energy < 8) return; // Fill time figures for high energy clusters not too close to trigger threshold
+  if(GetReader()->IsPileUpFromSPD())             { fhPtPileUp[0]->Fill(pt); fhTimePtSPD     ->Fill(pt,time); }
+  if(GetReader()->IsPileUpFromEMCal())             fhPtPileUp[1]->Fill(pt);
+  if(GetReader()->IsPileUpFromSPDOrEMCal())        fhPtPileUp[2]->Fill(pt);
+  if(GetReader()->IsPileUpFromSPDAndEMCal())       fhPtPileUp[3]->Fill(pt);
+  if(GetReader()->IsPileUpFromSPDAndNotEMCal())    fhPtPileUp[4]->Fill(pt);
+  if(GetReader()->IsPileUpFromEMCalAndNotSPD())    fhPtPileUp[5]->Fill(pt);
+  if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtPileUp[6]->Fill(pt);
+  
+  if(event->IsPileupFromSPDInMultBins()) fhTimePtSPDMulti->Fill(pt,time);
+  
+  // cells in cluster
+  
+  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;
+    
+  //Loop on cells inside cluster, max cell must be over 100 MeV and time in BC=0
+  if(cells->GetCellAmplitude(absIdMax) > 0.1 && TMath::Abs(tmax) < 30)
+  {
+    for (Int_t ipos = 0; ipos < calo->GetNCells(); ipos++)
+    {
+      Int_t absId  = calo->GetCellsAbsId()[ipos];
+      
+      if( absId == absIdMax ) continue ;
+      
+      Double_t timecell  = cells->GetCellTime(absId);
+      Float_t  amp       = cells->GetCellAmplitude(absId);
+      Int_t    bc        = GetReader()->GetInputEvent()->GetBunchCrossNumber();
+      GetCaloUtils()->GetEMCALRecoUtils()->AcceptCalibrateCell(absId,bc,amp,timecell,cells);
+      timecell*=1e9;
+      
+      Float_t diff = (tmax-timecell);
+            
+      if( cells->GetCellAmplitude(absIdMax) < 0.05 ) continue ;
+      
+      if(GetReader()->IsPileUpFromSPD())
+      {
+        fhPtCellTimePileUp[0]->Fill(pt, timecell);
+        fhPtTimeDiffPileUp[0]->Fill(pt, diff);
+       }
+      
+      if(GetReader()->IsPileUpFromEMCal())
+      {
+        fhPtCellTimePileUp[1]->Fill(pt, timecell);
+        fhPtTimeDiffPileUp[1]->Fill(pt, diff);
+      }
+      
+      if(GetReader()->IsPileUpFromSPDOrEMCal())
+      {
+        fhPtCellTimePileUp[2]->Fill(pt, timecell);
+        fhPtTimeDiffPileUp[2]->Fill(pt, diff);
+      }
+      
+      if(GetReader()->IsPileUpFromSPDAndEMCal())
+      {
+        fhPtCellTimePileUp[3]->Fill(pt, timecell);
+        fhPtTimeDiffPileUp[3]->Fill(pt, diff);
+      }
+      
+      if(GetReader()->IsPileUpFromSPDAndNotEMCal())
+      {
+        fhPtCellTimePileUp[4]->Fill(pt, timecell);
+        fhPtTimeDiffPileUp[4]->Fill(pt, diff);
+      }
+      
+      if(GetReader()->IsPileUpFromEMCalAndNotSPD())
+      {
+        fhPtCellTimePileUp[5]->Fill(pt, timecell);
+        fhPtTimeDiffPileUp[5]->Fill(pt, diff);
+      }
+      
+      if(GetReader()->IsPileUpFromNotSPDAndNotEMCal())
+      {
+        fhPtCellTimePileUp[6]->Fill(pt, timecell);
+        fhPtTimeDiffPileUp[6]->Fill(pt, diff);
+      }
+    }//loop
+  }
+
+  if(pt < 8) return; // Fill time figures for high energy clusters not too close to trigger threshold
   
   AliESDEvent* esdEv = dynamic_cast<AliESDEvent*> (event);
   AliAODEvent* aodEv = dynamic_cast<AliAODEvent*> (event);
@@ -292,7 +380,7 @@ void AliAnaPi0EbE::FillPileUpHistograms(const Float_t energy, const Float_t pt,
     fhTimePileUpMainVertexZDistance->Fill(time,distZ);
     fhTimePileUpMainVertexZDiamond ->Fill(time,diamZ);
     
-  }// loop
+  }// vertex loop
 }
 
 
@@ -809,6 +897,29 @@ TList *  AliAnaPi0EbE::GetCreateOutputObjects()
       outputContainer->Add(fhTimeTriggerEMCALBCUM[i]);
       
     }
+    
+    fhTimeTriggerEMCALBC0UMReMatchOpenTime = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_OpenTime",
+                                                      "cluster time vs E of clusters, no match, rematch open time",
+                                                      nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimeTriggerEMCALBC0UMReMatchOpenTime->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBC0UMReMatchOpenTime->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchOpenTime);
+    
+    
+    fhTimeTriggerEMCALBC0UMReMatchCheckNeigh = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_CheckNeighbours",
+                                                        "cluster time vs E of clusters, no match, rematch with neigbour parches",
+                                                        nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimeTriggerEMCALBC0UMReMatchCheckNeigh->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBC0UMReMatchCheckNeigh->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchCheckNeigh);
+    
+    fhTimeTriggerEMCALBC0UMReMatchBoth = new TH2F("hTimeTriggerBC0_UnMatch_ReMatch_Both",
+                                                  "cluster time vs E of clusters, no match, rematch open time and neigbour",
+                                                  nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimeTriggerEMCALBC0UMReMatchBoth->SetXTitle("E (GeV)");
+    fhTimeTriggerEMCALBC0UMReMatchBoth->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimeTriggerEMCALBC0UMReMatchBoth);
+    
   }
   
   fhPtCentrality  = new TH2F("hPtCentrality","centrality vs p_{T}",nptbins,ptmin,ptmax, 100,0,100);
@@ -1821,26 +1932,41 @@ TList *  AliAnaPi0EbE::GetCreateOutputObjects()
     
     for(Int_t i = 0 ; i < 7 ; i++)
     {
-      fhPtPi0PileUp[i]  = new TH1F(Form("hPtPi0PileUp%s",pileUpName[i].Data()),
+      fhPtPileUp[i]  = new TH1F(Form("hPtPileUp%s",pileUpName[i].Data()),
                                    Form("Selected #pi^{0} (#eta) p_{T} distribution, %s Pile-Up event",pileUpName[i].Data()), nptbins,ptmin,ptmax);
-      fhPtPi0PileUp[i]->SetXTitle("p_{T} (GeV/c)");
-      outputContainer->Add(fhPtPi0PileUp[i]);
+      fhPtPileUp[i]->SetXTitle("p_{T} (GeV/c)");
+      outputContainer->Add(fhPtPileUp[i]);
+      
+      fhPtCellTimePileUp[i]  = new TH2F(Form("hPtCellTimePileUp%s",pileUpName[i].Data()),
+                                             Form("Pt vs cell time in cluster, %s Pile-Up event",pileUpName[i].Data()),
+                                             nptbins,ptmin,ptmax,ntimebins,timemin,timemax);
+      fhPtCellTimePileUp[i]->SetXTitle("p_{T} (GeV/c)");
+      fhPtCellTimePileUp[i]->SetYTitle("t_{cell} (ns)");
+      outputContainer->Add(fhPtCellTimePileUp[i]);
+      
+      fhPtTimeDiffPileUp[i]  = new TH2F(Form("hPtTimeDiffPileUp%s",pileUpName[i].Data()),
+                                             Form("Pt vs t_{max}-t_{cell} in cluster, %s Pile-Up event",pileUpName[i].Data()),
+                                             nptbins,ptmin,ptmax,200,-100,100);
+      fhPtTimeDiffPileUp[i]->SetXTitle("p_{T} (GeV/c");
+      fhPtTimeDiffPileUp[i]->SetYTitle("t_{max}-t_{cell} (ns)");
+      outputContainer->Add(fhPtTimeDiffPileUp[i]);
+
     }
     
-    fhTimeENoCut  = new TH2F ("hTimeE_NoCut","time of cluster vs E of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
-    fhTimeENoCut->SetXTitle("E (GeV)");
-    fhTimeENoCut->SetYTitle("time (ns)");
-    outputContainer->Add(fhTimeENoCut);
+    fhTimePtNoCut  = new TH2F ("hTimePt_NoCut","time of cluster vs E of clusters, no cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimePtNoCut->SetXTitle("p_{T} (GeV/c)");
+    fhTimePtNoCut->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimePtNoCut);
     
-    fhTimeESPD  = new TH2F ("hTimeE_SPD","time of cluster vs E of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
-    fhTimeESPD->SetXTitle("E (GeV)");
-    fhTimeESPD->SetYTitle("time (ns)");
-    outputContainer->Add(fhTimeESPD);
+    fhTimePtSPD  = new TH2F ("hTimePt_SPD","time of cluster vs E of clusters, SPD cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimePtSPD->SetXTitle("p_{T} (GeV/c)");
+    fhTimePtSPD->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimePtSPD);
     
-    fhTimeESPDMulti  = new TH2F ("hTimeE_SPDMulti","time of cluster vs E of clusters, SPD multi cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
-    fhTimeESPDMulti->SetXTitle("E (GeV)");
-    fhTimeESPDMulti->SetYTitle("time (ns)");
-    outputContainer->Add(fhTimeESPDMulti);
+    fhTimePtSPDMulti  = new TH2F ("hTimePt_SPDMulti","time of cluster vs E of clusters, SPD multi cut", nptbins,ptmin,ptmax, ntimebins,timemin,timemax);
+    fhTimePtSPDMulti->SetXTitle("p_{T} (GeV/c)");
+    fhTimePtSPDMulti->SetYTitle("time (ns)");
+    outputContainer->Add(fhTimePtSPDMulti);
     
     fhTimeNPileUpVertSPD  = new TH2F ("hTime_NPileUpVertSPD","time of cluster vs N pile-up SPD vertex", ntimebins,timemin,timemax,50,0,50);
     fhTimeNPileUpVertSPD->SetYTitle("# vertex ");
@@ -2251,7 +2377,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(),mom.Pt(),((cluster1->GetTOF()+cluster2->GetTOF())*1e9) /2);
+        FillPileUpHistograms(mom.Pt(),((cluster1->GetTOF()+cluster2->GetTOF())*1e9)/2,cluster1);
         
         AliAODPWG4Particle pi0 = AliAODPWG4Particle(mom);
         
@@ -2395,7 +2521,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(),mom.Pt(),cluster->GetTOF()*1e9);
+        if(cluster) FillPileUpHistograms(mom.Pt(),cluster->GetTOF()*1e9,cluster);
         
         AliAODPWG4Particle pi0 = AliAODPWG4Particle(mom);
         
@@ -2665,7 +2791,7 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
     Double_t tofcluster   = calo->GetTOF()*1e9;
     Double_t tofclusterUS = TMath::Abs(tofcluster);
     
-    FillPileUpHistograms(calo->E(),aodpi0.Pt(),tofcluster);
+    FillPileUpHistograms(aodpi0.Pt(),tofcluster,calo);
     
     Int_t id = GetReader()->GetTriggerClusterId();
     if(fFillEMCALBCHistograms && fCalorimeter=="EMCAL" && id >=0 )
@@ -2693,7 +2819,14 @@ void  AliAnaPi0EbE::MakeShowerShapeIdentification()
         {
           if(calo->E() > 2) fhEtaPhiTriggerEMCALBCUM[bc+5]->Fill(aodpi0.Eta(), phicluster);
           fhTimeTriggerEMCALBCUM[bc+5]->Fill(calo->E(), tofcluster);
-        }
+          
+          if(bc==0)
+          {
+            if(GetReader()->IsTriggerMatchedOpenCuts(0)) fhTimeTriggerEMCALBC0UMReMatchOpenTime   ->Fill(calo->E(), tofcluster);
+            if(GetReader()->IsTriggerMatchedOpenCuts(1)) fhTimeTriggerEMCALBC0UMReMatchCheckNeigh ->Fill(calo->E(), tofcluster);
+            if(GetReader()->IsTriggerMatchedOpenCuts(2)) fhTimeTriggerEMCALBC0UMReMatchBoth       ->Fill(calo->E(), tofcluster);
+          }
+         }
       }
       else if(TMath::Abs(bc) >= 6)
         printf("AliAnaPi0EbE::MakeShowerShapeIdentification() - Trigger BC not expected = %d\n",bc);
@@ -2751,18 +2884,6 @@ void  AliAnaPi0EbE::MakeAnalysisFillHistograms()
     fhPtCentrality ->Fill(pt,cen) ;
     fhPtEventPlane ->Fill(pt,ep ) ;
     
-    if(fFillPileUpHistograms)
-    {
-      if(GetReader()->IsPileUpFromSPD())               fhPtPi0PileUp[0]->Fill(pt);
-      if(GetReader()->IsPileUpFromEMCal())             fhPtPi0PileUp[1]->Fill(pt);
-      if(GetReader()->IsPileUpFromSPDOrEMCal())        fhPtPi0PileUp[2]->Fill(pt);
-      if(GetReader()->IsPileUpFromSPDAndEMCal())       fhPtPi0PileUp[3]->Fill(pt);
-      if(GetReader()->IsPileUpFromSPDAndNotEMCal())    fhPtPi0PileUp[4]->Fill(pt);
-      if(GetReader()->IsPileUpFromEMCalAndNotSPD())    fhPtPi0PileUp[5]->Fill(pt);
-      if(GetReader()->IsPileUpFromNotSPDAndNotEMCal()) fhPtPi0PileUp[6]->Fill(pt);
-    }
-    
-    
     if(IsDataMC())
     {
       Int_t tag     = pi0->GetTag();
index a32d0d6..c73af4c 100755 (executable)
@@ -46,7 +46,7 @@ class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
   
   // Main
   
-  void           FillPileUpHistograms(const Float_t energy, const Float_t pt, const Float_t time) ;
+  void           FillPileUpHistograms(const Float_t pt, const Float_t time, AliVCluster * c) ;
   
   void           FillRejectedClusterHistograms(const TLorentzVector mom, const Int_t mctag);
   
@@ -168,6 +168,10 @@ class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
   TH2F         * fhEtaPhiTriggerEMCALBCUM[11]  ;  //! Pseudorapidity vs Phi of pi0 for E > 2, not matched to trigger
   TH2F         * fhTimeTriggerEMCALBCUM[11]  ;    //! Time distribution of pi0, when trigger is in a given BC, not matched to trigger
 
+  TH2F         * fhTimeTriggerEMCALBC0UMReMatchOpenTime   ; //! Time distribution of pi0s in event, when trigger is not found, rematched open time trigger
+  TH2F         * fhTimeTriggerEMCALBC0UMReMatchCheckNeigh ; //! Time distribution of pi0s in event, when trigger is not found, rematched with neigbour patchs
+  TH2F         * fhTimeTriggerEMCALBC0UMReMatchBoth       ; //! Time distribution of pi0s in event, when trigger is not found, rematched open both
+
   TH2F         * fhPtCentrality ;          //! centrality  vs pi0/eta pT
   TH2F         * fhPtEventPlane ;          //! event plane vs pi0/eta pT
   
@@ -318,10 +322,12 @@ class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
   TH2F         * fhMassPairLocMax[8];      //! pair mass, origin is same pi0, combine clusters depending on number of maxima
 
   // Pile-up
-  TH1F         * fhPtPi0PileUp[7];                //! pT distribution of selected pi0/eta
-  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
+  TH1F         * fhPtPileUp[7];                   //! pT distribution of selected pi0/eta
+  TH2F         * fhPtCellTimePileUp[7];           //! pT vs Time inside cluster, before any selection, not max cell
+  TH2F         * fhPtTimeDiffPileUp[7];           //! pT vs Time difference inside cluster, before any selection
+  TH2F         * fhTimePtNoCut;                   //! time of cluster vs pT, no cut
+  TH2F         * fhTimePtSPD;                     //! time of cluster vs pT, IsSPDPileUp
+  TH2F         * fhTimePtSPDMulti;                //! time of cluster vs pT, IsSPDPileUpMulti
   TH2F         * fhTimeNPileUpVertSPD;            //! time of cluster vs n pile-up vertices from SPD
   TH2F         * fhTimeNPileUpVertTrack;          //! time of cluster vs n pile-up vertices from Tracks
   TH2F         * fhTimeNPileUpVertContributors;   //! time of cluster vs n pile-up vertex from SPD contributors
@@ -338,7 +344,7 @@ class AliAnaPi0EbE : public AliAnaCaloTrackCorrBaseClass {
   AliAnaPi0EbE(              const AliAnaPi0EbE & pi0ebe) ; // cpy ctor
   AliAnaPi0EbE & operator = (const AliAnaPi0EbE & pi0ebe) ; // cpy assignment
   
-  ClassDef(AliAnaPi0EbE,30)
+  ClassDef(AliAnaPi0EbE,31)
 } ;