Updating eta storing
[u/mrichter/AliRoot.git] / ZDC / AliZDCReconstructor.cxx
index 5f950f8..336dce6 100644 (file)
@@ -33,7 +33,6 @@
 #include <TMap.h>
 
 #include "AliRawReader.h"
-#include "AliGRPObject.h"
 #include "AliESDEvent.h"
 #include "AliESDZDC.h"
 #include "AliZDCDigit.h"
 #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
-
 }
 
 
@@ -72,87 +79,116 @@ 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
-  
-  if(fRecoMode==0 && fBeamEnergy==0.){
-    // Initialization of the GRP entry 
-    AliCDBEntry*  entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
-    AliGRPObject* grpData = 0x0;
-    if(entry){
-      TMap* m = dynamic_cast<TMap*>(entry->GetObject());  // old GRP entry
-      if(m){
-        //m->Print();
-        grpData = new AliGRPObject();
-        grpData->ReadValuesFromMap(m);
-      }
-      else{
-        grpData = dynamic_cast<AliGRPObject*>(entry->GetObject());  // new GRP entry
-      }
-      entry->SetOwner(0);
-      AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
-    }
-    if(!grpData) AliError("No GRP entry found in OCDB!");
-  
-    TString runType = grpData->GetRunType();
-    if(runType==AliGRPObject::GetInvalidString()){
-      AliWarning("GRP/GRP/Data entry:  missing value for the run type ! Using UNKNOWN");
-      runType = "UNKNOWN";
-    }
-    if((runType.CompareTo("CALIBRATION_MB")) == 0){
-      fIsCalibrationMB = kTRUE;
-    }
+  // Setting reconstruction parameters
     
-    TString beamType = grpData->GetBeamType();
-    if(beamType==AliGRPObject::GetInvalidString()){
-      AliWarning("GRP/GRP/Data entry:  missing value for the beam energy !");
-      AliError("\t ZDC does not reconstruct event 4 UNKNOWN beam type\n");
-      return;
-    }
-    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;
-      if(fIsCalibrationMB == kTRUE){ 
-        fRecoParam = new AliZDCRecoParamPbPb();
-        //
-        TH2F* hZDCvsZEM = new TH2F("hZDCvsZEM","hZDCvsZEM",100,0.,10.,100,0.,1000.);
-        hZDCvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCvsZEM->SetYTitle("E_{ZDC} (TeV)");
-        fRecoParam->SetZDCvsZEM(hZDCvsZEM);
-        //
-        TH2F* hZDCCvsZEM = new TH2F("hZDCCvsZEM","hZDCCvsZEM",100,0.,10.,100,0.,500.);
-        hZDCCvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCCvsZEM->SetYTitle("E_{ZDCC} (TeV)");
-        fRecoParam->SetZDCCvsZEM(hZDCCvsZEM);
-        //
-        TH2F* hZDCAvsZEM = new TH2F("hZDCAvsZEM","hZDCAvsZEM",100,0.,10.,100,0.,500.);
-        hZDCAvsZEM->SetXTitle("E_{ZEM} (TeV)"); hZDCAvsZEM->SetYTitle("E_{ZDCA} (TeV)"); 
-        fRecoParam->SetZDCAvsZEM(hZDCAvsZEM);
-        //
-       AliInfo("\n ***** CALIBRATION_MB data -> building AliZDCRecoParamPbPb object *****");
-      }
-    }
+  TString runType = GetRunInfo()->GetRunType();
+  if((runType.CompareTo("CALIBRATION_MB")) == 0){
+    fIsCalibrationMB = kTRUE;
+  }
     
-    fBeamEnergy = grpData->GetBeamEnergy();
-    if(fBeamEnergy==AliGRPObject::GetInvalidFloat()){
-      AliWarning("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0.");
-      fBeamEnergy = 0.;
-    }
+  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 || (runType.CompareTo("CALIBRATION_BC"))==0)){
+    fRecoMode=1;
+  }
+  /*else if((beamType.CompareTo("UNKNOWN"))==0){
+    AliError("\t UNKNOWN beam type\n");
+    return;
+  }*/
     
-    if(fIsCalibrationMB==kFALSE)  
-      printf("\n\n ***** ZDC reconstruction initialized for %s @ %1.0f GeV *****\n\n",beamType.Data(), fBeamEnergy);
+  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("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();
+  // 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)  
+    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{
-    AliError(" ATTENTION!!!!!! No beam type nor beam energy has been set!!!!!!\n");
+  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));
   
 }
 
@@ -170,8 +206,8 @@ void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) co
   // Parameters pedestal subtraction through correlation with out-of-time signals
   Float_t corrCoeff0[2*kNch], corrCoeff1[2*kNch];
   for(Int_t jj=0; jj<2*kNch; jj++){
-     corrCoeff0[jj] =  fPedData->GetPedCorrCoeff0(jj);
-     corrCoeff1[jj] =  fPedData->GetPedCorrCoeff1(jj);
+     corrCoeff0[jj] = fPedData->GetPedCorrCoeff0(jj);
+     corrCoeff1[jj] = fPedData->GetPedCorrCoeff1(jj);
   }
 
   // get digits
@@ -189,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++;
     }
   }
   
@@ -227,105 +265,75 @@ 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.;
-       // Ch. debug
-       //printf("\t pedindex %d tZN1Corr[%d] = %1.0f tZN1Corr[%d] = %1.0f", 
-       //      pedindex, quad, tZN1Corr[quad], quad+5, tZN1Corr[quad+5]);
     }
     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.;
-       // Ch. debug
-       //printf("\t pedindex %d tZP1Corr[%d] = %1.0f tZP1Corr[%d] = %1.0f", 
-       //      pedindex, quad, tZP1Corr[quad], quad+5, tZP1Corr[quad+5]);
     }
     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.;
-         // Ch. debug
-         //printf("\t pedindex %d tZEM1Corr[%d] = %1.0f tZEM1Corr[%d] = %1.0f", 
-         //    pedindex, quad, tZEM1Corr[quad], quad+1, tZEM1Corr[quad+1]);
        }
        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.;
-         // Ch. debug
-         //printf("\t pedindex %d tZEM2Corr[%d] = %1.0f tZEM2Corr[%d] = %1.0f", 
-         //    pedindex, quad, tZEM2Corr[quad], quad+1, tZEM2Corr[quad+1]);
        }
     }
     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.;
-       // Ch. debug
-       //printf("\t pedindex %d tZN2Corr[%d] = %1.0f tZN2Corr[%d] = %1.0f\n", 
-       //      pedindex, quad, tZN2Corr[quad], quad+5, tZN2Corr[quad+5]);
-    }
+   }
     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.;
-       // Ch. debug
-       //printf("\t pedindex %d tZP2Corr[%d] = %1.0f tZP2Corr[%d] = %1.0f\n", 
-       //      pedindex, quad, tZP2Corr[quad], quad+5, tZP2Corr[quad+5]);
     }
    }
    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.;
      }
    }
 
    // Ch. debug
-   /*printf(" - AliZDCReconstructor -> digit #%d det %d quad %d pedHG %1.0f pedLG %1.0f\n",
+   /*printf("AliZDCReconstructor: digit #%d det %d quad %d pedHG %1.0f pedLG %1.0f\n",
         iDigit, det, quad, ped2SubHg, ped2SubLg);
-   printf("   HGChain -> RawDig %d DigCorr %1.2f\n", digit.GetADCValue(0), digit.GetADCValue(0)-ped2SubHg); 
-   printf("   LGChain -> RawDig %d DigCorr %1.2f\n", digit.GetADCValue(1), digit.GetADCValue(1)-ped2SubLg); 
-   */
+   printf(" -> pedindex %d\n", pedindex);
+   printf("   HGChain -> RawDig %d DigCorr %1.2f", 
+       digit.GetADCValue(0), digit.GetADCValue(0)-ped2SubHg); 
+   printf("   LGChain -> RawDig %d DigCorr %1.2f\n", 
+       digit.GetADCValue(1), digit.GetADCValue(1)-ped2SubLg);*/ 
+   
   }//digits loop
  
-  
-  // If CALIBRATION_MB run build the RecoParam object 
-  if(fIsCalibrationMB){
-    Float_t ZDCC=0., ZDCA=0., ZEM=0;
-    ZEM += dZEM1Corr[0] + dZEM2Corr[0];
-    for(Int_t jkl=0; jkl<5; jkl++){
-       ZDCC += tZN1Corr[jkl] + tZP1Corr[jkl];
-       ZDCA += tZN2Corr[jkl] + tZP2Corr[jkl];
-    }
-    // Using energies in TeV in fRecoParam object
-    BuildRecoParam(ZDCC/1000., ZDCA/1000., ZEM/1000.);
+  UInt_t counts[32];
+  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;
   }
-  Bool_t recFlag1 = kFALSE, recFlag2 = kFALSE, recFlag3 = kFALSE;
+  
+  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;
+  
   // reconstruct the event
   if(fRecoMode==1)
     ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
-      dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, recFlag1, recFlag2, recFlag3);
+      dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, 
+      kFALSE, counts, tdc,
+      evQualityBlock,  triggerBlock,  chBlock, puBits);
   else if(fRecoMode==2)
     ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
-      dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, recFlag1, recFlag2, recFlag3);
+      dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, 
+      kFALSE, counts, tdc,
+      evQualityBlock,  triggerBlock,  chBlock, puBits);    
 }
 
 //_____________________________________________________________________________
@@ -344,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];
@@ -363,7 +372,6 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
     }
   }
   
-  // loop over raw data
   Float_t tZN1Corr[10], tZP1Corr[10], tZN2Corr[10], tZP2Corr[10]; 
   Float_t dZEM1Corr[2], dZEM2Corr[2], sPMRef1[2], sPMRef2[2]; 
   for(Int_t i=0; i<10; i++){
@@ -371,20 +379,40 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
      if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = sPMRef1[i] = sPMRef2[i] = 0.;
   }  
 
-  //fNRun = (Int_t) rawReader->GetRunNumber();
-  Bool_t chOff=kFALSE, isUndflw=kFALSE, isOvflw=kFALSE;
-  //
-  rawReader->Reset();
+  Bool_t isScalerOn=kFALSE;
+  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;
+
+  Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kZDCTDCGeo=4, kPUGeo=29;
+  //Int_t kTrigScales=30, kTrigHistory=31;
+
+  // loop over raw data
+  //rawReader->Reset();
   AliZDCRawStream rawData(rawReader);
   while(rawData.Next()){
-   if(rawData.IsCalibration() == kFALSE){ // Reading ADCs
-    //printf(" **** Reading ADC raw data **** \n");
+   
+   // ***************************** Reading ADCs
+   if((rawData.GetADCModule()>=kFirstADCGeo) && (rawData.GetADCModule()<=kLastADCGeo)){    
+    //printf(" **** Reading ADC raw data from module %d **** \n",rawData.GetADCModule());
     //
-    if(rawData.GetNChannelsOn() < 48 ) chOff=kTRUE;
-    if((rawData.IsADCDataWord()) && (rawData.IsOverflow() == kTRUE))  isUndflw=kTRUE;
-    if((rawData.IsADCDataWord()) && (rawData.IsUnderflow() == kTRUE)) isOvflw=kTRUE;
-
-    if((rawData.IsADCDataWord()) && (isUndflw==kFALSE) && (isOvflw==kFALSE)){
+    if((rawData.IsADCDataWord()) && (rawData.GetNChannelsOn()<48))    chBlock[0] = kTRUE;
+    if((rawData.IsADCDataWord()) && (rawData.IsOverflow() == kTRUE))  chBlock[1] = kTRUE;
+    if((rawData.IsADCDataWord()) && (rawData.IsUnderflow() == kTRUE)) chBlock[2] = kTRUE;
+    if((rawData.IsADCDataWord()) && (rawData.IsADCEventGood() == kTRUE)) evQualityBlock[0] = kTRUE;
+    
+    if((rawData.IsADCDataWord()) && (rawData.IsUnderflow()==kFALSE) 
+        && (rawData.IsOverflow()==kFALSE) && (rawData.IsADCEventGood()==kTRUE)){
      
       Int_t adcMod = rawData.GetADCModule();
       Int_t det = rawData.GetSector(0);
@@ -394,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]); 
@@ -418,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]); 
@@ -434,19 +477,20 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
          pedindex = (det-1)/3 + 22;
          if(det == 1){
            if(gain==0) sPMRef1[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
-        else sPMRef1[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
+        else sPMRef1[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
          }
          else if(det == 4){
            if(gain==0) sPMRef2[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
-          else sPMRef2[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
+          else sPMRef2[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
          }
        }
        // Ch. debug
-       /*printf(" -> AliZDCReconstructor: det %d quad %d res %d -> Pedestal[%d] %1.0f\n", 
-         det,quad,gain, pedindex, meanPed[pedindex]);
-       printf(" -> AliZDCReconstructor: RawADC %1.0f ADCCorr %1.0f\n", 
-         rawData.GetADCValue(), rawData.GetADCValue()-meanPed[pedindex]);*/
-        
+       /*if(gain==0){
+         printf(" AliZDCReconstructor: det %d quad %d res %d -> Pedestal[%d] %1.0f", 
+           det,quad,gain, pedindex, meanPed[pedindex]);
+         printf("   RawADC %d ADCCorr %1.0f\n", 
+           rawData.GetADCValue(), rawData.GetADCValue()-meanPed[pedindex]);
+       }*/ 
       }// mean pedestal subtraction
       // Pedestal subtraction from correlation ------------------------------------------------
       else if(fPedSubMode == 1){
@@ -510,12 +554,43 @@ void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTr
        }
       } // pedestal subtraction from correlation
       // Ch. debug
-      //printf("\t AliZDCReconstructor - det %d quad %d res %d -> Ped[%d] = %1.0f\n", 
-      //  det,quad,gain, pedindex, meanPed[pedindex]);
+      /*printf("\t AliZDCReconstructor: det %d quad %d res %d -> Ped[%d] = %1.0f\n", 
+        det,quad,gain, pedindex, meanPed[pedindex]);*/
     }//IsADCDataWord
-   }// Not raw data from calibration run!
-   else{
+   }// ADC DATA
+   // ***************************** Reading Scaler
+   else if(rawData.GetADCModule()==kScalerGeo){
+     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();
+   }
+    // ***************************** Reading trigger history
+   else if(rawData.IstriggerHistoryWord()==kTRUE){
+     triggerBlock[0] = rawData.IsCPTInputEMDTrigger();
+     triggerBlock[1] = rawData.IsCPTInputSemiCentralTrigger();
+     triggerBlock[2] = rawData.IsCPTInputCentralTrigger();
+     triggerBlock[3] = rawData.IsCPTInputMBTrigger();
    }
+  
   }//loop on raw data
   
   if(fPedSubMode==1){
@@ -531,97 +606,125 @@ 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 CALIBRATION_MB run build the RecoParam object 
-  if(fIsCalibrationMB){
-    Float_t ZDCC=0., ZDCA=0., ZEM=0;
-    ZEM += dZEM1Corr[0] + dZEM2Corr[0];
-    for(Int_t jkl=0; jkl<5; jkl++){
-       ZDCC += tZN1Corr[jkl] + tZP1Corr[jkl];
-       ZDCA += tZN2Corr[jkl] + tZP2Corr[jkl];
-    }
-    BuildRecoParam(ZDCC/100., ZDCA/100., ZEM/100.);
+  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]);
+    // *************************************************************************
   }
-  // reconstruct the event
-  else{
-    if(fRecoMode==1) // p-p data
-      ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
-        dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, chOff, isUndflw, isOvflw);
-    else if(fRecoMode==2) // Pb-Pb data
-      ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
-        dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, chOff, isUndflw, isOvflw);
+  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, tdcData,
+      evQualityBlock, triggerBlock, chBlock, puBits);
+  else if(fRecoMode==2) // Pb-Pb data
+      ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr, 
+      dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2, 
+      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 channelsOff, Bool_t chUnderflow, Bool_t chOverflow) 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 ******************
+  
+  // CH. debug
+  /*printf("\n*************************************************\n");
+  printf(" ReconstructEventpp -> 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");*/
     
-  // ---- Setting reco flags
-  UInt_t recoFlag=0;
+  // ---------------------- Setting reco flags for ESD
   UInt_t rFlags[32];
   for(Int_t ifl=0; ifl<32; ifl++) rFlags[ifl]=0;
-
-  if(corrADCZN2[0]>fSignalThreshold)  rFlags[0] = 0x1;
-  if(corrADCZP2[0]>fSignalThreshold)  rFlags[1] = 0x1;
-  if(corrADCZEM1[0]>fSignalThreshold) rFlags[2] = 0x1;
-  if(corrADCZEM2[0]>fSignalThreshold) rFlags[3] = 0x1;
-  if(corrADCZN1[0]>fSignalThreshold)  rFlags[4] = 0x1;
-  if(corrADCZP1[0]>fSignalThreshold)  rFlags[5] = 0x1;
+  
+  if(evQualityBlock[0] == 1) rFlags[31] = 0x0;
+  else rFlags[31] = 0x1;
   //
-  if(channelsOff==kTRUE)   rFlags[8] = 0x1;
-  if(chUnderflow == kTRUE) rFlags[9] = 0x1;
-  if(chOverflow==kTRUE)    rFlags[10] = 0x1;
-  recoFlag = rFlags[10] << 10 | rFlags[9] << 9 | rFlags[8] << 8 |
-             rFlags[5] << 5 | rFlags[4] << 4 | rFlags[3] << 3 |
-             rFlags[2] << 2 | rFlags[1] << 1 | rFlags[0];
+  if(evQualityBlock[1] == 1) rFlags[30] = 0x1;
+  if(evQualityBlock[2] == 1) rFlags[29] = 0x1;
+  if(evQualityBlock[3] == 1) rFlags[28] = 0x1;
+
+  if(triggerBlock[0] == 1) rFlags[27] = 0x1;
+  if(triggerBlock[1] == 1) rFlags[26] = 0x1;
+  if(triggerBlock[2] == 1) rFlags[25] = 0x1;
+  if(triggerBlock[3] == 1) rFlags[24] = 0x1;
+  
+  if(chBlock[0] == 1) rFlags[18] = 0x1;
+  if(chBlock[1] == 1) rFlags[17] = 0x1;
+  if(chBlock[2] == 1) rFlags[16] = 0x1;
+  
+  
+  rFlags[13] = puBits & 0x00000020;
+  rFlags[12] = puBits & 0x00000010;
+  rFlags[11] = puBits & 0x00000080;
+  rFlags[10] = puBits & 0x00000040;
+  rFlags[9]  = puBits & 0x00000020;
+  rFlags[8]  = puBits & 0x00000010;
+  
+  if(corrADCZP1[0]>fSignalThreshold)  rFlags[5] = 0x1;
+  if(corrADCZN1[0]>fSignalThreshold)  rFlags[4] = 0x1;
+  if(corrADCZEM2[0]>fSignalThreshold) rFlags[3] = 0x1;
+  if(corrADCZEM1[0]>fSignalThreshold) rFlags[2] = 0x1;
+  if(corrADCZP2[0]>fSignalThreshold)  rFlags[1] = 0x1;
+  if(corrADCZN2[0]>fSignalThreshold)  rFlags[0] = 0x1;
+
+  UInt_t recoFlag = rFlags[31] << 31 | rFlags[30] << 30 | rFlags[29] << 29 | rFlags[28] << 28 |
+             rFlags[27] << 27 | rFlags[26] << 26 | rFlags[25] << 25 | rFlags[24] << 24 |
+            0x0 << 23 | 0x0 << 22 | 0x0 << 21 | 0x0 << 20 |
+            0x0 << 19 | rFlags[18] << 18 |  rFlags[17] << 17 |  rFlags[16] << 16 |
+            0x0 << 15 | 0x0 << 14 | rFlags[13] << 13 | rFlags[12] << 12 | 
+             rFlags[11] << 11 |rFlags[10] << 10 | rFlags[9] << 9 | rFlags[8] << 8 |
+            0x0 << 7 | 0x0 << 6 | rFlags[5] << 5 | rFlags[4] << 4 | 
+            rFlags[3] << 3 | rFlags[2] << 2 | rFlags[1] << 1 | rFlags[0];
+  // --------------------------------------------------
 
   // ******    Retrieving calibration data 
   // --- Equalization coefficients ---------------------------------------------
@@ -633,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];
@@ -654,6 +761,35 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
        equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi-5];
      }
   }
+  // 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];
+
+  // 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};
@@ -669,10 +805,10 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
        calibSumZP2[1] += equalTowZP2[gi+5];
   }
   // High gain chain
-  calibSumZN1[0] = calibSumZN1[0]*calibEne[0]/8.;
-  calibSumZP1[0] = calibSumZP1[0]*calibEne[1]/8.;
-  calibSumZN2[0] = calibSumZN2[0]*calibEne[2]/8.;
-  calibSumZP2[0] = calibSumZP2[0]*calibEne[3]/8.;
+  calibSumZN1[0] = calibSumZN1[0]*calibEne[0];
+  calibSumZP1[0] = calibSumZP1[0]*calibEne[1];
+  calibSumZN2[0] = calibSumZN2[0]*calibEne[2];
+  calibSumZP2[0] = calibSumZP2[0]*calibEne[3];
   // Low gain chain
   calibSumZN1[1] = calibSumZN1[1]*calibEne[0];
   calibSumZP1[1] = calibSumZP1[1]*calibEne[1];
@@ -683,10 +819,10 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
   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]*calibEne[0];
+     calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1];
+     calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2];
+     calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3];
      // Low gain chain
      calibTowZN1[gi+5] = equalTowZN1[gi+5]*calibEne[0];
      calibTowZP1[gi+5] = equalTowZP1[gi+5]*calibEne[1];
@@ -695,11 +831,23 @@ 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]/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];
+  // 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");*/
   
   //  ******   No. of spectator and participants nucleons
   //  Variables calculated to comply with ESD structure
@@ -709,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, 
@@ -717,41 +866,84 @@ void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrA
                   nGenSpec, nGenSpecLeft, nGenSpecRight, 
                   nPart, nPartTotLeft, nPartTotRight, 
                   impPar, impPar1, impPar2,
-                  recoFlag);
+                  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 channelsOff, Bool_t chUnderflow, Bool_t chOverflow) 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
-  UInt_t recoFlag=0;
+  // ---------------------- Setting reco flags for ESD
   UInt_t rFlags[32];
   for(Int_t ifl=0; ifl<32; ifl++) rFlags[ifl]=0;
-
-  if(corrADCZN2[0]>fSignalThreshold)  rFlags[0] = 0x1;
-  if(corrADCZP2[0]>fSignalThreshold)  rFlags[1] = 0x1;
-  if(corrADCZEM1[0]>fSignalThreshold) rFlags[2] = 0x1;
-  if(corrADCZEM2[0]>fSignalThreshold) rFlags[3] = 0x1;
-  if(corrADCZN1[0]>fSignalThreshold)  rFlags[4] = 0x1;
-  if(corrADCZP1[0]>fSignalThreshold)  rFlags[5] = 0x1;
+  
+  if(evQualityBlock[0] == 1) rFlags[31] = 0x0;
+  else rFlags[31] = 0x1;
   //
-  if(channelsOff==kTRUE)   rFlags[8] = 0x1;
-  if(chUnderflow == kTRUE) rFlags[9] = 0x1;
-  if(chOverflow==kTRUE)    rFlags[10] = 0x1;
-  recoFlag = rFlags[10] << 10 | rFlags[9] << 9 | rFlags[8] << 8 |
-             rFlags[5] << 5 | rFlags[4] << 4 | rFlags[3] << 3 |
-             rFlags[2] << 2 | rFlags[1] << 1 | rFlags[0];
+  if(evQualityBlock[1] == 1) rFlags[30] = 0x1;
+  if(evQualityBlock[2] == 1) rFlags[29] = 0x1;
+  if(evQualityBlock[3] == 1) rFlags[28] = 0x1;
+
+  if(triggerBlock[0] == 1) rFlags[27] = 0x1;
+  if(triggerBlock[1] == 1) rFlags[26] = 0x1;
+  if(triggerBlock[2] == 1) rFlags[25] = 0x1;
+  if(triggerBlock[3] == 1) rFlags[24] = 0x1;
+  
+  if(chBlock[0] == 1) rFlags[18] = 0x1;
+  if(chBlock[1] == 1) rFlags[17] = 0x1;
+  if(chBlock[2] == 1) rFlags[16] = 0x1;
+  
+  rFlags[13] = puBits & 0x00000020;
+  rFlags[12] = puBits & 0x00000010;
+  rFlags[11] = puBits & 0x00000080;
+  rFlags[10] = puBits & 0x00000040;
+  rFlags[9]  = puBits & 0x00000020;
+  rFlags[8]  = puBits & 0x00000010;  
+  
+  if(corrADCZP1[0]>fSignalThreshold)  rFlags[5] = 0x1;
+  if(corrADCZN1[0]>fSignalThreshold)  rFlags[4] = 0x1;
+  if(corrADCZEM2[0]>fSignalThreshold) rFlags[3] = 0x1;
+  if(corrADCZEM1[0]>fSignalThreshold) rFlags[2] = 0x1;
+  if(corrADCZP2[0]>fSignalThreshold)  rFlags[1] = 0x1;
+  if(corrADCZN2[0]>fSignalThreshold)  rFlags[0] = 0x1;
 
+  UInt_t recoFlag = rFlags[31] << 31 | rFlags[30] << 30 | rFlags[29] << 29 | rFlags[28] << 28 |
+             rFlags[27] << 27 | rFlags[26] << 26 | rFlags[25] << 25 | rFlags[24] << 24 |
+            0x0 << 23 | 0x0 << 22 | 0x0 << 21 | 0x0 << 20 |
+            0x0 << 19 | rFlags[18] << 18 |  rFlags[17] << 17 |  rFlags[16] << 16 |
+            0x0 << 15 | 0x0 << 14 | rFlags[13] << 13 | rFlags[12] << 12 | 
+             rFlags[11] << 11 |rFlags[10] << 10 | rFlags[9] << 9 | rFlags[8] << 8 |
+            0x0 << 7 | 0x0 << 6 | rFlags[5] << 5 | rFlags[4] << 4 | 
+            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];
@@ -762,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
@@ -789,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++){
@@ -802,11 +1018,14 @@ 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.;
-  calibSumZN2[0] = calibSumZN2[0]*calibEne[2]/8.;
-  calibSumZP2[0] = calibSumZP2[0]*calibEne[3]/8.;
+  calibSumZN1[0] = calibSumZN1[0]*calibEne[0]*8.;
+  calibSumZP1[0] = calibSumZP1[0]*calibEne[1]*8.;
+  calibSumZN2[0] = calibSumZN2[0]*calibEne[2]*8.;
+  calibSumZP2[0] = calibSumZP2[0]*calibEne[3]*8.;
   // Low gain chain
   calibSumZN1[1] = calibSumZN1[1]*calibEne[0];
   calibSumZP1[1] = calibSumZP1[1]*calibEne[1];
@@ -814,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];
     
@@ -824,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;
@@ -853,19 +1085,27 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
   Double_t b=0., bA=0., bC=0.;
   
   if(fIsCalibrationMB == kFALSE){
-    // ******  Reconstruction parameters ------------------ 
-    // Ch. debug
-    //fRecoParam->Print("");
-    //
-    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);
     //
@@ -890,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);
           }
         }
       }
@@ -993,7 +1233,6 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
     //printf("  xSecPercA %1.4f  \n", xSecPercA);
     
     //  ******    Number of participants (from E_ZDC vs. E_ZEM correlation)
-    Int_t nPart=0, nPartC=0, nPartA=0;
     Double_t nPartFrac=0., nPartFracC=0., nPartFracA=0.;
     for(Int_t npbin=1; npbin<hNpartDist->GetNbinsX(); npbin++){
       nPartFrac += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries());
@@ -1032,11 +1271,10 @@ void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
     if(nPartA<0) nPartA=0;
     
     //  ******    Impact parameter (from E_ZDC vs. E_ZEM correlation)
-    Float_t b=0, bC=0, bA=0;
     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;
       }
@@ -1044,82 +1282,68 @@ 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;
       }
     }
 
     //  ****** Number of spectator nucleons 
-    Int_t nGenSpec=0, nGenSpecC=0, nGenSpecA=0;
-    //
     nGenSpec = 416 - nPart;
     nGenSpecC = 416 - nPartC;
     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);
+                 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
 
-  if(fIsCalibrationMB==kTRUE) WritePbPbRecoParamInOCDB();
-  
+  // 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++){
@@ -1134,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();
@@ -1151,11 +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);
+    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);
 }
 
 //_____________________________________________________________________________
@@ -1191,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!");
@@ -1207,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!");
@@ -1215,65 +1491,65 @@ AliZDCEnCalib* AliZDCReconstructor::GetEnergyCalibData() const
 }
 
 //_____________________________________________________________________________
-AliZDCTowerCalib* AliZDCReconstructor::GetTowerCalibData() const
+AliZDCSaturationCalib* AliZDCReconstructor::GetSaturationCalibData() const
 {
 
   // Getting energy and equalization calibration object for ZDC set
 
-  AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/TowerCalib");
+  AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/SaturationCalib");
   if(!entry) AliFatal("No calibration data loaded!");  
+  entry->SetOwner(kFALSE);
 
-  AliZDCTowerCalib *calibdata = dynamic_cast<AliZDCTowerCalib*> (entry->GetObject());
+  AliZDCSaturationCalib *calibdata = dynamic_cast<AliZDCSaturationCalib*> (entry->GetObject());
   if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
 
   return calibdata;
 }
 
 //_____________________________________________________________________________
-AliZDCRecoParampp* AliZDCReconstructor::GetppRecoParamFromOCDB() const
+AliZDCTowerCalib* AliZDCReconstructor::GetTowerCalibData() 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/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!");
 
+  return calibdata;
 }
 
 //_____________________________________________________________________________
-AliZDCRecoParamPbPb* AliZDCReconstructor::GetPbPbRecoParamFromOCDB() 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/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/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;
 }
 
 //_____________________________________________________________________________
-void AliZDCReconstructor::WritePbPbRecoParamInOCDB() const
+AliZDCTDCCalib* AliZDCReconstructor::GetTDCCalibData() const
 {
 
-  // Writing Pb-Pb reconstruction parameters from OCDB
+  // Getting TDC object for ZDC 
 
-  AliCDBManager *man = AliCDBManager::Instance();
-  AliCDBMetaData *md= new AliCDBMetaData();
-  md->SetResponsible("Chiara Oppedisano");
-  md->SetComment("ZDC Pb-Pb reconstruction parameters");
-  md->SetObjectClassName("AliZDCRecoParamPbPb");
-  AliCDBId id("ZDC/Calib/RecoParamPbPb",fNRun,AliCDBRunRange::Infinity());
-  man->Put(fRecoParam, id, md);
+  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;
+}