/*
// Make a summary information of calibration.
// Store results in the summary trees
// OCDB configuration

gSystem->AddIncludePath("-I$ALICE_ROOT/TPC");
.L $ALICE_ROOT/TPC/AliTPCcalibSummary.cxx+

AliTPCcalibSummary calib;
calib.Procces("run.list",run0,run1);


*/

#include <TROOT.h>
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <AliCDBManager.h>
#include <AliCDBEntry.h>
#include <AliLog.h>
#include <AliMagF.h>
#include "AliTPCcalibDB.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 "TFile.h"
#include "TKey.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TString.h"
#include "AliTPCCalPad.h"
#include "AliTPCROC.h"
#include "AliTPCParam.h"
#include "AliTPCCalibPulser.h"
#include "AliTPCCalibPedestal.h"
#include "AliTPCCalibCE.h"
#include "AliTPCExBFirst.h"
#include "TTreeStream.h"
#include "AliTPCTempMap.h"
#include "TVectorD.h"
#include "TMatrixD.h"
#include "AliTPCCalibRaw.h"
#include "AliSplineFit.h"
#include "TGraphErrors.h"
#include <AliCTPTimeParams.h>
#include <AliTPCcalibSummary.h>
//
//
//
AliTPCcalibSummary::AliTPCcalibSummary():
  TNamed(),
  fCalibDB(0),
  fDButil(0),
  fPcstream(0)
{
  //
  // default constructor
  // OCDB have to be setupe before - not part of class
  // usualy ConfigOCDB.C macro used
  // 
  fPcstream = new TTreeSRedirector("dcsTime.root");
  fCalibDB = AliTPCcalibDB::Instance();
  fDButil= new AliTPCcalibDButil;
}

AliTPCcalibSummary::~AliTPCcalibSummary(){
  //
  // destructor  - close streamer
  //
  delete fPcstream;  
}

void AliTPCcalibSummary::Process(const char * runList, Int_t first, Int_t last){
  //
  // runList - listOfRuns to process
  // first   - first run to process
  // last    - last  to process
  // 
  //
  // make list of runs
  //

  ifstream inputFile;
  inputFile.open("run.list");
  Int_t irun=0;
  TArrayI runArray(100000);
  Int_t indexes[100000];
  Int_t nruns=0;
  printf("Runs to process:\n");
  if (!inputFile.is_open()) { 
    printf("Problem to open file %s\n",runList);
  }
  while( inputFile.good() ) {
    inputFile >> irun;
    printf("Run \t%d\n",irun);
    if (irun<first) continue;  // process only subset of list
    if (last>0 && irun>last) continue;  // process only subset of list
    runArray[nruns]=irun;
    nruns++;
  }


  TMath::Sort(nruns, runArray.fArray, indexes,kFALSE);
  Int_t startTime = 0;
  Int_t endTime   = 0;
  for (Int_t run=0; run<nruns; run++){
    irun=runArray[indexes[run]];
    printf("Processing run %d ...\n",irun);
    fCalibDB->SetRun(irun);
    fDButil->UpdateFromCalibDB();
    fDButil->SetReferenceRun(irun);
    fDButil->UpdateRefDataFromOCDB();
    //
    AliDCSSensorArray *arrHV=fCalibDB->GetVoltageSensors(irun);
    if (!arrHV) continue;
    for  (Int_t isenHV=0; isenHV<arrHV->NumSensors(); ++isenHV){
      AliDCSSensor *senHV=arrHV->GetSensorNum(isenHV);
      if (!senHV) {
	printf("Not interesting OCDB info\n");
	continue;
      }
      startTime=senHV->GetStartTime();
      endTime  =senHV->GetEndTime();
      if (startTime>0&&endTime>0) break;
    }
    AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun);	
    if (goofieArray) fDButil->FilterGoofie(goofieArray,0.5,4.,6.85,7.05,fPcstream);
    // don't filter goofie for the moment
    ProcessRun(irun, startTime,endTime);
  }
}


void AliTPCcalibSummary::ProcessRun(Int_t irun, Int_t startTime, Int_t endTime){
  //
  // Process run irun
  // 
  fCalibDB->SetRun(irun);
  fDButil->UpdateFromCalibDB();
  fDButil->SetReferenceRun(irun);
  fDButil->UpdateRefDataFromOCDB();
  //
  AliSplineFit *fitVdrift=0x0;
  Int_t startTimeGRP=0, stopTimeGRP=0;
  if (fCalibDB->GetGRP(irun)){
    startTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeStart();
    stopTimeGRP  = AliTPCcalibDB::GetGRP(irun)->GetTimeEnd();
  }
  if (startTime==0){
    startTime=startTimeGRP;
    endTime=stopTimeGRP;
  }
  AliTPCSensorTempArray * tempArray = fCalibDB->GetTemperatureSensor(irun);
  AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
  AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun);
  //
  Int_t dtime = TMath::Max((endTime-startTime)/20,10*60);
  //
  //Goofie statistical data
  //
  TVectorD vecEntries, vecMean, vecMedian,vecRMS;
  fDButil->ProcessGoofie(vecEntries ,vecMedian, vecMean, vecRMS);
  //
  //CE data processing - see ProcessCEdata function for description of the results
  //
  TVectorD fitResultsA, fitResultsC;
  Int_t nmaskedCE;
  Double_t chi2ACE=0,chi2CCE=0;
  //     fDButil->ProcessCEdata("(sector<36)++gx++gy++lx++lx**2",fitResultsA,fitResultsC,nmaskedCE);
  fDButil->ProcessCEdata("(sector<36)++gx++gy++(lx-134)++(sector<36)*(lx-134)++(ly/lx)^2",fitResultsA,fitResultsC,nmaskedCE,chi2ACE,chi2CCE);

  TVectorD fitCEResultsA(7), fitCEResultsC(7);
  Int_t    noutCE;
  Double_t chi2CEA=0,chi2CEC=0;
  AliTPCCalPad *time0 = fDButil->CreatePadTime0CE(fitCEResultsA, fitCEResultsC, noutCE, chi2CEA, chi2CEC);
  delete time0;
  //  
  //
  TVectorD vecTEntries, vecTMean, vecTRMS, vecTMedian, vecQEntries, vecQMean, vecQRMS, vecQMedian;
  Float_t driftTimeA, driftTimeC;
  fDButil->ProcessCEgraphs(vecTEntries, vecTMean, vecTRMS, vecTMedian,
			  vecQEntries, vecQMean, vecQRMS, vecQMedian,
			  driftTimeA, driftTimeC );
  //
  //
  //
  //drift velocity using tracks
  //
  //     fitVdrift=fCalibDB->GetVdriftSplineFit("ALISPLINEFIT_MEAN_VDRIFT_COSMICS_ALL",irun);
  fitVdrift=fCalibDB->CreateVdriftSplineFit("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL",irun);
  //noise data Processing - see ProcessNoiseData function for description of the results
  TVectorD vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions;
  Int_t nonMaskedZero=0, nNaN=0;
  fDButil->ProcessNoiseData(vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions, nonMaskedZero, nNaN);
  //
  // comparisons
  //
  TVectorF pedestalDeviations;
  TVectorF noiseDeviations;
  TVectorF pulserQdeviations;
  Float_t varQMean;
  Int_t npadsOutOneTB;
  Int_t npadsOffAdd;
  fDButil->ProcessPedestalVariations(pedestalDeviations);
  fDButil->ProcessNoiseVariations(noiseDeviations);
  fDButil->ProcessPulserVariations(pulserQdeviations,varQMean,npadsOutOneTB,npadsOffAdd);
  //
  //L3 data 
  //
  Float_t bz=AliTPCcalibDB::GetBz(irun);
  Char_t  l3pol=AliTPCcalibDB::GetL3Polarity(irun);
  //
  //calibration Pulser data processing
  //
  Int_t nOffChannels=0;
  TVectorD vTimePulser;
  nOffChannels=fDButil->GetNPulserOutliers();
  fDButil->ProcessPulser(vTimePulser);
  //
  //ALTRO data
  //
  Int_t nMasked=0;
  fDButil->ProcessALTROConfig(nMasked);
  //
  //Calib RAW data
  //
  Int_t nFailL1=-1;
  if (fCalibDB->GetCalibRaw()) nFailL1=fCalibDB->GetCalibRaw()->GetNFailL1Phase();
  //
  //production information
  //
  Int_t nalien=0,nRawAlien=0,nlocal=0,nRawLocal=0;
  //run type
  TObjString runType(AliTPCcalibDB::GetRunType(irun).Data());
  //
  //
  //
  
  for (Int_t itime=startTime; itime<endTime; itime+=dtime){
    //
    TTimeStamp tstamp(itime);
    Float_t valuePressure  = fCalibDB->GetPressure(tstamp,irun,0);
    Float_t valuePressure2 = fCalibDB->GetPressure(tstamp,irun,1);
    Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,0);
    Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,1);
    //temperature fits
    TLinearFitter * fitter = 0;
    TVectorD vecTemp[10];
    for (Int_t itype=0; itype<5; itype++)
      for (Int_t iside=0; iside<2; iside++){
	fitter= tempMap->GetLinearFitter(itype,iside,tstamp);	  
	if (!fitter) continue;
	fitter->Eval();
	fitter->GetParameters(vecTemp[itype+iside*5]);
	delete fitter;
      }
    //
    //measured skirt temperatures
    //
    TVectorD vecSkirtTempA(18);
    TVectorD vecSkirtTempC(18);
    Int_t nsenTemp=tempArray->NumSensors();
    for (Int_t isenTemp=0;isenTemp<nsenTemp;++isenTemp){
      AliTPCSensorTemp *senTemp=(AliTPCSensorTemp*)tempArray->GetSensorNum(isenTemp);
      if (senTemp->GetType()!=3) continue;
      if (TMath::Sqrt(senTemp->GetX()*senTemp->GetX()+senTemp->GetY()*senTemp->GetY())<100) continue; //only skirt, outer FC vessel
      Double_t val=senTemp->GetValue(tstamp);
      if (senTemp->GetSide()==0)
	vecSkirtTempA[senTemp->GetSector()]=val;
      else
	vecSkirtTempC[senTemp->GetSector()]=val;
    }
    //
    //goofie data
    //
    TVectorD vecGoofie; 
    if (goofieArray){
      vecGoofie.ResizeTo(goofieArray->NumSensors());
      for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){
	AliDCSSensor *gsensor = goofieArray->GetSensor(isensor);
	if (gsensor){
	  vecGoofie[isensor] = gsensor->GetValue(tstamp);
	}
      }
    } else {
      vecGoofie.ResizeTo(19);
    }
    //
    TVectorD voltagesIROC(36);
    TVectorD voltagesOROC(36);
    for(Int_t j=1; j<36; j++) voltagesIROC[j-1] = fCalibDB->GetChamberHighVoltage(irun, j,itime);
    for(Int_t j=36; j<72; j++) voltagesOROC[j-36] = fCalibDB->GetChamberHighVoltage(irun, j,itime);
    Double_t voltIROC = TMath::Median(36, voltagesIROC.GetMatrixArray());
    Double_t voltOROC = TMath::Median(36, voltagesOROC.GetMatrixArray());
    //
    Float_t  coverIA=AliTPCcalibDB::GetCoverVoltage(irun,0,itime);
    Float_t  coverIC=AliTPCcalibDB::GetCoverVoltage(irun,18,itime);
    Float_t  coverOA=AliTPCcalibDB::GetCoverVoltage(irun,36,itime);
    Float_t  coverOC=AliTPCcalibDB::GetCoverVoltage(irun,54,itime);
    Float_t  skirtA=AliTPCcalibDB::GetSkirtVoltage(irun,0,itime);
    Float_t  skirtC=AliTPCcalibDB::GetSkirtVoltage(irun,18,itime);
    Float_t  ggOffA=AliTPCcalibDB::GetGGoffsetVoltage(irun,0,itime);
    Float_t  ggOffC=AliTPCcalibDB::GetGGoffsetVoltage(irun,18,itime);
    //drift velocity
    Float_t dvCorr=-5;
    if (fitVdrift) dvCorr=fitVdrift->Eval(itime);
    
    //tempMap->GetLinearFitter(0,0,itime);
    (*fPcstream)<<"dcs"<<
      "run="<<irun<<
      "time="<<itime<<
      "startTimeGRP="<<startTimeGRP<<
      "stopTimeGRP="<<stopTimeGRP<<
      //run type
      "runType.="<<&runType<<
      // voltage setting
      "VIROC.="<<&voltagesIROC<<
      "VOROC.="<<&voltagesOROC<<
      "medianVIROC="<<voltIROC<<
      "medianVOROC="<<voltOROC<<
      "coverIA=" << coverIA <<
      "coverIC=" << coverIC <<
      "coverOA=" << coverOA <<
      "coverOC=" << coverOC <<
      "skirtA=" << skirtA <<
      "skirtC=" << skirtC <<
      "ggOffA=" << ggOffA <<
      "ggOffC=" << ggOffC <<
      //
      "ptrel0="<<ptrelative0<<  // deltaTP/TP  - A side
      "ptrel1="<<ptrelative1<<  // deltaTP/TPC - C side
      "goofie.="<<&vecGoofie<<
      "goofieE.="<<&vecEntries<<
      "goofieMean.="<<&vecMean<<
      "goofieMedian.="<<&vecMedian<<
      "goofieRMS.="<<&vecRMS<<
      //
      "press="<<valuePressure<<
      "press2="<<valuePressure2<<
      "temp00.="<<&vecTemp[0]<<
      "temp10.="<<&vecTemp[1]<<
      "temp20.="<<&vecTemp[2]<<
      "temp30.="<<&vecTemp[3]<<
      "temp40.="<<&vecTemp[4]<<
      "temp01.="<<&vecTemp[5]<<
      "temp11.="<<&vecTemp[6]<<
      "temp21.="<<&vecTemp[7]<<
      "temp31.="<<&vecTemp[8]<<
      "temp41.="<<&vecTemp[9]<<
      "tempSkirtA.="<<&vecSkirtTempA<<
      "tempSkirtC.="<<&vecSkirtTempC;

    ProcessDrift(irun, itime);
    ProcessDriftCE(irun,itime);
    ProcessDriftAll(irun,itime);
    ProcessKryptonTime(irun,itime);
    ProcessCTP(irun,itime);
    ProcessAlign(irun,itime);
    ProcessGain(irun,itime);


    (*fPcstream)<<"dcs"<<	
      //noise data
      "meanNoise.="<<&vNoiseMean<<
      "meanNoiseSen.="<<&vNoiseMeanSenRegions<<
      "rmsNoise.="<<&vNoiseRMS<<
      "rmsNoiseSen.="<<&vNoiseRMSSenRegions<<
      "zeroNoise="<<nonMaskedZero<<
      "nNaN="<<nNaN<<
      //pulser data
      "timePulser.=" << &vTimePulser <<
      "nOffPulser="<<nOffChannels<<
      //altro data
      "nMasked="<<nMasked<<
      //ce data -Jens version
      "CEfitA.="<<&fitResultsA<<
      "CEfitC.="<<&fitResultsC<<
      "nmaskedCE="<<nmaskedCE<<
      "chi2ACE="<<chi2ACE<<
      "chi2CCE="<<chi2CCE<<
      //ce data new - MI version
      "CEfitAMI.="<<&fitCEResultsA<<
      "CEfitCMI.="<<&fitCEResultsC<<
      "chi2CEA="<<chi2CEA<<
      "chi2CEC="<<chi2CEC<<
      //
      //ce graph data
      "CEgrTEntries.="<<&vecTEntries<<
      "CEgrTMean.="<<&vecTMean<<
      "CEgrTRMS.="<<&vecTRMS<<
      "CEgrTMedian.="<<&vecTMedian<<
      "CEgrQEntries.="<<&vecQEntries<<
      "CEgrQMean.="<<&vecQMean<<
      "CEgrQRMS.="<<&vecQRMS<<
      "CEgrQMedian.="<<&vecQMedian<<
      "CEgrDriftA="<<driftTimeA<<
      "CEgrDriftC="<<driftTimeC<<
      //calib raw data
      "nFailL1="<<nFailL1<<
      // b field
      "Bz="<< bz <<
      "L3polarity="<<l3pol<<
      // production information
      "nalien="<<nalien<<
      "nRawAlien="<<nRawAlien<<
      "nlocal="<<nlocal<<
      "nRawLocal="<<nRawLocal<<
      //comparisons with ref data
      "pedestalDeviations.="<<&pedestalDeviations<<
      "noiseDeviations.="<<&noiseDeviations<<
      "pulserQdeviations.="<<&pulserQdeviations<<
      //         "pulserVarQMean="<<varQMean<<
      "pulserNpadsOutOneTB="<<npadsOutOneTB<<
      "pulserNpadsOffAdd="<<npadsOffAdd<<
      "driftCorrCosmAll="<<dvCorr<<
      "\n";
  }//end run loop
}






void AliTPCcalibSummary::ProcessDrift(Int_t run, Int_t timeStamp){
  //
  // dump drift calibration data to the tree
  //
  TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
  TGraphErrors *laserA[3]={0,0,0};
  TGraphErrors *laserC[3]={0,0,0};
  TGraphErrors *cosmicAll=0;
  static Double_t     vlaserA[3]={0,0,0};
  static Double_t     vlaserC[3]={0,0,0};
  static Double_t     vcosmicAll=0;
  static Double_t     vdrift1=0;
  vdrift1=fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);

  if (array){
    laserA[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_A");
    laserA[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A");
    laserA[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A");
    laserC[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_C");
    laserC[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C");
    laserC[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C");
    cosmicAll =(TGraphErrors*)array->FindObject("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL");
  }
  if (laserA[0]) vlaserA[0]= AliTPCcalibDButil::EvalGraphConst(laserA[0],timeStamp);
  if (laserA[1]) vlaserA[1]= AliTPCcalibDButil::EvalGraphConst(laserA[1],timeStamp);
  if (laserA[2]) vlaserA[2]= AliTPCcalibDButil::EvalGraphConst(laserA[2],timeStamp);
  if (laserC[0]) vlaserC[0]= AliTPCcalibDButil::EvalGraphConst(laserC[0],timeStamp);
  if (laserC[1]) vlaserC[1]= AliTPCcalibDButil::EvalGraphConst(laserC[1],timeStamp);
  if (laserC[2]) vlaserC[2]= AliTPCcalibDButil::EvalGraphConst(laserC[2],timeStamp);
  if (cosmicAll) vcosmicAll= AliTPCcalibDButil::EvalGraphConst(cosmicAll,timeStamp); 
  (*fPcstream)<<"dcs"<<
    "vlaserA0="<<vlaserA[0]<<
    "vlaserA1="<<vlaserA[1]<<
    "vlaserA2="<<vlaserA[2]<<
    "vlaserC0="<<vlaserC[0]<<
    "vlaserC1="<<vlaserC[1]<<
    "vlaserC2="<<vlaserC[2]<<
    "vcosmicAll="<<vcosmicAll<<
    "vdrift1="<<vdrift1;

  //
  // define distance to measurement
  //
  static Double_t dlaserA=0; 
  static Double_t dlaserC=0; 
  static Double_t dcosmic=0; 
  static Double_t slaserA=0; 
  static Double_t slaserC=0; 
  static Double_t scosmic=0; 
  static Double_t  vclaserA[3]={0,0,0};
  static Double_t  vclaserC[3]={0,0,0};
  static Double_t  vccosmicAll=0;
  for (Int_t i=0;i<3;i++){
    if (laserA[i]) AliTPCcalibDButil::GetNearest(laserA[i],timeStamp,dlaserA,vclaserA[i]);
    if (laserC[i]) AliTPCcalibDButil::GetNearest(laserC[i],timeStamp,dlaserC,vclaserC[i]);
  }  
  if (cosmicAll) AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dcosmic,vccosmicAll);
  (*fPcstream)<<"dcs"<<
    "vclaserA0="<<vclaserA[0]<<
    "vclaserA1="<<vclaserA[1]<<
    "vclaserA2="<<vclaserA[2]<<
    "vclaserC0="<<vclaserC[0]<<
    "vclaserC1="<<vclaserC[1]<<
    "vclaserC2="<<vclaserC[2]<<
    "vccosmicAll="<<vccosmicAll<<
    "dlaserA="<<dlaserA<<
    "dlaserC="<<dlaserC<<
    "dcosmic="<<dcosmic<<
    "slaserA="<<slaserA<<
    "slaserC="<<slaserC<<
    "scosmic="<<scosmic;
}

void AliTPCcalibSummary::ProcessDriftCE(Int_t run,Int_t timeStamp){
  //
  // dump drift calibration data CE
  //
  TObjArray *arrT=fCalibDB->GetCErocTtime();
  AliTPCParam *param=fCalibDB->GetParameters();
  static TVectorD tdriftCE(74);
  static TVectorD tndriftCE(74);
  static TVectorD vdriftCE(74);
  static TVectorD tcdriftCE(74);
  static TVectorD tddriftCE(74);
  static Double_t ltime0A;
  static Double_t ltime0C;
  //
  //
  //
  ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
  ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);
  //
  for (Int_t i=0; i<arrT->GetEntries();i++){
    tdriftCE[i]=0;
    vdriftCE[i]=0;
    TGraph *graph = (TGraph*)arrT->At(i);
    if (!graph) continue;
    tdriftCE[i]=AliTPCcalibDButil::EvalGraphConst(graph,timeStamp);
    Double_t deltaT,gry;
    AliTPCcalibDButil::GetNearest(graph,timeStamp,deltaT,gry);
    tndriftCE[i]=graph->GetN();
    tcdriftCE[i]=gry;	       
    tddriftCE[i]=deltaT;	       
    if (i%36<18){
      vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
    }else{
      vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
    }
  }
  // export values
  (*fPcstream)<<"dcs"<<  
    "tdriftCE.="<<&tdriftCE<<    // arrival time 
    "vdriftCE.="<<&vdriftCE<<    // derived drift velocity per chamber 
    "tndriftCE.="<<&tndriftCE<<  // number of points (chambers)
    "tcdriftCE.="<<&tcdriftCE<<  // constant evaluation - nearest point used
    "tddriftCE.="<<&tddriftCE<<  // distance to closest measuement
    "ltime0A="<<ltime0A<<        // laser offset expected in reconstruction
    "ltime0C="<<ltime0C;         // laser offset expected in reconstruction 
   }


void AliTPCcalibSummary::ProcessDriftAll(Int_t run,Int_t timeStamp){
  //
  // dump drift calibration data  all calibrations form DB util
  // test of utils
  static Double_t vdriftCEA=0, vdriftCEC=0, vdriftCEM=0;
  static Double_t vdriftLTA=0, vdriftLTC=0, vdriftLTM=0;
  static Double_t vdriftITS=0;
  static Double_t vdriftP=0;
  static Double_t dcea=0, dcec=0, dcem=0,  dla=0,dlc=0,dlm=0,dp=0;
  static Double_t dits=0;
  static Double_t ltime0A;
  static Double_t ltime0C;
  static Double_t ctime0;
  static Double_t vdrift1=0;
  vdrift1= fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);
  vdriftP = fDButil->GetVDriftTPC(dp, run, timeStamp, 86400, 3600,0);
  ctime0 = AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, 36000, 3600,0);
  //
  vdriftCEA= fDButil->GetVDriftTPCCE(dcea,run,timeStamp,36000,0);
  vdriftCEC= fDButil->GetVDriftTPCCE(dcec,run,timeStamp,36000,1);
  vdriftCEM= fDButil->GetVDriftTPCCE(dcem,run,timeStamp,36000,2);
  //
  vdriftLTA= fDButil->GetVDriftTPCLaserTracks(dla,run,timeStamp,36000,0);
  vdriftLTC= fDButil->GetVDriftTPCLaserTracks(dlc,run,timeStamp,36000,1);
  vdriftLTM= fDButil->GetVDriftTPCLaserTracks(dlm,run,timeStamp,36000,2);
  //
  vdriftITS= fDButil->GetVDriftTPCITS(dits, run,timeStamp);
  //
  ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
  ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);

  (*fPcstream)<<"dcs"<<  
    //
    "vdriftCEA="<<vdriftCEA<<   // drift velocity CE
    "vdriftCEC="<<vdriftCEC<<
    "vdriftCEM="<<vdriftCEM<<
    "dcea="<<dcea<<
    "dcec="<<dcec<<
    "dcem="<<dcem<<
    "vdriftLTA="<<vdriftLTA<<   // drift velocity laser tracks
    "vdriftLTC="<<vdriftLTC<<
    "vdriftLTM="<<vdriftLTM<<
    "dla="<<dla<<
    "dlc="<<dlc<<
    "dlm="<<dlm<<
    //
    //
    "vdriftITS="<<vdriftITS<<
    "dits="<<dits<<
    "ctime0="<<ctime0<<
    "vdriftP="<<vdriftP<<       // drift velocity comsic 
    "dp="<<dp<<
    "vdrift1="<<vdrift1;        // combined drift velocity

}



void AliTPCcalibSummary::ProcessKryptonTime(Int_t run, Int_t timeStamp){
  //
  // Dumping  krypton calibration results
  //
  static TObjArray * krArray=0;
  if (!krArray) {
    AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGainKrypton", run);
    if (entry){
      krArray = (TObjArray*)entry->GetObject();
    }
  }
  static TVectorD krMean(74);
  static TVectorD krErr(74);
  static TVectorD krDist(74);
  TGraphErrors *gr=0;
  Double_t deltaT=0,gry=0;
  if (krArray){
    for (Int_t isec=0; isec<72; isec++){
      krMean[isec]=0;
      krDist[isec]=0;
      krErr[isec]=0;
      gr=(TGraphErrors*)krArray->At(isec);
      if (gr) {
	krMean[isec]=gr->Eval(timeStamp);
	AliTPCcalibDButil::GetNearest(gr, timeStamp,deltaT,gry);
	krDist[isec]=deltaT;
      }     
      if (72+isec<krArray->GetEntries()) {
	gr=(TGraphErrors*)krArray->At(72+isec);
	if (gr) krErr[isec]=gr->Eval(timeStamp);
      }
    }
    krMean[72]= TMath::Median(36,krMean.GetMatrixArray());
    krMean[73]= TMath::Median(36,&(krMean.GetMatrixArray()[36]));
    krErr[72]= TMath::Median(36,krErr.GetMatrixArray());
    krErr[73]= TMath::Median(36,&(krErr.GetMatrixArray()[36]));
  }
  (*fPcstream)<<"dcs"<<
    "krMean.="<<&krMean<<
    "krErr.="<<&krErr<<
    "krDist.="<<&krDist;
}

void AliTPCcalibSummary::ProcessCTP(Int_t irun, Int_t timeStamp){
  //
  // 
  //
  static TClonesArray *pcarray = new TClonesArray("AliCTPInputTimeParams",1);
  static AliCTPTimeParams *ctpParams =0;
  ctpParams = fCalibDB->GetCTPTimeParams(); //
  const TObjArray        *arr = ctpParams->GetInputTimeParams();
  pcarray->ExpandCreateFast(TMath::Max(arr->GetEntries(),1));
  for (Int_t i=0; i<arr->GetEntries(); i++){
    new ((*pcarray)[i]) AliCTPInputTimeParams(*((AliCTPInputTimeParams*)arr->At(i)));
  }
  (*fPcstream)<<"ctp"<<
    "run="<<irun<<
    "time="<<timeStamp<<
    "ctpP.="<<ctpParams<<
    "ctpArr="<<pcarray<<
    "\n";
  (*fPcstream)<<"dcs"<<
    "ctpP.="<<ctpParams<<
    "ctpArr="<<pcarray;
}

void AliTPCcalibSummary::ProcessGain(Int_t irun, Int_t timeStamp){
  //
  // Dump gain related information to the tree
  //
  static Float_t  gainCosmic = 0;
  static Float_t  gainMIP = 0;
  TObjArray * gainSplines = fCalibDB->GetTimeGainSplinesRun(irun);
  if (gainSplines) {
    TGraphErrors * graphMIP = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_BEAM_ALL");
    TGraphErrors * graphCosmic = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_COSMIC_ALL");
    if (graphMIP) gainMIP = AliTPCcalibDButil::EvalGraphConst(graphMIP,timeStamp);
    if (graphCosmic) gainCosmic = AliTPCcalibDButil::EvalGraphConst(graphCosmic,timeStamp);
  }
  // time dependence of gain
  (*fPcstream)<<"dcs"<<
    "gainMIP="<<gainMIP<<
    "gainCosmic="<<gainCosmic;     
}


void AliTPCcalibSummary::ProcessAlign(Int_t run, Int_t timeStamp){
  //
  // Proccess alignment 
  //
  TString   grnames[12]={"ALIGN_ITS", "ALIGN_ITSP", "ALIGN_ITSM", "ALIGN_ITSB",
			 "ALIGN_TRD", "ALIGN_TRDP", "ALIGN_TRDM","ALIGN_TRDB",
			 "ALIGN_TOF", "ALIGN_TOFP", "ALIGN_TOFM","ALIGN_TOFB"};
  TString   grpar[9]={"DELTAPSI", "DELTATHETA", "DELTAPHI",
		      "DELTAX", "DELTAY", "DELTAZ",
		      "DRIFTVD", "T0", "VDGY"};
  static Double_t values[12*9];
  static Double_t errs[12*9];

  TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
  TGraphErrors *gr=0;
  for (Int_t idet=0; idet<12; idet++){
    for (Int_t ipar=0; ipar<9; ipar++){
      TString grName=grnames[idet];
      grName+="_TPC_";
      grName+=grpar[ipar];
      if (array){
	gr = (TGraphErrors*)array->FindObject(grName.Data());
      }
      values[9*idet+ipar]=0;
      errs[9*idet+ipar]=0;
      if (gr) values[9*idet+ipar]=gr->Eval(timeStamp);
      (*fPcstream)<<"dcs"<<
	Form("%s=",grName.Data())<<values[9*idet+ipar];
      (*fPcstream)<<"align"<<
	Form("%s=",grName.Data())<<values[9*idet+ipar];
    }
  }
  (*fPcstream)<<"align"<<
    "time="<<timeStamp<<
    "run="<<run<<
    "\n";
}