Updating eta storing
[u/mrichter/AliRoot.git] / ZDC / AliZDCReconstructor.cxx
index 4e3c933..336dce6 100644 (file)
 #include "AliZDCReconstructor.h"
 #include "AliZDCPedestals.h"
 #include "AliZDCEnCalib.h"
+#include "AliZDCSaturationCalib.h"
 #include "AliZDCTowerCalib.h"
+#include "AliZDCMBCalib.h"
+#include "AliZDCTDCCalib.h"
 #include "AliZDCRecoParam.h"
 #include "AliZDCRecoParampp.h"
 #include "AliZDCRecoParamPbPb.h"
 #include "AliRunInfo.h"
+#include "AliLHCClockPhase.h"
 
 
 ClassImp(AliZDCReconstructor)
-AliZDCRecoParam *AliZDCReconstructor::fRecoParam=0;  //reconstruction parameters
+AliZDCRecoParam *AliZDCReconstructor::fgRecoParam=0;  //reconstruction parameters
+AliZDCMBCalib *AliZDCReconstructor::fgMBCalibData=0;  //calibration parameters for A-A reconstruction
 
 //_____________________________________________________________________________
 AliZDCReconstructor:: AliZDCReconstructor() :
   fPedData(GetPedestalData()),
   fEnCalibData(GetEnergyCalibData()),
+  fSatCalibData(GetSaturationCalibData()),
   fTowCalibData(GetTowerCalibData()),
+  fTDCCalibData(GetTDCCalibData()),
   fRecoMode(0),
   fBeamEnergy(0.),
   fNRun(0),
   fIsCalibrationMB(kFALSE),
   fPedSubMode(0),
-  fSignalThreshold(7)
-{
+  fSignalThreshold(7),
+  fMeanPhase(0),
+  fESDZDC(NULL){
   // **** Default constructor
 }
 
@@ -71,18 +79,20 @@ AliZDCReconstructor:: AliZDCReconstructor() :
 AliZDCReconstructor::~AliZDCReconstructor()
 {
 // destructor
-//   if(fRecoParam)    delete fRecoParam;
+//   if(fgRecoParam)    delete fgRecoParam;
    if(fPedData)      delete fPedData;    
    if(fEnCalibData)  delete fEnCalibData;
+   if(fSatCalibData)  delete fSatCalibData;
    if(fTowCalibData) delete fTowCalibData;
+   if(fgMBCalibData) delete fgMBCalibData;
+   if(fESDZDC)       delete fESDZDC;
 }
 
 //____________________________________________________________________________
 void AliZDCReconstructor::Init()
 {
-  // Setting reconstruction mode
-  // Getting beam type and beam energy from GRP calibration object
-  
+  // Setting reconstruction parameters
+    
   TString runType = GetRunInfo()->GetRunType();
   if((runType.CompareTo("CALIBRATION_MB")) == 0){
     fIsCalibrationMB = kTRUE;
@@ -90,30 +100,95 @@ void AliZDCReconstructor::Init()
     
   TString beamType = GetRunInfo()->GetBeamType();
   // This is a temporary solution to allow reconstruction in tests without beam
-  if(((beamType.CompareTo("UNKNOWN"))==0) && ((runType.CompareTo("PHYSICS")) == 0)){
+  if(((beamType.CompareTo("UNKNOWN"))==0) && 
+     ((runType.CompareTo("PHYSICS"))==0 || (runType.CompareTo("CALIBRATION_BC"))==0)){
     fRecoMode=1;
   }
   /*else if((beamType.CompareTo("UNKNOWN"))==0){
     AliError("\t UNKNOWN beam type\n");
     return;
   }*/
-
+    
+  fBeamEnergy = GetRunInfo()->GetBeamEnergy();
+  if(fBeamEnergy<0.01){
+     AliWarning(" Beam energy value missing -> setting it to 1380 GeV ");
+     fBeamEnergy = 1380.;
+  }
+  
   if(((beamType.CompareTo("pp"))==0) || ((beamType.CompareTo("p-p"))==0)
      ||((beamType.CompareTo("PP"))==0) || ((beamType.CompareTo("P-P"))==0)){
     fRecoMode=1;
   }
-  else if((beamType.CompareTo("A-A")) == 0){
-    fRecoMode=2;
+  else if(((beamType.CompareTo("p-A"))==0) || ((beamType.CompareTo("A-p"))==0)
+     ||((beamType.CompareTo("P-A"))==0) || ((beamType.CompareTo("A-P"))==0)){
+    fRecoMode=1;
   }
-    
-  fBeamEnergy = GetRunInfo()->GetBeamEnergy();
-  if(fBeamEnergy==0.){
-    AliWarning(" Beam energy value missing -> E_beam = 0");
-    fBeamEnergy = 0.;
+  else if((beamType.CompareTo("A-A")) == 0 || (beamType.CompareTo("AA")) == 0){
+    fRecoMode=2;
+    if(!fgRecoParam) fgRecoParam = const_cast<AliZDCRecoParam*>(GetRecoParam());
+    if(fgRecoParam){
+      fgRecoParam->SetGlauberMCDist(fBeamEnergy);      
+    } 
   }
+
+  AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase"); 
+  if (!entry) AliFatal("LHC clock-phase shift is not found in OCDB !");
+  AliLHCClockPhase *phaseLHC = (AliLHCClockPhase*)entry->GetObject();
+  // 4/2/2011 According to A. Di Mauro BEAM1 measurement is more reliable 
+  // than BEAM2 and therefore also than the average of the 2
+  fMeanPhase = phaseLHC->GetMeanPhaseB1();
     
   if(fIsCalibrationMB==kFALSE)  
-    printf("\n\n ***** ZDC reconstruction initialized for %s @ %1.0f GeV *****\n\n",beamType.Data(), fBeamEnergy);
+    AliInfo(Form("\n\n ***** ZDC reconstruction initialized for %s @ %1.0f + %1.0f GeV *****\n\n",
+       beamType.Data(), fBeamEnergy, fBeamEnergy));
+  
+  // if EMD calibration run NO ENERGY CALIBRATION should be performed
+  // pp-like reconstruction must be performed (E cailb. coeff. = 1)
+  if((runType.CompareTo("CALIBRATION_EMD")) == 0){
+    fRecoMode=1; 
+    fBeamEnergy = 1380.;
+  }
+  
+  AliInfo(Form("\n   ZDC reconstruction mode %d (1 -> p-p, 2-> A-A)\n\n",fRecoMode));
+  
+  fESDZDC = new AliESDZDC();
+
+}
+
+
+//____________________________________________________________________________
+void AliZDCReconstructor::Init(TString beamType, Float_t beamEnergy)
+{
+  // Setting reconstruction mode
+  // Needed to work in the HLT framework
+  
+  fIsCalibrationMB = kFALSE;
+     
+  fBeamEnergy = beamEnergy;
+  
+  if(((beamType.CompareTo("pp"))==0) || ((beamType.CompareTo("p-p"))==0)
+     ||((beamType.CompareTo("PP"))==0) || ((beamType.CompareTo("P-P"))==0)){
+    fRecoMode=1;
+  }
+  else if(((beamType.CompareTo("p-A"))==0) || ((beamType.CompareTo("A-p"))==0)
+     ||((beamType.CompareTo("P-A"))==0) || ((beamType.CompareTo("A-P"))==0)){
+    fRecoMode=1;
+  }
+  else if((beamType.CompareTo("A-A")) == 0 || (beamType.CompareTo("AA")) == 0){
+    fRecoMode=2;
+    if(!fgRecoParam) fgRecoParam = const_cast<AliZDCRecoParam*>(GetRecoParam());
+    if( fgRecoParam ) fgRecoParam->SetGlauberMCDist(fBeamEnergy);      
+  }    
+
+  AliCDBEntry *entry = AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase"); 
+  if (!entry) AliFatal("LHC clock-phase shift is not found in OCDB !");
+  AliLHCClockPhase *phaseLHC = (AliLHCClockPhase*)entry->GetObject();
+  fMeanPhase = phaseLHC->GetMeanPhase();
+  
+  fESDZDC = new AliESDZDC();
+  
+  AliInfo(Form("\n\n ***** ZDC reconstruction initialized for %s @ %1.0f + %1.0f GeV *****\n\n",
+       beamType.Data(), fBeamEnergy, fBeamEnergy));
   
 }
 
@@ -150,11 +225,13 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co
   }  
   
   Int_t digNentries = digitsTree->GetEntries();
-  Float_t ootDigi[kNch];
+  Float_t ootDigi[kNch]; Int_t i=0;
   // -- Reading out-of-time signals (last kNch entries) for current event
   if(fPedSubMode==1){
     for(Int_t iDigit=kNch; iDigit<digNentries; iDigit++){
-       ootDigi[iDigit] = digitsTree->GetEntry(iDigit);
+       if(i<=kNch) ootDigi[i] = digitsTree->GetEntry(iDigit);
+       else AliWarning(" Can't read more out of time values: index>kNch !!!\n");
+       i++;
     }
   }
   
@@ -188,56 +265,38 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co
     if(det == 1){ // *** ZNC
        tZN1Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
        tZN1Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
-       if(tZN1Corr[quad]<0.) tZN1Corr[quad] = 0.;
-       if(tZN1Corr[quad+5]<0.) tZN1Corr[quad+5] = 0.;
     }
     else if(det == 2){ // *** ZP1
        tZP1Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
        tZP1Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
-       if(tZP1Corr[quad]<0.) tZP1Corr[quad] = 0.;
-       if(tZP1Corr[quad+5]<0.) tZP1Corr[quad+5] = 0.;
     }
     else if(det == 3){
        if(quad == 1){      // *** ZEM1  
          dZEM1Corr[0] += (Float_t) (digit.GetADCValue(0)-ped2SubHg); 
          dZEM1Corr[1] += (Float_t) (digit.GetADCValue(1)-ped2SubLg); 
-         if(dZEM1Corr[0]<0.) dZEM1Corr[0] = 0.;
-         if(dZEM1Corr[1]<0.) dZEM1Corr[1] = 0.;
        }
        else if(quad == 2){  // *** ZEM2
          dZEM2Corr[0] += (Float_t) (digit.GetADCValue(0)-ped2SubHg); 
          dZEM2Corr[1] += (Float_t) (digit.GetADCValue(1)-ped2SubLg); 
-         if(dZEM2Corr[0]<0.) dZEM2Corr[0] = 0.;
-         if(dZEM2Corr[1]<0.) dZEM2Corr[1] = 0.;
        }
     }
     else if(det == 4){  // *** ZN2
        tZN2Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
        tZN2Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
-       if(tZN2Corr[quad]<0.) tZN2Corr[quad] = 0.;
-       if(tZN2Corr[quad+5]<0.) tZN2Corr[quad+5] = 0.;
    }
     else if(det == 5){  // *** ZP2 
        tZP2Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
        tZP2Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
-       if(tZP2Corr[quad]<0.) tZP2Corr[quad] = 0.;
-       if(tZP2Corr[quad+5]<0.) tZP2Corr[quad+5] = 0.;
     }
    }
    else{ // Reference PMs
      if(det == 1){
        sPMRef1[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
        sPMRef1[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
-       // Ch. debug
-       if(sPMRef1[0]<0.) sPMRef1[0] = 0.;
-       if(sPMRef2[1]<0.) sPMRef1[1] = 0.;
      }
      else if(det == 4){
        sPMRef2[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
        sPMRef2[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
-       // Ch. debug
-       if(sPMRef2[0]<0.) sPMRef2[0] = 0.;
-       if(sPMRef2[1]<0.) sPMRef2[1] = 0.;
      }
    }
 
@@ -253,7 +312,11 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co
   }//digits loop
  
   UInt_t counts[32];
-  for(Int_t jj=0; jj<32; jj++) counts[jj]=0;
+  Int_t  tdc[32][4];
+  for(Int_t jj=0; jj<32; jj++){
+    counts[jj]=0;
+    for(Int_t ii=0; ii<4; ii++) tdc[jj][ii]=0;
+  }
   
   Int_t  evQualityBlock[4] = {1,0,0,0};
   Int_t  triggerBlock[4] = {0,0,0,0};
@@ -264,13 +327,13 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co
   if(fRecoMode==1)
     ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
       dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, 
-      kFALSE, counts, 
+      kFALSE, counts, tdc,
       evQualityBlock,  triggerBlock,  chBlock, puBits);
   else if(fRecoMode==2)
     ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
       dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, 
-      kFALSE, counts, 
-      evQualityBlock,  triggerBlock,  chBlock, puBits);
+      kFALSE, counts, tdc,
+      evQualityBlock,  triggerBlock,  chBlock, puBits);    
 }
 
 //_____________________________________________________________________________
@@ -289,6 +352,7 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
   for(Int_t jj=0; jj<2*kNch; jj++){
      corrCoeff0[jj] =  fPedData->GetPedCorrCoeff0(jj);
      corrCoeff1[jj] =  fPedData->GetPedCorrCoeff1(jj);
+     //printf("  %d   %1.4f  %1.4f\n", jj,corrCoeff0[jj],corrCoeff1[jj]);
   }
 
   Int_t adcZN1[5], adcZN1oot[5], adcZN1lg[5], adcZN1ootlg[5];
@@ -316,21 +380,25 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
   }  
 
   Bool_t isScalerOn=kFALSE;
-  Int_t jsc=0;
-  UInt_t scalerData[32];       
-  for(Int_t k=0; k<32; k++) scalerData[k]=0;
+  Int_t jsc=0, itdc=0, iprevtdc=-1, ihittdc=0;
+  UInt_t scalerData[32];
+  Int_t tdcData[32][4];        
+  for(Int_t k=0; k<32; k++){
+    scalerData[k]=0;
+    for(Int_t i=0; i<4; i++) tdcData[k][i]=0;
+  }
+  
   
   Int_t  evQualityBlock[4] = {1,0,0,0};
   Int_t  triggerBlock[4] = {0,0,0,0};
   Int_t  chBlock[3] = {0,0,0};
   UInt_t puBits=0;
 
-  //fNRun = (Int_t) rawReader->GetRunNumber();
-  Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29;
+  Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kZDCTDCGeo=4, kPUGeo=29;
   //Int_t kTrigScales=30, kTrigHistory=31;
 
   // loop over raw data
-  rawReader->Reset();
+  //rawReader->Reset();
   AliZDCRawStream rawData(rawReader);
   while(rawData.Next()){
    
@@ -354,21 +422,36 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
       //
       // Mean pedestal value subtraction -------------------------------------------------------
       if(fPedSubMode == 0){
+       //  **** Pb-Pb data taking 2010 -> subtracting some ch. from correlation ****
        // Not interested in o.o.t. signals (ADC modules 2, 3)
+       //if(adcMod == 2 || adcMod == 3) continue;
+       //  **** Pb-Pb data taking 2011 -> subtracting only ZEM from correlation ****
+       if(det==3){
+        if(adcMod==0 || adcMod==1){
+          if(gain==0) adcZEM[quad-1] = rawData.GetADCValue();
+           else adcZEMlg[quad-1] = rawData.GetADCValue();
+        }
+        else if(adcMod==2 || adcMod==3){ 
+          if(gain==0) adcZEMoot[quad-1] = rawData.GetADCValue();
+           else adcZEMootlg[quad-1] = rawData.GetADCValue();
+        }
+       }
+       // When oot values are read the ADC modules 2, 3 can be skipped!!!
        if(adcMod == 2 || adcMod == 3) continue;
-       //
+       
+       // *************************************************************************
        if(quad != 5){ // ZDCs (not reference PTMs)
-        if(det == 1){    
+        if(det==1){    
           pedindex = quad;
           if(gain == 0) tZN1Corr[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
           else tZN1Corr[quad+5]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); 
         }
-        else if(det == 2){ 
+        else if(det==2){ 
           pedindex = quad+5;
           if(gain == 0) tZP1Corr[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
           else tZP1Corr[quad+5]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); 
         }
-        else if(det == 3){ 
+        /*else if(det == 3){ 
           pedindex = quad+9;
           if(quad==1){     
             if(gain == 0) dZEM1Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
@@ -378,7 +461,7 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
             if(gain == 0) dZEM2Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
             else dZEM2Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]); 
           }
-        }
+        }*/
         else if(det == 4){      
           pedindex = quad+12;
           if(gain == 0) tZN2Corr[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]); 
@@ -477,12 +560,25 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
    }// ADC DATA
    // ***************************** Reading Scaler
    else if(rawData.GetADCModule()==kScalerGeo){
-     if(rawData.IsScHeaderRead()==kTRUE && rawData.IsScEventGood()==kTRUE){
+     if(rawData.IsScalerWord()==kTRUE){
        isScalerOn = kTRUE;
        scalerData[jsc] = rawData.GetTriggerCount();
+       // Ch. debug
+       //printf("   Reconstructed VME Scaler: %d %d  ",jsc,scalerData[jsc]);
+       //
        jsc++;
      }
    }// VME SCALER DATA
+   // ***************************** Reading ZDC TDC
+   else if(rawData.GetADCModule()==kZDCTDCGeo && rawData.IsZDCTDCDatum()==kTRUE){
+       itdc = rawData.GetChannel(); 
+       if(itdc==iprevtdc) ihittdc++;
+       else ihittdc=0;
+       iprevtdc=itdc;
+       if(ihittdc<4) tdcData[itdc][ihittdc] = rawData.GetZDCTDCDatum();
+       // Ch. debug
+       //if(ihittdc==0) printf("   TDC%d %d  ",itdc, tdcData[itdc][ihittdc]);
+   }// ZDC TDC DATA
    // ***************************** Reading PU
    else if(rawData.GetADCModule()==kPUGeo){
      puBits = rawData.GetDetectorPattern();
@@ -510,68 +606,64 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
        //
        tZP2Corr[t] = adcZP2[t] - (corrCoeff1[t+17]*adcZP2oot[t]+corrCoeff0[t+17]);
        tZP2Corr[t+5] = adcZP2lg[t] - (corrCoeff1[t+17+kNch]*adcZP2ootlg[t]+corrCoeff0[t+17+kNch]);
-       // 0---------0 Ch. debug 0---------0
-/*       printf("\n\n ---------- Debug of pedestal subtraction from correlation ----------\n");
-       printf("\tCorrCoeff0\tCorrCoeff1\n");
-       printf(" ZN1 %d\t%1.0f\t%1.0f\n",t,corrCoeff0[t],corrCoeff1[t]);
-       printf(" ZN1lg %d\t%1.0f\t%1.0f\n",t+kNch,corrCoeff0[t+kNch],corrCoeff1[t+kNch]);
-       printf(" ZP1 %d\t%1.0f\t%1.0f\n",t+5,corrCoeff0[t+5],corrCoeff1[t+5]);
-       printf(" ZP1lg %d\t%1.0f\t%1.0f\n",t+5+kNch,corrCoeff0[t+5+kNch],corrCoeff1[t+5+kNch]);
-       printf(" ZN2 %d\t%1.0f\t%1.0f\n",t+12,corrCoeff0[t+12],corrCoeff1[t+12]);
-       printf(" ZN2lg %d\t%1.0f\t%1.0f\n",t+12+kNch,corrCoeff0[t+12+kNch],corrCoeff1[t+12+kNch]);
-       printf(" ZP2 %d\t%1.0f\t%1.0f\n",t+17,corrCoeff0[t+17],corrCoeff1[t+17]);
-       printf(" ZP2lg %d\t%1.0f\t%1.0f\n",t+17+kNch,corrCoeff0[t+17+kNch],corrCoeff1[t+17+kNch]);
-       
-       printf("ZN1 ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
-                       adcZN1[t],(corrCoeff1[t]*adcZN1oot[t]+corrCoeff0[t]),tZN1Corr[t]);
-       printf(" lg ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
-                       adcZN1lg[t],(corrCoeff1[t+kNch]*adcZN1ootlg[t]+corrCoeff0[t+kNch]),tZN1Corr[t+5]);
-       //
-       printf("ZP1 ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
-                       adcZP1[t],(corrCoeff1[t+5]*adcZP1oot[t]+corrCoeff0[t+5]),tZP1Corr[t]);
-       printf(" lg ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
-                       adcZP1lg[t],(corrCoeff1[t+5+kNch]*adcZP1ootlg[t]+corrCoeff0[t+5+kNch]),tZP1Corr[t+5]);
-       //
-       printf("ZN2 ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
-                       adcZN2[t],(corrCoeff1[t+12]*adcZN2oot[t]+corrCoeff0[t+12]),tZN2Corr[t]);
-       printf(" lg ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
-                       adcZN2lg[t],(corrCoeff1[t+12+kNch]*adcZN2ootlg[t]+corrCoeff0[t+12+kNch]),tZN2Corr[t+5]);
-       //
-       printf("ZP2 ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
-                       adcZP2[t],(corrCoeff1[t+17]*adcZP2oot[t]+corrCoeff0[t+17]),tZP2Corr[t]);
-       printf(" lg ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
-                       adcZP2lg[t],(corrCoeff1[t+17+kNch]*adcZP2ootlg[t]+corrCoeff0[t+17+kNch]),tZP2Corr[t+5]);
-*/
     }
-    dZEM1Corr[0] = adcZEM[0]   - (corrCoeff1[9]*adcZEMoot[0]+corrCoeff0[9]);
-    dZEM1Corr[1] = adcZEMlg[0] - (corrCoeff1[9+kNch]*adcZEMootlg[0]+corrCoeff0[9+kNch]);
-    dZEM2Corr[0] = adcZEM[1]   - (corrCoeff1[10]*adcZEMoot[1]+corrCoeff0[10]);
-    dZEM2Corr[1] = adcZEMlg[1] - (corrCoeff1[10+kNch]*adcZEMootlg[1]+corrCoeff0[10+kNch]);
+    dZEM1Corr[0] = adcZEM[0]   - (corrCoeff1[10]*adcZEMoot[0]+corrCoeff0[10]);
+    dZEM1Corr[1] = adcZEMlg[0] - (corrCoeff1[10+kNch]*adcZEMootlg[0]+corrCoeff0[10+kNch]);
+    dZEM2Corr[0] = adcZEM[1]   - (corrCoeff1[11]*adcZEMoot[1]+corrCoeff0[11]);
+    dZEM2Corr[1] = adcZEMlg[1] - (corrCoeff1[11+kNch]*adcZEMootlg[1]+corrCoeff0[11+kNch]);
     //
     sPMRef1[0] = pmRef[0]   - (corrCoeff1[22]*pmRefoot[0]+corrCoeff0[22]);
     sPMRef1[1] = pmReflg[0] - (corrCoeff1[22+kNch]*pmRefootlg[0]+corrCoeff0[22+kNch]);
     sPMRef2[0] = pmRef[0]   - (corrCoeff1[23]*pmRefoot[1]+corrCoeff0[23]);
     sPMRef2[1] = pmReflg[0] - (corrCoeff1[23+kNch]*pmRefootlg[1]+corrCoeff0[23+kNch]);
   }
+  if(fPedSubMode==0 && fRecoMode==2){
+    //  **** Pb-Pb data taking 2011 -> subtracting some ch. from correlation ****
+    //tZN1Corr[0] = adcZN1[0] - (corrCoeff1[0]*adcZN1oot[0]+corrCoeff0[0]);
+    //tZN1Corr[5] = adcZN1lg[0] - (corrCoeff1[kNch]*adcZN1ootlg[0]+corrCoeff0[kNch]);
+    // Ch. debug
+    //printf(" adcZN1 %d  adcZN1oot %d tZN1Corr %1.2f \n", adcZN1[0],adcZN1oot[0],tZN1Corr[0]);
+    //printf(" adcZN1lg %d  adcZN1ootlg %d tZN1Corrlg %1.2f \n", adcZN1lg[0],adcZN1ootlg[0],tZN1Corr[5]);
+    //
+    //tZP1Corr[2] = adcZP1[2] - (corrCoeff1[2+5]*adcZP1oot[2]+corrCoeff0[2+5]);
+    //tZP1Corr[2+5] = adcZP1lg[2] - (corrCoeff1[2+5+kNch]*adcZP1ootlg[2]+corrCoeff0[2+5+kNch]);
+    //
+    dZEM1Corr[0] = adcZEM[0]   - (corrCoeff1[10]*adcZEMoot[0]+corrCoeff0[10]);
+    dZEM1Corr[1] = adcZEMlg[0] - (corrCoeff1[10+kNch]*adcZEMootlg[0]+corrCoeff0[10+kNch]);
+    dZEM2Corr[0] = adcZEM[1]   - (corrCoeff1[11]*adcZEMoot[1]+corrCoeff0[11]);
+    dZEM2Corr[1] = adcZEMlg[1] - (corrCoeff1[11+kNch]*adcZEMootlg[1]+corrCoeff0[11+kNch]);
+    // *************************************************************************
+  }
+  else if(fPedSubMode==0 && fRecoMode==1){
+    //  **** p-p data taking 2011 -> temporary patch to overcome DA problem ****
+    //
+    dZEM1Corr[0] = adcZEM[0]   - meanPed[10];
+    dZEM1Corr[1] = adcZEMlg[0] - meanPed[10+kNch];
+    dZEM2Corr[0] = adcZEM[1]   - meanPed[11];
+    dZEM2Corr[1] = adcZEMlg[1] - meanPed[11+kNch];
+        // *************************************************************************
+  }
     
   if(fRecoMode==1) // p-p data
     ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
       dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, 
-      isScalerOn, scalerData, 
+      isScalerOn, scalerData, tdcData,
       evQualityBlock, triggerBlock, chBlock, puBits);
   else if(fRecoMode==2) // Pb-Pb data
-    ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
+      ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
       dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, 
-      isScalerOn, scalerData, 
+      isScalerOn, scalerData,  tdcData,
       evQualityBlock, triggerBlock, chBlock, puBits);
 }
 
 //_____________________________________________________________________________
-void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrADCZN1, 
-       Float_t* corrADCZP1, Float_t* corrADCZN2, Float_t* corrADCZP2,
-       Float_t* corrADCZEM1, Float_t* corrADCZEM2, Float_t* sPMRef1, Float_t* sPMRef2,
-       Bool_t isScalerOn, UInt_t* scaler, 
-       Int_t* evQualityBlock, Int_t* triggerBlock, Int_t* chBlock, UInt_t puBits) const
+void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, 
+       const Float_t* const corrADCZN1, const Float_t* const corrADCZP1, 
+       const Float_t* const corrADCZN2, const Float_t* const corrADCZP2,
+       const Float_t* const corrADCZEM1, const Float_t* const corrADCZEM2,
+       Float_t* sPMRef1, Float_t* sPMRef2, Bool_t isScalerOn, UInt_t* scaler, 
+       Int_t tdcData[32][4], const Int_t* const evQualityBlock, 
+       const Int_t* const triggerBlock, const Int_t* const chBlock, UInt_t puBits) const
 {
   // ****************** Reconstruct one event ******************
   
@@ -644,10 +736,14 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
      equalCoeffZP2[ji] = fTowCalibData->GetZP2EqualCoeff(ji); 
   }
   // --- Energy calibration factors ------------------------------------
-  Float_t calibEne[4];
+  Float_t calibEne[6], calibSatZNA[4], calibSatZNC[4];
   // **** Energy calibration coefficient set to 1 
   // **** (no trivial way to calibrate in p-p runs)
-  for(Int_t ij=0; ij<4; ij++) calibEne[ij] = fEnCalibData->GetEnCalib(ij);
+  for(Int_t ij=0; ij<6; ij++) calibEne[ij] = fEnCalibData->GetEnCalib(ij);
+  for(Int_t ij=0; ij<4; ij++){
+    calibSatZNA[ij] = fSatCalibData->GetZNASatCalib(ij);
+    calibSatZNC[ij] = fSatCalibData->GetZNCSatCalib(ij);
+  }
   
   // ******    Equalization of detector responses
   Float_t equalTowZN1[10], equalTowZN2[10], equalTowZP1[10], equalTowZP2[10];
@@ -677,6 +773,24 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
        equalTowZP2[0],equalTowZP2[1],equalTowZP2[2],equalTowZP2[3],equalTowZP2[4]);
   printf(" ----------------------------------------\n");*/
   
+  //  *** p-A RUN 2013 -> new calibration object
+  //      to take into account saturation in ZN PMC
+  //   -> 5th order pol. fun. to be applied BEFORE en. calibration 
+  equalTowZN1[0] = equalTowZN1[0] + calibSatZNC[0]*equalTowZN1[0]*equalTowZN1[0] +
+       calibSatZNC[1]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0] +
+       calibSatZNC[2]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0] +
+       calibSatZNC[3]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0];
+  equalTowZN2[0] = equalTowZN2[0] + calibSatZNA[0]*equalTowZN2[0]*equalTowZN2[0] +
+       calibSatZNA[1]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0] +
+       calibSatZNA[2]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0] +
+       calibSatZNA[3]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0];
+
+  // Ch. debug
+  /*printf("\n ------------- SATURATION CORRECTION -------------\n");
+  printf(" ZNC PMC %1.2f\n", equalTowZN1[0]);
+  printf(" ZNA PMC %1.2f\n", equalTowZN2[0]);
+  printf(" ----------------------------------------\n");*/
+  
   // ******    Summed response for hadronic calorimeter (SUMMED and then CALIBRATED!)
   Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0};
   for(Int_t gi=0; gi<5; gi++){
@@ -717,8 +831,8 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
   }
   //
   Float_t sumZEM[]={0,0}, calibZEM1[]={0,0}, calibZEM2[]={0,0};
-  calibZEM1[0] = corrADCZEM1[0]*calibEne[5];
-  calibZEM1[1] = corrADCZEM1[1]*calibEne[5];
+  calibZEM1[0] = corrADCZEM1[0]*calibEne[4];
+  calibZEM1[1] = corrADCZEM1[1]*calibEne[4];
   calibZEM2[0] = corrADCZEM2[0]*calibEne[5];
   calibZEM2[1] = corrADCZEM2[1]*calibEne[5];
   for(Int_t k=0; k<2; k++) sumZEM[k] = calibZEM1[k] + calibZEM2[k];
@@ -743,6 +857,7 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
   Int_t nPart=0, nPartTotLeft=0, nPartTotRight=0;
   Double_t impPar=0., impPar1=0., impPar2=0.;
   
+  Bool_t energyFlag = kFALSE;
   // create the output tree
   AliZDCReco* reco = new AliZDCReco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2, 
                   calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2, 
@@ -751,20 +866,23 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
                   nGenSpec, nGenSpecLeft, nGenSpecRight, 
                   nPart, nPartTotLeft, nPartTotRight, 
                   impPar, impPar1, impPar2,
-                  recoFlag, isScalerOn, scaler);
+                  recoFlag, energyFlag, isScalerOn, scaler, tdcData);
                  
   const Int_t kBufferSize = 4000;
   clustersTree->Branch("ZDC", "AliZDCReco", &reco, kBufferSize);
   // write the output tree
   clustersTree->Fill();
+  delete reco;
 }
 
 //_____________________________________________________________________________
 void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree, 
-       Float_t* corrADCZN1, Float_t* corrADCZP1, Float_t* corrADCZN2, Float_t* corrADCZP2,
-       Float_t* corrADCZEM1, Float_t* corrADCZEM2, Float_t* sPMRef1, Float_t* sPMRef2,
-       Bool_t isScalerOn, UInt_t* scaler, 
-       Int_t* evQualityBlock, Int_t* triggerBlock, Int_t* chBlock, UInt_t puBits) const
+       const Float_t* const corrADCZN1, const Float_t* const corrADCZP1, 
+       const Float_t* const corrADCZN2, const Float_t* const corrADCZP2,
+       const Float_t* const corrADCZEM1, const Float_t* const corrADCZEM2,
+       Float_t* sPMRef1, Float_t* sPMRef2, Bool_t isScalerOn, UInt_t* scaler, 
+       Int_t tdcData[32][4], const Int_t* const evQualityBlock, 
+       const Int_t* const triggerBlock, const Int_t* const chBlock, UInt_t puBits) const
 {
   // ****************** Reconstruct one event ******************
   // ---------------------- Setting reco flags for ESD
@@ -811,7 +929,21 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
             rFlags[3] << 3 | rFlags[2] << 2 | rFlags[1] << 1 | rFlags[0];
   // --------------------------------------------------
   
-
+  
+  // CH. debug
+/*  printf("\n*************************************************\n");
+  printf(" ReconstructEventPbPb -> values after pedestal subtraction:\n");
+  printf(" ADCZN1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       corrADCZN1[0],corrADCZN1[1],corrADCZN1[2],corrADCZN1[3],corrADCZN1[4]);
+  printf(" ADCZP1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       corrADCZP1[0],corrADCZP1[1],corrADCZP1[2],corrADCZP1[3],corrADCZP1[4]);
+  printf(" ADCZN2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       corrADCZN2[0],corrADCZN2[1],corrADCZN2[2],corrADCZN2[3],corrADCZN2[4]);
+  printf(" ADCZP2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       corrADCZP2[0],corrADCZP2[1],corrADCZP2[2],corrADCZP2[3],corrADCZP2[4]);
+  printf(" ADCZEM1 [%1.2f] ADCZEM2 [%1.2f] \n",corrADCZEM1[0],corrADCZEM2[0]);
+  printf("*************************************************\n");
+*/
   // ******    Retrieving calibration data 
   // --- Equalization coefficients ---------------------------------------------
   Float_t equalCoeffZN1[5], equalCoeffZP1[5], equalCoeffZN2[5], equalCoeffZP2[5];
@@ -822,14 +954,13 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
      equalCoeffZP2[ji] = fTowCalibData->GetZP2EqualCoeff(ji); 
   }
   // --- Energy calibration factors ------------------------------------
-  Float_t valFromOCDB[6], calibEne[6];
-  for(Int_t ij=0; ij<6; ij++){
-    valFromOCDB[ij] = fEnCalibData->GetEnCalib(ij);
-    if(ij<4){
-      if(valFromOCDB[ij]!=0) calibEne[ij] = fBeamEnergy/valFromOCDB[ij];
-      else AliWarning(" Value from OCDB for E calibration = 0 !!!\n");
-    } 
-    else calibEne[ij] = valFromOCDB[ij];
+  Float_t calibEne[6], calibSatZNA[4], calibSatZNC[4];
+  // **** Energy calibration coefficient set to 1 
+  // **** (no trivial way to calibrate in p-p runs)
+  for(Int_t ij=0; ij<6; ij++) calibEne[ij] = fEnCalibData->GetEnCalib(ij);
+  for(Int_t ij=0; ij<4; ij++){
+    calibSatZNA[ij] = fSatCalibData->GetZNASatCalib(ij);
+    calibSatZNC[ij] = fSatCalibData->GetZNCSatCalib(ij);
   }
   
   // ******    Equalization of detector responses
@@ -849,6 +980,31 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
      }
   }
   
+  // Ch. debug
+/*  printf("\n ------------- EQUALIZATION -------------\n");
+  printf(" ADCZN1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       equalTowZN1[0],equalTowZN1[1],equalTowZN1[2],equalTowZN1[3],equalTowZN1[4]);
+  printf(" ADCZP1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       equalTowZP1[0],equalTowZP1[1],equalTowZP1[2],equalTowZP1[3],equalTowZP1[4]);
+  printf(" ADCZN2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       equalTowZN2[0],equalTowZN2[1],equalTowZN2[2],equalTowZN2[3],equalTowZN2[4]);
+  printf(" ADCZP2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       equalTowZP2[0],equalTowZP2[1],equalTowZP2[2],equalTowZP2[3],equalTowZP2[4]);
+  printf(" ----------------------------------------\n");
+*/
+  
+  //  *** p-A RUN 2013 -> new calibration object
+  //      to take into account saturation in ZN PMC
+  //   -> 5th order pol. fun. to be applied BEFORE en. calibration 
+  equalTowZN1[0] = equalTowZN1[0] + calibSatZNC[0]*equalTowZN1[0]*equalTowZN1[0] +
+       calibSatZNC[1]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0] +
+       calibSatZNC[2]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0] +
+       calibSatZNC[3]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0]*equalTowZN1[0];
+  equalTowZN2[0] = equalTowZN2[0] + calibSatZNA[0]*equalTowZN2[0]*equalTowZN2[0] +
+       calibSatZNA[1]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0] +
+       calibSatZNA[2]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0] +
+       calibSatZNA[3]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0]*equalTowZN2[0];
+  
   // ******    Summed response for hadronic calorimeter (SUMMED and then CALIBRATED!)
   Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0};
   for(Int_t gi=0; gi<5; gi++){
@@ -862,6 +1018,9 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
        calibSumZN2[1] += equalTowZN2[gi+5];
        calibSumZP2[1] += equalTowZP2[gi+5];
   }
+  //
+  //fEnCalibData->Print("");
+  
   // High gain chain
   calibSumZN1[0] = calibSumZN1[0]*calibEne[0]*8.;
   calibSumZP1[0] = calibSumZP1[0]*calibEne[1]*8.;
@@ -874,9 +1033,9 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
   calibSumZP2[1] = calibSumZP2[1]*calibEne[3];
   //
   Float_t sumZEM[]={0,0}, calibZEM1[]={0,0}, calibZEM2[]={0,0};
-  calibZEM1[0] = corrADCZEM1[0]*calibEne[5]*8.;
-  calibZEM1[1] = corrADCZEM1[1]*calibEne[5];
-  calibZEM2[0] = corrADCZEM2[0]*calibEne[5]*8.;
+  calibZEM1[0] = corrADCZEM1[0]*calibEne[4];
+  calibZEM1[1] = corrADCZEM1[1]*calibEne[4];
+  calibZEM2[0] = corrADCZEM2[0]*calibEne[5];
   calibZEM2[1] = corrADCZEM2[1]*calibEne[5];
   for(Int_t k=0; k<2; k++) sumZEM[k] = calibZEM1[k] + calibZEM2[k];
     
@@ -884,28 +1043,41 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
   Float_t calibTowZN1[10], calibTowZN2[10], calibTowZP1[10], calibTowZP2[10];
   for(Int_t gi=0; gi<5; gi++){
      // High gain chain
-     calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0]*8.;
-     calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1]*8.;
-     calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2]*8.;
-     calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3]*8.;
+     calibTowZN1[gi] = equalTowZN1[gi]*2*calibEne[0]*8.;
+     calibTowZP1[gi] = equalTowZP1[gi]*2*calibEne[1]*8.;
+     calibTowZN2[gi] = equalTowZN2[gi]*2*calibEne[2]*8.;
+     calibTowZP2[gi] = equalTowZP2[gi]*2*calibEne[3]*8.;
      // Low gain chain
-     calibTowZN1[gi+5] = equalTowZN1[gi+5]*calibEne[0];
-     calibTowZP1[gi+5] = equalTowZP1[gi+5]*calibEne[1];
-     calibTowZN2[gi+5] = equalTowZN2[gi+5]*calibEne[2];
-     calibTowZP2[gi+5] = equalTowZP2[gi+5]*calibEne[3];
+     calibTowZN1[gi+5] = equalTowZN1[gi+5]*2*calibEne[0];
+     calibTowZP1[gi+5] = equalTowZP1[gi+5]*2*calibEne[1];
+     calibTowZN2[gi+5] = equalTowZN2[gi+5]*2*calibEne[2];
+     calibTowZP2[gi+5] = equalTowZP2[gi+5]*2*calibEne[3];
   }
-  
+
+  // Ch. debug
+/*  printf("\n ------------- CALIBRATION -------------\n");
+  printf(" ADCZN1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       calibTowZN1[0],calibTowZN1[1],calibTowZN1[2],calibTowZN1[3],calibTowZN1[4]);
+  printf(" ADCZP1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       calibTowZP1[0],calibTowZP1[1],calibTowZP1[2],calibTowZP1[3],calibTowZP1[4]);
+  printf(" ADCZN2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       calibTowZN2[0],calibTowZN2[1],calibTowZN2[2],calibTowZN2[3],calibTowZN2[4]);
+  printf(" ADCZP2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
+       calibTowZP2[0],calibTowZP2[1],calibTowZP2[2],calibTowZP2[3],calibTowZP2[4]);
+  printf(" ADCZEM1 [%1.2f] ADCZEM2 [%1.2f] \n",calibZEM1[0],calibZEM2[0]);
+  printf(" ----------------------------------------\n");
+*/  
   //  ******   Number of detected spectator nucleons
   Int_t nDetSpecNLeft=0, nDetSpecPLeft=0, nDetSpecNRight=0, nDetSpecPRight=0;
-  if(fBeamEnergy!=0){
+  if(fBeamEnergy>0.01){
     nDetSpecNLeft = (Int_t) (calibSumZN1[0]/fBeamEnergy);
     nDetSpecPLeft = (Int_t) (calibSumZP1[0]/fBeamEnergy);
     nDetSpecNRight = (Int_t) (calibSumZN2[0]/fBeamEnergy);
     nDetSpecPRight = (Int_t) (calibSumZP2[0]/fBeamEnergy);
   }
   else AliWarning(" ATTENTION!!! fBeamEnergy=0 -> N_spec will be ZERO!!! \n");
-  /*printf("\n\t AliZDCReconstructor -> nDetSpecNLeft %d, nDetSpecPLeft %d,"
-    " nDetSpecNRight %d, nDetSpecPRight %d\n",nDetSpecNLeft, nDetSpecPLeft, 
+  /*printf("\n\t AliZDCReconstructor -> fBeamEnergy %1.0f: nDetSpecNsideA %d, nDetSpecPsideA %d,"
+    " nDetSpecNsideC %d, nDetSpecPsideC %d\n",fBeamEnergy,nDetSpecNLeft, nDetSpecPLeft, 
     nDetSpecNRight, nDetSpecPRight);*/
   
   Int_t nGenSpec=0, nGenSpecA=0, nGenSpecC=0;
@@ -913,22 +1085,27 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
   Double_t b=0., bA=0., bC=0.;
   
   if(fIsCalibrationMB == kFALSE){
-    // ******  Reconstruction parameters ------------------ 
-    // Ch. debug
-    //fRecoParam->Print("");
-    //
-    if (!fRecoParam) fRecoParam = const_cast<AliZDCRecoParam*>(GetRecoParam()); 
-    TH2F *hZDCvsZEM  = fRecoParam->GethZDCvsZEM();
-    TH2F *hZDCCvsZEM = fRecoParam->GethZDCCvsZEM();
-    TH2F *hZDCAvsZEM = fRecoParam->GethZDCAvsZEM();
-    TH1D *hNpartDist = fRecoParam->GethNpartDist();
-    TH1D *hbDist = fRecoParam->GethbDist();    
-    Float_t ClkCenter = fRecoParam->GetClkCenter();
+   // ******   Reconstruction parameters ------------------ 
+   if(!fgRecoParam) fgRecoParam = const_cast<AliZDCRecoParam*>(GetRecoParam());
+   if(!fgRecoParam){  
+     AliError("  RecoParam object not retrieved correctly: not reconstructing ZDC event!!!");
+     return;
+   }
+   TH1D* hNpartDist = fgRecoParam->GethNpartDist();
+   TH1D*   hbDist = fgRecoParam->GethbDist();   
+   Float_t  fClkCenter = fgRecoParam->GetClkCenter();
+   if(!hNpartDist || !hbDist){  
+      AliError("Something wrong in Glauber MC histos got from AliZDCREcoParamPbPb: NO EVENT RECO FOR ZDC DATA!!!\n\n");
+      //return;
+   }
+   else{  
+    if(!fgMBCalibData) fgMBCalibData = const_cast<AliZDCMBCalib*>(GetMBCalibData()); 
+    TH2F *hZDCvsZEM  = fgMBCalibData->GethZDCvsZEM();
+    TH2F *hZDCCvsZEM = fgMBCalibData->GethZDCCvsZEM();
+    TH2F *hZDCAvsZEM = fgMBCalibData->GethZDCAvsZEM();
     //
     Double_t xHighEdge = hZDCvsZEM->GetXaxis()->GetXmax();
-    Double_t origin = xHighEdge*ClkCenter;
+    Double_t origin = xHighEdge*fClkCenter;
     // Ch. debug
     //printf("\n\n  xHighEdge %1.2f, origin %1.4f \n", xHighEdge, origin);
     //
@@ -953,16 +1130,16 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
            if(yBinCenter < (line->GetParameter(0)*xBinCenter + line->GetParameter(1))){
              countPerc += hZDCvsZEM->GetBinContent(nbinx,nbiny);
              // Ch. debug
-             /*printf(" xBinCenter  %1.3f, yBinCenter %1.0f,  countPerc %1.0f\n", 
-               xBinCenter, yBinCenter, countPerc);*/
+             //printf(" xBinCenter  %1.3f, yBinCenter %1.0f,  countPerc %1.0f\n", 
+               //xBinCenter, yBinCenter, countPerc);
            }
         }
         else{
           if(yBinCenter > (line->GetParameter(0)*xBinCenter + line->GetParameter(1))){
             countPerc += hZDCvsZEM->GetBinContent(nbinx,nbiny);
              // Ch. debug
-             /*printf(" xBinCenter  %1.3f, yBinCenter %1.0f,  countPerc %1.0f\n", 
-               xBinCenter, yBinCenter, countPerc);*/
+             //printf(" xBinCenter  %1.3f, yBinCenter %1.0f,  countPerc %1.0f\n", 
+               //xBinCenter, yBinCenter, countPerc);
           }
         }
       }
@@ -1097,7 +1274,7 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
     Double_t bFrac=0., bFracC=0., bFracA=0.;
     for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
       bFrac += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries());
-      if((1.-bFrac) < xSecPerc){
+      if(bFrac > xSecPerc){
        b = hbDist->GetBinLowEdge(ibbin);
        break;
       }
@@ -1105,15 +1282,15 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
     //
     for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
       bFracC += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries());
-      if((1.-bFracC) < xSecPercC){
+      if(bFracC > xSecPercC){
        bC = hbDist->GetBinLowEdge(ibbin);
        break;
       }
     }
     //
     for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
-      bFracA += (hbDist->GetBinContent(ibbin))/(hNpartDist->GetEntries());
-      if((1.-bFracA) < xSecPercA){
+      bFracA += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries());
+      if(bFracA > xSecPercA){
        bA = hbDist->GetBinLowEdge(ibbin);
        break;
       }
@@ -1125,58 +1302,48 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
     nGenSpecA = 416 - nPartA;
     if(nGenSpec>416) nGenSpec=416; if(nGenSpec<0) nGenSpec=0;
     if(nGenSpecC>416) nGenSpecC=416; if(nGenSpecC<0) nGenSpecC=0;
-    if(nGenSpecA>416) nGenSpecA=416; if(nGenSpecA<0) nGenSpecA=0;
-  
-    //  Ch. debug
-    /*printf("\n\t AliZDCReconstructor -> calibSumZN1[0] %1.0f, calibSumZP1[0] %1.0f,"
-        "  calibSumZN2[0] %1.0f, calibSumZP2[0] %1.0f, corrADCZEMHG %1.0f\n", 
-        calibSumZN1[0],calibSumZP1[0],calibSumZN2[0],calibSumZP2[0],corrADCZEMHG);
-    printf("\t AliZDCReconstructor -> nGenSpecLeft %d nGenSpecRight %d\n", 
-        nGenSpecLeft, nGenSpecRight);
-    printf("\t AliZDCReconstructor ->  NpartL %d,  NpartR %d,  b %1.2f fm\n\n",nPartTotLeft, nPartTotRight, impPar);
-    */
-  
+    if(nGenSpecA>416) nGenSpecA=416; if(nGenSpecA<0) nGenSpecA=0;    
+    
+    delete line; 
     delete lineC;  delete lineA;
-
+   }
   } // ONLY IF fIsCalibrationMB==kFALSE
   
+  Bool_t energyFlag = kTRUE;  
   AliZDCReco* reco = new AliZDCReco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2, 
                  calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2, 
                  calibZEM1, calibZEM2, sPMRef1, sPMRef2,
                  nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight, 
                  nGenSpec, nGenSpecA, nGenSpecC, 
                  nPart, nPartA, nPartC, b, bA, bC,
-                 recoFlag, isScalerOn, scaler);
+                 recoFlag, energyFlag, isScalerOn, scaler, tdcData);
                    
   const Int_t kBufferSize = 4000;
   clustersTree->Branch("ZDC", "AliZDCReco", &reco, kBufferSize);
-  reco->Print("");
+  //reco->Print("");
   // write the output tree
   clustersTree->Fill();
+  delete reco;
 }
 
-//_____________________________________________________________________________
-void AliZDCReconstructor::BuildRecoParam(Float_t ZDCC, Float_t ZDCA, Float_t ZEM) const
-{
-  // Calculate RecoParam object for Pb-Pb data
-  (fRecoParam->GethZDCvsZEM())->Fill(ZDCC+ZDCA, ZEM);
-  (fRecoParam->GethZDCCvsZEM())->Fill(ZDCC, ZEM);
-  (fRecoParam->GethZDCAvsZEM())->Fill(ZDCA, ZEM);
-}
 
 //_____________________________________________________________________________
 void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd) const
 {
   // fill energies and number of participants to the ESD
 
+  // Retrieving TDC calibration data  
+  // Parameters for TDC centering around zero
+  int const knTDC = 6;
+  Float_t tdcOffset[knTDC];
+  for(Int_t jj=0; jj<knTDC; jj++) tdcOffset[jj] = fTDCCalibData->GetMeanTDC(jj);
+  //fTDCCalibData->Print("");
+
   AliZDCReco reco;
   AliZDCReco* preco = &reco;
   clustersTree->SetBranchAddress("ZDC", &preco);
-
   clustersTree->GetEntry(0);
   //
-  AliESDZDC * esdzdc = esd->GetESDZDC();
   Float_t tZN1Ene[5], tZN2Ene[5], tZP1Ene[5], tZP2Ene[5];
   Float_t tZN1EneLR[5], tZN2EneLR[5], tZP1EneLR[5], tZP2EneLR[5];
   for(Int_t i=0; i<5; i++){
@@ -1191,15 +1358,15 @@ void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd)
      tZP2EneLR[i] = reco.GetZP2LREnTow(i);
   }
   //
-  esdzdc->SetZN1TowerEnergy(tZN1Ene);
-  esdzdc->SetZN2TowerEnergy(tZN2Ene);
-  esdzdc->SetZP1TowerEnergy(tZP1Ene);
-  esdzdc->SetZP2TowerEnergy(tZP2Ene);
+  fESDZDC->SetZN1TowerEnergy(tZN1Ene);
+  fESDZDC->SetZN2TowerEnergy(tZN2Ene);
+  fESDZDC->SetZP1TowerEnergy(tZP1Ene);
+  fESDZDC->SetZP2TowerEnergy(tZP2Ene);
   //
-  esdzdc->SetZN1TowerEnergyLR(tZN1EneLR);
-  esdzdc->SetZN2TowerEnergyLR(tZN2EneLR);
-  esdzdc->SetZP1TowerEnergyLR(tZP1EneLR);
-  esdzdc->SetZP2TowerEnergyLR(tZP2EneLR);
+  fESDZDC->SetZN1TowerEnergyLR(tZN1EneLR);
+  fESDZDC->SetZN2TowerEnergyLR(tZN2EneLR);
+  fESDZDC->SetZP1TowerEnergyLR(tZP1EneLR);
+  fESDZDC->SetZP2TowerEnergyLR(tZP2EneLR);
   // 
   Int_t nPart  = reco.GetNParticipants();
   Int_t nPartA = reco.GetNPartSideA();
@@ -1208,18 +1375,61 @@ void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd)
   Double_t bA = reco.GetImpParSideA();
   Double_t bC = reco.GetImpParSideC();
   UInt_t recoFlag = reco.GetRecoFlag();
-  //
-  esd->SetZDC(reco.GetZN1HREnergy(), reco.GetZP1HREnergy(), reco.GetZEM1HRsignal(), 
-             reco.GetZEM2HRsignal(), reco.GetZN2HREnergy(), reco.GetZP2HREnergy(), 
-             nPart, nPartA, nPartC, b, bA, bC, recoFlag);
+  
+  fESDZDC->SetZDC(reco.GetZN1HREnergy(), reco.GetZP1HREnergy(), 
+       reco.GetZEM1HRsignal(), reco.GetZEM2HRsignal(), 
+       reco.GetZN2HREnergy(), reco.GetZP2HREnergy(), 
+       nPart, nPartA, nPartC, b, bA, bC, recoFlag);
   
   // Writing ZDC scaler for cross section calculation
   // ONLY IF the scaler has been read during the event
   if(reco.IsScalerOn()==kTRUE){
     UInt_t counts[32];
     for(Int_t jk=0; jk<32; jk++) counts[jk] = reco.GetZDCScaler(jk);
-    esd->SetZDCScaler(counts);
+    fESDZDC->SetZDCScaler(counts);
+  }    
+  
+  Int_t tdcValues[32][4] = {{0,}}; 
+  Float_t tdcCorrected[32][4] = {{9999.,}};
+  for(Int_t jk=0; jk<32; jk++){
+    for(Int_t lk=0; lk<4; lk++){
+      tdcValues[jk][lk] = reco.GetZDCTDCData(jk, lk);
+      //
+      if(jk==8 && TMath::Abs(tdcValues[jk][lk])>1e-09)      fESDZDC->SetZEM1TDChit(kTRUE);
+      else if(jk==9 && TMath::Abs(tdcValues[jk][lk])>1e-09) fESDZDC->SetZEM2TDChit(kTRUE);
+      else if(jk==10 && TMath::Abs(tdcValues[jk][lk])>1e-09) fESDZDC->SetZNCTDChit(kTRUE);
+      else if(jk==11 && TMath::Abs(tdcValues[jk][lk])>1e-09) fESDZDC->SetZPCTDChit(kTRUE);
+      else if(jk==12 && TMath::Abs(tdcValues[jk][lk])>1e-09) fESDZDC->SetZNATDChit(kTRUE);
+      else if(jk==13 && TMath::Abs(tdcValues[jk][lk])>1e-09) fESDZDC->SetZPATDChit(kTRUE);
+      //Ch debug
+      //if((jk>=8 && jk<=13 && lk==0) || jk==15) printf(" *** ZDC: tdc%d =  %d = %f ns \n",jk,tdcValues[jk][lk],0.025*tdcValues[jk][lk]);
+    }
+  }
+  
+  // Writing TDC data into ZDC ESDs
+  // 4/2/2011 -> Subtracting L0 (tdcValues[15]) instead of ADC gate 
+  // we try to keep the TDC oscillations as low as possible!
+  for(Int_t jk=0; jk<32; jk++){
+    for(Int_t lk=0; lk<4; lk++){
+      if(tdcValues[jk][lk]!=0.){
+        // Feb2013 _-> TDC correct entry is there ONLY IF tdc has a hit!
+        if(TMath::Abs(tdcValues[jk][lk])>1e-09){
+          tdcCorrected[jk][lk] = 0.025*(tdcValues[jk][lk]-tdcValues[15][0])+fMeanPhase;
+           // Sep 2011: TDC ch. from 8 to 13 centered around 0 using OCDB 
+          if(jk>=8 && jk<=13) tdcCorrected[jk][lk] =  tdcCorrected[jk][lk] - tdcOffset[jk-8];
+          //Ch. debug
+          //if(jk>=8 && jk<=13) printf(" *** tdcOffset%d %f  tdcCorr%d %f \n",jk,tdcOffset[jk-8],tdcCorrected[jk][lk]);
+        }
+      }
+    }
   }
+
+  fESDZDC->SetZDCTDCData(tdcValues);
+  fESDZDC->SetZDCTDCCorrected(tdcCorrected);
+  fESDZDC->AliESDZDC::SetBit(AliESDZDC::kCorrectedTDCFilled, reco.GetEnergyFlag());
+  fESDZDC->AliESDZDC::SetBit(AliESDZDC::kEnergyCalibratedSignal, kTRUE);
+  
+  if(esd) esd->SetZDCData(fESDZDC);
 }
 
 //_____________________________________________________________________________
@@ -1255,7 +1465,8 @@ AliZDCPedestals* AliZDCReconstructor::GetPedestalData() const
   // Getting pedestal calibration object for ZDC set
 
   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/Pedestals");
-  if(!entry) AliFatal("No calibration data loaded!");  
+  if(!entry) AliFatal("No calibration data loaded!");
+  entry->SetOwner(kFALSE);
 
   AliZDCPedestals *calibdata = dynamic_cast<AliZDCPedestals*>  (entry->GetObject());
   if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
@@ -1271,6 +1482,7 @@ AliZDCEnCalib* AliZDCReconstructor::GetEnergyCalibData() const
 
   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/EnergyCalib");
   if(!entry) AliFatal("No calibration data loaded!");  
+  entry->SetOwner(kFALSE);
 
   AliZDCEnCalib *calibdata = dynamic_cast<AliZDCEnCalib*> (entry->GetObject());
   if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
@@ -1279,6 +1491,22 @@ AliZDCEnCalib* AliZDCReconstructor::GetEnergyCalibData() const
 }
 
 //_____________________________________________________________________________
+AliZDCSaturationCalib* AliZDCReconstructor::GetSaturationCalibData() const
+{
+
+  // Getting energy and equalization calibration object for ZDC set
+
+  AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/SaturationCalib");
+  if(!entry) AliFatal("No calibration data loaded!");  
+  entry->SetOwner(kFALSE);
+
+  AliZDCSaturationCalib *calibdata = dynamic_cast<AliZDCSaturationCalib*> (entry->GetObject());
+  if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
+
+  return calibdata;
+}
+
+//_____________________________________________________________________________
 AliZDCTowerCalib* AliZDCReconstructor::GetTowerCalibData() const
 {
 
@@ -1286,6 +1514,7 @@ AliZDCTowerCalib* AliZDCReconstructor::GetTowerCalibData() const
 
   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/TowerCalib");
   if(!entry) AliFatal("No calibration data loaded!");  
+  entry->SetOwner(kFALSE);
 
   AliZDCTowerCalib *calibdata = dynamic_cast<AliZDCTowerCalib*> (entry->GetObject());
   if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
@@ -1294,33 +1523,33 @@ AliZDCTowerCalib* AliZDCReconstructor::GetTowerCalibData() const
 }
 
 //_____________________________________________________________________________
-AliZDCRecoParampp* AliZDCReconstructor::GetppRecoParamFromOCDB() const
+AliZDCMBCalib* AliZDCReconstructor::GetMBCalibData() const
 {
 
-  // Getting reconstruction parameters from OCDB
+  // Getting energy and equalization calibration object for ZDC set
 
-  AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/RecoParampp");
-  if(!entry) AliFatal("No RecoParam data found in OCDB!");  
-  
-  AliZDCRecoParampp *param = dynamic_cast<AliZDCRecoParampp*> (entry->GetObject());
-  if(!param)  AliFatal("No RecoParam object in OCDB entry!");
-  
-  return param;
+  AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/MBCalib");
+  if(!entry) AliFatal("No calibration data loaded!");  
+  entry->SetOwner(kFALSE);
+
+  AliZDCMBCalib *calibdata = dynamic_cast<AliZDCMBCalib*> (entry->GetObject());
+  if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
 
+  return calibdata;
 }
 
 //_____________________________________________________________________________
-AliZDCRecoParamPbPb* AliZDCReconstructor::GetPbPbRecoParamFromOCDB() const
+AliZDCTDCCalib* AliZDCReconstructor::GetTDCCalibData() const
 {
 
-  // Getting reconstruction parameters from OCDB
+  // Getting TDC object for ZDC 
 
-  AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/RecoParamPbPb");
-  if(!entry) AliFatal("No RecoParam data found in OCDB!");  
-  
-  AliZDCRecoParamPbPb *param = dynamic_cast<AliZDCRecoParamPbPb*> (entry->GetObject());
-  if(!param)  AliFatal("No RecoParam object in OCDB entry!");
-  
-  return param;
+  AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/TDCCalib");
+  if(!entry) AliFatal("No calibration data loaded!");  
+  entry->SetOwner(kFALSE);
 
+  AliZDCTDCCalib *calibdata = dynamic_cast<AliZDCTDCCalib*> (entry->GetObject());
+  if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
+
+  return calibdata;
 }