ZDC/AliZDCReconstructor.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 //      ************** Class for ZDC reconstruction      **************      //
  21 //                  Author: Chiara.Oppedisano@to.infn.it                     //
  22 //                                                                           //
  23 // NOTATIONS ADOPTED TO IDENTIFY DETECTORS (used in different ages!):        //
  24 //   (ZN1,ZP1) or (ZNC, ZPC) or RIGHT refers to side C (RB26)                //
  25 //   (ZN2,ZP2) or (ZNA, ZPA) or LEFT refers to side A (RB24)                 //
  26 //                                                                           //
  27 ///////////////////////////////////////////////////////////////////////////////
  28
  29
  30 #include <TH2F.h>
  31 #include <TH1D.h>
  32 #include <TAxis.h>
  33 #include <TMap.h>
  34
  35 #include "AliRawReader.h"
  36 #include "AliESDEvent.h"
  37 #include "AliESDZDC.h"
  38 #include "AliZDCDigit.h"
  39 #include "AliZDCRawStream.h"
  40 #include "AliZDCReco.h"
  41 #include "AliZDCReconstructor.h"
  42 #include "AliZDCPedestals.h"
  43 #include "AliZDCEnCalib.h"
  44 #include "AliZDCTowerCalib.h"
  45 #include "AliZDCRecoParam.h"
  46 #include "AliZDCRecoParampp.h"
  47 #include "AliZDCRecoParamPbPb.h"
  48 #include "AliRunInfo.h"
  49
  50
  51 ClassImp(AliZDCReconstructor)
  52 AliZDCRecoParam *AliZDCReconstructor::fRecoParam=0;  //reconstruction parameters
  53
  54 //_____________________________________________________________________________
  55 AliZDCReconstructor:: AliZDCReconstructor() :
  56   fPedData(GetPedestalData()),
  57   fEnCalibData(GetEnergyCalibData()),
  58   fTowCalibData(GetTowerCalibData()),
  59   fRecoMode(0),
  60   fBeamEnergy(0.),
  61   fNRun(0),
  62   fIsCalibrationMB(kFALSE),
  63   fPedSubMode(0),
  64   fSignalThreshold(7)
  65 {
  66   // **** Default constructor
  67 }
  68
  69
  70 //_____________________________________________________________________________
  71 AliZDCReconstructor::~AliZDCReconstructor()
  72 {
  73 // destructor
  74 //   if(fRecoParam)    delete fRecoParam;
  75    if(fPedData)      delete fPedData;
  76    if(fEnCalibData)  delete fEnCalibData;
  77    if(fTowCalibData) delete fTowCalibData;
  78 }
  79
  80 //____________________________________________________________________________
  81 void AliZDCReconstructor::Init()
  82 {
  83   // Setting reconstruction mode
  84   // Getting beam type and beam energy from GRP calibration object
  85
  86   TString runType = GetRunInfo()->GetRunType();
  87   if((runType.CompareTo("CALIBRATION_MB")) == 0){
  88     fIsCalibrationMB = kTRUE;
  89   }
  90
  91   TString beamType = GetRunInfo()->GetBeamType();
  92   // This is a temporary solution to allow reconstruction in tests without beam
  93   if(((beamType.CompareTo("UNKNOWN"))==0) &&
  94      ((runType.CompareTo("PHYSICS"))==0 || (runType.CompareTo("CALIBRATION_BC"))==0)){
  95     fRecoMode=1;
  96   }
  97   /*else if((beamType.CompareTo("UNKNOWN"))==0){
  98     AliError("\t UNKNOWN beam type\n");
  99     return;
 100   }*/
 101
 102   if(((beamType.CompareTo("pp"))==0) || ((beamType.CompareTo("p-p"))==0)
 103      ||((beamType.CompareTo("PP"))==0) || ((beamType.CompareTo("P-P"))==0)){
 104     fRecoMode=1;
 105   }
 106   else if((beamType.CompareTo("A-A")) == 0){
 107     fRecoMode=2;
 108   }
 109
 110   fBeamEnergy = GetRunInfo()->GetBeamEnergy();
 111   if(fBeamEnergy==0.) AliWarning(" Beam energy value missing -> E_beam = 0");
 112
 113   if(fIsCalibrationMB==kFALSE)
 114     printf("\n\n ***** ZDC reconstruction initialized for %s @ %1.0f GeV *****\n\n",beamType.Data(), fBeamEnergy);
 115
 116 }
 117
 118 //_____________________________________________________________________________
 119 void AliZDCReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const
 120 {
 121   // *** Local ZDC reconstruction for digits
 122   // Works on the current event
 123
 124   // Retrieving calibration data
 125   // Parameters for mean value pedestal subtraction
 126   int const kNch = 24;
 127   Float_t meanPed[2*kNch];
 128   for(Int_t jj=0; jj<2*kNch; jj++) meanPed[jj] = fPedData->GetMeanPed(jj);
 129   // Parameters pedestal subtraction through correlation with out-of-time signals
 130   Float_t corrCoeff0[2*kNch], corrCoeff1[2*kNch];
 131   for(Int_t jj=0; jj<2*kNch; jj++){
 132      corrCoeff0[jj] = fPedData->GetPedCorrCoeff0(jj);
 133      corrCoeff1[jj] = fPedData->GetPedCorrCoeff1(jj);
 134   }
 135
 136   // get digits
 137   AliZDCDigit digit;
 138   AliZDCDigit* pdigit = &digit;
 139   digitsTree->SetBranchAddress("ZDC", &pdigit);
 140   //printf("\n\t # of digits in tree: %d\n",(Int_t) digitsTree->GetEntries());
 141
 142   // loop over digits
 143   Float_t tZN1Corr[10], tZP1Corr[10], tZN2Corr[10], tZP2Corr[10];
 144   Float_t dZEM1Corr[2], dZEM2Corr[2], sPMRef1[2], sPMRef2[2];
 145   for(Int_t i=0; i<10; i++){
 146      tZN1Corr[i] = tZP1Corr[i] = tZN2Corr[i] = tZP2Corr[i] = 0.;
 147      if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = sPMRef1[i] = sPMRef2[i] = 0.;
 148   }
 149
 150   Int_t digNentries = digitsTree->GetEntries();
 151   Float_t ootDigi[kNch];
 152   // -- Reading out-of-time signals (last kNch entries) for current event
 153   if(fPedSubMode==1){
 154     for(Int_t iDigit=kNch; iDigit<digNentries; iDigit++){
 155        ootDigi[iDigit] = digitsTree->GetEntry(iDigit);
 156     }
 157   }
 158
 159   for(Int_t iDigit=0; iDigit<(digNentries/2); iDigit++) {
 160    digitsTree->GetEntry(iDigit);
 161    if (!pdigit) continue;
 162    //
 163    Int_t det = digit.GetSector(0);
 164    Int_t quad = digit.GetSector(1);
 165    Int_t pedindex = -1;
 166    Float_t ped2SubHg=0., ped2SubLg=0.;
 167    if(quad!=5){
 168      if(det==1)      pedindex = quad;
 169      else if(det==2) pedindex = quad+5;
 170      else if(det==3) pedindex = quad+9;
 171      else if(det==4) pedindex = quad+12;
 172      else if(det==5) pedindex = quad+17;
 173    }
 174    else pedindex = (det-1)/3+22;
 175    //
 176    if(fPedSubMode==0){
 177      ped2SubHg = meanPed[pedindex];
 178      ped2SubLg = meanPed[pedindex+kNch];
 179    }
 180    else if(fPedSubMode==1){
 181      ped2SubHg = corrCoeff1[pedindex]*ootDigi[pedindex]+corrCoeff0[pedindex];
 182      ped2SubLg = corrCoeff1[pedindex+kNch]*ootDigi[pedindex+kNch]+corrCoeff0[pedindex+kNch];
 183    }
 184
 185    if(quad != 5){ // ZDC (not reference PTMs!)
 186     if(det == 1){ // *** ZNC
 187        tZN1Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
 188        tZN1Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
 189        if(tZN1Corr[quad]<0.) tZN1Corr[quad] = 0.;
 190        if(tZN1Corr[quad+5]<0.) tZN1Corr[quad+5] = 0.;
 191     }
 192     else if(det == 2){ // *** ZP1
 193        tZP1Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
 194        tZP1Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
 195        if(tZP1Corr[quad]<0.) tZP1Corr[quad] = 0.;
 196        if(tZP1Corr[quad+5]<0.) tZP1Corr[quad+5] = 0.;
 197     }
 198     else if(det == 3){
 199        if(quad == 1){       // *** ZEM1
 200          dZEM1Corr[0] += (Float_t) (digit.GetADCValue(0)-ped2SubHg);
 201          dZEM1Corr[1] += (Float_t) (digit.GetADCValue(1)-ped2SubLg);
 202          if(dZEM1Corr[0]<0.) dZEM1Corr[0] = 0.;
 203          if(dZEM1Corr[1]<0.) dZEM1Corr[1] = 0.;
 204        }
 205        else if(quad == 2){  // *** ZEM2
 206          dZEM2Corr[0] += (Float_t) (digit.GetADCValue(0)-ped2SubHg);
 207          dZEM2Corr[1] += (Float_t) (digit.GetADCValue(1)-ped2SubLg);
 208          if(dZEM2Corr[0]<0.) dZEM2Corr[0] = 0.;
 209          if(dZEM2Corr[1]<0.) dZEM2Corr[1] = 0.;
 210        }
 211     }
 212     else if(det == 4){  // *** ZN2
 213        tZN2Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
 214        tZN2Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
 215        if(tZN2Corr[quad]<0.) tZN2Corr[quad] = 0.;
 216        if(tZN2Corr[quad+5]<0.) tZN2Corr[quad+5] = 0.;
 217    }
 218     else if(det == 5){  // *** ZP2
 219        tZP2Corr[quad] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
 220        tZP2Corr[quad+5] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
 221        if(tZP2Corr[quad]<0.) tZP2Corr[quad] = 0.;
 222        if(tZP2Corr[quad+5]<0.) tZP2Corr[quad+5] = 0.;
 223     }
 224    }
 225    else{ // Reference PMs
 226      if(det == 1){
 227        sPMRef1[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
 228        sPMRef1[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
 229        // Ch. debug
 230        if(sPMRef1[0]<0.) sPMRef1[0] = 0.;
 231        if(sPMRef2[1]<0.) sPMRef1[1] = 0.;
 232      }
 233      else if(det == 4){
 234        sPMRef2[0] = (Float_t) (digit.GetADCValue(0)-ped2SubHg);
 235        sPMRef2[1] = (Float_t) (digit.GetADCValue(1)-ped2SubLg);
 236        // Ch. debug
 237        if(sPMRef2[0]<0.) sPMRef2[0] = 0.;
 238        if(sPMRef2[1]<0.) sPMRef2[1] = 0.;
 239      }
 240    }
 241
 242    // Ch. debug
 243    /*printf("AliZDCReconstructor: digit #%d det %d quad %d pedHG %1.0f pedLG %1.0f\n",
 244          iDigit, det, quad, ped2SubHg, ped2SubLg);
 245    printf(" -> pedindex %d\n", pedindex);
 246    printf("   HGChain -> RawDig %d DigCorr %1.2f",
 247         digit.GetADCValue(0), digit.GetADCValue(0)-ped2SubHg);
 248    printf("   LGChain -> RawDig %d DigCorr %1.2f\n",
 249         digit.GetADCValue(1), digit.GetADCValue(1)-ped2SubLg);*/
 250
 251   }//digits loop
 252
 253   UInt_t counts[32];
 254   for(Int_t jj=0; jj<32; jj++) counts[jj]=0;
 255
 256   Int_t  evQualityBlock[4] = {1,0,0,0};
 257   Int_t  triggerBlock[4] = {0,0,0,0};
 258   Int_t  chBlock[3] = {0,0,0};
 259   UInt_t puBits=0;
 260
 261   // reconstruct the event
 262   if(fRecoMode==1)
 263     ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
 264       dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2,
 265       kFALSE, counts,
 266       evQualityBlock,  triggerBlock,  chBlock, puBits);
 267   else if(fRecoMode==2)
 268     ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
 269       dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2,
 270       kFALSE, counts,
 271       evQualityBlock,  triggerBlock,  chBlock, puBits);
 272 }
 273
 274 //_____________________________________________________________________________
 275 void AliZDCReconstructor::Reconstruct(AliRawReader* rawReader, TTree* clustersTree) const
 276 {
 277   // *** ZDC raw data reconstruction
 278   // Works on the current event
 279
 280   // Retrieving calibration data
 281   // Parameters for pedestal subtraction
 282   int const kNch = 24;
 283   Float_t meanPed[2*kNch];
 284   for(Int_t jj=0; jj<2*kNch; jj++) meanPed[jj] = fPedData->GetMeanPed(jj);
 285   // Parameters pedestal subtraction through correlation with out-of-time signals
 286   Float_t corrCoeff0[2*kNch], corrCoeff1[2*kNch];
 287   for(Int_t jj=0; jj<2*kNch; jj++){
 288      corrCoeff0[jj] =  fPedData->GetPedCorrCoeff0(jj);
 289      corrCoeff1[jj] =  fPedData->GetPedCorrCoeff1(jj);
 290   }
 291
 292   Int_t adcZN1[5], adcZN1oot[5], adcZN1lg[5], adcZN1ootlg[5];
 293   Int_t adcZP1[5], adcZP1oot[5], adcZP1lg[5], adcZP1ootlg[5];
 294   Int_t adcZN2[5], adcZN2oot[5], adcZN2lg[5], adcZN2ootlg[5];
 295   Int_t adcZP2[5], adcZP2oot[5], adcZP2lg[5], adcZP2ootlg[5];
 296   Int_t adcZEM[2], adcZEMoot[2], adcZEMlg[2], adcZEMootlg[2];
 297   Int_t pmRef[2], pmRefoot[2], pmReflg[2], pmRefootlg[2];
 298   for(Int_t ich=0; ich<5; ich++){
 299     adcZN1[ich] = adcZN1oot[ich] = adcZN1lg[ich] = adcZN1ootlg[ich] = 0;
 300     adcZP1[ich] = adcZP1oot[ich] = adcZP1lg[ich] = adcZP1ootlg[ich] = 0;
 301     adcZN2[ich] = adcZN2oot[ich] = adcZN2lg[ich] = adcZN2ootlg[ich] = 0;
 302     adcZP2[ich] = adcZP2oot[ich] = adcZP2lg[ich] = adcZP2ootlg[ich] = 0;
 303     if(ich<2){
 304       adcZEM[ich] = adcZEMoot[ich] = adcZEMlg[ich] = adcZEMootlg[ich] = 0;
 305       pmRef[ich] = pmRefoot[ich] = pmReflg[ich] = pmRefootlg[ich] = 0;
 306     }
 307   }
 308
 309   Float_t tZN1Corr[10], tZP1Corr[10], tZN2Corr[10], tZP2Corr[10];
 310   Float_t dZEM1Corr[2], dZEM2Corr[2], sPMRef1[2], sPMRef2[2];
 311   for(Int_t i=0; i<10; i++){
 312      tZN1Corr[i] = tZP1Corr[i] = tZN2Corr[i] = tZP2Corr[i] = 0.;
 313      if(i<2) dZEM1Corr[i] = dZEM2Corr[i] = sPMRef1[i] = sPMRef2[i] = 0.;
 314   }
 315
 316   Bool_t isScalerOn=kFALSE;
 317   Int_t jsc=0;
 318   UInt_t scalerData[32];
 319   for(Int_t k=0; k<32; k++) scalerData[k]=0;
 320
 321   Int_t  evQualityBlock[4] = {1,0,0,0};
 322   Int_t  triggerBlock[4] = {0,0,0,0};
 323   Int_t  chBlock[3] = {0,0,0};
 324   UInt_t puBits=0;
 325
 326   //fNRun = (Int_t) rawReader->GetRunNumber();
 327   Int_t kFirstADCGeo=0, kLastADCGeo=3, kScalerGeo=8, kPUGeo=29;
 328   //Int_t kTrigScales=30, kTrigHistory=31;
 329
 330   // loop over raw data
 331   rawReader->Reset();
 332   AliZDCRawStream rawData(rawReader);
 333   while(rawData.Next()){
 334
 335    // ***************************** Reading ADCs
 336    if((rawData.GetADCModule()>=kFirstADCGeo) && (rawData.GetADCModule()<=kLastADCGeo)){
 337     //printf(" **** Reading ADC raw data from module %d **** \n",rawData.GetADCModule());
 338     //
 339     if((rawData.IsADCDataWord()) && (rawData.GetNChannelsOn()<48))    chBlock[0] = kTRUE;
 340     if((rawData.IsADCDataWord()) && (rawData.IsOverflow() == kTRUE))  chBlock[1] = kTRUE;
 341     if((rawData.IsADCDataWord()) && (rawData.IsUnderflow() == kTRUE)) chBlock[2] = kTRUE;
 342     if((rawData.IsADCDataWord()) && (rawData.IsADCEventGood() == kTRUE)) evQualityBlock[0] = kTRUE;
 343
 344     if((rawData.IsADCDataWord()) && (rawData.IsUnderflow()==kFALSE)
 345         && (rawData.IsOverflow()==kFALSE) && (rawData.IsADCEventGood()==kTRUE)){
 346
 347       Int_t adcMod = rawData.GetADCModule();
 348       Int_t det = rawData.GetSector(0);
 349       Int_t quad = rawData.GetSector(1);
 350       Int_t gain = rawData.GetADCGain();
 351       Int_t pedindex=0;
 352       //
 353       // Mean pedestal value subtraction -------------------------------------------------------
 354       if(fPedSubMode == 0){
 355        // Not interested in o.o.t. signals (ADC modules 2, 3)
 356        if(adcMod == 2 || adcMod == 3) continue;
 357        //
 358        if(quad != 5){ // ZDCs (not reference PTMs)
 359         if(det == 1){
 360           pedindex = quad;
 361           if(gain == 0) tZN1Corr[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
 362           else tZN1Corr[quad+5]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
 363         }
 364         else if(det == 2){
 365           pedindex = quad+5;
 366           if(gain == 0) tZP1Corr[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
 367           else tZP1Corr[quad+5]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
 368         }
 369         else if(det == 3){
 370           pedindex = quad+9;
 371           if(quad==1){
 372             if(gain == 0) dZEM1Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
 373             else dZEM1Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
 374           }
 375           else if(quad==2){
 376             if(gain == 0) dZEM2Corr[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
 377             else dZEM2Corr[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
 378           }
 379         }
 380         else if(det == 4){
 381           pedindex = quad+12;
 382           if(gain == 0) tZN2Corr[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
 383           else tZN2Corr[quad+5]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
 384         }
 385         else if(det == 5){
 386           pedindex = quad+17;
 387           if(gain == 0) tZP2Corr[quad]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
 388           else tZP2Corr[quad+5]  += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
 389         }
 390        }
 391        else{ // reference PM
 392          pedindex = (det-1)/3 + 22;
 393          if(det == 1){
 394            if(gain==0) sPMRef1[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
 395          else sPMRef1[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
 396          }
 397          else if(det == 4){
 398            if(gain==0) sPMRef2[0] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex]);
 399            else sPMRef2[1] += (Float_t) (rawData.GetADCValue()-meanPed[pedindex+kNch]);
 400          }
 401        }
 402        // Ch. debug
 403        /*if(gain==0){
 404          printf(" AliZDCReconstructor: det %d quad %d res %d -> Pedestal[%d] %1.0f",
 405            det,quad,gain, pedindex, meanPed[pedindex]);
 406          printf("   RawADC %d ADCCorr %1.0f\n",
 407            rawData.GetADCValue(), rawData.GetADCValue()-meanPed[pedindex]);
 408        }*/
 409       }// mean pedestal subtraction
 410       // Pedestal subtraction from correlation ------------------------------------------------
 411       else if(fPedSubMode == 1){
 412        // In time signals
 413        if(adcMod==0 || adcMod==1){
 414          if(quad != 5){ // signals from ZDCs
 415            if(det == 1){
 416              if(gain==0) adcZN1[quad] = rawData.GetADCValue();
 417              else adcZN1lg[quad] = rawData.GetADCValue();
 418            }
 419            else if(det == 2){
 420              if(gain==0) adcZP1[quad] = rawData.GetADCValue();
 421              else adcZP1lg[quad] = rawData.GetADCValue();
 422            }
 423            else if(det == 3){
 424              if(gain==0) adcZEM[quad-1] = rawData.GetADCValue();
 425              else adcZEMlg[quad-1] = rawData.GetADCValue();
 426            }
 427            else if(det == 4){
 428              if(gain==0) adcZN2[quad] = rawData.GetADCValue();
 429              else adcZN2lg[quad] = rawData.GetADCValue();
 430            }
 431            else if(det == 5){
 432              if(gain==0) adcZP2[quad] = rawData.GetADCValue();
 433              else adcZP2lg[quad] = rawData.GetADCValue();
 434            }
 435          }
 436          else{ // signals from reference PM
 437             if(gain==0) pmRef[quad-1] = rawData.GetADCValue();
 438             else pmReflg[quad-1] = rawData.GetADCValue();
 439          }
 440        }
 441        // Out-of-time pedestals
 442        else if(adcMod==2 || adcMod==3){
 443          if(quad != 5){ // signals from ZDCs
 444            if(det == 1){
 445              if(gain==0) adcZN1oot[quad] = rawData.GetADCValue();
 446              else adcZN1ootlg[quad] = rawData.GetADCValue();
 447            }
 448            else if(det == 2){
 449              if(gain==0) adcZP1oot[quad] = rawData.GetADCValue();
 450              else adcZP1ootlg[quad] = rawData.GetADCValue();
 451            }
 452            else if(det == 3){
 453              if(gain==0) adcZEMoot[quad-1] = rawData.GetADCValue();
 454              else adcZEMootlg[quad-1] = rawData.GetADCValue();
 455            }
 456            else if(det == 4){
 457              if(gain==0) adcZN2oot[quad] = rawData.GetADCValue();
 458              else adcZN2ootlg[quad] = rawData.GetADCValue();
 459            }
 460            else if(det == 5){
 461              if(gain==0) adcZP2oot[quad] = rawData.GetADCValue();
 462              else adcZP2ootlg[quad] = rawData.GetADCValue();
 463            }
 464          }
 465          else{ // signals from reference PM
 466             if(gain==0) pmRefoot[quad-1] = rawData.GetADCValue();
 467             else pmRefootlg[quad-1] = rawData.GetADCValue();
 468          }
 469        }
 470       } // pedestal subtraction from correlation
 471       // Ch. debug
 472       /*printf("\t AliZDCReconstructor: det %d quad %d res %d -> Ped[%d] = %1.0f\n",
 473         det,quad,gain, pedindex, meanPed[pedindex]);*/
 474     }//IsADCDataWord
 475    }// ADC DATA
 476    // ***************************** Reading Scaler
 477    else if(rawData.GetADCModule()==kScalerGeo){
 478      if(rawData.IsScalerWord()==kTRUE && rawData.IsScEventGood()==kTRUE){
 479        isScalerOn = kTRUE;
 480        scalerData[jsc] = rawData.GetTriggerCount();
 481        // Ch. debug
 482        //printf("   Reconstructed VME Scaler: %d %d  ",jsc,scalerData[jsc]);
 483        //
 484        jsc++;
 485      }
 486    }// VME SCALER DATA
 487    // ***************************** Reading PU
 488    else if(rawData.GetADCModule()==kPUGeo){
 489      puBits = rawData.GetDetectorPattern();
 490    }
 491     // ***************************** Reading trigger history
 492    else if(rawData.IstriggerHistoryWord()==kTRUE){
 493      triggerBlock[0] = rawData.IsCPTInputEMDTrigger();
 494      triggerBlock[1] = rawData.IsCPTInputSemiCentralTrigger();
 495      triggerBlock[2] = rawData.IsCPTInputCentralTrigger();
 496      triggerBlock[3] = rawData.IsCPTInputMBTrigger();
 497    }
 498
 499   }//loop on raw data
 500
 501   if(fPedSubMode==1){
 502     for(Int_t t=0; t<5; t++){
 503        tZN1Corr[t] = adcZN1[t] - (corrCoeff1[t]*adcZN1oot[t]+corrCoeff0[t]);
 504        tZN1Corr[t+5] = adcZN1lg[t] - (corrCoeff1[t+kNch]*adcZN1ootlg[t]+corrCoeff0[t+kNch]);
 505        //
 506        tZP1Corr[t] = adcZP1[t] - (corrCoeff1[t+5]*adcZP1oot[t]+corrCoeff0[t+5]);
 507        tZP1Corr[t+5] = adcZP1lg[t] - (corrCoeff1[t+5+kNch]*adcZP1ootlg[t]+corrCoeff0[t+5+kNch]);
 508        //
 509        tZN2Corr[t] = adcZN2[t] - (corrCoeff1[t+12]*adcZN2oot[t]+corrCoeff0[t+12]);
 510        tZN2Corr[t+5] = adcZN2lg[t] - (corrCoeff1[t+12+kNch]*adcZN2ootlg[t]+corrCoeff0[t+12+kNch]);
 511        //
 512        tZP2Corr[t] = adcZP2[t] - (corrCoeff1[t+17]*adcZP2oot[t]+corrCoeff0[t+17]);
 513        tZP2Corr[t+5] = adcZP2lg[t] - (corrCoeff1[t+17+kNch]*adcZP2ootlg[t]+corrCoeff0[t+17+kNch]);
 514        // 0---------0 Ch. debug 0---------0
 515 /*       printf("\n\n ---------- Debug of pedestal subtraction from correlation ----------\n");
 516        printf("\tCorrCoeff0\tCorrCoeff1\n");
 517        printf(" ZN1 %d\t%1.0f\t%1.0f\n",t,corrCoeff0[t],corrCoeff1[t]);
 518        printf(" ZN1lg %d\t%1.0f\t%1.0f\n",t+kNch,corrCoeff0[t+kNch],corrCoeff1[t+kNch]);
 519        printf(" ZP1 %d\t%1.0f\t%1.0f\n",t+5,corrCoeff0[t+5],corrCoeff1[t+5]);
 520        printf(" ZP1lg %d\t%1.0f\t%1.0f\n",t+5+kNch,corrCoeff0[t+5+kNch],corrCoeff1[t+5+kNch]);
 521        printf(" ZN2 %d\t%1.0f\t%1.0f\n",t+12,corrCoeff0[t+12],corrCoeff1[t+12]);
 522        printf(" ZN2lg %d\t%1.0f\t%1.0f\n",t+12+kNch,corrCoeff0[t+12+kNch],corrCoeff1[t+12+kNch]);
 523        printf(" ZP2 %d\t%1.0f\t%1.0f\n",t+17,corrCoeff0[t+17],corrCoeff1[t+17]);
 524        printf(" ZP2lg %d\t%1.0f\t%1.0f\n",t+17+kNch,corrCoeff0[t+17+kNch],corrCoeff1[t+17+kNch]);
 525
 526        printf("ZN1 ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
 527                 adcZN1[t],(corrCoeff1[t]*adcZN1oot[t]+corrCoeff0[t]),tZN1Corr[t]);
 528        printf(" lg ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
 529                 adcZN1lg[t],(corrCoeff1[t+kNch]*adcZN1ootlg[t]+corrCoeff0[t+kNch]),tZN1Corr[t+5]);
 530        //
 531        printf("ZP1 ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
 532                 adcZP1[t],(corrCoeff1[t+5]*adcZP1oot[t]+corrCoeff0[t+5]),tZP1Corr[t]);
 533        printf(" lg ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
 534                 adcZP1lg[t],(corrCoeff1[t+5+kNch]*adcZP1ootlg[t]+corrCoeff0[t+5+kNch]),tZP1Corr[t+5]);
 535        //
 536        printf("ZN2 ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
 537                 adcZN2[t],(corrCoeff1[t+12]*adcZN2oot[t]+corrCoeff0[t+12]),tZN2Corr[t]);
 538        printf(" lg ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
 539                 adcZN2lg[t],(corrCoeff1[t+12+kNch]*adcZN2ootlg[t]+corrCoeff0[t+12+kNch]),tZN2Corr[t+5]);
 540        //
 541        printf("ZP2 ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
 542                 adcZP2[t],(corrCoeff1[t+17]*adcZP2oot[t]+corrCoeff0[t+17]),tZP2Corr[t]);
 543        printf(" lg ->  rawADC %d\tpedestal%1.2f\tcorrADC%1.2f\n",
 544                 adcZP2lg[t],(corrCoeff1[t+17+kNch]*adcZP2ootlg[t]+corrCoeff0[t+17+kNch]),tZP2Corr[t+5]);
 545 */
 546     }
 547     dZEM1Corr[0] = adcZEM[0]   - (corrCoeff1[9]*adcZEMoot[0]+corrCoeff0[9]);
 548     dZEM1Corr[1] = adcZEMlg[0] - (corrCoeff1[9+kNch]*adcZEMootlg[0]+corrCoeff0[9+kNch]);
 549     dZEM2Corr[0] = adcZEM[1]   - (corrCoeff1[10]*adcZEMoot[1]+corrCoeff0[10]);
 550     dZEM2Corr[1] = adcZEMlg[1] - (corrCoeff1[10+kNch]*adcZEMootlg[1]+corrCoeff0[10+kNch]);
 551     //
 552     sPMRef1[0] = pmRef[0]   - (corrCoeff1[22]*pmRefoot[0]+corrCoeff0[22]);
 553     sPMRef1[1] = pmReflg[0] - (corrCoeff1[22+kNch]*pmRefootlg[0]+corrCoeff0[22+kNch]);
 554     sPMRef2[0] = pmRef[0]   - (corrCoeff1[23]*pmRefoot[1]+corrCoeff0[23]);
 555     sPMRef2[1] = pmReflg[0] - (corrCoeff1[23+kNch]*pmRefootlg[1]+corrCoeff0[23+kNch]);
 556   }
 557
 558   if(fRecoMode==1) // p-p data
 559     ReconstructEventpp(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
 560       dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2,
 561       isScalerOn, scalerData,
 562       evQualityBlock, triggerBlock, chBlock, puBits);
 563   else if(fRecoMode==2) // Pb-Pb data
 564     ReconstructEventPbPb(clustersTree, tZN1Corr, tZP1Corr, tZN2Corr, tZP2Corr,
 565       dZEM1Corr, dZEM2Corr, sPMRef1, sPMRef2,
 566       isScalerOn, scalerData,
 567       evQualityBlock, triggerBlock, chBlock, puBits);
 568 }
 569
 570 //_____________________________________________________________________________
 571 void AliZDCReconstructor::ReconstructEventpp(TTree *clustersTree, Float_t* corrADCZN1,
 572         Float_t* corrADCZP1, Float_t* corrADCZN2, Float_t* corrADCZP2,
 573         Float_t* corrADCZEM1, Float_t* corrADCZEM2, Float_t* sPMRef1, Float_t* sPMRef2,
 574         Bool_t isScalerOn, UInt_t* scaler,
 575         Int_t* evQualityBlock, Int_t* triggerBlock, Int_t* chBlock, UInt_t puBits) const
 576 {
 577   // ****************** Reconstruct one event ******************
 578
 579   // CH. debug
 580   /*printf("\n*************************************************\n");
 581   printf(" ReconstructEventpp -> values after pedestal subtraction:\n");
 582   printf(" ADCZN1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 583         corrADCZN1[0],corrADCZN1[1],corrADCZN1[2],corrADCZN1[3],corrADCZN1[4]);
 584   printf(" ADCZP1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 585         corrADCZP1[0],corrADCZP1[1],corrADCZP1[2],corrADCZP1[3],corrADCZP1[4]);
 586   printf(" ADCZN2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 587         corrADCZN2[0],corrADCZN2[1],corrADCZN2[2],corrADCZN2[3],corrADCZN2[4]);
 588   printf(" ADCZP2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 589         corrADCZP2[0],corrADCZP2[1],corrADCZP2[2],corrADCZP2[3],corrADCZP2[4]);
 590   printf(" ADCZEM1 [%1.2f] ADCZEM2 [%1.2f] \n",corrADCZEM1[0],corrADCZEM2[0]);
 591   printf("*************************************************\n");*/
 592
 593   // ---------------------- Setting reco flags for ESD
 594   UInt_t rFlags[32];
 595   for(Int_t ifl=0; ifl<32; ifl++) rFlags[ifl]=0;
 596
 597   if(evQualityBlock[0] == 1) rFlags[31] = 0x0;
 598   else rFlags[31] = 0x1;
 599   //
 600   if(evQualityBlock[1] == 1) rFlags[30] = 0x1;
 601   if(evQualityBlock[2] == 1) rFlags[29] = 0x1;
 602   if(evQualityBlock[3] == 1) rFlags[28] = 0x1;
 603
 604   if(triggerBlock[0] == 1) rFlags[27] = 0x1;
 605   if(triggerBlock[1] == 1) rFlags[26] = 0x1;
 606   if(triggerBlock[2] == 1) rFlags[25] = 0x1;
 607   if(triggerBlock[3] == 1) rFlags[24] = 0x1;
 608
 609   if(chBlock[0] == 1) rFlags[18] = 0x1;
 610   if(chBlock[1] == 1) rFlags[17] = 0x1;
 611   if(chBlock[2] == 1) rFlags[16] = 0x1;
 612
 613
 614   rFlags[13] = puBits & 0x00000020;
 615   rFlags[12] = puBits & 0x00000010;
 616   rFlags[11] = puBits & 0x00000080;
 617   rFlags[10] = puBits & 0x00000040;
 618   rFlags[9]  = puBits & 0x00000020;
 619   rFlags[8]  = puBits & 0x00000010;
 620
 621   if(corrADCZP1[0]>fSignalThreshold)  rFlags[5] = 0x1;
 622   if(corrADCZN1[0]>fSignalThreshold)  rFlags[4] = 0x1;
 623   if(corrADCZEM2[0]>fSignalThreshold) rFlags[3] = 0x1;
 624   if(corrADCZEM1[0]>fSignalThreshold) rFlags[2] = 0x1;
 625   if(corrADCZP2[0]>fSignalThreshold)  rFlags[1] = 0x1;
 626   if(corrADCZN2[0]>fSignalThreshold)  rFlags[0] = 0x1;
 627
 628   UInt_t recoFlag = rFlags[31] << 31 | rFlags[30] << 30 | rFlags[29] << 29 | rFlags[28] << 28 |
 629              rFlags[27] << 27 | rFlags[26] << 26 | rFlags[25] << 25 | rFlags[24] << 24 |
 630              0x0 << 23 | 0x0 << 22 | 0x0 << 21 | 0x0 << 20 |
 631              0x0 << 19 | rFlags[18] << 18 |  rFlags[17] << 17 |  rFlags[16] << 16 |
 632              0x0 << 15 | 0x0 << 14 | rFlags[13] << 13 | rFlags[12] << 12 |
 633              rFlags[11] << 11 |rFlags[10] << 10 | rFlags[9] << 9 | rFlags[8] << 8 |
 634              0x0 << 7 | 0x0 << 6 | rFlags[5] << 5 | rFlags[4] << 4 |
 635              rFlags[3] << 3 | rFlags[2] << 2 | rFlags[1] << 1 | rFlags[0];
 636   // --------------------------------------------------
 637
 638   // ******     Retrieving calibration data
 639   // --- Equalization coefficients ---------------------------------------------
 640   Float_t equalCoeffZN1[5], equalCoeffZP1[5], equalCoeffZN2[5], equalCoeffZP2[5];
 641   for(Int_t ji=0; ji<5; ji++){
 642      equalCoeffZN1[ji] = fTowCalibData->GetZN1EqualCoeff(ji);
 643      equalCoeffZP1[ji] = fTowCalibData->GetZP1EqualCoeff(ji);
 644      equalCoeffZN2[ji] = fTowCalibData->GetZN2EqualCoeff(ji);
 645      equalCoeffZP2[ji] = fTowCalibData->GetZP2EqualCoeff(ji);
 646   }
 647   // --- Energy calibration factors ------------------------------------
 648   Float_t calibEne[4];
 649   // **** Energy calibration coefficient set to 1
 650   // **** (no trivial way to calibrate in p-p runs)
 651   for(Int_t ij=0; ij<6; ij++) calibEne[ij] = fEnCalibData->GetEnCalib(ij);
 652
 653   // ******     Equalization of detector responses
 654   Float_t equalTowZN1[10], equalTowZN2[10], equalTowZP1[10], equalTowZP2[10];
 655   for(Int_t gi=0; gi<10; gi++){
 656      if(gi<5){
 657        equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi];
 658        equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi];
 659        equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi];
 660        equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi];
 661      }
 662      else{
 663        equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi-5];
 664        equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi-5];
 665        equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi-5];
 666        equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi-5];
 667      }
 668   }
 669   // Ch. debug
 670   /*printf("\n ------------- EQUALIZATION -------------\n");
 671   printf(" ADCZN1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 672         equalTowZN1[0],equalTowZN1[1],equalTowZN1[2],equalTowZN1[3],equalTowZN1[4]);
 673   printf(" ADCZP1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 674         equalTowZP1[0],equalTowZP1[1],equalTowZP1[2],equalTowZP1[3],equalTowZP1[4]);
 675   printf(" ADCZN2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 676         equalTowZN2[0],equalTowZN2[1],equalTowZN2[2],equalTowZN2[3],equalTowZN2[4]);
 677   printf(" ADCZP2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 678         equalTowZP2[0],equalTowZP2[1],equalTowZP2[2],equalTowZP2[3],equalTowZP2[4]);
 679   printf(" ----------------------------------------\n");*/
 680
 681   // ******     Summed response for hadronic calorimeter (SUMMED and then CALIBRATED!)
 682   Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0};
 683   for(Int_t gi=0; gi<5; gi++){
 684        calibSumZN1[0] += equalTowZN1[gi];
 685        calibSumZP1[0] += equalTowZP1[gi];
 686        calibSumZN2[0] += equalTowZN2[gi];
 687        calibSumZP2[0] += equalTowZP2[gi];
 688        //
 689        calibSumZN1[1] += equalTowZN1[gi+5];
 690        calibSumZP1[1] += equalTowZP1[gi+5];
 691        calibSumZN2[1] += equalTowZN2[gi+5];
 692        calibSumZP2[1] += equalTowZP2[gi+5];
 693   }
 694   // High gain chain
 695   calibSumZN1[0] = calibSumZN1[0]*calibEne[0];
 696   calibSumZP1[0] = calibSumZP1[0]*calibEne[1];
 697   calibSumZN2[0] = calibSumZN2[0]*calibEne[2];
 698   calibSumZP2[0] = calibSumZP2[0]*calibEne[3];
 699   // Low gain chain
 700   calibSumZN1[1] = calibSumZN1[1]*calibEne[0];
 701   calibSumZP1[1] = calibSumZP1[1]*calibEne[1];
 702   calibSumZN2[1] = calibSumZN2[1]*calibEne[2];
 703   calibSumZP2[1] = calibSumZP2[1]*calibEne[3];
 704
 705   // ******     Energy calibration of detector responses
 706   Float_t calibTowZN1[10], calibTowZN2[10], calibTowZP1[10], calibTowZP2[10];
 707   for(Int_t gi=0; gi<5; gi++){
 708      // High gain chain
 709      calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0];
 710      calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1];
 711      calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2];
 712      calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3];
 713      // Low gain chain
 714      calibTowZN1[gi+5] = equalTowZN1[gi+5]*calibEne[0];
 715      calibTowZP1[gi+5] = equalTowZP1[gi+5]*calibEne[1];
 716      calibTowZN2[gi+5] = equalTowZN2[gi+5]*calibEne[2];
 717      calibTowZP2[gi+5] = equalTowZP2[gi+5]*calibEne[3];
 718   }
 719   //
 720   Float_t sumZEM[]={0,0}, calibZEM1[]={0,0}, calibZEM2[]={0,0};
 721   calibZEM1[0] = corrADCZEM1[0]*calibEne[5];
 722   calibZEM1[1] = corrADCZEM1[1]*calibEne[5];
 723   calibZEM2[0] = corrADCZEM2[0]*calibEne[5];
 724   calibZEM2[1] = corrADCZEM2[1]*calibEne[5];
 725   for(Int_t k=0; k<2; k++) sumZEM[k] = calibZEM1[k] + calibZEM2[k];
 726   // Ch. debug
 727   /*printf("\n ------------- CALIBRATION -------------\n");
 728   printf(" ADCZN1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 729         calibTowZN1[0],calibTowZN1[1],calibTowZN1[2],calibTowZN1[3],calibTowZN1[4]);
 730   printf(" ADCZP1 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 731         calibTowZP1[0],calibTowZP1[1],calibTowZP1[2],calibTowZP1[3],calibTowZP1[4]);
 732   printf(" ADCZN2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 733         calibTowZN2[0],calibTowZN2[1],calibTowZN2[2],calibTowZN2[3],calibTowZN2[4]);
 734   printf(" ADCZP2 [%1.2f %1.2f %1.2f %1.2f %1.2f]\n",
 735         calibTowZP2[0],calibTowZP2[1],calibTowZP2[2],calibTowZP2[3],calibTowZP2[4]);
 736   printf(" ADCZEM1 [%1.2f] ADCZEM2 [%1.2f] \n",calibZEM1[0],calibZEM2[0]);
 737   printf(" ----------------------------------------\n");*/
 738
 739   //  ******    No. of spectator and participants nucleons
 740   //  Variables calculated to comply with ESD structure
 741   //  *** N.B. -> They have a meaning only in Pb-Pb!!!!!!!!!!!!
 742   Int_t nDetSpecNLeft=0, nDetSpecPLeft=0, nDetSpecNRight=0, nDetSpecPRight=0;
 743   Int_t nGenSpec=0, nGenSpecLeft=0, nGenSpecRight=0;
 744   Int_t nPart=0, nPartTotLeft=0, nPartTotRight=0;
 745   Double_t impPar=0., impPar1=0., impPar2=0.;
 746
 747   // create the output tree
 748   AliZDCReco* reco = new AliZDCReco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2,
 749                    calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2,
 750                    calibZEM1, calibZEM2, sPMRef1, sPMRef2,
 751                    nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight,
 752                    nGenSpec, nGenSpecLeft, nGenSpecRight,
 753                    nPart, nPartTotLeft, nPartTotRight,
 754                    impPar, impPar1, impPar2,
 755                    recoFlag, isScalerOn, scaler);
 756
 757   const Int_t kBufferSize = 4000;
 758   clustersTree->Branch("ZDC", "AliZDCReco", &reco, kBufferSize);
 759   // write the output tree
 760   clustersTree->Fill();
 761 }
 762
 763 //_____________________________________________________________________________
 764 void AliZDCReconstructor::ReconstructEventPbPb(TTree *clustersTree,
 765         Float_t* corrADCZN1, Float_t* corrADCZP1, Float_t* corrADCZN2, Float_t* corrADCZP2,
 766         Float_t* corrADCZEM1, Float_t* corrADCZEM2, Float_t* sPMRef1, Float_t* sPMRef2,
 767         Bool_t isScalerOn, UInt_t* scaler,
 768         Int_t* evQualityBlock, Int_t* triggerBlock, Int_t* chBlock, UInt_t puBits) const
 769 {
 770   // ****************** Reconstruct one event ******************
 771   // ---------------------- Setting reco flags for ESD
 772   UInt_t rFlags[32];
 773   for(Int_t ifl=0; ifl<32; ifl++) rFlags[ifl]=0;
 774
 775   if(evQualityBlock[0] == 1) rFlags[31] = 0x0;
 776   else rFlags[31] = 0x1;
 777   //
 778   if(evQualityBlock[1] == 1) rFlags[30] = 0x1;
 779   if(evQualityBlock[2] == 1) rFlags[29] = 0x1;
 780   if(evQualityBlock[3] == 1) rFlags[28] = 0x1;
 781
 782   if(triggerBlock[0] == 1) rFlags[27] = 0x1;
 783   if(triggerBlock[1] == 1) rFlags[26] = 0x1;
 784   if(triggerBlock[2] == 1) rFlags[25] = 0x1;
 785   if(triggerBlock[3] == 1) rFlags[24] = 0x1;
 786
 787   if(chBlock[0] == 1) rFlags[18] = 0x1;
 788   if(chBlock[1] == 1) rFlags[17] = 0x1;
 789   if(chBlock[2] == 1) rFlags[16] = 0x1;
 790
 791   rFlags[13] = puBits & 0x00000020;
 792   rFlags[12] = puBits & 0x00000010;
 793   rFlags[11] = puBits & 0x00000080;
 794   rFlags[10] = puBits & 0x00000040;
 795   rFlags[9]  = puBits & 0x00000020;
 796   rFlags[8]  = puBits & 0x00000010;
 797
 798   if(corrADCZP1[0]>fSignalThreshold)  rFlags[5] = 0x1;
 799   if(corrADCZN1[0]>fSignalThreshold)  rFlags[4] = 0x1;
 800   if(corrADCZEM2[0]>fSignalThreshold) rFlags[3] = 0x1;
 801   if(corrADCZEM1[0]>fSignalThreshold) rFlags[2] = 0x1;
 802   if(corrADCZP2[0]>fSignalThreshold)  rFlags[1] = 0x1;
 803   if(corrADCZN2[0]>fSignalThreshold)  rFlags[0] = 0x1;
 804
 805   UInt_t recoFlag = rFlags[31] << 31 | rFlags[30] << 30 | rFlags[29] << 29 | rFlags[28] << 28 |
 806              rFlags[27] << 27 | rFlags[26] << 26 | rFlags[25] << 25 | rFlags[24] << 24 |
 807              0x0 << 23 | 0x0 << 22 | 0x0 << 21 | 0x0 << 20 |
 808              0x0 << 19 | rFlags[18] << 18 |  rFlags[17] << 17 |  rFlags[16] << 16 |
 809              0x0 << 15 | 0x0 << 14 | rFlags[13] << 13 | rFlags[12] << 12 |
 810              rFlags[11] << 11 |rFlags[10] << 10 | rFlags[9] << 9 | rFlags[8] << 8 |
 811              0x0 << 7 | 0x0 << 6 | rFlags[5] << 5 | rFlags[4] << 4 |
 812              rFlags[3] << 3 | rFlags[2] << 2 | rFlags[1] << 1 | rFlags[0];
 813   // --------------------------------------------------
 814
 815
 816   // ******     Retrieving calibration data
 817   // --- Equalization coefficients ---------------------------------------------
 818   Float_t equalCoeffZN1[5], equalCoeffZP1[5], equalCoeffZN2[5], equalCoeffZP2[5];
 819   for(Int_t ji=0; ji<5; ji++){
 820      equalCoeffZN1[ji] = fTowCalibData->GetZN1EqualCoeff(ji);
 821      equalCoeffZP1[ji] = fTowCalibData->GetZP1EqualCoeff(ji);
 822      equalCoeffZN2[ji] = fTowCalibData->GetZN2EqualCoeff(ji);
 823      equalCoeffZP2[ji] = fTowCalibData->GetZP2EqualCoeff(ji);
 824   }
 825   // --- Energy calibration factors ------------------------------------
 826   Float_t valFromOCDB[6], calibEne[6];
 827   for(Int_t ij=0; ij<6; ij++){
 828     valFromOCDB[ij] = fEnCalibData->GetEnCalib(ij);
 829     if(ij<4){
 830       if(valFromOCDB[ij]!=0) calibEne[ij] = fBeamEnergy/valFromOCDB[ij];
 831       else AliWarning(" Value from OCDB for E calibration = 0 !!!\n");
 832     }
 833     else calibEne[ij] = valFromOCDB[ij];
 834   }
 835
 836   // ******     Equalization of detector responses
 837   Float_t equalTowZN1[10], equalTowZN2[10], equalTowZP1[10], equalTowZP2[10];
 838   for(Int_t gi=0; gi<10; gi++){
 839      if(gi<5){
 840        equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi];
 841        equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi];
 842        equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi];
 843        equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi];
 844      }
 845      else{
 846        equalTowZN1[gi] = corrADCZN1[gi]*equalCoeffZN1[gi-5];
 847        equalTowZP1[gi] = corrADCZP1[gi]*equalCoeffZP1[gi-5];
 848        equalTowZN2[gi] = corrADCZN2[gi]*equalCoeffZN2[gi-5];
 849        equalTowZP2[gi] = corrADCZP2[gi]*equalCoeffZP2[gi-5];
 850      }
 851   }
 852
 853   // ******     Summed response for hadronic calorimeter (SUMMED and then CALIBRATED!)
 854   Float_t calibSumZN1[]={0,0}, calibSumZN2[]={0,0}, calibSumZP1[]={0,0}, calibSumZP2[]={0,0};
 855   for(Int_t gi=0; gi<5; gi++){
 856        calibSumZN1[0] += equalTowZN1[gi];
 857        calibSumZP1[0] += equalTowZP1[gi];
 858        calibSumZN2[0] += equalTowZN2[gi];
 859        calibSumZP2[0] += equalTowZP2[gi];
 860        //
 861        calibSumZN1[1] += equalTowZN1[gi+5];
 862        calibSumZP1[1] += equalTowZP1[gi+5];
 863        calibSumZN2[1] += equalTowZN2[gi+5];
 864        calibSumZP2[1] += equalTowZP2[gi+5];
 865   }
 866   // High gain chain
 867   calibSumZN1[0] = calibSumZN1[0]*calibEne[0]*8.;
 868   calibSumZP1[0] = calibSumZP1[0]*calibEne[1]*8.;
 869   calibSumZN2[0] = calibSumZN2[0]*calibEne[2]*8.;
 870   calibSumZP2[0] = calibSumZP2[0]*calibEne[3]*8.;
 871   // Low gain chain
 872   calibSumZN1[1] = calibSumZN1[1]*calibEne[0];
 873   calibSumZP1[1] = calibSumZP1[1]*calibEne[1];
 874   calibSumZN2[1] = calibSumZN2[1]*calibEne[2];
 875   calibSumZP2[1] = calibSumZP2[1]*calibEne[3];
 876   //
 877   Float_t sumZEM[]={0,0}, calibZEM1[]={0,0}, calibZEM2[]={0,0};
 878   calibZEM1[0] = corrADCZEM1[0]*calibEne[5]*8.;
 879   calibZEM1[1] = corrADCZEM1[1]*calibEne[5];
 880   calibZEM2[0] = corrADCZEM2[0]*calibEne[5]*8.;
 881   calibZEM2[1] = corrADCZEM2[1]*calibEne[5];
 882   for(Int_t k=0; k<2; k++) sumZEM[k] = calibZEM1[k] + calibZEM2[k];
 883
 884   // ******     Energy calibration of detector responses
 885   Float_t calibTowZN1[10], calibTowZN2[10], calibTowZP1[10], calibTowZP2[10];
 886   for(Int_t gi=0; gi<5; gi++){
 887      // High gain chain
 888      calibTowZN1[gi] = equalTowZN1[gi]*calibEne[0]*8.;
 889      calibTowZP1[gi] = equalTowZP1[gi]*calibEne[1]*8.;
 890      calibTowZN2[gi] = equalTowZN2[gi]*calibEne[2]*8.;
 891      calibTowZP2[gi] = equalTowZP2[gi]*calibEne[3]*8.;
 892      // Low gain chain
 893      calibTowZN1[gi+5] = equalTowZN1[gi+5]*calibEne[0];
 894      calibTowZP1[gi+5] = equalTowZP1[gi+5]*calibEne[1];
 895      calibTowZN2[gi+5] = equalTowZN2[gi+5]*calibEne[2];
 896      calibTowZP2[gi+5] = equalTowZP2[gi+5]*calibEne[3];
 897   }
 898
 899   //  ******    Number of detected spectator nucleons
 900   Int_t nDetSpecNLeft=0, nDetSpecPLeft=0, nDetSpecNRight=0, nDetSpecPRight=0;
 901   if(fBeamEnergy!=0){
 902     nDetSpecNLeft = (Int_t) (calibSumZN1[0]/fBeamEnergy);
 903     nDetSpecPLeft = (Int_t) (calibSumZP1[0]/fBeamEnergy);
 904     nDetSpecNRight = (Int_t) (calibSumZN2[0]/fBeamEnergy);
 905     nDetSpecPRight = (Int_t) (calibSumZP2[0]/fBeamEnergy);
 906   }
 907   else AliWarning(" ATTENTION!!! fBeamEnergy=0 -> N_spec will be ZERO!!! \n");
 908   /*printf("\n\t AliZDCReconstructor -> nDetSpecNLeft %d, nDetSpecPLeft %d,"
 909     " nDetSpecNRight %d, nDetSpecPRight %d\n",nDetSpecNLeft, nDetSpecPLeft,
 910     nDetSpecNRight, nDetSpecPRight);*/
 911
 912   Int_t nGenSpec=0, nGenSpecA=0, nGenSpecC=0;
 913   Int_t nPart=0, nPartA=0, nPartC=0;
 914   Double_t b=0., bA=0., bC=0.;
 915
 916   if(fIsCalibrationMB == kFALSE){
 917     // ******   Reconstruction parameters ------------------
 918     // Ch. debug
 919     //fRecoParam->Print("");
 920     //
 921
 922     if (!fRecoParam) fRecoParam = const_cast<AliZDCRecoParam*>(GetRecoParam());
 923
 924     TH2F *hZDCvsZEM  = fRecoParam->GethZDCvsZEM();
 925     TH2F *hZDCCvsZEM = fRecoParam->GethZDCCvsZEM();
 926     TH2F *hZDCAvsZEM = fRecoParam->GethZDCAvsZEM();
 927     TH1D *hNpartDist = fRecoParam->GethNpartDist();
 928     TH1D *hbDist = fRecoParam->GethbDist();
 929     Float_t ClkCenter = fRecoParam->GetClkCenter();
 930     //
 931     Double_t xHighEdge = hZDCvsZEM->GetXaxis()->GetXmax();
 932     Double_t origin = xHighEdge*ClkCenter;
 933     // Ch. debug
 934     //printf("\n\n  xHighEdge %1.2f, origin %1.4f \n", xHighEdge, origin);
 935     //
 936     // ====> Summed ZDC info (sideA+side C)
 937     TF1 *line = new TF1("line","[0]*x+[1]",0.,xHighEdge);
 938     Float_t y = (calibSumZN1[0]+calibSumZP1[0]+calibSumZN2[0]+calibSumZP2[0])/1000.;
 939     Float_t x = (calibZEM1[0]+calibZEM2[0])/1000.;
 940     line->SetParameter(0, y/(x-origin));
 941     line->SetParameter(1, -origin*y/(x-origin));
 942     // Ch. debug
 943     //printf("  ***************** Summed ZDC info (sideA+side C) \n");
 944     //printf("  E_{ZEM} %1.4f, E_{ZDC} %1.2f, TF1: %1.2f*x + %1.2f   ", x, y,y/(x-origin),-origin*y/(x-origin));
 945     //
 946     Double_t countPerc=0;
 947     Double_t xBinCenter=0, yBinCenter=0;
 948     for(Int_t nbinx=1; nbinx<=hZDCvsZEM->GetNbinsX(); nbinx++){
 949       for(Int_t nbiny=1; nbiny<=hZDCvsZEM->GetNbinsY(); nbiny++){
 950          xBinCenter = hZDCvsZEM->GetXaxis()->GetBinCenter(nbinx);
 951          yBinCenter = hZDCvsZEM->GetYaxis()->GetBinCenter(nbiny);
 952          //
 953          if(line->GetParameter(0)>0){
 954            if(yBinCenter < (line->GetParameter(0)*xBinCenter + line->GetParameter(1))){
 955              countPerc += hZDCvsZEM->GetBinContent(nbinx,nbiny);
 956              // Ch. debug
 957              /*printf(" xBinCenter  %1.3f, yBinCenter %1.0f,  countPerc %1.0f\n",
 958                 xBinCenter, yBinCenter, countPerc);*/
 959            }
 960          }
 961          else{
 962            if(yBinCenter > (line->GetParameter(0)*xBinCenter + line->GetParameter(1))){
 963              countPerc += hZDCvsZEM->GetBinContent(nbinx,nbiny);
 964              // Ch. debug
 965              /*printf(" xBinCenter  %1.3f, yBinCenter %1.0f,  countPerc %1.0f\n",
 966                 xBinCenter, yBinCenter, countPerc);*/
 967            }
 968          }
 969       }
 970     }
 971     //
 972     Double_t xSecPerc = 0.;
 973     if(hZDCvsZEM->GetEntries()!=0){
 974       xSecPerc = countPerc/hZDCvsZEM->GetEntries();
 975     }
 976     else{
 977       AliWarning("  Histogram hZDCvsZEM from OCDB has no entries!!!");
 978     }
 979     // Ch. debug
 980     //printf("  xSecPerc %1.4f  \n", xSecPerc);
 981
 982     // ====> side C
 983     TF1 *lineC = new TF1("lineC","[0]*x+[1]",0.,xHighEdge);
 984     Float_t yC = (calibSumZN1[0]+calibSumZP1[0])/1000.;
 985     lineC->SetParameter(0, yC/(x-origin));
 986     lineC->SetParameter(1, -origin*yC/(x-origin));
 987     // Ch. debug
 988     //printf("  ***************** Side C \n");
 989     //printf("  E_{ZEM} %1.4f, E_{ZDCC} %1.2f, TF1: %1.2f*x + %1.2f   ", x, yC,yC/(x-origin),-origin*yC/(x-origin));
 990     //
 991     Double_t countPercC=0;
 992     Double_t xBinCenterC=0, yBinCenterC=0;
 993     for(Int_t nbinx=1; nbinx<=hZDCCvsZEM->GetNbinsX(); nbinx++){
 994       for(Int_t nbiny=1; nbiny<=hZDCCvsZEM->GetNbinsY(); nbiny++){
 995          xBinCenterC = hZDCCvsZEM->GetXaxis()->GetBinCenter(nbinx);
 996          yBinCenterC = hZDCCvsZEM->GetYaxis()->GetBinCenter(nbiny);
 997          if(lineC->GetParameter(0)>0){
 998            if(yBinCenterC < (lineC->GetParameter(0)*xBinCenterC + lineC->GetParameter(1))){
 999              countPercC += hZDCCvsZEM->GetBinContent(nbinx,nbiny);
1000            }
1001          }
1002          else{
1003            if(yBinCenterC > (lineC->GetParameter(0)*xBinCenterC + lineC->GetParameter(1))){
1004              countPercC += hZDCCvsZEM->GetBinContent(nbinx,nbiny);
1005            }
1006          }
1007       }
1008     }
1009     //
1010     Double_t xSecPercC = 0.;
1011     if(hZDCCvsZEM->GetEntries()!=0){
1012       xSecPercC = countPercC/hZDCCvsZEM->GetEntries();
1013     }
1014     else{
1015       AliWarning("  Histogram hZDCCvsZEM from OCDB has no entries!!!");
1016     }
1017     // Ch. debug
1018     //printf("  xSecPercC %1.4f  \n", xSecPercC);
1019
1020     // ====> side A
1021     TF1 *lineA = new TF1("lineA","[0]*x+[1]",0.,xHighEdge);
1022     Float_t yA = (calibSumZN2[0]+calibSumZP2[0])/1000.;
1023     lineA->SetParameter(0, yA/(x-origin));
1024     lineA->SetParameter(1, -origin*yA/(x-origin));
1025     //
1026     // Ch. debug
1027     //printf("  ***************** Side A \n");
1028     //printf("  E_{ZEM} %1.4f, E_{ZDCA} %1.2f, TF1: %1.2f*x + %1.2f   ", x, yA,yA/(x-origin),-origin*yA/(x-origin));
1029     //
1030     Double_t countPercA=0;
1031     Double_t xBinCenterA=0, yBinCenterA=0;
1032     for(Int_t nbinx=1; nbinx<=hZDCAvsZEM->GetNbinsX(); nbinx++){
1033       for(Int_t nbiny=1; nbiny<=hZDCAvsZEM->GetNbinsY(); nbiny++){
1034          xBinCenterA = hZDCAvsZEM->GetXaxis()->GetBinCenter(nbinx);
1035          yBinCenterA = hZDCAvsZEM->GetYaxis()->GetBinCenter(nbiny);
1036          if(lineA->GetParameter(0)>0){
1037            if(yBinCenterA < (lineA->GetParameter(0)*xBinCenterA + lineA->GetParameter(1))){
1038              countPercA += hZDCAvsZEM->GetBinContent(nbinx,nbiny);
1039            }
1040          }
1041          else{
1042            if(yBinCenterA > (lineA->GetParameter(0)*xBinCenterA + lineA->GetParameter(1))){
1043              countPercA += hZDCAvsZEM->GetBinContent(nbinx,nbiny);
1044            }
1045          }
1046       }
1047     }
1048     //
1049     Double_t xSecPercA = 0.;
1050     if(hZDCAvsZEM->GetEntries()!=0){
1051       xSecPercA = countPercA/hZDCAvsZEM->GetEntries();
1052     }
1053     else{
1054       AliWarning("  Histogram hZDCAvsZEM from OCDB has no entries!!!");
1055     }
1056     // Ch. debug
1057     //printf("  xSecPercA %1.4f  \n", xSecPercA);
1058
1059     //  ******    Number of participants (from E_ZDC vs. E_ZEM correlation)
1060     Double_t nPartFrac=0., nPartFracC=0., nPartFracA=0.;
1061     for(Int_t npbin=1; npbin<hNpartDist->GetNbinsX(); npbin++){
1062       nPartFrac += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries());
1063       if((1.-nPartFrac) < xSecPerc){
1064         nPart = (Int_t) hNpartDist->GetBinLowEdge(npbin);
1065         // Ch. debug
1066         //printf("  ***************** Summed ZDC info (sideA+side C) \n");
1067         //printf("  nPartFrac %1.4f, nPart %d\n", nPartFrac, nPart);
1068         break;
1069       }
1070     }
1071     if(nPart<0) nPart=0;
1072     //
1073     for(Int_t npbin=1; npbin<hNpartDist->GetNbinsX(); npbin++){
1074       nPartFracC += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries());
1075       if((1.-nPartFracC) < xSecPercC){
1076         nPartC = (Int_t) hNpartDist->GetBinLowEdge(npbin);
1077         // Ch. debug
1078         //printf("  ***************** Side C \n");
1079         //printf("  nPartFracC %1.4f, nPartC %d\n", nPartFracC, nPartC);
1080         break;
1081     }
1082     }
1083     if(nPartC<0) nPartC=0;
1084     //
1085     for(Int_t npbin=1; npbin<hNpartDist->GetNbinsX(); npbin++){
1086       nPartFracA += (hNpartDist->GetBinContent(npbin))/(hNpartDist->GetEntries());
1087       if((1.-nPartFracA) < xSecPercA){
1088         nPartA = (Int_t) hNpartDist->GetBinLowEdge(npbin);
1089         // Ch. debug
1090         //printf("  ***************** Side A \n");
1091         //printf("  nPartFracA %1.4f, nPartA %d\n\n", nPartFracA, nPartA);
1092         break;
1093       }
1094     }
1095     if(nPartA<0) nPartA=0;
1096
1097     //  ******    Impact parameter (from E_ZDC vs. E_ZEM correlation)
1098     Double_t bFrac=0., bFracC=0., bFracA=0.;
1099     for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
1100       bFrac += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries());
1101       if((1.-bFrac) < xSecPerc){
1102         b = hbDist->GetBinLowEdge(ibbin);
1103         break;
1104       }
1105     }
1106     //
1107     for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
1108       bFracC += (hbDist->GetBinContent(ibbin))/(hbDist->GetEntries());
1109       if((1.-bFracC) < xSecPercC){
1110         bC = hbDist->GetBinLowEdge(ibbin);
1111         break;
1112       }
1113     }
1114     //
1115     for(Int_t ibbin=1; ibbin<hbDist->GetNbinsX(); ibbin++){
1116       bFracA += (hbDist->GetBinContent(ibbin))/(hNpartDist->GetEntries());
1117       if((1.-bFracA) < xSecPercA){
1118         bA = hbDist->GetBinLowEdge(ibbin);
1119         break;
1120       }
1121     }
1122
1123     //  ******  Number of spectator nucleons
1124     nGenSpec = 416 - nPart;
1125     nGenSpecC = 416 - nPartC;
1126     nGenSpecA = 416 - nPartA;
1127     if(nGenSpec>416) nGenSpec=416; if(nGenSpec<0) nGenSpec=0;
1128     if(nGenSpecC>416) nGenSpecC=416; if(nGenSpecC<0) nGenSpecC=0;
1129     if(nGenSpecA>416) nGenSpecA=416; if(nGenSpecA<0) nGenSpecA=0;
1130
1131     //  Ch. debug
1132     /*printf("\n\t AliZDCReconstructor -> calibSumZN1[0] %1.0f, calibSumZP1[0] %1.0f,"
1133         "  calibSumZN2[0] %1.0f, calibSumZP2[0] %1.0f, corrADCZEMHG %1.0f\n",
1134         calibSumZN1[0],calibSumZP1[0],calibSumZN2[0],calibSumZP2[0],corrADCZEMHG);
1135     printf("\t AliZDCReconstructor -> nGenSpecLeft %d nGenSpecRight %d\n",
1136         nGenSpecLeft, nGenSpecRight);
1137     printf("\t AliZDCReconstructor ->  NpartL %d,  NpartR %d,  b %1.2f fm\n\n",nPartTotLeft, nPartTotRight, impPar);
1138     */
1139
1140     delete lineC;  delete lineA;
1141
1142   } // ONLY IF fIsCalibrationMB==kFALSE
1143
1144   AliZDCReco* reco = new AliZDCReco(calibSumZN1, calibSumZP1, calibSumZN2, calibSumZP2,
1145                   calibTowZN1, calibTowZP1, calibTowZN2, calibTowZP2,
1146                   calibZEM1, calibZEM2, sPMRef1, sPMRef2,
1147                   nDetSpecNLeft, nDetSpecPLeft, nDetSpecNRight, nDetSpecPRight,
1148                   nGenSpec, nGenSpecA, nGenSpecC,
1149                   nPart, nPartA, nPartC, b, bA, bC,
1150                   recoFlag, isScalerOn, scaler);
1151
1152   const Int_t kBufferSize = 4000;
1153   clustersTree->Branch("ZDC", "AliZDCReco", &reco, kBufferSize);
1154   //reco->Print("");
1155   // write the output tree
1156   clustersTree->Fill();
1157 }
1158
1159 //_____________________________________________________________________________
1160 void AliZDCReconstructor::BuildRecoParam(Float_t ZDCC, Float_t ZDCA, Float_t ZEM) const
1161 {
1162   // Calculate RecoParam object for Pb-Pb data
1163   (fRecoParam->GethZDCvsZEM())->Fill(ZDCC+ZDCA, ZEM);
1164   (fRecoParam->GethZDCCvsZEM())->Fill(ZDCC, ZEM);
1165   (fRecoParam->GethZDCAvsZEM())->Fill(ZDCA, ZEM);
1166
1167 }
1168
1169 //_____________________________________________________________________________
1170 void AliZDCReconstructor::FillZDCintoESD(TTree *clustersTree, AliESDEvent* esd) const
1171 {
1172   // fill energies and number of participants to the ESD
1173
1174   AliZDCReco reco;
1175   AliZDCReco* preco = &reco;
1176   clustersTree->SetBranchAddress("ZDC", &preco);
1177
1178   clustersTree->GetEntry(0);
1179   //
1180   AliESDZDC * esdzdc = esd->GetESDZDC();
1181   Float_t tZN1Ene[5], tZN2Ene[5], tZP1Ene[5], tZP2Ene[5];
1182   Float_t tZN1EneLR[5], tZN2EneLR[5], tZP1EneLR[5], tZP2EneLR[5];
1183   for(Int_t i=0; i<5; i++){
1184      tZN1Ene[i] = reco.GetZN1HREnTow(i);
1185      tZN2Ene[i] = reco.GetZN2HREnTow(i);
1186      tZP1Ene[i] = reco.GetZP1HREnTow(i);
1187      tZP2Ene[i] = reco.GetZP2HREnTow(i);
1188      //
1189      tZN1EneLR[i] = reco.GetZN1LREnTow(i);
1190      tZN2EneLR[i] = reco.GetZN2LREnTow(i);
1191      tZP1EneLR[i] = reco.GetZP1LREnTow(i);
1192      tZP2EneLR[i] = reco.GetZP2LREnTow(i);
1193   }
1194   //
1195   esdzdc->SetZN1TowerEnergy(tZN1Ene);
1196   esdzdc->SetZN2TowerEnergy(tZN2Ene);
1197   esdzdc->SetZP1TowerEnergy(tZP1Ene);
1198   esdzdc->SetZP2TowerEnergy(tZP2Ene);
1199   //
1200   esdzdc->SetZN1TowerEnergyLR(tZN1EneLR);
1201   esdzdc->SetZN2TowerEnergyLR(tZN2EneLR);
1202   esdzdc->SetZP1TowerEnergyLR(tZP1EneLR);
1203   esdzdc->SetZP2TowerEnergyLR(tZP2EneLR);
1204   //
1205   Int_t nPart  = reco.GetNParticipants();
1206   Int_t nPartA = reco.GetNPartSideA();
1207   Int_t nPartC = reco.GetNPartSideC();
1208   Double_t b  = reco.GetImpParameter();
1209   Double_t bA = reco.GetImpParSideA();
1210   Double_t bC = reco.GetImpParSideC();
1211   UInt_t recoFlag = reco.GetRecoFlag();
1212   //
1213   esd->SetZDC(reco.GetZN1HREnergy(), reco.GetZP1HREnergy(), reco.GetZEM1HRsignal(),
1214               reco.GetZEM2HRsignal(), reco.GetZN2HREnergy(), reco.GetZP2HREnergy(),
1215               nPart, nPartA, nPartC, b, bA, bC, recoFlag);
1216
1217   // Writing ZDC scaler for cross section calculation
1218   // ONLY IF the scaler has been read during the event
1219   if(reco.IsScalerOn()==kTRUE){
1220     UInt_t counts[32];
1221     for(Int_t jk=0; jk<32; jk++) counts[jk] = reco.GetZDCScaler(jk);
1222     esd->SetZDCScaler(counts);
1223   }
1224 }
1225
1226 //_____________________________________________________________________________
1227 AliCDBStorage* AliZDCReconstructor::SetStorage(const char *uri)
1228 {
1229   // Setting the storage
1230
1231   Bool_t deleteManager = kFALSE;
1232
1233   AliCDBManager *manager = AliCDBManager::Instance();
1234   AliCDBStorage *defstorage = manager->GetDefaultStorage();
1235
1236   if(!defstorage || !(defstorage->Contains("ZDC"))){
1237      AliWarning("No default storage set or default storage doesn't contain ZDC!");
1238      manager->SetDefaultStorage(uri);
1239      deleteManager = kTRUE;
1240   }
1241
1242   AliCDBStorage *storage = manager->GetDefaultStorage();
1243
1244   if(deleteManager){
1245     AliCDBManager::Instance()->UnsetDefaultStorage();
1246     defstorage = 0;   // the storage is killed by AliCDBManager::Instance()->Destroy()
1247   }
1248
1249   return storage;
1250 }
1251
1252 //_____________________________________________________________________________
1253 AliZDCPedestals* AliZDCReconstructor::GetPedestalData() const
1254 {
1255
1256   // Getting pedestal calibration object for ZDC set
1257
1258   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/Pedestals");
1259   if(!entry) AliFatal("No calibration data loaded!");
1260   entry->SetOwner(kFALSE);
1261
1262   AliZDCPedestals *calibdata = dynamic_cast<AliZDCPedestals*>  (entry->GetObject());
1263   if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
1264
1265   return calibdata;
1266 }
1267
1268 //_____________________________________________________________________________
1269 AliZDCEnCalib* AliZDCReconstructor::GetEnergyCalibData() const
1270 {
1271
1272   // Getting energy and equalization calibration object for ZDC set
1273
1274   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/EnergyCalib");
1275   if(!entry) AliFatal("No calibration data loaded!");
1276   entry->SetOwner(kFALSE);
1277
1278   AliZDCEnCalib *calibdata = dynamic_cast<AliZDCEnCalib*> (entry->GetObject());
1279   if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
1280
1281   return calibdata;
1282 }
1283
1284 //_____________________________________________________________________________
1285 AliZDCTowerCalib* AliZDCReconstructor::GetTowerCalibData() const
1286 {
1287
1288   // Getting energy and equalization calibration object for ZDC set
1289
1290   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/TowerCalib");
1291   if(!entry) AliFatal("No calibration data loaded!");
1292   entry->SetOwner(kFALSE);
1293
1294   AliZDCTowerCalib *calibdata = dynamic_cast<AliZDCTowerCalib*> (entry->GetObject());
1295   if(!calibdata)  AliFatal("Wrong calibration object in calibration  file!");
1296
1297   return calibdata;
1298 }
1299
1300 //_____________________________________________________________________________
1301 AliZDCRecoParampp* AliZDCReconstructor::GetppRecoParamFromOCDB() const
1302 {
1303
1304   // Getting reconstruction parameters from OCDB
1305
1306   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/RecoParampp");
1307   if(!entry) AliFatal("No RecoParam data found in OCDB!");
1308
1309   AliZDCRecoParampp *param = dynamic_cast<AliZDCRecoParampp*> (entry->GetObject());
1310   if(!param)  AliFatal("No RecoParam object in OCDB entry!");
1311
1312   return param;
1313
1314 }
1315
1316 //_____________________________________________________________________________
1317 AliZDCRecoParamPbPb* AliZDCReconstructor::GetPbPbRecoParamFromOCDB() const
1318 {
1319
1320   // Getting reconstruction parameters from OCDB
1321
1322   AliCDBEntry  *entry = AliCDBManager::Instance()->Get("ZDC/Calib/RecoParamPbPb");
1323   if(!entry) AliFatal("No RecoParam data found in OCDB!");
1324
1325   AliZDCRecoParamPbPb *param = dynamic_cast<AliZDCRecoParamPbPb*> (entry->GetObject());
1326   if(!param)  AliFatal("No RecoParam object in OCDB entry!");
1327
1328   return param;
1329
1330 }