TPC/Calib/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 #include <TStatToolkit.h>
  60 #include <TCut.h>
  61 #include "AliTPCCalibGlobalMisalignment.h"
  62 #include "AliTPCExBTwist.h"
  63 #include "AliTPCComposedCorrection.h"
  64 //
  65 //
  66 //
  67 AliTPCcalibSummary::AliTPCcalibSummary():
  68   TNamed(),
  69   fCalibDB(0),
  70   fDButil(0),
  71   fPcstream(0)
  72 {
  73   //
  74   // default constructor
  75   // OCDB have to be setupe before - not part of class
  76   // usualy ConfigOCDB.C macro used
  77   //
  78   fPcstream = new TTreeSRedirector("dcsTime.root");
  79   fCalibDB = AliTPCcalibDB::Instance();
  80   fDButil= new AliTPCcalibDButil;
  81 }
  82
  83 AliTPCcalibSummary::~AliTPCcalibSummary(){
  84   //
  85   // destructor  - close streamer
  86   //
  87   delete fPcstream;
  88 }
  89
  90 void AliTPCcalibSummary::Process(const char * runList, Int_t first, Int_t last){
  91   //
  92   // runList - listOfRuns to process
  93   // first   - first run to process
  94   // last    - last  to process
  95   //
  96   //
  97   // make list of runs
  98   //
  99
 100   ifstream inputFile;
 101   inputFile.open("run.list");
 102   Int_t irun=0;
 103   TArrayI runArray(100000);
 104   Int_t indexes[100000];
 105   Int_t nruns=0;
 106   printf("Runs to process:\n");
 107   if (!inputFile.is_open()) {
 108     printf("Problem to open file %s\n",runList);
 109   }
 110   while( inputFile.good() ) {
 111     inputFile >> irun;
 112     printf("Run \t%d\n",irun);
 113     if (irun<first) continue;  // process only subset of list
 114     if (last>0 && irun>last) continue;  // process only subset of list
 115     runArray[nruns]=irun;
 116     nruns++;
 117   }
 118
 119
 120   TMath::Sort(nruns, runArray.fArray, indexes,kFALSE);
 121   Int_t startTime = 0;
 122   Int_t endTime   = 0;
 123   for (Int_t run=0; run<nruns; run++){
 124     irun=runArray[indexes[run]];
 125     printf("Processing run %d ...\n",irun);
 126     fCalibDB->SetRun(irun);
 127     fDButil->UpdateFromCalibDB();
 128     fDButil->SetReferenceRun(irun);
 129     fDButil->UpdateRefDataFromOCDB();
 130     fCalibDB->CreateGUITree("calPads.root");
 131     fDButil->CreateGUIRefTree("calPadsRef.root");
 132     //
 133     AliDCSSensorArray *arrHV=fCalibDB->GetVoltageSensors(irun);
 134     if (!arrHV) continue;
 135     for  (Int_t isenHV=0; isenHV<arrHV->NumSensors(); ++isenHV){
 136       AliDCSSensor *senHV=arrHV->GetSensorNum(isenHV);
 137       if (!senHV) {
 138         printf("Not interesting OCDB info\n");
 139         continue;
 140       }
 141       startTime=senHV->GetStartTime();
 142       endTime  =senHV->GetEndTime();
 143       if (startTime>0&&endTime>0) break;
 144     }
 145     AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun);
 146     if (goofieArray) fDButil->FilterGoofie(goofieArray,0.5,4.,4,10,fPcstream);
 147     // don't filter goofie for the moment
 148     ProcessRun(irun, startTime,endTime);
 149   }
 150 }
 151
 152
 153 void AliTPCcalibSummary::ProcessRun(Int_t irun, Int_t startTime, Int_t endTime){
 154   //
 155   // Process run irun
 156   //
 157   fCalibDB->SetRun(irun);
 158   fDButil->UpdateFromCalibDB();
 159   fDButil->SetReferenceRun(irun);
 160   fDButil->UpdateRefDataFromOCDB();
 161   fCalibDB->CreateGUITree("calPads.root");
 162   fDButil->CreateGUIRefTree("calPadsRef.root");
 163
 164   //
 165   AliSplineFit *fitVdrift=0x0;
 166   Int_t startTimeGRP=0, stopTimeGRP=0;
 167   if (fCalibDB->GetGRP(irun)){
 168     startTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeStart();
 169     stopTimeGRP  = AliTPCcalibDB::GetGRP(irun)->GetTimeEnd();
 170   }
 171   if (startTime==0){
 172     startTime=startTimeGRP;
 173     endTime=stopTimeGRP;
 174   }
 175   AliTPCSensorTempArray * tempArray = fCalibDB->GetTemperatureSensor(irun);
 176   AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
 177   AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun);
 178   //
 179   Int_t dtime = TMath::Max((endTime-startTime)/20,10);
 180   //
 181   //Goofie statistical data
 182   //
 183   TVectorD vecEntries, vecMean, vecMedian,vecRMS;
 184   fDButil->ProcessGoofie(vecEntries ,vecMedian, vecMean, vecRMS);
 185   //
 186   //CE data processing - see ProcessCEdata function for description of the results
 187   //
 188   TVectorD fitResultsA, fitResultsC;
 189   Int_t nmaskedCE;
 190   Double_t chi2ACE=0,chi2CCE=0;
 191   //     fDButil->ProcessCEdata("(sector<36)++gx++gy++lx++lx**2",fitResultsA,fitResultsC,nmaskedCE);
 192   fDButil->ProcessCEdata("(sector<36)++gx++gy++(lx-134)++(sector<36)*(lx-134)++(ly/lx)^2",fitResultsA,fitResultsC,nmaskedCE,chi2ACE,chi2CCE);
 193
 194   TVectorD fitCEResultsA(7), fitCEResultsC(7);
 195   Int_t    noutCE;
 196   Double_t chi2CEA=0,chi2CEC=0;
 197   AliTPCCalPad *time0 = fDButil->CreatePadTime0CE(fitCEResultsA, fitCEResultsC, noutCE, chi2CEA, chi2CEC);
 198   delete time0;
 199   //
 200   //
 201   TVectorD vecTEntries, vecTMean, vecTRMS, vecTMedian, vecQEntries, vecQMean, vecQRMS, vecQMedian;
 202   Float_t driftTimeA, driftTimeC;
 203   fDButil->ProcessCEgraphs(vecTEntries, vecTMean, vecTRMS, vecTMedian,
 204                           vecQEntries, vecQMean, vecQRMS, vecQMedian,
 205                           driftTimeA, driftTimeC );
 206   //
 207   //
 208   //
 209   //drift velocity using tracks
 210   //
 211   //     fitVdrift=fCalibDB->GetVdriftSplineFit("ALISPLINEFIT_MEAN_VDRIFT_COSMICS_ALL",irun);
 212   fitVdrift=fCalibDB->CreateVdriftSplineFit("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL",irun);
 213   //noise data Processing - see ProcessNoiseData function for description of the results
 214   TVectorD vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions;
 215   Int_t nonMaskedZero=0, nNaN=0;
 216   fDButil->ProcessNoiseData(vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions, nonMaskedZero, nNaN);
 217   //
 218   // comparisons
 219   //
 220   TVectorF pedestalDeviations;
 221   TVectorF noiseDeviations;
 222   TVectorF pulserQdeviations;
 223   Float_t varQMean;
 224   Int_t npadsOutOneTB;
 225   Int_t npadsOffAdd;
 226   fDButil->ProcessPedestalVariations(pedestalDeviations);
 227   fDButil->ProcessNoiseVariations(noiseDeviations);
 228   fDButil->ProcessPulserVariations(pulserQdeviations,varQMean,npadsOutOneTB,npadsOffAdd);
 229   //
 230   //L3 data
 231   //
 232   Float_t bz=AliTPCcalibDB::GetBz(irun);
 233   Char_t  l3pol=AliTPCcalibDB::GetL3Polarity(irun);
 234   //
 235   //QA data processing
 236   //
 237   TVectorD vQaOcc;
 238   TVectorD vQaQtot;
 239   TVectorD vQaQmax;
 240   fDButil->ProcessQAData(vQaOcc, vQaQtot, vQaQmax);
 241   //
 242   //calibration Pulser data processing
 243   //
 244   Int_t nOffChannels=0;
 245   TVectorD vTimePulser;
 246   nOffChannels=fDButil->GetNPulserOutliers();
 247   fDButil->ProcessPulser(vTimePulser);
 248   //
 249   //ALTRO data
 250   //
 251   Int_t nMasked=0;
 252   fDButil->ProcessALTROConfig(nMasked);
 253   //
 254   //Calib RAW data
 255   //
 256   Int_t nFailL1=-1;
 257   if (fCalibDB->GetCalibRaw()) nFailL1=fCalibDB->GetCalibRaw()->GetNFailL1Phase();
 258   //
 259   //production information
 260   //
 261   Int_t nalien=0,nRawAlien=0,nlocal=0,nRawLocal=0;
 262   //run type
 263   TObjString runType(AliTPCcalibDB::GetRunType(irun).Data());
 264   //
 265   //
 266   //
 267
 268   for (Int_t itime=startTime; itime<endTime; itime+=dtime){
 269     //
 270     TTimeStamp tstamp(itime);
 271     Float_t valuePressure  = fCalibDB->GetPressure(tstamp,irun,0);
 272     Float_t valuePressure2 = fCalibDB->GetPressure(tstamp,irun,1);
 273     Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,0);
 274     Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,1);
 275     //temperature fits
 276     TLinearFitter * fitter = 0;
 277     TVectorD vecTemp[10];
 278     for (Int_t itype=0; itype<5; itype++)
 279       for (Int_t iside=0; iside<2; iside++){
 280         fitter= tempMap->GetLinearFitter(itype,iside,tstamp);
 281         if (!fitter) continue;
 282         fitter->Eval();
 283         fitter->GetParameters(vecTemp[itype+iside*5]);
 284         delete fitter;
 285       }
 286     //
 287     //measured skirt temperatures
 288     //
 289     TVectorD vecSkirtTempA(18);
 290     TVectorD vecSkirtTempC(18);
 291     Int_t nsenTemp=tempArray->NumSensors();
 292     for (Int_t isenTemp=0;isenTemp<nsenTemp;++isenTemp){
 293       AliTPCSensorTemp *senTemp=(AliTPCSensorTemp*)tempArray->GetSensorNum(isenTemp);
 294       if (senTemp->GetType()!=3) continue;
 295       if (TMath::Sqrt(senTemp->GetX()*senTemp->GetX()+senTemp->GetY()*senTemp->GetY())<100) continue; //only skirt, outer FC vessel
 296       Double_t val=senTemp->GetValue(tstamp);
 297       if (senTemp->GetSide()==0)
 298         vecSkirtTempA[senTemp->GetSector()]=val;
 299       else
 300         vecSkirtTempC[senTemp->GetSector()]=val;
 301     }
 302     //
 303     //goofie data
 304     //
 305     TVectorD vecGoofie;
 306     if (goofieArray){
 307       vecGoofie.ResizeTo(goofieArray->NumSensors());
 308       for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){
 309         AliDCSSensor *gsensor = goofieArray->GetSensor(isensor);
 310         if (gsensor){
 311           vecGoofie[isensor] = gsensor->GetValue(tstamp);
 312         }
 313       }
 314     } else {
 315       vecGoofie.ResizeTo(19);
 316     }
 317     //
 318     static TVectorF voltagesIROC(36);
 319     static TVectorF voltagesIROCMedian(36);
 320     static TVectorF voltagesIROCNominal(36);
 321     static TVectorF voltagesIROCCurrentNominal(36);
 322     static TVectorF voltagesIROCStatus(36);
 323     static TVectorF voltagesIROCGoodFraction(36);
 324     //
 325     static TVectorF voltagesOROC(36);
 326     static TVectorF voltagesOROCMedian(36);
 327     static TVectorF voltagesOROCNominal(36);
 328     static TVectorF voltagesOROCCurrentNominal(36);
 329     static TVectorF voltagesOROCStatus(36);
 330     static TVectorF voltagesOROCGoodFraction(36);
 331
 332     for(Int_t j=0; j<36; j++){
 333       voltagesIROC[j]               = fCalibDB->GetChamberHighVoltage(irun, j,itime);
 334       voltagesIROCMedian[j]         = fCalibDB->GetChamberHighVoltageMedian(j);
 335       voltagesIROCNominal[j]        = fCalibDB->GetParameters()->GetNominalVoltage(j);
 336       voltagesIROCCurrentNominal[j] = fCalibDB->GetChamberCurrentNominalHighVoltage(j);
 337       voltagesIROCStatus[j]         = fCalibDB->GetChamberHVStatus(j);
 338       voltagesIROCGoodFraction[j]   = fCalibDB->GetChamberGoodHighVoltageFraction(j);
 339     }
 340
 341     for(Int_t j=36; j<72; j++) {
 342       voltagesOROC[j-36]               = fCalibDB->GetChamberHighVoltage(irun, j,itime);
 343       voltagesOROCMedian[j-36]         = fCalibDB->GetChamberHighVoltageMedian(j);
 344       voltagesOROCNominal[j-36]        = fCalibDB->GetParameters()->GetNominalVoltage(j);
 345       voltagesOROCCurrentNominal[j-36] = fCalibDB->GetChamberCurrentNominalHighVoltage(j);
 346       voltagesOROCStatus[j-36]         = fCalibDB->GetChamberHVStatus(j);
 347       voltagesOROCGoodFraction[j-36]   = fCalibDB->GetChamberGoodHighVoltageFraction(j);
 348     }
 349
 350     Double_t voltIROC = TMath::Median(36, voltagesIROC.GetMatrixArray());
 351     Double_t voltOROC = TMath::Median(36, voltagesOROC.GetMatrixArray());
 352     //
 353     Float_t  coverIA=AliTPCcalibDB::GetCoverVoltage(irun,0,itime);
 354     Float_t  coverIC=AliTPCcalibDB::GetCoverVoltage(irun,18,itime);
 355     Float_t  coverOA=AliTPCcalibDB::GetCoverVoltage(irun,36,itime);
 356     Float_t  coverOC=AliTPCcalibDB::GetCoverVoltage(irun,54,itime);
 357     Float_t  skirtA=AliTPCcalibDB::GetSkirtVoltage(irun,0,itime);
 358     Float_t  skirtC=AliTPCcalibDB::GetSkirtVoltage(irun,18,itime);
 359     Float_t  ggOffA=AliTPCcalibDB::GetGGoffsetVoltage(irun,0,itime);
 360     Float_t  ggOffC=AliTPCcalibDB::GetGGoffsetVoltage(irun,18,itime);
 361     //drift velocity
 362     Float_t dvCorr=-5;
 363     if (fitVdrift) dvCorr=fitVdrift->Eval(itime);
 364     //data taking active
 365     Bool_t dataTakingActive=fCalibDB->IsDataTakingActive((time_t)itime);
 366
 367     //tempMap->GetLinearFitter(0,0,itime);
 368     (*fPcstream)<<"dcs"<<
 369       "run="<<irun<<
 370       "time="<<itime<<
 371       "startTimeGRP="<<startTimeGRP<<
 372       "stopTimeGRP="<<stopTimeGRP<<
 373       "dataTakingActive="<<dataTakingActive<<
 374       //run type
 375       "runType.="<<&runType<<
 376       // voltage setting
 377       "VIROC.="               << &voltagesIROC<<
 378       "VIROCMedian.="         << &voltagesIROCMedian<<
 379       "VIROCNominal.="        << &voltagesIROCNominal <<
 380       "VIROCCurrentNominal.=" << &voltagesIROCCurrentNominal <<
 381       "VIROCGoodHVFraction.=" << &voltagesIROCGoodFraction <<
 382       "VIROCStatus.="         << &voltagesIROCStatus <<
 383       //
 384       "VOROC.="               << &voltagesOROC<<
 385       "VOROCMedian.="         << &voltagesOROCMedian<<
 386       "VOROCNominal.="        << &voltagesOROCNominal <<
 387       "VOROCCurrentNominal.=" << &voltagesOROCCurrentNominal <<
 388       "VOROCGoodHVFraction.=" << &voltagesOROCGoodFraction <<
 389       "VOROCStatus.="         << &voltagesOROCStatus <<
 390       "medianVIROC="<<voltIROC<<
 391       "medianVOROC="<<voltOROC<<
 392       "coverIA=" << coverIA <<
 393       "coverIC=" << coverIC <<
 394       "coverOA=" << coverOA <<
 395       "coverOC=" << coverOC <<
 396       "skirtA=" << skirtA <<
 397       "skirtC=" << skirtC <<
 398       "ggOffA=" << ggOffA <<
 399       "ggOffC=" << ggOffC <<
 400       //
 401       "ptrel0="<<ptrelative0<<  // deltaTP/TP  - A side
 402       "ptrel1="<<ptrelative1<<  // deltaTP/TPC - C side
 403       "goofie.="<<&vecGoofie<<
 404       "goofieE.="<<&vecEntries<<
 405       "goofieMean.="<<&vecMean<<
 406       "goofieMedian.="<<&vecMedian<<
 407       "goofieRMS.="<<&vecRMS<<
 408       //
 409       "press="<<valuePressure<<
 410       "press2="<<valuePressure2<<
 411       "temp00.="<<&vecTemp[0]<<
 412       "temp10.="<<&vecTemp[1]<<
 413       "temp20.="<<&vecTemp[2]<<
 414       "temp30.="<<&vecTemp[3]<<
 415       "temp40.="<<&vecTemp[4]<<
 416       "temp01.="<<&vecTemp[5]<<
 417       "temp11.="<<&vecTemp[6]<<
 418       "temp21.="<<&vecTemp[7]<<
 419       "temp31.="<<&vecTemp[8]<<
 420       "temp41.="<<&vecTemp[9]<<
 421       "tempSkirtA.="<<&vecSkirtTempA<<
 422       "tempSkirtC.="<<&vecSkirtTempC;
 423
 424     ProcessDrift(irun, itime);
 425     ProcessDriftCE(irun,itime);
 426     ProcessDriftAll(irun,itime);
 427     //    ProcessKryptonTime(irun,itime);
 428     ProcessCTP(irun,itime);
 429     ProcessAlign(irun,itime);
 430     ProcessGain(irun,itime);
 431     //ProcessDriftCERef();
 432     //ProcessPulserRef();
 433     //ProcessCurrent(irun,itime);
 434
 435
 436     (*fPcstream)<<"dcs"<<
 437       //noise data
 438       "meanNoise.="<<&vNoiseMean<<
 439       "meanNoiseSen.="<<&vNoiseMeanSenRegions<<
 440       "rmsNoise.="<<&vNoiseRMS<<
 441       "rmsNoiseSen.="<<&vNoiseRMSSenRegions<<
 442       "zeroNoise="<<nonMaskedZero<<
 443       "nNaN="<<nNaN<<
 444       //QA data
 445       "occQA.="  << &vQaOcc  <<
 446       "qQA.="    << &vQaQtot <<
 447       "qmaxQA.=" << &vQaQmax <<
 448       //pulser data
 449       "timePulser.=" << &vTimePulser <<
 450       "nOffPulser="<<nOffChannels<<
 451       //altro data
 452       "nMasked="<<nMasked<<
 453       //ce data -Jens version
 454       "CEfitA.="<<&fitResultsA<<
 455       "CEfitC.="<<&fitResultsC<<
 456       "nmaskedCE="<<nmaskedCE<<
 457       "chi2ACE="<<chi2ACE<<
 458       "chi2CCE="<<chi2CCE<<
 459       //ce data new - MI version
 460       "CEfitAMI.="<<&fitCEResultsA<<
 461       "CEfitCMI.="<<&fitCEResultsC<<
 462       "chi2CEA="<<chi2CEA<<
 463       "chi2CEC="<<chi2CEC<<
 464       //
 465       //ce graph data
 466       "CEgrTEntries.="<<&vecTEntries<<
 467       "CEgrTMean.="<<&vecTMean<<
 468       "CEgrTRMS.="<<&vecTRMS<<
 469       "CEgrTMedian.="<<&vecTMedian<<
 470       "CEgrQEntries.="<<&vecQEntries<<
 471       "CEgrQMean.="<<&vecQMean<<
 472       "CEgrQRMS.="<<&vecQRMS<<
 473       "CEgrQMedian.="<<&vecQMedian<<
 474       "CEgrDriftA="<<driftTimeA<<
 475       "CEgrDriftC="<<driftTimeC<<
 476       //calib raw data
 477       "nFailL1="<<nFailL1<<
 478       // b field
 479       "Bz="<< bz <<
 480       "L3polarity="<<l3pol<<
 481       // production information
 482       "nalien="<<nalien<<
 483       "nRawAlien="<<nRawAlien<<
 484       "nlocal="<<nlocal<<
 485       "nRawLocal="<<nRawLocal<<
 486       //comparisons with ref data
 487       "pedestalDeviations.="<<&pedestalDeviations<<
 488       "noiseDeviations.="<<&noiseDeviations<<
 489       "pulserQdeviations.="<<&pulserQdeviations<<
 490       //         "pulserVarQMean="<<varQMean<<
 491       "pulserNpadsOutOneTB="<<npadsOutOneTB<<
 492       "pulserNpadsOffAdd="<<npadsOffAdd<<
 493       "driftCorrCosmAll="<<dvCorr<<
 494       "\n";
 495   }//end run loop
 496 }
 497
 498
 499
 500
 501
 502
 503 void AliTPCcalibSummary::ProcessDrift(Int_t run, Int_t timeStamp){
 504   //
 505   // dump drift calibration data to the tree
 506   //
 507   TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
 508   TGraphErrors *laserA[3]={0,0,0};
 509   TGraphErrors *laserC[3]={0,0,0};
 510   TGraphErrors *cosmicAll=0;
 511   static Double_t     vlaserA[3]={0,0,0};
 512   static Double_t     vlaserC[3]={0,0,0};
 513   static Double_t     vcosmicAll=0;
 514   static Double_t     vdrift1=0;
 515   vdrift1=fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);
 516
 517   if (array){
 518     laserA[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_A");
 519     laserA[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A");
 520     laserA[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A");
 521     laserC[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_C");
 522     laserC[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C");
 523     laserC[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C");
 524     cosmicAll =(TGraphErrors*)array->FindObject("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL");
 525   }
 526   if (laserA[0]) vlaserA[0]= AliTPCcalibDButil::EvalGraphConst(laserA[0],timeStamp);
 527   if (laserA[1]) vlaserA[1]= AliTPCcalibDButil::EvalGraphConst(laserA[1],timeStamp);
 528   if (laserA[2]) vlaserA[2]= AliTPCcalibDButil::EvalGraphConst(laserA[2],timeStamp);
 529   if (laserC[0]) vlaserC[0]= AliTPCcalibDButil::EvalGraphConst(laserC[0],timeStamp);
 530   if (laserC[1]) vlaserC[1]= AliTPCcalibDButil::EvalGraphConst(laserC[1],timeStamp);
 531   if (laserC[2]) vlaserC[2]= AliTPCcalibDButil::EvalGraphConst(laserC[2],timeStamp);
 532   if (cosmicAll) vcosmicAll= AliTPCcalibDButil::EvalGraphConst(cosmicAll,timeStamp);
 533   (*fPcstream)<<"dcs"<<
 534     "vlaserA0="<<vlaserA[0]<<
 535     "vlaserA1="<<vlaserA[1]<<
 536     "vlaserA2="<<vlaserA[2]<<
 537     "vlaserC0="<<vlaserC[0]<<
 538     "vlaserC1="<<vlaserC[1]<<
 539     "vlaserC2="<<vlaserC[2]<<
 540     "vcosmicAll="<<vcosmicAll<<
 541     "vdrift1="<<vdrift1;
 542
 543   //
 544   // define distance to measurement
 545   //
 546   static Double_t dlaserA=0;
 547   static Double_t dlaserC=0;
 548   static Double_t dcosmic=0;
 549   static Double_t slaserA=0;
 550   static Double_t slaserC=0;
 551   static Double_t scosmic=0;
 552   static Double_t  vclaserA[3]={0,0,0};
 553   static Double_t  vclaserC[3]={0,0,0};
 554   static Double_t  vccosmicAll=0;
 555   for (Int_t i=0;i<3;i++){
 556     if (laserA[i]) AliTPCcalibDButil::GetNearest(laserA[i],timeStamp,dlaserA,vclaserA[i]);
 557     if (laserC[i]) AliTPCcalibDButil::GetNearest(laserC[i],timeStamp,dlaserC,vclaserC[i]);
 558   }
 559   if (cosmicAll) AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dcosmic,vccosmicAll);
 560   (*fPcstream)<<"dcs"<<
 561     "vclaserA0="<<vclaserA[0]<<
 562     "vclaserA1="<<vclaserA[1]<<
 563     "vclaserA2="<<vclaserA[2]<<
 564     "vclaserC0="<<vclaserC[0]<<
 565     "vclaserC1="<<vclaserC[1]<<
 566     "vclaserC2="<<vclaserC[2]<<
 567     "vccosmicAll="<<vccosmicAll<<
 568     "dlaserA="<<dlaserA<<
 569     "dlaserC="<<dlaserC<<
 570     "dcosmic="<<dcosmic<<
 571     "slaserA="<<slaserA<<
 572     "slaserC="<<slaserC<<
 573     "scosmic="<<scosmic;
 574
 575   static TGeoMatrix * matrixAlign=0;
 576   static Double_t twistX=0;
 577   static Double_t twistY=0;
 578   if (matrixAlign==0){
 579     AliTPCComposedCorrection * corr =  (AliTPCComposedCorrection *)array->FindObject("FitCorrectionTime");
 580     if (!corr) {
 581       matrixAlign=new TGeoHMatrix;
 582
 583     }
 584     if (corr){
 585        AliTPCCalibGlobalMisalignment *align = (AliTPCCalibGlobalMisalignment*)corr->GetCorrections()->FindObject("FitAlignTime");
 586        AliTPCExBTwist *twist  = (AliTPCExBTwist*)corr->GetCorrections()->FindObject("FitExBTwistTime");
 587        if (twist){
 588          twistX=twist->GetXTwist();
 589          twistY=twist->GetYTwist();
 590          //delete twist;
 591        }
 592        if (align && align->GetAlignGlobal()){
 593          matrixAlign =  (TGeoMatrix*) (align->GetAlignGlobal()->Clone());
 594          //delete align;
 595        }
 596     }
 597   }
 598   (*fPcstream)<<"dcs"<<
 599     "alignTime.="<<matrixAlign<<
 600     "twistX="<<twistX<<
 601     "twistY="<<twistY;
 602 }
 603
 604 void AliTPCcalibSummary::ProcessDriftCE(Int_t run,Int_t timeStamp){
 605   //
 606   // dump drift calibration data CE
 607   //
 608   TObjArray *arrT=fCalibDB->GetCErocTtime();
 609   AliTPCParam *param=fCalibDB->GetParameters();
 610   static TVectorD tdriftCE(74);
 611   static TVectorD tndriftCE(74);
 612   static TVectorD vdriftCE(74);
 613   static TVectorD tcdriftCE(74);
 614   static TVectorD tddriftCE(74);
 615   static Double_t ltime0A=0.;
 616   static Double_t ltime0C=0.;
 617   //
 618   //
 619   //
 620   ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
 621   ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);
 622   //
 623   for (Int_t i=0; i<arrT->GetEntries();i++){
 624     tdriftCE[i]=0;
 625     vdriftCE[i]=0;
 626     TGraph *graph = (TGraph*)arrT->At(i);
 627     if (!graph) continue;
 628     tdriftCE[i]=AliTPCcalibDButil::EvalGraphConst(graph,timeStamp);
 629     Double_t deltaT,gry;
 630     AliTPCcalibDButil::GetNearest(graph,timeStamp,deltaT,gry);
 631     tndriftCE[i]=graph->GetN();
 632     tcdriftCE[i]=gry;
 633     tddriftCE[i]=deltaT;
 634     if (i%36<18){
 635       vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
 636     }else{
 637       vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
 638     }
 639   }
 640   // export values
 641   (*fPcstream)<<"dcs"<<
 642     "tdriftCE.="<<&tdriftCE<<    // arrival time
 643     "vdriftCE.="<<&vdriftCE<<    // derived drift velocity per chamber
 644     "tndriftCE.="<<&tndriftCE<<  // number of points (chambers)
 645     "tcdriftCE.="<<&tcdriftCE<<  // constant evaluation - nearest point used
 646     "tddriftCE.="<<&tddriftCE<<  // distance to closest measuement
 647     "ltime0A="<<ltime0A<<        // laser offset expected in reconstruction
 648     "ltime0C="<<ltime0C;         // laser offset expected in reconstruction
 649    }
 650
 651
 652 void AliTPCcalibSummary::ProcessDriftAll(Int_t run,Int_t timeStamp){
 653   //
 654   // dump drift calibration data  all calibrations form DB util
 655   // test of utils
 656   static Double_t vdriftCEA=0, vdriftCEC=0, vdriftCEM=0;
 657   static Double_t vdriftLTA=0, vdriftLTC=0, vdriftLTM=0;
 658   static Double_t vdriftLTAon=0, vdriftLTCon=0, vdriftLTMon=0;
 659   static Double_t vdriftITS=0;
 660   static Double_t vdriftP=0;
 661   static Double_t dcea=0, dcec=0, dcem=0,  dla=0,dlc=0,dlm=0, dlaon=0,dlcon=0,dlmon=0, dp=0;
 662   static Double_t dits=0;
 663   static Double_t ltime0A=0.;
 664   static Double_t ltime0C=0.;
 665   static Double_t ctime0=0.;
 666   static Double_t vdrift1=0;
 667   vdrift1= fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);
 668   vdriftP = fDButil->GetVDriftTPC(dp, run, timeStamp, 86400, 3600,0);
 669   ctime0 = AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, 36000, 3600,0);
 670   //
 671   vdriftCEA= fDButil->GetVDriftTPCCE(dcea,run,timeStamp,36000,0);
 672   vdriftCEC= fDButil->GetVDriftTPCCE(dcec,run,timeStamp,36000,1);
 673   vdriftCEM= fDButil->GetVDriftTPCCE(dcem,run,timeStamp,36000,2);
 674   //
 675   vdriftLTA= fDButil->GetVDriftTPCLaserTracks(dla,run,timeStamp,36000,0);
 676   vdriftLTC= fDButil->GetVDriftTPCLaserTracks(dlc,run,timeStamp,36000,1);
 677   vdriftLTM= fDButil->GetVDriftTPCLaserTracks(dlm,run,timeStamp,36000,2);
 678   //
 679   vdriftLTAon= fDButil->GetVDriftTPCLaserTracksOnline(dlaon,run,timeStamp,36000,0);
 680   vdriftLTCon= fDButil->GetVDriftTPCLaserTracksOnline(dlcon,run,timeStamp,36000,1);
 681   vdriftLTMon= fDButil->GetVDriftTPCLaserTracksOnline(dlmon,run,timeStamp,36000,2);
 682   //
 683   vdriftITS= fDButil->GetVDriftTPCITS(dits, run,timeStamp);
 684   //
 685   ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
 686   ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);
 687
 688   (*fPcstream)<<"dcs"<<
 689     //
 690     "vdriftCEA="<<vdriftCEA<<   // drift velocity CE
 691     "vdriftCEC="<<vdriftCEC<<
 692     "vdriftCEM="<<vdriftCEM<<
 693     "dcea="<<dcea<<
 694     "dcec="<<dcec<<
 695     "dcem="<<dcem<<
 696     "vdriftLTA="<<vdriftLTA<<   // drift velocity laser tracks
 697     "vdriftLTC="<<vdriftLTC<<
 698     "vdriftLTM="<<vdriftLTM<<
 699     "dla="<<dla<<
 700     "dlc="<<dlc<<
 701     "dlm="<<dlm<<
 702     "vdriftLTAon="<<vdriftLTAon<<   // drift velocity laser tracks and CE from online algorithm
 703     "vdriftLTCon="<<vdriftLTCon<<
 704     "vdriftLTMon="<<vdriftLTMon<<
 705     "dlaOn="<<dlaon<<
 706     "dlcOn="<<dlcon<<
 707     "dlmOn="<<dlmon<<
 708     //
 709     //
 710     "vdriftITS="<<vdriftITS<<
 711     "dits="<<dits<<
 712     "ctime0="<<ctime0<<
 713     "vdriftP="<<vdriftP<<       // drift velocity comsic
 714     "dp="<<dp<<
 715     "vdrift1="<<vdrift1;        // combined drift velocity
 716
 717 }
 718
 719
 720
 721 void AliTPCcalibSummary::ProcessKryptonTime(Int_t run, Int_t timeStamp){
 722   //
 723   // Dumping  krypton calibration results
 724   //
 725   static TObjArray * krArray=0;
 726   if (!krArray) {
 727     AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGainKrypton", run);
 728     if (entry){
 729       krArray = (TObjArray*)entry->GetObject();
 730     }
 731   }
 732   static TVectorD krMean(74);
 733   static TVectorD krErr(74);
 734   static TVectorD krDist(74);
 735   TGraphErrors *gr=0;
 736   Double_t deltaT=0,gry=0;
 737   if (krArray){
 738     for (Int_t isec=0; isec<72; isec++){
 739       krMean[isec]=0;
 740       krDist[isec]=0;
 741       krErr[isec]=0;
 742       gr=(TGraphErrors*)krArray->At(isec);
 743       if (gr) {
 744         krMean[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
 745         AliTPCcalibDButil::GetNearest(gr, timeStamp,deltaT,gry);
 746         krDist[isec]=deltaT;
 747       }
 748       if (72+isec<krArray->GetEntries()) {
 749         gr=(TGraphErrors*)krArray->At(72+isec);
 750         if (gr) krErr[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
 751       }
 752     }
 753     krMean[72]= TMath::Median(36,krMean.GetMatrixArray());
 754     krMean[73]= TMath::Median(36,&(krMean.GetMatrixArray()[36]));
 755     krErr[72]= TMath::Median(36,krErr.GetMatrixArray());
 756     krErr[73]= TMath::Median(36,&(krErr.GetMatrixArray()[36]));
 757   }
 758   (*fPcstream)<<"dcs"<<
 759     "krMean.="<<&krMean<<
 760     "krErr.="<<&krErr<<
 761     "krDist.="<<&krDist;
 762 }
 763
 764 void AliTPCcalibSummary::ProcessCTP(Int_t irun, Int_t timeStamp){
 765   //
 766   //
 767   //
 768   static TClonesArray *pcarray = new TClonesArray("AliCTPInputTimeParams",1);
 769   static AliCTPTimeParams *ctpParams =0;
 770   ctpParams = fCalibDB->GetCTPTimeParams(); //
 771   const TObjArray        *arr = ctpParams->GetInputTimeParams();
 772   pcarray->ExpandCreateFast(TMath::Max(arr->GetEntries(),1));
 773   for (Int_t i=0; i<arr->GetEntries(); i++){
 774     new ((*pcarray)[i]) AliCTPInputTimeParams(*((AliCTPInputTimeParams*)arr->At(i)));
 775   }
 776   (*fPcstream)<<"ctp"<<
 777     "run="<<irun<<
 778     "time="<<timeStamp<<
 779     "ctpP.="<<ctpParams<<
 780     "ctpArr="<<pcarray<<
 781     "\n";
 782   (*fPcstream)<<"dcs"<<
 783     "ctpP.="<<ctpParams<<
 784     "ctpArr="<<pcarray;
 785 }
 786
 787 void AliTPCcalibSummary::ProcessGain(Int_t irun, Int_t timeStamp){
 788   //
 789   // Dump gain related information to the tree
 790   //
 791   static Float_t  gainCosmic = 0;
 792   static Float_t  gainMIP = 0;
 793   static Float_t  attachMIP = 0;
 794   static Double_t dMIP=0;
 795   Double_t dummy=0;
 796   static TVectorD vGainGraphIROC(36);
 797   static TVectorD vGainGraphOROCmed(36);
 798   static TVectorD vGainGraphOROClong(36);
 799   static TVectorD vGainGraphIROCErr(36);
 800   static TVectorD vGainGraphOROCmedErr(36);
 801   static TVectorD vGainGraphOROClongErr(36);
 802   //
 803   static TVectorD vGainQMaxGraphRegion(3);
 804   static TVectorD vGainQTotGraphRegion(3);
 805   //
 806   static TGraphErrors ggrPadEqualMax(36);
 807   static TGraphErrors ggrPadEqualTot(36);
 808   //
 809   static TGraphErrors ggrDipAngleMaxShort;
 810   static TGraphErrors ggrDipAngleMaxMedium;
 811   static TGraphErrors ggrDipAngleMaxLong;
 812   static TGraphErrors ggrDipAngleMaxAbsolute;
 813   //
 814   static TGraphErrors ggrDipAngleTotShort;
 815   static TGraphErrors ggrDipAngleTotMedium;
 816   static TGraphErrors ggrDipAngleTotLong;
 817   static TGraphErrors ggrDipAngleTotAbsolute;
 818   //
 819   static TVectorD vFitDipAngleParMaxShort(3);
 820   static TVectorD vFitDipAngleParMaxMedium(3);
 821   static TVectorD vFitDipAngleParMaxLong(3);
 822   static TVectorD vFitDipAngleParMaxAbsolute(3);
 823   //
 824   static TVectorD vFitDipAngleParTotShort(3);
 825   static TVectorD vFitDipAngleParTotMedium(3);
 826   static TVectorD vFitDipAngleParTotLong(3);
 827   static TVectorD vFitDipAngleParTotAbsolute(3);
 828
 829
 830   vGainGraphIROC.Zero();
 831   vGainGraphOROCmed.Zero();
 832   vGainGraphOROClong.Zero();
 833   vGainGraphIROCErr.Zero();
 834   vGainGraphOROCmedErr.Zero();
 835   vGainGraphOROClongErr.Zero();
 836   vGainQMaxGraphRegion.Zero();
 837   vGainQTotGraphRegion.Zero();
 838   TGraphErrors grDummy;
 839   TObjArray * gainSplines = fCalibDB->GetTimeGainSplinesRun(irun);
 840   if (gainSplines) {
 841     TGraphErrors * graphMIP = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_BEAM_ALL");
 842     TGraphErrors * graphCosmic = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_COSMIC_ALL");
 843     TGraphErrors * graphAttach = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_ATTACHMENT_BEAM_ALL");
 844     //
 845     TGraphErrors * grPadEqualQMax = (TGraphErrors * ) gainSplines->FindObject("TGRAPHERRORS_MEANQMAX_PADREGIONGAIN_BEAM_ALL");
 846     TGraphErrors * grPadEqualQTot = (TGraphErrors * ) gainSplines->FindObject("TGRAPHERRORS_MEANQTOT_PADREGIONGAIN_BEAM_ALL");
 847     //
 848     TGraphErrors * graphGainIROC       = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_SHORT_BEAM_ALL");
 849     TGraphErrors * graphGainOROCMedium = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_MEDIUM_BEAM_ALL");
 850     TGraphErrors * graphGainOROCLong   = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_LONG_BEAM_ALL");
 851     //
 852     //
 853     TF1*  funDipAngleMax[4]={0x0,0x0,0x0,0x0};
 854     TF1*  funDipAngleTot[4]={0x0,0x0,0x0,0x0};
 855     TGraphErrors*  grDipAngleMax[4]={0x0,0x0,0x0,0x0};
 856     TGraphErrors*  grDipAngleTot[4]={0x0,0x0,0x0,0x0};
 857     const char* names[4]={"SHORT","MEDIUM","LONG","ABSOLUTE"};
 858     for (Int_t iPadRegion=0; iPadRegion<4; ++iPadRegion) {
 859       funDipAngleMax[iPadRegion]=(TF1*) gainSplines->FindObject(Form("TF1_QMAX_DIPANGLE_%s_BEAM_ALL",names[iPadRegion]));
 860       funDipAngleTot[iPadRegion]=(TF1*) gainSplines->FindObject(Form("TF1_QTOT_DIPANGLE_%s_BEAM_ALL",names[iPadRegion]));
 861       grDipAngleMax[iPadRegion]= (TGraphErrors*) gainSplines->FindObject(Form("TGRAPHERRORS_QMAX_DIPANGLE_%s_BEAM_ALL",names[iPadRegion]));
 862       grDipAngleTot[iPadRegion]= (TGraphErrors*) gainSplines->FindObject(Form("TGRAPHERRORS_QTOT_DIPANGLE_%s_BEAM_ALL",names[iPadRegion]));
 863     }
 864     //
 865     for(Int_t iPar=0; iPar < 3; iPar++) {
 866       if (funDipAngleMax[0]) vFitDipAngleParMaxShort(iPar)    = funDipAngleMax[0]->GetParameter(iPar);
 867       if (funDipAngleMax[1]) vFitDipAngleParMaxMedium(iPar)   = funDipAngleMax[1]->GetParameter(iPar);
 868       if (funDipAngleMax[2]) vFitDipAngleParMaxLong(iPar)     = funDipAngleMax[2]->GetParameter(iPar);
 869       if (funDipAngleMax[3]) vFitDipAngleParMaxAbsolute(iPar) = funDipAngleMax[3]->GetParameter(iPar);
 870       //
 871       if (funDipAngleTot[0]) vFitDipAngleParTotShort(iPar)    = funDipAngleTot[0]->GetParameter(iPar);
 872       if (funDipAngleTot[1]) vFitDipAngleParTotMedium(iPar)   = funDipAngleTot[1]->GetParameter(iPar);
 873       if (funDipAngleTot[2]) vFitDipAngleParTotLong(iPar)     = funDipAngleTot[2]->GetParameter(iPar);
 874       if (funDipAngleTot[3]) vFitDipAngleParTotAbsolute(iPar) = funDipAngleTot[3]->GetParameter(iPar);
 875     }
 876     //
 877     if (grDipAngleMax[0]) ggrDipAngleMaxShort    = * grDipAngleMax[0];
 878     if (grDipAngleMax[1]) ggrDipAngleMaxMedium   = * grDipAngleMax[1];
 879     if (grDipAngleMax[2]) ggrDipAngleMaxLong     = * grDipAngleMax[2];
 880     if (grDipAngleMax[3]) ggrDipAngleMaxAbsolute = * grDipAngleMax[3];
 881     //
 882     if (grDipAngleTot[0]) ggrDipAngleTotShort    = * grDipAngleTot[0];
 883     if (grDipAngleTot[1]) ggrDipAngleTotMedium   = * grDipAngleTot[1];
 884     if (grDipAngleTot[2]) ggrDipAngleTotLong     = * grDipAngleTot[2];
 885     if (grDipAngleTot[3]) ggrDipAngleTotAbsolute = * grDipAngleTot[3];
 886     //
 887     //
 888     TGraphErrors *grPadEqualMax = (TGraphErrors * ) gainSplines->FindObject("TGRAPHERRORS_MEANQMAX_PADREGIONGAIN_BEAM_ALL");
 889     TGraphErrors *grPadEqualTot = (TGraphErrors * ) gainSplines->FindObject("TGRAPHERRORS_MEANQTOT_PADREGIONGAIN_BEAM_ALL");
 890     if (grPadEqualMax) ggrPadEqualMax = *grPadEqualMax;
 891     if (grPadEqualTot) ggrPadEqualTot = *grPadEqualTot;
 892
 893
 894     if (graphGainIROC && graphGainOROCMedium && graphGainOROCLong) {
 895       Double_t x=0,y=0;
 896       for (Int_t i=0; i<36; ++i){
 897         graphGainIROC->GetPoint(i,x,y);
 898         vGainGraphIROC(i)=y;
 899         graphGainOROCMedium->GetPoint(i,x,y);
 900         vGainGraphOROCmed(i)=y;
 901         graphGainOROCLong->GetPoint(i,x,y);
 902         vGainGraphOROClong(i)=y;
 903         //errors
 904         vGainGraphIROCErr(i)     = graphGainIROC->GetEY()[i];
 905         vGainGraphOROCmedErr(i)  = graphGainOROCMedium->GetEY()[i];
 906         vGainGraphOROClongErr(i) = graphGainOROCLong->GetEY()[i];
 907       }
 908        for (Int_t i=0; i<3; ++i){
 909          vGainQMaxGraphRegion[i]=grPadEqualQMax->GetY()[i];
 910          vGainQTotGraphRegion[i]=grPadEqualQTot->GetY()[i];
 911        }
 912     }
 913
 914     if (graphMIP) gainMIP = AliTPCcalibDButil::EvalGraphConst(graphMIP,timeStamp);
 915     if (graphCosmic) gainCosmic = AliTPCcalibDButil::EvalGraphConst(graphCosmic,timeStamp);
 916     if (graphAttach) attachMIP = AliTPCcalibDButil::EvalGraphConst(graphAttach,timeStamp);
 917     if (graphMIP)  AliTPCcalibDButil::GetNearest(graphMIP, timeStamp, dMIP,dummy);
 918   }
 919
 920   // time dependence of gain
 921   (*fPcstream)<<"dcs"<<
 922     "grPadEqualMax.=" << &ggrPadEqualMax <<
 923     "grPadEqualTot.=" << &ggrPadEqualTot <<
 924     "rocGainIROC.="            << &vGainGraphIROC        <<
 925     "rocGainOROCMedium.="      << &vGainGraphOROCmed     <<
 926     "rocGainOROCLong.="        << &vGainGraphOROClong    <<
 927     "rocGainErrIROC.="         << &vGainGraphIROCErr     <<
 928     "rocGainErrOROCMedium.="   << &vGainGraphOROCmedErr  <<
 929     "rocGainErrOROCLong.="     << &vGainGraphOROClongErr <<
 930     "vGainQMaxGraphRegion.="   << &vGainQMaxGraphRegion<<
 931     "vGainQTotGraphRegion.="   << &vGainQTotGraphRegion<<
 932     //
 933     "vFitDipAngleParMaxShort.="   << &vFitDipAngleParMaxShort<<
 934     "vFitDipAngleParMaxMedium.="  << &vFitDipAngleParMaxMedium<<
 935     "vFitDipAngleParMaxLong.="    << &vFitDipAngleParMaxLong<<
 936     "vFitDipAngleParMaxAbsolute.="<< &vFitDipAngleParMaxAbsolute<<
 937     //
 938     "vFitDipAngleParTotShort.="   << &vFitDipAngleParTotShort<<
 939     "vFitDipAngleParTotMedium.="  << &vFitDipAngleParTotMedium<<
 940     "vFitDipAngleParTotLong.="    << &vFitDipAngleParTotLong<<
 941     "vFitDipAngleParTotAbsolute.="<< &vFitDipAngleParTotAbsolute<<
 942     //
 943     "grDipAngleMaxShort.="        << &ggrDipAngleMaxShort    <<
 944     "grDipAngleMaxMedium.="       << &ggrDipAngleMaxMedium   <<
 945     "grDipAngleMaxLong.="         << &ggrDipAngleMaxLong     <<
 946     "grDipAngleMaxAbsolute.="     << &ggrDipAngleMaxAbsolute <<
 947     //
 948     "grDipAngleTotShort.="        << &ggrDipAngleTotShort    <<
 949     "grDipAngleTotMedium.="       << &ggrDipAngleTotMedium   <<
 950     "grDipAngleTotLong.="         << &ggrDipAngleTotLong     <<
 951     "grDipAngleTotAbsolute.="     << &ggrDipAngleTotAbsolute <<
 952     //
 953     "gainMIP="                 << gainMIP                <<
 954     "attachMIP="               << attachMIP              <<
 955     "dMIP="                    << dMIP                   <<
 956     "gainCosmic="              << gainCosmic;
 957 }
 958
 959
 960 void AliTPCcalibSummary::ProcessAlign(Int_t run, Int_t timeStamp){
 961   //
 962   // Proccess alignment
 963   //
 964   TString   grnames[12]={"ALIGN_ITS", "ALIGN_ITSP", "ALIGN_ITSM", "ALIGN_ITSB",
 965                          "ALIGN_TRD", "ALIGN_TRDP", "ALIGN_TRDM","ALIGN_TRDB",
 966                          "ALIGN_TOF", "ALIGN_TOFP", "ALIGN_TOFM","ALIGN_TOFB"};
 967   TString   grpar[9]={"DELTAPSI", "DELTATHETA", "DELTAPHI",
 968                       "DELTAX", "DELTAY", "DELTAZ",
 969                       "DRIFTVD", "T0", "VDGY"};
 970   static Double_t values[12*9];
 971   static Double_t errs[12*9];
 972
 973   TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
 974   TGraphErrors *gr=0;
 975   for (Int_t idet=0; idet<12; idet++){
 976     for (Int_t ipar=0; ipar<9; ipar++){
 977       TString grName=grnames[idet];
 978       grName+="_TPC_";
 979       grName+=grpar[ipar];
 980       if (array){
 981         gr = (TGraphErrors*)array->FindObject(grName.Data());
 982       }
 983       values[9*idet+ipar]=0;
 984       errs[9*idet+ipar]=0;
 985       if (gr) values[9*idet+ipar]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
 986       (*fPcstream)<<"dcs"<<
 987         Form("%s=",grName.Data())<<values[9*idet+ipar];
 988       (*fPcstream)<<"align"<<
 989         Form("%s=",grName.Data())<<values[9*idet+ipar];
 990     }
 991   }
 992   (*fPcstream)<<"align"<<
 993     "time="<<timeStamp<<
 994     "run="<<run<<
 995     "\n";
 996 }
 997
 998
 999 void AliTPCcalibSummary::ProcessDriftCERef(){
1000   //
1001   // Get fit of residuals if CE in respect with reference
1002   // data
1003   //
1004   static TVectorD  sec(72);
1005   static TVectorD vec0(72);
1006   static TVectorD vecLy(72);
1007   static TVectorD vecLx(72);
1008   static TVectorD vecChi2(72);
1009   static TVectorD vecN(72);
1010   //
1011   static TVectorD vecA0(72);
1012   static TVectorD vecALy(72);
1013   static TVectorD vecALx(72);
1014   static TVectorD vecAChi2(72);
1015   //
1016   static TVectorD vecASide(4);
1017   static TVectorD vecCSide(4);
1018   static Bool_t isCalc=kFALSE;
1019
1020   TFile f("calPads.root");
1021   TFile fref("calPadsRef.root");
1022   TTree * tree = (TTree*)f.Get("calPads");
1023   TTree * treeRef = (TTree*)fref.Get("calPads");
1024   tree->AddFriend(treeRef,"R");
1025   tree->SetAlias("inCE","((CEQmean.fElements>35)&&abs(CETmean.fElements)<1.5&&abs(CETrms.fElements/1.2-1)<0.2)");  // outlyerTrms
1026   tree->SetAlias("inCER","((R.CEQmean.fElements>35)&&abs(R.CETmean.fElements)<1.5&&abs(R.CETrms.fElements/1.2-1)<0.2)");  // outlyerTrms
1027   //
1028   if (!isCalc){
1029     // make fits only once
1030     TStatToolkit toolkit;
1031     Double_t chi2=0;
1032     Int_t    npoints=0;
1033     TVectorD param;
1034     TMatrixD covar;
1035     tree->SetAlias("dt","CETmean.fElements-R.CETmean.fElements");
1036     TCut cutAll ="inCE&&inCER&&abs(CETmean.fElements-R.CETmean.fElements)<0.5";
1037     TString  fstringG="";              // global part
1038     fstringG+="ly.fElements++";
1039     fstringG+="(lx.fElements-134.)++";
1040     for (Int_t isec=0; isec<72; isec++){
1041       TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
1042       if (npoints<3) continue;
1043       printf("Sector=%d\n",isec);
1044       vec0[isec]=param[0];
1045       vecLy[isec]=param[1];
1046       vecLx[isec]=param[2];
1047       sec[isec]=isec;
1048       vecN[isec]=npoints;
1049       vecChi2[isec]=TMath::Sqrt(chi2/npoints);
1050
1051       TStatToolkit::FitPlane(tree,"0.264*CETmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
1052       if (npoints<3) continue;
1053       printf("Sector=%d\n",isec);
1054       vecA0[isec]=param[0];
1055       vecALy[isec]=param[1];
1056       vecALx[isec]=param[2];
1057       vecAChi2[isec]=TMath::Sqrt(chi2/npoints);
1058     }
1059     isCalc=kTRUE;
1060     //
1061     TString  fstringRef="";              // global fit
1062     fstringRef+="gx.fElements++";
1063     fstringRef+="gy.fElements++";
1064     fstringRef+="lx.fElements++";
1065     TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),"(sector%36)<18"+cutAll, chi2,npoints,vecASide,covar,-1,0, 10000000, kFALSE);
1066     TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),"(sector%36)>=18"+cutAll, chi2,npoints,vecCSide,covar,-1,0, 10000000, kFALSE);
1067
1068   }
1069   (*fPcstream)<<"dcs"<<     // CE information
1070     "CETSector.="<<&sec<<    // sector numbers
1071     "CETRefA.="<<&vecASide<<   // diff to reference A side
1072     "CETRefC.="<<&vecCSide<<   // diff to reference C side
1073     //                      // fit in respect to reference data
1074     "CETRef0.="<<&vec0<<    // offset change
1075     "CETRefY.="<<&vecLy<<   // slope y change - rad
1076     "CETRefX.="<<&vecLx<<   // slope x change - rad
1077     "CETRefChi2.="<<&vecChi2<<    // chi2 (rms in cm)
1078     "CETRefN.="<<&vecN<<     //number of accepted points
1079     //                       // fit in respect per mean per side
1080     "CET0.="<<&vecA0<<       // offset change
1081     "CETY.="<<&vecALy<<      // slope y change - rad
1082     "CETX.="<<&vecALx<<      // slope x change - rad
1083     "CETChi2.="<<&vecAChi2;  // chi2 (rms in cm)
1084 }
1085
1086 void AliTPCcalibSummary::ProcessPulserRef(){
1087   //
1088   // Get fit of residuals if Pulser in respect with reference
1089   // data
1090   //
1091   static TVectorD  sec(72);
1092   static TVectorD vec0(72);
1093   static TVectorD vecLy(72);
1094   static TVectorD vecLx(72);
1095   static TVectorD vecChi2(72);
1096   static TVectorD vecN(72);
1097   //
1098   static TVectorD vecA0(72);
1099   static TVectorD vecALy(72);
1100   static TVectorD vecALx(72);
1101   static TVectorD vecAChi2(72);
1102   static Bool_t isCalc=kFALSE;
1103
1104   TFile f("calPads.root");
1105   TFile fref("calPadsRef.root");
1106   TTree * tree = (TTree*)f.Get("calPads");
1107   TTree * treeRef = (TTree*)fref.Get("calPads");
1108   tree->AddFriend(treeRef,"R");
1109
1110   tree->SetAlias("inPulser","(abs(PulserTmean.fElements-PulserTmean_Median)<1.5&&abs(PulserTrms.fElements-PulserTrms_Median)<0.2)");  // outlyerTrms
1111   tree->SetAlias("inPulserR","(abs(R.PulserTmean.fElements-R.PulserTmean_Median)<1.5&&abs(R.PulserTrms.fElements-R.PulserTrms_Median)<0.2)");  // outlyerTrms
1112   //
1113   if (!isCalc){
1114     // make fits only once
1115     TStatToolkit toolkit;
1116     Double_t chi2=0;
1117     Int_t    npoints=0;
1118     TVectorD param;
1119     TMatrixD covar;
1120     tree->SetAlias("dt","PulserTmean.fElements-R.PulserTmean.fElements");
1121     TCut cutAll ="inPulser&&inPulserR";
1122     TString  fstringG="";              // global part
1123     fstringG+="ly.fElements++";
1124     fstringG+="(lx.fElements-134.)++";
1125     for (Int_t isec=0; isec<72; isec++){
1126       TStatToolkit::FitPlane(tree,"dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
1127       if (npoints<3) continue;
1128       printf("Setor=%d\n",isec);
1129       vec0[isec]=param[0];
1130       vecLy[isec]=param[1];
1131       vecLx[isec]=param[2];
1132       sec[isec]=isec;
1133       vecN[isec]=npoints;
1134
1135       TStatToolkit::FitPlane(tree,"PulserTmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
1136       if (npoints<3) continue;
1137       printf("Setor=%d\n",isec);
1138       vecA0[isec]=param[0];
1139       vecALy[isec]=param[1];
1140       vecALx[isec]=param[2];
1141       vecAChi2[isec]=TMath::Sqrt(chi2/npoints);
1142     }
1143
1144     isCalc=kTRUE;
1145   }
1146   (*fPcstream)<<"dcs"<<     // Pulser information
1147     "PulserTSector.="<<&sec<<    // sector numbers
1148     //                      // fit in respect to reference
1149     "PulserTRef0.="<<&vec0<<    // offset change
1150     "PulserTRefY.="<<&vecLy<<   // slope y change - rad
1151     "PulserTRefX.="<<&vecLx<<   // slope x change - rad
1152     "PulserTRefChi2.="<<&vecChi2<<    // chi2 (rms in cm)
1153     "PulserTRefN.="<<&vecN<<     //number of accepted points
1154     //                       // fit in respect per mean per side
1155     "PulserT0.="<<&vecA0<<       // offset change
1156     "PulserTY.="<<&vecALy<<      // slope y change - rad
1157     "PulserTX.="<<&vecALx<<      // slope x change - rad
1158     "PulserTChi2.="<<&vecAChi2;  // chi2 (rms in cm)
1159 }
1160
1161 void AliTPCcalibSummary::ProcessCurrent(Int_t irun, Int_t itime){
1162   //
1163   // Dump current
1164   //
1165   //variables to export
1166   //
1167   static TObjArray *currentArray=new TObjArray(72);   // current graphs
1168   static TObjArray *currentArray2=new TObjArray(72);  // current graphs to export
1169   //
1170   static TVectorD currentIROC(36);                    // current snapshots
1171   static TVectorD currentOROC(36);
1172   static TVectorF sector(72);                         //
1173   static Double_t medcurIROC = 0;
1174   static Double_t medcurOROC = 0;
1175   //
1176   static TVectorF minROC(72);                         // current mean +-5 minutes
1177   static TVectorF maxROC(72);
1178   static TVectorF meanROC(72);
1179   static TVectorF medianROC(72);
1180   static Double_t meanIIROC=0;
1181   static Double_t meanIOROC=0;
1182   static Double_t medianIIROC=0;
1183   static Double_t medianIOROC=0;
1184   //
1185   AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(irun);
1186   //
1187   for(Int_t j=1; j<36; j++) currentIROC[j-1] = fCalibDB->GetChamberHighVoltage(irun, j,itime,-1,kTRUE);
1188   for(Int_t j=36; j<72; j++) currentOROC[j-36] = fCalibDB->GetChamberHighVoltage(irun, j,itime,-1,kTRUE);
1189   medcurIROC = TMath::Median(36, currentIROC.GetMatrixArray());
1190   medcurOROC = TMath::Median(36, currentOROC.GetMatrixArray());
1191
1192
1193   if (currentArray->At(0)==0){
1194     for (Int_t isec=0; isec<72; isec++){
1195       TString sensorName="";
1196       const char* sideName=(isec%36<18) ? "A":"C";
1197       if (isec<36){
1198         //IROC
1199         sensorName=Form("TPC_ANODE_I_%s%02d_IMEAS",sideName,isec%18);
1200       }else{
1201         //OROC
1202         sensorName=Form("TPC_ANODE_O_%s%02d_0_IMEAS",sideName,isec%18);
1203       }
1204
1205       AliDCSSensor *sensor = 0;
1206       if (voltageArray) sensor= voltageArray->GetSensor(sensorName);
1207       TGraph *gr=0;
1208       if (!sensor) gr=new TGraph(1);
1209       else{
1210         if (!sensor->GetGraph()) gr=new TGraph(1);
1211         else{
1212           gr=sensor->GetGraph();
1213           Double_t startTime=sensor->GetStartTime();
1214           Double_t * time = new Double_t[gr->GetN()];
1215           for (Int_t ip=0; ip<gr->GetN(); ip++){ time[ip]= (gr->GetX()[ip]*3600.)+startTime;}
1216           gr=new TGraph(gr->GetN(), time, gr->GetY());
1217           delete [] time;
1218         }
1219       }
1220       gr->Sort();
1221       currentArray->AddAt(gr, isec);
1222       currentArray->AddAt(gr->Clone(), isec);
1223     }
1224   }
1225
1226
1227   for (Int_t isec=0; isec<72; isec++){
1228     sector[isec]=isec;
1229     TGraph * gr = (TGraph*)currentArray->At(isec);
1230     TGraph * graph2 = (TGraph*)currentArray2->At(isec);
1231     Int_t firstBin= TMath::BinarySearch(gr->GetN(), gr->GetX(), itime-300.)-2;
1232     Int_t lastBin= TMath::BinarySearch(gr->GetN(), gr->GetX(), itime+300.)+2;
1233     if (firstBin<0) firstBin=0;
1234     if (lastBin>=gr->GetN()) lastBin=gr->GetN()-1;
1235     //
1236     if (firstBin<lastBin){
1237       //
1238       minROC[isec]=TMath::MinElement(lastBin-firstBin, &(gr->GetY()[firstBin]));
1239       maxROC[isec]=TMath::MaxElement(lastBin-firstBin, &(gr->GetY()[firstBin]));
1240       meanROC[isec]=TMath::Mean(lastBin-firstBin, &(gr->GetY()[firstBin]));
1241       medianROC[isec]=TMath::Median(lastBin-firstBin, &(gr->GetY()[firstBin]));
1242       graph2 = new TGraph(lastBin-firstBin, &(gr->GetX()[firstBin]), &(gr->GetY()[firstBin]));
1243       delete currentArray2->At(isec);
1244       currentArray2->AddAt(graph2,isec);
1245     }
1246     (*fPcstream)<<"dcs"<<     // current information
1247       Form("current%d.=",isec)<<graph2;
1248   }
1249   meanIIROC=TMath::Mean(36, &(meanROC.GetMatrixArray()[0]));
1250   meanIOROC=TMath::Mean(36, &(meanROC.GetMatrixArray()[36]));
1251   medianIIROC=TMath::Median(36, &(meanROC.GetMatrixArray()[0]));
1252   medianIOROC=TMath::Median(36, &(meanROC.GetMatrixArray()[36]));
1253   //
1254   (*fPcstream)<<"dcs"<<     // current information
1255     "isec.="<<&sector<<                       //sector number
1256     "IIROC.="<<&currentIROC<<               // current sample at given moment
1257     "IOROC.="<<&currentOROC<<               // current sample at given moment
1258     "medianIIROC="<<medcurIROC<<            // median at given moment
1259     "medianIOROC="<<medcurOROC<<            // median at given moment
1260     //
1261     "minIROC.="<<&minROC<<                  // minimum in +-5 min
1262     "maxIROC.="<<&maxROC<<                  // maximum in +-5 min
1263     "meanIROC.="<<&meanROC<<                // mean in +-5 min
1264     "medianIROC.="<<&medianROC<<              // median in +-5 min
1265     "meanIIROC5="<<meanIIROC<<               // mean current in IROC +-5 minutes
1266     "meanIOROC5="<<meanIOROC<<               // mean current in OROC
1267     "medianIIROC5="<<medianIIROC<<           // median current in IROC
1268     "medianIOROC5="<<medianIOROC;           // medianan current in OROC
1269
1270
1271   (*fPcstream)<<"current"<<     // current information
1272     "time="<<itime<<
1273     "isec.="<<&sector<<                       //sector number
1274     "IIROC.="<<&currentIROC<<               // current sample at given moment
1275     "IOROC.="<<&currentOROC<<               // current sample at given moment
1276     "medianIIROC="<<medcurIROC<<            // median at given moment
1277     "medianIOROC="<<medcurOROC<<            // median at given moment
1278     //
1279     "minIROC.="<<&minROC<<                  // minimum in +-5 min
1280     "maxIROC.="<<&maxROC<<                  // maximum in +-5 min
1281     "meanIROC.="<<&meanROC<<                // mean in +-5 min
1282     "medianIROC.="<<&medianROC<<              // median in +-5 min
1283     "meanIIROC5="<<meanIIROC<<               // mean current in IROC +-5 minutes
1284     "meanIOROC5="<<meanIOROC<<               // mean current in OROC
1285     "medianIIROC5="<<medianIIROC<<           // median current in IROC
1286     "medianIOROC5="<<medianIOROC<< // medianan current in OROC
1287     "\n";
1288
1289 }
1290
1291
1292
1293
1294 // TCanvas * DrawCEDiff(TTree * tree){
1295
1296 //   TCanvas *canvasIO = new TCanvas("canvasCEIO","canvasCEIO");
1297 //   canvasIO->Divide(6,6);
1298 //   for (Int_t isec=0; isec<36; isec++){
1299 //     canvasIO->cd(isec+1);
1300 //     dcs->Draw(Form("CET0.fElements[%d]-CET0.fElements[%d]",isec+36,isec),Form("abs(CETRef0.fElements[%d])<0.3",isec),"");
1301 //     printf("%d\t%f\t%f\n",isec,dcs->GetHistogram()->GetMean(),dcs->GetHistogram()->GetRMS());
1302 //   }
1303
1304 // }