TPC/AliTPCcalibSummary.cxx

   1 /*
   2 // Make a summary information of calibration.
   3 // Store results in the summary trees
   4 // OCDB configuration
   5
   6 Example usage:
   7
   8 gSystem->Load("libANALYSIS");
   9 gSystem->Load("libTPCcalib");
  10
  11 Int_t irun=119037;
  12 gROOT->LoadMacro("$ALICE_ROOT/TPC/scripts/OCDBscan/ConfigOCDB.C");
  13 ConfigOCDB(irun)
  14
  15 AliTPCcalibSummary *calibSummary = new AliTPCcalibSummary;
  16 calibSummary->ProcessRun(irun);
  17 delete calibSummary;
  18
  19 */
  20
  21 #include <TROOT.h>
  22 #include <iostream>
  23 #include <fstream>
  24 #include <stdio.h>
  25 #include <AliCDBManager.h>
  26 #include <AliCDBEntry.h>
  27 #include <AliLog.h>
  28 #include <AliMagF.h>
  29 #include "AliTPCcalibDB.h"
  30 #include "AliTPCcalibDButil.h"
  31 #include "AliTPCAltroMapping.h"
  32 #include "AliTPCExB.h"
  33 #include "AliTPCCalROC.h"
  34 #include "AliTPCCalPad.h"
  35 #include "AliTPCSensorTempArray.h"
  36 #include "AliGRPObject.h"
  37 #include "AliTPCTransform.h"
  38 #include "TFile.h"
  39 #include "TKey.h"
  40 #include "TObjArray.h"
  41 #include "TObjString.h"
  42 #include "TString.h"
  43 #include "AliTPCCalPad.h"
  44 #include "AliTPCROC.h"
  45 #include "AliTPCParam.h"
  46 #include "AliTPCCalibPulser.h"
  47 #include "AliTPCCalibPedestal.h"
  48 #include "AliTPCCalibCE.h"
  49 #include "AliTPCExBFirst.h"
  50 #include "TTreeStream.h"
  51 #include "AliTPCTempMap.h"
  52 #include "TVectorD.h"
  53 #include "TMatrixD.h"
  54 #include "AliTPCCalibRaw.h"
  55 #include "AliSplineFit.h"
  56 #include "TGraphErrors.h"
  57 #include <AliCTPTimeParams.h>
  58 #include <AliTPCcalibSummary.h>
  59 //
  60 //
  61 //
  62 AliTPCcalibSummary::AliTPCcalibSummary():
  63   TNamed(),
  64   fCalibDB(0),
  65   fDButil(0),
  66   fPcstream(0)
  67 {
  68   //
  69   // default constructor
  70   // OCDB have to be setupe before - not part of class
  71   // usualy ConfigOCDB.C macro used
  72   //
  73   fPcstream = new TTreeSRedirector("dcsTime.root");
  74   fCalibDB = AliTPCcalibDB::Instance();
  75   fDButil= new AliTPCcalibDButil;
  76 }
  77
  78 AliTPCcalibSummary::~AliTPCcalibSummary(){
  79   //
  80   // destructor  - close streamer
  81   //
  82   delete fPcstream;
  83 }
  84
  85 void AliTPCcalibSummary::Process(const char * runList, Int_t first, Int_t last){
  86   //
  87   // runList - listOfRuns to process
  88   // first   - first run to process
  89   // last    - last  to process
  90   //
  91   //
  92   // make list of runs
  93   //
  94
  95   ifstream inputFile;
  96   inputFile.open("run.list");
  97   Int_t irun=0;
  98   TArrayI runArray(100000);
  99   Int_t indexes[100000];
 100   Int_t nruns=0;
 101   printf("Runs to process:\n");
 102   if (!inputFile.is_open()) {
 103     printf("Problem to open file %s\n",runList);
 104   }
 105   while( inputFile.good() ) {
 106     inputFile >> irun;
 107     printf("Run \t%d\n",irun);
 108     if (irun<first) continue;  // process only subset of list
 109     if (last>0 && irun>last) continue;  // process only subset of list
 110     runArray[nruns]=irun;
 111     nruns++;
 112   }
 113
 114
 115   TMath::Sort(nruns, runArray.fArray, indexes,kFALSE);
 116   Int_t startTime = 0;
 117   Int_t endTime   = 0;
 118   for (Int_t run=0; run<nruns; run++){
 119     irun=runArray[indexes[run]];
 120     printf("Processing run %d ...\n",irun);
 121     fCalibDB->SetRun(irun);
 122     fDButil->UpdateFromCalibDB();
 123     fDButil->SetReferenceRun(irun);
 124     fDButil->UpdateRefDataFromOCDB();
 125     //
 126     AliDCSSensorArray *arrHV=fCalibDB->GetVoltageSensors(irun);
 127     if (!arrHV) continue;
 128     for  (Int_t isenHV=0; isenHV<arrHV->NumSensors(); ++isenHV){
 129       AliDCSSensor *senHV=arrHV->GetSensorNum(isenHV);
 130       if (!senHV) {
 131         printf("Not interesting OCDB info\n");
 132         continue;
 133       }
 134       startTime=senHV->GetStartTime();
 135       endTime  =senHV->GetEndTime();
 136       if (startTime>0&&endTime>0) break;
 137     }
 138     AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun);
 139     if (goofieArray) fDButil->FilterGoofie(goofieArray,0.5,4.,6.85,7.05,fPcstream);
 140     // don't filter goofie for the moment
 141     ProcessRun(irun, startTime,endTime);
 142   }
 143 }
 144
 145
 146 void AliTPCcalibSummary::ProcessRun(Int_t irun, Int_t startTime, Int_t endTime){
 147   //
 148   // Process run irun
 149   //
 150   fCalibDB->SetRun(irun);
 151   fDButil->UpdateFromCalibDB();
 152   fDButil->SetReferenceRun(irun);
 153   fDButil->UpdateRefDataFromOCDB();
 154   //
 155   AliSplineFit *fitVdrift=0x0;
 156   Int_t startTimeGRP=0, stopTimeGRP=0;
 157   if (fCalibDB->GetGRP(irun)){
 158     startTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeStart();
 159     stopTimeGRP  = AliTPCcalibDB::GetGRP(irun)->GetTimeEnd();
 160   }
 161   if (startTime==0){
 162     startTime=startTimeGRP;
 163     endTime=stopTimeGRP;
 164   }
 165   AliTPCSensorTempArray * tempArray = fCalibDB->GetTemperatureSensor(irun);
 166   AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
 167   AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun);
 168   //
 169   Int_t dtime = TMath::Max((endTime-startTime)/20,10*60);
 170   //
 171   //Goofie statistical data
 172   //
 173   TVectorD vecEntries, vecMean, vecMedian,vecRMS;
 174   fDButil->ProcessGoofie(vecEntries ,vecMedian, vecMean, vecRMS);
 175   //
 176   //CE data processing - see ProcessCEdata function for description of the results
 177   //
 178   TVectorD fitResultsA, fitResultsC;
 179   Int_t nmaskedCE;
 180   Double_t chi2ACE=0,chi2CCE=0;
 181   //     fDButil->ProcessCEdata("(sector<36)++gx++gy++lx++lx**2",fitResultsA,fitResultsC,nmaskedCE);
 182   fDButil->ProcessCEdata("(sector<36)++gx++gy++(lx-134)++(sector<36)*(lx-134)++(ly/lx)^2",fitResultsA,fitResultsC,nmaskedCE,chi2ACE,chi2CCE);
 183
 184   TVectorD fitCEResultsA(7), fitCEResultsC(7);
 185   Int_t    noutCE;
 186   Double_t chi2CEA=0,chi2CEC=0;
 187   AliTPCCalPad *time0 = fDButil->CreatePadTime0CE(fitCEResultsA, fitCEResultsC, noutCE, chi2CEA, chi2CEC);
 188   delete time0;
 189   //
 190   //
 191   TVectorD vecTEntries, vecTMean, vecTRMS, vecTMedian, vecQEntries, vecQMean, vecQRMS, vecQMedian;
 192   Float_t driftTimeA, driftTimeC;
 193   fDButil->ProcessCEgraphs(vecTEntries, vecTMean, vecTRMS, vecTMedian,
 194                           vecQEntries, vecQMean, vecQRMS, vecQMedian,
 195                           driftTimeA, driftTimeC );
 196   //
 197   //
 198   //
 199   //drift velocity using tracks
 200   //
 201   //     fitVdrift=fCalibDB->GetVdriftSplineFit("ALISPLINEFIT_MEAN_VDRIFT_COSMICS_ALL",irun);
 202   fitVdrift=fCalibDB->CreateVdriftSplineFit("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL",irun);
 203   //noise data Processing - see ProcessNoiseData function for description of the results
 204   TVectorD vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions;
 205   Int_t nonMaskedZero=0, nNaN=0;
 206   fDButil->ProcessNoiseData(vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions, nonMaskedZero, nNaN);
 207   //
 208   // comparisons
 209   //
 210   TVectorF pedestalDeviations;
 211   TVectorF noiseDeviations;
 212   TVectorF pulserQdeviations;
 213   Float_t varQMean;
 214   Int_t npadsOutOneTB;
 215   Int_t npadsOffAdd;
 216   fDButil->ProcessPedestalVariations(pedestalDeviations);
 217   fDButil->ProcessNoiseVariations(noiseDeviations);
 218   fDButil->ProcessPulserVariations(pulserQdeviations,varQMean,npadsOutOneTB,npadsOffAdd);
 219   //
 220   //L3 data
 221   //
 222   Float_t bz=AliTPCcalibDB::GetBz(irun);
 223   Char_t  l3pol=AliTPCcalibDB::GetL3Polarity(irun);
 224   //
 225   //calibration Pulser data processing
 226   //
 227   Int_t nOffChannels=0;
 228   TVectorD vTimePulser;
 229   nOffChannels=fDButil->GetNPulserOutliers();
 230   fDButil->ProcessPulser(vTimePulser);
 231   //
 232   //ALTRO data
 233   //
 234   Int_t nMasked=0;
 235   fDButil->ProcessALTROConfig(nMasked);
 236   //
 237   //Calib RAW data
 238   //
 239   Int_t nFailL1=-1;
 240   if (fCalibDB->GetCalibRaw()) nFailL1=fCalibDB->GetCalibRaw()->GetNFailL1Phase();
 241   //
 242   //production information
 243   //
 244   Int_t nalien=0,nRawAlien=0,nlocal=0,nRawLocal=0;
 245   //run type
 246   TObjString runType(AliTPCcalibDB::GetRunType(irun).Data());
 247   //
 248   //
 249   //
 250
 251   for (Int_t itime=startTime; itime<endTime; itime+=dtime){
 252     //
 253     TTimeStamp tstamp(itime);
 254     Float_t valuePressure  = fCalibDB->GetPressure(tstamp,irun,0);
 255     Float_t valuePressure2 = fCalibDB->GetPressure(tstamp,irun,1);
 256     Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,0);
 257     Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,1);
 258     //temperature fits
 259     TLinearFitter * fitter = 0;
 260     TVectorD vecTemp[10];
 261     for (Int_t itype=0; itype<5; itype++)
 262       for (Int_t iside=0; iside<2; iside++){
 263         fitter= tempMap->GetLinearFitter(itype,iside,tstamp);
 264         if (!fitter) continue;
 265         fitter->Eval();
 266         fitter->GetParameters(vecTemp[itype+iside*5]);
 267         delete fitter;
 268       }
 269     //
 270     //measured skirt temperatures
 271     //
 272     TVectorD vecSkirtTempA(18);
 273     TVectorD vecSkirtTempC(18);
 274     Int_t nsenTemp=tempArray->NumSensors();
 275     for (Int_t isenTemp=0;isenTemp<nsenTemp;++isenTemp){
 276       AliTPCSensorTemp *senTemp=(AliTPCSensorTemp*)tempArray->GetSensorNum(isenTemp);
 277       if (senTemp->GetType()!=3) continue;
 278       if (TMath::Sqrt(senTemp->GetX()*senTemp->GetX()+senTemp->GetY()*senTemp->GetY())<100) continue; //only skirt, outer FC vessel
 279       Double_t val=senTemp->GetValue(tstamp);
 280       if (senTemp->GetSide()==0)
 281         vecSkirtTempA[senTemp->GetSector()]=val;
 282       else
 283         vecSkirtTempC[senTemp->GetSector()]=val;
 284     }
 285     //
 286     //goofie data
 287     //
 288     TVectorD vecGoofie;
 289     if (goofieArray){
 290       vecGoofie.ResizeTo(goofieArray->NumSensors());
 291       for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){
 292         AliDCSSensor *gsensor = goofieArray->GetSensor(isensor);
 293         if (gsensor){
 294           vecGoofie[isensor] = gsensor->GetValue(tstamp);
 295         }
 296       }
 297     } else {
 298       vecGoofie.ResizeTo(19);
 299     }
 300     //
 301     TVectorD voltagesIROC(36);
 302     TVectorD voltagesOROC(36);
 303     for(Int_t j=1; j<36; j++) voltagesIROC[j-1] = fCalibDB->GetChamberHighVoltage(irun, j,itime);
 304     for(Int_t j=36; j<72; j++) voltagesOROC[j-36] = fCalibDB->GetChamberHighVoltage(irun, j,itime);
 305     Double_t voltIROC = TMath::Median(36, voltagesIROC.GetMatrixArray());
 306     Double_t voltOROC = TMath::Median(36, voltagesOROC.GetMatrixArray());
 307     //
 308     Float_t  coverIA=AliTPCcalibDB::GetCoverVoltage(irun,0,itime);
 309     Float_t  coverIC=AliTPCcalibDB::GetCoverVoltage(irun,18,itime);
 310     Float_t  coverOA=AliTPCcalibDB::GetCoverVoltage(irun,36,itime);
 311     Float_t  coverOC=AliTPCcalibDB::GetCoverVoltage(irun,54,itime);
 312     Float_t  skirtA=AliTPCcalibDB::GetSkirtVoltage(irun,0,itime);
 313     Float_t  skirtC=AliTPCcalibDB::GetSkirtVoltage(irun,18,itime);
 314     Float_t  ggOffA=AliTPCcalibDB::GetGGoffsetVoltage(irun,0,itime);
 315     Float_t  ggOffC=AliTPCcalibDB::GetGGoffsetVoltage(irun,18,itime);
 316     //drift velocity
 317     Float_t dvCorr=-5;
 318     if (fitVdrift) dvCorr=fitVdrift->Eval(itime);
 319
 320     //tempMap->GetLinearFitter(0,0,itime);
 321     (*fPcstream)<<"dcs"<<
 322       "run="<<irun<<
 323       "time="<<itime<<
 324       "startTimeGRP="<<startTimeGRP<<
 325       "stopTimeGRP="<<stopTimeGRP<<
 326       //run type
 327       "runType.="<<&runType<<
 328       // voltage setting
 329       "VIROC.="<<&voltagesIROC<<
 330       "VOROC.="<<&voltagesOROC<<
 331       "medianVIROC="<<voltIROC<<
 332       "medianVOROC="<<voltOROC<<
 333       "coverIA=" << coverIA <<
 334       "coverIC=" << coverIC <<
 335       "coverOA=" << coverOA <<
 336       "coverOC=" << coverOC <<
 337       "skirtA=" << skirtA <<
 338       "skirtC=" << skirtC <<
 339       "ggOffA=" << ggOffA <<
 340       "ggOffC=" << ggOffC <<
 341       //
 342       "ptrel0="<<ptrelative0<<  // deltaTP/TP  - A side
 343       "ptrel1="<<ptrelative1<<  // deltaTP/TPC - C side
 344       "goofie.="<<&vecGoofie<<
 345       "goofieE.="<<&vecEntries<<
 346       "goofieMean.="<<&vecMean<<
 347       "goofieMedian.="<<&vecMedian<<
 348       "goofieRMS.="<<&vecRMS<<
 349       //
 350       "press="<<valuePressure<<
 351       "press2="<<valuePressure2<<
 352       "temp00.="<<&vecTemp[0]<<
 353       "temp10.="<<&vecTemp[1]<<
 354       "temp20.="<<&vecTemp[2]<<
 355       "temp30.="<<&vecTemp[3]<<
 356       "temp40.="<<&vecTemp[4]<<
 357       "temp01.="<<&vecTemp[5]<<
 358       "temp11.="<<&vecTemp[6]<<
 359       "temp21.="<<&vecTemp[7]<<
 360       "temp31.="<<&vecTemp[8]<<
 361       "temp41.="<<&vecTemp[9]<<
 362       "tempSkirtA.="<<&vecSkirtTempA<<
 363       "tempSkirtC.="<<&vecSkirtTempC;
 364
 365     ProcessDrift(irun, itime);
 366     ProcessDriftCE(irun,itime);
 367     ProcessDriftAll(irun,itime);
 368     //    ProcessKryptonTime(irun,itime);
 369     ProcessCTP(irun,itime);
 370     ProcessAlign(irun,itime);
 371     ProcessGain(irun,itime);
 372
 373
 374     (*fPcstream)<<"dcs"<<
 375       //noise data
 376       "meanNoise.="<<&vNoiseMean<<
 377       "meanNoiseSen.="<<&vNoiseMeanSenRegions<<
 378       "rmsNoise.="<<&vNoiseRMS<<
 379       "rmsNoiseSen.="<<&vNoiseRMSSenRegions<<
 380       "zeroNoise="<<nonMaskedZero<<
 381       "nNaN="<<nNaN<<
 382       //pulser data
 383       "timePulser.=" << &vTimePulser <<
 384       "nOffPulser="<<nOffChannels<<
 385       //altro data
 386       "nMasked="<<nMasked<<
 387       //ce data -Jens version
 388       "CEfitA.="<<&fitResultsA<<
 389       "CEfitC.="<<&fitResultsC<<
 390       "nmaskedCE="<<nmaskedCE<<
 391       "chi2ACE="<<chi2ACE<<
 392       "chi2CCE="<<chi2CCE<<
 393       //ce data new - MI version
 394       "CEfitAMI.="<<&fitCEResultsA<<
 395       "CEfitCMI.="<<&fitCEResultsC<<
 396       "chi2CEA="<<chi2CEA<<
 397       "chi2CEC="<<chi2CEC<<
 398       //
 399       //ce graph data
 400       "CEgrTEntries.="<<&vecTEntries<<
 401       "CEgrTMean.="<<&vecTMean<<
 402       "CEgrTRMS.="<<&vecTRMS<<
 403       "CEgrTMedian.="<<&vecTMedian<<
 404       "CEgrQEntries.="<<&vecQEntries<<
 405       "CEgrQMean.="<<&vecQMean<<
 406       "CEgrQRMS.="<<&vecQRMS<<
 407       "CEgrQMedian.="<<&vecQMedian<<
 408       "CEgrDriftA="<<driftTimeA<<
 409       "CEgrDriftC="<<driftTimeC<<
 410       //calib raw data
 411       "nFailL1="<<nFailL1<<
 412       // b field
 413       "Bz="<< bz <<
 414       "L3polarity="<<l3pol<<
 415       // production information
 416       "nalien="<<nalien<<
 417       "nRawAlien="<<nRawAlien<<
 418       "nlocal="<<nlocal<<
 419       "nRawLocal="<<nRawLocal<<
 420       //comparisons with ref data
 421       "pedestalDeviations.="<<&pedestalDeviations<<
 422       "noiseDeviations.="<<&noiseDeviations<<
 423       "pulserQdeviations.="<<&pulserQdeviations<<
 424       //         "pulserVarQMean="<<varQMean<<
 425       "pulserNpadsOutOneTB="<<npadsOutOneTB<<
 426       "pulserNpadsOffAdd="<<npadsOffAdd<<
 427       "driftCorrCosmAll="<<dvCorr<<
 428       "\n";
 429   }//end run loop
 430 }
 431
 432
 433
 434
 435
 436
 437 void AliTPCcalibSummary::ProcessDrift(Int_t run, Int_t timeStamp){
 438   //
 439   // dump drift calibration data to the tree
 440   //
 441   TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
 442   TGraphErrors *laserA[3]={0,0,0};
 443   TGraphErrors *laserC[3]={0,0,0};
 444   TGraphErrors *cosmicAll=0;
 445   static Double_t     vlaserA[3]={0,0,0};
 446   static Double_t     vlaserC[3]={0,0,0};
 447   static Double_t     vcosmicAll=0;
 448   static Double_t     vdrift1=0;
 449   vdrift1=fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);
 450
 451   if (array){
 452     laserA[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_A");
 453     laserA[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A");
 454     laserA[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A");
 455     laserC[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_C");
 456     laserC[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C");
 457     laserC[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C");
 458     cosmicAll =(TGraphErrors*)array->FindObject("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL");
 459   }
 460   if (laserA[0]) vlaserA[0]= AliTPCcalibDButil::EvalGraphConst(laserA[0],timeStamp);
 461   if (laserA[1]) vlaserA[1]= AliTPCcalibDButil::EvalGraphConst(laserA[1],timeStamp);
 462   if (laserA[2]) vlaserA[2]= AliTPCcalibDButil::EvalGraphConst(laserA[2],timeStamp);
 463   if (laserC[0]) vlaserC[0]= AliTPCcalibDButil::EvalGraphConst(laserC[0],timeStamp);
 464   if (laserC[1]) vlaserC[1]= AliTPCcalibDButil::EvalGraphConst(laserC[1],timeStamp);
 465   if (laserC[2]) vlaserC[2]= AliTPCcalibDButil::EvalGraphConst(laserC[2],timeStamp);
 466   if (cosmicAll) vcosmicAll= AliTPCcalibDButil::EvalGraphConst(cosmicAll,timeStamp);
 467   (*fPcstream)<<"dcs"<<
 468     "vlaserA0="<<vlaserA[0]<<
 469     "vlaserA1="<<vlaserA[1]<<
 470     "vlaserA2="<<vlaserA[2]<<
 471     "vlaserC0="<<vlaserC[0]<<
 472     "vlaserC1="<<vlaserC[1]<<
 473     "vlaserC2="<<vlaserC[2]<<
 474     "vcosmicAll="<<vcosmicAll<<
 475     "vdrift1="<<vdrift1;
 476
 477   //
 478   // define distance to measurement
 479   //
 480   static Double_t dlaserA=0;
 481   static Double_t dlaserC=0;
 482   static Double_t dcosmic=0;
 483   static Double_t slaserA=0;
 484   static Double_t slaserC=0;
 485   static Double_t scosmic=0;
 486   static Double_t  vclaserA[3]={0,0,0};
 487   static Double_t  vclaserC[3]={0,0,0};
 488   static Double_t  vccosmicAll=0;
 489   for (Int_t i=0;i<3;i++){
 490     if (laserA[i]) AliTPCcalibDButil::GetNearest(laserA[i],timeStamp,dlaserA,vclaserA[i]);
 491     if (laserC[i]) AliTPCcalibDButil::GetNearest(laserC[i],timeStamp,dlaserC,vclaserC[i]);
 492   }
 493   if (cosmicAll) AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dcosmic,vccosmicAll);
 494   (*fPcstream)<<"dcs"<<
 495     "vclaserA0="<<vclaserA[0]<<
 496     "vclaserA1="<<vclaserA[1]<<
 497     "vclaserA2="<<vclaserA[2]<<
 498     "vclaserC0="<<vclaserC[0]<<
 499     "vclaserC1="<<vclaserC[1]<<
 500     "vclaserC2="<<vclaserC[2]<<
 501     "vccosmicAll="<<vccosmicAll<<
 502     "dlaserA="<<dlaserA<<
 503     "dlaserC="<<dlaserC<<
 504     "dcosmic="<<dcosmic<<
 505     "slaserA="<<slaserA<<
 506     "slaserC="<<slaserC<<
 507     "scosmic="<<scosmic;
 508 }
 509
 510 void AliTPCcalibSummary::ProcessDriftCE(Int_t run,Int_t timeStamp){
 511   //
 512   // dump drift calibration data CE
 513   //
 514   TObjArray *arrT=fCalibDB->GetCErocTtime();
 515   AliTPCParam *param=fCalibDB->GetParameters();
 516   static TVectorD tdriftCE(74);
 517   static TVectorD tndriftCE(74);
 518   static TVectorD vdriftCE(74);
 519   static TVectorD tcdriftCE(74);
 520   static TVectorD tddriftCE(74);
 521   static Double_t ltime0A;
 522   static Double_t ltime0C;
 523   //
 524   //
 525   //
 526   ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
 527   ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);
 528   //
 529   for (Int_t i=0; i<arrT->GetEntries();i++){
 530     tdriftCE[i]=0;
 531     vdriftCE[i]=0;
 532     TGraph *graph = (TGraph*)arrT->At(i);
 533     if (!graph) continue;
 534     tdriftCE[i]=AliTPCcalibDButil::EvalGraphConst(graph,timeStamp);
 535     Double_t deltaT,gry;
 536     AliTPCcalibDButil::GetNearest(graph,timeStamp,deltaT,gry);
 537     tndriftCE[i]=graph->GetN();
 538     tcdriftCE[i]=gry;
 539     tddriftCE[i]=deltaT;
 540     if (i%36<18){
 541       vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
 542     }else{
 543       vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
 544     }
 545   }
 546   // export values
 547   (*fPcstream)<<"dcs"<<
 548     "tdriftCE.="<<&tdriftCE<<    // arrival time
 549     "vdriftCE.="<<&vdriftCE<<    // derived drift velocity per chamber
 550     "tndriftCE.="<<&tndriftCE<<  // number of points (chambers)
 551     "tcdriftCE.="<<&tcdriftCE<<  // constant evaluation - nearest point used
 552     "tddriftCE.="<<&tddriftCE<<  // distance to closest measuement
 553     "ltime0A="<<ltime0A<<        // laser offset expected in reconstruction
 554     "ltime0C="<<ltime0C;         // laser offset expected in reconstruction
 555    }
 556
 557
 558 void AliTPCcalibSummary::ProcessDriftAll(Int_t run,Int_t timeStamp){
 559   //
 560   // dump drift calibration data  all calibrations form DB util
 561   // test of utils
 562   static Double_t vdriftCEA=0, vdriftCEC=0, vdriftCEM=0;
 563   static Double_t vdriftLTA=0, vdriftLTC=0, vdriftLTM=0;
 564   static Double_t vdriftITS=0;
 565   static Double_t vdriftP=0;
 566   static Double_t dcea=0, dcec=0, dcem=0,  dla=0,dlc=0,dlm=0,dp=0;
 567   static Double_t dits=0;
 568   static Double_t ltime0A;
 569   static Double_t ltime0C;
 570   static Double_t ctime0;
 571   static Double_t vdrift1=0;
 572   vdrift1= fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);
 573   vdriftP = fDButil->GetVDriftTPC(dp, run, timeStamp, 86400, 3600,0);
 574   ctime0 = AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, 36000, 3600,0);
 575   //
 576   vdriftCEA= fDButil->GetVDriftTPCCE(dcea,run,timeStamp,36000,0);
 577   vdriftCEC= fDButil->GetVDriftTPCCE(dcec,run,timeStamp,36000,1);
 578   vdriftCEM= fDButil->GetVDriftTPCCE(dcem,run,timeStamp,36000,2);
 579   //
 580   vdriftLTA= fDButil->GetVDriftTPCLaserTracks(dla,run,timeStamp,36000,0);
 581   vdriftLTC= fDButil->GetVDriftTPCLaserTracks(dlc,run,timeStamp,36000,1);
 582   vdriftLTM= fDButil->GetVDriftTPCLaserTracks(dlm,run,timeStamp,36000,2);
 583   //
 584   vdriftITS= fDButil->GetVDriftTPCITS(dits, run,timeStamp);
 585   //
 586   ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
 587   ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);
 588
 589   (*fPcstream)<<"dcs"<<
 590     //
 591     "vdriftCEA="<<vdriftCEA<<   // drift velocity CE
 592     "vdriftCEC="<<vdriftCEC<<
 593     "vdriftCEM="<<vdriftCEM<<
 594     "dcea="<<dcea<<
 595     "dcec="<<dcec<<
 596     "dcem="<<dcem<<
 597     "vdriftLTA="<<vdriftLTA<<   // drift velocity laser tracks
 598     "vdriftLTC="<<vdriftLTC<<
 599     "vdriftLTM="<<vdriftLTM<<
 600     "dla="<<dla<<
 601     "dlc="<<dlc<<
 602     "dlm="<<dlm<<
 603     //
 604     //
 605     "vdriftITS="<<vdriftITS<<
 606     "dits="<<dits<<
 607     "ctime0="<<ctime0<<
 608     "vdriftP="<<vdriftP<<       // drift velocity comsic
 609     "dp="<<dp<<
 610     "vdrift1="<<vdrift1;        // combined drift velocity
 611
 612 }
 613
 614
 615
 616 void AliTPCcalibSummary::ProcessKryptonTime(Int_t run, Int_t timeStamp){
 617   //
 618   // Dumping  krypton calibration results
 619   //
 620   static TObjArray * krArray=0;
 621   if (!krArray) {
 622     AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGainKrypton", run);
 623     if (entry){
 624       krArray = (TObjArray*)entry->GetObject();
 625     }
 626   }
 627   static TVectorD krMean(74);
 628   static TVectorD krErr(74);
 629   static TVectorD krDist(74);
 630   TGraphErrors *gr=0;
 631   Double_t deltaT=0,gry=0;
 632   if (krArray){
 633     for (Int_t isec=0; isec<72; isec++){
 634       krMean[isec]=0;
 635       krDist[isec]=0;
 636       krErr[isec]=0;
 637       gr=(TGraphErrors*)krArray->At(isec);
 638       if (gr) {
 639         krMean[isec]=gr->Eval(timeStamp);
 640         AliTPCcalibDButil::GetNearest(gr, timeStamp,deltaT,gry);
 641         krDist[isec]=deltaT;
 642       }
 643       if (72+isec<krArray->GetEntries()) {
 644         gr=(TGraphErrors*)krArray->At(72+isec);
 645         if (gr) krErr[isec]=gr->Eval(timeStamp);
 646       }
 647     }
 648     krMean[72]= TMath::Median(36,krMean.GetMatrixArray());
 649     krMean[73]= TMath::Median(36,&(krMean.GetMatrixArray()[36]));
 650     krErr[72]= TMath::Median(36,krErr.GetMatrixArray());
 651     krErr[73]= TMath::Median(36,&(krErr.GetMatrixArray()[36]));
 652   }
 653   (*fPcstream)<<"dcs"<<
 654     "krMean.="<<&krMean<<
 655     "krErr.="<<&krErr<<
 656     "krDist.="<<&krDist;
 657 }
 658
 659 void AliTPCcalibSummary::ProcessCTP(Int_t irun, Int_t timeStamp){
 660   //
 661   //
 662   //
 663   static TClonesArray *pcarray = new TClonesArray("AliCTPInputTimeParams",1);
 664   static AliCTPTimeParams *ctpParams =0;
 665   ctpParams = fCalibDB->GetCTPTimeParams(); //
 666   const TObjArray        *arr = ctpParams->GetInputTimeParams();
 667   pcarray->ExpandCreateFast(TMath::Max(arr->GetEntries(),1));
 668   for (Int_t i=0; i<arr->GetEntries(); i++){
 669     new ((*pcarray)[i]) AliCTPInputTimeParams(*((AliCTPInputTimeParams*)arr->At(i)));
 670   }
 671   (*fPcstream)<<"ctp"<<
 672     "run="<<irun<<
 673     "time="<<timeStamp<<
 674     "ctpP.="<<ctpParams<<
 675     "ctpArr="<<pcarray<<
 676     "\n";
 677   (*fPcstream)<<"dcs"<<
 678     "ctpP.="<<ctpParams<<
 679     "ctpArr="<<pcarray;
 680 }
 681
 682 void AliTPCcalibSummary::ProcessGain(Int_t irun, Int_t timeStamp){
 683   //
 684   // Dump gain related information to the tree
 685   //
 686   static Float_t  gainCosmic = 0;
 687   static Float_t  gainMIP = 0;
 688   TObjArray * gainSplines = fCalibDB->GetTimeGainSplinesRun(irun);
 689   if (gainSplines) {
 690     TGraphErrors * graphMIP = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_BEAM_ALL");
 691     TGraphErrors * graphCosmic = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_COSMIC_ALL");
 692     if (graphMIP) gainMIP = AliTPCcalibDButil::EvalGraphConst(graphMIP,timeStamp);
 693     if (graphCosmic) gainCosmic = AliTPCcalibDButil::EvalGraphConst(graphCosmic,timeStamp);
 694   }
 695   // time dependence of gain
 696   (*fPcstream)<<"dcs"<<
 697     "gainMIP="<<gainMIP<<
 698     "gainCosmic="<<gainCosmic;
 699 }
 700
 701
 702 void AliTPCcalibSummary::ProcessAlign(Int_t run, Int_t timeStamp){
 703   //
 704   // Proccess alignment
 705   //
 706   TString   grnames[12]={"ALIGN_ITS", "ALIGN_ITSP", "ALIGN_ITSM", "ALIGN_ITSB",
 707                          "ALIGN_TRD", "ALIGN_TRDP", "ALIGN_TRDM","ALIGN_TRDB",
 708                          "ALIGN_TOF", "ALIGN_TOFP", "ALIGN_TOFM","ALIGN_TOFB"};
 709   TString   grpar[9]={"DELTAPSI", "DELTATHETA", "DELTAPHI",
 710                       "DELTAX", "DELTAY", "DELTAZ",
 711                       "DRIFTVD", "T0", "VDGY"};
 712   static Double_t values[12*9];
 713   static Double_t errs[12*9];
 714
 715   TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
 716   TGraphErrors *gr=0;
 717   for (Int_t idet=0; idet<12; idet++){
 718     for (Int_t ipar=0; ipar<9; ipar++){
 719       TString grName=grnames[idet];
 720       grName+="_TPC_";
 721       grName+=grpar[ipar];
 722       if (array){
 723         gr = (TGraphErrors*)array->FindObject(grName.Data());
 724       }
 725       values[9*idet+ipar]=0;
 726       errs[9*idet+ipar]=0;
 727       if (gr) values[9*idet+ipar]=gr->Eval(timeStamp);
 728       (*fPcstream)<<"dcs"<<
 729         Form("%s=",grName.Data())<<values[9*idet+ipar];
 730       (*fPcstream)<<"align"<<
 731         Form("%s=",grName.Data())<<values[9*idet+ipar];
 732     }
 733   }
 734   (*fPcstream)<<"align"<<
 735     "time="<<timeStamp<<
 736     "run="<<run<<
 737     "\n";
 738 }
 739
 740
 741