Install macros
[u/mrichter/AliRoot.git] / 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     // parameter description is as follows: // <name>;<unit>;<group>;<array type/array info>
369     //      <name> should also include the unit; e.g. IROC anode voltage (V))
370     // where group is e.g.
371     //       o HV:              for High Voltage information
372     //       o Environment:     for environmental information (temperature; pressure)
373     //       o Pulser:          Calibartion pulser information
374     //       o CE:              Central electrode inforamtion
375     //       o Noise Pedestals: Noise and Pedestal information
376     //       o ALTRO:           ALTRO configuration information
377     //
378     // <array type> describes the information stored in the elements of a TVectorT<> variable
379     // this can e.g. be
380     //       o Sector:   The array has 36 entries; one per sector (A00-A17 and C00 to C17)
381     //       o Sector-A: The array has 18 entries; one per sector on the A-Side (A00-A17)
382     //       o Sector-C: The array has 18 entries; one per sector on the C-Side (C00-C17)
383     //       o ROC:      The array has 72 entries; one per ROC (IA00-IA17, IC00-IC17, OA00-OA17, OC00-OC17)
384     //       o Parameters from a fit: in this case the description per parameter should be given
385     (*fPcstream)<<"dcs"<<
386       "run="<<irun<< // Run number
387       "time="<<itime<< // Time stamp of calibration entry
388       "startTimeGRP="<<startTimeGRP<< // Start time of run from GRP
389       "stopTimeGRP="<<stopTimeGRP<< // Stop time of run from GRP
390       "dataTakingActive="<<dataTakingActive<< // If data taking is active
391       //run type
392       "runType.="<<&runType<< // Run Type; e.g. PHYSICS; LASER; COSMIC; PEDESTAL; PULSER
393       // voltage setting
394       "VIROC.="               << &voltagesIROC               << // IROC anode voltage [calib interval] (V);HV;Sector
395       "VIROCMedian.="         << &voltagesIROCMedian         << // IROC anode voltage [Median of run] (V);HV;Sector
396       "VIROCNominal.="        << &voltagesIROCNominal        << // IROC anode voltage [global nominal] (V);HV;Sector
397       "VIROCCurrentNominal.=" << &voltagesIROCCurrentNominal << // IROC anode voltage [current nominal] (V);HV;Sector
398       "VIROCGoodHVFraction.=" << &voltagesIROCGoodFraction   << // IROC anode voltage [fraction of good settings];-;HV;Sector
399       "VIROCStatus.="         << &voltagesIROCStatus         << // IROC HV status;-;HV;Sector
400       //
401       "VOROC.="               << &voltagesOROC               << // OROC anode voltage [calib interval] (V);HV;Sector
402       "VOROCMedian.="         << &voltagesOROCMedian         << // OROC anode voltage [Median of run] (V);HV;Sector
403       "VOROCNominal.="        << &voltagesOROCNominal        << // OROC anode voltage [global nominal] (V);HV;Sector
404       "VOROCCurrentNominal.=" << &voltagesOROCCurrentNominal << // OROC anode voltage [current nominal] (V);HV;Sector
405       "VOROCGoodHVFraction.=" << &voltagesOROCGoodFraction   << // OROC anode voltage [fraction of good settings];-;HV;Sector
406       "VOROCStatus.="         << &voltagesOROCStatus         << // OROC HV status;-;HV;Sector
407       //
408       "medianVIROC="          << voltIROC                    << // IROC anode voltage [median of all IROCs] (V);HV
409       "medianVOROC="          << voltOROC                    << // OROC anode voltage [median of all OROCs] (V);HV
410       "coverIA="              << coverIA                     << // Cover voltage IROC A-Side (V);HV
411       "coverIC="              << coverIC                     << // Cover voltage IROC C-Side (V);HV
412       "coverOA="              << coverOA                     << // Cover voltage OROC A-Side (V);HV
413       "coverOC="              << coverOC                     << // Cover voltage OROC C-Side (V);HV
414       "skirtA="               << skirtA                      << // Skirt voltage IROC A-Side (V);HV
415       "skirtC="               << skirtC                      << // Skirt voltage IROC C-Side (V);HV
416       "ggOffA="               << ggOffA                      << // Gating grid offset voltage A-Side (V);HV
417       "ggOffC="               << ggOffC                      << // Gating grid offset voltage C-Side (V);HV
418       //
419       "ptrel0="<<ptrelative0<<  // deltaTP/TP  - A side
420       "ptrel1="<<ptrelative1<<  // deltaTP/TPC - C side
421       "goofie.="<<&vecGoofie<<
422       "goofieE.="<<&vecEntries<<
423       "goofieMean.="<<&vecMean<<
424       "goofieMedian.="<<&vecMedian<<
425       "goofieRMS.="<<&vecRMS<<
426       //
427       "press="<<valuePressure<<
428       "press2="<<valuePressure2<<
429       "temp00.="<<&vecTemp[0]<< // T-Fit ROC A-Side;Environment;Mean Temp (#circC);dT/dgx (K/cm);dT/dgy (K/cm)
430       "temp10.="<<&vecTemp[1]<< // T-Fit OFC A-Side;Environment;Mean Temp (#circC);dT/dz (K/cm);dT/d#phi (K/rad)
431       "temp20.="<<&vecTemp[2]<< // T-Fit IFC+TS A-Side;Environment;Mean Temp (#circC);dT/dz (K/cm);dT/d#phi (K/rad)
432       "temp30.="<<&vecTemp[3]<< // T-Fit Skirt A-Side;Environment;Mean Temp (#circC);dT/dgx (K/cm);dT/dgy (K/cm)
433       "temp40.="<<&vecTemp[4]<< // T-Fit IFC A-Side;Environment;Mean Temp (#circC);dT/dz (K/cm);dT/d#phi (K/rad)
434       "temp01.="<<&vecTemp[5]<< // T-Fit ROC C-Side;Environment;Mean Temp (#circC);dT/dgx (K/cm);dT/dgy (K/cm)
435       "temp11.="<<&vecTemp[6]<< // T-Fit OFC C-Side;Environment;Mean Temp (#circC);dT/dz (K/cm);dT/d#phi (K/rad)
436       "temp21.="<<&vecTemp[7]<< // T-Fit IFC+TS C-Side;Environment;Mean Temp (#circC);dT/dz (K/cm);dT/d#phi (K/rad)
437       "temp31.="<<&vecTemp[8]<< // T-Fit Skirt C-Side;Environment;Mean Temp (#circC);dT/dgx (K/cm);dT/dgy (K/cm)
438       "temp41.="<<&vecTemp[9]<< // T-Fit IFC C-Side;Environment;Mean Temp (#circC);dT/dz (K/cm);dT/d#phi (K/rad)
439       //
440       "tempSkirtA.="<<&vecSkirtTempA<< // T Skirt A-Side;Environment;Sector-A
441       "tempSkirtC.="<<&vecSkirtTempC;  // T Skirt C-Side;Environment;Sector-C
442
443     ProcessDrift(irun, itime);
444     ProcessDriftCE(irun,itime);
445     ProcessDriftAll(irun,itime);
446     //    ProcessKryptonTime(irun,itime);
447     ProcessCTP(irun,itime);
448     ProcessAlign(irun,itime);
449     ProcessGain(irun,itime);
450     //ProcessDriftCERef();
451     //ProcessPulserRef();
452     //ProcessCurrent(irun,itime);
453
454
455     (*fPcstream)<<"dcs"<<       
456       //noise data
457       "meanNoise.="    << &vNoiseMean           << // Mean Noise;Noise Pedestals;All Pads;IROCs;OROCs small pads;OROCs large pads
458       "meanNoiseSen.=" << &vNoiseMeanSenRegions << // Mean Noise in sensitive regions;Noise Pedestals;All Pads;IROCs;OROCs small pads;OROCs large pads
459       "rmsNoise.="     << &vNoiseRMS            << // RMS Noise;Noise Pedestals;All Pads;IROCs;OROCs small pads;OROCs large pads
460       "rmsNoiseSen.="  << &vNoiseRMSSenRegions  << // RMS Noise in sensitive regions;Noise Pedestals;All Pads;IROCs;OROCs small pads;OROCs large pads
461       "zeroNoise="     << nonMaskedZero         << // Pads with zero noise;Noise Pedestals
462       "nNaN="          << nNaN                  << // Pads with NaN noise;Noise Pedestals
463       //QA data
464       "occQA.="  << &vQaOcc  <<
465       "qQA.="    << &vQaQtot <<
466       "qmaxQA.=" << &vQaQmax <<
467       //pulser data
468       "timePulser.=" << &vTimePulser <<
469       "nOffPulser="<<nOffChannels<<
470       //altro data
471       "nMasked="<< nMasked << // Number of masked pads;ALTRO
472       //
473       //ce data -Jens version
474       //
475       "CEfitA.="        << &fitResultsA  << // CE-Fit A-Side;CE;Offset (timebins);IROC/OROC Offset (timebins);dt/dgx (timebins/cm);dt/dgy (timebins/cm);dt/dlx common (timebins/cm);dt/dlx IROCs (timebins/cm)
476       "CEfitC.="        << &fitResultsC  << // CE Fit C-Side;CE;Offset (timebins);IROC/OROC Offset (timebins);dt/dgx (timebins/cm);dt/dgy (timebins/cm);dt/dlx common (timebins/cm);dt/dlx IROCs (timebins/cm)
477       "nmaskedCE="      << nmaskedCE     << // CE Number of outliers;CE
478       "chi2ACE="        << chi2ACE       << // CE-Fit Chi^{2} A-Side;CE
479       "chi2CCE="        << chi2CCE       << // CE-Fit Chi^{2} C-Side;CE
480       //
481       //ce data new - MI version
482       //
483       "CEfitAMI.="      << &fitCEResultsA<< // CE-Fit A-Side [MI];CE;Offset (timebins);IROC/OROC Offset (timebins);dt/dgx (timebins/cm);dt/dgy (timebins/cm);dt/dlx common (timebins/cm);dt/dlx IROCs (timebins/cm)
484       "CEfitCMI.="      << &fitCEResultsC<< // CE-Fit C-Side [MI];CE;Offset (timebins);IROC/OROC Offset (timebins);dt/dgx (timebins/cm);dt/dgy (timebins/cm);dt/dlx common (timebins/cm);dt/dlx IROCs (timebins/cm)
485       "chi2CEA="        << chi2CEA       << // CE-Fit Chi^{2} A-Side [MI];CE
486       "chi2CEC="        << chi2CEC       << // CE-Fit Chi^{2} C-Side [MI];CE
487       //
488       //ce graph data
489       //
490       "CEgrTEntries.="   << &vecTEntries << // CE-graph drift time - entries;CE;ROC
491       "CEgrTMean.="      << &vecTMean    << // CE-graph mean drift time;CE;ROC
492       "CEgrTRMS.="       << &vecTRMS     << // CE-graph RMS of drift time;CE;ROC
493       "CEgrTMedian.="    << &vecTMedian  << // CE-graph median drift time;CE;ROC
494       "CEgrQEntries.="   << &vecQEntries << // CE-graph charge - entries;CE;ROC
495       "CEgrQMean.="      << &vecQMean    << // CE-graph mean charge;CE;ROC
496       "CEgrQRMS.="       << &vecQRMS     << // CE-graph RMS charge;CE;ROC
497       "CEgrQMedian.="    << &vecQMedian  << // CE-graph median charge;CE;ROC
498       "CEgrDriftA="      << driftTimeA   << // CE median drift time A-Side;CE
499       "CEgrDriftC="      << driftTimeC   << // CE median drift time C-Side;CE
500       //
501       //calib raw data
502       //
503       "nFailL1="         << nFailL1      << // RCU synchonisation failures;ALTRO
504       // b field
505       "Bz="              << bz           << // Magnetic Field (T);Environment
506       "L3polarity="      << l3pol        << // L3 polarity;Environment
507       // production information
508       "nalien="          << nalien       << // obsolete
509       "nRawAlien="       << nRawAlien    << // obsolete
510       "nlocal="          << nlocal       << // obsolete
511       "nRawLocal="       <<nRawLocal     << // obsolete
512       //
513       // comparisons with ref data
514       //
515       "pedestalDeviations.=" << &pedestalDeviations << // Pedestal variation to ref (fraction);Noise Pedestals;>#pm 0.5 ADC;>#pm 1 ADC;>#pm 1.5 ADC;>#pm 2.0 ADC
516       "noiseDeviations.="    << &noiseDeviations    << // Noise var to ref (fraction);Noise Pedestals;>5%;>10%;>15%;>20%
517       "pulserQdeviations.="  << &pulserQdeviations  << // Pulser-Q var to ref (fraction);Pulser;>0.5%;>1%;>5%;>10%
518       //         "pulserVarQMean="<<varQMean<<
519       "pulserNpadsOutOneTB=" << npadsOutOneTB       << // Number of pads with Pulser time var >#pm 1 tb to ROC mean;Pulser
520       "pulserNpadsOffAdd="   << npadsOffAdd         << // Number of pads without signal but signal in ref;Pulser
521       "driftCorrCosmAll="    << dvCorr              <<
522       "\n";
523   }//end run loop
524 }
525
526
527
528
529
530
531 void AliTPCcalibSummary::ProcessDrift(Int_t run, Int_t timeStamp){
532   //
533   // dump drift calibration data to the tree
534   //
535   TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
536   TGraphErrors *laserA[3]={0,0,0};
537   TGraphErrors *laserC[3]={0,0,0};
538   TGraphErrors *cosmicAll=0;
539   static Double_t     vlaserA[3]={0,0,0};
540   static Double_t     vlaserC[3]={0,0,0};
541   static Double_t     vcosmicAll=0;
542   static Double_t     vdrift1=0;                                // TODO: repeated below, obsolete?
543   vdrift1=fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1); // TODO: repeated below, obsolete?
544
545   if (array){
546     laserA[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_A");
547     laserA[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_A");
548     laserA[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_A");
549     laserC[0]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DELAY_LASER_ALL_C");
550     laserC[1]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_DRIFT_LASER_ALL_C");
551     laserC[2]=(TGraphErrors*)array->FindObject("GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_C");
552     cosmicAll =(TGraphErrors*)array->FindObject("TGRAPHERRORS_MEAN_VDRIFT_COSMICS_ALL");
553   }
554
555   //
556   // TODO: the information stored in vlaserXX, vcosmicAll and vclaserXX,vccosmicAll 
557   //       seem to be redundant information do we need to keep vlaserXX vcosmicAll
558   //
559   if (laserA[0]) vlaserA[0]= AliTPCcalibDButil::EvalGraphConst(laserA[0],timeStamp);
560   if (laserA[1]) vlaserA[1]= AliTPCcalibDButil::EvalGraphConst(laserA[1],timeStamp);
561   if (laserA[2]) vlaserA[2]= AliTPCcalibDButil::EvalGraphConst(laserA[2],timeStamp);
562   if (laserC[0]) vlaserC[0]= AliTPCcalibDButil::EvalGraphConst(laserC[0],timeStamp);
563   if (laserC[1]) vlaserC[1]= AliTPCcalibDButil::EvalGraphConst(laserC[1],timeStamp);
564   if (laserC[2]) vlaserC[2]= AliTPCcalibDButil::EvalGraphConst(laserC[2],timeStamp);
565   if (cosmicAll) vcosmicAll= AliTPCcalibDButil::EvalGraphConst(cosmicAll,timeStamp);
566   (*fPcstream)<<"dcs"<<
567     "vlaserA0="   << vlaserA[0] << // Laser offset A-Side;Drift            //TODO: Obsolete
568     "vlaserA1="   << vlaserA[1] << // Laser drift correction A-Side;Drift  //TODO: Obsolete
569     "vlaserA2="   << vlaserA[2] << // Laser gy correction A-Side;Drift     //TODO: Obsolete
570     "vlaserC0="   << vlaserC[0] << // Laser offset C-Side;Drift            //TODO: Obsolete
571     "vlaserC1="   << vlaserC[1] << // Laser drift correction C-Side;Drift  //TODO: Obsolete
572     "vlaserC2="   << vlaserC[2] << // Laser gy correction C-Side;Drift     //TODO: Obsolete
573     "vcosmicAll=" << vcosmicAll << // Cosmic drift corrrection;Drift       //TODO: Obsolete
574     //
575     "vdrift1="    << vdrift1;      // Combined drift correction ;Drift      // TODO: repeated below, obsolete?
576
577   //
578   // define distance to measurement
579   //
580   static Double_t dlaserA=0; 
581   static Double_t dlaserC=0; 
582   static Double_t dcosmic=0; 
583   static Double_t slaserA=0; //TODO: Obsolete?
584   static Double_t slaserC=0; //TODO: Obsolete?
585   static Double_t scosmic=0; //TODO: Obsolete?
586   static Double_t  vclaserA[3]={0,0,0};
587   static Double_t  vclaserC[3]={0,0,0};
588   static Double_t  vccosmicAll=0;
589   for (Int_t i=0;i<3;i++){
590     if (laserA[i]) AliTPCcalibDButil::GetNearest(laserA[i],timeStamp,dlaserA,vclaserA[i]);
591     if (laserC[i]) AliTPCcalibDButil::GetNearest(laserC[i],timeStamp,dlaserC,vclaserC[i]);
592   }  
593   if (cosmicAll) AliTPCcalibDButil::GetNearest(cosmicAll,timeStamp,dcosmic,vccosmicAll);
594   (*fPcstream)<<"dcs"<<
595     "vclaserA0="   << vclaserA[0]<< // Laser offset A-Side;Drift
596     "vclaserA1="   << vclaserA[1]<< // Laser drift correction A-Side;Drift
597     "vclaserA2="   << vclaserA[2]<< // Laser gy correction A-Side;Drift
598     "vclaserC0="   << vclaserC[0]<< // Laser offset A-Side;Drift
599     "vclaserC1="   << vclaserC[1]<< // Laser drift correction A-Side;Drift
600     "vclaserC2="   << vclaserC[2]<< // Laser gy correction A-Side;Drift
601     "vccosmicAll=" << vccosmicAll<< // Cosmic drift corrrection;Drift
602     "dlaserA="     << dlaserA    << // Distance to laser measurement A-Side;Drift
603     "dlaserC="     << dlaserC    << // Distance to laser measurement C-Side;Drift
604     "dcosmic="     << dcosmic    << // Distance to cosmics measurement A-Side;Drift
605     "slaserA="     << slaserA    << //TODO: Obsolete?
606     "slaserC="     << slaserC    << //TODO: Obsolete?
607     "scosmic="     << scosmic;      //TODO: Obsolete?
608
609   static TGeoMatrix * matrixAlign=0;
610   static Double_t twistX=0;
611   static Double_t twistY=0;
612   if (matrixAlign==0){
613     AliTPCComposedCorrection * corr =  (AliTPCComposedCorrection *)array->FindObject("FitCorrectionTime");
614     if (!corr) {
615       matrixAlign=new TGeoHMatrix;
616       
617     }
618     if (corr){
619        AliTPCCalibGlobalMisalignment *align = (AliTPCCalibGlobalMisalignment*)corr->GetCorrections()->FindObject("FitAlignTime");
620        AliTPCExBTwist *twist  = (AliTPCExBTwist*)corr->GetCorrections()->FindObject("FitExBTwistTime");
621        if (twist){
622          twistX=twist->GetXTwist();
623          twistY=twist->GetYTwist();
624          //delete twist;
625        }
626        if (align && align->GetAlignGlobal()){
627          matrixAlign =  (TGeoMatrix*) (align->GetAlignGlobal()->Clone());        
628          //delete align;
629        }
630     }    
631   }
632   (*fPcstream)<<"dcs"<<
633     "alignTime.="<<matrixAlign<<
634     "twistX="<<twistX<<
635     "twistY="<<twistY;
636 }
637
638 void AliTPCcalibSummary::ProcessDriftCE(Int_t run,Int_t timeStamp){
639   //
640   // dump drift calibration data CE
641   //
642   TObjArray *arrT=fCalibDB->GetCErocTtime();
643   AliTPCParam *param=fCalibDB->GetParameters();
644   static TVectorD tdriftCE(74);
645   static TVectorD tndriftCE(74);
646   static TVectorD vdriftCE(74);
647   static TVectorD tcdriftCE(74);
648   static TVectorD tddriftCE(74);
649   static Double_t ltime0A=0.;
650   static Double_t ltime0C=0.;
651   //
652   //
653   //
654   ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0);
655   ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1);
656   //
657   // TODO: are the values tdriftCE and tcdriftCE redundant and need both be kept?
658   for (Int_t i=0; i<arrT->GetEntries();i++){
659     tdriftCE[i]=0;
660     vdriftCE[i]=0;
661     TGraph *graph = (TGraph*)arrT->At(i);
662     if (!graph) continue;
663     tdriftCE[i]=AliTPCcalibDButil::EvalGraphConst(graph,timeStamp);
664     Double_t deltaT,gry;
665     AliTPCcalibDButil::GetNearest(graph,timeStamp,deltaT,gry);
666     tndriftCE[i]=graph->GetN();
667     tcdriftCE[i]=gry;
668     tddriftCE[i]=deltaT;
669     // TODO: use tdriftCE or tndriftCE
670     if (i%36<18){
671       vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
672     }else{
673       vdriftCE[i] =(param->GetZLength(i)/(tdriftCE[i]*param->GetTSample()*(1.-ltime0A)-param->GetL1Delay()))/param->GetDriftV();
674     }
675   }
676   // export values
677   (*fPcstream)<<"dcs"<<  
678     "tdriftCE.="  << &tdriftCE  << // CE arrival time;CE;Sector                  // TODO: obsolete, redundant?
679     "vdriftCE.="  << &vdriftCE  << // CE derived drift velocity;CE;Sector
680     "tndriftCE.=" << &tndriftCE << // CE number of points;CE;Sector
681     "tcdriftCE.=" << &tcdriftCE << // CE arrival time - nearest point;CE;Sector
682     "tddriftCE.=" << &tddriftCE << // CE distance to closest measuement;CE;Sector
683     "ltime0A="    << ltime0A    << // CE laser offset A-Side;CE
684     "ltime0C="    << ltime0C     ; // CE laser offset C-Side;CE
685    }
686
687
688 void AliTPCcalibSummary::ProcessDriftAll(Int_t run,Int_t timeStamp){
689   //
690   // dump drift calibration data  all calibrations form DB util
691   // test of utils
692   static Double_t vdriftCEA=0, vdriftCEC=0, vdriftCEM=0;
693   static Double_t vdriftLTA=0, vdriftLTC=0, vdriftLTM=0;
694   static Double_t vdriftLTAon=0, vdriftLTCon=0, vdriftLTMon=0;
695   static Double_t vdriftITS=0;
696   static Double_t vdriftP=0;
697   static Double_t dcea=0, dcec=0, dcem=0,  dla=0,dlc=0,dlm=0, dlaon=0,dlcon=0,dlmon=0, dp=0;
698   static Double_t dits=0;
699   static Double_t ltime0A=0.;
700   static Double_t ltime0C=0.;
701   static Double_t ctime0=0.;
702   static Double_t vdrift1=0;
703   vdrift1= fCalibDB->GetVDriftCorrectionTime(timeStamp,run,0,1);
704   vdriftP = fDButil->GetVDriftTPC(dp, run, timeStamp, 86400, 3600,0);
705   ctime0 = AliTPCcalibDButil::GetTriggerOffsetTPC(run,timeStamp, 36000, 3600,0);
706   //
707   vdriftCEA= fDButil->GetVDriftTPCCE(dcea,run,timeStamp,36000,0);
708   vdriftCEC= fDButil->GetVDriftTPCCE(dcec,run,timeStamp,36000,1);
709   vdriftCEM= fDButil->GetVDriftTPCCE(dcem,run,timeStamp,36000,2);
710   //
711   vdriftLTA= fDButil->GetVDriftTPCLaserTracks(dla,run,timeStamp,36000,0);
712   vdriftLTC= fDButil->GetVDriftTPCLaserTracks(dlc,run,timeStamp,36000,1);
713   vdriftLTM= fDButil->GetVDriftTPCLaserTracks(dlm,run,timeStamp,36000,2);
714   //
715   vdriftLTAon= fDButil->GetVDriftTPCLaserTracksOnline(dlaon,run,timeStamp,36000,0);
716   vdriftLTCon= fDButil->GetVDriftTPCLaserTracksOnline(dlcon,run,timeStamp,36000,1);
717   vdriftLTMon= fDButil->GetVDriftTPCLaserTracksOnline(dlmon,run,timeStamp,36000,2);
718   //
719   vdriftITS= fDButil->GetVDriftTPCITS(dits, run,timeStamp);
720   //
721   ltime0A  = fDButil->GetLaserTime0(run,timeStamp,36000,0); // TODO: not used, needed?
722   ltime0C  = fDButil->GetLaserTime0(run,timeStamp,36000,1); // TODO: not used, needed?
723
724   (*fPcstream)<<"dcs"<<  
725     //
726     "vdriftCEA="   << vdriftCEA   << // CE drift correction A-Side;Drift
727     "vdriftCEC="   << vdriftCEC   << // CE drift correction C-Side;Drift
728     "vdriftCEM="   << vdriftCEM   << // CE drift correction Mean;Drift
729     "dcea="        << dcea        << // CE distance to closest measurement A-Side;Drift
730     "dcec="        << dcec        << // CE distance to closest measurement C-Side;Drift
731     "dcem="        << dcem        << // CE distance to closest measurement Mean;Drift
732     "vdriftLTA="   << vdriftLTA   << // Offline Laser track vdrift correction A-Side;Drift
733     "vdriftLTC="   << vdriftLTC   << // Offline Laser track vdrift correction C-Side;Drift
734     "vdriftLTM="   << vdriftLTM   << // Offline Laser track vdrift correction Mean;Drift
735     "dla="         << dla         << // Offline Laser track distance to closest measurement A-Side;Drift
736     "dlc="         << dlc         << // Offline Laser track distance to closest measurement C-Side;Drift
737     "dlm="         << dlm         << // Offline Laser track distance to closest measurement Mean;Drift
738     "vdriftLTAon=" << vdriftLTAon << // Online Laser track vdrift correction A-Side;Drift
739     "vdriftLTCon=" << vdriftLTCon << // Online Laser track vdrift correction C-Side;Drift
740     "vdriftLTMon=" << vdriftLTMon << // Online Laser track vdrift correction Mean;Drift
741     "dlaOn="       << dlaon       << // Online Laser track distance to closest measurement A-Side;Drift
742     "dlcOn="       << dlcon       << // Online Laser track distance to closest measurement C-Side;Drift
743     "dlmOn="       << dlmon       << // Online Laser track distance to closest measurement Mean;Drift
744     //
745     //
746     "vdriftITS="   << vdriftITS   << // TPC-ITS vdrift correction;Drift
747     "dits="        << dits        << // TPC-ITS vdrift correction distance to closest measurement;Drift
748     "ctime0="      << ctime0      << // Trigger offset correction;Drift
749     "vdriftP="     << vdriftP     << // Cosmics vdrift correction;Drift
750     "dp="          << dp          << // Cosmics vdrift correction distance to closest measurement;Drift
751     "vdrift1="     << vdrift1      ; // combined drift velocity;Drift
752
753 }
754
755
756
757 void AliTPCcalibSummary::ProcessKryptonTime(Int_t run, Int_t timeStamp){
758   //
759   // Dumping  krypton calibration results
760   //
761   static TObjArray * krArray=0;
762   if (!krArray) {
763     AliCDBEntry* entry = AliCDBManager::Instance()->Get("TPC/Calib/TimeGainKrypton", run);
764     if (entry){
765       krArray = (TObjArray*)entry->GetObject();
766     }
767   }
768   static TVectorD krMean(74);
769   static TVectorD krErr(74);
770   static TVectorD krDist(74);
771   TGraphErrors *gr=0;
772   Double_t deltaT=0,gry=0;
773   if (krArray){
774     for (Int_t isec=0; isec<72; isec++){
775       krMean[isec]=0;
776       krDist[isec]=0;
777       krErr[isec]=0;
778       gr=(TGraphErrors*)krArray->At(isec);
779       if (gr) {
780         krMean[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
781         AliTPCcalibDButil::GetNearest(gr, timeStamp,deltaT,gry);
782         krDist[isec]=deltaT;
783       }     
784       if (72+isec<krArray->GetEntries()) {
785         gr=(TGraphErrors*)krArray->At(72+isec);
786         if (gr) krErr[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
787       }
788     }
789     krMean[72]= TMath::Median(36,krMean.GetMatrixArray());
790     krMean[73]= TMath::Median(36,&(krMean.GetMatrixArray()[36]));
791     krErr[72]= TMath::Median(36,krErr.GetMatrixArray());
792     krErr[73]= TMath::Median(36,&(krErr.GetMatrixArray()[36]));
793   }
794   (*fPcstream)<<"dcs"<<
795     "krMean.="<<&krMean<<
796     "krErr.="<<&krErr<<
797     "krDist.="<<&krDist;
798 }
799
800 void AliTPCcalibSummary::ProcessCTP(Int_t irun, Int_t timeStamp){
801   //
802   // 
803   //
804   static TClonesArray *pcarray = new TClonesArray("AliCTPInputTimeParams",1);
805   static AliCTPTimeParams *ctpParams =0;
806   ctpParams = fCalibDB->GetCTPTimeParams(); //
807   const TObjArray        *arr = ctpParams->GetInputTimeParams();
808   pcarray->ExpandCreateFast(TMath::Max(arr->GetEntries(),1));
809   for (Int_t i=0; i<arr->GetEntries(); i++){
810     new ((*pcarray)[i]) AliCTPInputTimeParams(*((AliCTPInputTimeParams*)arr->At(i)));
811   }
812   (*fPcstream)<<"ctp"<<
813     "run="<<irun<<
814     "time="<<timeStamp<<
815     "ctpP.="<<ctpParams<<
816     "ctpArr="<<pcarray<<
817     "\n";
818   (*fPcstream)<<"dcs"<<
819     "ctpP.="<<ctpParams<<
820     "ctpArr="<<pcarray;
821 }
822
823 void AliTPCcalibSummary::ProcessGain(Int_t irun, Int_t timeStamp){
824   //
825   // Dump gain related information to the tree
826   //
827   static Float_t  gainCosmic = 0;
828   static Float_t  gainMIP = 0;
829   static Float_t  attachMIP = 0;
830   static Double_t dMIP=0; 
831   Double_t dummy=0;
832   static TVectorD vGainGraphIROC(36);
833   static TVectorD vGainGraphOROCmed(36);
834   static TVectorD vGainGraphOROClong(36);
835   static TVectorD vGainGraphIROCErr(36);
836   static TVectorD vGainGraphOROCmedErr(36);
837   static TVectorD vGainGraphOROClongErr(36);
838   //
839   static TVectorD vGainQMaxGraphRegion(3);
840   static TVectorD vGainQTotGraphRegion(3);
841   //
842   static TGraphErrors ggrPadEqualMax(36);
843   static TGraphErrors ggrPadEqualTot(36);
844   //
845   static TGraphErrors ggrDipAngleMaxShort;
846   static TGraphErrors ggrDipAngleMaxMedium;
847   static TGraphErrors ggrDipAngleMaxLong;
848   static TGraphErrors ggrDipAngleMaxAbsolute;
849   //
850   static TGraphErrors ggrDipAngleTotShort;
851   static TGraphErrors ggrDipAngleTotMedium;
852   static TGraphErrors ggrDipAngleTotLong;
853   static TGraphErrors ggrDipAngleTotAbsolute;
854   //
855   static TVectorD vFitDipAngleParMaxShort(3);
856   static TVectorD vFitDipAngleParMaxMedium(3);
857   static TVectorD vFitDipAngleParMaxLong(3);
858   static TVectorD vFitDipAngleParMaxAbsolute(3);
859   //
860   static TVectorD vFitDipAngleParTotShort(3);
861   static TVectorD vFitDipAngleParTotMedium(3);
862   static TVectorD vFitDipAngleParTotLong(3);
863   static TVectorD vFitDipAngleParTotAbsolute(3);
864
865   
866   vGainGraphIROC.Zero();
867   vGainGraphOROCmed.Zero();
868   vGainGraphOROClong.Zero();
869   vGainGraphIROCErr.Zero();
870   vGainGraphOROCmedErr.Zero();
871   vGainGraphOROClongErr.Zero();
872   vGainQMaxGraphRegion.Zero();
873   vGainQTotGraphRegion.Zero();
874   TGraphErrors grDummy;
875   TObjArray * gainSplines = fCalibDB->GetTimeGainSplinesRun(irun);
876   if (gainSplines) {
877     TGraphErrors * graphMIP = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_BEAM_ALL");
878     TGraphErrors * graphCosmic = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_GAIN_COSMIC_ALL");
879     TGraphErrors * graphAttach = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_ATTACHMENT_BEAM_ALL");
880     //
881     TGraphErrors * grPadEqualQMax = (TGraphErrors * ) gainSplines->FindObject("TGRAPHERRORS_MEANQMAX_PADREGIONGAIN_BEAM_ALL");
882     TGraphErrors * grPadEqualQTot = (TGraphErrors * ) gainSplines->FindObject("TGRAPHERRORS_MEANQTOT_PADREGIONGAIN_BEAM_ALL");
883     //
884     TGraphErrors * graphGainIROC       = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_SHORT_BEAM_ALL");
885     TGraphErrors * graphGainOROCMedium = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_MEDIUM_BEAM_ALL");
886     TGraphErrors * graphGainOROCLong   = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_CHAMBERGAIN_LONG_BEAM_ALL");
887     //
888     //
889     TF1*  funDipAngleMax[4]={0x0,0x0,0x0,0x0};
890     TF1*  funDipAngleTot[4]={0x0,0x0,0x0,0x0};
891     TGraphErrors*  grDipAngleMax[4]={0x0,0x0,0x0,0x0};
892     TGraphErrors*  grDipAngleTot[4]={0x0,0x0,0x0,0x0};
893     const char* names[4]={"SHORT","MEDIUM","LONG","ABSOLUTE"};
894     for (Int_t iPadRegion=0; iPadRegion<4; ++iPadRegion) {
895       funDipAngleMax[iPadRegion]=(TF1*) gainSplines->FindObject(Form("TF1_QMAX_DIPANGLE_%s_BEAM_ALL",names[iPadRegion]));
896       funDipAngleTot[iPadRegion]=(TF1*) gainSplines->FindObject(Form("TF1_QTOT_DIPANGLE_%s_BEAM_ALL",names[iPadRegion]));
897       grDipAngleMax[iPadRegion]= (TGraphErrors*) gainSplines->FindObject(Form("TGRAPHERRORS_QMAX_DIPANGLE_%s_BEAM_ALL",names[iPadRegion]));
898       grDipAngleTot[iPadRegion]= (TGraphErrors*) gainSplines->FindObject(Form("TGRAPHERRORS_QTOT_DIPANGLE_%s_BEAM_ALL",names[iPadRegion]));
899     }
900     //
901     for(Int_t iPar=0; iPar < 3; iPar++) {
902       if (funDipAngleMax[0]) vFitDipAngleParMaxShort(iPar)    = funDipAngleMax[0]->GetParameter(iPar);
903       if (funDipAngleMax[1]) vFitDipAngleParMaxMedium(iPar)   = funDipAngleMax[1]->GetParameter(iPar);
904       if (funDipAngleMax[2]) vFitDipAngleParMaxLong(iPar)     = funDipAngleMax[2]->GetParameter(iPar);
905       if (funDipAngleMax[3]) vFitDipAngleParMaxAbsolute(iPar) = funDipAngleMax[3]->GetParameter(iPar);
906       //
907       if (funDipAngleTot[0]) vFitDipAngleParTotShort(iPar)    = funDipAngleTot[0]->GetParameter(iPar);
908       if (funDipAngleTot[1]) vFitDipAngleParTotMedium(iPar)   = funDipAngleTot[1]->GetParameter(iPar);
909       if (funDipAngleTot[2]) vFitDipAngleParTotLong(iPar)     = funDipAngleTot[2]->GetParameter(iPar);
910       if (funDipAngleTot[3]) vFitDipAngleParTotAbsolute(iPar) = funDipAngleTot[3]->GetParameter(iPar);
911     }
912     //
913     if (grDipAngleMax[0]) ggrDipAngleMaxShort    = * grDipAngleMax[0];
914     if (grDipAngleMax[1]) ggrDipAngleMaxMedium   = * grDipAngleMax[1];
915     if (grDipAngleMax[2]) ggrDipAngleMaxLong     = * grDipAngleMax[2];
916     if (grDipAngleMax[3]) ggrDipAngleMaxAbsolute = * grDipAngleMax[3];
917     //
918     if (grDipAngleTot[0]) ggrDipAngleTotShort    = * grDipAngleTot[0];
919     if (grDipAngleTot[1]) ggrDipAngleTotMedium   = * grDipAngleTot[1];
920     if (grDipAngleTot[2]) ggrDipAngleTotLong     = * grDipAngleTot[2];
921     if (grDipAngleTot[3]) ggrDipAngleTotAbsolute = * grDipAngleTot[3];
922     //
923     //
924     TGraphErrors *grPadEqualMax = (TGraphErrors * ) gainSplines->FindObject("TGRAPHERRORS_MEANQMAX_PADREGIONGAIN_BEAM_ALL");
925     TGraphErrors *grPadEqualTot = (TGraphErrors * ) gainSplines->FindObject("TGRAPHERRORS_MEANQTOT_PADREGIONGAIN_BEAM_ALL");
926     if (grPadEqualMax) ggrPadEqualMax = *grPadEqualMax;
927     if (grPadEqualTot) ggrPadEqualTot = *grPadEqualTot;
928
929
930     if (graphGainIROC && graphGainOROCMedium && graphGainOROCLong) {
931       Double_t x=0,y=0;
932       for (Int_t i=0; i<36; ++i){
933         graphGainIROC->GetPoint(i,x,y);
934         vGainGraphIROC(i)=y;
935         graphGainOROCMedium->GetPoint(i,x,y);
936         vGainGraphOROCmed(i)=y;
937         graphGainOROCLong->GetPoint(i,x,y);
938         vGainGraphOROClong(i)=y;
939         //errors
940         vGainGraphIROCErr(i)     = graphGainIROC->GetEY()[i];
941         vGainGraphOROCmedErr(i)  = graphGainOROCMedium->GetEY()[i];
942         vGainGraphOROClongErr(i) = graphGainOROCLong->GetEY()[i];
943       }
944        for (Int_t i=0; i<3; ++i){
945          vGainQMaxGraphRegion[i]=grPadEqualQMax->GetY()[i];
946          vGainQTotGraphRegion[i]=grPadEqualQTot->GetY()[i];
947        }
948     }
949     
950     if (graphMIP) gainMIP = AliTPCcalibDButil::EvalGraphConst(graphMIP,timeStamp);
951     if (graphCosmic) gainCosmic = AliTPCcalibDButil::EvalGraphConst(graphCosmic,timeStamp);
952     if (graphAttach) attachMIP = AliTPCcalibDButil::EvalGraphConst(graphAttach,timeStamp);
953     if (graphMIP)  AliTPCcalibDButil::GetNearest(graphMIP, timeStamp, dMIP,dummy);
954   }
955     
956   // time dependence of gain 
957   (*fPcstream)<<"dcs"<<
958     "grPadEqualMax.="             << &ggrPadEqualMax             <<
959     "grPadEqualTot.="             << &ggrPadEqualTot             <<
960     "rocGainIROC.="               << &vGainGraphIROC             <<
961     "rocGainOROCMedium.="         << &vGainGraphOROCmed          <<
962     "rocGainOROCLong.="           << &vGainGraphOROClong         <<
963     "rocGainErrIROC.="            << &vGainGraphIROCErr          <<
964     "rocGainErrOROCMedium.="      << &vGainGraphOROCmedErr       <<
965     "rocGainErrOROCLong.="        << &vGainGraphOROClongErr      <<
966     "vGainQMaxGraphRegion.="      << &vGainQMaxGraphRegion       <<
967     "vGainQTotGraphRegion.="      << &vGainQTotGraphRegion       <<
968     //
969     "vFitDipAngleParMaxShort.="   << &vFitDipAngleParMaxShort    <<
970     "vFitDipAngleParMaxMedium.="  << &vFitDipAngleParMaxMedium   <<
971     "vFitDipAngleParMaxLong.="    << &vFitDipAngleParMaxLong     <<
972     "vFitDipAngleParMaxAbsolute.="<< &vFitDipAngleParMaxAbsolute <<
973     //
974     "vFitDipAngleParTotShort.="   << &vFitDipAngleParTotShort    <<
975     "vFitDipAngleParTotMedium.="  << &vFitDipAngleParTotMedium   <<
976     "vFitDipAngleParTotLong.="    << &vFitDipAngleParTotLong     <<
977     "vFitDipAngleParTotAbsolute.="<< &vFitDipAngleParTotAbsolute <<
978     //
979     "grDipAngleMaxShort.="        << &ggrDipAngleMaxShort        <<
980     "grDipAngleMaxMedium.="       << &ggrDipAngleMaxMedium       <<
981     "grDipAngleMaxLong.="         << &ggrDipAngleMaxLong         <<
982     "grDipAngleMaxAbsolute.="     << &ggrDipAngleMaxAbsolute     <<
983     //
984     "grDipAngleTotShort.="        << &ggrDipAngleTotShort        <<
985     "grDipAngleTotMedium.="       << &ggrDipAngleTotMedium       <<
986     "grDipAngleTotLong.="         << &ggrDipAngleTotLong         <<
987     "grDipAngleTotAbsolute.="     << &ggrDipAngleTotAbsolute     <<
988     //
989     "gainMIP="                    << gainMIP                     <<
990     "attachMIP="                  << attachMIP                   <<
991     "dMIP="                       << dMIP                        <<
992     "gainCosmic="                 << gainCosmic                   ;
993 }
994
995
996 void AliTPCcalibSummary::ProcessAlign(Int_t run, Int_t timeStamp){
997   //
998   // Proccess alignment 
999   //
1000   TString   grnames[12]={"ALIGN_ITS", "ALIGN_ITSP", "ALIGN_ITSM", "ALIGN_ITSB",
1001                          "ALIGN_TRD", "ALIGN_TRDP", "ALIGN_TRDM","ALIGN_TRDB",
1002                          "ALIGN_TOF", "ALIGN_TOFP", "ALIGN_TOFM","ALIGN_TOFB"};
1003   TString   grpar[9]={"DELTAPSI", "DELTATHETA", "DELTAPHI",
1004                       "DELTAX", "DELTAY", "DELTAZ",
1005                       "DRIFTVD", "T0", "VDGY"};
1006   static Double_t values[12*9];
1007   static Double_t errs[12*9];
1008
1009   TObjArray *array =fCalibDB->GetTimeVdriftSplineRun(run);
1010   TGraphErrors *gr=0;
1011   for (Int_t idet=0; idet<12; idet++){
1012     for (Int_t ipar=0; ipar<9; ipar++){
1013       TString grName=grnames[idet];
1014       grName+="_TPC_";
1015       grName+=grpar[ipar];
1016       if (array){
1017         gr = (TGraphErrors*)array->FindObject(grName.Data());
1018       }
1019       values[9*idet+ipar]=0;
1020       errs[9*idet+ipar]=0;
1021       if (gr) values[9*idet+ipar]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp);
1022       (*fPcstream)<<"dcs"<<
1023         Form("%s=",grName.Data())<<values[9*idet+ipar];
1024       (*fPcstream)<<"align"<<
1025         Form("%s=",grName.Data())<<values[9*idet+ipar];
1026     }
1027   }
1028   (*fPcstream)<<"align"<<
1029     "time="<<timeStamp<<
1030     "run="<<run<<
1031     "\n";
1032 }
1033
1034
1035 void AliTPCcalibSummary::ProcessDriftCERef(){
1036   //
1037   // Get fit of residuals if CE in respect with reference
1038   // data
1039   //
1040   static TVectorD  sec(72);
1041   static TVectorD vec0(72);
1042   static TVectorD vecLy(72);
1043   static TVectorD vecLx(72);
1044   static TVectorD vecChi2(72);
1045   static TVectorD vecN(72);
1046   //
1047   static TVectorD vecA0(72);
1048   static TVectorD vecALy(72);
1049   static TVectorD vecALx(72);
1050   static TVectorD vecAChi2(72);
1051   //
1052   static TVectorD vecASide(4);
1053   static TVectorD vecCSide(4);
1054   static Bool_t isCalc=kFALSE;
1055   
1056   TFile f("calPads.root");
1057   TFile fref("calPadsRef.root");
1058   TTree * tree = (TTree*)f.Get("calPads");
1059   TTree * treeRef = (TTree*)fref.Get("calPads");
1060   tree->AddFriend(treeRef,"R");
1061   tree->SetAlias("inCE","((CEQmean.fElements>35)&&abs(CETmean.fElements)<1.5&&abs(CETrms.fElements/1.2-1)<0.2)");  // outlyerTrms
1062   tree->SetAlias("inCER","((R.CEQmean.fElements>35)&&abs(R.CETmean.fElements)<1.5&&abs(R.CETrms.fElements/1.2-1)<0.2)");  // outlyerTrms
1063   //
1064   if (!isCalc){
1065     // make fits only once
1066     TStatToolkit toolkit;
1067     Double_t chi2=0;
1068     Int_t    npoints=0;
1069     TVectorD param;
1070     TMatrixD covar;
1071     tree->SetAlias("dt","CETmean.fElements-R.CETmean.fElements");
1072     TCut cutAll ="inCE&&inCER&&abs(CETmean.fElements-R.CETmean.fElements)<0.5";
1073     TString  fstringG="";              // global part
1074     fstringG+="ly.fElements++";
1075     fstringG+="(lx.fElements-134.)++";
1076     for (Int_t isec=0; isec<72; isec++){
1077       TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
1078       if (npoints<3) continue;
1079       printf("Sector=%d\n",isec);
1080       vec0[isec]=param[0];
1081       vecLy[isec]=param[1];
1082       vecLx[isec]=param[2];
1083       sec[isec]=isec;
1084       vecN[isec]=npoints;
1085       vecChi2[isec]=TMath::Sqrt(chi2/npoints);
1086
1087       TStatToolkit::FitPlane(tree,"0.264*CETmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
1088       if (npoints<3) continue;
1089       printf("Sector=%d\n",isec);
1090       vecA0[isec]=param[0];
1091       vecALy[isec]=param[1];
1092       vecALx[isec]=param[2];
1093       vecAChi2[isec]=TMath::Sqrt(chi2/npoints);
1094     }
1095     isCalc=kTRUE;
1096     //
1097     TString  fstringRef="";              // global fit
1098     fstringRef+="gx.fElements++";
1099     fstringRef+="gy.fElements++";  
1100     fstringRef+="lx.fElements++";
1101     TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),"(sector%36)<18"+cutAll, chi2,npoints,vecASide,covar,-1,0, 10000000, kFALSE);
1102     TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),"(sector%36)>=18"+cutAll, chi2,npoints,vecCSide,covar,-1,0, 10000000, kFALSE);
1103
1104   }
1105   (*fPcstream)<<"dcs"<<     // CE information
1106     "CETSector.="  << &sec      << // sector numbers
1107     "CETRefA.="    << &vecASide << // diff to reference A side
1108     "CETRefC.="    << &vecCSide << // diff to reference C side
1109     //                      // fit in respect to reference data
1110     "CETRef0.="    << &vec0     << // offset change
1111     "CETRefY.="    << &vecLy    << // slope y change - rad
1112     "CETRefX.="    << &vecLx    << // slope x change - rad
1113     "CETRefChi2.=" << &vecChi2  << // chi2 (rms in cm)
1114     "CETRefN.="    << &vecN     << //number of accepted points
1115     //                       // fit in respect per mean per side
1116     "CET0.="       << &vecA0    << // offset change
1117     "CETY.="       << &vecALy   << // slope y change - rad
1118     "CETX.="       << &vecALx   << // slope x change - rad
1119     "CETChi2.="    << &vecAChi2  ; // chi2 (rms in cm)
1120 }
1121
1122 void AliTPCcalibSummary::ProcessPulserRef(){
1123   //
1124   // Get fit of residuals if Pulser in respect with reference
1125   // data
1126   //
1127   static TVectorD  sec(72);
1128   static TVectorD vec0(72);
1129   static TVectorD vecLy(72);
1130   static TVectorD vecLx(72);
1131   static TVectorD vecChi2(72);
1132   static TVectorD vecN(72);
1133   //
1134   static TVectorD vecA0(72);
1135   static TVectorD vecALy(72);
1136   static TVectorD vecALx(72);
1137   static TVectorD vecAChi2(72);
1138   static Bool_t isCalc=kFALSE;
1139   
1140   TFile f("calPads.root");
1141   TFile fref("calPadsRef.root");
1142   TTree * tree = (TTree*)f.Get("calPads");
1143   TTree * treeRef = (TTree*)fref.Get("calPads");
1144   tree->AddFriend(treeRef,"R");
1145   
1146   tree->SetAlias("inPulser","(abs(PulserTmean.fElements-PulserTmean_Median)<1.5&&abs(PulserTrms.fElements-PulserTrms_Median)<0.2)");  // outlyerTrms
1147   tree->SetAlias("inPulserR","(abs(R.PulserTmean.fElements-R.PulserTmean_Median)<1.5&&abs(R.PulserTrms.fElements-R.PulserTrms_Median)<0.2)");  // outlyerTrms
1148   //
1149   if (!isCalc){
1150     // make fits only once
1151     TStatToolkit toolkit;
1152     Double_t chi2=0;
1153     Int_t    npoints=0;
1154     TVectorD param;
1155     TMatrixD covar;
1156     tree->SetAlias("dt","PulserTmean.fElements-R.PulserTmean.fElements");
1157     TCut cutAll ="inPulser&&inPulserR"; 
1158     TString  fstringG="";              // global part
1159     fstringG+="ly.fElements++";
1160     fstringG+="(lx.fElements-134.)++";  
1161     for (Int_t isec=0; isec<72; isec++){
1162       TStatToolkit::FitPlane(tree,"dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
1163       if (npoints<3) continue;
1164       printf("Setor=%d\n",isec);
1165       vec0[isec]=param[0];
1166       vecLy[isec]=param[1];
1167       vecLx[isec]=param[2];
1168       sec[isec]=isec;
1169       vecN[isec]=npoints;
1170
1171       TStatToolkit::FitPlane(tree,"PulserTmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE);
1172       if (npoints<3) continue;
1173       printf("Setor=%d\n",isec);
1174       vecA0[isec]=param[0];
1175       vecALy[isec]=param[1];
1176       vecALx[isec]=param[2];
1177       vecAChi2[isec]=TMath::Sqrt(chi2/npoints);
1178     }
1179
1180     isCalc=kTRUE;
1181   }
1182   (*fPcstream)<<"dcs"<<     // Pulser information
1183     "PulserTSector.="  << &sec     << // sector numbers
1184     //                      // fit in respect to reference
1185     "PulserTRef0.="    << &vec0    << // offset change
1186     "PulserTRefY.="    << &vecLy   << // slope y change - rad
1187     "PulserTRefX.="    << &vecLx   << // slope x change - rad
1188     "PulserTRefChi2.=" << &vecChi2 << // chi2 (rms in cm)
1189     "PulserTRefN.="    << &vecN    << //number of accepted points
1190     //                       // fit in respect per mean per side
1191     "PulserT0.="       << &vecA0   << // offset change
1192     "PulserTY.="       << &vecALy  << // slope y change - rad
1193     "PulserTX.="       << &vecALx  << // slope x change - rad
1194     "PulserTChi2.="    << &vecAChi2 ; // chi2 (rms in cm)
1195 }
1196
1197 void AliTPCcalibSummary::ProcessCurrent(Int_t irun, Int_t itime){
1198   //
1199   // Dump current 
1200   //
1201   //variables to export
1202   //
1203   static TObjArray *currentArray=new TObjArray(72);   // current graphs
1204   static TObjArray *currentArray2=new TObjArray(72);  // current graphs to export
1205   //
1206   static TVectorD currentIROC(36);                    // current snapshots
1207   static TVectorD currentOROC(36); 
1208   static TVectorF sector(72);                         //
1209   static Double_t medcurIROC = 0;
1210   static Double_t medcurOROC = 0;
1211   //
1212   static TVectorF minROC(72);                         // current mean +-5 minutes
1213   static TVectorF maxROC(72);
1214   static TVectorF meanROC(72);
1215   static TVectorF medianROC(72);
1216   static Double_t meanIIROC=0;
1217   static Double_t meanIOROC=0;
1218   static Double_t medianIIROC=0;
1219   static Double_t medianIOROC=0;
1220   //
1221   AliDCSSensorArray* voltageArray = AliTPCcalibDB::Instance()->GetVoltageSensors(irun);
1222   //
1223   for(Int_t j=1; j<36; j++) currentIROC[j-1] = fCalibDB->GetChamberHighVoltage(irun, j,itime,-1,kTRUE);
1224   for(Int_t j=36; j<72; j++) currentOROC[j-36] = fCalibDB->GetChamberHighVoltage(irun, j,itime,-1,kTRUE);
1225   medcurIROC = TMath::Median(36, currentIROC.GetMatrixArray());
1226   medcurOROC = TMath::Median(36, currentOROC.GetMatrixArray());
1227
1228
1229   if (currentArray->At(0)==0){
1230     for (Int_t isec=0; isec<72; isec++){
1231       TString sensorName="";
1232       const char* sideName=(isec%36<18) ? "A":"C";
1233       if (isec<36){
1234         //IROC
1235         sensorName=Form("TPC_ANODE_I_%s%02d_IMEAS",sideName,isec%18);
1236       }else{
1237         //OROC
1238         sensorName=Form("TPC_ANODE_O_%s%02d_0_IMEAS",sideName,isec%18);
1239       }      
1240     
1241       AliDCSSensor *sensor = 0;
1242       if (voltageArray) sensor= voltageArray->GetSensor(sensorName);   
1243       TGraph *gr=0;
1244       if (!sensor) gr=new TGraph(1);
1245       else{
1246         if (!sensor->GetGraph()) gr=new TGraph(1);
1247         else{
1248           gr=sensor->GetGraph();
1249           Double_t startTime=sensor->GetStartTime();
1250           Double_t * time = new Double_t[gr->GetN()];
1251           for (Int_t ip=0; ip<gr->GetN(); ip++){ time[ip]= (gr->GetX()[ip]*3600.)+startTime;}     
1252           gr=new TGraph(gr->GetN(), time, gr->GetY());
1253           delete [] time;
1254         }      
1255       }
1256       gr->Sort();
1257       currentArray->AddAt(gr, isec);
1258       currentArray->AddAt(gr->Clone(), isec);
1259     }
1260   }
1261
1262
1263   for (Int_t isec=0; isec<72; isec++){
1264     sector[isec]=isec;
1265     TGraph * gr = (TGraph*)currentArray->At(isec);
1266     TGraph * graph2 = (TGraph*)currentArray2->At(isec);    
1267     Int_t firstBin= TMath::BinarySearch(gr->GetN(), gr->GetX(), itime-300.)-2;
1268     Int_t lastBin= TMath::BinarySearch(gr->GetN(), gr->GetX(), itime+300.)+2;
1269     if (firstBin<0) firstBin=0;
1270     if (lastBin>=gr->GetN()) lastBin=gr->GetN()-1;
1271     //
1272     if (firstBin<lastBin){
1273       //
1274       minROC[isec]=TMath::MinElement(lastBin-firstBin, &(gr->GetY()[firstBin]));
1275       maxROC[isec]=TMath::MaxElement(lastBin-firstBin, &(gr->GetY()[firstBin]));
1276       meanROC[isec]=TMath::Mean(lastBin-firstBin, &(gr->GetY()[firstBin]));
1277       medianROC[isec]=TMath::Median(lastBin-firstBin, &(gr->GetY()[firstBin]));
1278       graph2 = new TGraph(lastBin-firstBin, &(gr->GetX()[firstBin]), &(gr->GetY()[firstBin]));
1279       delete currentArray2->At(isec);
1280       currentArray2->AddAt(graph2,isec);
1281     }
1282     (*fPcstream)<<"dcs"<<     // current information
1283       Form("current%d.=",isec)<<graph2;
1284   }     
1285   meanIIROC=TMath::Mean(36, &(meanROC.GetMatrixArray()[0]));
1286   meanIOROC=TMath::Mean(36, &(meanROC.GetMatrixArray()[36]));
1287   medianIIROC=TMath::Median(36, &(meanROC.GetMatrixArray()[0]));
1288   medianIOROC=TMath::Median(36, &(meanROC.GetMatrixArray()[36]));
1289   //
1290   (*fPcstream)<<"dcs"<<     // current information
1291     "isec.="        << &sector      << // sector number
1292     "IIROC.="       << &currentIROC << // current sample at given moment
1293     "IOROC.="       << &currentOROC << // current sample at given moment
1294     "medianIIROC="  << medcurIROC   << // median at given moment
1295     "medianIOROC="  << medcurOROC   << // median at given moment
1296     //
1297     "minIROC.="     << &minROC      << // minimum in +-5 min
1298     "maxIROC.="     << &maxROC      << // maximum in +-5 min
1299     "meanIROC.="    << &meanROC     << // mean in +-5 min
1300     "medianIROC.="  << &medianROC   << // median in +-5 min
1301     "meanIIROC5="   << meanIIROC    << // mean current in IROC +-5 minutes
1302     "meanIOROC5="   << meanIOROC    << // mean current in OROC
1303     "medianIIROC5=" << medianIIROC  << // median current in IROC
1304     "medianIOROC5=" << medianIOROC   ; // medianan current in OROC
1305    
1306
1307   (*fPcstream)<<"current"<<     // current information
1308     "time="         << itime        <<
1309     "isec.="        << &sector      << // sector number
1310     "IIROC.="       << &currentIROC << // current sample at given moment
1311     "IOROC.="       << &currentOROC << // current sample at given moment
1312     "medianIIROC="  << medcurIROC   << // median at given moment
1313     "medianIOROC="  << medcurOROC   << // median at given moment
1314     //
1315     "minIROC.="     << &minROC      << // minimum in +-5 min
1316     "maxIROC.="     << &maxROC      << // maximum in +-5 min
1317     "meanIROC.="    << &meanROC     << // mean in +-5 min
1318     "medianIROC.="  << &medianROC   << // median in +-5 min
1319     "meanIIROC5="   << meanIIROC    << // mean current in IROC +-5 minutes
1320     "meanIOROC5="   << meanIOROC    << // mean current in OROC
1321     "medianIIROC5=" << medianIIROC  << // median current in IROC
1322     "medianIOROC5=" << medianIOROC  << // medianan current in OROC
1323     "\n";
1324
1325 }
1326
1327
1328
1329
1330 // TCanvas * DrawCEDiff(TTree * tree){
1331   
1332 //   TCanvas *canvasIO = new TCanvas("canvasCEIO","canvasCEIO");
1333 //   canvasIO->Divide(6,6);
1334 //   for (Int_t isec=0; isec<36; isec++){
1335 //     canvasIO->cd(isec+1);
1336 //     dcs->Draw(Form("CET0.fElements[%d]-CET0.fElements[%d]",isec+36,isec),Form("abs(CETRef0.fElements[%d])<0.3",isec),"");
1337 //     printf("%d\t%f\t%f\n",isec,dcs->GetHistogram()->GetMean(),dcs->GetHistogram()->GetRMS());
1338 //   }
1339
1340 // }