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.                  *
 **************************************************************************/


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class providing the calibration parameters by accessing the CDB           //
//                                                                           //
// Request an instance with AliTPCcalibDB::Instance()                        //
// If a new event is processed set the event number with SetRun              //
// Then request the calibration data                                         ////
//
//
// Calibration data:
// 0.)  Altro mapping
//          Simulation      - not yet 
//          Reconstruction  - AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
//
// 1.)  pad by pad calibration -  AliTPCCalPad
//      
//      a.) fPadGainFactor
//          Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
//          Reconstruction : AliTPCclusterer::Digits2Clusters - Divide by gain  
//
//      b.) fPadNoise -
//          Simulation:        AliTPCDigitizer::ExecFast
//          Reconstruction:    AliTPCclusterer::FindClusters(AliTPCCalROC * noiseROC)
//                             Noise depending cut on clusters charge (n sigma)
//      c.) fPedestal:
//          Simulation:     Not used yet - To be impleneted - Rounding to the nearest integer
//          Reconstruction: Used in AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader) 
//                          if data taken without zero suppression  
//                          Currently switch in  fRecoParam->GetCalcPedestal();
//      
//      d.) fPadTime0
//          Simulation:      applied in the AliTPC::MakeSector - adding offset
//          Reconstruction:  AliTPCTransform::Transform() - remove offset
//                           AliTPCTransform::Transform() - to be called
//                           in AliTPCtracker::Transform()      
//
// 
// 2.)  Space points transformation:
//
//      a.) General coordinate tranformation - AliTPCtransform (see $ALICE_ROOT/TPC/AliTPCtransform.cxx)
//          Created on fly - use the other calibration components
//                 Unisochronity  - (substract time0 - pad by pad)
//                 Drift velocity - Currently common drift velocity - functionality of AliTPCParam
//                 ExB effect    
//          Simulation     - Not used directly (the effects are applied one by one (see AliTPC::MakeSector)
//          Reconstruction - 
//                           AliTPCclusterer::AddCluster
//                           AliTPCtracker::Transform
//      b.) ExB effect calibration - 
//             classes (base class AliTPCExB, implementation- AliTPCExBExact.h  AliTPCExBFirst.h)
//             a.a) Simulation:   applied in the AliTPC::MakeSector - 
//                                calib->GetExB()->CorrectInverse(dxyz0,dxyz1);
//             a.b) Reconstruction -  
//                  
//                  in AliTPCtransform::Correct() - called calib->GetExB()->Correct(dxyz0,dxyz1)
//
//  3.)   cluster error, shape and Q parameterization
//
//
//
///////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <fstream>


#include <AliCDBManager.h>
#include <AliCDBEntry.h>
#include <AliCDBId.h>
#include <AliLog.h>
#include <AliMagF.h>
#include <AliSplineFit.h>
#include <AliCTPTimeParams.h>

#include "TGraphErrors.h"
#include "AliTPCcalibDB.h"
#include "AliTPCdataQA.h"
#include "AliTPCcalibDButil.h"
#include "AliTPCAltroMapping.h"
#include "AliTPCExB.h"

#include "AliTPCCalROC.h"
#include "AliTPCCalPad.h"
#include "AliTPCSensorTempArray.h"
#include "AliGRPObject.h"
#include "AliTPCTransform.h"
#include "AliTPCmapper.h"

class AliCDBStorage;
class AliTPCCalDet;
//
//

#include "TFile.h"
#include "TKey.h"
#include "TGraphErrors.h"

#include "TObjArray.h"
#include "TObjString.h"
#include "TString.h"
#include "TDirectory.h"
#include "TArrayI.h"
#include "AliTPCCalPad.h"
#include "AliTPCCalibPulser.h"
#include "AliTPCCalibPedestal.h"
#include "AliTPCCalibCE.h"
#include "AliTPCExBFirst.h"
#include "AliTPCTempMap.h"
#include "AliTPCCalibVdrift.h"
#include "AliTPCCalibRaw.h"
#include "AliTPCParam.h"
#include "AliTPCCorrection.h"
#include "AliTPCComposedCorrection.h"
#include "AliTPCPreprocessorOnline.h"
#include "AliTimeStamp.h"
#include "AliTriggerRunScalers.h"
#include "AliTriggerScalers.h"
#include "AliTriggerScalersRecord.h"

ClassImp(AliTPCcalibDB)

AliTPCcalibDB* AliTPCcalibDB::fgInstance = 0;
Bool_t AliTPCcalibDB::fgTerminated = kFALSE;
TObjArray    AliTPCcalibDB::fgExBArray;    // array of ExB corrections


//_ singleton implementation __________________________________________________
AliTPCcalibDB* AliTPCcalibDB::Instance()
{
  //
  // Singleton implementation
  // Returns an instance of this class, it is created if necessary
  //
  
  if (fgTerminated != kFALSE)
    return 0;

  if (fgInstance == 0)
    fgInstance = new AliTPCcalibDB();
  
  return fgInstance;
}

void AliTPCcalibDB::Terminate()
{
  //
  // Singleton implementation
  // Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
  // This function can be called several times.
  //
  
  fgTerminated = kTRUE;
  
  if (fgInstance != 0)
  {
    delete fgInstance;
    fgInstance = 0;
  }
}

//_____________________________________________________________________________
AliTPCcalibDB::AliTPCcalibDB():
  TObject(),
  fRun(-1),
  fTransform(0),
  fExB(0),
  fPadGainFactor(0),
  fActiveChannelMap(0),
  fDedxGainFactor(0),
  fPadTime0(0),
  fDistortionMap(0),
  fComposedCorrection(0),
  fComposedCorrectionArray(0),
  fPadNoise(0),
  fPedestals(0),
  fCalibRaw(0),
  fDataQA(0),
  fALTROConfigData(0),
  fIonTailArray(0),
  fPulserData(0),
  fCEData(0),
  fHVsensors(),
  fGrRunState(0x0),
  fTemperature(0),
  fMapping(0),
  fParam(0),
  fClusterParam(0),
  fRecoParamList(0),
  fTimeGainSplines(0),
  fTimeGainSplinesArray(1),
  fGRPArray(1),            //! array of GRPs  -  per run  - JUST for calibration studies
  fGRPMaps(1),            //! array of GRPs  -  per run  - JUST for calibration studies
  fGoofieArray(1),         //! array of GOOFIE values -per run - Just for calibration studies
  fVoltageArray(1),
  fTemperatureArray(1),    //! array of temperature sensors - per run - Just for calibration studies
  fVdriftArray(1),                 //! array of v drift interfaces
  fDriftCorrectionArray(1),  //! array of drift correction
  fRunList(1),              //! run list - indicates try to get the run param 
  fBHasAlignmentOCDB(kFALSE),    // Flag  - has the alignment on the composed correction ?
  fDButil(0),
  fCTPTimeParams(0),
  fMode(-1)
{
  //
  // constructor
  //  
  //
  fgInstance=this;
  for (Int_t i=0;i<72;++i){
    fChamberHVStatus[i]=kTRUE;
    fChamberHVmedian[i]=-1;
    fCurrentNominalVoltage[i]=0.;
    fChamberHVgoodFraction[i]=0.;
  }
  Update();    // temporary
  fTimeGainSplinesArray.SetOwner(); //own the keys
  fGRPArray.SetOwner(); //own the keys
  fGRPMaps.SetOwner(); //own the keys
  fGoofieArray.SetOwner(); //own the keys
  fVoltageArray.SetOwner(); //own the keys
  fTemperatureArray.SetOwner(); //own the keys
  fVdriftArray.SetOwner(); //own the keys
  fDriftCorrectionArray.SetOwner(); //own the keys
}

AliTPCcalibDB::AliTPCcalibDB(const AliTPCcalibDB& ):
  TObject(),
  fRun(-1),
  fTransform(0),
  fExB(0),
  fPadGainFactor(0),
  fActiveChannelMap(0),
  fDedxGainFactor(0),
  fPadTime0(0),
  fDistortionMap(0),
  fComposedCorrection(0),
  fComposedCorrectionArray(0),
  fPadNoise(0),
  fPedestals(0),
  fCalibRaw(0),
  fDataQA(0),
  fALTROConfigData(0),
  fIonTailArray(0),
  fPulserData(0),
  fCEData(0),
  fHVsensors(),
  fGrRunState(0x0),
  fTemperature(0),
  fMapping(0),
  fParam(0),
  fClusterParam(0),
  fRecoParamList(0),
  fTimeGainSplines(0),
  fTimeGainSplinesArray(1),
  fGRPArray(0),          //! array of GRPs  -  per run  - JUST for calibration studies
  fGRPMaps(0),          //! array of GRPs  -  per run  - JUST for calibration studies
  fGoofieArray(0),        //! array of GOOFIE values -per run - Just for calibration studies
  fVoltageArray(0),
  fTemperatureArray(0),   //! array of temperature sensors - per run - Just for calibration studies
  fVdriftArray(0),         //! array of v drift interfaces
  fDriftCorrectionArray(0), //! array of v drift corrections
  fRunList(0),              //! run list - indicates try to get the run param 
  fBHasAlignmentOCDB(kFALSE),    // Flag  - has the alignment on the composed correction ?
  fDButil(0),
  fCTPTimeParams(0),
  fMode(-1)
{
  //
  // Copy constructor invalid -- singleton implementation
  //
  Error("copy constructor","invalid -- singleton implementation");
  for (Int_t i=0;i<72;++i){
    fChamberHVStatus[i]=kTRUE;
    fChamberHVmedian[i]=-1;
    fCurrentNominalVoltage[i]=0.;
    fChamberHVgoodFraction[i]=0.;
  }
  fTimeGainSplinesArray.SetOwner(); //own the keys
  fGRPArray.SetOwner(); //own the keys
  fGRPMaps.SetOwner(); //own the keys
  fGoofieArray.SetOwner(); //own the keys
  fVoltageArray.SetOwner(); //own the keys
  fTemperatureArray.SetOwner(); //own the keys
  fVdriftArray.SetOwner(); //own the keys
  fDriftCorrectionArray.SetOwner(); //own the keys
}

AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& )
{
//
// Singleton implementation - no assignment operator
//
  Error("operator =", "assignment operator not implemented");
  return *this;
}



//_____________________________________________________________________________
AliTPCcalibDB::~AliTPCcalibDB() 
{
  //
  // destructor
  //
  //delete fIonTailArray; 
  delete fActiveChannelMap;
  delete fGrRunState;
  fgInstance = 0;
}

AliTPCCalPad* AliTPCcalibDB::GetDistortionMap(Int_t i) const {
  //
  // get distortion map - due E field distortions
  //
  return (fDistortionMap) ? (AliTPCCalPad*)fDistortionMap->At(i):0;
}

AliTPCRecoParam* AliTPCcalibDB::GetRecoParam(Int_t i) const {
  return (fRecoParamList) ? (AliTPCRecoParam*)fRecoParamList->At(i):0;
}

//_____________________________________________________________________________
AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath)
{
  // 
  // Retrieves an entry with path <cdbPath> from the CDB.
  //
  char chinfo[1000];
    
  AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, fRun); 
  if (!entry) 
  { 
    snprintf(chinfo,1000,"AliTPCcalibDB: Failed to get entry:\t%s ", cdbPath);
    AliError(chinfo); 
    return 0; 
  }
  return entry;
}


//_____________________________________________________________________________
void AliTPCcalibDB::SetRun(Long64_t run)
{
  //
  // Sets current run number. Calibration data is read from the corresponding file. 
  //  
  if (fRun == run)
    return;  
	fRun = run;
  Update();
}
  


void AliTPCcalibDB::Update(){
  //
  // cache the OCDB entries for simulation, reconstruction, calibration
  //  
  //
  AliCDBEntry * entry=0;
  Bool_t cdbCache = AliCDBManager::Instance()->GetCacheFlag(); // save cache status
  AliCDBManager::Instance()->SetCacheFlag(kTRUE); // activate CDB cache
  fDButil = new AliTPCcalibDButil;   
  //
  fRun = AliCDBManager::Instance()->GetRun();

  entry          = GetCDBEntry("TPC/Calib/PadGainFactor");
  if (entry){
    //if (fPadGainFactor) delete fPadGainFactor;
    entry->SetOwner(kTRUE);
    fPadGainFactor = (AliTPCCalPad*)entry->GetObject();
  }else{
    AliFatal("TPC - Missing calibration entry TPC/Calib/PadGainFactor");
  }
  //
  entry          = GetCDBEntry("TPC/Calib/TimeGain");
  if (entry){
    //if (fTimeGainSplines) delete fTimeGainSplines;
    entry->SetOwner(kTRUE);
    fTimeGainSplines = (TObjArray*)entry->GetObject();
  }else{
    AliFatal("TPC - Missing calibration entry TPC/Calib/Timegain");
  }
  //
  entry          = GetCDBEntry("TPC/Calib/GainFactorDedx");
  if (entry){
    entry->SetOwner(kTRUE);
    fDedxGainFactor = (AliTPCCalPad*)entry->GetObject();
  }else{
    AliFatal("TPC - Missing calibration entry TPC/Calib/gainFactordEdx");
  }
  //
  entry          = GetCDBEntry("TPC/Calib/PadTime0");
  if (entry){
    //if (fPadTime0) delete fPadTime0;
    entry->SetOwner(kTRUE);
    fPadTime0 = (AliTPCCalPad*)entry->GetObject();
  }else{
    AliFatal("TPC - Missing calibration entry");
  }

  entry          = GetCDBEntry("TPC/Calib/Distortion");
  if (entry){
    //if (fPadTime0) delete fPadTime0;
    entry->SetOwner(kTRUE);
    fDistortionMap =dynamic_cast<TObjArray*>(entry->GetObject());
  }else{
    //AliFatal("TPC - Missing calibration entry")
  }


  //
  //
  entry          = GetCDBEntry("TPC/Calib/PadNoise");
  if (entry){
    //if (fPadNoise) delete fPadNoise;
    entry->SetOwner(kTRUE);
    fPadNoise = (AliTPCCalPad*)entry->GetObject();
  }else{
    AliFatal("TPC - Missing calibration entry");
  }

  entry          = GetCDBEntry("TPC/Calib/Pedestals");
  if (entry){
    //if (fPedestals) delete fPedestals;
    entry->SetOwner(kTRUE);
    fPedestals = (AliTPCCalPad*)entry->GetObject();
  }

  entry          = GetCDBEntry("TPC/Calib/Temperature");
  if (entry){
    //if (fTemperature) delete fTemperature;
    entry->SetOwner(kTRUE);
    fTemperature = (AliTPCSensorTempArray*)entry->GetObject();
  }

  entry          = GetCDBEntry("TPC/Calib/Parameters");
  if (entry){
    //if (fPadNoise) delete fPadNoise;
    entry->SetOwner(kTRUE);
    fParam = (AliTPCParam*)(entry->GetObject());
  }else{
    AliFatal("TPC - Missing calibration entry TPC/Calib/Parameters");
  }

  entry          = GetCDBEntry("TPC/Calib/ClusterParam");
  if (entry){
    entry->SetOwner(kTRUE);
    fClusterParam = (AliTPCClusterParam*)(entry->GetObject());
  }else{
    AliFatal("TPC - Missing calibration entry");
  }

  entry          = GetCDBEntry("TPC/Calib/RecoParam");
  if (entry){
    //PH    entry->SetOwner(kTRUE);
    fRecoParamList = dynamic_cast<TObjArray*>(entry->GetObject());

  }else{
    AliFatal("TPC - Missing calibration entry TPC/Calib/RecoParam");
  }


  //ALTRO configuration data
  entry          = GetCDBEntry("TPC/Calib/AltroConfig");
  if (entry){
    entry->SetOwner(kTRUE);
    fALTROConfigData=(TObjArray*)(entry->GetObject());
  }else{
    AliFatal("TPC - Missing calibration entry");
  }
  
  //Calibration Pulser data
  entry          = GetCDBEntry("TPC/Calib/Pulser");
  if (entry){
    entry->SetOwner(kTRUE);
    fPulserData=(TObjArray*)(entry->GetObject());
  }
  
  //Calibration ION tail data
  entry          = GetCDBEntry("TPC/Calib/IonTail");
  if (entry){
    //delete fIonTailArray; fIonTailArray=NULL;
    entry->SetOwner(kTRUE);
     fIonTailArray=(TObjArray*)(entry->GetObject());
     fIonTailArray->SetOwner(); //own the keys
  }
  
  //CE data
  entry          = GetCDBEntry("TPC/Calib/CE");
  if (entry){
    entry->SetOwner(kTRUE);
    fCEData=(TObjArray*)(entry->GetObject());
  }
  //RAW calibration data
 //  entry          = GetCDBEntry("TPC/Calib/Raw");

  entry          = GetCDBEntry("TPC/Calib/Mapping");
  if (entry){
    //if (fPadNoise) delete fPadNoise;
    entry->SetOwner(kTRUE);
    TObjArray * array = dynamic_cast<TObjArray*>(entry->GetObject());
    if (array && array->GetEntriesFast()==6){
      fMapping = new AliTPCAltroMapping*[6];
      for (Int_t i=0; i<6; i++){
        fMapping[i] =  dynamic_cast<AliTPCAltroMapping*>(array->At(i));
      }
    }
  }

  //CTP calibration data
  entry          = GetCDBEntry("GRP/CTP/CTPtiming");
  if (entry){
    //entry->SetOwner(kTRUE);
    fCTPTimeParams=dynamic_cast<AliCTPTimeParams*>(entry->GetObject());
  }else{
    AliError("TPC - Missing calibration entry");
  }  
  //TPC space point correction data
  entry          = GetCDBEntry("TPC/Calib/Correction");
  if (entry){
    //entry->SetOwner(kTRUE);
    fComposedCorrection=dynamic_cast<AliTPCCorrection*>(entry->GetObject());
    if (fComposedCorrection) fComposedCorrection->Init();
    fComposedCorrectionArray=dynamic_cast<TObjArray*>(entry->GetObject());
    if (fComposedCorrectionArray){
      for (Int_t i=0; i<fComposedCorrectionArray->GetEntries(); i++){
	AliTPCComposedCorrection* composedCorrection= dynamic_cast<AliTPCComposedCorrection*>(fComposedCorrectionArray->At(i));
	if (composedCorrection) {
	  composedCorrection->Init();
	  if (composedCorrection->GetCorrections()){
	    if (composedCorrection->GetCorrections()->FindObject("FitAlignTPC")){
	      fBHasAlignmentOCDB=kTRUE;
	    }
	  }
	}
      }
    }  
  }else{
    AliError("TPC - Missing calibration entry-  TPC/Calib/Correction");
  } 
  //RCU trigger config mode
  fMode=GetRCUTriggerConfig();
  //
  if (!fTransform) {
    fTransform=new AliTPCTransform(); 
    fTransform->SetCurrentRun(AliCDBManager::Instance()->GetRun());
  }

  // Chamber HV data
  // needs to be called before InitDeadMap
  UpdateChamberHighVoltageData();
  
  // Create Dead Channel Map
  InitDeadMap();

  //
  AliCDBManager::Instance()->SetCacheFlag(cdbCache); // reset original CDB cache
}

void AliTPCcalibDB::UpdateNonRec(){
  //
  // Update/Load the parameters which are important for QA studies
  // and not used yet for the reconstruction
  //
   //RAW calibration data
  AliCDBEntry * entry=0;
  entry          = GetCDBEntry("TPC/Calib/Raw");
  if (entry){
    entry->SetOwner(kTRUE);
    TObjArray *arr=dynamic_cast<TObjArray*>(entry->GetObject());
    if (arr) fCalibRaw=(AliTPCCalibRaw*)arr->At(0);
    else fCalibRaw = (AliTPCCalibRaw*)(entry->GetObject());
  }
  //QA calibration data
  entry          = GetCDBEntry("TPC/Calib/QA");
  if (entry){
    entry->SetOwner(kTRUE);
    fDataQA=dynamic_cast<AliTPCdataQA*>(entry->GetObject());
  }
  // High voltage
  if (fRun>=0 && !fVoltageArray.GetValue(Form("%i",fRun))){
    entry = AliCDBManager::Instance()->Get("TPC/Calib/HighVoltage",fRun);
    if (entry)  {
      fVoltageArray.Add(new TObjString(Form("%i",fRun)),entry->GetObject());
    }
  }

}

Bool_t AliTPCcalibDB::GetTailcancelationGraphs(Int_t sector, TGraphErrors ** graphRes, Float_t * indexAmpGraphs){
 
// 
//   Read OCDB entry object of Iontail (TObjArray of TGraphErrors of TRFs)
//   Naming of the TRF objects is: "gr_<chamber_type>_<voltage>_<laser_track_angle>_<distance_to_COG>" --> "gr_iroc_1240_1_1" 
//   
  
  //Int_t run = fTransform->GetCurrentRunNumber();
  //SetRun(run);
  //Float_t rocVoltage = GetChamberHighVoltage(run,sector, -1);      // Get the voltage from OCDB with a getter (old function)
//   Float_t rocVoltage=GetChamberHighVoltageMedian(sector);                      // Get the voltage from OCDB, new function from Jens
 
  Int_t nominalVoltage = (sector<36) ? 1240 : 1470 ;     // nominal voltage of 2012 when the TRF functions were produced

  Float_t rocVoltage = nominalVoltage;

  if ( rocVoltage < nominalVoltage/2. || rocVoltage > nominalVoltage*2. )
  {
    AliInfo(Form("rocVoltage out of range: roc: %.2f, nominal: %i", rocVoltage, nominalVoltage));
    return kFALSE;
  }

  Int_t tempVoltage = 0;                                 
  Int_t trackAngle  = 4;                                 // (1=first, 2=second, 3=third, 4=first+second, 5=all tracks) note: 3rd is distorted by low freq
  TString rocType   = (sector<36) ? "iroc" : "oroc";     
  const Int_t ngraph=fIonTailArray->GetLast();
  
  // create array of voltages in order to select the proper TRF with closest voltage  
  Int_t voltages[ngraph];     // array of voltages
  for (Int_t i=0; i<ngraph; i++){
    voltages[i]=0;
  }
    
  // loop over response functions in the TObjarray
  Int_t nvoltages=0;
  for (Int_t i=0;i<=ngraph;i++){
    
    // read the TRF object name in order to select proper TRF for the given sector
    TString objname(fIonTailArray->At(i)->GetName());
    if (!objname.Contains(rocType)) continue;

    TObjArray *objArr = objname.Tokenize("_");
    
    // select the roc type (IROC or OROC) and the trackAngle
    if ( atoi(static_cast<TObjString*>(objArr->At(3))->GetName())==trackAngle )
    { 
      // Create the voltage array for proper voltage value selection
      voltages[nvoltages]=atoi(static_cast<TObjString*>(objArr->At(2))->GetName());
      nvoltages++;
    }
    delete objArr;
  }
    
  // find closest voltage value to ROC voltage (among the TRF' voltage array --> to select proper t.r.f.)
  Int_t ampIndex     = 0;
  Int_t diffVoltage  = TMath::Abs(rocVoltage - voltages[0]);
  for (Int_t k=0;k<ngraph;k++) {
    if (diffVoltage >= TMath::Abs(rocVoltage-voltages[k]) && voltages[k]!=0)
      {
        diffVoltage    = TMath::Abs(rocVoltage-voltages[k]);
        ampIndex   = k;
      }     
  }
  tempVoltage = voltages[ampIndex];    // use closest voltage to current voltage
  //if (run<140000) tempVoltage = nominalVoltage;    // for 2010 data
  
  // assign TGraphErrors   
  Int_t igraph=0;
  for (Int_t i=0; i<=ngraph; i++){
   
    // read TRFs for TObjArray and select the roc type (IROC or OROC) and the trackAngle
    TGraphErrors * trfObj = static_cast<TGraphErrors*>(fIonTailArray->At(i));
    TString objname(trfObj->GetName());
    if (!objname.Contains(rocType)) continue; //choose ROC type
    
    TObjArray *objArr1 = objname.Tokenize("_");
     
    // TRF eleminations
    TObjString* angleString = static_cast<TObjString*>(objArr1->At(3));
    TObjString* voltageString = static_cast<TObjString*>(objArr1->At(2));
    //choose angle and voltage
    if ((atoi(angleString->GetName())==trackAngle) && (atoi(voltageString->GetName())==tempVoltage) )
    {
      // Apply Voltage scaling
      Int_t voltage       = atoi(voltageString->GetName());
      Double_t voltageScaled = 1;
      if (rocVoltage>0)  voltageScaled = Double_t(voltage)/Double_t(rocVoltage); // for jens how it can happen that we have clusters at 0 HV ?
      const Int_t nScaled          = TMath::Nint(voltageScaled*trfObj->GetN())-1; 
      Double_t x;
      Double_t y;
      
      delete graphRes[igraph];
      graphRes[igraph]       = new TGraphErrors(nScaled);
      
      for (Int_t j=0; j<nScaled; j++){
        x = TMath::Nint(j*(voltageScaled));
        y = (j<trfObj->GetN()) ? (1./voltageScaled)*trfObj->GetY()[j] : 0.;
        graphRes[igraph]->SetPoint(j,x,y);
      }

      // fill arrays for proper position and amplitude selections
      TObjString* distanceToCenterOfGravity = static_cast<TObjString*>(objArr1->At(4));
      indexAmpGraphs[igraph] = (distanceToCenterOfGravity->GetString().Atof())/10.;
      // smooth voltage scaled graph 
      for (Int_t m=1; m<nScaled;m++){
        if (graphRes[igraph]->GetY()[m]==0) graphRes[igraph]->GetY()[m] = graphRes[igraph]->GetY()[m-1];
      }
      igraph++;
    }
  delete objArr1;
  }
  return kTRUE;
}

void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObjects)
{
//
// Create calibration objects and read contents from OCDB
//
   if ( calibObjects == 0x0 ) return;
   ifstream in;
   in.open(filename);
   if ( !in.is_open() ){
      fprintf(stderr,"Error: cannot open list file '%s'", filename);
      return;
   }
   
   AliTPCCalPad *calPad=0x0;
   
   TString sFile;
   sFile.ReadFile(in);
   in.close();
   
   TObjArray *arrFileLine = sFile.Tokenize("\n");
   
   TIter nextLine(arrFileLine);
   
   TObjString *sObjLine=0x0;
   while ( (sObjLine = (TObjString*)nextLine()) ){
      TString sLine(sObjLine->GetString());
      
      TObjArray *arrNextCol = sLine.Tokenize("\t");
      
      TObjString *sObjType     = (TObjString*)(arrNextCol->At(0));
      TObjString *sObjFileName = (TObjString*)(arrNextCol->At(1));
      delete arrNextCol;

      if ( !sObjType || ! sObjFileName ) continue;
      TString sType(sObjType->GetString());
      TString sFileName(sObjFileName->GetString());
//       printf("%s\t%s\n",sType.Data(),sFileName.Data());
      
      TFile *fIn = TFile::Open(sFileName);
      if ( !fIn ){
         fprintf(stderr,"File not found: '%s'", sFileName.Data());
         continue;
      }
      
      if ( sType == "CE" ){
         AliTPCCalibCE *ce = (AliTPCCalibCE*)fIn->Get("AliTPCCalibCE");
         
         calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());         
         calPad->SetNameTitle("CETmean","CETmean");
         calibObjects->Add(calPad);
         
         calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());         
         calPad->SetNameTitle("CEQmean","CEQmean");
         calibObjects->Add(calPad);        
         
         calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadRMS());
         calPad->SetNameTitle("CETrms","CETrms");
         calibObjects->Add(calPad);         
                  
      } else if ( sType == "Pulser") {
         AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fIn->Get("AliTPCCalibPulser");
         
         calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());         
         calPad->SetNameTitle("PulserTmean","PulserTmean");
         calibObjects->Add(calPad);
         
         calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());         
         calPad->SetNameTitle("PulserQmean","PulserQmean");
         calibObjects->Add(calPad);        
         
         calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadRMS());
         calPad->SetNameTitle("PulserTrms","PulserTrms");
         calibObjects->Add(calPad);         
      
      } else if ( sType == "Pedestals") {
         AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)fIn->Get("AliTPCCalibPedestal");
         
         calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());         
         calPad->SetNameTitle("Pedestals","Pedestals");
         calibObjects->Add(calPad);
         
         calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());         
         calPad->SetNameTitle("Noise","Noise");
         calibObjects->Add(calPad);        
     
      } else {
         fprintf(stderr,"Undefined Type: '%s'",sType.Data());
         
      }
      delete fIn;
   }
   delete arrFileLine;
}

Int_t AliTPCcalibDB::InitDeadMap() {
  // Initialize DeadChannel Map 
  // Source of information:
  // -  HV (see UpdateChamberHighVoltageData())
  // -  Altro disabled channels. Noisy channels.
  // -  DDL list

  // check necessary information
  const Int_t run=GetRun();
  if (run<0){
    AliError("run not set in CDB manager. Cannot create active channel map");
    return 0;
  }
  AliDCSSensorArray* voltageArray = GetVoltageSensors(run);
  AliTPCCalPad*          altroMap = GetALTROMasked();
  TMap*                    mapddl = GetDDLMap();

  if (!voltageArray && !altroMap && !mapddl) {
    AliError("All necessary information to create the activate channel are map missing.");
    return 0;
  }
  
  //=============================================================
  // Setup DDL map

  Bool_t ddlMap[216]={0};
  for (Int_t iddl=0; iddl<216; ++iddl) ddlMap[iddl]=1;
  if (mapddl){
    TObjString *s = (TObjString*)mapddl->GetValue("DDLArray");
    if (s){
      for (Int_t iddl=0; iddl<216; ++iddl) ddlMap[iddl]=TString(s->GetString()(iddl))!="0";
    }
  } else {
    AliError("DDL map missing. ActiveChannelMap can only be created with parts of the information.");
  }
  // Setup DDL map done
  // ============================================================

  //=============================================================
  // Setup active chnnel map
  //

  if (!fActiveChannelMap) fActiveChannelMap=new AliTPCCalPad("ActiveChannelMap","ActiveChannelMap");

  AliTPCmapper map(gSystem->ExpandPathName("$ALICE_ROOT/TPC/mapping/"));

  if (!altroMap) AliError("ALTRO dead channel map missing. ActiveChannelMap can only be created with parts of the information.");
  
  for (Int_t iROC=0;iROC<AliTPCCalPad::kNsec;++iROC){
    AliTPCCalROC *roc=fActiveChannelMap->GetCalROC(iROC);
    if (!roc){
      AliError(Form("No ROC %d in active channel map",iROC));
      continue;
    }
    
    // check for bad voltage
    // see UpdateChamberHighVoltageData()
    if (!fChamberHVStatus[iROC]){
      roc->Multiply(0.);
      continue;
    }
    
    AliTPCCalROC *masked=0x0;
    if (altroMap) masked=altroMap->GetCalROC(iROC);
    
    for (UInt_t irow=0; irow<roc->GetNrows(); ++irow){
      for (UInt_t ipad=0; ipad<roc->GetNPads(irow); ++ipad){
        //per default the channel is on
        roc->SetValue(irow,ipad,1);
        // apply altro dead channel mask (inverse logik, it is not active, but inactive channles)
        if (masked && masked->GetValue(irow, ipad)) roc->SetValue(irow, ipad ,0);
        // mask channels if a DDL is inactive
        Int_t ddlId=map.GetEquipmentID(iROC, irow, ipad)-768;
        if (ddlId>=0 && !ddlMap[ddlId]) roc->SetValue(irow, ipad ,0);
      }
    }
  }
  
  return 1;
}

void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
  //
  // Write a tree with all available information
  // if mapFileName is specified, the Map information are also written to the tree
  // pads specified in outlierPad are not used for calculating statistics
  //  - the same function as AliTPCCalPad::MakeTree - 
  //
   AliTPCROC* tpcROCinstance = AliTPCROC::Instance();

   TObjArray* mapIROCs = 0;
   TObjArray* mapOROCs = 0;
   TVectorF *mapIROCArray = 0;
   TVectorF *mapOROCArray = 0;
   Int_t mapEntries = 0;
   TString* mapNames = 0;
   
   if (mapFileName) {
      TFile mapFile(mapFileName, "read");
      
      TList* listOfROCs = mapFile.GetListOfKeys();
      mapEntries = listOfROCs->GetEntries()/2;
      mapIROCs = new TObjArray(mapEntries*2);
      mapOROCs = new TObjArray(mapEntries*2);
      mapIROCArray = new TVectorF[mapEntries];
      mapOROCArray = new TVectorF[mapEntries];
      
      mapNames = new TString[mapEntries];
      for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
	TString nameROC(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
         nameROC.Remove(nameROC.Length()-4, 4);
         mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "IROC").Data()), ivalue);
         mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((nameROC + "OROC").Data()), ivalue);
         mapNames[ivalue].Append(nameROC);
      }
      
      for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
         mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
         mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
      
         for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
            (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
         for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
            (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
      }

   } //  if (mapFileName)
  
   TTreeSRedirector cstream(fileName);
   Int_t arrayEntries = array->GetEntries();
   
   TString* names = new TString[arrayEntries];
   for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
      names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());

   for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
      //
      // get statistic for given sector
      //
      TVectorF median(arrayEntries);
      TVectorF mean(arrayEntries);
      TVectorF rms(arrayEntries);
      TVectorF ltm(arrayEntries);
      TVectorF ltmrms(arrayEntries);
      TVectorF medianWithOut(arrayEntries);
      TVectorF meanWithOut(arrayEntries);
      TVectorF rmsWithOut(arrayEntries);
      TVectorF ltmWithOut(arrayEntries);
      TVectorF ltmrmsWithOut(arrayEntries);
      
      TVectorF *vectorArray = new TVectorF[arrayEntries];
      for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
         vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
      
      for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
         AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
         AliTPCCalROC* calROC = calPad->GetCalROC(isector);
         AliTPCCalROC* outlierROC = 0;
         if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
         if (calROC) {
            median[ivalue] = calROC->GetMedian();
            mean[ivalue] = calROC->GetMean();
            rms[ivalue] = calROC->GetRMS();
            Double_t ltmrmsValue = 0;
            ltm[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction);
            ltmrms[ivalue] = ltmrmsValue;
            if (outlierROC) {
               medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
               meanWithOut[ivalue] = calROC->GetMean(outlierROC);
               rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
               ltmrmsValue = 0;
               ltmWithOut[ivalue] = calROC->GetLTM(&ltmrmsValue, ltmFraction, outlierROC);
               ltmrmsWithOut[ivalue] = ltmrmsValue;
            }
         }
         else {
            median[ivalue] = 0.;
            mean[ivalue] = 0.;
            rms[ivalue] = 0.;
            ltm[ivalue] = 0.;
            ltmrms[ivalue] = 0.;
            medianWithOut[ivalue] = 0.;
            meanWithOut[ivalue] = 0.;
            rmsWithOut[ivalue] = 0.;
            ltmWithOut[ivalue] = 0.;
            ltmrmsWithOut[ivalue] = 0.;
         }
      }
      
      //
      // fill vectors of variable per pad
      //
      TVectorF *posArray = new TVectorF[8];
      for (Int_t ivalue = 0; ivalue < 8; ivalue++)
         posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));

      Float_t posG[3] = {0};
      Float_t posL[3] = {0};
      Int_t ichannel = 0;
      for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
         for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
            tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
            tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
            posArray[0][ichannel] = irow;
            posArray[1][ichannel] = ipad;
            posArray[2][ichannel] = posL[0];
            posArray[3][ichannel] = posL[1];
            posArray[4][ichannel] = posG[0];
            posArray[5][ichannel] = posG[1];
            posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
            posArray[7][ichannel] = ichannel;
            
            // loop over array containing AliTPCCalPads
            for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
               AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
               AliTPCCalROC* calROC = calPad->GetCalROC(isector);
               if (calROC)
                  (vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
               else
                  (vectorArray[ivalue])[ichannel] = 0;
            }
            ichannel++;
         }
      }
      
      cstream << "calPads" <<
         "sector=" << isector;
      
      for  (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
         cstream << "calPads" <<
            (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
            (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
            (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
            (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
            (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
         if (outlierPad) {
            cstream << "calPads" <<
               (Char_t*)((names[ivalue] + "_Median_OutlierCutted=").Data()) << medianWithOut[ivalue] <<
               (Char_t*)((names[ivalue] + "_Mean_OutlierCutted=").Data()) << meanWithOut[ivalue] <<
               (Char_t*)((names[ivalue] + "_RMS_OutlierCutted=").Data()) << rmsWithOut[ivalue] <<
               (Char_t*)((names[ivalue] + "_LTM_OutlierCutted=").Data()) << ltmWithOut[ivalue] <<
               (Char_t*)((names[ivalue] + "_RMS_LTM_OutlierCutted=").Data()) << ltmrmsWithOut[ivalue];
         }
      }

      for  (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
         cstream << "calPads" <<
            (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
      }

      if (mapFileName) {
         for  (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
            if (isector < 36)
               cstream << "calPads" <<
                  (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
            else
               cstream << "calPads" <<
                  (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
         }
      }

      cstream << "calPads" <<
         "row.=" << &posArray[0] <<
         "pad.=" << &posArray[1] <<
         "lx.=" << &posArray[2] <<
         "ly.=" << &posArray[3] <<
         "gx.=" << &posArray[4] <<
         "gy.=" << &posArray[5] <<
         "rpad.=" << &posArray[6] <<
         "channel.=" << &posArray[7];
         
      cstream << "calPads" <<
         "\n";

      delete[] posArray;
      delete[] vectorArray;
   }
   

   delete[] names;
   if (mapFileName) {
      delete mapIROCs;
      delete mapOROCs;
      delete[] mapIROCArray;
      delete[] mapOROCArray;
      delete[] mapNames;
   }
}

Int_t AliTPCcalibDB::GetRCUTriggerConfig() const
{
  //
  // return the RCU trigger configuration register
  //
  TMap *map=GetRCUconfig();
  if (!map) return -1;
  TVectorF *v=(TVectorF*)map->GetValue("TRGCONF_TRG_MODE");
  Float_t mode=-1;
  for (Int_t i=0; i<v->GetNrows(); ++i){
    Float_t newmode=v->GetMatrixArray()[i];
    if (newmode>-1){
      if (mode>-1&&newmode!=mode) AliWarning("Found different RCU trigger configurations!!!");
      mode=newmode;
    }
  }
  return (Int_t)mode;
}

Bool_t AliTPCcalibDB::IsTrgL0() 
{
  //
  // return if the FEE readout was triggered on L0
  //
  if (fMode<0) return kFALSE;
  return (fMode==1);
}

Bool_t AliTPCcalibDB::IsTrgL1()
{
  //
  // return if the FEE readout was triggered on L1
  //
  if (fMode<0) return kFALSE;
  return (fMode==0);
}

void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){
  //
  // Register static ExB correction map
  // index - registration index - used for visualization
  // bz    - bz field in kGaus

  //  Float_t factor =  bz/(-5.);  // default b filed in Cheb with minus sign
  Float_t factor =  bz/(5.);  // default b filed in Cheb with minus sign
                              // was chenged in the Revision ???? (Ruben can you add here number)
  
  AliMagF*   bmap = new AliMagF("MapsExB","MapsExB", factor,TMath::Sign(1.f,factor),AliMagF::k5kG);
  
  AliTPCExBFirst *exb  = new  AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50);
  AliTPCExB::SetInstance(exb);
  
  if (bdelete){
    delete bmap;
  }else{
    AliTPCExB::RegisterField(index,bmap);
  }
  if (index>=fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11);
  fgExBArray.AddAt(exb,index);
}


AliTPCExB*    AliTPCcalibDB::GetExB(Float_t bz, Bool_t deleteB) {
  //
  // bz filed in KGaus not in tesla
  // Get ExB correction map
  // if doesn't exist - create it
  //
  Int_t index = TMath::Nint(5+bz);
  if (index>fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11);
  if (!fgExBArray.At(index)) AliTPCcalibDB::RegisterExB(index,bz,deleteB);
  return (AliTPCExB*)fgExBArray.At(index);
}


void  AliTPCcalibDB::SetExBField(Float_t bz){
  //
  // Set magnetic filed for ExB correction
  //
  fExB = GetExB(bz,kFALSE);
}

void  AliTPCcalibDB::SetExBField(const AliMagF*   bmap){
  //
  // Set magnetic field for ExB correction
  //
  AliTPCExBFirst *exb  = new  AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50);
  AliTPCExB::SetInstance(exb);
  fExB=exb;
}



void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){
  //
  // - > Don't use it for reconstruction - Only for Calibration studies
  //
  if (run<=0) return;
  TObjString runstr(Form("%i",run));
  fRun=run;
  AliCDBEntry * entry = 0;
  if (run>= fRunList.fN){
    fRunList.Set(run*2+1);
    //
    //
    fALTROConfigData->Expand(run*2+1);    // ALTRO configuration data
    fPulserData->Expand(run*2+1);         // Calibration Pulser data
    fCEData->Expand(run*2+1);             // CE data
    if (!fTimeGainSplines) fTimeGainSplines = new TObjArray(run*2+1);
    fTimeGainSplines->Expand(run*2+1); // Array of AliSplineFits: at 0 MIP position in
  }
  if (fRunList[run]>0 &&force==kFALSE) return;

  fRunList[run]=1;  // sign as used

  //
  entry = AliCDBManager::Instance()->Get("GRP/GRP/Data",run);
  if (entry)  {
    AliGRPObject * grpRun = dynamic_cast<AliGRPObject*>(entry->GetObject());
    if (!grpRun){
      TMap* map = dynamic_cast<TMap*>(entry->GetObject());
      if (map){
	//grpRun = new AliGRPObject; 
	//grpRun->ReadValuesFromMap(map);
	grpRun =  MakeGRPObjectFromMap(map);

	fGRPMaps.Add(new TObjString(runstr),map);
      }
    }
    fGRPArray.Add(new TObjString(runstr),grpRun);
  }
  entry = AliCDBManager::Instance()->Get("TPC/Calib/Goofie",run);
  if (entry){
    fGoofieArray.Add(new TObjString(runstr),entry->GetObject());
  }
  //
  
  //
  entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGain",run);
  if (entry)  {
    fTimeGainSplinesArray.Add(new TObjString(runstr),entry->GetObject());
  }else{
    AliFatal("TPC - Missing calibration entry TimeGain");
  }
  //
  entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeDrift",run);
  if (entry)  {
    TObjArray * timeArray = (TObjArray*)entry->GetObject();    
    fDriftCorrectionArray.Add(new TObjString(runstr),entry->GetObject());  
    AliTPCCorrection * correctionTime = (AliTPCCorrection *)timeArray->FindObject("FitCorrectionTime");
    if (correctionTime && fComposedCorrectionArray){
      correctionTime->Init();
      if (fComposedCorrectionArray->GetEntriesFast()<4) fComposedCorrectionArray->Expand(40);
      fComposedCorrectionArray->AddAt(correctionTime,4); //add time dependent correction to the list of available corrections
    }
  }else{
    AliFatal("TPC - Missing calibration entry TimeDrift");
  }
  //
  entry = AliCDBManager::Instance()->Get("TPC/Calib/Temperature",run);
  if (entry)  {
    fTemperatureArray.Add(new TObjString(runstr),entry->GetObject());
  }

  // High voltage
  entry = AliCDBManager::Instance()->Get("TPC/Calib/HighVoltage",run);
  if (!fVoltageArray.GetValue(runstr.GetName()) && entry)  {
    fVoltageArray.Add(new TObjString(runstr),entry->GetObject());
  }

  //apply fDButil filters

  fDButil->UpdateFromCalibDB();
  if (fTemperature) fDButil->FilterTemperature(fTemperature);

  AliDCSSensor * press = GetPressureSensor(run,0);
  AliTPCSensorTempArray * temp = GetTemperatureSensor(run);
  Bool_t accept=kTRUE;
  if (temp) {
    accept = fDButil->FilterTemperature(temp)>0.1;
  }
  if (press) {
    const Double_t kMinP=900.;
    const Double_t kMaxP=1050.;
    const Double_t kMaxdP=10.;
    const Double_t kSigmaCut=4.;
    fDButil->FilterSensor(press,kMinP,kMaxP,kMaxdP,kSigmaCut);
    if (press->GetFit()==0) accept=kFALSE;
  }

  if (press && temp &&accept){
    AliTPCCalibVdrift * vdrift = new AliTPCCalibVdrift(temp, press,0);
    fVdriftArray.Add(new TObjString(runstr),vdrift);
  }

  fDButil->FilterCE(120., 3., 4.,0);
  fDButil->FilterTracks(run, 10.,0);

}


Float_t AliTPCcalibDB::GetGain(Int_t sector, Int_t row, Int_t pad){
  //
  // Get Gain factor for given pad
  //
  AliTPCCalPad *calPad = Instance()->fDedxGainFactor;;
  if (!calPad) return 0;
  return calPad->GetCalROC(sector)->GetValue(row,pad);
}

AliSplineFit* AliTPCcalibDB::GetVdriftSplineFit(const char* name, Int_t run){
  //
  // GetDrift velocity spline fit
  //
  TObjArray *arr=GetTimeVdriftSplineRun(run);
  if (!arr) return 0;
  return dynamic_cast<AliSplineFit*>(arr->FindObject(name));
}

AliSplineFit* AliTPCcalibDB::CreateVdriftSplineFit(const char* graphName, Int_t run){
  //
  // create spline fit from the drift time graph in TimeDrift
  //
  TObjArray *arr=GetTimeVdriftSplineRun(run);
  if (!arr) return 0;
  TGraph *graph=dynamic_cast<TGraph*>(arr->FindObject(graphName));
  if (!graph) return 0;
  AliSplineFit *fit = new AliSplineFit();
  fit->SetGraph(graph);
  fit->SetMinPoints(graph->GetN()+1);
  fit->InitKnots(graph,2,0,0.001);
  fit->SplineFit(0);
  return fit;
}

AliGRPObject *AliTPCcalibDB::GetGRP(Int_t run){
  //
  // Get GRP object for given run 
  //
  AliGRPObject * grpRun = dynamic_cast<AliGRPObject *>((Instance()->fGRPArray).GetValue(Form("%i",run)));
  if (!grpRun) {
    Instance()->UpdateRunInformations(run);
    grpRun = dynamic_cast<AliGRPObject *>(Instance()->fGRPArray.GetValue(Form("%i",run)));
    if (!grpRun) return 0; 
  }
  return grpRun;
}

TMap *  AliTPCcalibDB::GetGRPMap(Int_t run){
  //
  // Get GRP map for given run
  //
  TMap * grpRun = dynamic_cast<TMap *>((Instance()->fGRPMaps).GetValue(Form("%i",run)));
  if (!grpRun) {
    Instance()->UpdateRunInformations(run);
    grpRun = dynamic_cast<TMap *>(Instance()->fGRPMaps.GetValue(Form("%i",run)));
    if (!grpRun) return 0; 
  }
  return grpRun;
}


AliDCSSensor * AliTPCcalibDB::GetPressureSensor(Int_t run, Int_t type){
  //
  // Get Pressure sensor
  // run  = run number
  // type = 0 - Cavern pressure
  //        1 - Suface pressure
  // First try to get if trom map - if existing  (Old format of data storing)
  //


  TMap *map = GetGRPMap(run);  
  if (map){
    AliDCSSensor * sensor = 0;
    TObject *osensor=0;
    if (type==0) osensor = ((*map)("fCavernPressure"));
    if (type==1) osensor = ((*map)("fP2Pressure"));
    sensor =dynamic_cast<AliDCSSensor *>(osensor); 
    if (sensor) return sensor;
  }
  //
  // If not map try to get it from the GRPObject
  //
  AliGRPObject * grpRun = dynamic_cast<AliGRPObject *>(fGRPArray.GetValue(Form("%i",run))); 
  if (!grpRun) {
    UpdateRunInformations(run);
    grpRun = dynamic_cast<AliGRPObject *>(fGRPArray.GetValue(Form("%i",run)));
    if (!grpRun) return 0; 
  }
  AliDCSSensor * sensor = grpRun->GetCavernAtmosPressure();
  if (type==1) sensor = grpRun->GetSurfaceAtmosPressure();
  return sensor; 
}

AliTPCSensorTempArray * AliTPCcalibDB::GetTemperatureSensor(Int_t run){
  //
  // Get temperature sensor array
  //
  AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)fTemperatureArray.GetValue(Form("%i",run));
  if (!tempArray) {
    UpdateRunInformations(run);
    tempArray = (AliTPCSensorTempArray *)fTemperatureArray.GetValue(Form("%i",run));
  }
  return tempArray;
}


TObjArray * AliTPCcalibDB::GetTimeGainSplinesRun(Int_t run){
  //
  // Get temperature sensor array
  //
  TObjArray * gainSplines = (TObjArray *)fTimeGainSplinesArray.GetValue(Form("%i",run));
  if (!gainSplines) {
    UpdateRunInformations(run);
    gainSplines = (TObjArray *)fTimeGainSplinesArray.GetValue(Form("%i",run));
  }
  return gainSplines;
}

TObjArray * AliTPCcalibDB::GetTimeVdriftSplineRun(Int_t run){
  //
  // Get drift spline array
  //
  TObjArray * driftSplines = (TObjArray *)fDriftCorrectionArray.GetValue(Form("%i",run));
  if (!driftSplines) {
    UpdateRunInformations(run);
    driftSplines = (TObjArray *)fDriftCorrectionArray.GetValue(Form("%i",run));
  }
  return driftSplines;
}

AliDCSSensorArray * AliTPCcalibDB::GetVoltageSensors(Int_t run){
  //
  // Get temperature sensor array
  //
  AliDCSSensorArray * voltageArray = (AliDCSSensorArray *)fVoltageArray.GetValue(Form("%i",run));
  if (!voltageArray) {
    UpdateRunInformations(run);
    voltageArray = (AliDCSSensorArray *)fVoltageArray.GetValue(Form("%i",run));
  }
  return voltageArray;
}

AliDCSSensorArray * AliTPCcalibDB::GetGoofieSensors(Int_t run){
  //
  // Get temperature sensor array
  //
  AliDCSSensorArray * goofieArray = (AliDCSSensorArray *)fGoofieArray.GetValue(Form("%i",run));
  if (!goofieArray) {
    UpdateRunInformations(run);
    goofieArray = (AliDCSSensorArray *)fGoofieArray.GetValue(Form("%i",run));
  }
  return goofieArray;
}



AliTPCCalibVdrift *     AliTPCcalibDB::GetVdrift(Int_t run){
  //
  // Get the interface to the the vdrift 
  //
  AliTPCCalibVdrift  * vdrift = (AliTPCCalibVdrift*)fVdriftArray.GetValue(Form("%i",run));
  if (!vdrift) {
    UpdateRunInformations(run);
    vdrift= (AliTPCCalibVdrift*)fVdriftArray.GetValue(Form("%i",run));
  }
  return vdrift;
}

Float_t AliTPCcalibDB::GetCEdriftTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
{
  //
  // GetCE drift time information for 'sector'
  // sector 72 is the mean drift time of the A-Side
  // sector 73 is the mean drift time of the C-Side
  // it timestamp==-1 return mean value
  //
  AliTPCcalibDB::Instance()->SetRun(run);
  TGraph *gr=AliTPCcalibDB::Instance()->GetCErocTgraph(sector);
  if (!gr||sector<0||sector>73) {
    if (entries) *entries=0;
    return 0.;
  }
  Float_t val=0.;
  if (timeStamp==-1.){
    val=gr->GetMean(2);
  }else{
    for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
      Double_t x,y;
      gr->GetPoint(ipoint,x,y);
      if (x<timeStamp) continue;
      val=y;
      break;
    }
  }
  return val;
}
  
Float_t AliTPCcalibDB::GetCEchargeTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
{
  //
  // GetCE mean charge for 'sector'
  // it timestamp==-1 return mean value
  //
  AliTPCcalibDB::Instance()->SetRun(run);
  TGraph *gr=AliTPCcalibDB::Instance()->GetCErocQgraph(sector);
  if (!gr||sector<0||sector>71) {
    if (entries) *entries=0;
    return 0.;
  }
  Float_t val=0.;
  if (timeStamp==-1.){
    val=gr->GetMean(2);
  }else{
    for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
      Double_t x,y;
      gr->GetPoint(ipoint,x,y);
      if (x<timeStamp) continue;
      val=y;
      break;
    }
  }
  return val;
}

Float_t AliTPCcalibDB::GetDCSSensorValue(AliDCSSensorArray *arr, Int_t timeStamp, const char * sensorName, Int_t sigDigits)
{
  //
  // Get Value for a DCS sensor 'sensorName', run 'run' at time 'timeStamp'
  //
  Float_t val=0;
  const TString sensorNameString(sensorName);
  AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
  if (!sensor) return val;
  //use the dcs graph if possible
  TGraph *gr=sensor->GetGraph();
  if (gr){
    for (Int_t ipoint=0;ipoint<gr->GetN();++ipoint){
      Double_t x,y;
      gr->GetPoint(ipoint,x,y);
      Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
      if (time<timeStamp) continue;
      val=y;
      break;
    }
    //if val is still 0, test if if the requested time if within 5min of the first/last
    //data point. If this is the case return the firs/last entry
    //the timestamps might not be syncronised for all calibration types, sometimes a 'pre'
    //and 'pos' period is requested. Especially to the HV this is not the case!
    //first point
    if (val==0 ){
      Double_t x,y;
      gr->GetPoint(0,x,y);
      const Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
      const Int_t dtime=time-timeStamp;
      if ( (dtime>0) && (dtime<5*60) ) val=y;
    }
    //last point
    if (val==0 ){
      Double_t x,y;
      gr->GetPoint(gr->GetN()-1,x,y);
      const Int_t time=TMath::Nint(sensor->GetStartTime()+x*3600); //time in graph is hours
      const Int_t dtime=timeStamp-time;
      if ( (dtime>0) && (dtime<5*60) ) val=y;
    }
  } else {
    val=sensor->GetValue(timeStamp);
  }
  if (sigDigits>=0){
    val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits);
  }
  return val;
}

Float_t AliTPCcalibDB::GetDCSSensorMeanValue(AliDCSSensorArray *arr, const char * sensorName, Int_t sigDigits)
{
  //
  // Get mean Value for a DCS sensor 'sensorName' during run 'run'
  //
  Float_t val=0;
  const TString sensorNameString(sensorName);
  AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
  if (!sensor) return val;

  //use dcs graph if it exists
  TGraph *gr=sensor->GetGraph();
  if (gr){
    val=gr->GetMean(2);
  } else {
    //if we don't have the dcs graph, try to get some meaningful information
    if (!sensor->GetFit()) return val;
    Int_t nKnots=sensor->GetFit()->GetKnots();
    Double_t tMid=(sensor->GetEndTime()-sensor->GetStartTime())/2.;
    for (Int_t iKnot=0;iKnot<nKnots;++iKnot){
      if (sensor->GetFit()->GetX()[iKnot]>tMid/3600.) break;
      val=(Float_t)sensor->GetFit()->GetY0()[iKnot];
    }
  }
  if (sigDigits>=0){
    // val/=10;
    val=(Float_t)TMath::Floor(val * TMath::Power(10., sigDigits) + .5) / TMath::Power(10., sigDigits);
    //    val*=10;
  }
  return val;
}

Bool_t AliTPCcalibDB::IsDataTakingActive(time_t timeStamp)
{
  if (!fGrRunState) return kFALSE;
  Double_t time=Double_t(timeStamp);
  Int_t currentPoint=0;
  Bool_t currentVal=fGrRunState->GetY()[currentPoint]>0.5;
  Bool_t retVal=currentVal;
  Double_t currentTime=fGrRunState->GetX()[currentPoint];
  
  while (time>currentTime){
    retVal=currentVal;
    if (currentPoint==fGrRunState->GetN()) break;
    currentVal=fGrRunState->GetY()[currentPoint]>0.5;
    currentTime=fGrRunState->GetX()[currentPoint];
    ++currentPoint;
  }

  return retVal;
}

void AliTPCcalibDB::UpdateChamberHighVoltageData()
{
  //
  // set chamber high voltage data
  // 1. Robust median (sampling the hv graphs over time)
  // 2. Current nominal voltages (nominal voltage corrected for common HV offset)
  // 3. Fraction of good HV values over time (deviation from robust median)
  // 4. HV status, based on the above
  //

  // start and end time of the run
  const Int_t run=GetRun();
  if (run<0) return;

  // if no valid run information - return
  AliGRPObject* grp = GetGRP(run);
  if (!grp) return;

  const Int_t startTimeGRP = grp->GetTimeStart();
  const Int_t stopTimeGRP  = grp->GetTimeEnd();

  //
  // In case we use a generated GRP we cannot make use of the start time and end time information
  // therefore we cannot calculate proper HV information and will skip this
  //
  if (startTimeGRP==0 && stopTimeGRP==0) {
    AliWarning("Using a generated GRP with 'GetTimeStart()' and 'GetTimeEnd()' == 0. Cannot calculate HV information.");
    return;
  }

  //
  // check active state by analysing the scalers
  //
  // initialise graph with active running
  AliCDBEntry *entry = GetCDBEntry("GRP/CTP/Scalers");
  if (!entry) return;
  // entry->SetOwner(kTRUE);
  AliTriggerRunScalers *sca = (AliTriggerRunScalers*)entry->GetObject();
  Int_t nchannels = sca->GetNumClasses(); // number of scaler channels (i.e. trigger classes)
  Int_t npoints = sca->GetScalersRecords()->GetEntries(); // number of samples

  delete fGrRunState;
  fGrRunState=new TGraph;
  fGrRunState->SetPoint(fGrRunState->GetN(),Double_t(startTimeGRP)-.001,0);
  fGrRunState->SetPoint(fGrRunState->GetN(),Double_t(startTimeGRP),1);
  ULong64_t lastSum=0;
  Double_t timeLast=0.;
  Bool_t active=kTRUE;
  for (int i=0; i<npoints; i++) {
    AliTriggerScalersRecord *rec = (AliTriggerScalersRecord *) sca->GetScalersRecord(i);
    Double_t time = ((AliTimeStamp*) rec->GetTimeStamp())->GetSeconds();
    ULong64_t sum=0;
    for (int j=0; j<nchannels; j++) sum += ((AliTriggerScalers*) rec->GetTriggerScalers()->At(j))->GetL2CA();
    if (TMath::Abs(time-timeLast)<.001 && sum==lastSum ) continue;
    if (active && sum==lastSum){
      fGrRunState->SetPoint(fGrRunState->GetN(),timeLast-.01,1);
      fGrRunState->SetPoint(fGrRunState->GetN(),timeLast,0);
      active=kFALSE;
    } else if (!active && sum>lastSum ){
      fGrRunState->SetPoint(fGrRunState->GetN(),timeLast-.01,0);
      fGrRunState->SetPoint(fGrRunState->GetN(),timeLast,1);
      active=kTRUE;
    }
    lastSum=sum;
    timeLast=time;
  }
  fGrRunState->SetPoint(fGrRunState->GetN(),Double_t(stopTimeGRP),active);
  fGrRunState->SetPoint(fGrRunState->GetN(),Double_t(stopTimeGRP)+.001,0);
  
  
  
  // reset all values
  for (Int_t iROC=0;iROC<72;++iROC) {
    fChamberHVmedian[iROC]       = -1;
    fChamberHVgoodFraction[iROC] = 0.;
    fCurrentNominalVoltage[iROC] = -999.;
    fChamberHVStatus[iROC]       = kFALSE;
  }
  
  AliDCSSensorArray* voltageArray = GetVoltageSensors(run);
  if (!voltageArray) {
    AliError("Voltage Array missing. Cannot calculate HV information!");
    return;
  }

  // max HV diffs before a chamber is masked
  const Float_t maxVdiff      = fParam->GetMaxVoltageDeviation();
  const Float_t maxDipVoltage = fParam->GetMaxDipVoltage();
  const Float_t maxFracHVbad  = fParam->GetMaxFractionHVbad();

  const Int_t samplingPeriod=1;

  // array with sampled voltages
  const Int_t maxSamples=(stopTimeGRP-startTimeGRP)/samplingPeriod + 10*samplingPeriod;
  Float_t *vSampled = new Float_t[maxSamples];

  // deviation of the median from the nominal voltage
  Double_t chamberMedianDeviation[72]={0.};

  for (Int_t iROC=0; iROC<72; ++iROC){
    chamberMedianDeviation[iROC]=0.;
    TString sensorName="";
    Char_t sideName='A';
    if ((iROC/18)%2==1) sideName='C';
    if (iROC<36) sensorName=Form("TPC_ANODE_I_%c%02d_VMEAS",sideName,iROC%18);
    else        sensorName=Form("TPC_ANODE_O_%c%02d_0_VMEAS",sideName,iROC%18);

    AliDCSSensor *sensor = voltageArray->GetSensor(sensorName);

    fHVsensors[iROC]=sensor;
    if (!sensor) continue;

    Int_t nPointsSampled=0;
    
    TGraph *gr=sensor->GetGraph();
    if ( gr && gr->GetN()>1 ){
      //1. sample voltage over time
      //   get a robust median
      //   buffer sampled voltages
      
      // current sampling time
      Int_t time=startTimeGRP;
      
      // input graph sampling point
      const Int_t nGraph=gr->GetN();
      Int_t pointGraph=0;
      
      //initialise graph information
      Int_t timeGraph=TMath::Nint(gr->GetX()[pointGraph+1]*3600+sensor->GetStartTime());
      Double_t sampledHV=gr->GetY()[pointGraph++];

      while (time<stopTimeGRP){
        while (timeGraph<=time && pointGraph+1<nGraph){
          timeGraph=TMath::Nint(gr->GetX()[pointGraph+1]*3600+sensor->GetStartTime());
          sampledHV=gr->GetY()[pointGraph++];
        }
        time+=samplingPeriod;
        if (!IsDataTakingActive(time-samplingPeriod)) continue;
        vSampled[nPointsSampled++]=sampledHV;
      }

      if (nPointsSampled<1) continue;
      
      fChamberHVmedian[iROC]=TMath::Median(nPointsSampled,vSampled);
      chamberMedianDeviation[iROC]=fChamberHVmedian[iROC]-fParam->GetNominalVoltage(iROC);

      //2. calculate good HV fraction
      Int_t ngood=0;
      for (Int_t ipoint=0; ipoint<nPointsSampled; ++ipoint) {
        if (TMath::Abs(vSampled[ipoint]-fChamberHVmedian[iROC])<maxDipVoltage) ++ngood;
      }

      fChamberHVgoodFraction[iROC]=Float_t(ngood)/Float_t(nPointsSampled);
    } else if (!gr && !sensor->GetFit() ){
      // This is an exception handling.
      // It was observed that for some rund in the 2010 data taking no HV info is available
      //    for some sectors. However they were active. So take care about this
      fChamberHVmedian[iROC]       = fParam->GetNominalVoltage(iROC);
      fChamberHVgoodFraction[iROC] = 1.;
      AliWarning(Form("ROC %d detected without HV Splines and HV graph. Will set median HV to nominal voltage",iROC));
    } else {
      AliError(Form("No Graph or too few points found for HV sensor of ROC %d",iROC));
    }
  }

  delete [] vSampled;
  vSampled=0x0;
  
  // get median deviation from all chambers (detect e.g. -50V)
  const Double_t medianIROC=TMath::Median( 36, chamberMedianDeviation );
  const Double_t medianOROC=TMath::Median( 36, chamberMedianDeviation+36 );
  
  // Define current default voltages
  for (Int_t iROC=0;iROC<72/*AliTPCCalPad::kNsec*/;++iROC){
    const Float_t averageDeviation=(iROC<36)?medianIROC:medianOROC;
    fCurrentNominalVoltage[iROC]=fParam->GetNominalVoltage(iROC)+averageDeviation;
  }

  //
  // Check HV status
  //
  for (Int_t iROC=0;iROC<72/*AliTPCCalPad::kNsec*/;++iROC){
    fChamberHVStatus[iROC]=kTRUE;

    //a. Deviation of median from current nominal voltage
    //   allow larger than nominal voltages
    if (fCurrentNominalVoltage[iROC]-fChamberHVmedian[iROC] >  maxVdiff) fChamberHVStatus[iROC]=kFALSE;

    //b. Fraction of bad hv values
    if ( 1-fChamberHVgoodFraction[iROC] > maxFracHVbad ) fChamberHVStatus[iROC]=kFALSE;
  }
}

Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits, Bool_t current) {
  //
  // return the chamber HV for given run and time: 0-35 IROC, 36-72 OROC
  // if timeStamp==-1 return mean value
  //
  Float_t val=0;
  TString sensorName="";
  TTimeStamp stamp(timeStamp);
  AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
  if (!voltageArray || (sector<0) || (sector>71)) return val;
  Char_t sideName='A';
  if ((sector/18)%2==1) sideName='C';
  if (sector<36){
    //IROC
    sensorName=Form("TPC_ANODE_I_%c%02d_VMEAS",sideName,sector%18);
  }else{
    //OROC
    sensorName=Form("TPC_ANODE_O_%c%02d_0_VMEAS",sideName,sector%18);
  }
  if (current){
    if (sector<36){
      //IROC
      sensorName=Form("TPC_ANODE_I_%c%02d_IMEAS",sideName,sector%18);
    }else{
      //OROC
      sensorName=Form("TPC_ANODE_O_%c%02d_0_IMEAS",sideName,sector%18);
    }
    
  }
  if (timeStamp==-1){
    val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
  } else {
    val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
  }
  return val;
}
Float_t AliTPCcalibDB::GetSkirtVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
  //
  // Get the skirt voltage for 'run' at 'timeStamp' and 'sector': 0-35 IROC, 36-72 OROC
  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
  // if timeStamp==-1 return the mean value for the run
  //
  Float_t val=0;
  TString sensorName="";
  TTimeStamp stamp(timeStamp);
  AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
  if (!voltageArray || (sector<0) || (sector>71)) return val;
  Char_t sideName='A';
  if ((sector/18)%2==1) sideName='C';
  sensorName=Form("TPC_SKIRT_%c_VMEAS",sideName);
  if (timeStamp==-1){
    val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
  } else {
    val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
  }
  return val;
}

Float_t AliTPCcalibDB::GetCoverVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
  //
  // Get the cover voltage for run 'run' at time 'timeStamp'
  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
  // if timeStamp==-1 return the mean value for the run
  //
  Float_t val=0;
  TString sensorName="";
  TTimeStamp stamp(timeStamp);
  AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
  if (!voltageArray || (sector<0) || (sector>71)) return val;
  Char_t sideName='A';
  if ((sector/18)%2==1) sideName='C';
  if (sector<36){
    //IROC
    sensorName=Form("TPC_COVER_I_%c_VMEAS",sideName);
  }else{
    //OROC
    sensorName=Form("TPC_COVER_O_%c_VMEAS",sideName);
  }
  if (timeStamp==-1){
    val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
  } else {
    val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
  }
  return val;
}

Float_t AliTPCcalibDB::GetGGoffsetVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
  //
  // Get the GG offset voltage for run 'run' at time 'timeStamp'
  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
  // if timeStamp==-1 return the mean value for the run
  //
  Float_t val=0;
  TString sensorName="";
  TTimeStamp stamp(timeStamp);
  AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
  if (!voltageArray || (sector<0) || (sector>71)) return val;
  Char_t sideName='A';
  if ((sector/18)%2==1) sideName='C';
  if (sector<36){
    //IROC
    sensorName=Form("TPC_GATE_I_%c_OFF_VMEAS",sideName);
  }else{
    //OROC
    sensorName=Form("TPC_GATE_O_%c_OFF_VMEAS",sideName);
  }
  if (timeStamp==-1){
    val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
  } else {
    val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
  }
  return val;
}

Float_t AliTPCcalibDB::GetGGnegVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
  //
  // Get the GG offset voltage for run 'run' at time 'timeStamp'
  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
  // if timeStamp==-1 return the mean value for the run
  //
  Float_t val=0;
  TString sensorName="";
  TTimeStamp stamp(timeStamp);
  AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
  if (!voltageArray || (sector<0) || (sector>71)) return val;
  Char_t sideName='A';
  if ((sector/18)%2==1) sideName='C';
  if (sector<36){
    //IROC
    sensorName=Form("TPC_GATE_I_%c_NEG_VMEAS",sideName);
  }else{
    //OROC
    sensorName=Form("TPC_GATE_O_%c_NEG_VMEAS",sideName);
  }
  if (timeStamp==-1){
    val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
  } else {
    val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
  }
  return val;
}

Float_t AliTPCcalibDB::GetGGposVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
  //
  // Get the GG offset voltage for run 'run' at time 'timeStamp'
  // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
  // if timeStamp==-1 return the mean value for the run
  //
  Float_t val=0;
  TString sensorName="";
  TTimeStamp stamp(timeStamp);
  AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(run);
  if (!voltageArray || (sector<0) || (sector>71)) return val;
  Char_t sideName='A';
  if ((sector/18)%2==1) sideName='C';
  if (sector<36){
    //IROC
    sensorName=Form("TPC_GATE_I_%c_POS_VMEAS",sideName);
  }else{
    //OROC
    sensorName=Form("TPC_GATE_O_%c_POS_VMEAS",sideName);
  }
  if (timeStamp==-1){
    val=AliTPCcalibDB::GetDCSSensorMeanValue(voltageArray, sensorName.Data(),sigDigits);
  } else {
    val=AliTPCcalibDB::GetDCSSensorValue(voltageArray, timeStamp, sensorName.Data(),sigDigits);
  }
  return val;
}

Float_t AliTPCcalibDB::GetPressure(Int_t timeStamp, Int_t run, Int_t type){
  //
  // GetPressure for given time stamp and runt
  //
  TTimeStamp stamp(timeStamp);
  AliDCSSensor * sensor = Instance()->GetPressureSensor(run,type);
  if (!sensor) return 0;
  return sensor->GetValue(stamp);
}

Float_t AliTPCcalibDB::GetL3Current(Int_t run, Int_t statType){
  //
  // return L3 current
  // stat type is: AliGRPObject::Stats: kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4
  //
  Float_t current=-1;
  AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
  if (grp) current=grp->GetL3Current((AliGRPObject::Stats)statType);
  return current;
}

Float_t AliTPCcalibDB::GetBz(Int_t run){
  //
  // calculate BZ in T from L3 current
  //
  Float_t bz=-1;
  Float_t current=AliTPCcalibDB::GetL3Current(run);
  if (current>-1) bz=5*current/30000.*.1;
  return bz;
}

Char_t  AliTPCcalibDB::GetL3Polarity(Int_t run) {
  //
  // get l3 polarity from GRP
  //
  Char_t pol=-100;
  AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
  if (grp) pol=grp->GetL3Polarity();
  return pol;
}

TString AliTPCcalibDB::GetRunType(Int_t run){
  //
  // return run type from grp
  //

//   TString type("UNKNOWN");
  AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
  if (grp) return grp->GetRunType();
  return "UNKNOWN";
}

Float_t AliTPCcalibDB::GetValueGoofie(Int_t timeStamp, Int_t run, Int_t type){
  //
  // GetPressure for given time stamp and runt
  //
  TTimeStamp stamp(timeStamp);
  AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(run);
  if (!goofieArray) return 0;
  AliDCSSensor *sensor = goofieArray->GetSensor(type);
  return sensor->GetValue(stamp);
}






Bool_t  AliTPCcalibDB::GetTemperatureFit(Int_t timeStamp, Int_t run, Int_t side,TVectorD& fit){
  //
  // GetTmeparature fit at parameter for given time stamp
  //
  TTimeStamp tstamp(timeStamp);
  AliTPCSensorTempArray* tempArray  = Instance()->GetTemperatureSensor(run);
  if (! tempArray) return kFALSE;
  AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
  TLinearFitter * fitter = tempMap->GetLinearFitter(3,side,tstamp);
  if (fitter){
    fitter->Eval(); 
    fitter->GetParameters(fit);
  }
  delete fitter;
  delete tempMap;
  if (!fitter) return kFALSE;
  return kTRUE;
}

Float_t AliTPCcalibDB::GetTemperature(Int_t timeStamp, Int_t run, Int_t side){
  //
  // Get mean temperature
  // 
  TVectorD vec(5);
  if (side==0) {
    GetTemperatureFit(timeStamp,run,0,vec);
    return vec[0];
  }
  if (side==1){
    GetTemperatureFit(timeStamp,run,0,vec);
    return vec[0];
  }
  return 0;
}


Double_t AliTPCcalibDB::GetPTRelative(UInt_t timeSec, Int_t run, Int_t side){
  //
  // Get relative P/T 
  // time - absolute time
  // run  - run number
  // side - 0 - A side   1-C side
  AliTPCCalibVdrift * vdrift =  Instance()->GetVdrift(run);
  if (!vdrift) return 0;
  return vdrift->GetPTRelative(timeSec,side);
}

AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){
  //
  // Function to covert old GRP run information from TMap to GRPObject
  //
  //  TMap * map = AliTPCcalibDB::GetGRPMap(52406);
  if (!map) return 0;
  AliDCSSensor * sensor = 0;
  TObject *osensor=0;
  osensor = ((*map)("fP2Pressure"));
  sensor  =dynamic_cast<AliDCSSensor *>(osensor); 
  //
  if (!sensor) return 0;
  //
  AliDCSSensor * sensor2 = new AliDCSSensor(*sensor);
  osensor = ((*map)("fCavernPressure"));
  TGraph * gr = new TGraph(2);
  gr->GetX()[0]= -100000.;
  gr->GetX()[1]= 1000000.;
  gr->GetY()[0]= atof(osensor->GetName());
  gr->GetY()[1]= atof(osensor->GetName());
  sensor2->SetGraph(gr);
  sensor2->SetFit(0);
  

  AliGRPObject *grpRun = new AliGRPObject; 
  grpRun->ReadValuesFromMap(map);
  grpRun->SetCavernAtmosPressure(sensor2);
  grpRun->SetCavernAtmosPressure(sensor2);
  grpRun->SetSurfaceAtmosPressure(sensor);
  return grpRun;
}

Bool_t AliTPCcalibDB::CreateGUITree(Int_t run, const char* filename)
{
  //
  // Create a gui tree for run number 'run'
  //

  if (!AliCDBManager::Instance()->GetDefaultStorage()){
    AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
                    MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__);
    return kFALSE;
  }
  //db instance
  AliTPCcalibDB *db=AliTPCcalibDB::Instance();
  // retrieve cal pad objects
  db->SetRun(run);
  db->CreateGUITree(filename);
  return kTRUE;
}

Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){
  //
  //
  //
  if (!AliCDBManager::Instance()->GetDefaultStorage()){
    AliError("Default Storage not set. Cannot create calibration Tree!");
    return kFALSE;
  }
  UpdateNonRec();  // load all infromation now

  AliTPCPreprocessorOnline prep;
  if (GetActiveChannelMap()) prep.AddComponent(new AliTPCCalPad(*GetActiveChannelMap()));

  // gain map
  if (GetDedxGainFactor()) prep.AddComponent(new AliTPCCalPad(*GetDedxGainFactor()));
  //noise and pedestals
  if (GetPedestals()) prep.AddComponent(new AliTPCCalPad(*(GetPedestals())));
  if (GetPadNoise() ) prep.AddComponent(new AliTPCCalPad(*(GetPadNoise())));
  //pulser data
  if (GetPulserTmean()) prep.AddComponent(new AliTPCCalPad(*(GetPulserTmean())));
  if (GetPulserTrms() ) prep.AddComponent(new AliTPCCalPad(*(GetPulserTrms())));
  if (GetPulserQmean()) prep.AddComponent(new AliTPCCalPad(*(GetPulserQmean())));
  //CE data
  if (GetCETmean()) prep.AddComponent(new AliTPCCalPad(*(GetCETmean())));
  if (GetCETrms() ) prep.AddComponent(new AliTPCCalPad(*(GetCETrms())));
  if (GetCEQmean()) prep.AddComponent(new AliTPCCalPad(*(GetCEQmean())));
  //Altro data
  if (GetALTROAcqStart() ) prep.AddComponent(new AliTPCCalPad(*(GetALTROAcqStart() )));
  if (GetALTROZsThr()    ) prep.AddComponent(new AliTPCCalPad(*(GetALTROZsThr()    )));
  if (GetALTROFPED()     ) prep.AddComponent(new AliTPCCalPad(*(GetALTROFPED()     )));
  if (GetALTROAcqStop()  ) prep.AddComponent(new AliTPCCalPad(*(GetALTROAcqStop()  )));
  if (GetALTROMasked()   ) prep.AddComponent(new AliTPCCalPad(*(GetALTROMasked()   )));
  //QA
  AliTPCdataQA *dataQA=GetDataQA();
  if (dataQA) {
    if (dataQA->GetNLocalMaxima())
      prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNLocalMaxima())));
    if (dataQA->GetMaxCharge())
      prep.AddComponent(new AliTPCCalPad(*(dataQA->GetMaxCharge())));
    if (dataQA->GetMeanCharge())
      prep.AddComponent(new AliTPCCalPad(*(dataQA->GetMeanCharge())));
    if (dataQA->GetNoThreshold())
      prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNoThreshold())));
    if (dataQA->GetNTimeBins())
      prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNTimeBins())));
    if (dataQA->GetNPads())
      prep.AddComponent(new AliTPCCalPad(*(dataQA->GetNPads())));
    if (dataQA->GetTimePosition())
      prep.AddComponent(new AliTPCCalPad(*(dataQA->GetTimePosition())));
  }
  
  //
  TString file(filename);
  if (file.IsNull()) file=Form("guiTreeRun_%i.root",fRun);
  prep.DumpToFile(file.Data());
  return kTRUE;
}

Bool_t AliTPCcalibDB::CreateRefFile(Int_t run, const char* filename)
{
  //
  // Create a gui tree for run number 'run'
  //
  
  if (!AliCDBManager::Instance()->GetDefaultStorage()){
    AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
                    MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__);
    return kFALSE;
  }
  TString file(filename);
  if (file.IsNull()) file=Form("RefCalPads_%d.root",run);
  TDirectory *currDir=gDirectory;
  //db instance
  AliTPCcalibDB *db=AliTPCcalibDB::Instance();
  // retrieve cal pad objects
  db->SetRun(run);
  //open file
  TFile f(file.Data(),"recreate");
  //noise and pedestals
  db->GetPedestals()->Write("Pedestals");
  db->GetPadNoise()->Write("PadNoise");
  //pulser data
  db->GetPulserTmean()->Write("PulserTmean");
  db->GetPulserTrms()->Write("PulserTrms");
  db->GetPulserQmean()->Write("PulserQmean");
  //CE data
  db->GetCETmean()->Write("CETmean");
  db->GetCETrms()->Write("CETrms");
  db->GetCEQmean()->Write("CEQmean");
  //Altro data
  db->GetALTROAcqStart() ->Write("ALTROAcqStart");
  db->GetALTROZsThr()    ->Write("ALTROZsThr");
  db->GetALTROFPED()     ->Write("ALTROFPED");
  db->GetALTROAcqStop()  ->Write("ALTROAcqStop");
  db->GetALTROMasked()   ->Write("ALTROMasked");
  //
  f.Close();
  currDir->cd();
  return kTRUE;
}



Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
  //
  // Get time dependent drift velocity correction
  // multiplication factor        vd = vdnom *(1+vdriftcorr)
  // Arguments:
  // mode determines the algorith how to combine the Laser Track, LaserCE and physics tracks
  // timestamp - timestamp
  // run       - run number
  // side      - the drift velocity per side (possible for laser and CE)
  //
  // Notice - Extrapolation outside of calibration range  - using constant function
  //
  Double_t result=0;
  // mode 1  automatic mode - according to the distance to the valid calibration
  //                        -  
  Double_t deltaP=0,  driftP=0,      wP  = 0.;
  Double_t deltaITS=0,driftITS=0,    wITS= 0.;
  Double_t deltaLT=0, driftLT=0,     wLT = 0.;
  Double_t deltaCE=0, driftCE=0,     wCE = 0.;
  driftP  = fDButil->GetVDriftTPC(deltaP,run,timeStamp); 
  driftITS= fDButil->GetVDriftTPCITS(deltaITS,run,timeStamp);
  driftCE = fDButil->GetVDriftTPCCE(deltaCE, run,timeStamp,36000,2);
  driftLT = fDButil->GetVDriftTPCLaserTracks(deltaLT,run,timeStamp,36000,2);
  deltaITS = TMath::Abs(deltaITS);
  deltaP   = TMath::Abs(deltaP);
  deltaLT  = TMath::Abs(deltaLT);
  deltaCE  = TMath::Abs(deltaCE);
  if (mode==1) {
    const Double_t kEpsilon=0.00000000001;
    const Double_t kdeltaT=360.; // 10 minutes
    if(TMath::Abs(deltaITS) < 12*kdeltaT) {
      result = driftITS;
    } else {
    wITS  = 64.*kdeltaT/(deltaITS +kdeltaT);
    wLT   = 16.*kdeltaT/(deltaLT  +kdeltaT);
    wP    = 0. *kdeltaT/(deltaP   +kdeltaT);
    wCE   = 1. *kdeltaT/(deltaCE  +kdeltaT);
    //
    //
    if (TMath::Abs(driftP)<kEpsilon)  wP=0;  // invalid calibration
    if (TMath::Abs(driftITS)<kEpsilon)wITS=0;  // invalid calibration
    if (TMath::Abs(driftLT)<kEpsilon) wLT=0;  // invalid calibration
    if (TMath::Abs(driftCE)<kEpsilon) wCE=0;  // invalid calibration
    if (wP+wITS+wLT+wCE<kEpsilon) return 0;
    result = (driftP*wP+driftITS*wITS+driftLT*wLT+driftCE*wCE)/(wP+wITS+wLT+wCE);
   }
   

  }

  return result;
}

Double_t AliTPCcalibDB::GetTime0CorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
  //
  // Get time dependent time 0 (trigger delay in cm) correction
  // additive correction        time0 = time0+ GetTime0CorrectionTime
  // Value etracted combining the vdrift correction using laser tracks and CE and the physics track matchin
  // Arguments:
  // mode determines the algorith how to combine the Laser Track and physics tracks
  // timestamp - timestamp
  // run       - run number
  // side      - the drift velocity per side (possible for laser and CE)
  //
  // Notice - Extrapolation outside of calibration range  - using constant function
  //
  Double_t result=0;
  if (mode==2) {
    // TPC-TPC mode
    result=fDButil->GetTriggerOffsetTPC(run,timeStamp);    
    result  *=fParam->GetZLength();
  }
  if (mode==1){
    // TPC-ITS mode
    Double_t dist=0;
    result= -fDButil->GetTime0TPCITS(dist, run, timeStamp)*fParam->GetDriftV()/1000000.;
  }
  return result;

}




Double_t AliTPCcalibDB::GetVDriftCorrectionGy(Int_t timeStamp, Int_t run, Int_t side, Int_t /*mode*/){
  //
  // Get global y correction drift velocity correction factor
  // additive factor        vd = vdnom*(1+GetVDriftCorrectionGy *gy)
  // Value etracted combining the vdrift correction using laser tracks and CE or TPC-ITS
  // Arguments:
  // mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
  // timestamp - timestamp
  // run       - run number
  // side      - the drift velocity gy correction per side (CE and Laser tracks)
  //
  // Notice - Extrapolation outside of calibration range  - using constant function
  // 
  if (run<=0 && fTransform) run = fTransform->GetCurrentRunNumber();
  UpdateRunInformations(run,kFALSE);
  TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
  if (!array) return 0;
  Double_t result=0;

  // use TPC-ITS if present
  TGraphErrors *gr= (TGraphErrors*)array->FindObject("ALIGN_ITSB_TPC_VDGY");
  if (!gr) gr = (TGraphErrors*)array->FindObject("ALIGN_TOFB_TPC_VDGY");
  if(gr) { 
    result = AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);

    // transform from [(cm/mus)/ m] to [1/cm]
    result /= (fParam->GetDriftV()/1000000.);
    result /= 100.;

    //printf("result %e \n", result);
    return result; 
  }

  // use laser if ITS-TPC not present
  TGraphErrors *laserA= (TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A");
  TGraphErrors *laserC= (TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C");
  
  if (laserA && laserC){
   result= (laserA->Eval(timeStamp)+laserC->Eval(timeStamp))*0.5;
  }
  if (laserA && side==0){
    result = (laserA->Eval(timeStamp));
  }
  if (laserC &&side==1){
    result = (laserC->Eval(timeStamp));
  }
  //printf("laser result %e \n", -result/250.);

  return -result/250.; //normalized before
}


Double_t AliTPCcalibDB::GetVDriftCorrectionDeltaZ(Int_t /*timeStamp*/, Int_t run, Int_t /*side*/, Int_t /*mode*/){
  //
  // Get deltaZ run/by/run  correction - as fitted together with drift velocity
  // Value extracted  form the TPC-ITS, mean value is used
  
  // Arguments:
  // mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
  // timestamp - not used
  // run       - run number
  // side      - common for boith sides
  //
  if (run<=0 && fTransform) run = fTransform->GetCurrentRunNumber();
  UpdateRunInformations(run,kFALSE);
  TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
  if (!array) return 0;
  Double_t result=0;

  // use TPC-ITS if present
  TGraphErrors *gr= (TGraphErrors*)array->FindObject("ALIGN_ITSB_TPC_DELTAZ");
  if(gr) { 
    result = TMath::Mean(gr->GetN(), gr->GetY());
  }
  return result;
}




AliTPCCalPad* AliTPCcalibDB::MakeDeadMap(Double_t notInMap, const char* nameMappingFile) {
//
//   Read list of active DDLs from OCDB entry
//   Generate and return AliTPCCalPad containing 1 for all pads in active DDLs,
//   0 for all pads in non-active DDLs. 
//   For DDLs with missing status information (no DCS input point to Shuttle),
//     the value of the AliTPCCalPad entry is determined by the parameter
//     notInMap (default value 1)
//
  char chinfo[1000];
   
  TFile *fileMapping = new TFile(nameMappingFile, "read");
  AliTPCmapper *mapping = (AliTPCmapper*) fileMapping->Get("tpcMapping");
  if (!mapping) {
    snprintf(chinfo,1000,"Failed to get mapping object from %s.  ...\n", nameMappingFile);
    AliError (chinfo);
    return 0;
  }
  
  AliTPCCalPad *deadMap = new AliTPCCalPad("deadMap","deadMap");
  if (!deadMap) {
     AliError("Failed to allocate dead map AliTPCCalPad");
     return 0;
  }  
  
  /// get list of active DDLs from OCDB entry
  Int_t idDDL=0;
  if (!fALTROConfigData ) {
     AliError("No ALTRO config OCDB entry available");
     return 0; 
  }
  TMap *activeDDL = (TMap*)fALTROConfigData->FindObject("DDLArray");
  TObjString *ddlArray=0;
  if (activeDDL) {
    ddlArray = (TObjString*)activeDDL->GetValue("DDLArray");
    if (!ddlArray) {
      AliError("Empty list of active DDLs in OCDB entry");
      return 0;
    }
  } else { 
    AliError("List of active DDLs not available in OCDB entry");
    return 0;
  }
  TString arrDDL=ddlArray->GetString();
  Int_t offset = mapping->GetTpcDdlOffset();
  Double_t active;
  for (Int_t i=0; i<mapping->GetNumDdl(); i++) {
    idDDL= i+offset;
    if (idDDL<0) continue;
    Int_t patch = mapping->GetPatchFromEquipmentID(idDDL);   
    if (patch<0) continue;
    Int_t roc=mapping->GetRocFromEquipmentID(idDDL);
    if (roc<0) continue;
    AliTPCCalROC *calRoc=deadMap->GetCalROC(roc);
    if (calRoc) {
     for ( Int_t branch = 0; branch < 2; branch++ ) {
      for ( Int_t fec = 0; fec < mapping->GetNfec(patch, branch); fec++ ) {
        for ( Int_t altro = 0; altro < 8; altro++ ) {
         for ( Int_t channel = 0; channel < 16; channel++ ) {
           Int_t hwadd     = mapping->CodeHWAddress(branch, fec, altro, channel);
           Int_t row       = mapping->GetPadRow(patch, hwadd);        // row in a ROC (IROC or OROC)
//              Int_t globalrow = mapping.GetGlobalPadRow(patch, hwadd);  // row in full sector (IROC plus OROC)
           Int_t pad       = mapping->GetPad(patch, hwadd);
           if (!TString(arrDDL[i]).IsDigit()) {
	      active = notInMap;
           } else { 
              active=TString(arrDDL[i]).Atof();
	   }
           calRoc->SetValue(row,pad,active);
         } // end channel for loop
        } // end altro for loop
      } // end fec for loop
     } // end branch for loop
    } // valid calROC 
   } // end loop on active DDLs
   return deadMap;
}



AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrection(Float_t field) const{
  //
  // GetComposed correction for given field setting
  // If not specific correction for field used return correction for all field
  //        - Complication needed to gaurantee OCDB back compatibility 
  //        - Not neeeded for the new space point correction 
  if (!fComposedCorrectionArray) return 0;
  if (field>0.1 && fComposedCorrectionArray->At(1)) {   
    return (AliTPCCorrection *)fComposedCorrectionArray->At(1);
  }
  if (field<-0.1 &&fComposedCorrectionArray->At(2)) {
    return (AliTPCCorrection *)fComposedCorrectionArray->At(2);
  }
  return (AliTPCCorrection *)fComposedCorrectionArray->At(0);
  
}


AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrectionDelta() const{
  //
  // GetComposedCorrection delta
  // Delta is time dependent - taken form the CalibTime OCDB entry
  //
  if (!fComposedCorrectionArray) return 0;
  if (fRun<0) return 0;
  if (fDriftCorrectionArray.GetValue(Form("%i",fRun))==0) return 0;
  if (fComposedCorrectionArray->GetEntriesFast()<=4) {
    fComposedCorrectionArray->Expand(5);
    TObjArray * timeArray =(TObjArray*)(fDriftCorrectionArray.GetValue(Form("%i",fRun)));
     AliTPCCorrection * correctionTime = (AliTPCCorrection *)timeArray->FindObject("FitCorrectionTime");
     if (correctionTime){
       correctionTime->Init();
       fComposedCorrectionArray->AddAt(correctionTime,4); //add time dependent c
     }
  }
  return (AliTPCCorrection *)fComposedCorrectionArray->At(4);  //
}

Double_t AliTPCcalibDB::GetGainCorrectionHVandPT(Int_t timeStamp, Int_t run, Int_t sector, Int_t deltaCache, Int_t mode){
  //
  // Correction for  changes of gain caused by change of the HV and by relative change of the gas density
  // Function is slow some kind of caching needed
  // Cache implemented using the static TVectorD
  //
  // Input paremeters:
  //  deltaCache - maximal time differnce above which the cache is recaclulated
  //  mode       - mode==0 by default return combined correction 
  //                       actual HV and Pt correction has to be present in the run calibration otherwise it is ignored.
  //                       (retrun value differnt than 1 only in case calibration present in the OCDB entry CalibTimeGain
  //               mode==1 return combined correction ( important for calibration pass)
  //                       (in case thereis  no calibration in  CalibTimeGain, default value from the AliTPCParam (Parameters) is used
  //                       this mode is used in the CPass0
  //               mode==2 return HV correction
  //               mode==3 return P/T correction
  //  Usage in the simulation/reconstruction
  //  MC:     Qcorr  = Qorig*GetGainCorrectionHVandPT   ( in AliTPC.cxx ) 
  //  Rec:    dEdx   = dEdx/GetGainCorrectionHVandPT    ( in aliTPCseed.cxx )
  //
  static Float_t gGainCorrection[72];
  static Float_t gGainCorrectionPT[72];
  static Float_t gGainCorrectionHV[72];
  static Int_t    gTimeStamp=-99999999;
  static Bool_t   hasTimeDependent=kFALSE; 
  if ( TMath::Abs(timeStamp-gTimeStamp)> deltaCache){    
    //
    TGraphErrors * graphGHV = 0;
    TGraphErrors * graphGPT = 0;
    TObjArray *timeGainSplines = GetTimeGainSplinesRun(run);
    if (timeGainSplines){
      graphGHV  = (TGraphErrors*) timeGainSplines->FindObject("GainSlopesHV");
      graphGPT  = (TGraphErrors*) timeGainSplines->FindObject("GainSlopesPT");
      if (graphGHV) hasTimeDependent=kTRUE;
    }
    if (!graphGHV) graphGHV = fParam->GetGainSlopesHV();
    if (!graphGPT) graphGPT = fParam->GetGainSlopesPT();
    //
    for (Int_t isec=0; isec<72; isec++){
      Double_t deltaHV= GetChamberHighVoltage(run,isec, timeStamp) - fParam->GetNominalVoltage(isec);
      Double_t deltaGHV=0;
      Double_t deltaGPT=0;
      if (graphGHV) deltaGHV = graphGHV->GetY()[isec]*deltaHV;
      if (graphGPT) deltaGPT = graphGPT->GetY()[isec]*GetPTRelative(timeStamp,run,0);
      gGainCorrection[isec]=(1.+deltaGHV)*(1.+deltaGPT);
      gGainCorrectionPT[isec]=1+deltaGPT;
      gGainCorrectionHV[isec]=1+deltaGHV;
    }    
    gTimeStamp=timeStamp;
  }
  if (mode==0){
    if (hasTimeDependent) return gGainCorrection[sector];
    if (!hasTimeDependent) return 1;
  }
  if (mode==1) return gGainCorrection[sector];
  if (mode==2) return gGainCorrectionPT[sector];
  if (mode==3) return gGainCorrectionHV[sector];
  return 1;
}
 AliTPCcalibDB.cxx:1
 AliTPCcalibDB.cxx:2
 AliTPCcalibDB.cxx:3
 AliTPCcalibDB.cxx:4
 AliTPCcalibDB.cxx:5
 AliTPCcalibDB.cxx:6
 AliTPCcalibDB.cxx:7
 AliTPCcalibDB.cxx:8
 AliTPCcalibDB.cxx:9
 AliTPCcalibDB.cxx:10
 AliTPCcalibDB.cxx:11
 AliTPCcalibDB.cxx:12
 AliTPCcalibDB.cxx:13
 AliTPCcalibDB.cxx:14
 AliTPCcalibDB.cxx:15
 AliTPCcalibDB.cxx:16
 AliTPCcalibDB.cxx:17
 AliTPCcalibDB.cxx:18
 AliTPCcalibDB.cxx:19
 AliTPCcalibDB.cxx:20
 AliTPCcalibDB.cxx:21
 AliTPCcalibDB.cxx:22
 AliTPCcalibDB.cxx:23
 AliTPCcalibDB.cxx:24
 AliTPCcalibDB.cxx:25
 AliTPCcalibDB.cxx:26
 AliTPCcalibDB.cxx:27
 AliTPCcalibDB.cxx:28
 AliTPCcalibDB.cxx:29
 AliTPCcalibDB.cxx:30
 AliTPCcalibDB.cxx:31
 AliTPCcalibDB.cxx:32
 AliTPCcalibDB.cxx:33
 AliTPCcalibDB.cxx:34
 AliTPCcalibDB.cxx:35
 AliTPCcalibDB.cxx:36
 AliTPCcalibDB.cxx:37
 AliTPCcalibDB.cxx:38
 AliTPCcalibDB.cxx:39
 AliTPCcalibDB.cxx:40
 AliTPCcalibDB.cxx:41
 AliTPCcalibDB.cxx:42
 AliTPCcalibDB.cxx:43
 AliTPCcalibDB.cxx:44
 AliTPCcalibDB.cxx:45
 AliTPCcalibDB.cxx:46
 AliTPCcalibDB.cxx:47
 AliTPCcalibDB.cxx:48
 AliTPCcalibDB.cxx:49
 AliTPCcalibDB.cxx:50
 AliTPCcalibDB.cxx:51
 AliTPCcalibDB.cxx:52
 AliTPCcalibDB.cxx:53
 AliTPCcalibDB.cxx:54
 AliTPCcalibDB.cxx:55
 AliTPCcalibDB.cxx:56
 AliTPCcalibDB.cxx:57
 AliTPCcalibDB.cxx:58
 AliTPCcalibDB.cxx:59
 AliTPCcalibDB.cxx:60
 AliTPCcalibDB.cxx:61
 AliTPCcalibDB.cxx:62
 AliTPCcalibDB.cxx:63
 AliTPCcalibDB.cxx:64
 AliTPCcalibDB.cxx:65
 AliTPCcalibDB.cxx:66
 AliTPCcalibDB.cxx:67
 AliTPCcalibDB.cxx:68
 AliTPCcalibDB.cxx:69
 AliTPCcalibDB.cxx:70
 AliTPCcalibDB.cxx:71
 AliTPCcalibDB.cxx:72
 AliTPCcalibDB.cxx:73
 AliTPCcalibDB.cxx:74
 AliTPCcalibDB.cxx:75
 AliTPCcalibDB.cxx:76
 AliTPCcalibDB.cxx:77
 AliTPCcalibDB.cxx:78
 AliTPCcalibDB.cxx:79
 AliTPCcalibDB.cxx:80
 AliTPCcalibDB.cxx:81
 AliTPCcalibDB.cxx:82
 AliTPCcalibDB.cxx:83
 AliTPCcalibDB.cxx:84
 AliTPCcalibDB.cxx:85
 AliTPCcalibDB.cxx:86
 AliTPCcalibDB.cxx:87
 AliTPCcalibDB.cxx:88
 AliTPCcalibDB.cxx:89
 AliTPCcalibDB.cxx:90
 AliTPCcalibDB.cxx:91
 AliTPCcalibDB.cxx:92
 AliTPCcalibDB.cxx:93
 AliTPCcalibDB.cxx:94
 AliTPCcalibDB.cxx:95
 AliTPCcalibDB.cxx:96
 AliTPCcalibDB.cxx:97
 AliTPCcalibDB.cxx:98
 AliTPCcalibDB.cxx:99
 AliTPCcalibDB.cxx:100
 AliTPCcalibDB.cxx:101
 AliTPCcalibDB.cxx:102
 AliTPCcalibDB.cxx:103
 AliTPCcalibDB.cxx:104
 AliTPCcalibDB.cxx:105
 AliTPCcalibDB.cxx:106
 AliTPCcalibDB.cxx:107
 AliTPCcalibDB.cxx:108
 AliTPCcalibDB.cxx:109
 AliTPCcalibDB.cxx:110
 AliTPCcalibDB.cxx:111
 AliTPCcalibDB.cxx:112
 AliTPCcalibDB.cxx:113
 AliTPCcalibDB.cxx:114
 AliTPCcalibDB.cxx:115
 AliTPCcalibDB.cxx:116
 AliTPCcalibDB.cxx:117
 AliTPCcalibDB.cxx:118
 AliTPCcalibDB.cxx:119
 AliTPCcalibDB.cxx:120
 AliTPCcalibDB.cxx:121
 AliTPCcalibDB.cxx:122
 AliTPCcalibDB.cxx:123
 AliTPCcalibDB.cxx:124
 AliTPCcalibDB.cxx:125
 AliTPCcalibDB.cxx:126
 AliTPCcalibDB.cxx:127
 AliTPCcalibDB.cxx:128
 AliTPCcalibDB.cxx:129
 AliTPCcalibDB.cxx:130
 AliTPCcalibDB.cxx:131
 AliTPCcalibDB.cxx:132
 AliTPCcalibDB.cxx:133
 AliTPCcalibDB.cxx:134
 AliTPCcalibDB.cxx:135
 AliTPCcalibDB.cxx:136
 AliTPCcalibDB.cxx:137
 AliTPCcalibDB.cxx:138
 AliTPCcalibDB.cxx:139
 AliTPCcalibDB.cxx:140
 AliTPCcalibDB.cxx:141
 AliTPCcalibDB.cxx:142
 AliTPCcalibDB.cxx:143
 AliTPCcalibDB.cxx:144
 AliTPCcalibDB.cxx:145
 AliTPCcalibDB.cxx:146
 AliTPCcalibDB.cxx:147
 AliTPCcalibDB.cxx:148
 AliTPCcalibDB.cxx:149
 AliTPCcalibDB.cxx:150
 AliTPCcalibDB.cxx:151
 AliTPCcalibDB.cxx:152
 AliTPCcalibDB.cxx:153
 AliTPCcalibDB.cxx:154
 AliTPCcalibDB.cxx:155
 AliTPCcalibDB.cxx:156
 AliTPCcalibDB.cxx:157
 AliTPCcalibDB.cxx:158
 AliTPCcalibDB.cxx:159
 AliTPCcalibDB.cxx:160
 AliTPCcalibDB.cxx:161
 AliTPCcalibDB.cxx:162
 AliTPCcalibDB.cxx:163
 AliTPCcalibDB.cxx:164
 AliTPCcalibDB.cxx:165
 AliTPCcalibDB.cxx:166
 AliTPCcalibDB.cxx:167
 AliTPCcalibDB.cxx:168
 AliTPCcalibDB.cxx:169
 AliTPCcalibDB.cxx:170
 AliTPCcalibDB.cxx:171
 AliTPCcalibDB.cxx:172
 AliTPCcalibDB.cxx:173
 AliTPCcalibDB.cxx:174
 AliTPCcalibDB.cxx:175
 AliTPCcalibDB.cxx:176
 AliTPCcalibDB.cxx:177
 AliTPCcalibDB.cxx:178
 AliTPCcalibDB.cxx:179
 AliTPCcalibDB.cxx:180
 AliTPCcalibDB.cxx:181
 AliTPCcalibDB.cxx:182
 AliTPCcalibDB.cxx:183
 AliTPCcalibDB.cxx:184
 AliTPCcalibDB.cxx:185
 AliTPCcalibDB.cxx:186
 AliTPCcalibDB.cxx:187
 AliTPCcalibDB.cxx:188
 AliTPCcalibDB.cxx:189
 AliTPCcalibDB.cxx:190
 AliTPCcalibDB.cxx:191
 AliTPCcalibDB.cxx:192
 AliTPCcalibDB.cxx:193
 AliTPCcalibDB.cxx:194
 AliTPCcalibDB.cxx:195
 AliTPCcalibDB.cxx:196
 AliTPCcalibDB.cxx:197
 AliTPCcalibDB.cxx:198
 AliTPCcalibDB.cxx:199
 AliTPCcalibDB.cxx:200
 AliTPCcalibDB.cxx:201
 AliTPCcalibDB.cxx:202
 AliTPCcalibDB.cxx:203
 AliTPCcalibDB.cxx:204
 AliTPCcalibDB.cxx:205
 AliTPCcalibDB.cxx:206
 AliTPCcalibDB.cxx:207
 AliTPCcalibDB.cxx:208
 AliTPCcalibDB.cxx:209
 AliTPCcalibDB.cxx:210
 AliTPCcalibDB.cxx:211
 AliTPCcalibDB.cxx:212
 AliTPCcalibDB.cxx:213
 AliTPCcalibDB.cxx:214
 AliTPCcalibDB.cxx:215
 AliTPCcalibDB.cxx:216
 AliTPCcalibDB.cxx:217
 AliTPCcalibDB.cxx:218
 AliTPCcalibDB.cxx:219
 AliTPCcalibDB.cxx:220
 AliTPCcalibDB.cxx:221
 AliTPCcalibDB.cxx:222
 AliTPCcalibDB.cxx:223
 AliTPCcalibDB.cxx:224
 AliTPCcalibDB.cxx:225
 AliTPCcalibDB.cxx:226
 AliTPCcalibDB.cxx:227
 AliTPCcalibDB.cxx:228
 AliTPCcalibDB.cxx:229
 AliTPCcalibDB.cxx:230
 AliTPCcalibDB.cxx:231
 AliTPCcalibDB.cxx:232
 AliTPCcalibDB.cxx:233
 AliTPCcalibDB.cxx:234
 AliTPCcalibDB.cxx:235
 AliTPCcalibDB.cxx:236
 AliTPCcalibDB.cxx:237
 AliTPCcalibDB.cxx:238
 AliTPCcalibDB.cxx:239
 AliTPCcalibDB.cxx:240
 AliTPCcalibDB.cxx:241
 AliTPCcalibDB.cxx:242
 AliTPCcalibDB.cxx:243
 AliTPCcalibDB.cxx:244
 AliTPCcalibDB.cxx:245
 AliTPCcalibDB.cxx:246
 AliTPCcalibDB.cxx:247
 AliTPCcalibDB.cxx:248
 AliTPCcalibDB.cxx:249
 AliTPCcalibDB.cxx:250
 AliTPCcalibDB.cxx:251
 AliTPCcalibDB.cxx:252
 AliTPCcalibDB.cxx:253
 AliTPCcalibDB.cxx:254
 AliTPCcalibDB.cxx:255
 AliTPCcalibDB.cxx:256
 AliTPCcalibDB.cxx:257
 AliTPCcalibDB.cxx:258
 AliTPCcalibDB.cxx:259
 AliTPCcalibDB.cxx:260
 AliTPCcalibDB.cxx:261
 AliTPCcalibDB.cxx:262
 AliTPCcalibDB.cxx:263
 AliTPCcalibDB.cxx:264
 AliTPCcalibDB.cxx:265
 AliTPCcalibDB.cxx:266
 AliTPCcalibDB.cxx:267
 AliTPCcalibDB.cxx:268
 AliTPCcalibDB.cxx:269
 AliTPCcalibDB.cxx:270
 AliTPCcalibDB.cxx:271
 AliTPCcalibDB.cxx:272
 AliTPCcalibDB.cxx:273
 AliTPCcalibDB.cxx:274
 AliTPCcalibDB.cxx:275
 AliTPCcalibDB.cxx:276
 AliTPCcalibDB.cxx:277
 AliTPCcalibDB.cxx:278
 AliTPCcalibDB.cxx:279
 AliTPCcalibDB.cxx:280
 AliTPCcalibDB.cxx:281
 AliTPCcalibDB.cxx:282
 AliTPCcalibDB.cxx:283
 AliTPCcalibDB.cxx:284
 AliTPCcalibDB.cxx:285
 AliTPCcalibDB.cxx:286
 AliTPCcalibDB.cxx:287
 AliTPCcalibDB.cxx:288
 AliTPCcalibDB.cxx:289
 AliTPCcalibDB.cxx:290
 AliTPCcalibDB.cxx:291
 AliTPCcalibDB.cxx:292
 AliTPCcalibDB.cxx:293
 AliTPCcalibDB.cxx:294
 AliTPCcalibDB.cxx:295
 AliTPCcalibDB.cxx:296
 AliTPCcalibDB.cxx:297
 AliTPCcalibDB.cxx:298
 AliTPCcalibDB.cxx:299
 AliTPCcalibDB.cxx:300
 AliTPCcalibDB.cxx:301
 AliTPCcalibDB.cxx:302
 AliTPCcalibDB.cxx:303
 AliTPCcalibDB.cxx:304
 AliTPCcalibDB.cxx:305
 AliTPCcalibDB.cxx:306
 AliTPCcalibDB.cxx:307
 AliTPCcalibDB.cxx:308
 AliTPCcalibDB.cxx:309
 AliTPCcalibDB.cxx:310
 AliTPCcalibDB.cxx:311
 AliTPCcalibDB.cxx:312
 AliTPCcalibDB.cxx:313
 AliTPCcalibDB.cxx:314
 AliTPCcalibDB.cxx:315
 AliTPCcalibDB.cxx:316
 AliTPCcalibDB.cxx:317
 AliTPCcalibDB.cxx:318
 AliTPCcalibDB.cxx:319
 AliTPCcalibDB.cxx:320
 AliTPCcalibDB.cxx:321
 AliTPCcalibDB.cxx:322
 AliTPCcalibDB.cxx:323
 AliTPCcalibDB.cxx:324
 AliTPCcalibDB.cxx:325
 AliTPCcalibDB.cxx:326
 AliTPCcalibDB.cxx:327
 AliTPCcalibDB.cxx:328
 AliTPCcalibDB.cxx:329
 AliTPCcalibDB.cxx:330
 AliTPCcalibDB.cxx:331
 AliTPCcalibDB.cxx:332
 AliTPCcalibDB.cxx:333
 AliTPCcalibDB.cxx:334
 AliTPCcalibDB.cxx:335
 AliTPCcalibDB.cxx:336
 AliTPCcalibDB.cxx:337
 AliTPCcalibDB.cxx:338
 AliTPCcalibDB.cxx:339
 AliTPCcalibDB.cxx:340
 AliTPCcalibDB.cxx:341
 AliTPCcalibDB.cxx:342
 AliTPCcalibDB.cxx:343
 AliTPCcalibDB.cxx:344
 AliTPCcalibDB.cxx:345
 AliTPCcalibDB.cxx:346
 AliTPCcalibDB.cxx:347
 AliTPCcalibDB.cxx:348
 AliTPCcalibDB.cxx:349
 AliTPCcalibDB.cxx:350
 AliTPCcalibDB.cxx:351
 AliTPCcalibDB.cxx:352
 AliTPCcalibDB.cxx:353
 AliTPCcalibDB.cxx:354
 AliTPCcalibDB.cxx:355
 AliTPCcalibDB.cxx:356
 AliTPCcalibDB.cxx:357
 AliTPCcalibDB.cxx:358
 AliTPCcalibDB.cxx:359
 AliTPCcalibDB.cxx:360
 AliTPCcalibDB.cxx:361
 AliTPCcalibDB.cxx:362
 AliTPCcalibDB.cxx:363
 AliTPCcalibDB.cxx:364
 AliTPCcalibDB.cxx:365
 AliTPCcalibDB.cxx:366
 AliTPCcalibDB.cxx:367
 AliTPCcalibDB.cxx:368
 AliTPCcalibDB.cxx:369
 AliTPCcalibDB.cxx:370
 AliTPCcalibDB.cxx:371
 AliTPCcalibDB.cxx:372
 AliTPCcalibDB.cxx:373
 AliTPCcalibDB.cxx:374
 AliTPCcalibDB.cxx:375
 AliTPCcalibDB.cxx:376
 AliTPCcalibDB.cxx:377
 AliTPCcalibDB.cxx:378
 AliTPCcalibDB.cxx:379
 AliTPCcalibDB.cxx:380
 AliTPCcalibDB.cxx:381
 AliTPCcalibDB.cxx:382
 AliTPCcalibDB.cxx:383
 AliTPCcalibDB.cxx:384
 AliTPCcalibDB.cxx:385
 AliTPCcalibDB.cxx:386
 AliTPCcalibDB.cxx:387
 AliTPCcalibDB.cxx:388
 AliTPCcalibDB.cxx:389
 AliTPCcalibDB.cxx:390
 AliTPCcalibDB.cxx:391
 AliTPCcalibDB.cxx:392
 AliTPCcalibDB.cxx:393
 AliTPCcalibDB.cxx:394
 AliTPCcalibDB.cxx:395
 AliTPCcalibDB.cxx:396
 AliTPCcalibDB.cxx:397
 AliTPCcalibDB.cxx:398
 AliTPCcalibDB.cxx:399
 AliTPCcalibDB.cxx:400
 AliTPCcalibDB.cxx:401
 AliTPCcalibDB.cxx:402
 AliTPCcalibDB.cxx:403
 AliTPCcalibDB.cxx:404
 AliTPCcalibDB.cxx:405
 AliTPCcalibDB.cxx:406
 AliTPCcalibDB.cxx:407
 AliTPCcalibDB.cxx:408
 AliTPCcalibDB.cxx:409
 AliTPCcalibDB.cxx:410
 AliTPCcalibDB.cxx:411
 AliTPCcalibDB.cxx:412
 AliTPCcalibDB.cxx:413
 AliTPCcalibDB.cxx:414
 AliTPCcalibDB.cxx:415
 AliTPCcalibDB.cxx:416
 AliTPCcalibDB.cxx:417
 AliTPCcalibDB.cxx:418
 AliTPCcalibDB.cxx:419
 AliTPCcalibDB.cxx:420
 AliTPCcalibDB.cxx:421
 AliTPCcalibDB.cxx:422
 AliTPCcalibDB.cxx:423
 AliTPCcalibDB.cxx:424
 AliTPCcalibDB.cxx:425
 AliTPCcalibDB.cxx:426
 AliTPCcalibDB.cxx:427
 AliTPCcalibDB.cxx:428
 AliTPCcalibDB.cxx:429
 AliTPCcalibDB.cxx:430
 AliTPCcalibDB.cxx:431
 AliTPCcalibDB.cxx:432
 AliTPCcalibDB.cxx:433
 AliTPCcalibDB.cxx:434
 AliTPCcalibDB.cxx:435
 AliTPCcalibDB.cxx:436
 AliTPCcalibDB.cxx:437
 AliTPCcalibDB.cxx:438
 AliTPCcalibDB.cxx:439
 AliTPCcalibDB.cxx:440
 AliTPCcalibDB.cxx:441
 AliTPCcalibDB.cxx:442
 AliTPCcalibDB.cxx:443
 AliTPCcalibDB.cxx:444
 AliTPCcalibDB.cxx:445
 AliTPCcalibDB.cxx:446
 AliTPCcalibDB.cxx:447
 AliTPCcalibDB.cxx:448
 AliTPCcalibDB.cxx:449
 AliTPCcalibDB.cxx:450
 AliTPCcalibDB.cxx:451
 AliTPCcalibDB.cxx:452
 AliTPCcalibDB.cxx:453
 AliTPCcalibDB.cxx:454
 AliTPCcalibDB.cxx:455
 AliTPCcalibDB.cxx:456
 AliTPCcalibDB.cxx:457
 AliTPCcalibDB.cxx:458
 AliTPCcalibDB.cxx:459
 AliTPCcalibDB.cxx:460
 AliTPCcalibDB.cxx:461
 AliTPCcalibDB.cxx:462
 AliTPCcalibDB.cxx:463
 AliTPCcalibDB.cxx:464
 AliTPCcalibDB.cxx:465
 AliTPCcalibDB.cxx:466
 AliTPCcalibDB.cxx:467
 AliTPCcalibDB.cxx:468
 AliTPCcalibDB.cxx:469
 AliTPCcalibDB.cxx:470
 AliTPCcalibDB.cxx:471
 AliTPCcalibDB.cxx:472
 AliTPCcalibDB.cxx:473
 AliTPCcalibDB.cxx:474
 AliTPCcalibDB.cxx:475
 AliTPCcalibDB.cxx:476
 AliTPCcalibDB.cxx:477
 AliTPCcalibDB.cxx:478
 AliTPCcalibDB.cxx:479
 AliTPCcalibDB.cxx:480
 AliTPCcalibDB.cxx:481
 AliTPCcalibDB.cxx:482
 AliTPCcalibDB.cxx:483
 AliTPCcalibDB.cxx:484
 AliTPCcalibDB.cxx:485
 AliTPCcalibDB.cxx:486
 AliTPCcalibDB.cxx:487
 AliTPCcalibDB.cxx:488
 AliTPCcalibDB.cxx:489
 AliTPCcalibDB.cxx:490
 AliTPCcalibDB.cxx:491
 AliTPCcalibDB.cxx:492
 AliTPCcalibDB.cxx:493
 AliTPCcalibDB.cxx:494
 AliTPCcalibDB.cxx:495
 AliTPCcalibDB.cxx:496
 AliTPCcalibDB.cxx:497
 AliTPCcalibDB.cxx:498
 AliTPCcalibDB.cxx:499
 AliTPCcalibDB.cxx:500
 AliTPCcalibDB.cxx:501
 AliTPCcalibDB.cxx:502
 AliTPCcalibDB.cxx:503
 AliTPCcalibDB.cxx:504
 AliTPCcalibDB.cxx:505
 AliTPCcalibDB.cxx:506
 AliTPCcalibDB.cxx:507
 AliTPCcalibDB.cxx:508
 AliTPCcalibDB.cxx:509
 AliTPCcalibDB.cxx:510
 AliTPCcalibDB.cxx:511
 AliTPCcalibDB.cxx:512
 AliTPCcalibDB.cxx:513
 AliTPCcalibDB.cxx:514
 AliTPCcalibDB.cxx:515
 AliTPCcalibDB.cxx:516
 AliTPCcalibDB.cxx:517
 AliTPCcalibDB.cxx:518
 AliTPCcalibDB.cxx:519
 AliTPCcalibDB.cxx:520
 AliTPCcalibDB.cxx:521
 AliTPCcalibDB.cxx:522
 AliTPCcalibDB.cxx:523
 AliTPCcalibDB.cxx:524
 AliTPCcalibDB.cxx:525
 AliTPCcalibDB.cxx:526
 AliTPCcalibDB.cxx:527
 AliTPCcalibDB.cxx:528
 AliTPCcalibDB.cxx:529
 AliTPCcalibDB.cxx:530
 AliTPCcalibDB.cxx:531
 AliTPCcalibDB.cxx:532
 AliTPCcalibDB.cxx:533
 AliTPCcalibDB.cxx:534
 AliTPCcalibDB.cxx:535
 AliTPCcalibDB.cxx:536
 AliTPCcalibDB.cxx:537
 AliTPCcalibDB.cxx:538
 AliTPCcalibDB.cxx:539
 AliTPCcalibDB.cxx:540
 AliTPCcalibDB.cxx:541
 AliTPCcalibDB.cxx:542
 AliTPCcalibDB.cxx:543
 AliTPCcalibDB.cxx:544
 AliTPCcalibDB.cxx:545
 AliTPCcalibDB.cxx:546
 AliTPCcalibDB.cxx:547
 AliTPCcalibDB.cxx:548
 AliTPCcalibDB.cxx:549
 AliTPCcalibDB.cxx:550
 AliTPCcalibDB.cxx:551
 AliTPCcalibDB.cxx:552
 AliTPCcalibDB.cxx:553
 AliTPCcalibDB.cxx:554
 AliTPCcalibDB.cxx:555
 AliTPCcalibDB.cxx:556
 AliTPCcalibDB.cxx:557
 AliTPCcalibDB.cxx:558
 AliTPCcalibDB.cxx:559
 AliTPCcalibDB.cxx:560
 AliTPCcalibDB.cxx:561
 AliTPCcalibDB.cxx:562
 AliTPCcalibDB.cxx:563
 AliTPCcalibDB.cxx:564
 AliTPCcalibDB.cxx:565
 AliTPCcalibDB.cxx:566
 AliTPCcalibDB.cxx:567
 AliTPCcalibDB.cxx:568
 AliTPCcalibDB.cxx:569
 AliTPCcalibDB.cxx:570
 AliTPCcalibDB.cxx:571
 AliTPCcalibDB.cxx:572
 AliTPCcalibDB.cxx:573
 AliTPCcalibDB.cxx:574
 AliTPCcalibDB.cxx:575
 AliTPCcalibDB.cxx:576
 AliTPCcalibDB.cxx:577
 AliTPCcalibDB.cxx:578
 AliTPCcalibDB.cxx:579
 AliTPCcalibDB.cxx:580
 AliTPCcalibDB.cxx:581
 AliTPCcalibDB.cxx:582
 AliTPCcalibDB.cxx:583
 AliTPCcalibDB.cxx:584
 AliTPCcalibDB.cxx:585
 AliTPCcalibDB.cxx:586
 AliTPCcalibDB.cxx:587
 AliTPCcalibDB.cxx:588
 AliTPCcalibDB.cxx:589
 AliTPCcalibDB.cxx:590
 AliTPCcalibDB.cxx:591
 AliTPCcalibDB.cxx:592
 AliTPCcalibDB.cxx:593
 AliTPCcalibDB.cxx:594
 AliTPCcalibDB.cxx:595
 AliTPCcalibDB.cxx:596
 AliTPCcalibDB.cxx:597
 AliTPCcalibDB.cxx:598
 AliTPCcalibDB.cxx:599
 AliTPCcalibDB.cxx:600
 AliTPCcalibDB.cxx:601
 AliTPCcalibDB.cxx:602
 AliTPCcalibDB.cxx:603
 AliTPCcalibDB.cxx:604
 AliTPCcalibDB.cxx:605
 AliTPCcalibDB.cxx:606
 AliTPCcalibDB.cxx:607
 AliTPCcalibDB.cxx:608
 AliTPCcalibDB.cxx:609
 AliTPCcalibDB.cxx:610
 AliTPCcalibDB.cxx:611
 AliTPCcalibDB.cxx:612
 AliTPCcalibDB.cxx:613
 AliTPCcalibDB.cxx:614
 AliTPCcalibDB.cxx:615
 AliTPCcalibDB.cxx:616
 AliTPCcalibDB.cxx:617
 AliTPCcalibDB.cxx:618
 AliTPCcalibDB.cxx:619
 AliTPCcalibDB.cxx:620
 AliTPCcalibDB.cxx:621
 AliTPCcalibDB.cxx:622
 AliTPCcalibDB.cxx:623
 AliTPCcalibDB.cxx:624
 AliTPCcalibDB.cxx:625
 AliTPCcalibDB.cxx:626
 AliTPCcalibDB.cxx:627
 AliTPCcalibDB.cxx:628
 AliTPCcalibDB.cxx:629
 AliTPCcalibDB.cxx:630
 AliTPCcalibDB.cxx:631
 AliTPCcalibDB.cxx:632
 AliTPCcalibDB.cxx:633
 AliTPCcalibDB.cxx:634
 AliTPCcalibDB.cxx:635
 AliTPCcalibDB.cxx:636
 AliTPCcalibDB.cxx:637
 AliTPCcalibDB.cxx:638
 AliTPCcalibDB.cxx:639
 AliTPCcalibDB.cxx:640
 AliTPCcalibDB.cxx:641
 AliTPCcalibDB.cxx:642
 AliTPCcalibDB.cxx:643
 AliTPCcalibDB.cxx:644
 AliTPCcalibDB.cxx:645
 AliTPCcalibDB.cxx:646
 AliTPCcalibDB.cxx:647
 AliTPCcalibDB.cxx:648
 AliTPCcalibDB.cxx:649
 AliTPCcalibDB.cxx:650
 AliTPCcalibDB.cxx:651
 AliTPCcalibDB.cxx:652
 AliTPCcalibDB.cxx:653
 AliTPCcalibDB.cxx:654
 AliTPCcalibDB.cxx:655
 AliTPCcalibDB.cxx:656
 AliTPCcalibDB.cxx:657
 AliTPCcalibDB.cxx:658
 AliTPCcalibDB.cxx:659
 AliTPCcalibDB.cxx:660
 AliTPCcalibDB.cxx:661
 AliTPCcalibDB.cxx:662
 AliTPCcalibDB.cxx:663
 AliTPCcalibDB.cxx:664
 AliTPCcalibDB.cxx:665
 AliTPCcalibDB.cxx:666
 AliTPCcalibDB.cxx:667
 AliTPCcalibDB.cxx:668
 AliTPCcalibDB.cxx:669
 AliTPCcalibDB.cxx:670
 AliTPCcalibDB.cxx:671
 AliTPCcalibDB.cxx:672
 AliTPCcalibDB.cxx:673
 AliTPCcalibDB.cxx:674
 AliTPCcalibDB.cxx:675
 AliTPCcalibDB.cxx:676
 AliTPCcalibDB.cxx:677
 AliTPCcalibDB.cxx:678
 AliTPCcalibDB.cxx:679
 AliTPCcalibDB.cxx:680
 AliTPCcalibDB.cxx:681
 AliTPCcalibDB.cxx:682
 AliTPCcalibDB.cxx:683
 AliTPCcalibDB.cxx:684
 AliTPCcalibDB.cxx:685
 AliTPCcalibDB.cxx:686
 AliTPCcalibDB.cxx:687
 AliTPCcalibDB.cxx:688
 AliTPCcalibDB.cxx:689
 AliTPCcalibDB.cxx:690
 AliTPCcalibDB.cxx:691
 AliTPCcalibDB.cxx:692
 AliTPCcalibDB.cxx:693
 AliTPCcalibDB.cxx:694
 AliTPCcalibDB.cxx:695
 AliTPCcalibDB.cxx:696
 AliTPCcalibDB.cxx:697
 AliTPCcalibDB.cxx:698
 AliTPCcalibDB.cxx:699
 AliTPCcalibDB.cxx:700
 AliTPCcalibDB.cxx:701
 AliTPCcalibDB.cxx:702
 AliTPCcalibDB.cxx:703
 AliTPCcalibDB.cxx:704
 AliTPCcalibDB.cxx:705
 AliTPCcalibDB.cxx:706
 AliTPCcalibDB.cxx:707
 AliTPCcalibDB.cxx:708
 AliTPCcalibDB.cxx:709
 AliTPCcalibDB.cxx:710
 AliTPCcalibDB.cxx:711
 AliTPCcalibDB.cxx:712
 AliTPCcalibDB.cxx:713
 AliTPCcalibDB.cxx:714
 AliTPCcalibDB.cxx:715
 AliTPCcalibDB.cxx:716
 AliTPCcalibDB.cxx:717
 AliTPCcalibDB.cxx:718
 AliTPCcalibDB.cxx:719
 AliTPCcalibDB.cxx:720
 AliTPCcalibDB.cxx:721
 AliTPCcalibDB.cxx:722
 AliTPCcalibDB.cxx:723
 AliTPCcalibDB.cxx:724
 AliTPCcalibDB.cxx:725
 AliTPCcalibDB.cxx:726
 AliTPCcalibDB.cxx:727
 AliTPCcalibDB.cxx:728
 AliTPCcalibDB.cxx:729
 AliTPCcalibDB.cxx:730
 AliTPCcalibDB.cxx:731
 AliTPCcalibDB.cxx:732
 AliTPCcalibDB.cxx:733
 AliTPCcalibDB.cxx:734
 AliTPCcalibDB.cxx:735
 AliTPCcalibDB.cxx:736
 AliTPCcalibDB.cxx:737
 AliTPCcalibDB.cxx:738
 AliTPCcalibDB.cxx:739
 AliTPCcalibDB.cxx:740
 AliTPCcalibDB.cxx:741
 AliTPCcalibDB.cxx:742
 AliTPCcalibDB.cxx:743
 AliTPCcalibDB.cxx:744
 AliTPCcalibDB.cxx:745
 AliTPCcalibDB.cxx:746
 AliTPCcalibDB.cxx:747
 AliTPCcalibDB.cxx:748
 AliTPCcalibDB.cxx:749
 AliTPCcalibDB.cxx:750
 AliTPCcalibDB.cxx:751
 AliTPCcalibDB.cxx:752
 AliTPCcalibDB.cxx:753
 AliTPCcalibDB.cxx:754
 AliTPCcalibDB.cxx:755
 AliTPCcalibDB.cxx:756
 AliTPCcalibDB.cxx:757
 AliTPCcalibDB.cxx:758
 AliTPCcalibDB.cxx:759
 AliTPCcalibDB.cxx:760
 AliTPCcalibDB.cxx:761
 AliTPCcalibDB.cxx:762
 AliTPCcalibDB.cxx:763
 AliTPCcalibDB.cxx:764
 AliTPCcalibDB.cxx:765
 AliTPCcalibDB.cxx:766
 AliTPCcalibDB.cxx:767
 AliTPCcalibDB.cxx:768
 AliTPCcalibDB.cxx:769
 AliTPCcalibDB.cxx:770
 AliTPCcalibDB.cxx:771
 AliTPCcalibDB.cxx:772
 AliTPCcalibDB.cxx:773
 AliTPCcalibDB.cxx:774
 AliTPCcalibDB.cxx:775
 AliTPCcalibDB.cxx:776
 AliTPCcalibDB.cxx:777
 AliTPCcalibDB.cxx:778
 AliTPCcalibDB.cxx:779
 AliTPCcalibDB.cxx:780
 AliTPCcalibDB.cxx:781
 AliTPCcalibDB.cxx:782
 AliTPCcalibDB.cxx:783
 AliTPCcalibDB.cxx:784
 AliTPCcalibDB.cxx:785
 AliTPCcalibDB.cxx:786
 AliTPCcalibDB.cxx:787
 AliTPCcalibDB.cxx:788
 AliTPCcalibDB.cxx:789
 AliTPCcalibDB.cxx:790
 AliTPCcalibDB.cxx:791
 AliTPCcalibDB.cxx:792
 AliTPCcalibDB.cxx:793
 AliTPCcalibDB.cxx:794
 AliTPCcalibDB.cxx:795
 AliTPCcalibDB.cxx:796
 AliTPCcalibDB.cxx:797
 AliTPCcalibDB.cxx:798
 AliTPCcalibDB.cxx:799
 AliTPCcalibDB.cxx:800
 AliTPCcalibDB.cxx:801
 AliTPCcalibDB.cxx:802
 AliTPCcalibDB.cxx:803
 AliTPCcalibDB.cxx:804
 AliTPCcalibDB.cxx:805
 AliTPCcalibDB.cxx:806
 AliTPCcalibDB.cxx:807
 AliTPCcalibDB.cxx:808
 AliTPCcalibDB.cxx:809
 AliTPCcalibDB.cxx:810
 AliTPCcalibDB.cxx:811
 AliTPCcalibDB.cxx:812
 AliTPCcalibDB.cxx:813
 AliTPCcalibDB.cxx:814
 AliTPCcalibDB.cxx:815
 AliTPCcalibDB.cxx:816
 AliTPCcalibDB.cxx:817
 AliTPCcalibDB.cxx:818
 AliTPCcalibDB.cxx:819
 AliTPCcalibDB.cxx:820
 AliTPCcalibDB.cxx:821
 AliTPCcalibDB.cxx:822
 AliTPCcalibDB.cxx:823
 AliTPCcalibDB.cxx:824
 AliTPCcalibDB.cxx:825
 AliTPCcalibDB.cxx:826
 AliTPCcalibDB.cxx:827
 AliTPCcalibDB.cxx:828
 AliTPCcalibDB.cxx:829
 AliTPCcalibDB.cxx:830
 AliTPCcalibDB.cxx:831
 AliTPCcalibDB.cxx:832
 AliTPCcalibDB.cxx:833
 AliTPCcalibDB.cxx:834
 AliTPCcalibDB.cxx:835
 AliTPCcalibDB.cxx:836
 AliTPCcalibDB.cxx:837
 AliTPCcalibDB.cxx:838
 AliTPCcalibDB.cxx:839
 AliTPCcalibDB.cxx:840
 AliTPCcalibDB.cxx:841
 AliTPCcalibDB.cxx:842
 AliTPCcalibDB.cxx:843
 AliTPCcalibDB.cxx:844
 AliTPCcalibDB.cxx:845
 AliTPCcalibDB.cxx:846
 AliTPCcalibDB.cxx:847
 AliTPCcalibDB.cxx:848
 AliTPCcalibDB.cxx:849
 AliTPCcalibDB.cxx:850
 AliTPCcalibDB.cxx:851
 AliTPCcalibDB.cxx:852
 AliTPCcalibDB.cxx:853
 AliTPCcalibDB.cxx:854
 AliTPCcalibDB.cxx:855
 AliTPCcalibDB.cxx:856
 AliTPCcalibDB.cxx:857
 AliTPCcalibDB.cxx:858
 AliTPCcalibDB.cxx:859
 AliTPCcalibDB.cxx:860
 AliTPCcalibDB.cxx:861
 AliTPCcalibDB.cxx:862
 AliTPCcalibDB.cxx:863
 AliTPCcalibDB.cxx:864
 AliTPCcalibDB.cxx:865
 AliTPCcalibDB.cxx:866
 AliTPCcalibDB.cxx:867
 AliTPCcalibDB.cxx:868
 AliTPCcalibDB.cxx:869
 AliTPCcalibDB.cxx:870
 AliTPCcalibDB.cxx:871
 AliTPCcalibDB.cxx:872
 AliTPCcalibDB.cxx:873
 AliTPCcalibDB.cxx:874
 AliTPCcalibDB.cxx:875
 AliTPCcalibDB.cxx:876
 AliTPCcalibDB.cxx:877
 AliTPCcalibDB.cxx:878
 AliTPCcalibDB.cxx:879
 AliTPCcalibDB.cxx:880
 AliTPCcalibDB.cxx:881
 AliTPCcalibDB.cxx:882
 AliTPCcalibDB.cxx:883
 AliTPCcalibDB.cxx:884
 AliTPCcalibDB.cxx:885
 AliTPCcalibDB.cxx:886
 AliTPCcalibDB.cxx:887
 AliTPCcalibDB.cxx:888
 AliTPCcalibDB.cxx:889
 AliTPCcalibDB.cxx:890
 AliTPCcalibDB.cxx:891
 AliTPCcalibDB.cxx:892
 AliTPCcalibDB.cxx:893
 AliTPCcalibDB.cxx:894
 AliTPCcalibDB.cxx:895
 AliTPCcalibDB.cxx:896
 AliTPCcalibDB.cxx:897
 AliTPCcalibDB.cxx:898
 AliTPCcalibDB.cxx:899
 AliTPCcalibDB.cxx:900
 AliTPCcalibDB.cxx:901
 AliTPCcalibDB.cxx:902
 AliTPCcalibDB.cxx:903
 AliTPCcalibDB.cxx:904
 AliTPCcalibDB.cxx:905
 AliTPCcalibDB.cxx:906
 AliTPCcalibDB.cxx:907
 AliTPCcalibDB.cxx:908
 AliTPCcalibDB.cxx:909
 AliTPCcalibDB.cxx:910
 AliTPCcalibDB.cxx:911
 AliTPCcalibDB.cxx:912
 AliTPCcalibDB.cxx:913
 AliTPCcalibDB.cxx:914
 AliTPCcalibDB.cxx:915
 AliTPCcalibDB.cxx:916
 AliTPCcalibDB.cxx:917
 AliTPCcalibDB.cxx:918
 AliTPCcalibDB.cxx:919
 AliTPCcalibDB.cxx:920
 AliTPCcalibDB.cxx:921
 AliTPCcalibDB.cxx:922
 AliTPCcalibDB.cxx:923
 AliTPCcalibDB.cxx:924
 AliTPCcalibDB.cxx:925
 AliTPCcalibDB.cxx:926
 AliTPCcalibDB.cxx:927
 AliTPCcalibDB.cxx:928
 AliTPCcalibDB.cxx:929
 AliTPCcalibDB.cxx:930
 AliTPCcalibDB.cxx:931
 AliTPCcalibDB.cxx:932
 AliTPCcalibDB.cxx:933
 AliTPCcalibDB.cxx:934
 AliTPCcalibDB.cxx:935
 AliTPCcalibDB.cxx:936
 AliTPCcalibDB.cxx:937
 AliTPCcalibDB.cxx:938
 AliTPCcalibDB.cxx:939
 AliTPCcalibDB.cxx:940
 AliTPCcalibDB.cxx:941
 AliTPCcalibDB.cxx:942
 AliTPCcalibDB.cxx:943
 AliTPCcalibDB.cxx:944
 AliTPCcalibDB.cxx:945
 AliTPCcalibDB.cxx:946
 AliTPCcalibDB.cxx:947
 AliTPCcalibDB.cxx:948
 AliTPCcalibDB.cxx:949
 AliTPCcalibDB.cxx:950
 AliTPCcalibDB.cxx:951
 AliTPCcalibDB.cxx:952
 AliTPCcalibDB.cxx:953
 AliTPCcalibDB.cxx:954
 AliTPCcalibDB.cxx:955
 AliTPCcalibDB.cxx:956
 AliTPCcalibDB.cxx:957
 AliTPCcalibDB.cxx:958
 AliTPCcalibDB.cxx:959
 AliTPCcalibDB.cxx:960
 AliTPCcalibDB.cxx:961
 AliTPCcalibDB.cxx:962
 AliTPCcalibDB.cxx:963
 AliTPCcalibDB.cxx:964
 AliTPCcalibDB.cxx:965
 AliTPCcalibDB.cxx:966
 AliTPCcalibDB.cxx:967
 AliTPCcalibDB.cxx:968
 AliTPCcalibDB.cxx:969
 AliTPCcalibDB.cxx:970
 AliTPCcalibDB.cxx:971
 AliTPCcalibDB.cxx:972
 AliTPCcalibDB.cxx:973
 AliTPCcalibDB.cxx:974
 AliTPCcalibDB.cxx:975
 AliTPCcalibDB.cxx:976
 AliTPCcalibDB.cxx:977
 AliTPCcalibDB.cxx:978
 AliTPCcalibDB.cxx:979
 AliTPCcalibDB.cxx:980
 AliTPCcalibDB.cxx:981
 AliTPCcalibDB.cxx:982
 AliTPCcalibDB.cxx:983
 AliTPCcalibDB.cxx:984
 AliTPCcalibDB.cxx:985
 AliTPCcalibDB.cxx:986
 AliTPCcalibDB.cxx:987
 AliTPCcalibDB.cxx:988
 AliTPCcalibDB.cxx:989
 AliTPCcalibDB.cxx:990
 AliTPCcalibDB.cxx:991
 AliTPCcalibDB.cxx:992
 AliTPCcalibDB.cxx:993
 AliTPCcalibDB.cxx:994
 AliTPCcalibDB.cxx:995
 AliTPCcalibDB.cxx:996
 AliTPCcalibDB.cxx:997
 AliTPCcalibDB.cxx:998
 AliTPCcalibDB.cxx:999
 AliTPCcalibDB.cxx:1000
 AliTPCcalibDB.cxx:1001
 AliTPCcalibDB.cxx:1002
 AliTPCcalibDB.cxx:1003
 AliTPCcalibDB.cxx:1004
 AliTPCcalibDB.cxx:1005
 AliTPCcalibDB.cxx:1006
 AliTPCcalibDB.cxx:1007
 AliTPCcalibDB.cxx:1008
 AliTPCcalibDB.cxx:1009
 AliTPCcalibDB.cxx:1010
 AliTPCcalibDB.cxx:1011
 AliTPCcalibDB.cxx:1012
 AliTPCcalibDB.cxx:1013
 AliTPCcalibDB.cxx:1014
 AliTPCcalibDB.cxx:1015
 AliTPCcalibDB.cxx:1016
 AliTPCcalibDB.cxx:1017
 AliTPCcalibDB.cxx:1018
 AliTPCcalibDB.cxx:1019
 AliTPCcalibDB.cxx:1020
 AliTPCcalibDB.cxx:1021
 AliTPCcalibDB.cxx:1022
 AliTPCcalibDB.cxx:1023
 AliTPCcalibDB.cxx:1024
 AliTPCcalibDB.cxx:1025
 AliTPCcalibDB.cxx:1026
 AliTPCcalibDB.cxx:1027
 AliTPCcalibDB.cxx:1028
 AliTPCcalibDB.cxx:1029
 AliTPCcalibDB.cxx:1030
 AliTPCcalibDB.cxx:1031
 AliTPCcalibDB.cxx:1032
 AliTPCcalibDB.cxx:1033
 AliTPCcalibDB.cxx:1034
 AliTPCcalibDB.cxx:1035
 AliTPCcalibDB.cxx:1036
 AliTPCcalibDB.cxx:1037
 AliTPCcalibDB.cxx:1038
 AliTPCcalibDB.cxx:1039
 AliTPCcalibDB.cxx:1040
 AliTPCcalibDB.cxx:1041
 AliTPCcalibDB.cxx:1042
 AliTPCcalibDB.cxx:1043
 AliTPCcalibDB.cxx:1044
 AliTPCcalibDB.cxx:1045
 AliTPCcalibDB.cxx:1046
 AliTPCcalibDB.cxx:1047
 AliTPCcalibDB.cxx:1048
 AliTPCcalibDB.cxx:1049
 AliTPCcalibDB.cxx:1050
 AliTPCcalibDB.cxx:1051
 AliTPCcalibDB.cxx:1052
 AliTPCcalibDB.cxx:1053
 AliTPCcalibDB.cxx:1054
 AliTPCcalibDB.cxx:1055
 AliTPCcalibDB.cxx:1056
 AliTPCcalibDB.cxx:1057
 AliTPCcalibDB.cxx:1058
 AliTPCcalibDB.cxx:1059
 AliTPCcalibDB.cxx:1060
 AliTPCcalibDB.cxx:1061
 AliTPCcalibDB.cxx:1062
 AliTPCcalibDB.cxx:1063
 AliTPCcalibDB.cxx:1064
 AliTPCcalibDB.cxx:1065
 AliTPCcalibDB.cxx:1066
 AliTPCcalibDB.cxx:1067
 AliTPCcalibDB.cxx:1068
 AliTPCcalibDB.cxx:1069
 AliTPCcalibDB.cxx:1070
 AliTPCcalibDB.cxx:1071
 AliTPCcalibDB.cxx:1072
 AliTPCcalibDB.cxx:1073
 AliTPCcalibDB.cxx:1074
 AliTPCcalibDB.cxx:1075
 AliTPCcalibDB.cxx:1076
 AliTPCcalibDB.cxx:1077
 AliTPCcalibDB.cxx:1078
 AliTPCcalibDB.cxx:1079
 AliTPCcalibDB.cxx:1080
 AliTPCcalibDB.cxx:1081
 AliTPCcalibDB.cxx:1082
 AliTPCcalibDB.cxx:1083
 AliTPCcalibDB.cxx:1084
 AliTPCcalibDB.cxx:1085
 AliTPCcalibDB.cxx:1086
 AliTPCcalibDB.cxx:1087
 AliTPCcalibDB.cxx:1088
 AliTPCcalibDB.cxx:1089
 AliTPCcalibDB.cxx:1090
 AliTPCcalibDB.cxx:1091
 AliTPCcalibDB.cxx:1092
 AliTPCcalibDB.cxx:1093
 AliTPCcalibDB.cxx:1094
 AliTPCcalibDB.cxx:1095
 AliTPCcalibDB.cxx:1096
 AliTPCcalibDB.cxx:1097
 AliTPCcalibDB.cxx:1098
 AliTPCcalibDB.cxx:1099
 AliTPCcalibDB.cxx:1100
 AliTPCcalibDB.cxx:1101
 AliTPCcalibDB.cxx:1102
 AliTPCcalibDB.cxx:1103
 AliTPCcalibDB.cxx:1104
 AliTPCcalibDB.cxx:1105
 AliTPCcalibDB.cxx:1106
 AliTPCcalibDB.cxx:1107
 AliTPCcalibDB.cxx:1108
 AliTPCcalibDB.cxx:1109
 AliTPCcalibDB.cxx:1110
 AliTPCcalibDB.cxx:1111
 AliTPCcalibDB.cxx:1112
 AliTPCcalibDB.cxx:1113
 AliTPCcalibDB.cxx:1114
 AliTPCcalibDB.cxx:1115
 AliTPCcalibDB.cxx:1116
 AliTPCcalibDB.cxx:1117
 AliTPCcalibDB.cxx:1118
 AliTPCcalibDB.cxx:1119
 AliTPCcalibDB.cxx:1120
 AliTPCcalibDB.cxx:1121
 AliTPCcalibDB.cxx:1122
 AliTPCcalibDB.cxx:1123
 AliTPCcalibDB.cxx:1124
 AliTPCcalibDB.cxx:1125
 AliTPCcalibDB.cxx:1126
 AliTPCcalibDB.cxx:1127
 AliTPCcalibDB.cxx:1128
 AliTPCcalibDB.cxx:1129
 AliTPCcalibDB.cxx:1130
 AliTPCcalibDB.cxx:1131
 AliTPCcalibDB.cxx:1132
 AliTPCcalibDB.cxx:1133
 AliTPCcalibDB.cxx:1134
 AliTPCcalibDB.cxx:1135
 AliTPCcalibDB.cxx:1136
 AliTPCcalibDB.cxx:1137
 AliTPCcalibDB.cxx:1138
 AliTPCcalibDB.cxx:1139
 AliTPCcalibDB.cxx:1140
 AliTPCcalibDB.cxx:1141
 AliTPCcalibDB.cxx:1142
 AliTPCcalibDB.cxx:1143
 AliTPCcalibDB.cxx:1144
 AliTPCcalibDB.cxx:1145
 AliTPCcalibDB.cxx:1146
 AliTPCcalibDB.cxx:1147
 AliTPCcalibDB.cxx:1148
 AliTPCcalibDB.cxx:1149
 AliTPCcalibDB.cxx:1150
 AliTPCcalibDB.cxx:1151
 AliTPCcalibDB.cxx:1152
 AliTPCcalibDB.cxx:1153
 AliTPCcalibDB.cxx:1154
 AliTPCcalibDB.cxx:1155
 AliTPCcalibDB.cxx:1156
 AliTPCcalibDB.cxx:1157
 AliTPCcalibDB.cxx:1158
 AliTPCcalibDB.cxx:1159
 AliTPCcalibDB.cxx:1160
 AliTPCcalibDB.cxx:1161
 AliTPCcalibDB.cxx:1162
 AliTPCcalibDB.cxx:1163
 AliTPCcalibDB.cxx:1164
 AliTPCcalibDB.cxx:1165
 AliTPCcalibDB.cxx:1166
 AliTPCcalibDB.cxx:1167
 AliTPCcalibDB.cxx:1168
 AliTPCcalibDB.cxx:1169
 AliTPCcalibDB.cxx:1170
 AliTPCcalibDB.cxx:1171
 AliTPCcalibDB.cxx:1172
 AliTPCcalibDB.cxx:1173
 AliTPCcalibDB.cxx:1174
 AliTPCcalibDB.cxx:1175
 AliTPCcalibDB.cxx:1176
 AliTPCcalibDB.cxx:1177
 AliTPCcalibDB.cxx:1178
 AliTPCcalibDB.cxx:1179
 AliTPCcalibDB.cxx:1180
 AliTPCcalibDB.cxx:1181
 AliTPCcalibDB.cxx:1182
 AliTPCcalibDB.cxx:1183
 AliTPCcalibDB.cxx:1184
 AliTPCcalibDB.cxx:1185
 AliTPCcalibDB.cxx:1186
 AliTPCcalibDB.cxx:1187
 AliTPCcalibDB.cxx:1188
 AliTPCcalibDB.cxx:1189
 AliTPCcalibDB.cxx:1190
 AliTPCcalibDB.cxx:1191
 AliTPCcalibDB.cxx:1192
 AliTPCcalibDB.cxx:1193
 AliTPCcalibDB.cxx:1194
 AliTPCcalibDB.cxx:1195
 AliTPCcalibDB.cxx:1196
 AliTPCcalibDB.cxx:1197
 AliTPCcalibDB.cxx:1198
 AliTPCcalibDB.cxx:1199
 AliTPCcalibDB.cxx:1200
 AliTPCcalibDB.cxx:1201
 AliTPCcalibDB.cxx:1202
 AliTPCcalibDB.cxx:1203
 AliTPCcalibDB.cxx:1204
 AliTPCcalibDB.cxx:1205
 AliTPCcalibDB.cxx:1206
 AliTPCcalibDB.cxx:1207
 AliTPCcalibDB.cxx:1208
 AliTPCcalibDB.cxx:1209
 AliTPCcalibDB.cxx:1210
 AliTPCcalibDB.cxx:1211
 AliTPCcalibDB.cxx:1212
 AliTPCcalibDB.cxx:1213
 AliTPCcalibDB.cxx:1214
 AliTPCcalibDB.cxx:1215
 AliTPCcalibDB.cxx:1216
 AliTPCcalibDB.cxx:1217
 AliTPCcalibDB.cxx:1218
 AliTPCcalibDB.cxx:1219
 AliTPCcalibDB.cxx:1220
 AliTPCcalibDB.cxx:1221
 AliTPCcalibDB.cxx:1222
 AliTPCcalibDB.cxx:1223
 AliTPCcalibDB.cxx:1224
 AliTPCcalibDB.cxx:1225
 AliTPCcalibDB.cxx:1226
 AliTPCcalibDB.cxx:1227
 AliTPCcalibDB.cxx:1228
 AliTPCcalibDB.cxx:1229
 AliTPCcalibDB.cxx:1230
 AliTPCcalibDB.cxx:1231
 AliTPCcalibDB.cxx:1232
 AliTPCcalibDB.cxx:1233
 AliTPCcalibDB.cxx:1234
 AliTPCcalibDB.cxx:1235
 AliTPCcalibDB.cxx:1236
 AliTPCcalibDB.cxx:1237
 AliTPCcalibDB.cxx:1238
 AliTPCcalibDB.cxx:1239
 AliTPCcalibDB.cxx:1240
 AliTPCcalibDB.cxx:1241
 AliTPCcalibDB.cxx:1242
 AliTPCcalibDB.cxx:1243
 AliTPCcalibDB.cxx:1244
 AliTPCcalibDB.cxx:1245
 AliTPCcalibDB.cxx:1246
 AliTPCcalibDB.cxx:1247
 AliTPCcalibDB.cxx:1248
 AliTPCcalibDB.cxx:1249
 AliTPCcalibDB.cxx:1250
 AliTPCcalibDB.cxx:1251
 AliTPCcalibDB.cxx:1252
 AliTPCcalibDB.cxx:1253
 AliTPCcalibDB.cxx:1254
 AliTPCcalibDB.cxx:1255
 AliTPCcalibDB.cxx:1256
 AliTPCcalibDB.cxx:1257
 AliTPCcalibDB.cxx:1258
 AliTPCcalibDB.cxx:1259
 AliTPCcalibDB.cxx:1260
 AliTPCcalibDB.cxx:1261
 AliTPCcalibDB.cxx:1262
 AliTPCcalibDB.cxx:1263
 AliTPCcalibDB.cxx:1264
 AliTPCcalibDB.cxx:1265
 AliTPCcalibDB.cxx:1266
 AliTPCcalibDB.cxx:1267
 AliTPCcalibDB.cxx:1268
 AliTPCcalibDB.cxx:1269
 AliTPCcalibDB.cxx:1270
 AliTPCcalibDB.cxx:1271
 AliTPCcalibDB.cxx:1272
 AliTPCcalibDB.cxx:1273
 AliTPCcalibDB.cxx:1274
 AliTPCcalibDB.cxx:1275
 AliTPCcalibDB.cxx:1276
 AliTPCcalibDB.cxx:1277
 AliTPCcalibDB.cxx:1278
 AliTPCcalibDB.cxx:1279
 AliTPCcalibDB.cxx:1280
 AliTPCcalibDB.cxx:1281
 AliTPCcalibDB.cxx:1282
 AliTPCcalibDB.cxx:1283
 AliTPCcalibDB.cxx:1284
 AliTPCcalibDB.cxx:1285
 AliTPCcalibDB.cxx:1286
 AliTPCcalibDB.cxx:1287
 AliTPCcalibDB.cxx:1288
 AliTPCcalibDB.cxx:1289
 AliTPCcalibDB.cxx:1290
 AliTPCcalibDB.cxx:1291
 AliTPCcalibDB.cxx:1292
 AliTPCcalibDB.cxx:1293
 AliTPCcalibDB.cxx:1294
 AliTPCcalibDB.cxx:1295
 AliTPCcalibDB.cxx:1296
 AliTPCcalibDB.cxx:1297
 AliTPCcalibDB.cxx:1298
 AliTPCcalibDB.cxx:1299
 AliTPCcalibDB.cxx:1300
 AliTPCcalibDB.cxx:1301
 AliTPCcalibDB.cxx:1302
 AliTPCcalibDB.cxx:1303
 AliTPCcalibDB.cxx:1304
 AliTPCcalibDB.cxx:1305
 AliTPCcalibDB.cxx:1306
 AliTPCcalibDB.cxx:1307
 AliTPCcalibDB.cxx:1308
 AliTPCcalibDB.cxx:1309
 AliTPCcalibDB.cxx:1310
 AliTPCcalibDB.cxx:1311
 AliTPCcalibDB.cxx:1312
 AliTPCcalibDB.cxx:1313
 AliTPCcalibDB.cxx:1314
 AliTPCcalibDB.cxx:1315
 AliTPCcalibDB.cxx:1316
 AliTPCcalibDB.cxx:1317
 AliTPCcalibDB.cxx:1318
 AliTPCcalibDB.cxx:1319
 AliTPCcalibDB.cxx:1320
 AliTPCcalibDB.cxx:1321
 AliTPCcalibDB.cxx:1322
 AliTPCcalibDB.cxx:1323
 AliTPCcalibDB.cxx:1324
 AliTPCcalibDB.cxx:1325
 AliTPCcalibDB.cxx:1326
 AliTPCcalibDB.cxx:1327
 AliTPCcalibDB.cxx:1328
 AliTPCcalibDB.cxx:1329
 AliTPCcalibDB.cxx:1330
 AliTPCcalibDB.cxx:1331
 AliTPCcalibDB.cxx:1332
 AliTPCcalibDB.cxx:1333
 AliTPCcalibDB.cxx:1334
 AliTPCcalibDB.cxx:1335
 AliTPCcalibDB.cxx:1336
 AliTPCcalibDB.cxx:1337
 AliTPCcalibDB.cxx:1338
 AliTPCcalibDB.cxx:1339
 AliTPCcalibDB.cxx:1340
 AliTPCcalibDB.cxx:1341
 AliTPCcalibDB.cxx:1342
 AliTPCcalibDB.cxx:1343
 AliTPCcalibDB.cxx:1344
 AliTPCcalibDB.cxx:1345
 AliTPCcalibDB.cxx:1346
 AliTPCcalibDB.cxx:1347
 AliTPCcalibDB.cxx:1348
 AliTPCcalibDB.cxx:1349
 AliTPCcalibDB.cxx:1350
 AliTPCcalibDB.cxx:1351
 AliTPCcalibDB.cxx:1352
 AliTPCcalibDB.cxx:1353
 AliTPCcalibDB.cxx:1354
 AliTPCcalibDB.cxx:1355
 AliTPCcalibDB.cxx:1356
 AliTPCcalibDB.cxx:1357
 AliTPCcalibDB.cxx:1358
 AliTPCcalibDB.cxx:1359
 AliTPCcalibDB.cxx:1360
 AliTPCcalibDB.cxx:1361
 AliTPCcalibDB.cxx:1362
 AliTPCcalibDB.cxx:1363
 AliTPCcalibDB.cxx:1364
 AliTPCcalibDB.cxx:1365
 AliTPCcalibDB.cxx:1366
 AliTPCcalibDB.cxx:1367
 AliTPCcalibDB.cxx:1368
 AliTPCcalibDB.cxx:1369
 AliTPCcalibDB.cxx:1370
 AliTPCcalibDB.cxx:1371
 AliTPCcalibDB.cxx:1372
 AliTPCcalibDB.cxx:1373
 AliTPCcalibDB.cxx:1374
 AliTPCcalibDB.cxx:1375
 AliTPCcalibDB.cxx:1376
 AliTPCcalibDB.cxx:1377
 AliTPCcalibDB.cxx:1378
 AliTPCcalibDB.cxx:1379
 AliTPCcalibDB.cxx:1380
 AliTPCcalibDB.cxx:1381
 AliTPCcalibDB.cxx:1382
 AliTPCcalibDB.cxx:1383
 AliTPCcalibDB.cxx:1384
 AliTPCcalibDB.cxx:1385
 AliTPCcalibDB.cxx:1386
 AliTPCcalibDB.cxx:1387
 AliTPCcalibDB.cxx:1388
 AliTPCcalibDB.cxx:1389
 AliTPCcalibDB.cxx:1390
 AliTPCcalibDB.cxx:1391
 AliTPCcalibDB.cxx:1392
 AliTPCcalibDB.cxx:1393
 AliTPCcalibDB.cxx:1394
 AliTPCcalibDB.cxx:1395
 AliTPCcalibDB.cxx:1396
 AliTPCcalibDB.cxx:1397
 AliTPCcalibDB.cxx:1398
 AliTPCcalibDB.cxx:1399
 AliTPCcalibDB.cxx:1400
 AliTPCcalibDB.cxx:1401
 AliTPCcalibDB.cxx:1402
 AliTPCcalibDB.cxx:1403
 AliTPCcalibDB.cxx:1404
 AliTPCcalibDB.cxx:1405
 AliTPCcalibDB.cxx:1406
 AliTPCcalibDB.cxx:1407
 AliTPCcalibDB.cxx:1408
 AliTPCcalibDB.cxx:1409
 AliTPCcalibDB.cxx:1410
 AliTPCcalibDB.cxx:1411
 AliTPCcalibDB.cxx:1412
 AliTPCcalibDB.cxx:1413
 AliTPCcalibDB.cxx:1414
 AliTPCcalibDB.cxx:1415
 AliTPCcalibDB.cxx:1416
 AliTPCcalibDB.cxx:1417
 AliTPCcalibDB.cxx:1418
 AliTPCcalibDB.cxx:1419
 AliTPCcalibDB.cxx:1420
 AliTPCcalibDB.cxx:1421
 AliTPCcalibDB.cxx:1422
 AliTPCcalibDB.cxx:1423
 AliTPCcalibDB.cxx:1424
 AliTPCcalibDB.cxx:1425
 AliTPCcalibDB.cxx:1426
 AliTPCcalibDB.cxx:1427
 AliTPCcalibDB.cxx:1428
 AliTPCcalibDB.cxx:1429
 AliTPCcalibDB.cxx:1430
 AliTPCcalibDB.cxx:1431
 AliTPCcalibDB.cxx:1432
 AliTPCcalibDB.cxx:1433
 AliTPCcalibDB.cxx:1434
 AliTPCcalibDB.cxx:1435
 AliTPCcalibDB.cxx:1436
 AliTPCcalibDB.cxx:1437
 AliTPCcalibDB.cxx:1438
 AliTPCcalibDB.cxx:1439
 AliTPCcalibDB.cxx:1440
 AliTPCcalibDB.cxx:1441
 AliTPCcalibDB.cxx:1442
 AliTPCcalibDB.cxx:1443
 AliTPCcalibDB.cxx:1444
 AliTPCcalibDB.cxx:1445
 AliTPCcalibDB.cxx:1446
 AliTPCcalibDB.cxx:1447
 AliTPCcalibDB.cxx:1448
 AliTPCcalibDB.cxx:1449
 AliTPCcalibDB.cxx:1450
 AliTPCcalibDB.cxx:1451
 AliTPCcalibDB.cxx:1452
 AliTPCcalibDB.cxx:1453
 AliTPCcalibDB.cxx:1454
 AliTPCcalibDB.cxx:1455
 AliTPCcalibDB.cxx:1456
 AliTPCcalibDB.cxx:1457
 AliTPCcalibDB.cxx:1458
 AliTPCcalibDB.cxx:1459
 AliTPCcalibDB.cxx:1460
 AliTPCcalibDB.cxx:1461
 AliTPCcalibDB.cxx:1462
 AliTPCcalibDB.cxx:1463
 AliTPCcalibDB.cxx:1464
 AliTPCcalibDB.cxx:1465
 AliTPCcalibDB.cxx:1466
 AliTPCcalibDB.cxx:1467
 AliTPCcalibDB.cxx:1468
 AliTPCcalibDB.cxx:1469
 AliTPCcalibDB.cxx:1470
 AliTPCcalibDB.cxx:1471
 AliTPCcalibDB.cxx:1472
 AliTPCcalibDB.cxx:1473
 AliTPCcalibDB.cxx:1474
 AliTPCcalibDB.cxx:1475
 AliTPCcalibDB.cxx:1476
 AliTPCcalibDB.cxx:1477
 AliTPCcalibDB.cxx:1478
 AliTPCcalibDB.cxx:1479
 AliTPCcalibDB.cxx:1480
 AliTPCcalibDB.cxx:1481
 AliTPCcalibDB.cxx:1482
 AliTPCcalibDB.cxx:1483
 AliTPCcalibDB.cxx:1484
 AliTPCcalibDB.cxx:1485
 AliTPCcalibDB.cxx:1486
 AliTPCcalibDB.cxx:1487
 AliTPCcalibDB.cxx:1488
 AliTPCcalibDB.cxx:1489
 AliTPCcalibDB.cxx:1490
 AliTPCcalibDB.cxx:1491
 AliTPCcalibDB.cxx:1492
 AliTPCcalibDB.cxx:1493
 AliTPCcalibDB.cxx:1494
 AliTPCcalibDB.cxx:1495
 AliTPCcalibDB.cxx:1496
 AliTPCcalibDB.cxx:1497
 AliTPCcalibDB.cxx:1498
 AliTPCcalibDB.cxx:1499
 AliTPCcalibDB.cxx:1500
 AliTPCcalibDB.cxx:1501
 AliTPCcalibDB.cxx:1502
 AliTPCcalibDB.cxx:1503
 AliTPCcalibDB.cxx:1504
 AliTPCcalibDB.cxx:1505
 AliTPCcalibDB.cxx:1506
 AliTPCcalibDB.cxx:1507
 AliTPCcalibDB.cxx:1508
 AliTPCcalibDB.cxx:1509
 AliTPCcalibDB.cxx:1510
 AliTPCcalibDB.cxx:1511
 AliTPCcalibDB.cxx:1512
 AliTPCcalibDB.cxx:1513
 AliTPCcalibDB.cxx:1514
 AliTPCcalibDB.cxx:1515
 AliTPCcalibDB.cxx:1516
 AliTPCcalibDB.cxx:1517
 AliTPCcalibDB.cxx:1518
 AliTPCcalibDB.cxx:1519
 AliTPCcalibDB.cxx:1520
 AliTPCcalibDB.cxx:1521
 AliTPCcalibDB.cxx:1522
 AliTPCcalibDB.cxx:1523
 AliTPCcalibDB.cxx:1524
 AliTPCcalibDB.cxx:1525
 AliTPCcalibDB.cxx:1526
 AliTPCcalibDB.cxx:1527
 AliTPCcalibDB.cxx:1528
 AliTPCcalibDB.cxx:1529
 AliTPCcalibDB.cxx:1530
 AliTPCcalibDB.cxx:1531
 AliTPCcalibDB.cxx:1532
 AliTPCcalibDB.cxx:1533
 AliTPCcalibDB.cxx:1534
 AliTPCcalibDB.cxx:1535
 AliTPCcalibDB.cxx:1536
 AliTPCcalibDB.cxx:1537
 AliTPCcalibDB.cxx:1538
 AliTPCcalibDB.cxx:1539
 AliTPCcalibDB.cxx:1540
 AliTPCcalibDB.cxx:1541
 AliTPCcalibDB.cxx:1542
 AliTPCcalibDB.cxx:1543
 AliTPCcalibDB.cxx:1544
 AliTPCcalibDB.cxx:1545
 AliTPCcalibDB.cxx:1546
 AliTPCcalibDB.cxx:1547
 AliTPCcalibDB.cxx:1548
 AliTPCcalibDB.cxx:1549
 AliTPCcalibDB.cxx:1550
 AliTPCcalibDB.cxx:1551
 AliTPCcalibDB.cxx:1552
 AliTPCcalibDB.cxx:1553
 AliTPCcalibDB.cxx:1554
 AliTPCcalibDB.cxx:1555
 AliTPCcalibDB.cxx:1556
 AliTPCcalibDB.cxx:1557
 AliTPCcalibDB.cxx:1558
 AliTPCcalibDB.cxx:1559
 AliTPCcalibDB.cxx:1560
 AliTPCcalibDB.cxx:1561
 AliTPCcalibDB.cxx:1562
 AliTPCcalibDB.cxx:1563
 AliTPCcalibDB.cxx:1564
 AliTPCcalibDB.cxx:1565
 AliTPCcalibDB.cxx:1566
 AliTPCcalibDB.cxx:1567
 AliTPCcalibDB.cxx:1568
 AliTPCcalibDB.cxx:1569
 AliTPCcalibDB.cxx:1570
 AliTPCcalibDB.cxx:1571
 AliTPCcalibDB.cxx:1572
 AliTPCcalibDB.cxx:1573
 AliTPCcalibDB.cxx:1574
 AliTPCcalibDB.cxx:1575
 AliTPCcalibDB.cxx:1576
 AliTPCcalibDB.cxx:1577
 AliTPCcalibDB.cxx:1578
 AliTPCcalibDB.cxx:1579
 AliTPCcalibDB.cxx:1580
 AliTPCcalibDB.cxx:1581
 AliTPCcalibDB.cxx:1582
 AliTPCcalibDB.cxx:1583
 AliTPCcalibDB.cxx:1584
 AliTPCcalibDB.cxx:1585
 AliTPCcalibDB.cxx:1586
 AliTPCcalibDB.cxx:1587
 AliTPCcalibDB.cxx:1588
 AliTPCcalibDB.cxx:1589
 AliTPCcalibDB.cxx:1590
 AliTPCcalibDB.cxx:1591
 AliTPCcalibDB.cxx:1592
 AliTPCcalibDB.cxx:1593
 AliTPCcalibDB.cxx:1594
 AliTPCcalibDB.cxx:1595
 AliTPCcalibDB.cxx:1596
 AliTPCcalibDB.cxx:1597
 AliTPCcalibDB.cxx:1598
 AliTPCcalibDB.cxx:1599
 AliTPCcalibDB.cxx:1600
 AliTPCcalibDB.cxx:1601
 AliTPCcalibDB.cxx:1602
 AliTPCcalibDB.cxx:1603
 AliTPCcalibDB.cxx:1604
 AliTPCcalibDB.cxx:1605
 AliTPCcalibDB.cxx:1606
 AliTPCcalibDB.cxx:1607
 AliTPCcalibDB.cxx:1608
 AliTPCcalibDB.cxx:1609
 AliTPCcalibDB.cxx:1610
 AliTPCcalibDB.cxx:1611
 AliTPCcalibDB.cxx:1612
 AliTPCcalibDB.cxx:1613
 AliTPCcalibDB.cxx:1614
 AliTPCcalibDB.cxx:1615
 AliTPCcalibDB.cxx:1616
 AliTPCcalibDB.cxx:1617
 AliTPCcalibDB.cxx:1618
 AliTPCcalibDB.cxx:1619
 AliTPCcalibDB.cxx:1620
 AliTPCcalibDB.cxx:1621
 AliTPCcalibDB.cxx:1622
 AliTPCcalibDB.cxx:1623
 AliTPCcalibDB.cxx:1624
 AliTPCcalibDB.cxx:1625
 AliTPCcalibDB.cxx:1626
 AliTPCcalibDB.cxx:1627
 AliTPCcalibDB.cxx:1628
 AliTPCcalibDB.cxx:1629
 AliTPCcalibDB.cxx:1630
 AliTPCcalibDB.cxx:1631
 AliTPCcalibDB.cxx:1632
 AliTPCcalibDB.cxx:1633
 AliTPCcalibDB.cxx:1634
 AliTPCcalibDB.cxx:1635
 AliTPCcalibDB.cxx:1636
 AliTPCcalibDB.cxx:1637
 AliTPCcalibDB.cxx:1638
 AliTPCcalibDB.cxx:1639
 AliTPCcalibDB.cxx:1640
 AliTPCcalibDB.cxx:1641
 AliTPCcalibDB.cxx:1642
 AliTPCcalibDB.cxx:1643
 AliTPCcalibDB.cxx:1644
 AliTPCcalibDB.cxx:1645
 AliTPCcalibDB.cxx:1646
 AliTPCcalibDB.cxx:1647
 AliTPCcalibDB.cxx:1648
 AliTPCcalibDB.cxx:1649
 AliTPCcalibDB.cxx:1650
 AliTPCcalibDB.cxx:1651
 AliTPCcalibDB.cxx:1652
 AliTPCcalibDB.cxx:1653
 AliTPCcalibDB.cxx:1654
 AliTPCcalibDB.cxx:1655
 AliTPCcalibDB.cxx:1656
 AliTPCcalibDB.cxx:1657
 AliTPCcalibDB.cxx:1658
 AliTPCcalibDB.cxx:1659
 AliTPCcalibDB.cxx:1660
 AliTPCcalibDB.cxx:1661
 AliTPCcalibDB.cxx:1662
 AliTPCcalibDB.cxx:1663
 AliTPCcalibDB.cxx:1664
 AliTPCcalibDB.cxx:1665
 AliTPCcalibDB.cxx:1666
 AliTPCcalibDB.cxx:1667
 AliTPCcalibDB.cxx:1668
 AliTPCcalibDB.cxx:1669
 AliTPCcalibDB.cxx:1670
 AliTPCcalibDB.cxx:1671
 AliTPCcalibDB.cxx:1672
 AliTPCcalibDB.cxx:1673
 AliTPCcalibDB.cxx:1674
 AliTPCcalibDB.cxx:1675
 AliTPCcalibDB.cxx:1676
 AliTPCcalibDB.cxx:1677
 AliTPCcalibDB.cxx:1678
 AliTPCcalibDB.cxx:1679
 AliTPCcalibDB.cxx:1680
 AliTPCcalibDB.cxx:1681
 AliTPCcalibDB.cxx:1682
 AliTPCcalibDB.cxx:1683
 AliTPCcalibDB.cxx:1684
 AliTPCcalibDB.cxx:1685
 AliTPCcalibDB.cxx:1686
 AliTPCcalibDB.cxx:1687
 AliTPCcalibDB.cxx:1688
 AliTPCcalibDB.cxx:1689
 AliTPCcalibDB.cxx:1690
 AliTPCcalibDB.cxx:1691
 AliTPCcalibDB.cxx:1692
 AliTPCcalibDB.cxx:1693
 AliTPCcalibDB.cxx:1694
 AliTPCcalibDB.cxx:1695
 AliTPCcalibDB.cxx:1696
 AliTPCcalibDB.cxx:1697
 AliTPCcalibDB.cxx:1698
 AliTPCcalibDB.cxx:1699
 AliTPCcalibDB.cxx:1700
 AliTPCcalibDB.cxx:1701
 AliTPCcalibDB.cxx:1702
 AliTPCcalibDB.cxx:1703
 AliTPCcalibDB.cxx:1704
 AliTPCcalibDB.cxx:1705
 AliTPCcalibDB.cxx:1706
 AliTPCcalibDB.cxx:1707
 AliTPCcalibDB.cxx:1708
 AliTPCcalibDB.cxx:1709
 AliTPCcalibDB.cxx:1710
 AliTPCcalibDB.cxx:1711
 AliTPCcalibDB.cxx:1712
 AliTPCcalibDB.cxx:1713
 AliTPCcalibDB.cxx:1714
 AliTPCcalibDB.cxx:1715
 AliTPCcalibDB.cxx:1716
 AliTPCcalibDB.cxx:1717
 AliTPCcalibDB.cxx:1718
 AliTPCcalibDB.cxx:1719
 AliTPCcalibDB.cxx:1720
 AliTPCcalibDB.cxx:1721
 AliTPCcalibDB.cxx:1722
 AliTPCcalibDB.cxx:1723
 AliTPCcalibDB.cxx:1724
 AliTPCcalibDB.cxx:1725
 AliTPCcalibDB.cxx:1726
 AliTPCcalibDB.cxx:1727
 AliTPCcalibDB.cxx:1728
 AliTPCcalibDB.cxx:1729
 AliTPCcalibDB.cxx:1730
 AliTPCcalibDB.cxx:1731
 AliTPCcalibDB.cxx:1732
 AliTPCcalibDB.cxx:1733
 AliTPCcalibDB.cxx:1734
 AliTPCcalibDB.cxx:1735
 AliTPCcalibDB.cxx:1736
 AliTPCcalibDB.cxx:1737
 AliTPCcalibDB.cxx:1738
 AliTPCcalibDB.cxx:1739
 AliTPCcalibDB.cxx:1740
 AliTPCcalibDB.cxx:1741
 AliTPCcalibDB.cxx:1742
 AliTPCcalibDB.cxx:1743
 AliTPCcalibDB.cxx:1744
 AliTPCcalibDB.cxx:1745
 AliTPCcalibDB.cxx:1746
 AliTPCcalibDB.cxx:1747
 AliTPCcalibDB.cxx:1748
 AliTPCcalibDB.cxx:1749
 AliTPCcalibDB.cxx:1750
 AliTPCcalibDB.cxx:1751
 AliTPCcalibDB.cxx:1752
 AliTPCcalibDB.cxx:1753
 AliTPCcalibDB.cxx:1754
 AliTPCcalibDB.cxx:1755
 AliTPCcalibDB.cxx:1756
 AliTPCcalibDB.cxx:1757
 AliTPCcalibDB.cxx:1758
 AliTPCcalibDB.cxx:1759
 AliTPCcalibDB.cxx:1760
 AliTPCcalibDB.cxx:1761
 AliTPCcalibDB.cxx:1762
 AliTPCcalibDB.cxx:1763
 AliTPCcalibDB.cxx:1764
 AliTPCcalibDB.cxx:1765
 AliTPCcalibDB.cxx:1766
 AliTPCcalibDB.cxx:1767
 AliTPCcalibDB.cxx:1768
 AliTPCcalibDB.cxx:1769
 AliTPCcalibDB.cxx:1770
 AliTPCcalibDB.cxx:1771
 AliTPCcalibDB.cxx:1772
 AliTPCcalibDB.cxx:1773
 AliTPCcalibDB.cxx:1774
 AliTPCcalibDB.cxx:1775
 AliTPCcalibDB.cxx:1776
 AliTPCcalibDB.cxx:1777
 AliTPCcalibDB.cxx:1778
 AliTPCcalibDB.cxx:1779
 AliTPCcalibDB.cxx:1780
 AliTPCcalibDB.cxx:1781
 AliTPCcalibDB.cxx:1782
 AliTPCcalibDB.cxx:1783
 AliTPCcalibDB.cxx:1784
 AliTPCcalibDB.cxx:1785
 AliTPCcalibDB.cxx:1786
 AliTPCcalibDB.cxx:1787
 AliTPCcalibDB.cxx:1788
 AliTPCcalibDB.cxx:1789
 AliTPCcalibDB.cxx:1790
 AliTPCcalibDB.cxx:1791
 AliTPCcalibDB.cxx:1792
 AliTPCcalibDB.cxx:1793
 AliTPCcalibDB.cxx:1794
 AliTPCcalibDB.cxx:1795
 AliTPCcalibDB.cxx:1796
 AliTPCcalibDB.cxx:1797
 AliTPCcalibDB.cxx:1798
 AliTPCcalibDB.cxx:1799
 AliTPCcalibDB.cxx:1800
 AliTPCcalibDB.cxx:1801
 AliTPCcalibDB.cxx:1802
 AliTPCcalibDB.cxx:1803
 AliTPCcalibDB.cxx:1804
 AliTPCcalibDB.cxx:1805
 AliTPCcalibDB.cxx:1806
 AliTPCcalibDB.cxx:1807
 AliTPCcalibDB.cxx:1808
 AliTPCcalibDB.cxx:1809
 AliTPCcalibDB.cxx:1810
 AliTPCcalibDB.cxx:1811
 AliTPCcalibDB.cxx:1812
 AliTPCcalibDB.cxx:1813
 AliTPCcalibDB.cxx:1814
 AliTPCcalibDB.cxx:1815
 AliTPCcalibDB.cxx:1816
 AliTPCcalibDB.cxx:1817
 AliTPCcalibDB.cxx:1818
 AliTPCcalibDB.cxx:1819
 AliTPCcalibDB.cxx:1820
 AliTPCcalibDB.cxx:1821
 AliTPCcalibDB.cxx:1822
 AliTPCcalibDB.cxx:1823
 AliTPCcalibDB.cxx:1824
 AliTPCcalibDB.cxx:1825
 AliTPCcalibDB.cxx:1826
 AliTPCcalibDB.cxx:1827
 AliTPCcalibDB.cxx:1828
 AliTPCcalibDB.cxx:1829
 AliTPCcalibDB.cxx:1830
 AliTPCcalibDB.cxx:1831
 AliTPCcalibDB.cxx:1832
 AliTPCcalibDB.cxx:1833
 AliTPCcalibDB.cxx:1834
 AliTPCcalibDB.cxx:1835
 AliTPCcalibDB.cxx:1836
 AliTPCcalibDB.cxx:1837
 AliTPCcalibDB.cxx:1838
 AliTPCcalibDB.cxx:1839
 AliTPCcalibDB.cxx:1840
 AliTPCcalibDB.cxx:1841
 AliTPCcalibDB.cxx:1842
 AliTPCcalibDB.cxx:1843
 AliTPCcalibDB.cxx:1844
 AliTPCcalibDB.cxx:1845
 AliTPCcalibDB.cxx:1846
 AliTPCcalibDB.cxx:1847
 AliTPCcalibDB.cxx:1848
 AliTPCcalibDB.cxx:1849
 AliTPCcalibDB.cxx:1850
 AliTPCcalibDB.cxx:1851
 AliTPCcalibDB.cxx:1852
 AliTPCcalibDB.cxx:1853
 AliTPCcalibDB.cxx:1854
 AliTPCcalibDB.cxx:1855
 AliTPCcalibDB.cxx:1856
 AliTPCcalibDB.cxx:1857
 AliTPCcalibDB.cxx:1858
 AliTPCcalibDB.cxx:1859
 AliTPCcalibDB.cxx:1860
 AliTPCcalibDB.cxx:1861
 AliTPCcalibDB.cxx:1862
 AliTPCcalibDB.cxx:1863
 AliTPCcalibDB.cxx:1864
 AliTPCcalibDB.cxx:1865
 AliTPCcalibDB.cxx:1866
 AliTPCcalibDB.cxx:1867
 AliTPCcalibDB.cxx:1868
 AliTPCcalibDB.cxx:1869
 AliTPCcalibDB.cxx:1870
 AliTPCcalibDB.cxx:1871
 AliTPCcalibDB.cxx:1872
 AliTPCcalibDB.cxx:1873
 AliTPCcalibDB.cxx:1874
 AliTPCcalibDB.cxx:1875
 AliTPCcalibDB.cxx:1876
 AliTPCcalibDB.cxx:1877
 AliTPCcalibDB.cxx:1878
 AliTPCcalibDB.cxx:1879
 AliTPCcalibDB.cxx:1880
 AliTPCcalibDB.cxx:1881
 AliTPCcalibDB.cxx:1882
 AliTPCcalibDB.cxx:1883
 AliTPCcalibDB.cxx:1884
 AliTPCcalibDB.cxx:1885
 AliTPCcalibDB.cxx:1886
 AliTPCcalibDB.cxx:1887
 AliTPCcalibDB.cxx:1888
 AliTPCcalibDB.cxx:1889
 AliTPCcalibDB.cxx:1890
 AliTPCcalibDB.cxx:1891
 AliTPCcalibDB.cxx:1892
 AliTPCcalibDB.cxx:1893
 AliTPCcalibDB.cxx:1894
 AliTPCcalibDB.cxx:1895
 AliTPCcalibDB.cxx:1896
 AliTPCcalibDB.cxx:1897
 AliTPCcalibDB.cxx:1898
 AliTPCcalibDB.cxx:1899
 AliTPCcalibDB.cxx:1900
 AliTPCcalibDB.cxx:1901
 AliTPCcalibDB.cxx:1902
 AliTPCcalibDB.cxx:1903
 AliTPCcalibDB.cxx:1904
 AliTPCcalibDB.cxx:1905
 AliTPCcalibDB.cxx:1906
 AliTPCcalibDB.cxx:1907
 AliTPCcalibDB.cxx:1908
 AliTPCcalibDB.cxx:1909
 AliTPCcalibDB.cxx:1910
 AliTPCcalibDB.cxx:1911
 AliTPCcalibDB.cxx:1912
 AliTPCcalibDB.cxx:1913
 AliTPCcalibDB.cxx:1914
 AliTPCcalibDB.cxx:1915
 AliTPCcalibDB.cxx:1916
 AliTPCcalibDB.cxx:1917
 AliTPCcalibDB.cxx:1918
 AliTPCcalibDB.cxx:1919
 AliTPCcalibDB.cxx:1920
 AliTPCcalibDB.cxx:1921
 AliTPCcalibDB.cxx:1922
 AliTPCcalibDB.cxx:1923
 AliTPCcalibDB.cxx:1924
 AliTPCcalibDB.cxx:1925
 AliTPCcalibDB.cxx:1926
 AliTPCcalibDB.cxx:1927
 AliTPCcalibDB.cxx:1928
 AliTPCcalibDB.cxx:1929
 AliTPCcalibDB.cxx:1930
 AliTPCcalibDB.cxx:1931
 AliTPCcalibDB.cxx:1932
 AliTPCcalibDB.cxx:1933
 AliTPCcalibDB.cxx:1934
 AliTPCcalibDB.cxx:1935
 AliTPCcalibDB.cxx:1936
 AliTPCcalibDB.cxx:1937
 AliTPCcalibDB.cxx:1938
 AliTPCcalibDB.cxx:1939
 AliTPCcalibDB.cxx:1940
 AliTPCcalibDB.cxx:1941
 AliTPCcalibDB.cxx:1942
 AliTPCcalibDB.cxx:1943
 AliTPCcalibDB.cxx:1944
 AliTPCcalibDB.cxx:1945
 AliTPCcalibDB.cxx:1946
 AliTPCcalibDB.cxx:1947
 AliTPCcalibDB.cxx:1948
 AliTPCcalibDB.cxx:1949
 AliTPCcalibDB.cxx:1950
 AliTPCcalibDB.cxx:1951
 AliTPCcalibDB.cxx:1952
 AliTPCcalibDB.cxx:1953
 AliTPCcalibDB.cxx:1954
 AliTPCcalibDB.cxx:1955
 AliTPCcalibDB.cxx:1956
 AliTPCcalibDB.cxx:1957
 AliTPCcalibDB.cxx:1958
 AliTPCcalibDB.cxx:1959
 AliTPCcalibDB.cxx:1960
 AliTPCcalibDB.cxx:1961
 AliTPCcalibDB.cxx:1962
 AliTPCcalibDB.cxx:1963
 AliTPCcalibDB.cxx:1964
 AliTPCcalibDB.cxx:1965
 AliTPCcalibDB.cxx:1966
 AliTPCcalibDB.cxx:1967
 AliTPCcalibDB.cxx:1968
 AliTPCcalibDB.cxx:1969
 AliTPCcalibDB.cxx:1970
 AliTPCcalibDB.cxx:1971
 AliTPCcalibDB.cxx:1972
 AliTPCcalibDB.cxx:1973
 AliTPCcalibDB.cxx:1974
 AliTPCcalibDB.cxx:1975
 AliTPCcalibDB.cxx:1976
 AliTPCcalibDB.cxx:1977
 AliTPCcalibDB.cxx:1978
 AliTPCcalibDB.cxx:1979
 AliTPCcalibDB.cxx:1980
 AliTPCcalibDB.cxx:1981
 AliTPCcalibDB.cxx:1982
 AliTPCcalibDB.cxx:1983
 AliTPCcalibDB.cxx:1984
 AliTPCcalibDB.cxx:1985
 AliTPCcalibDB.cxx:1986
 AliTPCcalibDB.cxx:1987
 AliTPCcalibDB.cxx:1988
 AliTPCcalibDB.cxx:1989
 AliTPCcalibDB.cxx:1990
 AliTPCcalibDB.cxx:1991
 AliTPCcalibDB.cxx:1992
 AliTPCcalibDB.cxx:1993
 AliTPCcalibDB.cxx:1994
 AliTPCcalibDB.cxx:1995
 AliTPCcalibDB.cxx:1996
 AliTPCcalibDB.cxx:1997
 AliTPCcalibDB.cxx:1998
 AliTPCcalibDB.cxx:1999
 AliTPCcalibDB.cxx:2000
 AliTPCcalibDB.cxx:2001
 AliTPCcalibDB.cxx:2002
 AliTPCcalibDB.cxx:2003
 AliTPCcalibDB.cxx:2004
 AliTPCcalibDB.cxx:2005
 AliTPCcalibDB.cxx:2006
 AliTPCcalibDB.cxx:2007
 AliTPCcalibDB.cxx:2008
 AliTPCcalibDB.cxx:2009
 AliTPCcalibDB.cxx:2010
 AliTPCcalibDB.cxx:2011
 AliTPCcalibDB.cxx:2012
 AliTPCcalibDB.cxx:2013
 AliTPCcalibDB.cxx:2014
 AliTPCcalibDB.cxx:2015
 AliTPCcalibDB.cxx:2016
 AliTPCcalibDB.cxx:2017
 AliTPCcalibDB.cxx:2018
 AliTPCcalibDB.cxx:2019
 AliTPCcalibDB.cxx:2020
 AliTPCcalibDB.cxx:2021
 AliTPCcalibDB.cxx:2022
 AliTPCcalibDB.cxx:2023
 AliTPCcalibDB.cxx:2024
 AliTPCcalibDB.cxx:2025
 AliTPCcalibDB.cxx:2026
 AliTPCcalibDB.cxx:2027
 AliTPCcalibDB.cxx:2028
 AliTPCcalibDB.cxx:2029
 AliTPCcalibDB.cxx:2030
 AliTPCcalibDB.cxx:2031
 AliTPCcalibDB.cxx:2032
 AliTPCcalibDB.cxx:2033
 AliTPCcalibDB.cxx:2034
 AliTPCcalibDB.cxx:2035
 AliTPCcalibDB.cxx:2036
 AliTPCcalibDB.cxx:2037
 AliTPCcalibDB.cxx:2038
 AliTPCcalibDB.cxx:2039
 AliTPCcalibDB.cxx:2040
 AliTPCcalibDB.cxx:2041
 AliTPCcalibDB.cxx:2042
 AliTPCcalibDB.cxx:2043
 AliTPCcalibDB.cxx:2044
 AliTPCcalibDB.cxx:2045
 AliTPCcalibDB.cxx:2046
 AliTPCcalibDB.cxx:2047
 AliTPCcalibDB.cxx:2048
 AliTPCcalibDB.cxx:2049
 AliTPCcalibDB.cxx:2050
 AliTPCcalibDB.cxx:2051
 AliTPCcalibDB.cxx:2052
 AliTPCcalibDB.cxx:2053
 AliTPCcalibDB.cxx:2054
 AliTPCcalibDB.cxx:2055
 AliTPCcalibDB.cxx:2056
 AliTPCcalibDB.cxx:2057
 AliTPCcalibDB.cxx:2058
 AliTPCcalibDB.cxx:2059
 AliTPCcalibDB.cxx:2060
 AliTPCcalibDB.cxx:2061
 AliTPCcalibDB.cxx:2062
 AliTPCcalibDB.cxx:2063
 AliTPCcalibDB.cxx:2064
 AliTPCcalibDB.cxx:2065
 AliTPCcalibDB.cxx:2066
 AliTPCcalibDB.cxx:2067
 AliTPCcalibDB.cxx:2068
 AliTPCcalibDB.cxx:2069
 AliTPCcalibDB.cxx:2070
 AliTPCcalibDB.cxx:2071
 AliTPCcalibDB.cxx:2072
 AliTPCcalibDB.cxx:2073
 AliTPCcalibDB.cxx:2074
 AliTPCcalibDB.cxx:2075
 AliTPCcalibDB.cxx:2076
 AliTPCcalibDB.cxx:2077
 AliTPCcalibDB.cxx:2078
 AliTPCcalibDB.cxx:2079
 AliTPCcalibDB.cxx:2080
 AliTPCcalibDB.cxx:2081
 AliTPCcalibDB.cxx:2082
 AliTPCcalibDB.cxx:2083
 AliTPCcalibDB.cxx:2084
 AliTPCcalibDB.cxx:2085
 AliTPCcalibDB.cxx:2086
 AliTPCcalibDB.cxx:2087
 AliTPCcalibDB.cxx:2088
 AliTPCcalibDB.cxx:2089
 AliTPCcalibDB.cxx:2090
 AliTPCcalibDB.cxx:2091
 AliTPCcalibDB.cxx:2092
 AliTPCcalibDB.cxx:2093
 AliTPCcalibDB.cxx:2094
 AliTPCcalibDB.cxx:2095
 AliTPCcalibDB.cxx:2096
 AliTPCcalibDB.cxx:2097
 AliTPCcalibDB.cxx:2098
 AliTPCcalibDB.cxx:2099
 AliTPCcalibDB.cxx:2100
 AliTPCcalibDB.cxx:2101
 AliTPCcalibDB.cxx:2102
 AliTPCcalibDB.cxx:2103
 AliTPCcalibDB.cxx:2104
 AliTPCcalibDB.cxx:2105
 AliTPCcalibDB.cxx:2106
 AliTPCcalibDB.cxx:2107
 AliTPCcalibDB.cxx:2108
 AliTPCcalibDB.cxx:2109
 AliTPCcalibDB.cxx:2110
 AliTPCcalibDB.cxx:2111
 AliTPCcalibDB.cxx:2112
 AliTPCcalibDB.cxx:2113
 AliTPCcalibDB.cxx:2114
 AliTPCcalibDB.cxx:2115
 AliTPCcalibDB.cxx:2116
 AliTPCcalibDB.cxx:2117
 AliTPCcalibDB.cxx:2118
 AliTPCcalibDB.cxx:2119
 AliTPCcalibDB.cxx:2120
 AliTPCcalibDB.cxx:2121
 AliTPCcalibDB.cxx:2122
 AliTPCcalibDB.cxx:2123
 AliTPCcalibDB.cxx:2124
 AliTPCcalibDB.cxx:2125
 AliTPCcalibDB.cxx:2126
 AliTPCcalibDB.cxx:2127
 AliTPCcalibDB.cxx:2128
 AliTPCcalibDB.cxx:2129
 AliTPCcalibDB.cxx:2130
 AliTPCcalibDB.cxx:2131
 AliTPCcalibDB.cxx:2132
 AliTPCcalibDB.cxx:2133
 AliTPCcalibDB.cxx:2134
 AliTPCcalibDB.cxx:2135
 AliTPCcalibDB.cxx:2136
 AliTPCcalibDB.cxx:2137
 AliTPCcalibDB.cxx:2138
 AliTPCcalibDB.cxx:2139
 AliTPCcalibDB.cxx:2140
 AliTPCcalibDB.cxx:2141
 AliTPCcalibDB.cxx:2142
 AliTPCcalibDB.cxx:2143
 AliTPCcalibDB.cxx:2144
 AliTPCcalibDB.cxx:2145
 AliTPCcalibDB.cxx:2146
 AliTPCcalibDB.cxx:2147
 AliTPCcalibDB.cxx:2148
 AliTPCcalibDB.cxx:2149
 AliTPCcalibDB.cxx:2150
 AliTPCcalibDB.cxx:2151
 AliTPCcalibDB.cxx:2152
 AliTPCcalibDB.cxx:2153
 AliTPCcalibDB.cxx:2154
 AliTPCcalibDB.cxx:2155
 AliTPCcalibDB.cxx:2156
 AliTPCcalibDB.cxx:2157
 AliTPCcalibDB.cxx:2158
 AliTPCcalibDB.cxx:2159
 AliTPCcalibDB.cxx:2160
 AliTPCcalibDB.cxx:2161
 AliTPCcalibDB.cxx:2162
 AliTPCcalibDB.cxx:2163
 AliTPCcalibDB.cxx:2164
 AliTPCcalibDB.cxx:2165
 AliTPCcalibDB.cxx:2166
 AliTPCcalibDB.cxx:2167
 AliTPCcalibDB.cxx:2168
 AliTPCcalibDB.cxx:2169
 AliTPCcalibDB.cxx:2170
 AliTPCcalibDB.cxx:2171
 AliTPCcalibDB.cxx:2172
 AliTPCcalibDB.cxx:2173
 AliTPCcalibDB.cxx:2174
 AliTPCcalibDB.cxx:2175
 AliTPCcalibDB.cxx:2176
 AliTPCcalibDB.cxx:2177
 AliTPCcalibDB.cxx:2178
 AliTPCcalibDB.cxx:2179
 AliTPCcalibDB.cxx:2180
 AliTPCcalibDB.cxx:2181
 AliTPCcalibDB.cxx:2182
 AliTPCcalibDB.cxx:2183
 AliTPCcalibDB.cxx:2184
 AliTPCcalibDB.cxx:2185
 AliTPCcalibDB.cxx:2186
 AliTPCcalibDB.cxx:2187
 AliTPCcalibDB.cxx:2188
 AliTPCcalibDB.cxx:2189
 AliTPCcalibDB.cxx:2190
 AliTPCcalibDB.cxx:2191
 AliTPCcalibDB.cxx:2192
 AliTPCcalibDB.cxx:2193
 AliTPCcalibDB.cxx:2194
 AliTPCcalibDB.cxx:2195
 AliTPCcalibDB.cxx:2196
 AliTPCcalibDB.cxx:2197
 AliTPCcalibDB.cxx:2198
 AliTPCcalibDB.cxx:2199
 AliTPCcalibDB.cxx:2200
 AliTPCcalibDB.cxx:2201
 AliTPCcalibDB.cxx:2202
 AliTPCcalibDB.cxx:2203
 AliTPCcalibDB.cxx:2204
 AliTPCcalibDB.cxx:2205
 AliTPCcalibDB.cxx:2206
 AliTPCcalibDB.cxx:2207
 AliTPCcalibDB.cxx:2208
 AliTPCcalibDB.cxx:2209
 AliTPCcalibDB.cxx:2210
 AliTPCcalibDB.cxx:2211
 AliTPCcalibDB.cxx:2212
 AliTPCcalibDB.cxx:2213
 AliTPCcalibDB.cxx:2214
 AliTPCcalibDB.cxx:2215
 AliTPCcalibDB.cxx:2216
 AliTPCcalibDB.cxx:2217
 AliTPCcalibDB.cxx:2218
 AliTPCcalibDB.cxx:2219
 AliTPCcalibDB.cxx:2220
 AliTPCcalibDB.cxx:2221
 AliTPCcalibDB.cxx:2222
 AliTPCcalibDB.cxx:2223
 AliTPCcalibDB.cxx:2224
 AliTPCcalibDB.cxx:2225
 AliTPCcalibDB.cxx:2226
 AliTPCcalibDB.cxx:2227
 AliTPCcalibDB.cxx:2228
 AliTPCcalibDB.cxx:2229
 AliTPCcalibDB.cxx:2230
 AliTPCcalibDB.cxx:2231
 AliTPCcalibDB.cxx:2232
 AliTPCcalibDB.cxx:2233
 AliTPCcalibDB.cxx:2234
 AliTPCcalibDB.cxx:2235
 AliTPCcalibDB.cxx:2236
 AliTPCcalibDB.cxx:2237
 AliTPCcalibDB.cxx:2238
 AliTPCcalibDB.cxx:2239
 AliTPCcalibDB.cxx:2240
 AliTPCcalibDB.cxx:2241
 AliTPCcalibDB.cxx:2242
 AliTPCcalibDB.cxx:2243
 AliTPCcalibDB.cxx:2244
 AliTPCcalibDB.cxx:2245
 AliTPCcalibDB.cxx:2246
 AliTPCcalibDB.cxx:2247
 AliTPCcalibDB.cxx:2248
 AliTPCcalibDB.cxx:2249
 AliTPCcalibDB.cxx:2250
 AliTPCcalibDB.cxx:2251
 AliTPCcalibDB.cxx:2252
 AliTPCcalibDB.cxx:2253
 AliTPCcalibDB.cxx:2254
 AliTPCcalibDB.cxx:2255
 AliTPCcalibDB.cxx:2256
 AliTPCcalibDB.cxx:2257
 AliTPCcalibDB.cxx:2258
 AliTPCcalibDB.cxx:2259
 AliTPCcalibDB.cxx:2260
 AliTPCcalibDB.cxx:2261
 AliTPCcalibDB.cxx:2262
 AliTPCcalibDB.cxx:2263
 AliTPCcalibDB.cxx:2264
 AliTPCcalibDB.cxx:2265
 AliTPCcalibDB.cxx:2266
 AliTPCcalibDB.cxx:2267
 AliTPCcalibDB.cxx:2268
 AliTPCcalibDB.cxx:2269
 AliTPCcalibDB.cxx:2270
 AliTPCcalibDB.cxx:2271
 AliTPCcalibDB.cxx:2272
 AliTPCcalibDB.cxx:2273
 AliTPCcalibDB.cxx:2274
 AliTPCcalibDB.cxx:2275
 AliTPCcalibDB.cxx:2276
 AliTPCcalibDB.cxx:2277
 AliTPCcalibDB.cxx:2278
 AliTPCcalibDB.cxx:2279
 AliTPCcalibDB.cxx:2280
 AliTPCcalibDB.cxx:2281
 AliTPCcalibDB.cxx:2282
 AliTPCcalibDB.cxx:2283
 AliTPCcalibDB.cxx:2284
 AliTPCcalibDB.cxx:2285
 AliTPCcalibDB.cxx:2286
 AliTPCcalibDB.cxx:2287
 AliTPCcalibDB.cxx:2288
 AliTPCcalibDB.cxx:2289
 AliTPCcalibDB.cxx:2290
 AliTPCcalibDB.cxx:2291
 AliTPCcalibDB.cxx:2292
 AliTPCcalibDB.cxx:2293
 AliTPCcalibDB.cxx:2294
 AliTPCcalibDB.cxx:2295
 AliTPCcalibDB.cxx:2296
 AliTPCcalibDB.cxx:2297
 AliTPCcalibDB.cxx:2298
 AliTPCcalibDB.cxx:2299
 AliTPCcalibDB.cxx:2300
 AliTPCcalibDB.cxx:2301
 AliTPCcalibDB.cxx:2302
 AliTPCcalibDB.cxx:2303
 AliTPCcalibDB.cxx:2304
 AliTPCcalibDB.cxx:2305
 AliTPCcalibDB.cxx:2306
 AliTPCcalibDB.cxx:2307
 AliTPCcalibDB.cxx:2308
 AliTPCcalibDB.cxx:2309
 AliTPCcalibDB.cxx:2310
 AliTPCcalibDB.cxx:2311
 AliTPCcalibDB.cxx:2312
 AliTPCcalibDB.cxx:2313
 AliTPCcalibDB.cxx:2314
 AliTPCcalibDB.cxx:2315
 AliTPCcalibDB.cxx:2316
 AliTPCcalibDB.cxx:2317
 AliTPCcalibDB.cxx:2318
 AliTPCcalibDB.cxx:2319
 AliTPCcalibDB.cxx:2320
 AliTPCcalibDB.cxx:2321
 AliTPCcalibDB.cxx:2322
 AliTPCcalibDB.cxx:2323
 AliTPCcalibDB.cxx:2324
 AliTPCcalibDB.cxx:2325
 AliTPCcalibDB.cxx:2326
 AliTPCcalibDB.cxx:2327
 AliTPCcalibDB.cxx:2328
 AliTPCcalibDB.cxx:2329
 AliTPCcalibDB.cxx:2330
 AliTPCcalibDB.cxx:2331
 AliTPCcalibDB.cxx:2332
 AliTPCcalibDB.cxx:2333
 AliTPCcalibDB.cxx:2334
 AliTPCcalibDB.cxx:2335
 AliTPCcalibDB.cxx:2336
 AliTPCcalibDB.cxx:2337
 AliTPCcalibDB.cxx:2338
 AliTPCcalibDB.cxx:2339
 AliTPCcalibDB.cxx:2340
 AliTPCcalibDB.cxx:2341
 AliTPCcalibDB.cxx:2342
 AliTPCcalibDB.cxx:2343
 AliTPCcalibDB.cxx:2344
 AliTPCcalibDB.cxx:2345
 AliTPCcalibDB.cxx:2346
 AliTPCcalibDB.cxx:2347
 AliTPCcalibDB.cxx:2348
 AliTPCcalibDB.cxx:2349
 AliTPCcalibDB.cxx:2350
 AliTPCcalibDB.cxx:2351
 AliTPCcalibDB.cxx:2352
 AliTPCcalibDB.cxx:2353
 AliTPCcalibDB.cxx:2354
 AliTPCcalibDB.cxx:2355
 AliTPCcalibDB.cxx:2356
 AliTPCcalibDB.cxx:2357
 AliTPCcalibDB.cxx:2358
 AliTPCcalibDB.cxx:2359
 AliTPCcalibDB.cxx:2360
 AliTPCcalibDB.cxx:2361
 AliTPCcalibDB.cxx:2362
 AliTPCcalibDB.cxx:2363
 AliTPCcalibDB.cxx:2364
 AliTPCcalibDB.cxx:2365
 AliTPCcalibDB.cxx:2366
 AliTPCcalibDB.cxx:2367
 AliTPCcalibDB.cxx:2368
 AliTPCcalibDB.cxx:2369
 AliTPCcalibDB.cxx:2370
 AliTPCcalibDB.cxx:2371
 AliTPCcalibDB.cxx:2372
 AliTPCcalibDB.cxx:2373
 AliTPCcalibDB.cxx:2374
 AliTPCcalibDB.cxx:2375
 AliTPCcalibDB.cxx:2376
 AliTPCcalibDB.cxx:2377
 AliTPCcalibDB.cxx:2378
 AliTPCcalibDB.cxx:2379
 AliTPCcalibDB.cxx:2380
 AliTPCcalibDB.cxx:2381
 AliTPCcalibDB.cxx:2382
 AliTPCcalibDB.cxx:2383
 AliTPCcalibDB.cxx:2384
 AliTPCcalibDB.cxx:2385
 AliTPCcalibDB.cxx:2386
 AliTPCcalibDB.cxx:2387
 AliTPCcalibDB.cxx:2388
 AliTPCcalibDB.cxx:2389
 AliTPCcalibDB.cxx:2390
 AliTPCcalibDB.cxx:2391
 AliTPCcalibDB.cxx:2392
 AliTPCcalibDB.cxx:2393
 AliTPCcalibDB.cxx:2394
 AliTPCcalibDB.cxx:2395
 AliTPCcalibDB.cxx:2396
 AliTPCcalibDB.cxx:2397
 AliTPCcalibDB.cxx:2398
 AliTPCcalibDB.cxx:2399
 AliTPCcalibDB.cxx:2400
 AliTPCcalibDB.cxx:2401
 AliTPCcalibDB.cxx:2402
 AliTPCcalibDB.cxx:2403
 AliTPCcalibDB.cxx:2404
 AliTPCcalibDB.cxx:2405
 AliTPCcalibDB.cxx:2406
 AliTPCcalibDB.cxx:2407
 AliTPCcalibDB.cxx:2408
 AliTPCcalibDB.cxx:2409
 AliTPCcalibDB.cxx:2410
 AliTPCcalibDB.cxx:2411
 AliTPCcalibDB.cxx:2412
 AliTPCcalibDB.cxx:2413
 AliTPCcalibDB.cxx:2414
 AliTPCcalibDB.cxx:2415
 AliTPCcalibDB.cxx:2416
 AliTPCcalibDB.cxx:2417
 AliTPCcalibDB.cxx:2418
 AliTPCcalibDB.cxx:2419
 AliTPCcalibDB.cxx:2420
 AliTPCcalibDB.cxx:2421
 AliTPCcalibDB.cxx:2422
 AliTPCcalibDB.cxx:2423
 AliTPCcalibDB.cxx:2424
 AliTPCcalibDB.cxx:2425
 AliTPCcalibDB.cxx:2426
 AliTPCcalibDB.cxx:2427
 AliTPCcalibDB.cxx:2428
 AliTPCcalibDB.cxx:2429
 AliTPCcalibDB.cxx:2430
 AliTPCcalibDB.cxx:2431
 AliTPCcalibDB.cxx:2432
 AliTPCcalibDB.cxx:2433
 AliTPCcalibDB.cxx:2434
 AliTPCcalibDB.cxx:2435
 AliTPCcalibDB.cxx:2436
 AliTPCcalibDB.cxx:2437
 AliTPCcalibDB.cxx:2438
 AliTPCcalibDB.cxx:2439
 AliTPCcalibDB.cxx:2440
 AliTPCcalibDB.cxx:2441
 AliTPCcalibDB.cxx:2442
 AliTPCcalibDB.cxx:2443
 AliTPCcalibDB.cxx:2444
 AliTPCcalibDB.cxx:2445
 AliTPCcalibDB.cxx:2446
 AliTPCcalibDB.cxx:2447
 AliTPCcalibDB.cxx:2448
 AliTPCcalibDB.cxx:2449
 AliTPCcalibDB.cxx:2450
 AliTPCcalibDB.cxx:2451
 AliTPCcalibDB.cxx:2452
 AliTPCcalibDB.cxx:2453
 AliTPCcalibDB.cxx:2454
 AliTPCcalibDB.cxx:2455
 AliTPCcalibDB.cxx:2456
 AliTPCcalibDB.cxx:2457
 AliTPCcalibDB.cxx:2458
 AliTPCcalibDB.cxx:2459
 AliTPCcalibDB.cxx:2460
 AliTPCcalibDB.cxx:2461
 AliTPCcalibDB.cxx:2462
 AliTPCcalibDB.cxx:2463
 AliTPCcalibDB.cxx:2464
 AliTPCcalibDB.cxx:2465
 AliTPCcalibDB.cxx:2466
 AliTPCcalibDB.cxx:2467
 AliTPCcalibDB.cxx:2468
 AliTPCcalibDB.cxx:2469
 AliTPCcalibDB.cxx:2470
 AliTPCcalibDB.cxx:2471
 AliTPCcalibDB.cxx:2472
 AliTPCcalibDB.cxx:2473
 AliTPCcalibDB.cxx:2474
 AliTPCcalibDB.cxx:2475
 AliTPCcalibDB.cxx:2476
 AliTPCcalibDB.cxx:2477
 AliTPCcalibDB.cxx:2478
 AliTPCcalibDB.cxx:2479
 AliTPCcalibDB.cxx:2480
 AliTPCcalibDB.cxx:2481
 AliTPCcalibDB.cxx:2482
 AliTPCcalibDB.cxx:2483
 AliTPCcalibDB.cxx:2484
 AliTPCcalibDB.cxx:2485
 AliTPCcalibDB.cxx:2486
 AliTPCcalibDB.cxx:2487
 AliTPCcalibDB.cxx:2488
 AliTPCcalibDB.cxx:2489
 AliTPCcalibDB.cxx:2490
 AliTPCcalibDB.cxx:2491
 AliTPCcalibDB.cxx:2492
 AliTPCcalibDB.cxx:2493
 AliTPCcalibDB.cxx:2494
 AliTPCcalibDB.cxx:2495
 AliTPCcalibDB.cxx:2496
 AliTPCcalibDB.cxx:2497
 AliTPCcalibDB.cxx:2498
 AliTPCcalibDB.cxx:2499
 AliTPCcalibDB.cxx:2500
 AliTPCcalibDB.cxx:2501
 AliTPCcalibDB.cxx:2502
 AliTPCcalibDB.cxx:2503
 AliTPCcalibDB.cxx:2504
 AliTPCcalibDB.cxx:2505
 AliTPCcalibDB.cxx:2506
 AliTPCcalibDB.cxx:2507
 AliTPCcalibDB.cxx:2508
 AliTPCcalibDB.cxx:2509
 AliTPCcalibDB.cxx:2510
 AliTPCcalibDB.cxx:2511
 AliTPCcalibDB.cxx:2512
 AliTPCcalibDB.cxx:2513
 AliTPCcalibDB.cxx:2514
 AliTPCcalibDB.cxx:2515
 AliTPCcalibDB.cxx:2516
 AliTPCcalibDB.cxx:2517
 AliTPCcalibDB.cxx:2518
 AliTPCcalibDB.cxx:2519
 AliTPCcalibDB.cxx:2520
 AliTPCcalibDB.cxx:2521
 AliTPCcalibDB.cxx:2522
 AliTPCcalibDB.cxx:2523
 AliTPCcalibDB.cxx:2524
 AliTPCcalibDB.cxx:2525
 AliTPCcalibDB.cxx:2526
 AliTPCcalibDB.cxx:2527
 AliTPCcalibDB.cxx:2528
 AliTPCcalibDB.cxx:2529
 AliTPCcalibDB.cxx:2530
 AliTPCcalibDB.cxx:2531
 AliTPCcalibDB.cxx:2532
 AliTPCcalibDB.cxx:2533
 AliTPCcalibDB.cxx:2534
 AliTPCcalibDB.cxx:2535
 AliTPCcalibDB.cxx:2536
 AliTPCcalibDB.cxx:2537
 AliTPCcalibDB.cxx:2538
 AliTPCcalibDB.cxx:2539
 AliTPCcalibDB.cxx:2540
 AliTPCcalibDB.cxx:2541
 AliTPCcalibDB.cxx:2542
 AliTPCcalibDB.cxx:2543
 AliTPCcalibDB.cxx:2544
 AliTPCcalibDB.cxx:2545
 AliTPCcalibDB.cxx:2546
 AliTPCcalibDB.cxx:2547
 AliTPCcalibDB.cxx:2548
 AliTPCcalibDB.cxx:2549
 AliTPCcalibDB.cxx:2550
 AliTPCcalibDB.cxx:2551
 AliTPCcalibDB.cxx:2552
 AliTPCcalibDB.cxx:2553
 AliTPCcalibDB.cxx:2554
 AliTPCcalibDB.cxx:2555
 AliTPCcalibDB.cxx:2556
 AliTPCcalibDB.cxx:2557
 AliTPCcalibDB.cxx:2558
 AliTPCcalibDB.cxx:2559
 AliTPCcalibDB.cxx:2560
 AliTPCcalibDB.cxx:2561
 AliTPCcalibDB.cxx:2562
 AliTPCcalibDB.cxx:2563
 AliTPCcalibDB.cxx:2564
 AliTPCcalibDB.cxx:2565
 AliTPCcalibDB.cxx:2566
 AliTPCcalibDB.cxx:2567
 AliTPCcalibDB.cxx:2568
 AliTPCcalibDB.cxx:2569
 AliTPCcalibDB.cxx:2570
 AliTPCcalibDB.cxx:2571
 AliTPCcalibDB.cxx:2572
 AliTPCcalibDB.cxx:2573
 AliTPCcalibDB.cxx:2574
 AliTPCcalibDB.cxx:2575
 AliTPCcalibDB.cxx:2576
 AliTPCcalibDB.cxx:2577
 AliTPCcalibDB.cxx:2578
 AliTPCcalibDB.cxx:2579
 AliTPCcalibDB.cxx:2580
 AliTPCcalibDB.cxx:2581
 AliTPCcalibDB.cxx:2582
 AliTPCcalibDB.cxx:2583
 AliTPCcalibDB.cxx:2584
 AliTPCcalibDB.cxx:2585
 AliTPCcalibDB.cxx:2586
 AliTPCcalibDB.cxx:2587
 AliTPCcalibDB.cxx:2588
 AliTPCcalibDB.cxx:2589
 AliTPCcalibDB.cxx:2590
 AliTPCcalibDB.cxx:2591
 AliTPCcalibDB.cxx:2592
 AliTPCcalibDB.cxx:2593
 AliTPCcalibDB.cxx:2594
 AliTPCcalibDB.cxx:2595
 AliTPCcalibDB.cxx:2596
 AliTPCcalibDB.cxx:2597
 AliTPCcalibDB.cxx:2598
 AliTPCcalibDB.cxx:2599
 AliTPCcalibDB.cxx:2600
 AliTPCcalibDB.cxx:2601
 AliTPCcalibDB.cxx:2602
 AliTPCcalibDB.cxx:2603
 AliTPCcalibDB.cxx:2604
 AliTPCcalibDB.cxx:2605
 AliTPCcalibDB.cxx:2606
 AliTPCcalibDB.cxx:2607
 AliTPCcalibDB.cxx:2608