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 #include <TStatToolkit.h>
  60 #include <TCut.h>
  61 //
  62 //
  63 //
  64 AliTPCcalibSummary::AliTPCcalibSummary():
  65   TNamed(),
  66   fCalibDB(0),
  67   fDButil(0),
  68   fPcstream(0)
  69 {
  70   //
  71   // default constructor
  72   // OCDB have to be setupe before - not part of class
  73   // usualy ConfigOCDB.C macro used
  74   //
  75   fPcstream = new TTreeSRedirector("dcsTime.root");
  76   fCalibDB = AliTPCcalibDB::Instance();
  77   fDButil= new AliTPCcalibDButil;
  78 }
  79
  80 AliTPCcalibSummary::~AliTPCcalibSummary(){
  81   //
  82   // destructor  - close streamer
  83   //
  84   delete fPcstream;
  85 }
  86
  87 void AliTPCcalibSummary::Process(const char * runList, Int_t first, Int_t last){
  88   //
  89   // runList - listOfRuns to process
  90   // first   - first run to process
  91   // last    - last  to process
  92   //
  93   //
  94   // make list of runs
  95   //
  96
  97   ifstream inputFile;
  98   inputFile.open("run.list");
  99   Int_t irun=0;
 100   TArrayI runArray(100000);
 101   Int_t indexes[100000];
 102   Int_t nruns=0;
 103   printf("Runs to process:\n");
 104   if (!inputFile.is_open()) {
 105     printf("Problem to open file %s\n",runList);
 106   }
 107   while( inputFile.good() ) {
 108     inputFile >> irun;
 109     printf("Run \t%d\n",irun);
 110     if (irun<first) continue;  // process only subset of list
 111     if (last>0 && irun>last) continue;  // process only subset of list
 112     runArray[nruns]=irun;
 113     nruns++;
 114   }
 115
 116
 117   TMath::Sort(nruns, runArray.fArray, indexes,kFALSE);
 118   Int_t startTime = 0;
 119   Int_t endTime   = 0;
 120   for (Int_t run=0; run<nruns; run++){
 121     irun=runArray[indexes[run]];
 122     printf("Processing run %d ...\n",irun);
 123     fCalibDB->SetRun(irun);
 124     fDButil->UpdateFromCalibDB();
 125     fDButil->SetReferenceRun(irun);
 126     fDButil->UpdateRefDataFromOCDB();
 127     fCalibDB->CreateGUITree("calPads.root");
 128     fDButil->CreateGUIRefTree("calPadsRef.root");
 129     //
 130     AliDCSSensorArray *arrHV=fCalibDB->GetVoltageSensors(irun);
 131     if (!arrHV) continue;
 132     for  (Int_t isenHV=0; isenHV<arrHV->NumSensors(); ++isenHV){
 133       AliDCSSensor *senHV=arrHV->GetSensorNum(isenHV);
 134       if (!senHV) {
 135         printf("Not interesting OCDB info\n");
 136         continue;
 137       }
 138       startTime=senHV->GetStartTime();
 139       endTime  =senHV->GetEndTime();
 140       if (startTime>0&&endTime>0) break;
 141     }
 142     AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun);
 143     if (goofieArray) fDButil->FilterGoofie(goofieArray,0.5,4.,6.85,7.05,fPcstream);
 144     // don't filter goofie for the moment
 145     ProcessRun(irun, startTime,endTime);
 146   }
 147 }
 148
 149
 150 void AliTPCcalibSummary::ProcessRun(Int_t irun, Int_t startTime, Int_t endTime){
 151   //
 152   // Process run irun
 153   //
 154   fCalibDB->SetRun(irun);
 155   fDButil->UpdateFromCalibDB();
 156   fDButil->SetReferenceRun(irun);
 157   fDButil->UpdateRefDataFromOCDB();
 158   fCalibDB->CreateGUITree("calPads.root");
 159   fDButil->CreateGUIRefTree("calPadsRef.root");
 160
 161   //
 162   AliSplineFit *fitVdrift=0x0;
 163   Int_t startTimeGRP=0, stopTimeGRP=0;
 164   if (fCalibDB->GetGRP(irun)){
 165     startTimeGRP = AliTPCcalibDB::GetGRP(irun)->GetTimeStart();
 166     stopTimeGRP  = AliTPCcalibDB::GetGRP(irun)->GetTimeEnd();
 167   }
 168   if (startTime==0){
 169     startTime=startTimeGRP;
 170     endTime=stopTimeGRP;
 171   }
 172   AliTPCSensorTempArray * tempArray = fCalibDB->GetTemperatureSensor(irun);
 173   AliTPCTempMap * tempMap = new AliTPCTempMap(tempArray);
 174   AliDCSSensorArray* goofieArray = fCalibDB->GetGoofieSensors(irun);
 175   //
 176   Int_t dtime = TMath::Max((endTime-startTime)/20,10*60);
 177   //
 178   //Goofie statistical data
 179   //
 180   TVectorD vecEntries, vecMean, vecMedian,vecRMS;
 181   fDButil->ProcessGoofie(vecEntries ,vecMedian, vecMean, vecRMS);
 182   //
 183   //CE data processing - see ProcessCEdata function for description of the results
 184   //
 185   TVectorD fitResultsA, fitResultsC;
 186   Int_t nmaskedCE;
 187   Double_t chi2ACE=0,chi2CCE=0;
 188   //     fDButil->ProcessCEdata("(sector<36)++gx++gy++lx++lx**2",fitResultsA,fitResultsC,nmaskedCE);
 189   fDButil->ProcessCEdata("(sector<36)++gx++gy++(lx-134)++(sector<36)*(lx-134)++(ly/lx)^2",fitResultsA,fitResultsC,nmaskedCE,chi2ACE,chi2CCE);
 190
 191   TVectorD fitCEResultsA(7), fitCEResultsC(7);
 192   Int_t    noutCE;
 193   Double_t chi2CEA=0,chi2CEC=0;
 194   AliTPCCalPad *time0 = fDButil->CreatePadTime0CE(fitCEResultsA, fitCEResultsC, noutCE, chi2CEA, chi2CEC);
 195   delete time0;
 196   //
 197   //
 198   TVectorD vecTEntries, vecTMean, vecTRMS, vecTMedian, vecQEntries, vecQMean, vecQRMS, vecQMedian;
 199   Float_t driftTimeA, driftTimeC;
 200   fDButil->ProcessCEgraphs(vecTEntries, vecTMean, vecTRMS, vecTMedian,
 201                           vecQEntries, vecQMean, vecQRMS, vecQMedian,
 202                           driftTimeA, driftTimeC );
 203   //
 204   //
 205   //
 206   //drift velocity using tracks
 207   //
 208   //     fitVdrift=fCalibDB->GetVdriftSplineFit("ALISPLINEFIT_MEAN_VDRIFT_COSMICS_ALL",irun);
 209   fitVdrift=fCalibDB->CreateVdriftSplineFit("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL",irun);
 210   //noise data Processing - see ProcessNoiseData function for description of the results
 211   TVectorD vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions;
 212   Int_t nonMaskedZero=0, nNaN=0;
 213   fDButil->ProcessNoiseData(vNoiseMean, vNoiseMeanSenRegions, vNoiseRMS, vNoiseRMSSenRegions, nonMaskedZero, nNaN);
 214   //
 215   // comparisons
 216   //
 217   TVectorF pedestalDeviations;
 218   TVectorF noiseDeviations;
 219   TVectorF pulserQdeviations;
 220   Float_t varQMean;
 221   Int_t npadsOutOneTB;
 222   Int_t npadsOffAdd;
 223   fDButil->ProcessPedestalVariations(pedestalDeviations);
 224   fDButil->ProcessNoiseVariations(noiseDeviations);
 225   fDButil->ProcessPulserVariations(pulserQdeviations,varQMean,npadsOutOneTB,npadsOffAdd);
 226   //
 227   //L3 data
 228   //
 229   Float_t bz=AliTPCcalibDB::GetBz(irun);
 230   Char_t  l3pol=AliTPCcalibDB::GetL3Polarity(irun);
 231   //
 232   //QA data processing
 233   //
 234   TVectorD vQaOcc;
 235   TVectorD vQaQtot;
 236   TVectorD vQaQmax;
 237   fDButil->ProcessQAData(vQaOcc, vQaQtot, vQaQmax);
 238   //
 239   //calibration Pulser data processing
 240   //
 241   Int_t nOffChannels=0;
 242   TVectorD vTimePulser;
 243   nOffChannels=fDButil->GetNPulserOutliers();
 244   fDButil->ProcessPulser(vTimePulser);
 245   //
 246   //ALTRO data
 247   //
 248   Int_t nMasked=0;
 249   fDButil->ProcessALTROConfig(nMasked);
 250   //
 251   //Calib RAW data
 252   //
 253   Int_t nFailL1=-1;
 254   if (fCalibDB->GetCalibRaw()) nFailL1=fCalibDB->GetCalibRaw()->GetNFailL1Phase();
 255   //
 256   //production information
 257   //
 258   Int_t nalien=0,nRawAlien=0,nlocal=0,nRawLocal=0;
 259   //run type
 260   TObjString runType(AliTPCcalibDB::GetRunType(irun).Data());
 261   //
 262   //
 263   //
 264
 265   for (Int_t itime=startTime; itime<endTime; itime+=dtime){
 266     //
 267     TTimeStamp tstamp(itime);
 268     Float_t valuePressure  = fCalibDB->GetPressure(tstamp,irun,0);
 269     Float_t valuePressure2 = fCalibDB->GetPressure(tstamp,irun,1);
 270     Double_t ptrelative0 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,0);
 271     Double_t ptrelative1 = AliTPCcalibDB::GetPTRelative((UInt_t)itime,irun,1);
 272     //temperature fits
 273     TLinearFitter * fitter = 0;
 274     TVectorD vecTemp[10];
 275     for (Int_t itype=0; itype<5; itype++)
 276       for (Int_t iside=0; iside<2; iside++){
 277         fitter= tempMap->GetLinearFitter(itype,iside,tstamp);
 278         if (!fitter) continue;
 279         fitter->Eval();
 280         fitter->GetParameters(vecTemp[itype+iside*5]);
 281         delete fitter;
 282       }
 283     //
 284     //measured skirt temperatures
 285     //
 286     TVectorD vecSkirtTempA(18);
 287     TVectorD vecSkirtTempC(18);
 288     Int_t nsenTemp=tempArray->NumSensors();
 289     for (Int_t isenTemp=0;isenTemp<nsenTemp;++isenTemp){
 290       AliTPCSensorTemp *senTemp=(AliTPCSensorTemp*)tempArray->GetSensorNum(isenTemp);
 291       if (senTemp->GetType()!=3) continue;
 292       if (TMath::Sqrt(senTemp->GetX()*senTemp->GetX()+senTemp->GetY()*senTemp->GetY())<100) continue; //only skirt, outer FC vessel
 293       Double_t val=senTemp->GetValue(tstamp);
 294       if (senTemp->GetSide()==0)
 295         vecSkirtTempA[senTemp->GetSector()]=val;
 296       else
 297         vecSkirtTempC[senTemp->GetSector()]=val;
 298     }
 299     //
 300     //goofie data
 301     //
 302     TVectorD vecGoofie;
 303     if (goofieArray){
 304       vecGoofie.ResizeTo(goofieArray->NumSensors());
 305       for (Int_t isensor=0; isensor<goofieArray->NumSensors();isensor++){
 306         AliDCSSensor *gsensor = goofieArray->GetSensor(isensor);
 307         if (gsensor){
 308           vecGoofie[isensor] = gsensor->GetValue(tstamp);
 309         }
 310       }
 311     } else {
 312       vecGoofie.ResizeTo(19);
 313     }
 314     //
 315     TVectorD voltagesIROC(36);
 316     TVectorD voltagesOROC(36);
 317     for(Int_t j=1; j<36; j++) voltagesIROC[j-1] = fCalibDB->GetChamberHighVoltage(irun, j,itime);
 318     for(Int_t j=36; j<72; j++) voltagesOROC[j-36] = fCalibDB->GetChamberHighVoltage(irun, j,itime);
 319     Double_t voltIROC = TMath::Median(36, voltagesIROC.GetMatrixArray());
 320     Double_t voltOROC = TMath::Median(36, voltagesOROC.GetMatrixArray());
 321     //
 322     Float_t  coverIA=AliTPCcalibDB::GetCoverVoltage(irun,0,itime);
 323     Float_t  coverIC=AliTPCcalibDB::GetCoverVoltage(irun,18,itime);
 324     Float_t  coverOA=AliTPCcalibDB::GetCoverVoltage(irun,36,itime);
 325     Float_t  coverOC=AliTPCcalibDB::GetCoverVoltage(irun,54,itime);
 326     Float_t  skirtA=AliTPCcalibDB::GetSkirtVoltage(irun,0,itime);
 327     Float_t  skirtC=AliTPCcalibDB::GetSkirtVoltage(irun,18,itime);
 328     Float_t  ggOffA=AliTPCcalibDB::GetGGoffsetVoltage(irun,0,itime);
 329     Float_t  ggOffC=AliTPCcalibDB::GetGGoffsetVoltage(irun,18,itime);
 330     //drift velocity
 331     Float_t dvCorr=-5;
 332     if (fitVdrift) dvCorr=fitVdrift->Eval(itime);
 333
 334     //tempMap->GetLinearFitter(0,0,itime);
 335     (*fPcstream)<<"dcs"<<
 336       "run="<<irun<<
 337       "time="<<itime<<
 338       "startTimeGRP="<<startTimeGRP<<
 339       "stopTimeGRP="<<stopTimeGRP<<
 340       //run type
 341       "runType.="<<&runType<<
 342       // voltage setting
 343       "VIROC.="<<&voltagesIROC<<
 344       "VOROC.="<<&voltagesOROC<<
 345       "medianVIROC="<<voltIROC<<
 346       "medianVOROC="<<voltOROC<<
 347       "coverIA=" << coverIA <<
 348       "coverIC=" << coverIC <<
 349       "coverOA=" << coverOA <<
 350       "coverOC=" << coverOC <<
 351       "skirtA=" << skirtA <<
 352       "skirtC=" << skirtC <<
 353       "ggOffA=" << ggOffA <<
 354       "ggOffC=" << ggOffC <<
 355       //
 356       "ptrel0="<<ptrelative0<<  // deltaTP/TP  - A side
 357       "ptrel1="<<ptrelative1<<  // deltaTP/TPC - C side
 358       "goofie.="<<&vecGoofie<<
 359       "goofieE.="<<&vecEntries<<
 360       "goofieMean.="<<&vecMean<<
 361       "goofieMedian.="<<&vecMedian<<
 362       "goofieRMS.="<<&vecRMS<<
 363       //
 364       "press="<<valuePressure<<
 365       "press2="<<valuePressure2<<
 366       "temp00.="<<&vecTemp[0]<<
 367       "temp10.="<<&vecTemp[1]<<
 368       "temp20.="<<&vecTemp[2]<<
 369       "temp30.="<<&vecTemp[3]<<
 370       "temp40.="<<&vecTemp[4]<<
 371       "temp01.="<<&vecTemp[5]<<
 372       "temp11.="<<&vecTemp[6]<<
 373       "temp21.="<<&vecTemp[7]<<
 374       "temp31.="<<&vecTemp[8]<<
 375       "temp41.="<<&vecTemp[9]<<
 376       "tempSkirtA.="<<&vecSkirtTempA<<
 377       "tempSkirtC.="<<&vecSkirtTempC;
 378
 379     ProcessDrift(irun, itime);
 380     ProcessDriftCE(irun,itime);
 381     ProcessDriftAll(irun,itime);
 382     //    ProcessKryptonTime(irun,itime);
 383     ProcessCTP(irun,itime);
 384     ProcessAlign(irun,itime);
 385     ProcessGain(irun,itime);
 386     ProcessDriftCERef();
 387     ProcessPulserRef();
 388
 389
 390     (*fPcstream)<<"dcs"<<
 391       //noise data
 392       "meanNoise.="<<&vNoiseMean<<
 393       "meanNoiseSen.="<<&vNoiseMeanSenRegions<<
 394       "rmsNoise.="<<&vNoiseRMS<<
 395       "rmsNoiseSen.="<<&vNoiseRMSSenRegions<<
 396       "zeroNoise="<<nonMaskedZero<<
 397       "nNaN="<<nNaN<<
 398       //QA data
 399       "occQA.="  << &vQaOcc  <<
 400       "qQA.="    << &vQaQtot <<
 401       "qmaxQA.=" << &vQaQmax <<
 402       //pulser data
 403       "timePulser.=" << &vTimePulser <<
 404       "nOffPulser="<<nOffChannels<<
 405       //altro data
 406       "nMasked="<<nMasked<<
 407       //ce data -Jens version
 408       "CEfitA.="<<&fitResultsA<<
 409       "CEfitC.="<<&fitResultsC<<
 410       "nmaskedCE="<<nmaskedCE<<
 411       "chi2ACE="<<chi2ACE<<
 412       "chi2CCE="<<chi2CCE<<
 413       //ce data new - MI version
 414       "CEfitAMI.="<<&fitCEResultsA<<
 415       "CEfitCMI.="<<&fitCEResultsC<<
 416       "chi2CEA="<<chi2CEA<<
 417       "chi2CEC="<<chi2CEC<<
 418       //
 419       //ce graph data
 420       "CEgrTEntries.="<<&vecTEntries<<
 421       "CEgrTMean.="<<&vecTMean<<
 422       "CEgrTRMS.="<<&vecTRMS<<
 423       "CEgrTMedian.="<<&vecTMedian<<
 424       "CEgrQEntries.="<<&vecQEntries<<
 425       "CEgrQMean.="<<&vecQMean<<
 426       "CEgrQRMS.="<<&vecQRMS<<
 427       "CEgrQMedian.="<<&vecQMedian<<
 428       "CEgrDriftA="<<driftTimeA<<
 429       "CEgrDriftC="<<driftTimeC<<
 430       //calib raw data
 431       "nFailL1="<<nFailL1<<
 432       // b field
 433       "Bz="<< bz <<
 434       "L3polarity="<<l3pol<<
 435       // production information
 436       "nalien="<<nalien<<
 437       "nRawAlien="<<nRawAlien<<
 438       "nlocal="<<nlocal<<
 439       "nRawLocal="<<nRawLocal<<
 440       //comparisons with ref data
 441       "pedestalDeviations.="<<&pedestalDeviations<<
 442       "noiseDeviations.="<<&noiseDeviations<<
 443       "pulserQdeviations.="<<&pulserQdeviations<<
 444       //         "pulserVarQMean="<<varQMean<<
 445       "pulserNpadsOutOneTB="<<npadsOutOneTB<<
 446       "pulserNpadsOffAdd="<<npadsOffAdd<<
 447       "driftCorrCosmAll="<<dvCorr<<
 448       "\n";
 449   }//end run loop
 450 }
 451
 452
 453
 454
 455
 456
 457 void AliTPCcalibSummary::ProcessDrift(Int_t run, Int_t timeStamp){
 458   //
 459   // dump drift calibration data to the tree
 460   //
 461   TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
 462   TGraphErrors *laserA[3]={0,0,0};
 463   TGraphErrors *laserC[3]={0,0,0};
 464   TGraphErrors *cosmicAll=0;
 465   static Double_t     vlaserA[3]={0,0,0};
 466   static Double_t     vlaserC[3]={0,0,0};
 467   static Double_t     vcosmicAll=0;
 468   static Double_t     vdrift1=0;
 469   vdrift1=fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);
 470
 471   if (array){
 472     laserA[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_A");
 473     laserA[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A");
 474     laserA[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A");
 475     laserC[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_C");
 476     laserC[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C");
 477     laserC[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C");
 478     cosmicAll =(TGraphErrors*)array->FindObject("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL");
 479   }
 480   if (laserA[0]) vlaserA[0]= AliTPCcalibDButil::EvalGraphConst(laserA[0],timeStamp);
 481   if (laserA[1]) vlaserA[1]= AliTPCcalibDButil::EvalGraphConst(laserA[1],timeStamp);
 482   if (laserA[2]) vlaserA[2]= AliTPCcalibDButil::EvalGraphConst(laserA[2],timeStamp);
 483   if (laserC[0]) vlaserC[0]= AliTPCcalibDButil::EvalGraphConst(laserC[0],timeStamp);
 484   if (laserC[1]) vlaserC[1]= AliTPCcalibDButil::EvalGraphConst(laserC[1],timeStamp);
 485   if (laserC[2]) vlaserC[2]= AliTPCcalibDButil::EvalGraphConst(laserC[2],timeStamp);
 486   if (cosmicAll) vcosmicAll= AliTPCcalibDButil::EvalGraphConst(cosmicAll,timeStamp);
 487   (*fPcstream)<<"dcs"<<
 488     "vlaserA0="<<vlaserA[0]<<
 489     "vlaserA1="<<vlaserA[1]<<
 490     "vlaserA2="<<vlaserA[2]<<
 491     "vlaserC0="<<vlaserC[0]<<
 492     "vlaserC1="<<vlaserC[1]<<
 493     "vlaserC2="<<vlaserC[2]<<
 494     "vcosmicAll="<<vcosmicAll<<
 495     "vdrift1="<<vdrift1;
 496
 497   //
 498   // define distance to measurement
 499   //
 500   static Double_t dlaserA=0;
 501   static Double_t dlaserC=0;
 502   static Double_t dcosmic=0;
 503   static Double_t slaserA=0;
 504   static Double_t slaserC=0;
 505   static Double_t scosmic=0;
 506   static Double_t  vclaserA[3]={0,0,0};
 507   static Double_t  vclaserC[3]={0,0,0};
 508   static Double_t  vccosmicAll=0;
 509   for (Int_t i=0;i<3;i++){
 510     if (laserA[i]) AliTPCcalibDButil::GetNearest(laserA[i],timeStamp,dlaserA,vclaserA[i]);
 511     if (laserC[i]) AliTPCcalibDButil::GetNearest(laserC[i],timeStamp,dlaserC,vclaserC[i]);
 512   }
 513   if (cosmicAll) AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dcosmic,vccosmicAll);
 514   (*fPcstream)<<"dcs"<<
 515     "vclaserA0="<<vclaserA[0]<<
 516     "vclaserA1="<<vclaserA[1]<<
 517     "vclaserA2="<<vclaserA[2]<<
 518     "vclaserC0="<<vclaserC[0]<<
 519     "vclaserC1="<<vclaserC[1]<<
 520     "vclaserC2="<<vclaserC[2]<<
 521     "vccosmicAll="<<vccosmicAll<<
 522     "dlaserA="<<dlaserA<<
 523     "dlaserC="<<dlaserC<<
 524     "dcosmic="<<dcosmic<<
 525     "slaserA="<<slaserA<<
 526     "slaserC="<<slaserC<<
 527     "scosmic="<<scosmic;
 528 }
 529
 530 void AliTPCcalibSummary::ProcessDriftCE(Int_t run,Int_t timeStamp){
 531   //
 532   // dump drift calibration data CE
 533   //
 534   TObjArray *arrT=fCalibDB->GetCErocTtime();
 535   AliTPCParam *param=fCalibDB->GetParameters();
 536   static TVectorD tdriftCE(74);
 537   static TVectorD tndriftCE(74);
 538   static TVectorD vdriftCE(74);
 539   static TVectorD tcdriftCE(74);
 540   static TVectorD tddriftCE(74);
 541   static Double_t ltime0A;
 542   static Double_t ltime0C;
 543   //
 544   //
 545   //
 546   ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
 547   ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);
 548   //
 549   for (Int_t i=0; i<arrT->GetEntries();i++){
 550     tdriftCE[i]=0;
 551     vdriftCE[i]=0;
 552     TGraph *graph = (TGraph*)arrT->At(i);
 553     if (!graph) continue;
 554     tdriftCE[i]=AliTPCcalibDButil::EvalGraphConst(graph,timeStamp);
 555     Double_t deltaT,gry;
 556     AliTPCcalibDButil::GetNearest(graph,timeStamp,deltaT,gry);
 557     tndriftCE[i]=graph->GetN();
 558     tcdriftCE[i]=gry;
 559     tddriftCE[i]=deltaT;
 560     if (i%36<18){
 561       vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
 562     }else{
 563       vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
 564     }
 565   }
 566   // export values
 567   (*fPcstream)<<"dcs"<<
 568     "tdriftCE.="<<&tdriftCE<<    // arrival time
 569     "vdriftCE.="<<&vdriftCE<<    // derived drift velocity per chamber
 570     "tndriftCE.="<<&tndriftCE<<  // number of points (chambers)
 571     "tcdriftCE.="<<&tcdriftCE<<  // constant evaluation - nearest point used
 572     "tddriftCE.="<<&tddriftCE<<  // distance to closest measuement
 573     "ltime0A="<<ltime0A<<        // laser offset expected in reconstruction
 574     "ltime0C="<<ltime0C;         // laser offset expected in reconstruction
 575    }
 576
 577
 578 void AliTPCcalibSummary::ProcessDriftAll(Int_t run,Int_t timeStamp){
 579   //
 580   // dump drift calibration data  all calibrations form DB util
 581   // test of utils
 582   static Double_t vdriftCEA=0, vdriftCEC=0, vdriftCEM=0;
 583   static Double_t vdriftLTA=0, vdriftLTC=0, vdriftLTM=0;
 584   static Double_t vdriftLTAon=0, vdriftLTCon=0, vdriftLTMon=0;
 585   static Double_t vdriftITS=0;
 586   static Double_t vdriftP=0;
 587   static Double_t dcea=0, dcec=0, dcem=0,  dla=0,dlc=0,dlm=0, dlaon=0,dlcon=0,dlmon=0, dp=0;
 588   static Double_t dits=0;
 589   static Double_t ltime0A;
 590   static Double_t ltime0C;
 591   static Double_t ctime0;
 592   static Double_t vdrift1=0;
 593   vdrift1= fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);
 594   vdriftP = fDButil->GetVDriftTPC(dp, run, timeStamp, 86400, 3600,0);
 595   ctime0 = AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, 36000, 3600,0);
 596   //
 597   vdriftCEA= fDButil->GetVDriftTPCCE(dcea,run,timeStamp,36000,0);
 598   vdriftCEC= fDButil->GetVDriftTPCCE(dcec,run,timeStamp,36000,1);
 599   vdriftCEM= fDButil->GetVDriftTPCCE(dcem,run,timeStamp,36000,2);
 600   //
 601   vdriftLTA= fDButil->GetVDriftTPCLaserTracks(dla,run,timeStamp,36000,0);
 602   vdriftLTC= fDButil->GetVDriftTPCLaserTracks(dlc,run,timeStamp,36000,1);
 603   vdriftLTM= fDButil->GetVDriftTPCLaserTracks(dlm,run,timeStamp,36000,2);
 604   //
 605   vdriftLTAon= fDButil->GetVDriftTPCLaserTracksOnline(dlaon,run,timeStamp,36000,0);
 606   vdriftLTCon= fDButil->GetVDriftTPCLaserTracksOnline(dlcon,run,timeStamp,36000,1);
 607   vdriftLTMon= fDButil->GetVDriftTPCLaserTracksOnline(dlmon,run,timeStamp,36000,2);
 608   //
 609   vdriftITS= fDButil->GetVDriftTPCITS(dits, run,timeStamp);
 610   //
 611   ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
 612   ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);
 613
 614   (*fPcstream)<<"dcs"<<
 615     //
 616     "vdriftCEA="<<vdriftCEA<<   // drift velocity CE
 617     "vdriftCEC="<<vdriftCEC<<
 618     "vdriftCEM="<<vdriftCEM<<
 619     "dcea="<<dcea<<
 620     "dcec="<<dcec<<
 621     "dcem="<<dcem<<
 622     "vdriftLTA="<<vdriftLTA<<   // drift velocity laser tracks
 623     "vdriftLTC="<<vdriftLTC<<
 624     "vdriftLTM="<<vdriftLTM<<
 625     "dla="<<dla<<
 626     "dlc="<<dlc<<
 627     "dlm="<<dlm<<
 628     "vdriftLTAon="<<vdriftLTAon<<   // drift velocity laser tracks and CE from online algorithm
 629     "vdriftLTCon="<<vdriftLTCon<<
 630     "vdriftLTMon="<<vdriftLTMon<<
 631     "dlaOn="<<dlaon<<
 632     "dlcOn="<<dlcon<<
 633     "dlmOn="<<dlmon<<
 634     //
 635     //
 636     "vdriftITS="<<vdriftITS<<
 637     "dits="<<dits<<
 638     "ctime0="<<ctime0<<
 639     "vdriftP="<<vdriftP<<       // drift velocity comsic
 640     "dp="<<dp<<
 641     "vdrift1="<<vdrift1;        // combined drift velocity
 642
 643 }
 644
 645
 646
 647 void AliTPCcalibSummary::ProcessKryptonTime(Int_t run, Int_t timeStamp){
 648   //
 649   // Dumping  krypton calibration results
 650   //
 651   static TObjArray * krArray=0;
 652   if (!krArray) {
 653     AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGainKrypton", run);
 654     if (entry){
 655       krArray = (TObjArray*)entry->GetObject();
 656     }
 657   }
 658   static TVectorD krMean(74);
 659   static TVectorD krErr(74);
 660   static TVectorD krDist(74);
 661   TGraphErrors *gr=0;
 662   Double_t deltaT=0,gry=0;
 663   if (krArray){
 664     for (Int_t isec=0; isec<72; isec++){
 665       krMean[isec]=0;
 666       krDist[isec]=0;
 667       krErr[isec]=0;
 668       gr=(TGraphErrors*)krArray->At(isec);
 669       if (gr) {
 670         krMean[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
 671         AliTPCcalibDButil::GetNearest(gr, timeStamp,deltaT,gry);
 672         krDist[isec]=deltaT;
 673       }
 674       if (72+isec<krArray->GetEntries()) {
 675         gr=(TGraphErrors*)krArray->At(72+isec);
 676         if (gr) krErr[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
 677       }
 678     }
 679     krMean[72]= TMath::Median(36,krMean.GetMatrixArray());
 680     krMean[73]= TMath::Median(36,&(krMean.GetMatrixArray()[36]));
 681     krErr[72]= TMath::Median(36,krErr.GetMatrixArray());
 682     krErr[73]= TMath::Median(36,&(krErr.GetMatrixArray()[36]));
 683   }
 684   (*fPcstream)<<"dcs"<<
 685     "krMean.="<<&krMean<<
 686     "krErr.="<<&krErr<<
 687     "krDist.="<<&krDist;
 688 }
 689
 690 void AliTPCcalibSummary::ProcessCTP(Int_t irun, Int_t timeStamp){
 691   //
 692   //
 693   //
 694   static TClonesArray *pcarray = new TClonesArray("AliCTPInputTimeParams",1);
 695   static AliCTPTimeParams *ctpParams =0;
 696   ctpParams = fCalibDB->GetCTPTimeParams(); //
 697   const TObjArray        *arr = ctpParams->GetInputTimeParams();
 698   pcarray->ExpandCreateFast(TMath::Max(arr->GetEntries(),1));
 699   for (Int_t i=0; i<arr->GetEntries(); i++){
 700     new ((*pcarray)[i]) AliCTPInputTimeParams(*((AliCTPInputTimeParams*)arr->At(i)));
 701   }
 702   (*fPcstream)<<"ctp"<<
 703     "run="<<irun<<
 704     "time="<<timeStamp<<
 705     "ctpP.="<<ctpParams<<
 706     "ctpArr="<<pcarray<<
 707     "\n";
 708   (*fPcstream)<<"dcs"<<
 709     "ctpP.="<<ctpParams<<
 710     "ctpArr="<<pcarray;
 711 }
 712
 713 void AliTPCcalibSummary::ProcessGain(Int_t irun, Int_t timeStamp){
 714   //
 715   // Dump gain related information to the tree
 716   //
 717   static Float_t  gainCosmic = 0;
 718   static Float_t  gainMIP = 0;
 719   static Float_t  attachMIP = 0;
 720   static Double_t dMIP=0;
 721   Double_t dummy=0;
 722   TObjArray * gainSplines = fCalibDB->GetTimeGainSplinesRun(irun);
 723   if (gainSplines) {
 724     TGraphErrors * graphMIP = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_BEAM_ALL");
 725     TGraphErrors * graphCosmic = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_COSMIC_ALL");
 726     TGraphErrors * graphAttach = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_ATTACHMENT_BEAM_ALL");
 727     if (graphMIP) gainMIP = AliTPCcalibDButil::EvalGraphConst(graphMIP,timeStamp);
 728     if (graphCosmic) gainCosmic = AliTPCcalibDButil::EvalGraphConst(graphCosmic,timeStamp);
 729     if (graphAttach) attachMIP = AliTPCcalibDButil::EvalGraphConst(graphAttach,timeStamp);
 730     if (graphMIP)  AliTPCcalibDButil::GetNearest(graphMIP, timeStamp, dMIP,dummy);
 731   }
 732   // time dependence of gain
 733   (*fPcstream)<<"dcs"<<
 734     "gainMIP="<<gainMIP<<
 735     "attachMIP="<<attachMIP<<
 736     "dMIP="<<dMIP<<
 737     "gainCosmic="<<gainCosmic;
 738 }
 739
 740
 741 void AliTPCcalibSummary::ProcessAlign(Int_t run, Int_t timeStamp){
 742   //
 743   // Proccess alignment
 744   //
 745   TString   grnames[12]={"ALIGN_ITS", "ALIGN_ITSP", "ALIGN_ITSM", "ALIGN_ITSB",
 746                          "ALIGN_TRD", "ALIGN_TRDP", "ALIGN_TRDM","ALIGN_TRDB",
 747                          "ALIGN_TOF", "ALIGN_TOFP", "ALIGN_TOFM","ALIGN_TOFB"};
 748   TString   grpar[9]={"DELTAPSI", "DELTATHETA", "DELTAPHI",
 749                       "DELTAX", "DELTAY", "DELTAZ",
 750                       "DRIFTVD", "T0", "VDGY"};
 751   static Double_t values[12*9];
 752   static Double_t errs[12*9];
 753
 754   TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
 755   TGraphErrors *gr=0;
 756   for (Int_t idet=0; idet<12; idet++){
 757     for (Int_t ipar=0; ipar<9; ipar++){
 758       TString grName=grnames[idet];
 759       grName+="_TPC_";
 760       grName+=grpar[ipar];
 761       if (array){
 762         gr = (TGraphErrors*)array->FindObject(grName.Data());
 763       }
 764       values[9*idet+ipar]=0;
 765       errs[9*idet+ipar]=0;
 766       if (gr) values[9*idet+ipar]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
 767       (*fPcstream)<<"dcs"<<
 768         Form("%s=",grName.Data())<<values[9*idet+ipar];
 769       (*fPcstream)<<"align"<<
 770         Form("%s=",grName.Data())<<values[9*idet+ipar];
 771     }
 772   }
 773   (*fPcstream)<<"align"<<
 774     "time="<<timeStamp<<
 775     "run="<<run<<
 776     "\n";
 777 }
 778
 779
 780 void AliTPCcalibSummary::ProcessDriftCERef(){
 781   //
 782   // Get fit of residuals if CE in respect with reference
 783   // data
 784   //
 785   static TVectorD  sec(72);
 786   static TVectorD vec0(72);
 787   static TVectorD vecLy(72);
 788   static TVectorD vecLx(72);
 789   static TVectorD vecChi2(72);
 790   static TVectorD vecN(72);
 791   //
 792   static TVectorD vecA0(72);
 793   static TVectorD vecALy(72);
 794   static TVectorD vecALx(72);
 795   static TVectorD vecAChi2(72);
 796   //
 797   static TVectorD vecASide(4);
 798   static TVectorD vecCSide(4);
 799   static Bool_t isCalc=kFALSE;
 800
 801   TFile f("calPads.root");
 802   TFile fref("calPadsRef.root");
 803   TTree * tree = (TTree*)f.Get("calPads");
 804   TTree * treeRef = (TTree*)fref.Get("calPads");
 805   tree->AddFriend(treeRef,"R");
 806   tree->SetAlias("inCE","((CEQmean.fElements>35)&&abs(CETmean.fElements)<1.5&&abs(CETrms.fElements/1.2-1)<0.2)");  // outlyerTrms
 807   tree->SetAlias("inCER","((R.CEQmean.fElements>35)&&abs(R.CETmean.fElements)<1.5&&abs(R.CETrms.fElements/1.2-1)<0.2)");  // outlyerTrms
 808   //
 809   if (!isCalc){
 810     // make fits only once
 811     TStatToolkit toolkit;
 812     Double_t chi2=0;
 813     Int_t    npoints=0;
 814     TVectorD param;
 815     TMatrixD covar;
 816     tree->SetAlias("dt","CETmean.fElements-R.CETmean.fElements");
 817     TCut cutAll ="inCE&&inCER&&abs(CETmean.fElements-R.CETmean.fElements)<0.5";
 818     TString  fstringG="";              // global part
 819     fstringG+="ly.fElements++";
 820     fstringG+="(lx.fElements-134.)++";
 821     for (Int_t isec=0; isec<72; isec++){
 822       TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
 823       if (npoints<3) continue;
 824       printf("Sector=%d\n",isec);
 825       vec0[isec]=param[0];
 826       vecLy[isec]=param[1];
 827       vecLx[isec]=param[2];
 828       sec[isec]=isec;
 829       vecN[isec]=npoints;
 830       vecChi2[isec]=TMath::Sqrt(chi2/npoints);
 831
 832       TStatToolkit::FitPlane(tree,"0.264*CETmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
 833       if (npoints<3) continue;
 834       printf("Sector=%d\n",isec);
 835       vecA0[isec]=param[0];
 836       vecALy[isec]=param[1];
 837       vecALx[isec]=param[2];
 838       vecAChi2[isec]=TMath::Sqrt(chi2/npoints);
 839     }
 840     isCalc=kTRUE;
 841     //
 842     TString  fstringRef="";              // global fit
 843     fstringRef+="gx.fElements++";
 844     fstringRef+="gy.fElements++";
 845     fstringRef+="lx.fElements++";
 846     TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),"(sector%36)<18"+cutAll, chi2,npoints,vecASide,covar,-1,0, 10000000, kFALSE);
 847     TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),"(sector%36)>=18"+cutAll, chi2,npoints,vecCSide,covar,-1,0, 10000000, kFALSE);
 848
 849   }
 850   (*fPcstream)<<"dcs"<<     // CE information
 851     "CETSector.="<<&sec<<    // sector numbers
 852     "CETRefA.="<<&vecASide<<   // diff to reference A side
 853     "CETRefC.="<<&vecCSide<<   // diff to reference C side
 854     //                      // fit in respect to reference data
 855     "CETRef0.="<<&vec0<<    // offset change
 856     "CETRefY.="<<&vecLy<<   // slope y change - rad
 857     "CETRefX.="<<&vecLx<<   // slope x change - rad
 858     "CETRefChi2.="<<&vecChi2<<    // chi2 (rms in cm)
 859     "CETRefN.="<<&vecN<<     //number of accepted points
 860     //                       // fit in respect per mean per side
 861     "CET0.="<<&vecA0<<       // offset change
 862     "CETY.="<<&vecALy<<      // slope y change - rad
 863     "CETX.="<<&vecALx<<      // slope x change - rad
 864     "CETChi2.="<<&vecAChi2;  // chi2 (rms in cm)
 865 }
 866
 867 void AliTPCcalibSummary::ProcessPulserRef(){
 868   //
 869   // Get fit of residuals if Pulser in respect with reference
 870   // data
 871   //
 872   static TVectorD  sec(72);
 873   static TVectorD vec0(72);
 874   static TVectorD vecLy(72);
 875   static TVectorD vecLx(72);
 876   static TVectorD vecChi2(72);
 877   static TVectorD vecN(72);
 878   //
 879   static TVectorD vecA0(72);
 880   static TVectorD vecALy(72);
 881   static TVectorD vecALx(72);
 882   static TVectorD vecAChi2(72);
 883   static Bool_t isCalc=kFALSE;
 884
 885   TFile f("calPads.root");
 886   TFile fref("calPadsRef.root");
 887   TTree * tree = (TTree*)f.Get("calPads");
 888   TTree * treeRef = (TTree*)fref.Get("calPads");
 889   tree->AddFriend(treeRef,"R");
 890
 891   tree->SetAlias("inPulser","(abs(PulserTmean.fElements-PulserTmean_Median)<1.5&&abs(PulserTrms.fElements-PulserTrms_Median)<0.2)");  // outlyerTrms
 892   tree->SetAlias("inPulserR","(abs(R.PulserTmean.fElements-R.PulserTmean_Median)<1.5&&abs(R.PulserTrms.fElements-R.PulserTrms_Median)<0.2)");  // outlyerTrms
 893   //
 894   if (!isCalc){
 895     // make fits only once
 896     TStatToolkit toolkit;
 897     Double_t chi2=0;
 898     Int_t    npoints=0;
 899     TVectorD param;
 900     TMatrixD covar;
 901     tree->SetAlias("dt","PulserTmean.fElements-R.PulserTmean.fElements");
 902     TCut cutAll ="inPulser&&inPulserR";
 903     TString  fstringG="";              // global part
 904     fstringG+="ly.fElements++";
 905     fstringG+="(lx.fElements-134.)++";
 906     for (Int_t isec=0; isec<72; isec++){
 907       TStatToolkit::FitPlane(tree,"dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
 908       if (npoints<3) continue;
 909       printf("Setor=%d\n",isec);
 910       vec0[isec]=param[0];
 911       vecLy[isec]=param[1];
 912       vecLx[isec]=param[2];
 913       sec[isec]=isec;
 914       vecN[isec]=npoints;
 915
 916       TStatToolkit::FitPlane(tree,"PulserTmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
 917       if (npoints<3) continue;
 918       printf("Setor=%d\n",isec);
 919       vecA0[isec]=param[0];
 920       vecALy[isec]=param[1];
 921       vecALx[isec]=param[2];
 922       vecAChi2[isec]=TMath::Sqrt(chi2/npoints);
 923     }
 924
 925     isCalc=kTRUE;
 926   }
 927   (*fPcstream)<<"dcs"<<     // Pulser information
 928     "PulserTSector.="<<&sec<<    // sector numbers
 929     //                      // fit in respect to reference
 930     "PulserTRef0.="<<&vec0<<    // offset change
 931     "PulserTRefY.="<<&vecLy<<   // slope y change - rad
 932     "PulserTRefX.="<<&vecLx<<   // slope x change - rad
 933     "PulserTRefChi2.="<<&vecChi2<<    // chi2 (rms in cm)
 934     "PulserTRefN.="<<&vecN<<     //number of accepted points
 935     //                       // fit in respect per mean per side
 936     "PulserT0.="<<&vecA0<<       // offset change
 937     "PulserTY.="<<&vecALy<<      // slope y change - rad
 938     "PulserTX.="<<&vecALx<<      // slope x change - rad
 939     "PulserTChi2.="<<&vecAChi2;  // chi2 (rms in cm)
 940 }
 941
 942
 943
 944
 945
 946 // TCanvas * DrawCEDiff(TTree * tree){
 947
 948 //   TCanvas *canvasIO = new TCanvas("canvasCEIO","canvasCEIO");
 949 //   canvasIO->Divide(6,6);
 950 //   for (Int_t isec=0; isec<36; isec++){
 951 //     canvasIO->cd(isec+1);
 952 //     dcs->Draw(Form("CET0.fElements[%d]-CET0.fElements[%d]",isec+36,isec),Form("abs(CETRef0.fElements[%d])<0.3",isec),"");
 953 //     printf("%d\t%f\t%f\n",isec,dcs->GetHistogram()->GetMean(),dcs->GetHistogram()->GetRMS());
 954 //   }
 955
 956 // }