]>
Commit | Line | Data |
---|---|---|
12f69174 | 1 | /* |
2 | // Make a summary information of calibration. | |
3 | // Store results in the summary trees | |
4 | // OCDB configuration | |
5 | ||
5f547d58 | 6 | Example usage: |
12f69174 | 7 | |
5f547d58 | 8 | gSystem->Load("libANALYSIS"); |
9 | gSystem->Load("libTPCcalib"); | |
12f69174 | 10 | |
5f547d58 | 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; | |
12f69174 | 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> | |
af6a50bb | 59 | #include <TStatToolkit.h> |
60 | #include <TCut.h> | |
12f69174 | 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(); | |
af6a50bb | 127 | fCalibDB->CreateGUITree("calPads.root"); |
128 | fDButil->CreateGUIRefTree("calPadsRef.root"); | |
12f69174 | 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(); | |
af6a50bb | 158 | fCalibDB->CreateGUITree("calPads.root"); |
159 | fDButil->CreateGUIRefTree("calPadsRef.root"); | |
160 | ||
12f69174 | 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 | // | |
abb20887 | 232 | //QA data processing |
233 | // | |
234 | TVectorD vQaOcc; | |
235 | TVectorD vQaQtot; | |
236 | TVectorD vQaQmax; | |
237 | fDButil->ProcessQAData(vQaOcc, vQaQtot, vQaQmax); | |
238 | // | |
12f69174 | 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); | |
5f547d58 | 382 | // ProcessKryptonTime(irun,itime); |
12f69174 | 383 | ProcessCTP(irun,itime); |
384 | ProcessAlign(irun,itime); | |
385 | ProcessGain(irun,itime); | |
af6a50bb | 386 | ProcessDriftCERef(); |
387 | ProcessPulserRef(); | |
12f69174 | 388 | |
389 | ||
390 | (*fPcstream)<<"dcs"<< | |
391 | //noise data | |
392 | "meanNoise.="<<&vNoiseMean<< | |
393 | "meanNoiseSen.="<<&vNoiseMeanSenRegions<< | |
394 | "rmsNoise.="<<&vNoiseRMS<< | |
395 | "rmsNoiseSen.="<<&vNoiseRMSSenRegions<< | |
396 | "zeroNoise="<<nonMaskedZero<< | |
abb20887 | 397 | "nNaN="<<nNaN<< |
398 | //QA data | |
399 | "occQA.=" << &vQaOcc << | |
400 | "qQA.=" << &vQaQtot << | |
401 | "qmaxQA.=" << &vQaQmax << | |
12f69174 | 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; | |
78f17711 | 584 | static Double_t vdriftLTAon=0, vdriftLTCon=0, vdriftLTMon=0; |
12f69174 | 585 | static Double_t vdriftITS=0; |
586 | static Double_t vdriftP=0; | |
78f17711 | 587 | static Double_t dcea=0, dcec=0, dcem=0, dla=0,dlc=0,dlm=0, dlaon=0,dlcon=0,dlmon=0, dp=0; |
12f69174 | 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 | // | |
78f17711 | 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 | // | |
12f69174 | 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<< | |
78f17711 | 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<< | |
12f69174 | 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) { | |
5647625c | 670 | krMean[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp); |
12f69174 | 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); | |
5647625c | 676 | if (gr) krErr[isec]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp); |
12f69174 | 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; | |
5647625c | 719 | static Float_t attachMIP = 0; |
720 | static Double_t dMIP=0; | |
721 | Double_t dummy=0; | |
12f69174 | 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"); | |
5647625c | 726 | TGraphErrors * graphAttach = (TGraphErrors *) gainSplines->FindObject("TGRAPHERRORS_MEAN_ATTACHMENT_BEAM_ALL"); |
12f69174 | 727 | if (graphMIP) gainMIP = AliTPCcalibDButil::EvalGraphConst(graphMIP,timeStamp); |
728 | if (graphCosmic) gainCosmic = AliTPCcalibDButil::EvalGraphConst(graphCosmic,timeStamp); | |
5647625c | 729 | if (graphAttach) attachMIP = AliTPCcalibDButil::EvalGraphConst(graphAttach,timeStamp); |
730 | if (graphMIP) AliTPCcalibDButil::GetNearest(graphMIP, timeStamp, dMIP,dummy); | |
12f69174 | 731 | } |
732 | // time dependence of gain | |
733 | (*fPcstream)<<"dcs"<< | |
734 | "gainMIP="<<gainMIP<< | |
5647625c | 735 | "attachMIP="<<attachMIP<< |
736 | "dMIP="<<dMIP<< | |
12f69174 | 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; | |
5647625c | 766 | if (gr) values[9*idet+ipar]=AliTPCcalibDButil::EvalGraphConst(gr,timeStamp); |
12f69174 | 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 | ||
af6a50bb | 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 | // | |
5647625c | 797 | static TVectorD vecASide(4); |
798 | static TVectorD vecCSide(4); | |
af6a50bb | 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++){ | |
5647625c | 822 | TStatToolkit::FitPlane(tree,"0.264*dt", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE); |
af6a50bb | 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; | |
5647625c | 830 | vecChi2[isec]=TMath::Sqrt(chi2/npoints); |
af6a50bb | 831 | |
5647625c | 832 | TStatToolkit::FitPlane(tree,"0.264*CETmean.fElements", fstringG.Data(),Form("sector==%d",isec)+cutAll, chi2,npoints,param,covar,-1,0, 10000000, kFALSE); |
af6a50bb | 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); | |
af6a50bb | 839 | } |
840 | isCalc=kTRUE; | |
5647625c | 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 | ||
af6a50bb | 849 | } |
850 | (*fPcstream)<<"dcs"<< // CE information | |
851 | "CETSector.="<<&sec<< // sector numbers | |
5647625c | 852 | "CETRefA.="<<&vecASide<< // diff to reference A side |
853 | "CETRefC.="<<&vecCSide<< // diff to reference C side | |
854 | // // fit in respect to reference data | |
af6a50bb | 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 | } | |
12f69174 | 866 | |
af6a50bb | 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 | } | |
5647625c | 924 | |
af6a50bb | 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 | // } |