]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDPreprocessorOffline.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
More Coverity stuff ..
[u/mrichter/AliRoot.git] / TRD / AliTRDPreprocessorOffline.cxx
CommitLineData
b3fcfd96 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16
17
18/*
4c865c34 19 Responsible: Raphaelle Bailhache (rbailhache@ikf.uni-frankfurt.de)
20 Code to analyze the TRD calibration and to produce OCDB entries
b3fcfd96 21
22
23 .x ~/rootlogon.C
24 gSystem->Load("libANALYSIS");
4c865c34 25 gSystem->Load("libTRDcalib");
b3fcfd96 26
27 AliTRDPreprocessorOffline proces;
28 TString ocdbPath="local:////"
29 ocdbPath+=gSystem->GetFromPipe("pwd");
30
31 proces.CalibTimeGain("CalibObjects.root",run0,run1,ocdbPath);
32 proces.CalibTimeVdrift("CalibObjects.root",run0,run1,ocdbPath);
33 // take the raw calibration data from the file CalibObjects.root
34 // and make a OCDB entry with run validity run0-run1
35 // results are stored at the ocdbPath - local or alien ...
36 // default storage ""- data stored at current working directory
37
38*/
00d203b6 39#include "AliLog.h"
b3fcfd96 40#include "Riostream.h"
41#include <fstream>
42#include "TFile.h"
43#include "TCanvas.h"
44#include "TLegend.h"
45#include "TH2I.h"
46#include "TH1I.h"
47#include "TH2F.h"
48#include "TH1F.h"
49#include "TProfile2D.h"
50#include "AliTRDCalDet.h"
51#include "AliTRDCalPad.h"
52#include "AliCDBMetaData.h"
53#include "AliCDBId.h"
54#include "AliCDBManager.h"
55#include "AliCDBStorage.h"
56#include "AliTRDCalibraMode.h"
57#include "AliTRDCalibraFit.h"
58#include "AliTRDCalibraVdriftLinearFit.h"
59#include "AliTRDPreprocessorOffline.h"
60
61
62ClassImp(AliTRDPreprocessorOffline)
63
64AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
01239968 65 TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"),
b3fcfd96 66 fMethodSecond(kTRUE),
01239968 67 fNameList("TRDCalib"),
68 fCalDetGainUsed(0x0),
4c865c34 69 fCalDetVdriftUsed(0x0),
b3fcfd96 70 fCH2d(0x0),
71 fPH2d(0x0),
72 fPRF2d(0x0),
73 fAliTRDCalibraVdriftLinearFit(0x0),
74 fNEvents(0x0),
75 fAbsoluteGain(0x0),
76 fPlots(new TObjArray(8)),
4c865c34 77 fCalibObjects(new TObjArray(8)),
78 fVersionGainUsed(0),
79 fSubVersionGainUsed(0),
80 fVersionVdriftUsed(0),
00d203b6 81 fSubVersionVdriftUsed(0),
82 fSwitchOnValidation(kTRUE),
83 fVdriftValidated(kFALSE),
a2a4ec8e 84 fT0Validated(kFALSE),
85 fMinStatsVdriftT0PH(800*20),
86 fMinStatsVdriftLinear(800),
87 fMinStatsGain(800),
88 fMinStatsPRF(600)
b3fcfd96 89{
90 //
91 // default constructor
92 //
93}
00d203b6 94//_________________________________________________________________________________________________________________
b3fcfd96 95AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
96 //
97 // Destructor
98 //
99
01239968 100 if(fCalDetGainUsed) delete fCalDetGainUsed;
4c865c34 101 if(fCalDetVdriftUsed) delete fCalDetVdriftUsed;
b3fcfd96 102 if(fCH2d) delete fCH2d;
103 if(fPH2d) delete fPH2d;
104 if(fPRF2d) delete fPRF2d;
105 if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
106 if(fNEvents) delete fNEvents;
107 if(fAbsoluteGain) delete fAbsoluteGain;
108 if(fPlots) delete fPlots;
109 if(fCalibObjects) delete fCalibObjects;
110
111}
00d203b6 112//___________________________________________________________________________________________________________________
b3fcfd96 113
114void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
115 //
116 // make calibration of the drift velocity
117 // Input parameters:
118 // file - the location of input file
119 // startRunNumber, endRunNumber - run validity period
120 // ocdbStorage - path to the OCDB storage
121 // - if empty - local storage 'pwd' uesed
122 if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
123 //
124 // 1. Initialization
125 //
008817a3 126 fVdriftValidated = kTRUE;
127 fT0Validated = kTRUE;
b3fcfd96 128 //
129 // 2. extraction of the information
130 //
131 if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
132 if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit();
133 //
134 // 3. Append QA plots
135 //
136 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
137 //
138 //
00d203b6 139 // 4. validate OCDB entries
b3fcfd96 140 //
00d203b6 141 if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) {
142 AliError("TRD vdrift OCDB parameters out of range!");
143 fVdriftValidated = kFALSE;
144 }
145 if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) {
146 AliError("TRD t0 OCDB parameters out of range!");
147 fT0Validated = kFALSE;
148 }
b3fcfd96 149 //
00d203b6 150 // 5. update of OCDB
151 //
152 //
153 if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage);
154 if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage);
155
b3fcfd96 156}
00d203b6 157//_________________________________________________________________________________________________________________
b3fcfd96 158
159void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
160 //
161 // make calibration of the drift velocity
162 // Input parameters:
163 // file - the location of input file
164 // startRunNumber, endRunNumber - run validity period
165 // ocdbStorage - path to the OCDB storage
166 // - if empty - local storage 'pwd' uesed
167 if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
168 //
169 // 1. Initialization
170 if(!ReadGainGlobal(file)) return;
171 //
172 //
173 // 2. extraction of the information
174 //
175 AnalyzeGain();
01239968 176 if(fCalDetGainUsed) CorrectFromDetGainUsed();
4c865c34 177 if(fCalDetVdriftUsed) CorrectFromDetVdriftUsed();
b3fcfd96 178 //
179 // 3. Append QA plots
180 //
181 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
182 //
183 //
00d203b6 184 // 4. validate OCDB entries
185 //
186 if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) {
187 AliError("TRD gain OCDB parameters out of range!");
188 return;
189 }
b3fcfd96 190 //
00d203b6 191 // 5. update of OCDB
b3fcfd96 192 //
00d203b6 193 //
194 if((!fCalDetVdriftUsed) || (fCalDetVdriftUsed && fVdriftValidated)) UpdateOCDBGain(startRunNumber,endRunNumber,ocdbStorage);
195
b3fcfd96 196
197}
00d203b6 198//________________________________________________________________________________________________________________
b3fcfd96 199
200void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
201 //
202 // make calibration of the drift velocity
203 // Input parameters:
204 // file - the location of input file
205 // startRunNumber, endRunNumber - run validity period
206 // ocdbStorage - path to the OCDB storage
207 // - if empty - local storage 'pwd' uesed
208 if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
209 //
210 // 1. Initialization
211 if(!ReadPRFGlobal(file)) return;
212 //
213 //
214 // 2. extraction of the information
215 //
216 AnalyzePRF();
217 //
218 // 3. Append QA plots
219 //
220 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
221 //
222 //
00d203b6 223 //
224 // 4. validate OCDB entries
225 //
226 if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) {
227 AliError("TRD prf OCDB parameters out of range!");
228 return;
229 }
230 //
231 // 5. update of OCDB
b3fcfd96 232 //
233 //
234 UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage);
235
236}
00d203b6 237//______________________________________________________________________________________________________
4c865c34 238Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
239 //
240 // read the calibration used during the reconstruction
241 //
242
243 if(ReadVdriftT0Global(fileName)) {
244
245 TString nameph = fPH2d->GetTitle();
246 fVersionVdriftUsed = GetVersion(nameph);
247 fSubVersionVdriftUsed = GetSubVersion(nameph);
248
249 //printf("Found Version %d, Subversion %d for vdrift\n",fVersionVdriftUsed,fSubVersionVdriftUsed);
250
251 }
252
253 if(ReadGainGlobal(fileName)) {
254
255 TString namech = fCH2d->GetTitle();
256 fVersionGainUsed = GetVersion(namech);
257 fSubVersionGainUsed = GetSubVersion(namech);
258
259 //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed);
260
261 }
262
263 return kTRUE;
264
265}
00d203b6 266//___________________________________________________________________________________________________________________
b3fcfd96 267
268Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){
269 //
270 // read calibration entries from file
271 //
4c865c34 272 if(fCH2d) return kTRUE;
b3fcfd96 273 TFile fcalib(fileName);
01239968 274 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 275 if (array){
276 TH2I *ch2d = (TH2I *) array->FindObject("CH2d");
277 if(!ch2d) return kFALSE;
278 fCH2d = (TH2I*)ch2d->Clone();
279 //fNEvents = (TH1I *) array->FindObject("NEvents");
280 //fAbsoluteGain = (TH2F *) array->FindObject("AbsoluteGain");
281 }else{
282 TH2I *ch2d = (TH2I *) fcalib.Get("CH2d");
283 if(!ch2d) return kFALSE;
284 fCH2d = (TH2I*)ch2d->Clone();
285 //fNEvents = (TH1I *) fcalib.Get("NEvents");
286 //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain");
287 }
288 fCH2d->SetDirectory(0);
289 //printf("title of CH2d %s\n",fCH2d->GetTitle());
290
291 return kTRUE;
292
293}
00d203b6 294//_________________________________________________________________________________________________________________
b3fcfd96 295
296Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){
297 //
298 // read calibration entries from file
299 //
4c865c34 300 if(fPH2d) return kTRUE;
b3fcfd96 301 TFile fcalib(fileName);
01239968 302 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 303 if (array){
304 TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d");
305 if(!ph2d) return kFALSE;
306 fPH2d = (TProfile2D*)ph2d->Clone();
307 //fNEvents = (TH1I *) array->FindObject("NEvents");
308 }else{
309 TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d");
310 if(!ph2d) return kFALSE;
311 fPH2d = (TProfile2D*)ph2d->Clone();
312 //fNEvents = (TH1I *) fcalib.Get("NEvents");
313 }
314 fPH2d->SetDirectory(0);
315 //printf("title of PH2d %s\n",fPH2d->GetTitle());
316
317 return kTRUE;
318
319}
00d203b6 320//___________________________________________________________________________________________________________________
b3fcfd96 321
322Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){
323 //
324 // read calibration entries from file
325 //
4c865c34 326 if(fAliTRDCalibraVdriftLinearFit) return kTRUE;
b3fcfd96 327 TFile fcalib(fileName);
01239968 328 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 329 if (array){
330 fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit");
331 //fNEvents = (TH1I *) array->FindObject("NEvents");
332 }else{
333 fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit");
334 //fNEvents = (TH1I *) fcalib.Get("NEvents");
335 }
336 if(!fAliTRDCalibraVdriftLinearFit) {
337 //printf("No AliTRDCalibraVdriftLinearFit\n");
338 return kFALSE;
339 }
340 return kTRUE;
341
342}
00d203b6 343//_____________________________________________________________________________________________________________
b3fcfd96 344
345Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
346 //
347 // read calibration entries from file
348 //
4c865c34 349 if(fPRF2d) return kTRUE;
b3fcfd96 350 TFile fcalib(fileName);
01239968 351 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 352 if (array){
353 TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d");
354 if(!prf2d) return kFALSE;
355 fPRF2d = (TProfile2D*)prf2d->Clone();
356 //fNEvents = (TH1I *) array->FindObject("NEvents");
357 }else{
358 TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d");
359 if(!prf2d) return kFALSE;
360 fPRF2d = (TProfile2D*)prf2d->Clone();
361 //fNEvents = (TH1I *) fcalib.Get("NEvents");
362 }
363 fPRF2d->SetDirectory(0);
364 //printf("title of PRF2d %s\n",fPRF2d->GetTitle());
365
366 return kTRUE;
367
368}
00d203b6 369//__________________________________________________________________________________________________________
b3fcfd96 370
371Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
372 //
373 // Analyze gain - produce the calibration objects
374 //
375
376 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 377 calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 378 calibra->AnalyseCH(fCH2d);
379
380 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
381 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
382 Int_t nbfit = calibra->GetNumberFit();
383 Int_t nbE = calibra->GetNumberEnt();
384
385
386 Bool_t ok = kFALSE;
4c865c34 387 Bool_t meanother = kFALSE;
b3fcfd96 388 // enough statistics
389 if ((nbtg > 0) &&
390 (nbfit >= 0.5*nbE) && (nbE > 30)) {
391 // create the cal objects
4c865c34 392 if(!fCalDetGainUsed) {
393 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
394 meanother = kTRUE;
395 }
b3fcfd96 396 TObjArray object = calibra->GetVectorFit();
4c865c34 397 AliTRDCalDet *calDetGain = calibra->CreateDetObjectGain(&object,meanother);
b3fcfd96 398 TH1F *coefGain = calDetGain->MakeHisto1DAsFunctionOfDet();
399 // Put them in the array
400 fCalibObjects->AddAt(calDetGain,kGain);
401 fPlots->AddAt(coefGain,kGain);
402 //
403 ok = kTRUE;
404 }
405
406 calibra->ResetVectorFit();
407
408 return ok;
409
410}
00d203b6 411//_____________________________________________________________________________________________________
b3fcfd96 412Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
413 //
414 // Analyze VdriftT0 - produce the calibration objects
415 //
416
417 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 418 calibra->SetMinEntries(fMinStatsVdriftT0PH); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 419 calibra->AnalysePH(fPH2d);
420
421 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
422 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
423 Int_t nbfit = calibra->GetNumberFit();
424 Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
425 Int_t nbE = calibra->GetNumberEnt();
426
427 //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
428
429 Bool_t ok = kFALSE;
430 if ((nbtg > 0) &&
431 (nbfit >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
432 //printf("Pass the cut for VdriftT0\n");
433 // create the cal objects
01239968 434 calibra->RemoveOutliers(1,kFALSE);
435 calibra->PutMeanValueOtherVectorFit(1,kFALSE);
436 calibra->RemoveOutliers2(kFALSE);
437 calibra->PutMeanValueOtherVectorFit2(1,kFALSE);
438 //
b3fcfd96 439 TObjArray object = calibra->GetVectorFit();
440 AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object);
441 TH1F *coefVdriftPH = calDetVdrift->MakeHisto1DAsFunctionOfDet();
442 AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift);
443 TH1F *coefPadVdrift = calPadVdrift->MakeHisto1D();
444 object = calibra->GetVectorFit2();
445 AliTRDCalDet *calDetT0 = calibra->CreateDetObjectT0(&object);
446 TH1F *coefT0 = calDetT0->MakeHisto1DAsFunctionOfDet();
447 AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0);
448 TH1F *coefPadT0 = calPadT0->MakeHisto1D();
449 // Put them in the array
450 fCalibObjects->AddAt(calDetT0,kT0PHDet);
451 fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet);
452 fCalibObjects->AddAt(calPadT0,kT0PHPad);
453 fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad);
454 fPlots->AddAt(coefVdriftPH,kVdriftPHDet);
455 fPlots->AddAt(coefT0,kT0PHDet);
456 fPlots->AddAt(coefPadVdrift,kVdriftPHPad);
457 fPlots->AddAt(coefPadT0,kT0PHPad);
458 //
459 ok = kTRUE;
460 }
461 calibra->ResetVectorFit();
462
463 return ok;
464
465}
00d203b6 466//____________________________________________________________________________________________________________________
b3fcfd96 467Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
468 //
469 // Analyze vdrift linear fit - produce the calibration objects
470 //
471
472 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 473 calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
01239968 474 fAliTRDCalibraVdriftLinearFit->FillPEArray();
b3fcfd96 475 calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
476
477 //Int_t nbtg = 540;
478 Int_t nbfit = calibra->GetNumberFit();
479 Int_t nbE = calibra->GetNumberEnt();
480
481
482 Bool_t ok = kFALSE;
483 // enough statistics
484 if ((nbfit >= 0.5*nbE) && (nbE > 30)) {
485 // create the cal objects
01239968 486 //calibra->RemoveOutliers(1,kTRUE);
487 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
488 //calibra->RemoveOutliers2(kTRUE);
489 calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
490 //
b3fcfd96 491 TObjArray object = calibra->GetVectorFit();
492 AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE);
493 TH1F *coefDriftLinear = calDetVdrift->MakeHisto1DAsFunctionOfDet();
494 object = calibra->GetVectorFit2();
495 AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
496 TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
497 // Put them in the array
498 fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
499 fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
500 fPlots->AddAt(coefDriftLinear,kVdriftLinear);
501 fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
502 //
503 ok = kTRUE;
504 }
505
506 calibra->ResetVectorFit();
507
508 return ok;
509
510}
00d203b6 511//________________________________________________________________________________________________________________
b3fcfd96 512
513Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
514 //
515 // Analyze PRF - produce the calibration objects
516 //
517
518 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 519 calibra->SetMinEntries(fMinStatsPRF); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 520 calibra->AnalysePRFMarianFit(fPRF2d);
521
522 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
523 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
524 Int_t nbfit = calibra->GetNumberFit();
525 Int_t nbE = calibra->GetNumberEnt();
526
527
528 Bool_t ok = kFALSE;
529 // enough statistics
530 if ((nbtg > 0) &&
531 (nbfit >= 0.95*nbE) && (nbE > 30)) {
532 // create the cal objects
533 TObjArray object = calibra->GetVectorFit();
534 AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object);
535 TH1F *coefPRF = calPadPRF->MakeHisto1D();
536 // Put them in the array
537 fCalibObjects->AddAt(calPadPRF,kPRF);
538 fPlots->AddAt(coefPRF,kPRF);
539 //
540 ok = kTRUE;
541 }
542
543 calibra->ResetVectorFit();
544
545 return ok;
546
547}
00d203b6 548//________________________________________________________________________________________________
01239968 549void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
4c865c34 550 //
551 // Correct from the gas gain used afterwards
552 //
01239968 553 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
554 if(!calDetGain) return;
555
4c865c34 556 // Calculate mean
557 Double_t mean = 0.0;
558 Int_t nbdet = 0;
559
01239968 560 for(Int_t det = 0; det < 540; det++) {
561
562 Float_t gaininit = fCalDetGainUsed->GetValue(det);
563 Float_t gainout = calDetGain->GetValue(det);
01239968 564
4c865c34 565
566 if(TMath::Abs(gainout-1.0) > 0.000001) {
567 mean += (gaininit*gainout);
568 nbdet++;
569 }
570 }
571 if(nbdet > 0) mean = mean/nbdet;
572
573 for(Int_t det = 0; det < 540; det++) {
574
575 Float_t gaininit = fCalDetGainUsed->GetValue(det);
576 Float_t gainout = calDetGain->GetValue(det);
577
578 if(TMath::Abs(gainout-1.0) > 0.000001) calDetGain->SetValue(det,gaininit*gainout);
579 else calDetGain->SetValue(det,mean);
01239968 580 }
581
582
583}
00d203b6 584//________________________________________________________________________________________________
4c865c34 585void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
586 //
587 // Correct from the drift velocity
588 //
589
590 //printf("Correct for vdrift\n");
591
592 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
593 if(!calDetGain) return;
594
595 Int_t detVdrift = kVdriftPHDet;
596 if(fMethodSecond) detVdrift = kVdriftLinear;
597 AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
598 if(!calDetVdrift) return;
599
600 // Calculate mean
601
602 for(Int_t det = 0; det < 540; det++) {
603
604 Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
605 Float_t vdriftout = calDetVdrift->GetValue(det);
606
607 Float_t gain = calDetGain->GetValue(det);
608 if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
609 calDetGain->SetValue(det,gain);
610
611
612 }
613
614}
00d203b6 615//_________________________________________________________________________________________________________________
b3fcfd96 616void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
617 //
618 // Update OCDB entry
619 //
620
621 AliCDBMetaData *metaData= new AliCDBMetaData();
622 metaData->SetObjectClassName("AliTRDCalDet");
623 metaData->SetResponsible("Raphaelle Bailhache");
624 metaData->SetBeamPeriod(1);
625
626 AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
627 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
628 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
629 if(calDet) gStorage->Put(calDet, id1, metaData);
b3fcfd96 630
631
632}
00d203b6 633//___________________________________________________________________________________________________________________
b3fcfd96 634void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
635 //
636 // Update OCDB entry
637 //
638
639 Int_t detVdrift = kVdriftPHDet;
640
641 if(fMethodSecond) detVdrift = kVdriftLinear;
642
643 AliCDBMetaData *metaData= new AliCDBMetaData();
644 metaData->SetObjectClassName("AliTRDCalDet");
645 metaData->SetResponsible("Raphaelle Bailhache");
646 metaData->SetBeamPeriod(1);
647
648 AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
649 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
650 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
651 if(calDet) gStorage->Put(calDet, id1, metaData);
4c865c34 652
b3fcfd96 653 //
654
655 if(!fMethodSecond) {
656
657 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
658 metaDataPad->SetObjectClassName("AliTRDCalPad");
659 metaDataPad->SetResponsible("Raphaelle Bailhache");
660 metaDataPad->SetBeamPeriod(1);
661
662 AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
663 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
664 if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
4c865c34 665
b3fcfd96 666 }
667
668}
00d203b6 669//________________________________________________________________________________________________________________________
b3fcfd96 670void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
671 //
672 // Update OCDB entry
673 //
674
675 AliCDBMetaData *metaData= new AliCDBMetaData();
676 metaData->SetObjectClassName("AliTRDCalDet");
677 metaData->SetResponsible("Raphaelle Bailhache");
678 metaData->SetBeamPeriod(1);
679
680 AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
681 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
682 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
683 if(calDet) gStorage->Put(calDet, id1, metaData);
b3fcfd96 684
b3fcfd96 685 //
686
687 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
688 metaDataPad->SetObjectClassName("AliTRDCalPad");
689 metaDataPad->SetResponsible("Raphaelle Bailhache");
690 metaDataPad->SetBeamPeriod(1);
691
692 AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
693 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
694 if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
4c865c34 695
b3fcfd96 696
697
698}
00d203b6 699//_________________________________________________________________________________________________________________
b3fcfd96 700void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
701 //
702 // Update OCDB entry
703 //
704
705 AliCDBMetaData *metaData= new AliCDBMetaData();
706 metaData->SetObjectClassName("AliTRDCalPad");
707 metaData->SetResponsible("Raphaelle Bailhache");
708 metaData->SetBeamPeriod(1);
709
710 AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
711 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
712 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
713 if(calPad) gStorage->Put(calPad, id1, metaData);
b3fcfd96 714
715
00d203b6 716}
717//__________________________________________________________________________________________________________________________
718Bool_t AliTRDPreprocessorOffline::ValidateGain() const {
719 //
720 // Validate OCDB entry
721 //
722
723 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
724 if(calDet) {
725 Double_t mean = calDet->GetMean();
726 Double_t rms = calDet->GetRMS();
727 if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
728 else return kFALSE;
729 }
730 else return kFALSE;
731
732
733}
734//__________________________________________________________________________________________________________________________
735Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
736 //
737 // Update OCDB entry
738 //
739
740 Int_t detVdrift = kVdriftPHDet;
741 Bool_t ok = kTRUE;
742
743 if(fMethodSecond) detVdrift = kVdriftLinear;
744
745 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
746 if(calDet) {
747 Double_t mean = calDet->GetMean();
748 Double_t rms = calDet->GetRMS();
749 //printf("Vdrift::mean %f, rms %f\n",mean,rms);
750 if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE;
751 }
752 else return kFALSE;
753
754 if(!fMethodSecond) {
755 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
756 if(calPad) {
757 Double_t mean = calPad->GetMean();
758 Double_t rms = calPad->GetRMS();
759 //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
760 if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE;
761 }
762 else return kFALSE;
763 }
764
765 return ok;
766
767}
768//__________________________________________________________________________________________________________________________
769Bool_t AliTRDPreprocessorOffline::ValidateT0(){
770 //
771 // Update OCDB entry
772 //
773
774 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
775 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
776 if(calDet && calPad) {
777 Double_t meandet = calDet->GetMean();
778 Double_t rmsdet = calDet->GetRMS();
779 Double_t meanpad = calPad->GetMean();
780 //Double_t rmspad = calPad->GetRMS();
781 //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
782 if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
783 else return kFALSE;
784 }
785 else return kFALSE;
786
787}
788//__________________________________________________________________________________________________________________________
789Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
790 //
791 // Update OCDB entry
792 //
793
794 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
795 if(calPad) {
796 Double_t meanpad = calPad->GetMean();
797 Double_t rmspad = calPad->GetRMS();
798 //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
799 if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
800 else return kFALSE;
801 }
802 else return kFALSE;
803
804
b3fcfd96 805}
4c865c34 806//_____________________________________________________________________________
807Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
808{
809 //
810 // Get version from the title
811 //
812
813 // Some patterns
814 const Char_t *version = "Ver";
815 if(!strstr(name.Data(),version)) return -1;
816
817 for(Int_t ver = 0; ver < 999999999; ver++) {
818
819 TString vertry(version);
820 vertry += ver;
821 vertry += "Subver";
822
823 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
824
825 if(strstr(name.Data(),vertry.Data())) return ver;
826
827 }
828
829 return -1;
830
831}
832
833//_____________________________________________________________________________
834Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
835{
836 //
837 // Get subversion from the title
838 //
839
840 // Some patterns
841 const Char_t *subversion = "Subver";
842 if(!strstr(name.Data(),subversion)) return -1;
843
844 for(Int_t ver = 0; ver < 999999999; ver++) {
845
846 TString vertry(subversion);
847 vertry += ver;
848 vertry += "Nz";
849
850 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
851
852 if(strstr(name.Data(),vertry.Data())) return ver;
853
854 }
855
856 return -1;
857
858}
01239968 859