Changes for #94138: Port update in Ali*CaloCells to trunk and release
[u/mrichter/AliRoot.git] / PWGGA / EMCALTasks / AliAnalysisTaskEMCALClusterize.cxx
index 4f12b4e..7807335 100644 (file)
 //_________________________________________________________________________
 
 // --- Root ---
-#include "TString.h"
-#include "TRefArray.h"
-#include "TClonesArray.h"
-#include "TTree.h"
-#include "TGeoManager.h"
-#include "TROOT.h"
-#include "TInterpreter.h"
-#include "TFile.h"
+#include <TString.h>
+#include <TRefArray.h>
+#include <TClonesArray.h>
+#include <TTree.h>
+#include <TGeoManager.h>
+#include <TROOT.h>
+#include <TInterpreter.h>
+#include <TFile.h>
 
 // --- AliRoot Analysis Steering
 #include "AliAnalysisTask.h"
@@ -45,9 +45,9 @@
 #include "AliLog.h"
 #include "AliVEventHandler.h"
 #include "AliAODInputHandler.h"
+#include "AliOADBContainer.h"
 
 // --- EMCAL
-#include "AliEMCALRecParam.h"
 #include "AliEMCALAfterBurnerUF.h"
 #include "AliEMCALGeometry.h"
 #include "AliEMCALClusterizerNxN.h"
@@ -57,7 +57,6 @@
 #include "AliEMCALDigit.h"
 #include "AliCaloCalibPedestal.h"
 #include "AliEMCALCalibData.h"
-#include "AliEMCALRecoUtils.h"
 
 #include "AliAnalysisTaskEMCALClusterize.h"
 
@@ -67,25 +66,27 @@ ClassImp(AliAnalysisTaskEMCALClusterize)
 AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize(const char *name) 
 : AliAnalysisTaskSE(name)
 , fEvent(0)
-, fGeom(0),               fGeomName("EMCAL_COMPLETEV1") 
+, fGeom(0),               fGeomName("") 
 , fGeomMatrixSet(kFALSE), fLoadGeomMatrices(kFALSE)
 , fCalibData(0),          fPedestalData(0)
-, fOCDBpath("raw://"),    fAccessOCDB(kFALSE)
+, fOCDBpath(""),          fAccessOCDB(kFALSE)
 , fDigitsArr(0),          fClusterArr(0),             fCaloClusterArr(0)
 , fRecParam(0),           fClusterizer(0)
 , fUnfolder(0),           fJustUnfold(kFALSE) 
-, fOutputAODBranch(0),    fOutputAODBranchName("newEMCALClusters")
+, fOutputAODBranch(0),    fOutputAODBranchName("")
 , fFillAODFile(kTRUE),    fFillAODHeader(0)
 , fFillAODCaloCells(0),   fRun(-1)
 , fRecoUtils(0),          fConfigName("")
 , fCellLabels(),          fCellSecondLabels(),        fCellTime()
 , fCellMatchdEta(),       fCellMatchdPhi()
-, fMaxEvent(1000000000),  fDoTrackMatching(kFALSE)
-, fSelectCell(kFALSE),    fSelectCellMinE(0.005),     fSelectCellMinFrac(0.001)
-, fRemoveLEDEvents(kFALSE),        fRemoveExoticEvents(kFALSE)
-, fImportGeometryFromFile(kFALSE), fImportGeometryFilePath("")
+, fMaxEvent(0),           fDoTrackMatching(kFALSE)
+, fSelectCell(kFALSE),    fSelectCellMinE(0),         fSelectCellMinFrac(0)
+, fRemoveLEDEvents(kTRUE), fRemoveExoticEvents(kFALSE)
+, fImportGeometryFromFile(kFALSE), fImportGeometryFilePath("") 
+, fOADBSet(kFALSE),       fAccessOADB(kTRUE),         fOADBFilePath("")           
 {
-  //ctor
+  // Constructor
+  
   for(Int_t i = 0; i < 12;    i++)  fGeomMatrix[i] =  0;
   for(Int_t j = 0; j < 24*48*11; j++)  
   {
@@ -96,12 +97,6 @@ AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize(const char *name)
     fCellMatchdPhi[j]    = -999;
   }  
   
-  fDigitsArr       = new TClonesArray("AliEMCALDigit",12000);
-  fClusterArr      = new TObjArray(10000);
-  fCaloClusterArr  = new TObjArray(10000);
-  fRecParam        = new AliEMCALRecParam;
-  fBranchNames     = "ESD:AliESDHeader.,EMCALCells.";
-  fRecoUtils       = new AliEMCALRecoUtils();
   
 }
 
@@ -109,25 +104,28 @@ AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize(const char *name)
 AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize() 
 : AliAnalysisTaskSE("DefaultAnalysis_AliAnalysisTaskEMCALClusterize")
 , fEvent(0)
-, fGeom(0),                 fGeomName("EMCAL_COMPLETEV1") 
+, fGeom(0),                 fGeomName("") 
 , fGeomMatrixSet(kFALSE),   fLoadGeomMatrices(kFALSE)
 , fCalibData(0),            fPedestalData(0)
-, fOCDBpath("raw://"),      fAccessOCDB(kFALSE)
+, fOCDBpath(""),            fAccessOCDB(kFALSE)
 , fDigitsArr(0),            fClusterArr(0),             fCaloClusterArr(0)
 , fRecParam(0),             fClusterizer(0)
 , fUnfolder(0),             fJustUnfold(kFALSE) 
-, fOutputAODBranch(0),      fOutputAODBranchName("newEMCALClusters")
+, fOutputAODBranch(0),      fOutputAODBranchName("")
 , fFillAODFile(kTRUE),      fFillAODHeader(0)
 , fFillAODCaloCells(0),     fRun(-1)
 , fRecoUtils(0),            fConfigName("")
 , fCellLabels(),            fCellSecondLabels(),        fCellTime()
 , fCellMatchdEta(),         fCellMatchdPhi()
-, fMaxEvent(1000000000),    fDoTrackMatching(kFALSE)
-, fSelectCell(kFALSE),      fSelectCellMinE(0.005),     fSelectCellMinFrac(0.001)
-, fRemoveLEDEvents(kFALSE), fRemoveExoticEvents(kFALSE)
+, fMaxEvent(0),             fDoTrackMatching(kFALSE)
+, fSelectCell(kFALSE),      fSelectCellMinE(0),         fSelectCellMinFrac(0)
+, fRemoveLEDEvents(kTRUE), fRemoveExoticEvents(kFALSE)
 , fImportGeometryFromFile(kFALSE), fImportGeometryFilePath("")
+, fOADBSet(kFALSE),         fAccessOADB(kTRUE),        fOADBFilePath("")           
+
 {
   // Constructor
+  
   for(Int_t i = 0; i < 12;    i++)  fGeomMatrix[i] =  0;
   for(Int_t j = 0; j < 24*48*11; j++)  
   {
@@ -137,12 +135,7 @@ AliAnalysisTaskEMCALClusterize::AliAnalysisTaskEMCALClusterize()
     fCellMatchdEta[j]    = -999;
     fCellMatchdPhi[j]    = -999;
   }
-  fDigitsArr       = new TClonesArray("AliEMCALDigit",12000);
-  fClusterArr      = new TObjArray(10000);
-  fCaloClusterArr  = new TObjArray(10000);
-  fRecParam        = new AliEMCALRecParam;
-  fBranchNames     = "ESD:AliESDHeader.,EMCALCells.";
-  fRecoUtils       = new AliEMCALRecoUtils();
+  
 }
 
 
@@ -151,17 +144,20 @@ AliAnalysisTaskEMCALClusterize::~AliAnalysisTaskEMCALClusterize()
 {
   //dtor 
   
-  if (fDigitsArr){
+  if (fDigitsArr)
+  {
     fDigitsArr->Clear("C");
     delete fDigitsArr; 
   }
   
-  if (fClusterArr){
+  if (fClusterArr)
+  {
     fClusterArr->Delete();
     delete fClusterArr;
   }
   
-  if (fCaloClusterArr){
+  if (fCaloClusterArr)
+  {
     fCaloClusterArr->Delete();
     delete fCaloClusterArr; 
   }
@@ -172,6 +168,159 @@ AliAnalysisTaskEMCALClusterize::~AliAnalysisTaskEMCALClusterize()
   
 }
 
+//_______________________________________________
+void AliAnalysisTaskEMCALClusterize::AccessOADB()
+{
+  // Set the AODB calibration, bad channels etc. parameters at least once
+  // alignment matrices from OADB done in SetGeometryMatrices
+  
+  //Set it only once
+  if(fOADBSet) return ; 
+  
+  Int_t   runnumber = InputEvent()->GetRunNumber() ;
+  TString pass      = GetPass();
+  
+  printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Get AODB parameters from EMCAL in %s for run %d, and <%s> \n",fOADBFilePath.Data(),runnumber,pass.Data());
+  
+  Int_t nSM = fGeom->GetNumberOfSuperModules();
+  
+  // Bad map
+  if(fRecoUtils->IsBadChannelsRemovalSwitchedOn())
+  {
+    AliOADBContainer *contBC=new AliOADBContainer("");
+    contBC->InitFromFile(Form("%s/EMCALBadChannels.root",fOADBFilePath.Data()),"AliEMCALBadChannels"); 
+    
+    TObjArray *arrayBC=(TObjArray*)contBC->GetObject(runnumber);
+    
+    if(arrayBC)
+    {
+      TObjArray * arrayBCpass = 0x0; 
+      if(pass!="")arrayBCpass = (TObjArray*)arrayBC->FindObject(pass);
+      // There are no passes for simulation, in order to get the bad map put pass1
+      else        arrayBCpass = (TObjArray*)arrayBC->FindObject("pass1");
+      
+      if(arrayBCpass)
+      {
+        fRecoUtils->SwitchOnDistToBadChannelRecalculation();
+        printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Remove EMCAL bad cells \n");
+        
+        for (Int_t i=0; i<nSM; ++i) 
+        {
+          TH2I *hbm = fRecoUtils->GetEMCALChannelStatusMap(i);
+          
+          if (hbm)
+            delete hbm;
+          
+          hbm=(TH2I*)arrayBCpass->FindObject(Form("EMCALBadChannelMap_Mod%d",i));
+          
+          if (!hbm) 
+          {
+            AliError(Form("Can not get EMCALBadChannelMap_Mod%d",i));
+            continue;
+          }
+          
+          hbm->SetDirectory(0);
+          fRecoUtils->SetEMCALChannelStatusMap(i,hbm);
+          
+        } // loop
+      } else printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Do NOT remove EMCAL bad channels 1\n"); // pass array
+    } else printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Do NOT remove EMCAL bad channels 2\n"); // run array
+  }  // Remove bad
+  
+  // Energy Recalibration
+  if(fRecoUtils->IsRecalibrationOn())
+  {
+    AliOADBContainer *contRF=new AliOADBContainer("");
+    
+    contRF->InitFromFile(Form("%s/EMCALRecalib.root",fOADBFilePath.Data()),"AliEMCALRecalib");
+    
+    TObjArray *recal=(TObjArray*)contRF->GetObject(runnumber); 
+    
+    if(recal)
+    {
+      TObjArray *recalpass=(TObjArray*)recal->FindObject(pass);
+      
+      if(recalpass)
+      {
+        TObjArray *recalib=(TObjArray*)recalpass->FindObject("Recalib");
+        
+        if(recalib)
+        {
+          printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Recalibrate EMCAL \n");
+          for (Int_t i=0; i<nSM; ++i) 
+          {
+            TH2F *h = fRecoUtils->GetEMCALChannelRecalibrationFactors(i);
+            
+            if (h)
+              delete h;
+            
+            h = (TH2F*)recalib->FindObject(Form("EMCALRecalFactors_SM%d",i));
+            
+            if (!h) 
+            {
+              AliError(Form("Could not load EMCALRecalFactors_SM%d",i));
+              continue;
+            }
+            
+            h->SetDirectory(0);
+            
+            fRecoUtils->SetEMCALChannelRecalibrationFactors(i,h);
+          } // SM loop
+        }else printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Do NOT recalibrate EMCAL 1\n"); // array ok
+      }else printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Do NOT recalibrate EMCAL 2\n"); // array pass ok
+    }else printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Do NOT recalibrate EMCAL 3\n");  // run number array ok
+    
+    // once set, apply run dependent corrections if requested
+    fRecoUtils->SetRunDependentCorrections(runnumber);
+    
+  } // Recalibration on
+  
+  
+  // Time Recalibration
+  if(fRecoUtils->IsTimeRecalibrationOn())
+  {
+    AliOADBContainer *contTRF=new AliOADBContainer("");
+    
+    contTRF->InitFromFile(Form("%s/EMCALTimeCalib.root",fOADBFilePath.Data()),"AliEMCALTimeCalib");
+    
+    TObjArray *trecal=(TObjArray*)contTRF->GetObject(runnumber); 
+    
+    if(trecal)
+    {
+      TObjArray *trecalpass=(TObjArray*)trecal->FindObject(pass);
+      
+      if(trecalpass)
+      {
+        printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Time Recalibrate EMCAL \n");
+        for (Int_t ibc = 0; ibc < 4; ++ibc) 
+        {
+          TH1F *h = fRecoUtils->GetEMCALChannelTimeRecalibrationFactors(ibc);
+          
+          if (h)
+            delete h;
+          
+          h = (TH1F*)trecalpass->FindObject(Form("hAllTimeAvBC%d",ibc));
+          
+          if (!h) 
+          {
+            AliError(Form("Could not load hAllTimeAvBC%d",ibc));
+            continue;
+          }
+          
+          h->SetDirectory(0);
+          
+          fRecoUtils->SetEMCALChannelTimeRecalibrationFactors(ibc,h);
+        } // bunch crossing loop
+      }else printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Do NOT recalibrate time EMCAL 1\n"); // array pass ok
+    }else printf("AliAnalysisTaskEMCALClusterize::SetOADBParameters() - Do NOT recalibrate time EMCAL 2\n");  // run number array ok
+    
+  } // Time recalibration on    
+  
+  // Parameters already set once, so do not it again
+  fOADBSet = kTRUE;
+  
+}  
+
 //_________________________________________________
 Bool_t AliAnalysisTaskEMCALClusterize::AccessOCDB()
 {
@@ -191,12 +340,11 @@ Bool_t AliAnalysisTaskEMCALClusterize::AccessOCDB()
   if(DebugLevel() > 1 )
     printf("AliAnalysisTaksEMCALClusterize::AccessODCD() - Begin");
   
-  //fGeom = AliEMCALGeometry::GetInstance(fGeomName);
-  
   AliCDBManager *cdb = AliCDBManager::Instance();
   
   
-  if (fOCDBpath.Length()){
+  if (fOCDBpath.Length())
+  {
     cdb->SetDefaultStorage(fOCDBpath.Data());
     printf("AliAnalysisTaksEMCALClusterize::AccessOCDB() - Default storage %s",fOCDBpath.Data());
   }
@@ -258,36 +406,45 @@ void AliAnalysisTaskEMCALClusterize::CheckAndGetEvent()
     return ;
   
   //printf("Clusterizer --- Event %d-- \n",eventN);
-
+  
   //Check if input event are embedded events
   //If so, take output event
-  if (aodIH && aodIH->GetMergeEvents()) {
+  if (aodIH && aodIH->GetMergeEvents()) 
+  {
     fEvent  = AODEvent();
     
     if(!aodIH->GetMergeEMCALCells()) 
       AliFatal("Events merged but not EMCAL cells, check analysis settings!");
     
-    if(DebugLevel() > 1){
-     printf("AliAnalysisTaksEMCALClusterize::UserExec() - Use embedded events\n");
-        printf("\t InputEvent  N Clusters %d, N Cells %d\n",InputEvent()->GetNumberOfCaloClusters(),
-               InputEvent()->GetEMCALCells()->GetNumberOfCells());
-        printf("\t MergedEvent  N Clusters %d, N Cells %d\n",aodIH->GetEventToMerge()->GetNumberOfCaloClusters(),
-               aodIH->GetEventToMerge()->GetEMCALCells()->GetNumberOfCells());
-        for (Int_t icl=0; icl < aodIH->GetEventToMerge()->GetNumberOfCaloClusters(); icl++) {
-            AliAODCaloCluster *sigCluster = aodIH->GetEventToMerge()->GetCaloCluster(icl);
-            if(sigCluster->IsEMCAL()) printf("\t \t Signal cluster: i %d, E  %f\n",icl,sigCluster->E());
-        }
-        printf("\t OutputEvent N Clusters %d, N Cells %d\n", AODEvent()->GetNumberOfCaloClusters(),
-               AODEvent()->GetEMCALCells()->GetNumberOfCells());
+    if(DebugLevel() > 1)
+    {
+      printf("AliAnalysisTaksEMCALClusterize::UserExec() - Use embedded events\n");
+      
+      printf("\t InputEvent  N Clusters %d, N Cells %d\n",InputEvent()->GetNumberOfCaloClusters(),
+             InputEvent()->GetEMCALCells()->GetNumberOfCells());
+      
+      printf("\t MergedEvent  N Clusters %d, N Cells %d\n",aodIH->GetEventToMerge()->GetNumberOfCaloClusters(),
+             aodIH->GetEventToMerge()->GetEMCALCells()->GetNumberOfCells());
+      
+      for (Int_t icl=0; icl < aodIH->GetEventToMerge()->GetNumberOfCaloClusters(); icl++) 
+      {
+        AliAODCaloCluster *sigCluster = aodIH->GetEventToMerge()->GetCaloCluster(icl);
+        if(sigCluster->IsEMCAL()) printf("\t \t Signal cluster: i %d, E  %f\n",icl,sigCluster->E());
+      }
+      
+      printf("\t OutputEvent N Clusters %d, N Cells %d\n", AODEvent()->GetNumberOfCaloClusters(),
+             AODEvent()->GetEMCALCells()->GetNumberOfCells());
     }
   }
-  else {
+  else 
+  {
     fEvent =  InputEvent();
     if(fFillAODCaloCells) FillAODCaloCells();   
     if(fFillAODHeader)    FillAODHeader();
   }
   
-  if (!fEvent) {
+  if (!fEvent) 
+  {
     Error("UserExec","Event not available");
     return ;
   }
@@ -297,9 +454,9 @@ void AliAnalysisTaskEMCALClusterize::CheckAndGetEvent()
   // Reject event if triggered by exotic cell and remove exotic cells if not triggered
   //-------------------------------------------------------------------------------------
   
-  if(IsLEDEvent   ()) { fEvent = 0x0 ; return ; }
+  if( IsLEDEvent( InputEvent()->GetRunNumber() ) ) { fEvent = 0x0 ; return ; }
   
-  if(IsExoticEvent()) { fEvent = 0x0 ; return ; }
+  if( IsExoticEvent() )                            { fEvent = 0x0 ; return ; }
   
   //Magic line to write events to AOD filem put after event rejection
   AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(fFillAODFile);
@@ -315,7 +472,7 @@ void AliAnalysisTaskEMCALClusterize::ClusterizeCells()
   //In case of MC, first loop on the clusters and fill MC label to array  
   Int_t nClusters     = fEvent->GetNumberOfCaloClusters();
   Int_t nClustersOrg  = 0;
-
+  
   AliAODInputHandler* aodIH = dynamic_cast<AliAODInputHandler*>((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
   if(aodIH && aodIH->GetEventToMerge())  //Embedding
     nClusters = aodIH->GetEventToMerge()->GetNumberOfCaloClusters(); //Get clusters directly from embedded signal
@@ -330,13 +487,15 @@ void AliAnalysisTaskEMCALClusterize::ClusterizeCells()
     
     if(!clus) return;
     
-    if(clus->IsEMCAL()){   
+    if(clus->IsEMCAL())
+    {   
       Int_t label = clus->GetLabel();
       Int_t label2 = -1 ;
       //printf("Org cluster E %f, Time  %e, Id = ", clus->E(), clus->GetTOF() );
       if (clus->GetNLabels()>=2) label2 = clus->GetLabelAt(1) ;
       UShort_t * index    = clus->GetCellsAbsId() ;
-      for(Int_t icell=0; icell < clus->GetNCells(); icell++ ){
+      for(Int_t icell=0; icell < clus->GetNCells(); icell++ )
+      {
         fCellLabels[index[icell]]       = label;
         fCellSecondLabels[index[icell]] = label2;
         fCellTime[index[icell]]         = clus->GetTOF();    
@@ -346,24 +505,21 @@ void AliAnalysisTaskEMCALClusterize::ClusterizeCells()
       }
       nClustersOrg++;
     }
-     // printf("\n");
+    // printf("\n");
   } 
   
   // Transform CaloCells into Digits
-
+  
   Int_t    idigit =  0;
   Int_t    id     = -1;
   Float_t  amp    = -1; 
   Double_t time   = -1; 
   
   AliVCaloCells *cells   = fEvent->GetEMCALCells();
-    
-  TTree *digitsTree = new TTree("digitstree","digitstree");
-  digitsTree->Branch("EMCAL","TClonesArray", &fDigitsArr, 32000);
+  
   Int_t bc = InputEvent()->GetBunchCrossNumber();
   for (Int_t icell = 0; icell < cells->GetNumberOfCells(); icell++)
   {
-    
     // Get cell values, recalibrate and not include bad channels found in analysis, nor cells with too low energy, nor exotic cell
     id = cells->GetCellNumber(icell);
     Bool_t accept = fRecoUtils->AcceptCalibrateCell(id,bc,amp,time,cells);
@@ -372,70 +528,66 @@ void AliAnalysisTaskEMCALClusterize::ClusterizeCells()
     if(amp < fRecParam->GetMinECut() ) accept = kFALSE;
     
     // In case of AOD analysis cell time is 0, approximate replacing by time of the cluster the digit belongs.
-    if (time*1e9 < 1.) { 
+    if (time*1e9 < 1.) 
+    { 
       time = fCellTime[id];
-      //printf("cell %d time cluster %e\n",id, time);
+      //printf("cell %d time org %f - ",id, time*1.e9);
       fRecoUtils->RecalibrateCellTime(id,bc,time);
+      //printf("recal %f\n",time*1.e9);
     }
     
-    if(  accept && fRecoUtils->IsExoticCell(id,cells,bc)){
+    if(  accept && fRecoUtils->IsExoticCell(id,cells,bc))
+    {
       accept = kFALSE;
     }
-
-    if( !accept ){
+    
+    if( !accept )
+    {
       fCellLabels[id]      =-1; //reset the entry in the array for next event
       fCellSecondLabels[id]=-1; //reset the entry in the array for next event
       fCellTime[id]        = 0.; 
       fCellMatchdEta[id]   =-999;
       fCellMatchdPhi[id]   =-999;
-      if( DebugLevel() > 2 ) printf("AliAnalysisTaksEMCALClusterize::ClusterizeCells() - Remove channel absId %d, index %d of %d, amp %f, time %f\n",
-                                    id,icell, cells->GetNumberOfCells(), amp, time*1.e9);
+      if( DebugLevel() > 2 )
+        printf("AliAnalysisTaksEMCALClusterize::ClusterizeCells() - Remove channel absId %d, index %d of %d, amp %f, time %f\n",
+               id,icell, cells->GetNumberOfCells(), amp, time*1.e9);
       continue;
     }
-            
+    
     //Create the digit, put a fake primary deposited energy to trick the clusterizer when checking the most likely primary
     new((*fDigitsArr)[idigit]) AliEMCALDigit( fCellLabels[id], fCellLabels[id],id, amp, time,AliEMCALDigit::kHG,idigit, 0, 0, 1); 
-    fCellLabels[id]      =-1; //reset the entry in the array for next event
+    
+    fCellLabels[id] =-1; //reset the entry in the array for next event
     
     idigit++;
   }
   
-  //Fill the tree with digits
-  digitsTree->Fill();
+  fDigitsArr->Sort();
   
   //-------------------------------------------------------------------------------------
   //Do the clusterization
   //-------------------------------------------------------------------------------------        
-  TTree *clustersTree = new TTree("clustertree","clustertree");
   
-  fClusterizer->SetInput(digitsTree);
-  fClusterizer->SetOutput(clustersTree);
   fClusterizer->Digits2Clusters("");
   
   //-------------------------------------------------------------------------------------
   //Transform the recpoints into AliVClusters
   //-------------------------------------------------------------------------------------
   
-  clustersTree->SetBranchStatus("*",0); //disable all branches
-  clustersTree->SetBranchStatus("EMCALECARP",1); //Enable only the branch we need
+  RecPoints2Clusters();
   
-  TBranch *branch = clustersTree->GetBranch("EMCALECARP");
-  branch->SetAddress(&fClusterArr);
-  branch->GetEntry(0);
-  
-  RecPoints2Clusters(fDigitsArr, fClusterArr, fCaloClusterArr);
-  
-  if(!fCaloClusterArr){ 
+  if(!fCaloClusterArr)
+  { 
     printf("AliAnalysisTaksEMCALClusterize::UserExec() - No array with CaloClusters, input RecPoints entries %d\n",fClusterArr->GetEntriesFast());
     return;    
   }
   
-  if( DebugLevel() > 0 ){
-    
+  if( DebugLevel() > 0 )
+  {
     printf("AliAnalysisTaksEMCALClusterize::ClusterizeCells() - N clusters: before recluster %d, after recluster %d\n",nClustersOrg, fCaloClusterArr->GetEntriesFast());
-
-    if(fCaloClusterArr->GetEntriesFast() != fClusterArr->GetEntriesFast()){
+    
+    if(fCaloClusterArr->GetEntriesFast() != fClusterArr->GetEntriesFast())
+    {
       printf("\t Some RecRoints not transformed into CaloClusters (clusterizer %d, unfold %d): Input entries %d - Output entries %d - %d (not fast)\n",
              fRecParam->GetClusterizerFlag(),fRecParam->GetUnfold(),
              fClusterArr->GetEntriesFast(), fCaloClusterArr->GetEntriesFast(), fCaloClusterArr->GetEntries());
@@ -445,14 +597,6 @@ void AliAnalysisTaskEMCALClusterize::ClusterizeCells()
   //Reset the array with second labels for this event
   memset(fCellSecondLabels, -1, sizeof(fCellSecondLabels));
   
-  //---CLEAN UP-----
-  fClusterizer->Clear();
-  fDigitsArr  ->Clear("C");
-  fClusterArr ->Delete(); // Do not Clear(), it leaks, why?
-  
-  clustersTree->Delete("all");
-  digitsTree  ->Delete("all");
-  
 }
 
 //_____________________________________________________
@@ -464,28 +608,31 @@ void AliAnalysisTaskEMCALClusterize::ClusterUnfolding()
   Double_t cellAmplitude = 0;
   Double_t cellTime      = 0;
   Short_t  cellNumber    = 0;
+  Short_t  cellMCLabel   = 0;
+  Double_t cellEFrac     = 0;
   Int_t    nClustersOrg  = 0;
   
   // Fill the array with the EMCAL clusters, copy them
   for (Int_t i = 0; i < fEvent->GetNumberOfCaloClusters(); i++)
   {
     AliVCluster *clus = fEvent->GetCaloCluster(i);
-    if(clus->IsEMCAL()){        
-      
+    if(clus->IsEMCAL())
+    {        
       //recalibrate/remove bad channels/etc if requested
-      if(fRecoUtils->ClusterContainsBadChannel(fGeom,clus->GetCellsAbsId(), clus->GetNCells())){
+      if(fRecoUtils->ClusterContainsBadChannel(fGeom,clus->GetCellsAbsId(), clus->GetNCells()))
+      {
         continue;
       } 
       
-      if(fRecoUtils->IsRecalibrationOn()){
-        
+      if(fRecoUtils->IsRecalibrationOn())
+      {
         //Calibrate cluster
         fRecoUtils->RecalibrateClusterEnergy(fGeom, clus, cells);
         
         //CalibrateCells
         for (Int_t icell = 0; icell < cells->GetNumberOfCells(); icell++)
         {
-          if (cells->GetCell(icell, cellNumber, cellAmplitude, cellTime) != kTRUE)
+          if (cells->GetCell(icell, cellNumber, cellAmplitude, cellTime, cellMCLabel, cellEFrac) != kTRUE)
             break;
           
           Int_t imod = -1, iphi =-1, ieta=-1,iTower = -1, iIphi = -1, iIeta = -1; 
@@ -494,7 +641,8 @@ void AliAnalysisTaskEMCALClusterize::ClusterUnfolding()
           
           //Do not include bad channels found in analysis?
           if( fRecoUtils->IsBadChannelsRemovalSwitchedOn() && 
-             fRecoUtils->GetEMCALChannelStatus(imod, ieta, iphi)){
+             fRecoUtils->GetEMCALChannelStatus(imod, ieta, iphi))
+          {
             fCellLabels[cellNumber]      =-1; //reset the entry in the array for next event
             fCellSecondLabels[cellNumber]=-1; //reset the entry in the array for next event
             fCellTime[cellNumber]        = 0.;   
@@ -511,14 +659,18 @@ void AliAnalysisTaskEMCALClusterize::ClusterUnfolding()
       //Cast to ESD or AOD, needed to create the cluster array
       AliESDCaloCluster * esdCluster = dynamic_cast<AliESDCaloCluster*> (clus);
       AliAODCaloCluster * aodCluster = dynamic_cast<AliAODCaloCluster*> (clus);
-      if     (esdCluster){
+      
+      if     (esdCluster)
+      {
         fCaloClusterArr->Add( new AliESDCaloCluster(*esdCluster) );   
       }//ESD
-      else if(aodCluster){
+      else if(aodCluster)
+      {
         fCaloClusterArr->Add( new AliAODCaloCluster(*aodCluster) );   
       }//AOD
       else 
         Warning("UserExec()"," - Wrong CaloCluster type?");
+      
       nClustersOrg++;
     }
   }
@@ -542,20 +694,25 @@ void AliAnalysisTaskEMCALClusterize::FillAODCaloCells()
   aodEMcells.CreateContainer(nEMcell);
   aodEMcells.SetType(AliVCaloCells::kEMCALCell);
   Double_t calibFactor = 1.;   
-  for (Int_t iCell = 0; iCell < nEMcell; iCell++) { 
+  for (Int_t iCell = 0; iCell < nEMcell; iCell++) 
+  { 
     Int_t imod = -1, iphi =-1, ieta=-1,iTower = -1, iIphi = -1, iIeta = -1; 
     fGeom->GetCellIndex(eventEMcells.GetCellNumber(iCell),imod,iTower,iIphi,iIeta); 
     fGeom->GetCellPhiEtaIndexInSModule(imod,iTower,iIphi, iIeta,iphi,ieta);    
     
-    if(fRecoUtils->IsRecalibrationOn()){ 
+    if(fRecoUtils->IsRecalibrationOn())
+    { 
       calibFactor = fRecoUtils->GetEMCALChannelRecalibrationFactor(imod,ieta,iphi);
     }
     
-    if(!fRecoUtils->GetEMCALChannelStatus(imod, ieta, iphi)){ //Channel is not declared as bad
-      aodEMcells.SetCell(iCell,eventEMcells.GetCellNumber(iCell),eventEMcells.GetAmplitude(iCell)*calibFactor);
+    if(!fRecoUtils->GetEMCALChannelStatus(imod, ieta, iphi))
+    { //Channel is not declared as bad
+      aodEMcells.SetCell(iCell,eventEMcells.GetCellNumber(iCell),eventEMcells.GetAmplitude(iCell)*calibFactor,
+                         eventEMcells.GetTime(iCell),eventEMcells.GetMCLabel(iCell),eventEMcells.GetEFraction(iCell));
     }
-    else {
-      aodEMcells.SetCell(iCell,eventEMcells.GetCellNumber(iCell),0);
+    else 
+    {
+      aodEMcells.SetCell(iCell,eventEMcells.GetCellNumber(iCell),0,-1,-1,0);
     }
   }
   aodEMcells.Sort();
@@ -577,9 +734,11 @@ void AliAnalysisTaskEMCALClusterize::FillAODHeader()
   AliAODHeader* header = AODEvent()->GetHeader();
   header->SetRunNumber(fEvent->GetRunNumber());
   
-  if(esdevent){
+  if(esdevent)
+  {
     TTree* tree = fInputHandler->GetTree();
-    if (tree) {
+    if (tree) 
+    {
       TFile* file = tree->GetCurrentFile();
       if (file) header->SetESDFileName(file->GetName());
     }
@@ -592,25 +751,27 @@ void AliAnalysisTaskEMCALClusterize::FillAODHeader()
   header->SetEventType(fEvent->GetEventType());
   
   //Centrality
-  if(fEvent->GetCentrality()){
+  if(fEvent->GetCentrality())
     header->SetCentrality(new AliCentrality(*(fEvent->GetCentrality())));
-  }
-  else{
+  else
     header->SetCentrality(0);
-  }
   
   //Trigger  
   header->SetOfflineTrigger(fInputHandler->IsEventSelected()); // propagate the decision of the physics selection
   if      (esdevent) header->SetFiredTriggerClasses(esdevent->GetFiredTriggerClasses());
   else if (aodevent) header->SetFiredTriggerClasses(aodevent->GetFiredTriggerClasses());
+  
   header->SetTriggerMask(fEvent->GetTriggerMask()); 
   header->SetTriggerCluster(fEvent->GetTriggerCluster());
-  if(esdevent){
+  
+  if      (esdevent)
+  {
     header->SetL0TriggerInputs(esdevent->GetHeader()->GetL0TriggerInputs());    
     header->SetL1TriggerInputs(esdevent->GetHeader()->GetL1TriggerInputs());    
     header->SetL2TriggerInputs(esdevent->GetHeader()->GetL2TriggerInputs());    
   }
-  else if (aodevent){
+  else if (aodevent)
+  {
     header->SetL0TriggerInputs(aodevent->GetHeader()->GetL0TriggerInputs());    
     header->SetL1TriggerInputs(aodevent->GetHeader()->GetL1TriggerInputs());    
     header->SetL2TriggerInputs(aodevent->GetHeader()->GetL2TriggerInputs());    
@@ -633,7 +794,6 @@ void AliAnalysisTaskEMCALClusterize::FillAODHeader()
   else if (aodevent) header->SetDiamondZ(aodevent->GetDiamondZ(),aodevent->GetSigma2DiamondZ());
   
   //
-  //
   Int_t nVertices = 1 ;/* = prim. vtx*/;
   Int_t nCaloClus = fEvent->GetNumberOfCaloClusters();
   
@@ -647,11 +807,13 @@ void AliAnalysisTaskEMCALClusterize::FillAODHeader()
   // after the loops on the composite objects (V0, cascades, kinks)
   fEvent->GetPrimaryVertex()->GetXYZ(pos);
   Float_t chi = 0;
-  if      (esdevent){
+  if      (esdevent)
+  {
     esdevent->GetPrimaryVertex()->GetCovMatrix(covVtx);
     chi = esdevent->GetPrimaryVertex()->GetChi2toNDF();
   }
-  else if (aodevent){
+  else if (aodevent)
+  {
     aodevent->GetPrimaryVertex()->GetCovMatrix(covVtx);
     chi = aodevent->GetPrimaryVertex()->GetChi2perNDF();//Different from ESD?
   }
@@ -663,12 +825,120 @@ void AliAnalysisTaskEMCALClusterize::FillAODHeader()
   
 }
 
+//_________________________________________________________
+void AliAnalysisTaskEMCALClusterize::FillCaloClusterInAOD()
+{
+  // Get the CaloClusters array, do some final calculations 
+  // and put the clusters in the AOD branch
+  
+  //First recalculate track-matching for the new clusters
+  if(fDoTrackMatching) 
+  {
+    fRecoUtils->FindMatches(fEvent,fCaloClusterArr,fGeom);
+  }
+  //Put the new clusters in the AOD list
+  
+  Int_t kNumberOfCaloClusters   = fCaloClusterArr->GetEntriesFast();
+  for(Int_t i = 0; i < kNumberOfCaloClusters; i++)
+  {
+    AliAODCaloCluster *newCluster = (AliAODCaloCluster *) fCaloClusterArr->At(i);
+    
+    newCluster->SetID(i);
+    
+    //Add matched track
+    if(fDoTrackMatching)
+    {
+      Int_t trackIndex = fRecoUtils->GetMatchedTrackIndex(i);
+      if(trackIndex >= 0)
+      {
+        newCluster->AddTrackMatched(fEvent->GetTrack(trackIndex));
+        if(DebugLevel() > 1) 
+          printf("AliAnalysisTaksEMCALClusterize::UserExec() - Matched Track index %d to new cluster %d \n",trackIndex,i);
+      }
+      
+      Float_t dR = 999., dZ = 999.;
+      fRecoUtils->GetMatchedResiduals(newCluster->GetID(),dR,dZ);
+      newCluster->SetTrackDistance(dR,dZ);
+      
+    }
+    else 
+    {// Assign previously assigned matched track in reco, very very rough
+      Int_t absId0 = newCluster->GetCellsAbsId()[0]; // Assign match of first cell in cluster
+      newCluster->SetTrackDistance(fCellMatchdPhi[absId0],fCellMatchdEta[absId0]);
+    }
+    
+    //printf("New cluster E %f, Time  %e, Id = ", newCluster->E(), newCluster->GetTOF() );
+    //for(Int_t icell=0; icell < newCluster->GetNCells(); icell++ ) printf(" %d,", newCluster->GetCellsAbsId() [icell] );
+    //printf("\n");
+    
+    // Calculate distance to bad channel for new cluster. Make sure you give the list of bad channels.
+    fRecoUtils->RecalculateClusterDistanceToBadChannel(fGeom, fEvent->GetEMCALCells(), newCluster);
+    
+    new((*fOutputAODBranch)[i])  AliAODCaloCluster(*newCluster);
+    
+    if(DebugLevel() > 1 )    
+      printf("AliAnalysisTaksEMCALClusterize::UserExec() - New cluster %d of %d, energy %f\n",newCluster->GetID(), kNumberOfCaloClusters, newCluster->E());
+    
+  } // cluster loop
+  
+  fOutputAODBranch->Expand(kNumberOfCaloClusters); // resize TObjArray to 'remove' slots
+  
+  // Clean up
+  fCaloClusterArr->Delete(); // Do not Clear(), it leaks, why?
+  
+}
+
+//_______________________________________________
+TString AliAnalysisTaskEMCALClusterize::GetPass()
+{
+  // Get passx from filename.
+  
+  if (!AliAnalysisManager::GetAnalysisManager()->GetTree()) 
+  {
+    AliError("AliAnalysisTaskEMCALClusterize::GetPass() - Pointer to tree = 0, returning null\n");
+    return TString("");
+  }
+  
+  if (!AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()) 
+  {
+    AliError("AliAnalysisTaskEMCALClusterize::GetPass() - Null pointer input file, returning null\n");
+    return TString("");
+  }
+  
+  TString pass(AliAnalysisManager::GetAnalysisManager()->GetTree()->GetCurrentFile()->GetName());
+  if      (pass.Contains("ass1")) return TString("pass1");
+  else if (pass.Contains("ass2")) return TString("pass2");
+  else if (pass.Contains("ass3")) return TString("pass3");
+  
+  // No condition fullfilled, give a default value
+  printf("AliAnalysisTaskEMCALClusterize::GetPass() - Pass number string not found \n");
+  return TString("");            
+  
+}
+
 //_________________________________________
 void AliAnalysisTaskEMCALClusterize::Init()
 {
   //Init analysis with configuration macro if available
   
-  if(gROOT->LoadMacro(fConfigName) >=0){
+  fOADBSet           = kFALSE;
+  if(fOADBFilePath == "") fOADBFilePath = "$ALICE_ROOT/OADB/EMCAL" ;          
+  
+  fCaloClusterArr    = new TObjArray(10000);
+  fBranchNames       = "ESD:AliESDHeader.,EMCALCells.";
+  
+  if(!fRecParam)     fRecParam  = new AliEMCALRecParam;
+  if(!fRecoUtils)    fRecoUtils = new AliEMCALRecoUtils();  
+  
+  if(fMaxEvent          <= 0) fMaxEvent          = 1000000000;
+  if(fSelectCellMinE    <= 0) fSelectCellMinE    = 0.005;     
+  if(fSelectCellMinFrac <= 0) fSelectCellMinFrac = 0.001;
+  
+  if (fOCDBpath            == "") fOCDBpath            = "raw://" ;
+  if (fOutputAODBranchName == "") fOutputAODBranchName = "newEMCALClusters" ;
+  
+  if(gROOT->LoadMacro(fConfigName) >=0)
+  {
     printf("AliAnalysisTaksEMCALClusterize::Init() - Configure analysis with %s\n",fConfigName.Data());
     AliAnalysisTaskEMCALClusterize *clus = (AliAnalysisTaskEMCALClusterize*)gInterpreter->ProcessLine("ConfigEMCALClusterize()");
     fGeomName         = clus->fGeomName; 
@@ -684,13 +954,14 @@ void AliAnalysisTaskEMCALClusterize::Init()
     fDoTrackMatching  = clus->fDoTrackMatching;
     fOutputAODBranchName = clus->fOutputAODBranchName;
     for(Int_t i = 0; i < 12; i++) fGeomMatrix[i] = clus->fGeomMatrix[i] ;
-    
   }
   
   // Init geometry, I do not like much to do it like this ...
-  if(fImportGeometryFromFile && !gGeoManager) {
-    printf("AliAnalysisTaskEMCALClusterize::Init() - Import geometry.root file\n");
-    TGeoManager::Import(Form("%s/geometry.root", fImportGeometryFilePath.Data())) ; // default need file "geometry.root" in local dir!!!!
+  if(fImportGeometryFromFile && !gGeoManager) 
+  {
+    if (fImportGeometryFilePath == "") fImportGeometryFilePath = "$ALICE_ROOT/PWGGA/EMCALTasks/macros/geometry.root" ; // "$ALICE_ROOT/EVE/alice-data/default_geo.root"
+    printf("AliAnalysisTaskEMCALClusterize::Init() - Import %s\n",fImportGeometryFilePath.Data());
+    TGeoManager::Import(fImportGeometryFilePath) ; 
   }
   
 }  
@@ -700,7 +971,8 @@ void AliAnalysisTaskEMCALClusterize::InitClusterization()
 {
   //Select clusterization/unfolding algorithm and set all the needed parameters
   
-  if (fJustUnfold){
+  if (fJustUnfold)
+  {
     // init the unfolding afterburner 
     delete fUnfolder;
     fUnfolder =  new AliEMCALAfterBurnerUF(fRecParam->GetW0(),fRecParam->GetLocMaxCut(),fRecParam->GetMinECut());
@@ -713,11 +985,14 @@ void AliAnalysisTaskEMCALClusterize::InitClusterization()
     fClusterizer = new AliEMCALClusterizerv1 (fGeom, fCalibData, fPedestalData);
   else if(fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerv2) 
     fClusterizer = new AliEMCALClusterizerv2(fGeom, fCalibData, fPedestalData);
-  else if(fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerNxN){ 
+  else if(fRecParam->GetClusterizerFlag() == AliEMCALRecParam::kClusterizerNxN)
+  { 
     fClusterizer = new AliEMCALClusterizerNxN(fGeom, fCalibData, fPedestalData);
     fClusterizer->SetNRowDiff(fRecParam->GetNRowDiff());
     fClusterizer->SetNColDiff(fRecParam->GetNColDiff());
-  } else {
+  } 
+  else 
+  {
     AliFatal(Form("Clusterizer < %d > not available", fRecParam->GetClusterizerFlag()));
   }
   
@@ -732,13 +1007,23 @@ void AliAnalysisTaskEMCALClusterize::InitClusterization()
   fClusterizer->SetTimeMax               ( fRecParam->GetTimeMax()             );
   fClusterizer->SetInputCalibrated       ( kTRUE                               );
   fClusterizer->SetJustClusters          ( kTRUE                               );  
+  
+  // Initialize the cluster rec points and digits arrays and get them.
+  fClusterizer->SetOutput(0);
+  fClusterArr = const_cast<TObjArray *>(fClusterizer->GetRecPoints());
+  fDigitsArr  = fClusterizer->GetDigits();
+  
   //In case of unfolding after clusterization is requested, set the corresponding parameters
-  if(fRecParam->GetUnfold()){
+  if(fRecParam->GetUnfold())
+  {
     Int_t i=0;
-    for (i = 0; i < 8; i++) {
+    for (i = 0; i < 8; i++) 
+    {
       fClusterizer->SetSSPars(i, fRecParam->GetSSPars(i));
     }//end of loop over parameters
-    for (i = 0; i < 3; i++) {
+    
+    for (i = 0; i < 3; i++) 
+    {
       fClusterizer->SetPar5  (i, fRecParam->GetPar5(i));
       fClusterizer->SetPar6  (i, fRecParam->GetPar6(i));
     }//end of loop over parameters
@@ -751,49 +1036,103 @@ void AliAnalysisTaskEMCALClusterize::InitClusterization()
 //_________________________________________________
 void AliAnalysisTaskEMCALClusterize::InitGeometry()
 {
-  // Set the geometry matrix, for the first event, skip the rest
+  // Init geometry and set the geometry matrix, for the first event, skip the rest
   // Also set once the run dependent calibrations
   
-  if(!fGeomMatrixSet){
-    if(fLoadGeomMatrices){
-      for(Int_t mod=0; mod < (fGeom->GetEMCGeometry())->GetNumberOfSuperModules(); mod++){
-        if(fGeomMatrix[mod]){
-          if(DebugLevel() > 1) 
-            fGeomMatrix[mod]->Print();
-          fGeom->SetMisalMatrix(fGeomMatrix[mod],mod) ;  
-        }
-        fGeomMatrixSet=kTRUE;
-      }//SM loop
-    }//Load matrices
-    else if(!gGeoManager){
-      printf("AliAnalysisTaksEMCALClusterize::InitGeometry() - Get geo matrices from data");
-      //Still not implemented in AOD, just a workaround to be able to work at least with ESDs  
-      if(!strcmp(fEvent->GetName(),"AliAODEvent")) {
-        if(DebugLevel() > 1) 
-          Warning("UserExec","Use ideal geometry, values geometry matrix not kept in AODs.");
-      }//AOD
-      else {   
-        if(DebugLevel() > 1) 
-          printf("AliAnalysisTaksEMCALClusterize::InitGeometry() - AliAnalysisTaskEMCALClusterize Load Misaligned matrices.");
-        AliESDEvent* esd = dynamic_cast<AliESDEvent*>(fEvent) ;
-        if(!esd) {
-          Error("InitGeometry"," - This event does not contain ESDs?");
-          AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kFALSE);
-          return;
-        }
-        for(Int_t mod=0; mod < (fGeom->GetEMCGeometry())->GetNumberOfSuperModules(); mod++){
-          if(DebugLevel() > 1) 
-            esd->GetEMCALMatrix(mod)->Print();
-          if(esd->GetEMCALMatrix(mod)) fGeom->SetMisalMatrix(esd->GetEMCALMatrix(mod),mod) ;
-        } 
-        fGeomMatrixSet=kTRUE;
-      }//ESD
-    }//Load matrices from Data 
+  if(fGeomMatrixSet) return;
+  
+  Int_t runnumber = InputEvent()->GetRunNumber() ;
+  if (!fGeom)
+  {
+    if(fGeomName=="")
+    {
+      if     (runnumber < 140000) fGeomName = "EMCAL_FIRSTYEARV1";
+      else if(runnumber < 171000) fGeomName = "EMCAL_COMPLETEV1";
+      else                        fGeomName = "EMCAL_COMPLETE12SMV1";  
+      printf("AliAnalysisTaskEMCALClusterize::InitGeometry() - Set EMCAL geometry name to <%s> for run %d\n",fGeomName.Data(),runnumber);
+    }
     
-    //Recover time dependent corrections, put then in recalibration histograms. Do it once
-    fRecoUtils->SetRunDependentCorrections(InputEvent()->GetRunNumber());
+               fGeom = AliEMCALGeometry::GetInstance(fGeomName);
     
-  }//first event  
+               if(fDebug > 0)
+    {
+                       printf("AliAnalysisTaskEMCALClusterize::InitGeometry(run=%d)",runnumber);
+                       if (!gGeoManager) printf(" - Careful!, gGeoManager not loaded, load misalign matrices");
+                       printf("\n");
+               }
+       } // geometry pointer did not exist before
+  
+  if(fLoadGeomMatrices)
+  {
+    printf("AliAnalysisTaskEMCALClusterize::InitGeometry() - Load user defined EMCAL geometry matrices\n");
+    
+    // OADB if available
+    AliOADBContainer emcGeoMat("AliEMCALgeo");
+    emcGeoMat.InitFromFile(Form("%s/EMCALlocal2master.root",fOADBFilePath.Data()),"AliEMCALgeo");
+    TObjArray *matEMCAL=(TObjArray*)emcGeoMat.GetObject(runnumber,"EmcalMatrices");
+    
+    
+    for(Int_t mod=0; mod < (fGeom->GetEMCGeometry())->GetNumberOfSuperModules(); mod++)
+    {
+      
+      if (!fGeomMatrix[mod]) // Get it from OADB
+      {
+        if(fDebug > 1 ) 
+          printf("AliAnalysisTaskEMCALClusterize::InitGeometry() - EMCAL matrices SM %d, %p\n",
+                 mod,((TGeoHMatrix*) matEMCAL->At(mod)));
+        //((TGeoHMatrix*) matEMCAL->At(mod))->Print();
+        
+        fGeomMatrix[mod] = (TGeoHMatrix*) matEMCAL->At(mod) ;
+      }        
+      
+      if(fGeomMatrix[mod])
+      {
+        if(DebugLevel() > 1) 
+          fGeomMatrix[mod]->Print();
+        
+        fGeom->SetMisalMatrix(fGeomMatrix[mod],mod) ;  
+      }
+      
+      fGeomMatrixSet=kTRUE;
+      
+    }//SM loop
+  }//Load matrices
+  else if(!gGeoManager)
+  {
+    printf("AliAnalysisTaksEMCALClusterize::InitGeometry() - Get geo matrices from data");
+    //Still not implemented in AOD, just a workaround to be able to work at least with ESDs    
+    if(!strcmp(fEvent->GetName(),"AliAODEvent")) 
+    {
+      if(DebugLevel() > 1) 
+        Warning("UserExec","Use ideal geometry, values geometry matrix not kept in AODs.");
+    }//AOD
+    else 
+    {  
+      if(DebugLevel() > 1) 
+        printf("AliAnalysisTaksEMCALClusterize::InitGeometry() - AliAnalysisTaskEMCALClusterize Load Misaligned matrices.");
+      
+      AliESDEvent* esd = dynamic_cast<AliESDEvent*>(fEvent) ;
+      
+      if(!esd)
+      {
+        Error("InitGeometry"," - This event does not contain ESDs?");
+        AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kFALSE);
+        return;
+      }
+      
+      for(Int_t mod=0; mod < (fGeom->GetEMCGeometry())->GetNumberOfSuperModules(); mod++)
+      {
+        if(DebugLevel() > 1) 
+          esd->GetEMCALMatrix(mod)->Print();
+        
+        if(esd->GetEMCALMatrix(mod)) fGeom->SetMisalMatrix(esd->GetEMCALMatrix(mod),mod) ;
+        
+      } 
+      
+      fGeomMatrixSet=kTRUE;
+      
+    }//ESD
+  }//Load matrices from Data 
   
 }
 
@@ -810,7 +1149,8 @@ Bool_t AliAnalysisTaskEMCALClusterize::IsExoticEvent()
   AliVCaloCells * cells = fEvent->GetEMCALCells();
   Float_t totCellE = 0;
   Int_t bc = InputEvent()->GetBunchCrossNumber();
-  for(Int_t icell = 0; icell < cells->GetNumberOfCells(); icell++){
+  for(Int_t icell = 0; icell < cells->GetNumberOfCells(); icell++)
+  {
     
     Float_t  ecell = 0 ;
     Double_t tcell = 0 ;
@@ -836,18 +1176,22 @@ Bool_t AliAnalysisTaskEMCALClusterize::IsExoticEvent()
   
 } 
 
-//_________________________________________________
-Bool_t AliAnalysisTaskEMCALClusterize::IsLEDEvent()
+//________________________________________________________________
+Bool_t AliAnalysisTaskEMCALClusterize::IsLEDEvent(const Int_t run)
 {
   //Check if event is LED
   
   if(!fRemoveLEDEvents) return kFALSE;
-    
+  
+  //check events of LHC11a period
+  if(run < 140000  || run > 146860) return kFALSE ;
+  
   // Count number of cells with energy larger than 0.1 in SM3, cut on this number
   Int_t ncellsSM3 = 0;
   Int_t ncellsSM4 = 0;
   AliVCaloCells * cells = fEvent->GetEMCALCells();
-  for(Int_t icell = 0; icell < cells->GetNumberOfCells(); icell++){
+  for(Int_t icell = 0; icell < cells->GetNumberOfCells(); icell++)
+  {
     if(cells->GetAmplitude(icell) > 0.1 && cells->GetCellNumber(icell)/(24*48)==3) ncellsSM3++;
     if(cells->GetAmplitude(icell) > 0.1 && cells->GetCellNumber(icell)/(24*48)==4) ncellsSM4++;      
   }
@@ -861,7 +1205,8 @@ Bool_t AliAnalysisTaskEMCALClusterize::IsLEDEvent()
   Int_t ncellcut = 21;
   if(triggerclasses.Contains("EMC")) ncellcut = 35;
   
-  if( ncellsSM3 >= ncellcut || ncellsSM4 >= 100 ){
+  if( ncellsSM3 >= ncellcut || ncellsSM4 >= 100 )
+  {
     printf("AliAnalysisTaksEMCALClusterize::IsLEDEvent() - reject event %d with ncells in SM3 %d and SM4 %d\n",(Int_t)Entry(),ncellsSM3, ncellsSM4);
     AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillAOD(kFALSE);
     return kTRUE;
@@ -871,17 +1216,17 @@ Bool_t AliAnalysisTaskEMCALClusterize::IsLEDEvent()
   
 } 
 
-//______________________________________________________________________________
-void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr, 
-                                                        TObjArray *recPoints, 
-                                                        TObjArray *clusArray)
+//_______________________________________________________
+void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters()
 {
   // Restore clusters from recPoints
-  // Cluster energy, global position, cells and their amplitude fractions are restored
+  // Cluster energy, global position, cells and their amplitude 
+  // fractions are restored
+  
   Int_t j = 0;
-  for(Int_t i = 0; i < recPoints->GetEntriesFast(); i++)
+  for(Int_t i = 0; i < fClusterArr->GetEntriesFast(); i++)
   {
-    AliEMCALRecPoint *recPoint = (AliEMCALRecPoint*) recPoints->At(i);
+    AliEMCALRecPoint *recPoint = (AliEMCALRecPoint*) fClusterArr->At(i);
     
     const Int_t ncells = recPoint->GetMultiplicity();
     Int_t ncellsTrue = 0;
@@ -896,17 +1241,20 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
     AliAODInputHandler* aodIH = dynamic_cast<AliAODInputHandler*>((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
     
     Float_t clusterE = 0; 
-    for (Int_t c = 0; c < ncells; c++) {
-      AliEMCALDigit *digit = (AliEMCALDigit*) digitsArr->At(recPoint->GetDigitsList()[c]);
+    for (Int_t c = 0; c < ncells; c++) 
+    {
+      AliEMCALDigit *digit = (AliEMCALDigit*) fDigitsArr->At(recPoint->GetDigitsList()[c]);
       
       absIds[ncellsTrue] = digit->GetId();
       ratios[ncellsTrue] = recPoint->GetEnergiesList()[c]/digit->GetAmplitude();
       
       // In case of unfolding, remove digits with unfolded energy too low      
-      if(fSelectCell){
-        if     (recPoint->GetEnergiesList()[c] < fSelectCellMinE || ratios[ncellsTrue] < fSelectCellMinFrac)  {
-          
-          if(DebugLevel() > 1)  {
+      if(fSelectCell)
+      {
+        if     (recPoint->GetEnergiesList()[c] < fSelectCellMinE || ratios[ncellsTrue] < fSelectCellMinFrac)  
+        {
+          if(DebugLevel() > 1)  
+          {
             printf("AliAnalysisTaksEMCALClusterize::RecPoints2Clusters() - Too small energy in cell of cluster: cluster cell %f, digit %f\n",
                    recPoint->GetEnergiesList()[c],digit->GetAmplitude());
           }
@@ -921,8 +1269,8 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
       clusterE  +=recPoint->GetEnergiesList()[c];
       
       // In case of embedding, fill ratio with amount of signal, 
-      if (aodIH && aodIH->GetMergeEvents()) {
-        
+      if (aodIH && aodIH->GetMergeEvents()) 
+      {
         //AliVCaloCells* inEMCALCells = InputEvent()->GetEMCALCells();
         AliVCaloCells* meEMCALCells = aodIH->GetEventToMerge()->GetEMCALCells();
         AliVCaloCells* ouEMCALCells = AODEvent()->GetEMCALCells();
@@ -939,7 +1287,8 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
       
     }// cluster cell loop
     
-    if (ncellsTrue < 1) {
+    if (ncellsTrue < 1) 
+    {
       if (DebugLevel() > 1) 
         printf("AliAnalysisTaskEMCALClusterize::RecPoints2Clusters() - Skipping cluster with no cells avobe threshold E = %f, ncells %d\n",
                recPoint->GetEnergy(), ncells);
@@ -948,7 +1297,8 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
     
     //if(ncellsTrue != ncells) printf("Old E %f, ncells %d; New E %f, ncells %d\n",recPoint->GetEnergy(),ncells,clusterE,ncellsTrue);
     
-    if(clusterE <  fRecParam->GetClusteringThreshold()) {
+    if(clusterE <  fRecParam->GetClusteringThreshold()) 
+    {
       if (DebugLevel()>1)
         printf("AliAnalysisTaskEMCALClusterize::RecPoints2Clusters() - Remove cluster with energy below seed threshold %f\n",clusterE);
       continue;
@@ -958,13 +1308,13 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
     Float_t g[3];
     
     // calculate new cluster position
-    recPoint->EvalGlobalPosition(fRecParam->GetW0(), digitsArr);
+    recPoint->EvalGlobalPosition(fRecParam->GetW0(), fDigitsArr);
     recPoint->GetGlobalPosition(gpos);
     gpos.GetXYZ(g);
     
     // create a new cluster
-    (*clusArray)[j] = new AliAODCaloCluster() ;
-    AliAODCaloCluster *clus = dynamic_cast<AliAODCaloCluster *>( clusArray->At(j) ) ;
+    (*fCaloClusterArr)[j] = new AliAODCaloCluster() ;
+    AliAODCaloCluster *clus = dynamic_cast<AliAODCaloCluster *>( fCaloClusterArr->At(j) ) ;
     j++;
     clus->SetType(AliVCluster::kEMCALClusterv1);
     clus->SetE(clusterE);
@@ -976,20 +1326,26 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
     clus->SetTOF(recPoint->GetTime()) ; //time-of-flight
     clus->SetNExMax(recPoint->GetNExMax()); //number of local maxima
     clus->SetDistanceToBadChannel(recPoint->GetDistanceToBadTower()); 
-
-    if(ncells == ncellsTrue){
+    
+    if(ncells == ncellsTrue)
+    {
       Float_t elipAxis[2];
       recPoint->GetElipsAxis(elipAxis);
       clus->SetM02(elipAxis[0]*elipAxis[0]) ;
       clus->SetM20(elipAxis[1]*elipAxis[1]) ;
       clus->SetDispersion(recPoint->GetDispersion());
     }
-    else if(fSelectCell){
+    else if(fSelectCell)
+    {
       // In case some cells rejected, in unfolding case, recalculate
       // shower shape parameters and position
+      if(DebugLevel() > 1) 
+        printf("AliAnalysisTaskEMCALClusterize::RecPoints2Clusters() - Cells removed from cluster (ncells %d, ncellsTrue %d), recalculate Shower Shape\n",ncells,ncellsTrue);
+      
       AliVCaloCells* cells = 0x0; 
       if (aodIH && aodIH->GetMergeEvents()) cells = AODEvent()  ->GetEMCALCells();
       else                                  cells = InputEvent()->GetEMCALCells();
+      
       fRecoUtils->RecalculateClusterShowerShapeParameters(fGeom,cells,clus);
       fRecoUtils->RecalculateClusterPID(clus);
       fRecoUtils->RecalculateClusterPosition(fGeom,cells,clus); 
@@ -1003,10 +1359,12 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
     
     //Write the second major contributor to each MC cluster.
     Int_t iNewLabel ;
-    for ( Int_t iLoopCell = 0 ; iLoopCell < clus->GetNCells() ; iLoopCell++ ){
+    for ( Int_t iLoopCell = 0 ; iLoopCell < clus->GetNCells() ; iLoopCell++ )
+    {
       
       Int_t idCell = clus->GetCellAbsId(iLoopCell) ;
-      if(idCell>=0){
+      if(idCell>=0)
+      {
         iNewLabel = 1 ; //iNewLabel makes sure we  don't write twice the same label.
         for ( UInt_t iLoopLabels = 0 ; iLoopLabels < clus->GetNLabels() ; iLoopLabels++ )
         {
@@ -1016,7 +1374,8 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
         if (iNewLabel == 1) 
         {
           Int_t * newLabelArray = new Int_t[clus->GetNLabels()+1] ;
-          for ( UInt_t iLoopNewLabels = 0 ; iLoopNewLabels < clus->GetNLabels() ; iLoopNewLabels++ ){
+          for ( UInt_t iLoopNewLabels = 0 ; iLoopNewLabels < clus->GetNLabels() ; iLoopNewLabels++ )
+          {
             newLabelArray[iLoopNewLabels] = clus->GetLabelAt(iLoopNewLabels) ;
           }
           
@@ -1031,33 +1390,42 @@ void AliAnalysisTaskEMCALClusterize::RecPoints2Clusters(TClonesArray *digitsArr,
   
 }
 
+
 //____________________________________________________________
 void AliAnalysisTaskEMCALClusterize::UserCreateOutputObjects()
 {
   // Init geometry, create list of output clusters
   
-  fGeom =  AliEMCALGeometry::GetInstance(fGeomName) ;  
-  if(fOutputAODBranchName.Length()!=0){
+  if(fOutputAODBranchName.Length()!=0)
+  {
     fOutputAODBranch = new TClonesArray("AliAODCaloCluster", 0);
     fOutputAODBranch->SetName(fOutputAODBranchName);
     //fOutputAODBranch->SetOwner(kFALSE);
     AddAODBranch("TClonesArray", &fOutputAODBranch);
   }
-  else {
+  else
+  {
     AliFatal("fOutputAODBranchName not set\n");
   }
   
-  //PostData(0,fOutputAODBranch);
-  
 }
 
 //_______________________________________________________
 void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *) 
 {
-  // Main loop
-  // Called for each event
-    
-  //Remove the contents of output list set in the previous event 
+  // Do clusterization event by event, execute different steps
+  // 1) Do some checks on the kind of events (ESD, AOD) or if some filtering is needed and initializations
+  // 2) Clusterize a) just unfolding existing clusters (fJustUnfold)
+  //               b) recluster cells
+  //                   +  convert cells into digits (calibrating them)
+  //                   +  recluster digits into recPoints with the chosen clusterizer (V1, V1+Unfold,V2, NxN) 
+  //                      with methods in AliEMCALClusterizer
+  //                   +  transform recPoints into CaloClusters
+  // 3) Do some final calculations in the found clusters (track-matching) and put them in an AOD branch
+  
+  // Step 1
+  
+  //Remove the contents of AOD branch output list set in the previous event 
   fOutputAODBranch->Clear("C");
   
   LoadBranches();
@@ -1071,72 +1439,24 @@ void AliAnalysisTaskEMCALClusterize::UserExec(Option_t *)
     return ;
   }
   
-  //Init pointers, clusterizer, ocdb
+  //Init pointers, geometry, clusterizer, ocdb, aodb
+  
+  InitGeometry(); // only once, must be done before OADB, geo OADB accessed here
+  
   if(fAccessOCDB) AccessOCDB();
+  if(fAccessOADB) AccessOADB(); // only once
   
   InitClusterization();
   
-  InitGeometry(); // only once
+  // Step 2
   
   // Make clusters
   if (fJustUnfold) ClusterUnfolding();
   else             ClusterizeCells() ;
   
-  //Recalculate track-matching for the new clusters
-  if(fDoTrackMatching) 
-  {
-    fRecoUtils->FindMatches(fEvent,fCaloClusterArr,fGeom);
-  }
-  //Put the new clusters in the AOD list
-  
-  Int_t kNumberOfCaloClusters   = fCaloClusterArr->GetEntriesFast();
-  for(Int_t i = 0; i < kNumberOfCaloClusters; i++){
-    AliAODCaloCluster *newCluster = (AliAODCaloCluster *) fCaloClusterArr->At(i);
-    
-    newCluster->SetID(i);
-
-    //Add matched track
-    if(fDoTrackMatching)
-    {
-      Int_t trackIndex = fRecoUtils->GetMatchedTrackIndex(i);
-      if(trackIndex >= 0)
-      {
-        newCluster->AddTrackMatched(fEvent->GetTrack(trackIndex));
-        if(DebugLevel() > 1) 
-          printf("AliAnalysisTaksEMCALClusterize::UserExec() - Matched Track index %d to new cluster %d \n",trackIndex,i);
-      }
-      
-      Float_t dR = 999., dZ = 999.;
-      fRecoUtils->GetMatchedResiduals(newCluster->GetID(),dR,dZ);
-      newCluster->SetTrackDistance(dR,dZ);
-      
-    }
-    else 
-    {// Assign previously assigned matched track in reco, very very rough
-      Int_t absId0 = newCluster->GetCellsAbsId()[0]; // Assign match of first cell in cluster
-      newCluster->SetTrackDistance(fCellMatchdPhi[absId0],fCellMatchdEta[absId0]);
-    }
-
-    //printf("New cluster E %f, Time  %e, Id = ", newCluster->E(), newCluster->GetTOF() );
-    //for(Int_t icell=0; icell < newCluster->GetNCells(); icell++ ) printf(" %d,", newCluster->GetCellsAbsId() [icell] );
-    //printf("\n");
-
-    // Calculate distance to bad channel for new cluster. Make sure you give the list of bad channels.
-    fRecoUtils->RecalculateClusterDistanceToBadChannel(fGeom, fEvent->GetEMCALCells(), newCluster);
-    
-    new((*fOutputAODBranch)[i])  AliAODCaloCluster(*newCluster);
-        
-    if(DebugLevel() > 1 )    
-      printf("AliAnalysisTaksEMCALClusterize::UserExec() - New cluster %d of %d, energy %f\n",newCluster->GetID(), kNumberOfCaloClusters, newCluster->E());
-    
-  } // cluster loop
-  
-  fOutputAODBranch->Expand(kNumberOfCaloClusters); // resize TObjArray to 'remove' slots
-  
-  // Clean up
-  fCaloClusterArr->Delete(); // Do not Clear(), it leaks, why?
+  // Step 3
   
-  //PostData(0,fOutputAODBranch);
+  FillCaloClusterInAOD();
   
 }