ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id: AliEMCALCalibTimeDep.cxx $ */

//_________________________________________________________________________
///*-- Author: 
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// class for EMCAL time-dep calibration   
// - supposed to run in preprocessor
// we use input from the following sources:
// AliEMCALCalibTempCoeff (APD temperature coefficients),
// AliCaloCalibSignal (LED DA), AliEMCALSensorTempArray (ELMB DCS)
// AliEMCALCalibReference: LED amplitude and temperature info at reference time
//
// output/result is in AliEMCALCalibTimeDepCorrection 
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <TGraphSmooth.h>
#include <TMath.h>
#include "AliLog.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliEMCALSensorTempArray.h"
#include "AliCaloCalibSignal.h"
#include "AliEMCALCalibTempCoeff.h"
#include "AliEMCALCalibReference.h"
#include "AliEMCALCalibTimeDepCorrection.h" 
#include "AliEMCALCalibTimeDep.h"

/* first a bunch of constants.. */
const double kSecToHour = 1.0/3600.0; // conversion factor from seconds to hours

// some global variables for APD handling; values from Catania studies, best fit
// TempCoeff = p0+p1*M (M=gain), where p0 and and p1 are functions of the dark current
const double kTempCoeffP0Const = -0.903; // 
const double kTempCoeffP0Factor = -1.381e7; // 
const double kTempCoeffP1Const = -0.023; // 
const double kTempCoeffP1Factor = -4.966e5; //
 
const double kTempMaxDiffMedian = 2; // Temperature values should not be further away from median value within SM when considered in the average calc.

const double kErrorCode = -999; // to indicate that something went wrong

using namespace std;

ClassImp(AliEMCALCalibTimeDep)

//________________________________________________________________
AliEMCALCalibTimeDep::AliEMCALCalibTimeDep() :
  fRun(0),
  fStartTime(0),
  fEndTime(0),
  fMinTemp(0),
  fMaxTemp(0),
  fMinTempVariation(0),
  fMaxTempVariation(0),
  fMinTempValid(15),
  fMaxTempValid(35),
  fMinTime(0),
  fMaxTime(0),
  fTemperatureResolution(0.1), // 0.1 deg C is default
  fMaxTemperatureDiff(5), // 5 deg C is default max diff relative to reference 
  fTimeBinsPerHour(2), // 2 30-min bins per hour is default
  fHighLowGainFactor(16), // factor ~16 between High gain and low gain
  fTempArray(NULL),
  fCalibSignal(NULL),
  fCalibTempCoeff(NULL),
  fCalibReference(NULL),
  fCalibTimeDepCorrection(NULL),
  fVerbosity(0)
{
  // Constructor
}

//________________________________________________________________
AliEMCALCalibTimeDep::AliEMCALCalibTimeDep(const AliEMCALCalibTimeDep& calibt) :
  TObject(calibt),
  fRun(calibt.GetRunNumber()),
  fStartTime(calibt.GetStartTime()),
  fEndTime(calibt.GetEndTime()),
  fMinTemp(calibt.GetMinTemp()),
  fMaxTemp(calibt.GetMaxTemp()),
  fMinTempVariation(calibt.GetMinTempVariation()),
  fMaxTempVariation(calibt.GetMaxTempVariation()),
  fMinTempValid(calibt.GetMinTempValid()),
  fMaxTempValid(calibt.GetMaxTempValid()),
  fMinTime(calibt.GetMinTime()),
  fMaxTime(calibt.GetMaxTime()),
  fTemperatureResolution(calibt.GetTemperatureResolution()),
  fMaxTemperatureDiff(calibt.GetMaxTemperatureDiff()),
  fTimeBinsPerHour(calibt.GetTimeBinsPerHour()),
  fHighLowGainFactor(calibt.GetHighLowGainFactor()),
  fTempArray(calibt.GetTempArray()),
  fCalibSignal(calibt.GetCalibSignal()),
  fCalibTempCoeff(calibt.GetCalibTempCoeff()),
  fCalibReference(calibt.GetCalibReference()),
  fCalibTimeDepCorrection(calibt.GetCalibTimeDepCorrection()),
  fVerbosity(calibt.GetVerbosity())
{
  // copy constructor
}


//________________________________________________________________
AliEMCALCalibTimeDep &AliEMCALCalibTimeDep::operator =(const AliEMCALCalibTimeDep& calibt)
{
  // assignment operator; use copy ctor
  if (&calibt == this) return *this;

  new (this) AliEMCALCalibTimeDep(calibt);
  return *this;
}

//________________________________________________________________
AliEMCALCalibTimeDep::~AliEMCALCalibTimeDep()
{
  // Destructor
}

//________________________________________________________________
void  AliEMCALCalibTimeDep::Reset() 
{
  // clear variables to default
  fRun = 0;
  fStartTime = 0;
  fEndTime = 0;
  fMinTemp = 0;
  fMaxTemp = 0;
  fMinTempVariation = 0;
  fMaxTempVariation = 0;
  fMinTempValid = 15; 
  fMaxTempValid = 35;
  fMinTime = 0;
  fMaxTime = 0;
  fTemperatureResolution = 0.1; // 0.1 deg C is default
  fMaxTemperatureDiff = 5; // 5 deg C is default max diff relative to reference 
  fTimeBinsPerHour = 2; // 2 30-min bins per hour is default
  fTempArray = NULL;
  fCalibSignal = NULL;
  fCalibTempCoeff = NULL;
  fCalibReference = NULL;
  fCalibTimeDepCorrection = NULL;
  fVerbosity = 0;
  return;
}

//________________________________________________________________
void  AliEMCALCalibTimeDep::PrintInfo() const
{
  // print some info
  cout << endl << " AliEMCALCalibTimeDep::PrintInfo() " << endl;
  // basic variables, all 'publicly available' also
  cout << " VARIABLE DUMP: " << endl
       << " GetStartTime() " << GetStartTime() << endl
       << " GetEndTime() " << GetEndTime() << endl
       << " GetMinTime() " << GetMinTime() << endl
       << " GetMaxTime() " << GetMaxTime() << endl
       << " GetMinTemp() " << GetMinTemp() << endl
       << " GetMaxTemp() " << GetMaxTemp() << endl
       << " GetMinTempVariation() " << GetMinTempVariation() << endl
       << " GetMaxTempVariation() " << GetMaxTempVariation() << endl
       << " GetTemperatureResolution() " << GetTemperatureResolution() << endl;
  // run ranges
  cout << " RUN INFO: " << endl
       << " runnumber " << GetRunNumber() << endl
       << " length (in hours) " << GetLengthOfRunInHours() << endl
       << " length (in bins) " << GetLengthOfRunInBins() << endl
       << " range of temperature measurements (in hours) " << GetRangeOfTempMeasureInHours()
       << " (in deg. C) " << GetRangeOfTempMeasureInDegrees()
       << endl;

  return;
}

//________________________________________________________________ 
Double_t AliEMCALCalibTimeDep::GetLengthOfRunInHours() const
{
  return (fEndTime - fStartTime)*kSecToHour;
}

//________________________________________________________________ 
Double_t AliEMCALCalibTimeDep::GetLengthOfRunInBins() const
{
  return (fEndTime - fStartTime)*kSecToHour*fTimeBinsPerHour;
}

//________________________________________________________________ 
Double_t AliEMCALCalibTimeDep::GetRangeOfTempMeasureInHours() const
{
  return (fMaxTime - fMinTime)*kSecToHour;
}

//________________________________________________________________ 
Double_t AliEMCALCalibTimeDep::GetRangeOfTempMeasureInDegrees() const
{
  return (fMaxTemp - fMinTemp);
}

//________________________________________________________________
void AliEMCALCalibTimeDep::Initialize(Int_t run, 
				      UInt_t startTime, UInt_t endTime)
{ // setup, and get temperature info
  Reset(); // start fresh

  fRun = run;
  fStartTime = startTime;
  fEndTime = endTime;
  
  // collect the needed information
  GetTemperatureInfo(); // temperature readings during the run
  ScanTemperatureInfo(); // see what the boundaries are (Min/Max Time/Temp)

  return;
}

//________________________________________________________________
Double_t AliEMCALCalibTimeDep::GetTemperatureSM(int imod, UInt_t timeStamp) const
{// return estimate for this one SuperModule, if it had data 

  // first convert from seconds to hours..
  Double_t timeHour = (timeStamp - fStartTime) * kSecToHour;

  int n = 0;
  Double_t valArr[8]={0}; // 8 sensors per SM

  for (int i=0; i<fTempArray->NumSensors(); i++) {
    
    AliEMCALSensorTemp *st = fTempArray->GetSensor(i);
    int module = st->GetSector()*2 + st->GetSide();
    if ( module == imod ) { // right module
      // check if we had valid data for the time that is being asked for
      if ( timeStamp>=st->GetStartTime() && timeStamp<=st->GetEndTime() ) {
	AliSplineFit *f = st->GetFit();
	if (f) { // ok, looks like we have valid data/info
	  // let's check what the expected value at the time appears to be
	  Double_t val = f->Eval(timeHour);
	  if ( fVerbosity > 0 ) {
	    cout << " sensor i " << i << " val " << val << endl;
	  }
	  if (val>fMinTempValid && val<fMaxTempValid && n<8) { 
	    valArr[n] = val;
	    n++;
	  }
	}
      } // time
    }
    
  } // loop over fTempArray
  
  if (n>0) { // some valid data was found
    Double_t median = TMath::Median(n, valArr);
    Double_t average = 0;
    Int_t nval = 0;
    for (int is=0; is<n; is++) {
      if (TMath::Abs(valArr[is] - median) < kTempMaxDiffMedian) {
	average += valArr[is];
	nval++;
      }
    }
    //cout << " n " << n << " nval " << nval << " median " << median << endl;
    if (nval >  0) {
      average /= nval;
      //cout << " average " << average << endl; 
      return average;
    }
    else { // this case should not happen, but kept for completeness (coverity etc)
      return median;
    }
  }
  else { // no good data
    return kErrorCode;
  }

}

//________________________________________________________________
Int_t AliEMCALCalibTimeDep::CalcCorrection()
{ // OK, this is where the real action takes place - the heart of this class..
  /* The philosophy is as follows:
     0. Init corrections to 1.0 values, and see how many correction bins we need
     1. Check how large temperature variations we have through the run - do we really need all the correction bias (otherwise adjust to single bin)
     2. try to use temperature info + APD temperature coefficient info, to estimate correction.
     For now (from Dec 2009), we do not use LED info.
   */

  // 0: Init
  // how many SuperModules do we have?
  Int_t nSM = fCalibReference->GetNSuperModule();
  // how many time-bins should we have for this run?
  Int_t nBins = (Int_t) (GetLengthOfRunInBins() + 1); // round-up (from double to int; always at least 1)
  Int_t binSize = (Int_t) (3600/fTimeBinsPerHour); // in seconds

  // 1: get info on how much individual sensors might have changed during
  // the run (compare max-min for each sensor separately)
  if (fMaxTempVariation < fTemperatureResolution) {
    nBins = 1; // just one bin needed..
  }
  if (nBins == 1) {    
    binSize = fEndTime - fStartTime;
  }
  if (fVerbosity > 0) {
    cout << " nBins " << nBins << " binSize " << binSize << endl;
  }

  // set up a reasonable default (correction = 1.0)
  fCalibTimeDepCorrection = new AliEMCALCalibTimeDepCorrection(nSM);
  fCalibTimeDepCorrection->InitCorrection(nSM, nBins, 1.0);
  fCalibTimeDepCorrection->SetStartTime(fStartTime);
  fCalibTimeDepCorrection->SetNTimeBins(nBins);
  fCalibTimeDepCorrection->SetTimeBinSize(binSize);

  // 2: try with Temperature correction 
  Int_t nRemaining = CalcTemperatureCorrection(nSM, nBins, binSize);

  return nRemaining;
}


//________________________________________________________________
Double_t AliEMCALCalibTimeDep::GetTempCoeff(Double_t IDark, Double_t M) const
{ // estimate the Temperature Coefficient, based on the dark current (IDark)
  // and the gain (M), based on Catania parameterizations

  Double_t dP0 = kTempCoeffP0Const + kTempCoeffP0Factor * IDark;
  Double_t dP1 = kTempCoeffP1Const + kTempCoeffP1Factor * IDark;
 
  Double_t dTC = dP0 + dP1*M;
  // from % numbers to regular ones..:
  dTC *= 0.01;

  return TMath::Abs(dTC); // return the absolute value, to avoid any sign confusion
}

/* Next come the methods that do the work in picking up all the needed info..*/
//________________________________________________________________
void AliEMCALCalibTimeDep::GetTemperatureInfo() 
{
  // pick up Preprocessor output, based on fRun (most recent version)
  AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/Temperature", fRun);
  if (entry) {
    fTempArray = (AliEMCALSensorTempArray *) entry->GetObject();
  }

  if (fTempArray) { 
    AliInfo( Form("NumSensors %d - IdDCS: first %d last %d",
		  fTempArray->NumSensors(),
		  fTempArray->GetFirstIdDCS(), fTempArray->GetLastIdDCS() ) );
  }
  else {
    AliWarning( Form("AliEMCALSensorTempArray not found!") );
  }
  
  return;
}

//________________________________________________________________
Int_t AliEMCALCalibTimeDep::ScanTemperatureInfo() 
{// assign max/min time and temperature values

  fMinTemp = 999; // init to some large value (999 deg C)
  fMaxTemp = 0;
  fMinTempVariation = 999; // init to some large value (999 deg C)
  fMaxTempVariation = 0;
  fMinTime = 2147483647; // init to a large value in the far future (0x7fffffff), year 2038 times..
  fMaxTime = 0;

  Int_t n = 0; // number of valid readings

  for (int i=0; i<fTempArray->NumSensors(); i++) {
    
    AliEMCALSensorTemp *st = fTempArray->GetSensor(i);
    if ( st->GetStartTime() == 0 ) { // no valid data
      continue;
    }

    // check time ranges
    if (fMinTime > st->GetStartTime()) { fMinTime = st->GetStartTime(); }
    if (fMaxTime < st->GetEndTime()) { fMaxTime = st->GetEndTime(); }
 
    // check temperature ranges
    AliSplineFit *f = st->GetFit();

    if (f) { // ok, looks like we have valid data/info
      int np = f->GetKnots();
      Double_t *y0 = f->GetY0();
      // min and max values within the single sensor
      Double_t min = 999;
      Double_t max = 0;
      int nval = 0;
      for (int ip=0; ip<np; ip++) { 
	if (y0[ip]>fMinTempValid && y0[ip]<fMaxTempValid) {
	  if (min > y0[ip]) { min = y0[ip]; }
	  if (max < y0[ip]) { max = y0[ip]; }
	  nval++;
	}
      }
      if (nval>0) {
	if (fMinTemp > min) { fMinTemp = min; }
	if (fMaxTemp < max) { fMaxTemp = max; }
	Double_t variation = max - min;
	if (fMinTempVariation > variation) { fMinTempVariation = variation; }
	if (fMaxTempVariation < variation) { fMaxTempVariation = variation; }
	
	n++;
      }
    }
  } // loop over fTempArray
  
  if (n>0) { // some valid data was found
    return n;
  }
  else { // no good data
    return (Int_t) kErrorCode;
  }

}

//________________________________________________________________
void AliEMCALCalibTimeDep::GetCalibSignalInfo() 
{
  // pick up Preprocessor output, based on fRun (most recent version)
  AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/LED", fRun);
  if (entry) {
    fCalibSignal = (AliCaloCalibSignal *) entry->GetObject();
  }

  if (fCalibSignal) { 
    AliInfo( Form("CalibSignal: NEvents %d NAcceptedEvents %d Entries %lld AvgEntries LEDRefEntries %lld LEDRefEntries %lld, LEDRefAvgEntries %lld",
		  fCalibSignal->GetNEvents(), fCalibSignal->GetNAcceptedEvents(),
		  fCalibSignal->GetTreeAmpVsTime()->GetEntries(),
		  fCalibSignal->GetTreeAvgAmpVsTime()->GetEntries(),
		  fCalibSignal->GetTreeLEDAmpVsTime()->GetEntries(),
		  fCalibSignal->GetTreeLEDAvgAmpVsTime()->GetEntries() ) );		  
  }
  else {
    AliWarning( Form("AliCaloCalibSignal not found!") );
  }
  
  return;
}

//________________________________________________________________
void AliEMCALCalibTimeDep::GetCalibTempCoeffInfo() 
{
  // pick up Preprocessor output, based on fRun (most recent version)
  AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/TempCoeff", fRun);
  // stored object should be a TTree; read the info
  if (entry) {
    fCalibTempCoeff = (AliEMCALCalibTempCoeff *) entry->GetObject();
  }

  if (fCalibTempCoeff) { 
    AliInfo( Form("CalibTempCoeff: NSuperModule %d ", fCalibTempCoeff->GetNSuperModule() ) );
  }
  else {
    AliWarning( Form("AliEMCALCalibTempCoeff not found!") );
  }
  
  return;
}

//________________________________________________________________
void AliEMCALCalibTimeDep::GetCalibReferenceInfo() 
{
  // pick up Preprocessor output, based on fRun (most recent version)
  AliCDBEntry* entry = AliCDBManager::Instance()->Get("EMCAL/Calib/Reference", fRun);
  if (entry) {
    fCalibReference = (AliEMCALCalibReference *) entry->GetObject();
  }

  if (fCalibReference) { 
    AliInfo( Form("CalibReference: NSuperModule %d ", fCalibReference->GetNSuperModule() ) );
  }
  else {
    AliWarning( Form("AliEMCALCalibReference not found!") );
  }
  
  return;
}

//________________________________________________________________
Int_t AliEMCALCalibTimeDep::CalcLEDCorrection(Int_t nSM, Int_t nBins) 
{// Construct normalized ratios R(t)=LED(t)/LEDRef(t), for current time T and calibration time t0 
  // The correction factor we keep is c(T) = R(t0)/R(T)
  // T info from fCalibSignal, t0 info from fCalibReference

  // NOTE: for now we don't use the RMS info either from fCalibSignal or fCalibReference
  // but one could upgrade this in the future
  Int_t nRemaining = 0; // we count the towers for which we could not get valid data

  // sanity check; same SuperModule indices for corrections as for regular calibrations
  for (int i = 0; i < nSM; i++) {
    AliEMCALSuperModuleCalibReference * dataCalibReference = fCalibReference->GetSuperModuleCalibReferenceNum(i);
    AliEMCALSuperModuleCalibTimeDepCorrection * dataCalibTimeDepCorrection = fCalibTimeDepCorrection->GetSuperModuleCalibTimeDepCorrectionNum(i);

    int iSMRef = dataCalibReference->GetSuperModuleNum();
    int iSMCorr = dataCalibTimeDepCorrection->GetSuperModuleNum();
    if (iSMRef != iSMCorr) {
      AliWarning( Form("AliEMCALCalibTimeDep - SuperModule index mismatch: %d != %d", iSMRef, iSMCorr) );
      nRemaining = nSM * AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows * nBins;
      return nRemaining;
    }
  }
 
  int iSM = 0;
  int iCol = 0;
  int iRow = 0;
  int iStrip = 0;
  int iGain = 0;

  // The fCalibSignal info is stored in TTrees
  // Note that the time-bins for the TTree's may not exactly match with our correction time bins 
  int timeDiff = fCalibSignal->GetStartTime() - fStartTime; // in seconds
  // fCalibSignal time info in seconds: Hour/kSecToHour
  // corrected for startTime difference: Hour/kSecToHour + timeDiff
  // converted into a time-bin we use: (Hour + timeDiff*kSecToHour) * fTimeBinsPerHour

  // values for R(T), size of TArray = nBins
  // the [2] dimension below is for the low or high gain 
  TArrayF ampT[AliEMCALGeoParams::fgkEMCALModules][AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows][2]; 
  TArrayF nT[AliEMCALGeoParams::fgkEMCALModules][AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows][2]; 
  TArrayF ampLEDRefT[AliEMCALGeoParams::fgkEMCALModules][AliEMCALGeoParams::fgkEMCALLEDRefs][2]; 
  TArrayF nLEDRefT[AliEMCALGeoParams::fgkEMCALModules][AliEMCALGeoParams::fgkEMCALLEDRefs][2]; 

  // set up TArray's first
  for (iSM = 0; iSM < AliEMCALGeoParams::fgkEMCALModules; iSM++) {
    for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
      for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
	for (iGain = 0; iGain < 2; iGain++) {
	  // length of arrays
	  ampT[iSM][iCol][iRow][iGain].Set(nBins);
	  nT[iSM][iCol][iRow][iGain].Set(nBins);
	  // content of arrys
	  for (int j = 0; j < nBins; j++) {
	    ampT[iSM][iCol][iRow][iGain].AddAt(0, j);
	    nT[iSM][iCol][iRow][iGain].AddAt(0, j);
	  }
	}
      }
    }//iCol
    for (iStrip = 0; iStrip < AliEMCALGeoParams::fgkEMCALLEDRefs; iStrip++) {
      for (iGain = 0; iGain < 2; iGain++) {
	// length of arrays
	ampLEDRefT[iSM][iStrip][iGain].Set(nBins);
	nLEDRefT[iSM][iStrip][iGain].Set(nBins);
	// content of arrys
	for (int j = 0; j < nBins; j++) {
	  ampLEDRefT[iSM][iStrip][iGain].AddAt(0, j);
	  nLEDRefT[iSM][iStrip][iGain].AddAt(0, j);
	}
      }
    }//iStrip
  }

  // OK, now loop over the TTrees and fill the arrays needed for R(T)
  TTree *treeAvg = fCalibSignal->GetTreeAvgAmpVsTime();
  TTree *treeLEDRefAvg = fCalibSignal->GetTreeAvgAmpVsTime();

  int iChannelNum = 0; // for regular towers
  int iRefNum = 0; // for LED
  double dHour = 0;
  double dAvgAmp = 0;

  treeAvg->SetBranchAddress("fChannelNum", &iChannelNum);
  treeAvg->SetBranchAddress("fHour", &dHour);
  treeAvg->SetBranchAddress("fAvgAmp",&dAvgAmp);

  int iBin = 0;
  // counters for how many values were seen per SuperModule
  int nCount[AliEMCALGeoParams::fgkEMCALModules] = {0};
  int nCountLEDRef[AliEMCALGeoParams::fgkEMCALModules] = {0};

  for (int ient=0; ient<treeAvg->GetEntries(); ient++) {
    treeAvg->GetEntry(ient);
    // figure out where this info comes from
    fCalibSignal->DecodeChannelNum(iChannelNum, &iSM, &iCol, &iRow, &iGain);
    iBin = (int) ( (dHour + timeDiff*kSecToHour) * fTimeBinsPerHour  ); // CHECK!!!
    // add value in the arrays
    ampT[iSM][iCol][iRow][iGain].AddAt( ampT[iSM][iCol][iRow][iGain].At(iBin)+dAvgAmp, iBin );
    nT[iSM][iCol][iRow][iGain].AddAt( nT[iSM][iCol][iRow][iGain].At(iBin)+1, iBin );
    nCount[iSM]++;
  }

  treeLEDRefAvg->SetBranchAddress("fRefNum", &iRefNum);
  treeLEDRefAvg->SetBranchAddress("fHour", &dHour);
  treeLEDRefAvg->SetBranchAddress("fAvgAmp",&dAvgAmp);

  for (int ient=0; ient<treeLEDRefAvg->GetEntries(); ient++) {
    treeLEDRefAvg->GetEntry(ient);
    // figure out where this info comes from
    fCalibSignal->DecodeRefNum(iRefNum, &iSM, &iStrip, &iGain);
    iBin = (int) ( (dHour + timeDiff*kSecToHour) * fTimeBinsPerHour  ); // CHECK!!!
    // add value in the arrays
    ampLEDRefT[iSM][iStrip][iGain].AddAt( ampLEDRefT[iSM][iStrip][iGain].At(iBin)+dAvgAmp, iBin );
    nLEDRefT[iSM][iStrip][iGain].AddAt( nLEDRefT[iSM][iStrip][iGain].At(iBin)+1, iBin );
    nCountLEDRef[iSM]++;
  }

  // Normalize TArray values, and calculate average also
  Float_t norm = 0; // extra var, for readability

  for (iSM = 0; iSM < AliEMCALGeoParams::fgkEMCALModules; iSM++) {
    if (nCount[iSM]>0 && nCountLEDRef[iSM]>0) { // avoid SuperModules with no data..
      for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
	//	iStrip = AliEMCALGeoParams::GetStripModule(iSM, iCol);
	iStrip = (iSM%2==0) ? iCol/2 : AliEMCALGeoParams::fgkEMCALLEDRefs - 1 - iCol/2; //TMP, FIXME
	for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
	  for (iGain = 0; iGain < 2; iGain++) {
	    // content of arrys
	    for (int j = 0; j < nBins; j++) {
	      if (nT[iSM][iCol][iRow][iGain].At(j) > 0) { 
		norm = ampT[iSM][iCol][iRow][iGain].At(j) / nT[iSM][iCol][iRow][iGain].At(j); 
		ampT[iSM][iCol][iRow][iGain].AddAt(norm, j); // AddAt = SetAt
	      }	
	    }
	  }
	}
      }//iCol
      for (iStrip = 0; iStrip < AliEMCALGeoParams::fgkEMCALLEDRefs; iStrip++) {
	for (iGain = 0; iGain < 2; iGain++) {
	  for (int j = 0; j < nBins; j++) {
	    if (nLEDRefT[iSM][iStrip][iGain].At(j) > 0) {
	      norm = ampLEDRefT[iSM][iStrip][iGain].At(j) / nLEDRefT[iSM][iStrip][iGain].At(j); 
	      ampLEDRefT[iSM][iStrip][iGain].AddAt(norm, j); // AddAt = SetAt
	    }
	  }
	}
      }//iStrip
    }
  } // iSM


  // Calculate correction values, and store them
  // set kErrorCode values for those that could not be set

  Float_t ratiot0 = 0;
  Float_t ratioT = 0;
  Float_t correction = 0; // c(T) = R(t0)/R(T)
  Int_t refGain = 0; // typically use low gain for LED reference amplitude (high gain typically well beyond saturation)

  for (int i = 0; i < nSM; i++) {
    AliEMCALSuperModuleCalibReference * dataCalibReference = fCalibReference->GetSuperModuleCalibReferenceNum(i);
    AliEMCALSuperModuleCalibTimeDepCorrection * dataCalibTimeDepCorrection = fCalibTimeDepCorrection->GetSuperModuleCalibTimeDepCorrectionNum(i);
    iSM = dataCalibReference->GetSuperModuleNum();

    for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
      //      iStrip = AliEMCALGeoParams::GetStripModule(iSM, iCol);
      iStrip = (iSM%2==0) ? iCol/2 : AliEMCALGeoParams::fgkEMCALLEDRefs - 1 - iCol/2; //TMP, FIXME
	refGain = dataCalibReference->GetLEDRefHighLow(iStrip); // LED reference gain value used for reference calibration	

      for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {

	// Calc. R(t0):
	AliEMCALCalibReferenceVal * refVal = dataCalibReference->GetAPDVal(iCol, iRow);
	iGain = refVal->GetHighLow(); // gain value used for reference calibration	
	// valid amplitude values should be larger than 0
	if (refVal->GetLEDAmp()>0 && dataCalibReference->GetLEDRefAmp(iStrip)>0) {
	  ratiot0 =  refVal->GetLEDAmp() / dataCalibReference->GetLEDRefAmp(iStrip);
	}
	else {
	  ratiot0 = kErrorCode;
	}

	// Calc. R(T)
	for (int j = 0; j < nBins; j++) {

	  // calculate R(T) also; first try with individual tower:
	  // same gain as for reference calibration is the default
	  if (ampT[iSM][iCol][iRow][iGain].At(j)>0 && ampLEDRefT[iSM][iStrip][refGain].At(j)>0) {
	    // looks like valid data with the right gain combination
	    ratioT = ampT[iSM][iCol][iRow][iGain].At(j) / ampLEDRefT[iSM][iStrip][refGain].At(j); 

	    // if data appears to be saturated, and we are in high gain, then try with low gain instead
	    int newGain = iGain;
	    int newRefGain = refGain;
	    if ( ampT[iSM][iCol][iRow][iGain].At(j)>AliEMCALGeoParams::fgkOverflowCut && iGain==1 ) {
	      newGain = 0;
	    }
	    if ( ampLEDRefT[iSM][iStrip][refGain].At(j)>AliEMCALGeoParams::fgkOverflowCut && refGain==1 ) { 
	      newRefGain = 0;
	    }

	    if (newGain!=iGain || newRefGain!=refGain) {
	      // compensate for using different gain than in the reference calibration
	      // we may need to have a custom H/L ratio value for each tower
	      // later, but for now just use a common value, as the rest of the code does.. 
	      ratioT = ampT[iSM][iCol][iRow][newGain].At(j) / ampLEDRefT[iSM][iStrip][newRefGain].At(j); 

	      if (newGain<iGain) {
		ratioT *= fHighLowGainFactor;
	      }
	      else if (newRefGain<refGain) {
		ratioT /= fHighLowGainFactor;
	      }
	    }
	  }
	  else {
	    ratioT = kErrorCode;
	  }

	  // Calc. correction factor
	  if (ratiot0>0 && ratioT>0) { 
	    correction = ratiot0/ratioT;
	  }
	  else {
	    correction = kErrorCode;
	    nRemaining++;
	  }

	  // Store the value
	  dataCalibTimeDepCorrection->GetCorrection(iCol,iRow)->AddAt(correction, j);
	  /* Check that
	  fTimeDepCorrection->SetCorrection(i, iCol, iRow, j, correction);
	  also works OK */
	} // nBins
      }
    }
  }

  nRemaining = CalcLEDCorrectionStripBasis(nSM, nBins);
  return nRemaining;
}

//________________________________________________________________
Int_t AliEMCALCalibTimeDep::CalcLEDCorrectionStripBasis(Int_t nSM, Int_t nBins) 
{ // use averages for each strip if no good values exist for some single tower 

  // go over fTimeDepCorrection info
  Int_t nRemaining = 0; // we count the towers for which we could not get valid data

  // for calculating StripAverage info
  int nValidTower = 0;
  Float_t stripAverage = 0;
  Float_t val = 0;

  int iSM = 0;
  int iCol = 0;
  int iRow = 0;
  int iStrip = 0;
  int firstCol = 0;
  int lastCol = 0;

  for (int i = 0; i < nSM; i++) {
    AliEMCALSuperModuleCalibTimeDepCorrection * dataCalibTimeDepCorrection = fCalibTimeDepCorrection->GetSuperModuleCalibTimeDepCorrectionNum(i);
    iSM = dataCalibTimeDepCorrection->GetSuperModuleNum();

    for (int j = 0; j < nBins; j++) {

      nValidTower = 0;
      stripAverage = 0;

      for (iStrip = 0; iStrip < AliEMCALGeoParams::fgkEMCALLEDRefs; iStrip++) {
	firstCol = iStrip*2;
	if ((iSM%2)==1) { // C side
	  firstCol = (AliEMCALGeoParams::fgkEMCALLEDRefs-1 - iStrip)*2;
	}
	lastCol = firstCol+1;

	for (iCol = firstCol; iCol <= lastCol; iCol++) {
	  for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
	    val = dataCalibTimeDepCorrection->GetCorrection(iCol,iRow)->At(j);
	    if (val>0) { // valid value; error code is negative
	      stripAverage += val;
	      nValidTower++;
	    } 
	  }
	}

	// calc average over strip
	if (nValidTower>0) {
	  stripAverage /= nValidTower;
	  for (iCol = firstCol; iCol <= lastCol; iCol++) {
	    for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
	      val = dataCalibTimeDepCorrection->GetCorrection(iCol,iRow)->At(j);
	      if (val<0) { // invalid value; error code is negative
		dataCalibTimeDepCorrection->GetCorrection(iCol,iRow)->AddAt(val, j);
	      }
	    }
	  }
	}
	else { // could not fill in unvalid entries
	  nRemaining += 2*AliEMCALGeoParams::fgkEMCALRows;
	}

      } // iStrip
    } // j, bins
  } // iSM

  return nRemaining;
}

//________________________________________________________________
Int_t AliEMCALCalibTimeDep::CalcTemperatureCorrection(Int_t nSM, Int_t nBins, Int_t binSize) 
{ // OK, so we didn't have valid LED data that allowed us to do the correction only 
  // with that info.
  // So, instead we'll rely on the temperature info and try to do the correction
  // based on that instead.
  // For this, we'll need the info from 3 classes (+temperature array), and output the values in a 4th class 
  Int_t nRemaining = 0;

  int iSM = 0;
  int iCol = 0;
  int iRow = 0;

  Double_t dTempCoeff[AliEMCALGeoParams::fgkEMCALCols][AliEMCALGeoParams::fgkEMCALRows];
  memset(dTempCoeff, 0, sizeof(dTempCoeff));
  Double_t correction = 0;
  Double_t secondsPerBin = (Double_t) binSize;

  for (int i = 0; i < nSM; i++) {
    AliEMCALSuperModuleCalibTimeDepCorrection * dataCalibTimeDepCorrection = fCalibTimeDepCorrection->GetSuperModuleCalibTimeDepCorrectionNum(i);
    iSM = dataCalibTimeDepCorrection->GetSuperModuleNum();

    AliEMCALSuperModuleCalibReference * dataCalibReference = fCalibReference->GetSuperModuleCalibReferenceNum(iSM);
    AliEMCALSuperModuleCalibTempCoeff * dataCalibTempCoeff = fCalibTempCoeff->GetSuperModuleCalibTempCoeffNum(iSM);

    // first get CalibTempCoeff info
    for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
      for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {

	dTempCoeff[iCol][iRow] = dataCalibTempCoeff->GetTC(iCol, iRow);
	if (fVerbosity > 1) {
	  cout << " iSM " << iSM << " iCol " << iCol << " iRow " << iRow 
	       << " dTempCoeff " << dTempCoeff[iCol][iRow] << endl; 
	}
      }
    }
    
    // figure out what the reference temperature is, from fCalibReference
    Double_t referenceTemperature = 0;
    int nVal = 0;
    for (int iSensor = 0; iSensor<AliEMCALGeoParams::fgkEMCALTempSensors ; iSensor++) {
      if (dataCalibReference->GetTemperature(iSensor)>0) { // hopefully OK value
	referenceTemperature += dataCalibReference->GetTemperature(iSensor);
	nVal++;
      }
    }
    
    if (nVal>0) {
      referenceTemperature /= nVal; // valid values exist, we can look into corrections
      
      Double_t dSMTemperature = 0;
      for (int j = 0; j < nBins; j++) {
	// what is the timestamp in the middle of this bin? (0.5 is for middle of bin)
	UInt_t timeStamp = fStartTime + (UInt_t)((j+0.5)*secondsPerBin);
      // get the temperature at this time; use average over whole SM for now (TO BE CHECKED LATER - if we can do better with finer grained info)
	Double_t oldSMTemperature = dSMTemperature;
	dSMTemperature = GetTemperatureSM(iSM, timeStamp); 
	if (j>0 && (dSMTemperature==kErrorCode)) { 
	  // if we have previous values, and retrieval of values failed - use that instead (hopefully good)
	  dSMTemperature = oldSMTemperature; 
	}
 
	Double_t temperatureDiff = referenceTemperature - dSMTemperature; // ref - new
	if (fVerbosity > 0) {
	  cout << " referenceTemperature " << referenceTemperature
	       << " dSMTemperature " << dSMTemperature
	       << " temperatureDiff " << temperatureDiff
	       << endl;
	}
	// if the new temperature is higher than the old/reference one (diff<0), then the gain has gone down 
	// if the new temperature is lower than the old/reference one (diff>0), then the gain has gone up
	// dTempCoeff is a (unsigned) factor describing how many % the gain 
	// changes with a degree change.  
	// i.e. the product temperatureDiff * dTempCoeff increase when the gain goes up
	// The correction we want to keep is what we should multiply our ADC value with as a function
	// of time, i.e. the inverse of the gain change..
	if ( (TMath::Abs(temperatureDiff)>fTemperatureResolution)
	     && (TMath::Abs(temperatureDiff)<fMaxTemperatureDiff) ) {
	  // significant enough difference that we need to consider it, and also not unreasonably large

	  // loop over all towers; effect of temperature change will depend on gain for this tower
	  for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
	    for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {

	      // the correction should be inverse of modification in gain: (see discussion above)
	      // modification in gain: 1.0 + (temperatureDiff * dTempCoeff[iCol][iRow])*0.01; 
	      // 1/(1+x) ~= 1 - x for small x, i.e. we arrive at:
	      correction = 1.0 - (temperatureDiff * dTempCoeff[iCol][iRow]); 
	      dataCalibTimeDepCorrection->GetCorrection(iCol,iRow)->AddAt(correction, j);
	      if (fVerbosity > 1) {
		cout << " iSM " << iSM
		     << " iCol  " << iCol 
		     << " iRow  " << iRow 
		     << " j  " << j 
		     << " correction  " << correction 
		     << endl;
	      }
	    }
	  }

	} // if noteworthy temperature change
	else { // just set correction values to 1.0
	  correction = 1;
	  for (iCol = 0; iCol < AliEMCALGeoParams::fgkEMCALCols; iCol++) {
	    for (iRow = 0; iRow < AliEMCALGeoParams::fgkEMCALRows; iRow++) {
	      dataCalibTimeDepCorrection->GetCorrection(iCol,iRow)->AddAt(correction, j);
	    }
	  }
	} // else
      } // j, Bins

    } // if reference temperature exist 
    else { // could not do the needed check.. signal that in the return code
      nRemaining += AliEMCALGeoParams::fgkEMCALCols * AliEMCALGeoParams::fgkEMCALRows * nBins;
    }
  } // iSM

  return nRemaining;
}

 AliEMCALCalibTimeDep.cxx:1
 AliEMCALCalibTimeDep.cxx:2
 AliEMCALCalibTimeDep.cxx:3
 AliEMCALCalibTimeDep.cxx:4
 AliEMCALCalibTimeDep.cxx:5
 AliEMCALCalibTimeDep.cxx:6
 AliEMCALCalibTimeDep.cxx:7
 AliEMCALCalibTimeDep.cxx:8
 AliEMCALCalibTimeDep.cxx:9
 AliEMCALCalibTimeDep.cxx:10
 AliEMCALCalibTimeDep.cxx:11
 AliEMCALCalibTimeDep.cxx:12
 AliEMCALCalibTimeDep.cxx:13
 AliEMCALCalibTimeDep.cxx:14
 AliEMCALCalibTimeDep.cxx:15
 AliEMCALCalibTimeDep.cxx:16
 AliEMCALCalibTimeDep.cxx:17
 AliEMCALCalibTimeDep.cxx:18
 AliEMCALCalibTimeDep.cxx:19
 AliEMCALCalibTimeDep.cxx:20
 AliEMCALCalibTimeDep.cxx:21
 AliEMCALCalibTimeDep.cxx:22
 AliEMCALCalibTimeDep.cxx:23
 AliEMCALCalibTimeDep.cxx:24
 AliEMCALCalibTimeDep.cxx:25
 AliEMCALCalibTimeDep.cxx:26
 AliEMCALCalibTimeDep.cxx:27
 AliEMCALCalibTimeDep.cxx:28
 AliEMCALCalibTimeDep.cxx:29
 AliEMCALCalibTimeDep.cxx:30
 AliEMCALCalibTimeDep.cxx:31
 AliEMCALCalibTimeDep.cxx:32
 AliEMCALCalibTimeDep.cxx:33
 AliEMCALCalibTimeDep.cxx:34
 AliEMCALCalibTimeDep.cxx:35
 AliEMCALCalibTimeDep.cxx:36
 AliEMCALCalibTimeDep.cxx:37
 AliEMCALCalibTimeDep.cxx:38
 AliEMCALCalibTimeDep.cxx:39
 AliEMCALCalibTimeDep.cxx:40
 AliEMCALCalibTimeDep.cxx:41
 AliEMCALCalibTimeDep.cxx:42
 AliEMCALCalibTimeDep.cxx:43
 AliEMCALCalibTimeDep.cxx:44
 AliEMCALCalibTimeDep.cxx:45
 AliEMCALCalibTimeDep.cxx:46
 AliEMCALCalibTimeDep.cxx:47
 AliEMCALCalibTimeDep.cxx:48
 AliEMCALCalibTimeDep.cxx:49
 AliEMCALCalibTimeDep.cxx:50
 AliEMCALCalibTimeDep.cxx:51
 AliEMCALCalibTimeDep.cxx:52
 AliEMCALCalibTimeDep.cxx:53
 AliEMCALCalibTimeDep.cxx:54
 AliEMCALCalibTimeDep.cxx:55
 AliEMCALCalibTimeDep.cxx:56
 AliEMCALCalibTimeDep.cxx:57
 AliEMCALCalibTimeDep.cxx:58
 AliEMCALCalibTimeDep.cxx:59
 AliEMCALCalibTimeDep.cxx:60
 AliEMCALCalibTimeDep.cxx:61
 AliEMCALCalibTimeDep.cxx:62
 AliEMCALCalibTimeDep.cxx:63
 AliEMCALCalibTimeDep.cxx:64
 AliEMCALCalibTimeDep.cxx:65
 AliEMCALCalibTimeDep.cxx:66
 AliEMCALCalibTimeDep.cxx:67
 AliEMCALCalibTimeDep.cxx:68
 AliEMCALCalibTimeDep.cxx:69
 AliEMCALCalibTimeDep.cxx:70
 AliEMCALCalibTimeDep.cxx:71
 AliEMCALCalibTimeDep.cxx:72
 AliEMCALCalibTimeDep.cxx:73
 AliEMCALCalibTimeDep.cxx:74
 AliEMCALCalibTimeDep.cxx:75
 AliEMCALCalibTimeDep.cxx:76
 AliEMCALCalibTimeDep.cxx:77
 AliEMCALCalibTimeDep.cxx:78
 AliEMCALCalibTimeDep.cxx:79
 AliEMCALCalibTimeDep.cxx:80
 AliEMCALCalibTimeDep.cxx:81
 AliEMCALCalibTimeDep.cxx:82
 AliEMCALCalibTimeDep.cxx:83
 AliEMCALCalibTimeDep.cxx:84
 AliEMCALCalibTimeDep.cxx:85
 AliEMCALCalibTimeDep.cxx:86
 AliEMCALCalibTimeDep.cxx:87
 AliEMCALCalibTimeDep.cxx:88
 AliEMCALCalibTimeDep.cxx:89
 AliEMCALCalibTimeDep.cxx:90
 AliEMCALCalibTimeDep.cxx:91
 AliEMCALCalibTimeDep.cxx:92
 AliEMCALCalibTimeDep.cxx:93
 AliEMCALCalibTimeDep.cxx:94
 AliEMCALCalibTimeDep.cxx:95
 AliEMCALCalibTimeDep.cxx:96
 AliEMCALCalibTimeDep.cxx:97
 AliEMCALCalibTimeDep.cxx:98
 AliEMCALCalibTimeDep.cxx:99
 AliEMCALCalibTimeDep.cxx:100
 AliEMCALCalibTimeDep.cxx:101
 AliEMCALCalibTimeDep.cxx:102
 AliEMCALCalibTimeDep.cxx:103
 AliEMCALCalibTimeDep.cxx:104
 AliEMCALCalibTimeDep.cxx:105
 AliEMCALCalibTimeDep.cxx:106
 AliEMCALCalibTimeDep.cxx:107
 AliEMCALCalibTimeDep.cxx:108
 AliEMCALCalibTimeDep.cxx:109
 AliEMCALCalibTimeDep.cxx:110
 AliEMCALCalibTimeDep.cxx:111
 AliEMCALCalibTimeDep.cxx:112
 AliEMCALCalibTimeDep.cxx:113
 AliEMCALCalibTimeDep.cxx:114
 AliEMCALCalibTimeDep.cxx:115
 AliEMCALCalibTimeDep.cxx:116
 AliEMCALCalibTimeDep.cxx:117
 AliEMCALCalibTimeDep.cxx:118
 AliEMCALCalibTimeDep.cxx:119
 AliEMCALCalibTimeDep.cxx:120
 AliEMCALCalibTimeDep.cxx:121
 AliEMCALCalibTimeDep.cxx:122
 AliEMCALCalibTimeDep.cxx:123
 AliEMCALCalibTimeDep.cxx:124
 AliEMCALCalibTimeDep.cxx:125
 AliEMCALCalibTimeDep.cxx:126
 AliEMCALCalibTimeDep.cxx:127
 AliEMCALCalibTimeDep.cxx:128
 AliEMCALCalibTimeDep.cxx:129
 AliEMCALCalibTimeDep.cxx:130
 AliEMCALCalibTimeDep.cxx:131
 AliEMCALCalibTimeDep.cxx:132
 AliEMCALCalibTimeDep.cxx:133
 AliEMCALCalibTimeDep.cxx:134
 AliEMCALCalibTimeDep.cxx:135
 AliEMCALCalibTimeDep.cxx:136
 AliEMCALCalibTimeDep.cxx:137
 AliEMCALCalibTimeDep.cxx:138
 AliEMCALCalibTimeDep.cxx:139
 AliEMCALCalibTimeDep.cxx:140
 AliEMCALCalibTimeDep.cxx:141
 AliEMCALCalibTimeDep.cxx:142
 AliEMCALCalibTimeDep.cxx:143
 AliEMCALCalibTimeDep.cxx:144
 AliEMCALCalibTimeDep.cxx:145
 AliEMCALCalibTimeDep.cxx:146
 AliEMCALCalibTimeDep.cxx:147
 AliEMCALCalibTimeDep.cxx:148
 AliEMCALCalibTimeDep.cxx:149
 AliEMCALCalibTimeDep.cxx:150
 AliEMCALCalibTimeDep.cxx:151
 AliEMCALCalibTimeDep.cxx:152
 AliEMCALCalibTimeDep.cxx:153
 AliEMCALCalibTimeDep.cxx:154
 AliEMCALCalibTimeDep.cxx:155
 AliEMCALCalibTimeDep.cxx:156
 AliEMCALCalibTimeDep.cxx:157
 AliEMCALCalibTimeDep.cxx:158
 AliEMCALCalibTimeDep.cxx:159
 AliEMCALCalibTimeDep.cxx:160
 AliEMCALCalibTimeDep.cxx:161
 AliEMCALCalibTimeDep.cxx:162
 AliEMCALCalibTimeDep.cxx:163
 AliEMCALCalibTimeDep.cxx:164
 AliEMCALCalibTimeDep.cxx:165
 AliEMCALCalibTimeDep.cxx:166
 AliEMCALCalibTimeDep.cxx:167
 AliEMCALCalibTimeDep.cxx:168
 AliEMCALCalibTimeDep.cxx:169
 AliEMCALCalibTimeDep.cxx:170
 AliEMCALCalibTimeDep.cxx:171
 AliEMCALCalibTimeDep.cxx:172
 AliEMCALCalibTimeDep.cxx:173
 AliEMCALCalibTimeDep.cxx:174
 AliEMCALCalibTimeDep.cxx:175
 AliEMCALCalibTimeDep.cxx:176
 AliEMCALCalibTimeDep.cxx:177
 AliEMCALCalibTimeDep.cxx:178
 AliEMCALCalibTimeDep.cxx:179
 AliEMCALCalibTimeDep.cxx:180
 AliEMCALCalibTimeDep.cxx:181
 AliEMCALCalibTimeDep.cxx:182
 AliEMCALCalibTimeDep.cxx:183
 AliEMCALCalibTimeDep.cxx:184
 AliEMCALCalibTimeDep.cxx:185
 AliEMCALCalibTimeDep.cxx:186
 AliEMCALCalibTimeDep.cxx:187
 AliEMCALCalibTimeDep.cxx:188
 AliEMCALCalibTimeDep.cxx:189
 AliEMCALCalibTimeDep.cxx:190
 AliEMCALCalibTimeDep.cxx:191
 AliEMCALCalibTimeDep.cxx:192
 AliEMCALCalibTimeDep.cxx:193
 AliEMCALCalibTimeDep.cxx:194
 AliEMCALCalibTimeDep.cxx:195
 AliEMCALCalibTimeDep.cxx:196
 AliEMCALCalibTimeDep.cxx:197
 AliEMCALCalibTimeDep.cxx:198
 AliEMCALCalibTimeDep.cxx:199
 AliEMCALCalibTimeDep.cxx:200
 AliEMCALCalibTimeDep.cxx:201
 AliEMCALCalibTimeDep.cxx:202
 AliEMCALCalibTimeDep.cxx:203
 AliEMCALCalibTimeDep.cxx:204
 AliEMCALCalibTimeDep.cxx:205
 AliEMCALCalibTimeDep.cxx:206
 AliEMCALCalibTimeDep.cxx:207
 AliEMCALCalibTimeDep.cxx:208
 AliEMCALCalibTimeDep.cxx:209
 AliEMCALCalibTimeDep.cxx:210
 AliEMCALCalibTimeDep.cxx:211
 AliEMCALCalibTimeDep.cxx:212
 AliEMCALCalibTimeDep.cxx:213
 AliEMCALCalibTimeDep.cxx:214
 AliEMCALCalibTimeDep.cxx:215
 AliEMCALCalibTimeDep.cxx:216
 AliEMCALCalibTimeDep.cxx:217
 AliEMCALCalibTimeDep.cxx:218
 AliEMCALCalibTimeDep.cxx:219
 AliEMCALCalibTimeDep.cxx:220
 AliEMCALCalibTimeDep.cxx:221
 AliEMCALCalibTimeDep.cxx:222
 AliEMCALCalibTimeDep.cxx:223
 AliEMCALCalibTimeDep.cxx:224
 AliEMCALCalibTimeDep.cxx:225
 AliEMCALCalibTimeDep.cxx:226
 AliEMCALCalibTimeDep.cxx:227
 AliEMCALCalibTimeDep.cxx:228
 AliEMCALCalibTimeDep.cxx:229
 AliEMCALCalibTimeDep.cxx:230
 AliEMCALCalibTimeDep.cxx:231
 AliEMCALCalibTimeDep.cxx:232
 AliEMCALCalibTimeDep.cxx:233
 AliEMCALCalibTimeDep.cxx:234
 AliEMCALCalibTimeDep.cxx:235
 AliEMCALCalibTimeDep.cxx:236
 AliEMCALCalibTimeDep.cxx:237
 AliEMCALCalibTimeDep.cxx:238
 AliEMCALCalibTimeDep.cxx:239
 AliEMCALCalibTimeDep.cxx:240
 AliEMCALCalibTimeDep.cxx:241
 AliEMCALCalibTimeDep.cxx:242
 AliEMCALCalibTimeDep.cxx:243
 AliEMCALCalibTimeDep.cxx:244
 AliEMCALCalibTimeDep.cxx:245
 AliEMCALCalibTimeDep.cxx:246
 AliEMCALCalibTimeDep.cxx:247
 AliEMCALCalibTimeDep.cxx:248
 AliEMCALCalibTimeDep.cxx:249
 AliEMCALCalibTimeDep.cxx:250
 AliEMCALCalibTimeDep.cxx:251
 AliEMCALCalibTimeDep.cxx:252
 AliEMCALCalibTimeDep.cxx:253
 AliEMCALCalibTimeDep.cxx:254
 AliEMCALCalibTimeDep.cxx:255
 AliEMCALCalibTimeDep.cxx:256
 AliEMCALCalibTimeDep.cxx:257
 AliEMCALCalibTimeDep.cxx:258
 AliEMCALCalibTimeDep.cxx:259
 AliEMCALCalibTimeDep.cxx:260
 AliEMCALCalibTimeDep.cxx:261
 AliEMCALCalibTimeDep.cxx:262
 AliEMCALCalibTimeDep.cxx:263
 AliEMCALCalibTimeDep.cxx:264
 AliEMCALCalibTimeDep.cxx:265
 AliEMCALCalibTimeDep.cxx:266
 AliEMCALCalibTimeDep.cxx:267
 AliEMCALCalibTimeDep.cxx:268
 AliEMCALCalibTimeDep.cxx:269
 AliEMCALCalibTimeDep.cxx:270
 AliEMCALCalibTimeDep.cxx:271
 AliEMCALCalibTimeDep.cxx:272
 AliEMCALCalibTimeDep.cxx:273
 AliEMCALCalibTimeDep.cxx:274
 AliEMCALCalibTimeDep.cxx:275
 AliEMCALCalibTimeDep.cxx:276
 AliEMCALCalibTimeDep.cxx:277
 AliEMCALCalibTimeDep.cxx:278
 AliEMCALCalibTimeDep.cxx:279
 AliEMCALCalibTimeDep.cxx:280
 AliEMCALCalibTimeDep.cxx:281
 AliEMCALCalibTimeDep.cxx:282
 AliEMCALCalibTimeDep.cxx:283
 AliEMCALCalibTimeDep.cxx:284
 AliEMCALCalibTimeDep.cxx:285
 AliEMCALCalibTimeDep.cxx:286
 AliEMCALCalibTimeDep.cxx:287
 AliEMCALCalibTimeDep.cxx:288
 AliEMCALCalibTimeDep.cxx:289
 AliEMCALCalibTimeDep.cxx:290
 AliEMCALCalibTimeDep.cxx:291
 AliEMCALCalibTimeDep.cxx:292
 AliEMCALCalibTimeDep.cxx:293
 AliEMCALCalibTimeDep.cxx:294
 AliEMCALCalibTimeDep.cxx:295
 AliEMCALCalibTimeDep.cxx:296
 AliEMCALCalibTimeDep.cxx:297
 AliEMCALCalibTimeDep.cxx:298
 AliEMCALCalibTimeDep.cxx:299
 AliEMCALCalibTimeDep.cxx:300
 AliEMCALCalibTimeDep.cxx:301
 AliEMCALCalibTimeDep.cxx:302
 AliEMCALCalibTimeDep.cxx:303
 AliEMCALCalibTimeDep.cxx:304
 AliEMCALCalibTimeDep.cxx:305
 AliEMCALCalibTimeDep.cxx:306
 AliEMCALCalibTimeDep.cxx:307
 AliEMCALCalibTimeDep.cxx:308
 AliEMCALCalibTimeDep.cxx:309
 AliEMCALCalibTimeDep.cxx:310
 AliEMCALCalibTimeDep.cxx:311
 AliEMCALCalibTimeDep.cxx:312
 AliEMCALCalibTimeDep.cxx:313
 AliEMCALCalibTimeDep.cxx:314
 AliEMCALCalibTimeDep.cxx:315
 AliEMCALCalibTimeDep.cxx:316
 AliEMCALCalibTimeDep.cxx:317
 AliEMCALCalibTimeDep.cxx:318
 AliEMCALCalibTimeDep.cxx:319
 AliEMCALCalibTimeDep.cxx:320
 AliEMCALCalibTimeDep.cxx:321
 AliEMCALCalibTimeDep.cxx:322
 AliEMCALCalibTimeDep.cxx:323
 AliEMCALCalibTimeDep.cxx:324
 AliEMCALCalibTimeDep.cxx:325
 AliEMCALCalibTimeDep.cxx:326
 AliEMCALCalibTimeDep.cxx:327
 AliEMCALCalibTimeDep.cxx:328
 AliEMCALCalibTimeDep.cxx:329
 AliEMCALCalibTimeDep.cxx:330
 AliEMCALCalibTimeDep.cxx:331
 AliEMCALCalibTimeDep.cxx:332
 AliEMCALCalibTimeDep.cxx:333
 AliEMCALCalibTimeDep.cxx:334
 AliEMCALCalibTimeDep.cxx:335
 AliEMCALCalibTimeDep.cxx:336
 AliEMCALCalibTimeDep.cxx:337
 AliEMCALCalibTimeDep.cxx:338
 AliEMCALCalibTimeDep.cxx:339
 AliEMCALCalibTimeDep.cxx:340
 AliEMCALCalibTimeDep.cxx:341
 AliEMCALCalibTimeDep.cxx:342
 AliEMCALCalibTimeDep.cxx:343
 AliEMCALCalibTimeDep.cxx:344
 AliEMCALCalibTimeDep.cxx:345
 AliEMCALCalibTimeDep.cxx:346
 AliEMCALCalibTimeDep.cxx:347
 AliEMCALCalibTimeDep.cxx:348
 AliEMCALCalibTimeDep.cxx:349
 AliEMCALCalibTimeDep.cxx:350
 AliEMCALCalibTimeDep.cxx:351
 AliEMCALCalibTimeDep.cxx:352
 AliEMCALCalibTimeDep.cxx:353
 AliEMCALCalibTimeDep.cxx:354
 AliEMCALCalibTimeDep.cxx:355
 AliEMCALCalibTimeDep.cxx:356
 AliEMCALCalibTimeDep.cxx:357
 AliEMCALCalibTimeDep.cxx:358
 AliEMCALCalibTimeDep.cxx:359
 AliEMCALCalibTimeDep.cxx:360
 AliEMCALCalibTimeDep.cxx:361
 AliEMCALCalibTimeDep.cxx:362
 AliEMCALCalibTimeDep.cxx:363
 AliEMCALCalibTimeDep.cxx:364
 AliEMCALCalibTimeDep.cxx:365
 AliEMCALCalibTimeDep.cxx:366
 AliEMCALCalibTimeDep.cxx:367
 AliEMCALCalibTimeDep.cxx:368
 AliEMCALCalibTimeDep.cxx:369
 AliEMCALCalibTimeDep.cxx:370
 AliEMCALCalibTimeDep.cxx:371
 AliEMCALCalibTimeDep.cxx:372
 AliEMCALCalibTimeDep.cxx:373
 AliEMCALCalibTimeDep.cxx:374
 AliEMCALCalibTimeDep.cxx:375
 AliEMCALCalibTimeDep.cxx:376
 AliEMCALCalibTimeDep.cxx:377
 AliEMCALCalibTimeDep.cxx:378
 AliEMCALCalibTimeDep.cxx:379
 AliEMCALCalibTimeDep.cxx:380
 AliEMCALCalibTimeDep.cxx:381
 AliEMCALCalibTimeDep.cxx:382
 AliEMCALCalibTimeDep.cxx:383
 AliEMCALCalibTimeDep.cxx:384
 AliEMCALCalibTimeDep.cxx:385
 AliEMCALCalibTimeDep.cxx:386
 AliEMCALCalibTimeDep.cxx:387
 AliEMCALCalibTimeDep.cxx:388
 AliEMCALCalibTimeDep.cxx:389
 AliEMCALCalibTimeDep.cxx:390
 AliEMCALCalibTimeDep.cxx:391
 AliEMCALCalibTimeDep.cxx:392
 AliEMCALCalibTimeDep.cxx:393
 AliEMCALCalibTimeDep.cxx:394
 AliEMCALCalibTimeDep.cxx:395
 AliEMCALCalibTimeDep.cxx:396
 AliEMCALCalibTimeDep.cxx:397
 AliEMCALCalibTimeDep.cxx:398
 AliEMCALCalibTimeDep.cxx:399
 AliEMCALCalibTimeDep.cxx:400
 AliEMCALCalibTimeDep.cxx:401
 AliEMCALCalibTimeDep.cxx:402
 AliEMCALCalibTimeDep.cxx:403
 AliEMCALCalibTimeDep.cxx:404
 AliEMCALCalibTimeDep.cxx:405
 AliEMCALCalibTimeDep.cxx:406
 AliEMCALCalibTimeDep.cxx:407
 AliEMCALCalibTimeDep.cxx:408
 AliEMCALCalibTimeDep.cxx:409
 AliEMCALCalibTimeDep.cxx:410
 AliEMCALCalibTimeDep.cxx:411
 AliEMCALCalibTimeDep.cxx:412
 AliEMCALCalibTimeDep.cxx:413
 AliEMCALCalibTimeDep.cxx:414
 AliEMCALCalibTimeDep.cxx:415
 AliEMCALCalibTimeDep.cxx:416
 AliEMCALCalibTimeDep.cxx:417
 AliEMCALCalibTimeDep.cxx:418
 AliEMCALCalibTimeDep.cxx:419
 AliEMCALCalibTimeDep.cxx:420
 AliEMCALCalibTimeDep.cxx:421
 AliEMCALCalibTimeDep.cxx:422
 AliEMCALCalibTimeDep.cxx:423
 AliEMCALCalibTimeDep.cxx:424
 AliEMCALCalibTimeDep.cxx:425
 AliEMCALCalibTimeDep.cxx:426
 AliEMCALCalibTimeDep.cxx:427
 AliEMCALCalibTimeDep.cxx:428
 AliEMCALCalibTimeDep.cxx:429
 AliEMCALCalibTimeDep.cxx:430
 AliEMCALCalibTimeDep.cxx:431
 AliEMCALCalibTimeDep.cxx:432
 AliEMCALCalibTimeDep.cxx:433
 AliEMCALCalibTimeDep.cxx:434
 AliEMCALCalibTimeDep.cxx:435
 AliEMCALCalibTimeDep.cxx:436
 AliEMCALCalibTimeDep.cxx:437
 AliEMCALCalibTimeDep.cxx:438
 AliEMCALCalibTimeDep.cxx:439
 AliEMCALCalibTimeDep.cxx:440
 AliEMCALCalibTimeDep.cxx:441
 AliEMCALCalibTimeDep.cxx:442
 AliEMCALCalibTimeDep.cxx:443
 AliEMCALCalibTimeDep.cxx:444
 AliEMCALCalibTimeDep.cxx:445
 AliEMCALCalibTimeDep.cxx:446
 AliEMCALCalibTimeDep.cxx:447
 AliEMCALCalibTimeDep.cxx:448
 AliEMCALCalibTimeDep.cxx:449
 AliEMCALCalibTimeDep.cxx:450
 AliEMCALCalibTimeDep.cxx:451
 AliEMCALCalibTimeDep.cxx:452
 AliEMCALCalibTimeDep.cxx:453
 AliEMCALCalibTimeDep.cxx:454
 AliEMCALCalibTimeDep.cxx:455
 AliEMCALCalibTimeDep.cxx:456
 AliEMCALCalibTimeDep.cxx:457
 AliEMCALCalibTimeDep.cxx:458
 AliEMCALCalibTimeDep.cxx:459
 AliEMCALCalibTimeDep.cxx:460
 AliEMCALCalibTimeDep.cxx:461
 AliEMCALCalibTimeDep.cxx:462
 AliEMCALCalibTimeDep.cxx:463
 AliEMCALCalibTimeDep.cxx:464
 AliEMCALCalibTimeDep.cxx:465
 AliEMCALCalibTimeDep.cxx:466
 AliEMCALCalibTimeDep.cxx:467
 AliEMCALCalibTimeDep.cxx:468
 AliEMCALCalibTimeDep.cxx:469
 AliEMCALCalibTimeDep.cxx:470
 AliEMCALCalibTimeDep.cxx:471
 AliEMCALCalibTimeDep.cxx:472
 AliEMCALCalibTimeDep.cxx:473
 AliEMCALCalibTimeDep.cxx:474
 AliEMCALCalibTimeDep.cxx:475
 AliEMCALCalibTimeDep.cxx:476
 AliEMCALCalibTimeDep.cxx:477
 AliEMCALCalibTimeDep.cxx:478
 AliEMCALCalibTimeDep.cxx:479
 AliEMCALCalibTimeDep.cxx:480
 AliEMCALCalibTimeDep.cxx:481
 AliEMCALCalibTimeDep.cxx:482
 AliEMCALCalibTimeDep.cxx:483
 AliEMCALCalibTimeDep.cxx:484
 AliEMCALCalibTimeDep.cxx:485
 AliEMCALCalibTimeDep.cxx:486
 AliEMCALCalibTimeDep.cxx:487
 AliEMCALCalibTimeDep.cxx:488
 AliEMCALCalibTimeDep.cxx:489
 AliEMCALCalibTimeDep.cxx:490
 AliEMCALCalibTimeDep.cxx:491
 AliEMCALCalibTimeDep.cxx:492
 AliEMCALCalibTimeDep.cxx:493
 AliEMCALCalibTimeDep.cxx:494
 AliEMCALCalibTimeDep.cxx:495
 AliEMCALCalibTimeDep.cxx:496
 AliEMCALCalibTimeDep.cxx:497
 AliEMCALCalibTimeDep.cxx:498
 AliEMCALCalibTimeDep.cxx:499
 AliEMCALCalibTimeDep.cxx:500
 AliEMCALCalibTimeDep.cxx:501
 AliEMCALCalibTimeDep.cxx:502
 AliEMCALCalibTimeDep.cxx:503
 AliEMCALCalibTimeDep.cxx:504
 AliEMCALCalibTimeDep.cxx:505
 AliEMCALCalibTimeDep.cxx:506
 AliEMCALCalibTimeDep.cxx:507
 AliEMCALCalibTimeDep.cxx:508
 AliEMCALCalibTimeDep.cxx:509
 AliEMCALCalibTimeDep.cxx:510
 AliEMCALCalibTimeDep.cxx:511
 AliEMCALCalibTimeDep.cxx:512
 AliEMCALCalibTimeDep.cxx:513
 AliEMCALCalibTimeDep.cxx:514
 AliEMCALCalibTimeDep.cxx:515
 AliEMCALCalibTimeDep.cxx:516
 AliEMCALCalibTimeDep.cxx:517
 AliEMCALCalibTimeDep.cxx:518
 AliEMCALCalibTimeDep.cxx:519
 AliEMCALCalibTimeDep.cxx:520
 AliEMCALCalibTimeDep.cxx:521
 AliEMCALCalibTimeDep.cxx:522
 AliEMCALCalibTimeDep.cxx:523
 AliEMCALCalibTimeDep.cxx:524
 AliEMCALCalibTimeDep.cxx:525
 AliEMCALCalibTimeDep.cxx:526
 AliEMCALCalibTimeDep.cxx:527
 AliEMCALCalibTimeDep.cxx:528
 AliEMCALCalibTimeDep.cxx:529
 AliEMCALCalibTimeDep.cxx:530
 AliEMCALCalibTimeDep.cxx:531
 AliEMCALCalibTimeDep.cxx:532
 AliEMCALCalibTimeDep.cxx:533
 AliEMCALCalibTimeDep.cxx:534
 AliEMCALCalibTimeDep.cxx:535
 AliEMCALCalibTimeDep.cxx:536
 AliEMCALCalibTimeDep.cxx:537
 AliEMCALCalibTimeDep.cxx:538
 AliEMCALCalibTimeDep.cxx:539
 AliEMCALCalibTimeDep.cxx:540
 AliEMCALCalibTimeDep.cxx:541
 AliEMCALCalibTimeDep.cxx:542
 AliEMCALCalibTimeDep.cxx:543
 AliEMCALCalibTimeDep.cxx:544
 AliEMCALCalibTimeDep.cxx:545
 AliEMCALCalibTimeDep.cxx:546
 AliEMCALCalibTimeDep.cxx:547
 AliEMCALCalibTimeDep.cxx:548
 AliEMCALCalibTimeDep.cxx:549
 AliEMCALCalibTimeDep.cxx:550
 AliEMCALCalibTimeDep.cxx:551
 AliEMCALCalibTimeDep.cxx:552
 AliEMCALCalibTimeDep.cxx:553
 AliEMCALCalibTimeDep.cxx:554
 AliEMCALCalibTimeDep.cxx:555
 AliEMCALCalibTimeDep.cxx:556
 AliEMCALCalibTimeDep.cxx:557
 AliEMCALCalibTimeDep.cxx:558
 AliEMCALCalibTimeDep.cxx:559
 AliEMCALCalibTimeDep.cxx:560
 AliEMCALCalibTimeDep.cxx:561
 AliEMCALCalibTimeDep.cxx:562
 AliEMCALCalibTimeDep.cxx:563
 AliEMCALCalibTimeDep.cxx:564
 AliEMCALCalibTimeDep.cxx:565
 AliEMCALCalibTimeDep.cxx:566
 AliEMCALCalibTimeDep.cxx:567
 AliEMCALCalibTimeDep.cxx:568
 AliEMCALCalibTimeDep.cxx:569
 AliEMCALCalibTimeDep.cxx:570
 AliEMCALCalibTimeDep.cxx:571
 AliEMCALCalibTimeDep.cxx:572
 AliEMCALCalibTimeDep.cxx:573
 AliEMCALCalibTimeDep.cxx:574
 AliEMCALCalibTimeDep.cxx:575
 AliEMCALCalibTimeDep.cxx:576
 AliEMCALCalibTimeDep.cxx:577
 AliEMCALCalibTimeDep.cxx:578
 AliEMCALCalibTimeDep.cxx:579
 AliEMCALCalibTimeDep.cxx:580
 AliEMCALCalibTimeDep.cxx:581
 AliEMCALCalibTimeDep.cxx:582
 AliEMCALCalibTimeDep.cxx:583
 AliEMCALCalibTimeDep.cxx:584
 AliEMCALCalibTimeDep.cxx:585
 AliEMCALCalibTimeDep.cxx:586
 AliEMCALCalibTimeDep.cxx:587
 AliEMCALCalibTimeDep.cxx:588
 AliEMCALCalibTimeDep.cxx:589
 AliEMCALCalibTimeDep.cxx:590
 AliEMCALCalibTimeDep.cxx:591
 AliEMCALCalibTimeDep.cxx:592
 AliEMCALCalibTimeDep.cxx:593
 AliEMCALCalibTimeDep.cxx:594
 AliEMCALCalibTimeDep.cxx:595
 AliEMCALCalibTimeDep.cxx:596
 AliEMCALCalibTimeDep.cxx:597
 AliEMCALCalibTimeDep.cxx:598
 AliEMCALCalibTimeDep.cxx:599
 AliEMCALCalibTimeDep.cxx:600
 AliEMCALCalibTimeDep.cxx:601
 AliEMCALCalibTimeDep.cxx:602
 AliEMCALCalibTimeDep.cxx:603
 AliEMCALCalibTimeDep.cxx:604
 AliEMCALCalibTimeDep.cxx:605
 AliEMCALCalibTimeDep.cxx:606
 AliEMCALCalibTimeDep.cxx:607
 AliEMCALCalibTimeDep.cxx:608
 AliEMCALCalibTimeDep.cxx:609
 AliEMCALCalibTimeDep.cxx:610
 AliEMCALCalibTimeDep.cxx:611
 AliEMCALCalibTimeDep.cxx:612
 AliEMCALCalibTimeDep.cxx:613
 AliEMCALCalibTimeDep.cxx:614
 AliEMCALCalibTimeDep.cxx:615
 AliEMCALCalibTimeDep.cxx:616
 AliEMCALCalibTimeDep.cxx:617
 AliEMCALCalibTimeDep.cxx:618
 AliEMCALCalibTimeDep.cxx:619
 AliEMCALCalibTimeDep.cxx:620
 AliEMCALCalibTimeDep.cxx:621
 AliEMCALCalibTimeDep.cxx:622
 AliEMCALCalibTimeDep.cxx:623
 AliEMCALCalibTimeDep.cxx:624
 AliEMCALCalibTimeDep.cxx:625
 AliEMCALCalibTimeDep.cxx:626
 AliEMCALCalibTimeDep.cxx:627
 AliEMCALCalibTimeDep.cxx:628
 AliEMCALCalibTimeDep.cxx:629
 AliEMCALCalibTimeDep.cxx:630
 AliEMCALCalibTimeDep.cxx:631
 AliEMCALCalibTimeDep.cxx:632
 AliEMCALCalibTimeDep.cxx:633
 AliEMCALCalibTimeDep.cxx:634
 AliEMCALCalibTimeDep.cxx:635
 AliEMCALCalibTimeDep.cxx:636
 AliEMCALCalibTimeDep.cxx:637
 AliEMCALCalibTimeDep.cxx:638
 AliEMCALCalibTimeDep.cxx:639
 AliEMCALCalibTimeDep.cxx:640
 AliEMCALCalibTimeDep.cxx:641
 AliEMCALCalibTimeDep.cxx:642
 AliEMCALCalibTimeDep.cxx:643
 AliEMCALCalibTimeDep.cxx:644
 AliEMCALCalibTimeDep.cxx:645
 AliEMCALCalibTimeDep.cxx:646
 AliEMCALCalibTimeDep.cxx:647
 AliEMCALCalibTimeDep.cxx:648
 AliEMCALCalibTimeDep.cxx:649
 AliEMCALCalibTimeDep.cxx:650
 AliEMCALCalibTimeDep.cxx:651
 AliEMCALCalibTimeDep.cxx:652
 AliEMCALCalibTimeDep.cxx:653
 AliEMCALCalibTimeDep.cxx:654
 AliEMCALCalibTimeDep.cxx:655
 AliEMCALCalibTimeDep.cxx:656
 AliEMCALCalibTimeDep.cxx:657
 AliEMCALCalibTimeDep.cxx:658
 AliEMCALCalibTimeDep.cxx:659
 AliEMCALCalibTimeDep.cxx:660
 AliEMCALCalibTimeDep.cxx:661
 AliEMCALCalibTimeDep.cxx:662
 AliEMCALCalibTimeDep.cxx:663
 AliEMCALCalibTimeDep.cxx:664
 AliEMCALCalibTimeDep.cxx:665
 AliEMCALCalibTimeDep.cxx:666
 AliEMCALCalibTimeDep.cxx:667
 AliEMCALCalibTimeDep.cxx:668
 AliEMCALCalibTimeDep.cxx:669
 AliEMCALCalibTimeDep.cxx:670
 AliEMCALCalibTimeDep.cxx:671
 AliEMCALCalibTimeDep.cxx:672
 AliEMCALCalibTimeDep.cxx:673
 AliEMCALCalibTimeDep.cxx:674
 AliEMCALCalibTimeDep.cxx:675
 AliEMCALCalibTimeDep.cxx:676
 AliEMCALCalibTimeDep.cxx:677
 AliEMCALCalibTimeDep.cxx:678
 AliEMCALCalibTimeDep.cxx:679
 AliEMCALCalibTimeDep.cxx:680
 AliEMCALCalibTimeDep.cxx:681
 AliEMCALCalibTimeDep.cxx:682
 AliEMCALCalibTimeDep.cxx:683
 AliEMCALCalibTimeDep.cxx:684
 AliEMCALCalibTimeDep.cxx:685
 AliEMCALCalibTimeDep.cxx:686
 AliEMCALCalibTimeDep.cxx:687
 AliEMCALCalibTimeDep.cxx:688
 AliEMCALCalibTimeDep.cxx:689
 AliEMCALCalibTimeDep.cxx:690
 AliEMCALCalibTimeDep.cxx:691
 AliEMCALCalibTimeDep.cxx:692
 AliEMCALCalibTimeDep.cxx:693
 AliEMCALCalibTimeDep.cxx:694
 AliEMCALCalibTimeDep.cxx:695
 AliEMCALCalibTimeDep.cxx:696
 AliEMCALCalibTimeDep.cxx:697
 AliEMCALCalibTimeDep.cxx:698
 AliEMCALCalibTimeDep.cxx:699
 AliEMCALCalibTimeDep.cxx:700
 AliEMCALCalibTimeDep.cxx:701
 AliEMCALCalibTimeDep.cxx:702
 AliEMCALCalibTimeDep.cxx:703
 AliEMCALCalibTimeDep.cxx:704
 AliEMCALCalibTimeDep.cxx:705
 AliEMCALCalibTimeDep.cxx:706
 AliEMCALCalibTimeDep.cxx:707
 AliEMCALCalibTimeDep.cxx:708
 AliEMCALCalibTimeDep.cxx:709
 AliEMCALCalibTimeDep.cxx:710
 AliEMCALCalibTimeDep.cxx:711
 AliEMCALCalibTimeDep.cxx:712
 AliEMCALCalibTimeDep.cxx:713
 AliEMCALCalibTimeDep.cxx:714
 AliEMCALCalibTimeDep.cxx:715
 AliEMCALCalibTimeDep.cxx:716
 AliEMCALCalibTimeDep.cxx:717
 AliEMCALCalibTimeDep.cxx:718
 AliEMCALCalibTimeDep.cxx:719
 AliEMCALCalibTimeDep.cxx:720
 AliEMCALCalibTimeDep.cxx:721
 AliEMCALCalibTimeDep.cxx:722
 AliEMCALCalibTimeDep.cxx:723
 AliEMCALCalibTimeDep.cxx:724
 AliEMCALCalibTimeDep.cxx:725
 AliEMCALCalibTimeDep.cxx:726
 AliEMCALCalibTimeDep.cxx:727
 AliEMCALCalibTimeDep.cxx:728
 AliEMCALCalibTimeDep.cxx:729
 AliEMCALCalibTimeDep.cxx:730
 AliEMCALCalibTimeDep.cxx:731
 AliEMCALCalibTimeDep.cxx:732
 AliEMCALCalibTimeDep.cxx:733
 AliEMCALCalibTimeDep.cxx:734
 AliEMCALCalibTimeDep.cxx:735
 AliEMCALCalibTimeDep.cxx:736
 AliEMCALCalibTimeDep.cxx:737
 AliEMCALCalibTimeDep.cxx:738
 AliEMCALCalibTimeDep.cxx:739
 AliEMCALCalibTimeDep.cxx:740
 AliEMCALCalibTimeDep.cxx:741
 AliEMCALCalibTimeDep.cxx:742
 AliEMCALCalibTimeDep.cxx:743
 AliEMCALCalibTimeDep.cxx:744
 AliEMCALCalibTimeDep.cxx:745
 AliEMCALCalibTimeDep.cxx:746
 AliEMCALCalibTimeDep.cxx:747
 AliEMCALCalibTimeDep.cxx:748
 AliEMCALCalibTimeDep.cxx:749
 AliEMCALCalibTimeDep.cxx:750
 AliEMCALCalibTimeDep.cxx:751
 AliEMCALCalibTimeDep.cxx:752
 AliEMCALCalibTimeDep.cxx:753
 AliEMCALCalibTimeDep.cxx:754
 AliEMCALCalibTimeDep.cxx:755
 AliEMCALCalibTimeDep.cxx:756
 AliEMCALCalibTimeDep.cxx:757
 AliEMCALCalibTimeDep.cxx:758
 AliEMCALCalibTimeDep.cxx:759
 AliEMCALCalibTimeDep.cxx:760
 AliEMCALCalibTimeDep.cxx:761
 AliEMCALCalibTimeDep.cxx:762
 AliEMCALCalibTimeDep.cxx:763
 AliEMCALCalibTimeDep.cxx:764
 AliEMCALCalibTimeDep.cxx:765
 AliEMCALCalibTimeDep.cxx:766
 AliEMCALCalibTimeDep.cxx:767
 AliEMCALCalibTimeDep.cxx:768
 AliEMCALCalibTimeDep.cxx:769
 AliEMCALCalibTimeDep.cxx:770
 AliEMCALCalibTimeDep.cxx:771
 AliEMCALCalibTimeDep.cxx:772
 AliEMCALCalibTimeDep.cxx:773
 AliEMCALCalibTimeDep.cxx:774
 AliEMCALCalibTimeDep.cxx:775
 AliEMCALCalibTimeDep.cxx:776
 AliEMCALCalibTimeDep.cxx:777
 AliEMCALCalibTimeDep.cxx:778
 AliEMCALCalibTimeDep.cxx:779
 AliEMCALCalibTimeDep.cxx:780
 AliEMCALCalibTimeDep.cxx:781
 AliEMCALCalibTimeDep.cxx:782
 AliEMCALCalibTimeDep.cxx:783
 AliEMCALCalibTimeDep.cxx:784
 AliEMCALCalibTimeDep.cxx:785
 AliEMCALCalibTimeDep.cxx:786
 AliEMCALCalibTimeDep.cxx:787
 AliEMCALCalibTimeDep.cxx:788
 AliEMCALCalibTimeDep.cxx:789
 AliEMCALCalibTimeDep.cxx:790
 AliEMCALCalibTimeDep.cxx:791
 AliEMCALCalibTimeDep.cxx:792
 AliEMCALCalibTimeDep.cxx:793
 AliEMCALCalibTimeDep.cxx:794
 AliEMCALCalibTimeDep.cxx:795
 AliEMCALCalibTimeDep.cxx:796
 AliEMCALCalibTimeDep.cxx:797
 AliEMCALCalibTimeDep.cxx:798
 AliEMCALCalibTimeDep.cxx:799
 AliEMCALCalibTimeDep.cxx:800
 AliEMCALCalibTimeDep.cxx:801
 AliEMCALCalibTimeDep.cxx:802
 AliEMCALCalibTimeDep.cxx:803
 AliEMCALCalibTimeDep.cxx:804
 AliEMCALCalibTimeDep.cxx:805
 AliEMCALCalibTimeDep.cxx:806
 AliEMCALCalibTimeDep.cxx:807
 AliEMCALCalibTimeDep.cxx:808
 AliEMCALCalibTimeDep.cxx:809
 AliEMCALCalibTimeDep.cxx:810
 AliEMCALCalibTimeDep.cxx:811
 AliEMCALCalibTimeDep.cxx:812
 AliEMCALCalibTimeDep.cxx:813
 AliEMCALCalibTimeDep.cxx:814
 AliEMCALCalibTimeDep.cxx:815
 AliEMCALCalibTimeDep.cxx:816
 AliEMCALCalibTimeDep.cxx:817
 AliEMCALCalibTimeDep.cxx:818
 AliEMCALCalibTimeDep.cxx:819
 AliEMCALCalibTimeDep.cxx:820
 AliEMCALCalibTimeDep.cxx:821
 AliEMCALCalibTimeDep.cxx:822
 AliEMCALCalibTimeDep.cxx:823
 AliEMCALCalibTimeDep.cxx:824
 AliEMCALCalibTimeDep.cxx:825
 AliEMCALCalibTimeDep.cxx:826
 AliEMCALCalibTimeDep.cxx:827
 AliEMCALCalibTimeDep.cxx:828
 AliEMCALCalibTimeDep.cxx:829
 AliEMCALCalibTimeDep.cxx:830
 AliEMCALCalibTimeDep.cxx:831
 AliEMCALCalibTimeDep.cxx:832
 AliEMCALCalibTimeDep.cxx:833
 AliEMCALCalibTimeDep.cxx:834
 AliEMCALCalibTimeDep.cxx:835
 AliEMCALCalibTimeDep.cxx:836
 AliEMCALCalibTimeDep.cxx:837
 AliEMCALCalibTimeDep.cxx:838
 AliEMCALCalibTimeDep.cxx:839
 AliEMCALCalibTimeDep.cxx:840
 AliEMCALCalibTimeDep.cxx:841
 AliEMCALCalibTimeDep.cxx:842
 AliEMCALCalibTimeDep.cxx:843
 AliEMCALCalibTimeDep.cxx:844
 AliEMCALCalibTimeDep.cxx:845
 AliEMCALCalibTimeDep.cxx:846
 AliEMCALCalibTimeDep.cxx:847
 AliEMCALCalibTimeDep.cxx:848
 AliEMCALCalibTimeDep.cxx:849
 AliEMCALCalibTimeDep.cxx:850
 AliEMCALCalibTimeDep.cxx:851
 AliEMCALCalibTimeDep.cxx:852
 AliEMCALCalibTimeDep.cxx:853
 AliEMCALCalibTimeDep.cxx:854
 AliEMCALCalibTimeDep.cxx:855
 AliEMCALCalibTimeDep.cxx:856
 AliEMCALCalibTimeDep.cxx:857
 AliEMCALCalibTimeDep.cxx:858
 AliEMCALCalibTimeDep.cxx:859
 AliEMCALCalibTimeDep.cxx:860
 AliEMCALCalibTimeDep.cxx:861
 AliEMCALCalibTimeDep.cxx:862
 AliEMCALCalibTimeDep.cxx:863
 AliEMCALCalibTimeDep.cxx:864
 AliEMCALCalibTimeDep.cxx:865
 AliEMCALCalibTimeDep.cxx:866
 AliEMCALCalibTimeDep.cxx:867
 AliEMCALCalibTimeDep.cxx:868
 AliEMCALCalibTimeDep.cxx:869
 AliEMCALCalibTimeDep.cxx:870
 AliEMCALCalibTimeDep.cxx:871
 AliEMCALCalibTimeDep.cxx:872
 AliEMCALCalibTimeDep.cxx:873
 AliEMCALCalibTimeDep.cxx:874
 AliEMCALCalibTimeDep.cxx:875
 AliEMCALCalibTimeDep.cxx:876
 AliEMCALCalibTimeDep.cxx:877
 AliEMCALCalibTimeDep.cxx:878
 AliEMCALCalibTimeDep.cxx:879
 AliEMCALCalibTimeDep.cxx:880
 AliEMCALCalibTimeDep.cxx:881
 AliEMCALCalibTimeDep.cxx:882
 AliEMCALCalibTimeDep.cxx:883
 AliEMCALCalibTimeDep.cxx:884
 AliEMCALCalibTimeDep.cxx:885
 AliEMCALCalibTimeDep.cxx:886
 AliEMCALCalibTimeDep.cxx:887
 AliEMCALCalibTimeDep.cxx:888
 AliEMCALCalibTimeDep.cxx:889
 AliEMCALCalibTimeDep.cxx:890
 AliEMCALCalibTimeDep.cxx:891
 AliEMCALCalibTimeDep.cxx:892
 AliEMCALCalibTimeDep.cxx:893
 AliEMCALCalibTimeDep.cxx:894
 AliEMCALCalibTimeDep.cxx:895
 AliEMCALCalibTimeDep.cxx:896
 AliEMCALCalibTimeDep.cxx:897
 AliEMCALCalibTimeDep.cxx:898
 AliEMCALCalibTimeDep.cxx:899
 AliEMCALCalibTimeDep.cxx:900
 AliEMCALCalibTimeDep.cxx:901
 AliEMCALCalibTimeDep.cxx:902
 AliEMCALCalibTimeDep.cxx:903
 AliEMCALCalibTimeDep.cxx:904
 AliEMCALCalibTimeDep.cxx:905
 AliEMCALCalibTimeDep.cxx:906
 AliEMCALCalibTimeDep.cxx:907
 AliEMCALCalibTimeDep.cxx:908
 AliEMCALCalibTimeDep.cxx:909
 AliEMCALCalibTimeDep.cxx:910
 AliEMCALCalibTimeDep.cxx:911
 AliEMCALCalibTimeDep.cxx:912
 AliEMCALCalibTimeDep.cxx:913
 AliEMCALCalibTimeDep.cxx:914
 AliEMCALCalibTimeDep.cxx:915
 AliEMCALCalibTimeDep.cxx:916
 AliEMCALCalibTimeDep.cxx:917
 AliEMCALCalibTimeDep.cxx:918
 AliEMCALCalibTimeDep.cxx:919
 AliEMCALCalibTimeDep.cxx:920
 AliEMCALCalibTimeDep.cxx:921
 AliEMCALCalibTimeDep.cxx:922
 AliEMCALCalibTimeDep.cxx:923
 AliEMCALCalibTimeDep.cxx:924
 AliEMCALCalibTimeDep.cxx:925
 AliEMCALCalibTimeDep.cxx:926
 AliEMCALCalibTimeDep.cxx:927