]> 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
fix for bug 79155. To be ported to release v4-20-Release
[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"
81a5aeca 60#include "AliTRDCalChamberStatus.h"
b3fcfd96 61
62
63ClassImp(AliTRDPreprocessorOffline)
64
65AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
01239968 66 TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"),
b3fcfd96 67 fMethodSecond(kTRUE),
01239968 68 fNameList("TRDCalib"),
69 fCalDetGainUsed(0x0),
4c865c34 70 fCalDetVdriftUsed(0x0),
b3fcfd96 71 fCH2d(0x0),
72 fPH2d(0x0),
73 fPRF2d(0x0),
74 fAliTRDCalibraVdriftLinearFit(0x0),
75 fNEvents(0x0),
76 fAbsoluteGain(0x0),
adab6236 77 fPlots(new TObjArray(9)),
78 fCalibObjects(new TObjArray(9)),
4c865c34 79 fVersionGainUsed(0),
80 fSubVersionGainUsed(0),
ca7e6e64 81 fFirstRunVdriftUsed(0),
4c865c34 82 fVersionVdriftUsed(0),
00d203b6 83 fSubVersionVdriftUsed(0),
84 fSwitchOnValidation(kTRUE),
85 fVdriftValidated(kFALSE),
a2a4ec8e 86 fT0Validated(kFALSE),
87 fMinStatsVdriftT0PH(800*20),
88 fMinStatsVdriftLinear(800),
89 fMinStatsGain(800),
90 fMinStatsPRF(600)
b3fcfd96 91{
92 //
93 // default constructor
94 //
95}
00d203b6 96//_________________________________________________________________________________________________________________
b3fcfd96 97AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
98 //
99 // Destructor
100 //
101
01239968 102 if(fCalDetGainUsed) delete fCalDetGainUsed;
4c865c34 103 if(fCalDetVdriftUsed) delete fCalDetVdriftUsed;
b3fcfd96 104 if(fCH2d) delete fCH2d;
105 if(fPH2d) delete fPH2d;
106 if(fPRF2d) delete fPRF2d;
107 if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
108 if(fNEvents) delete fNEvents;
109 if(fAbsoluteGain) delete fAbsoluteGain;
110 if(fPlots) delete fPlots;
111 if(fCalibObjects) delete fCalibObjects;
112
113}
00d203b6 114//___________________________________________________________________________________________________________________
b3fcfd96 115
116void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
117 //
118 // make calibration of the drift velocity
119 // Input parameters:
120 // file - the location of input file
121 // startRunNumber, endRunNumber - run validity period
122 // ocdbStorage - path to the OCDB storage
123 // - if empty - local storage 'pwd' uesed
124 if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
125 //
126 // 1. Initialization
127 //
008817a3 128 fVdriftValidated = kTRUE;
129 fT0Validated = kTRUE;
b3fcfd96 130 //
131 // 2. extraction of the information
132 //
133 if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
a5dcf618 134 //printf("Finish PH\n");
b3fcfd96 135 if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit();
136 //
137 // 3. Append QA plots
138 //
139 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
140 //
141 //
00d203b6 142 // 4. validate OCDB entries
b3fcfd96 143 //
00d203b6 144 if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) {
145 AliError("TRD vdrift OCDB parameters out of range!");
146 fVdriftValidated = kFALSE;
147 }
148 if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) {
149 AliError("TRD t0 OCDB parameters out of range!");
150 fT0Validated = kFALSE;
151 }
b3fcfd96 152 //
00d203b6 153 // 5. update of OCDB
154 //
155 //
156 if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage);
157 if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage);
158
b3fcfd96 159}
00d203b6 160//_________________________________________________________________________________________________________________
b3fcfd96 161
162void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
163 //
164 // make calibration of the drift velocity
165 // Input parameters:
166 // file - the location of input file
167 // startRunNumber, endRunNumber - run validity period
168 // ocdbStorage - path to the OCDB storage
169 // - if empty - local storage 'pwd' uesed
170 if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
171 //
172 // 1. Initialization
173 if(!ReadGainGlobal(file)) return;
174 //
175 //
176 // 2. extraction of the information
177 //
178 AnalyzeGain();
01239968 179 if(fCalDetGainUsed) CorrectFromDetGainUsed();
4c865c34 180 if(fCalDetVdriftUsed) CorrectFromDetVdriftUsed();
b3fcfd96 181 //
182 // 3. Append QA plots
183 //
184 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
185 //
186 //
00d203b6 187 // 4. validate OCDB entries
188 //
189 if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) {
190 AliError("TRD gain OCDB parameters out of range!");
191 return;
192 }
b3fcfd96 193 //
00d203b6 194 // 5. update of OCDB
b3fcfd96 195 //
00d203b6 196 //
197 if((!fCalDetVdriftUsed) || (fCalDetVdriftUsed && fVdriftValidated)) UpdateOCDBGain(startRunNumber,endRunNumber,ocdbStorage);
198
b3fcfd96 199
200}
00d203b6 201//________________________________________________________________________________________________________________
b3fcfd96 202
203void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
204 //
205 // make calibration of the drift velocity
206 // Input parameters:
207 // file - the location of input file
208 // startRunNumber, endRunNumber - run validity period
209 // ocdbStorage - path to the OCDB storage
210 // - if empty - local storage 'pwd' uesed
211 if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
212 //
213 // 1. Initialization
214 if(!ReadPRFGlobal(file)) return;
215 //
216 //
217 // 2. extraction of the information
218 //
219 AnalyzePRF();
220 //
221 // 3. Append QA plots
222 //
223 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
224 //
225 //
00d203b6 226 //
227 // 4. validate OCDB entries
228 //
229 if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) {
230 AliError("TRD prf OCDB parameters out of range!");
231 return;
232 }
233 //
234 // 5. update of OCDB
b3fcfd96 235 //
236 //
237 UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage);
238
a5dcf618 239}
240//________________________________________________________________________________________________________________
241
242void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
243 //
244 // make calibration of the chamber status
245 // Input parameters:
246 // startRunNumber, endRunNumber - run validity period
247 // ocdbStorage - path to the OCDB storage
248 // - if empty - local storage 'pwd' uesed
249 if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
250 //
251 //
252 // 2. extraction of the information
253 //
254 if(!AnalyzeChamberStatus()) return;
255 //
256 // 3. Append QA plots
257 //
258 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
259 //
260 //
261 //
262 // 4. validate OCDB entries
263 //
264 if(fSwitchOnValidation==kTRUE && ValidateChamberStatus()==kFALSE) {
265 AliError("TRD Chamber status OCDB parameters not ok!");
266 return;
267 }
268 //
269 // 5. update of OCDB
270 //
271 //
272 UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
273
b3fcfd96 274}
00d203b6 275//______________________________________________________________________________________________________
4c865c34 276Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
277 //
278 // read the calibration used during the reconstruction
279 //
280
281 if(ReadVdriftT0Global(fileName)) {
282
283 TString nameph = fPH2d->GetTitle();
ca7e6e64 284 fFirstRunVdriftUsed = GetFirstRun(nameph);
4c865c34 285 fVersionVdriftUsed = GetVersion(nameph);
286 fSubVersionVdriftUsed = GetSubVersion(nameph);
287
288 //printf("Found Version %d, Subversion %d for vdrift\n",fVersionVdriftUsed,fSubVersionVdriftUsed);
289
290 }
291
292 if(ReadGainGlobal(fileName)) {
293
294 TString namech = fCH2d->GetTitle();
295 fVersionGainUsed = GetVersion(namech);
296 fSubVersionGainUsed = GetSubVersion(namech);
297
298 //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed);
299
300 }
301
302 return kTRUE;
303
304}
00d203b6 305//___________________________________________________________________________________________________________________
b3fcfd96 306
307Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){
308 //
309 // read calibration entries from file
310 //
4c865c34 311 if(fCH2d) return kTRUE;
b3fcfd96 312 TFile fcalib(fileName);
01239968 313 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 314 if (array){
315 TH2I *ch2d = (TH2I *) array->FindObject("CH2d");
316 if(!ch2d) return kFALSE;
317 fCH2d = (TH2I*)ch2d->Clone();
318 //fNEvents = (TH1I *) array->FindObject("NEvents");
319 //fAbsoluteGain = (TH2F *) array->FindObject("AbsoluteGain");
320 }else{
321 TH2I *ch2d = (TH2I *) fcalib.Get("CH2d");
322 if(!ch2d) return kFALSE;
323 fCH2d = (TH2I*)ch2d->Clone();
324 //fNEvents = (TH1I *) fcalib.Get("NEvents");
325 //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain");
326 }
327 fCH2d->SetDirectory(0);
328 //printf("title of CH2d %s\n",fCH2d->GetTitle());
329
330 return kTRUE;
331
332}
00d203b6 333//_________________________________________________________________________________________________________________
b3fcfd96 334
335Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){
336 //
337 // read calibration entries from file
338 //
4c865c34 339 if(fPH2d) return kTRUE;
b3fcfd96 340 TFile fcalib(fileName);
01239968 341 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 342 if (array){
343 TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d");
344 if(!ph2d) return kFALSE;
345 fPH2d = (TProfile2D*)ph2d->Clone();
346 //fNEvents = (TH1I *) array->FindObject("NEvents");
347 }else{
348 TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d");
349 if(!ph2d) return kFALSE;
350 fPH2d = (TProfile2D*)ph2d->Clone();
351 //fNEvents = (TH1I *) fcalib.Get("NEvents");
352 }
353 fPH2d->SetDirectory(0);
354 //printf("title of PH2d %s\n",fPH2d->GetTitle());
355
356 return kTRUE;
357
358}
00d203b6 359//___________________________________________________________________________________________________________________
b3fcfd96 360
361Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){
362 //
363 // read calibration entries from file
364 //
4c865c34 365 if(fAliTRDCalibraVdriftLinearFit) return kTRUE;
b3fcfd96 366 TFile fcalib(fileName);
01239968 367 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 368 if (array){
369 fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit");
370 //fNEvents = (TH1I *) array->FindObject("NEvents");
371 }else{
372 fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit");
373 //fNEvents = (TH1I *) fcalib.Get("NEvents");
374 }
375 if(!fAliTRDCalibraVdriftLinearFit) {
376 //printf("No AliTRDCalibraVdriftLinearFit\n");
377 return kFALSE;
378 }
379 return kTRUE;
380
381}
00d203b6 382//_____________________________________________________________________________________________________________
b3fcfd96 383
384Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
385 //
386 // read calibration entries from file
387 //
4c865c34 388 if(fPRF2d) return kTRUE;
b3fcfd96 389 TFile fcalib(fileName);
01239968 390 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 391 if (array){
392 TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d");
393 if(!prf2d) return kFALSE;
394 fPRF2d = (TProfile2D*)prf2d->Clone();
395 //fNEvents = (TH1I *) array->FindObject("NEvents");
396 }else{
397 TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d");
398 if(!prf2d) return kFALSE;
399 fPRF2d = (TProfile2D*)prf2d->Clone();
400 //fNEvents = (TH1I *) fcalib.Get("NEvents");
401 }
402 fPRF2d->SetDirectory(0);
403 //printf("title of PRF2d %s\n",fPRF2d->GetTitle());
404
405 return kTRUE;
406
407}
00d203b6 408//__________________________________________________________________________________________________________
b3fcfd96 409
410Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
411 //
412 // Analyze gain - produce the calibration objects
413 //
414
415 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 416 calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 417 calibra->AnalyseCH(fCH2d);
418
419 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
420 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
421 Int_t nbfit = calibra->GetNumberFit();
422 Int_t nbE = calibra->GetNumberEnt();
423
424
425 Bool_t ok = kFALSE;
4c865c34 426 Bool_t meanother = kFALSE;
b3fcfd96 427 // enough statistics
428 if ((nbtg > 0) &&
429 (nbfit >= 0.5*nbE) && (nbE > 30)) {
430 // create the cal objects
4c865c34 431 if(!fCalDetGainUsed) {
432 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
433 meanother = kTRUE;
434 }
b3fcfd96 435 TObjArray object = calibra->GetVectorFit();
4c865c34 436 AliTRDCalDet *calDetGain = calibra->CreateDetObjectGain(&object,meanother);
b3fcfd96 437 TH1F *coefGain = calDetGain->MakeHisto1DAsFunctionOfDet();
438 // Put them in the array
439 fCalibObjects->AddAt(calDetGain,kGain);
440 fPlots->AddAt(coefGain,kGain);
441 //
442 ok = kTRUE;
443 }
444
445 calibra->ResetVectorFit();
446
447 return ok;
448
449}
00d203b6 450//_____________________________________________________________________________________________________
b3fcfd96 451Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
452 //
453 // Analyze VdriftT0 - produce the calibration objects
454 //
455
456 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 457 calibra->SetMinEntries(fMinStatsVdriftT0PH); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 458 calibra->AnalysePH(fPH2d);
459
460 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
461 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
462 Int_t nbfit = calibra->GetNumberFit();
463 Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
464 Int_t nbE = calibra->GetNumberEnt();
465
466 //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
467
468 Bool_t ok = kFALSE;
469 if ((nbtg > 0) &&
470 (nbfit >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
471 //printf("Pass the cut for VdriftT0\n");
472 // create the cal objects
01239968 473 calibra->RemoveOutliers(1,kFALSE);
474 calibra->PutMeanValueOtherVectorFit(1,kFALSE);
475 calibra->RemoveOutliers2(kFALSE);
476 calibra->PutMeanValueOtherVectorFit2(1,kFALSE);
477 //
b3fcfd96 478 TObjArray object = calibra->GetVectorFit();
479 AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object);
480 TH1F *coefVdriftPH = calDetVdrift->MakeHisto1DAsFunctionOfDet();
481 AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift);
482 TH1F *coefPadVdrift = calPadVdrift->MakeHisto1D();
483 object = calibra->GetVectorFit2();
484 AliTRDCalDet *calDetT0 = calibra->CreateDetObjectT0(&object);
485 TH1F *coefT0 = calDetT0->MakeHisto1DAsFunctionOfDet();
486 AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0);
487 TH1F *coefPadT0 = calPadT0->MakeHisto1D();
488 // Put them in the array
489 fCalibObjects->AddAt(calDetT0,kT0PHDet);
490 fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet);
491 fCalibObjects->AddAt(calPadT0,kT0PHPad);
492 fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad);
493 fPlots->AddAt(coefVdriftPH,kVdriftPHDet);
494 fPlots->AddAt(coefT0,kT0PHDet);
495 fPlots->AddAt(coefPadVdrift,kVdriftPHPad);
496 fPlots->AddAt(coefPadT0,kT0PHPad);
497 //
498 ok = kTRUE;
499 }
500 calibra->ResetVectorFit();
501
502 return ok;
503
504}
00d203b6 505//____________________________________________________________________________________________________________________
b3fcfd96 506Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
507 //
508 // Analyze vdrift linear fit - produce the calibration objects
509 //
510
a5dcf618 511 //printf("Analyse linear fit\n");
512
b3fcfd96 513 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 514 calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
a5dcf618 515 //printf("Fill PE Array\n");
01239968 516 fAliTRDCalibraVdriftLinearFit->FillPEArray();
a5dcf618 517 //printf("AliTRDCalibraFit\n");
b3fcfd96 518 calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
a5dcf618 519 //printf("After\n");
b3fcfd96 520
521 //Int_t nbtg = 540;
522 Int_t nbfit = calibra->GetNumberFit();
523 Int_t nbE = calibra->GetNumberEnt();
524
525
526 Bool_t ok = kFALSE;
527 // enough statistics
528 if ((nbfit >= 0.5*nbE) && (nbE > 30)) {
529 // create the cal objects
01239968 530 //calibra->RemoveOutliers(1,kTRUE);
531 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
532 //calibra->RemoveOutliers2(kTRUE);
533 calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
534 //
b3fcfd96 535 TObjArray object = calibra->GetVectorFit();
536 AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE);
537 TH1F *coefDriftLinear = calDetVdrift->MakeHisto1DAsFunctionOfDet();
538 object = calibra->GetVectorFit2();
539 AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
540 TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
541 // Put them in the array
542 fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
543 fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
544 fPlots->AddAt(coefDriftLinear,kVdriftLinear);
545 fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
546 //
547 ok = kTRUE;
548 }
549
550 calibra->ResetVectorFit();
551
552 return ok;
553
554}
00d203b6 555//________________________________________________________________________________________________________________
b3fcfd96 556
557Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
558 //
559 // Analyze PRF - produce the calibration objects
560 //
561
562 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 563 calibra->SetMinEntries(fMinStatsPRF); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 564 calibra->AnalysePRFMarianFit(fPRF2d);
565
566 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
567 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
568 Int_t nbfit = calibra->GetNumberFit();
569 Int_t nbE = calibra->GetNumberEnt();
570
571
572 Bool_t ok = kFALSE;
573 // enough statistics
574 if ((nbtg > 0) &&
575 (nbfit >= 0.95*nbE) && (nbE > 30)) {
576 // create the cal objects
577 TObjArray object = calibra->GetVectorFit();
578 AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object);
579 TH1F *coefPRF = calPadPRF->MakeHisto1D();
580 // Put them in the array
581 fCalibObjects->AddAt(calPadPRF,kPRF);
582 fPlots->AddAt(coefPRF,kPRF);
583 //
584 ok = kTRUE;
585 }
586
587 calibra->ResetVectorFit();
588
589 return ok;
590
591}
a5dcf618 592
593//_____________________________________________________________________________
594Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
595{
4c865c34 596 //
a5dcf618 597 // Produce AliTRDCalChamberStatus out of calibration results
4c865c34 598 //
b61b92a0 599
a5dcf618 600 // set up AliTRDCalChamberStatus
601 AliTRDCalChamberStatus *CalChamberStatus = new AliTRDCalChamberStatus();
602 for(Int_t det = 0; det < 540; det++) CalChamberStatus->SetStatus(det,1);
01239968 603
a5dcf618 604 // get calibration objects
605 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
606 AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear);
607
608 // Check
b61b92a0 609 if((!calDetGain) || (!calDetVDrift) || (!fCH2d)) return kFALSE;
a5dcf618 610
611 // Gain
612 Double_t gainmean = calDetGain->GetMean();
613 Double_t vdriftmean = calDetVDrift->GetMean();
614
615 Double_t gainrms = calDetGain->GetRMSRobust();
616 Double_t vdriftrms = calDetVDrift->GetRMSRobust();
617
618 //printf("Gain mean: %f, rms: %f\n",gainmean,gainrms);
619 //printf("Vdrift mean: %f, rms: %f\n",vdriftmean,vdriftrms);
4c865c34 620
a5dcf618 621 // Check
622 if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001)) return kFALSE;
01239968 623
a5dcf618 624 // mask chambers with empty gain entries
625 //Int_t counter = 0;
626 for (Int_t idet = 0; idet < 540; idet++) {
01239968 627
a5dcf618 628 // ch2d
629 TH1I *projch = (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e");
630 Double_t entries = projch->GetEntries();
4c865c34 631
a5dcf618 632 // gain
633 Double_t gain = calDetGain->GetValue(idet);
4c865c34 634
a5dcf618 635 // vdrift
636 Double_t vdrift = calDetVDrift->GetValue(idet);
4c865c34 637
4c865c34 638
a5dcf618 639 if(entries<=0.5 ||
640 TMath::Abs(gainmean-gain) > (15.0*gainrms) ||
641 TMath::Abs(vdriftmean-vdrift) > (15.0*vdriftrms)) {
642
643 //printf(" chamber det %03d masked \n",idet);
644 //printf(" gainmean %f and gain %f, gainrms %f \n",gainmean,gain,gainrms);
645 //printf(" vdriftmean %f and vdrift %f, vdriftrms %f \n",vdriftmean,vdrift,vdriftrms);
646 CalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kMasked);
647 //counter++;
648 }
4c865c34 649
a5dcf618 650 /*
651 // installed supermodules+1 -> abort
652 if(counter > (7+1)*30) {
653 printf("ERROR: more than one SM to be masked!! \n Abort...\n");
654 if(projch) delete projch;
655 return 0x0;
656 }
657 */
4c865c34 658
b61b92a0 659 delete projch;
660
a5dcf618 661 }
b3fcfd96 662
a5dcf618 663 // Security
664 for(Int_t sm=0; sm < 18; sm++) {
665 Int_t counter = 0;
666 for(Int_t det = 0; det < 30; det++){
667 Int_t detector = sm*30+det;
668 if(CalChamberStatus->IsMasked(detector)) counter++;
669 }
670 if(counter >= 10) {
671 for(Int_t det = 0; det < 30; det++){
672 Int_t detector = sm*30+det;
673 CalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kInstalled);
674 }
675 }
676 }
b3fcfd96 677
a5dcf618 678 fCalibObjects->AddAt(CalChamberStatus,kChamberStatus);
679 return kTRUE;
b3fcfd96 680
a5dcf618 681 }
b3fcfd96 682
b3fcfd96 683
a5dcf618 684 //________________________________________________________________________________________________
685 void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
686 //
687 // Correct from the gas gain used afterwards
688 //
689 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
690 if(!calDetGain) return;
b3fcfd96 691
a5dcf618 692 // Calculate mean
693 Double_t mean = 0.0;
694 Int_t nbdet = 0;
b3fcfd96 695
a5dcf618 696 for(Int_t det = 0; det < 540; det++) {
00d203b6 697
a5dcf618 698 Float_t gaininit = fCalDetGainUsed->GetValue(det);
699 Float_t gainout = calDetGain->GetValue(det);
00d203b6 700
00d203b6 701
a5dcf618 702 if(TMath::Abs(gainout-1.0) > 0.000001) {
703 mean += (gaininit*gainout);
704 nbdet++;
705 }
706 }
707 if(nbdet > 0) mean = mean/nbdet;
00d203b6 708
a5dcf618 709 for(Int_t det = 0; det < 540; det++) {
00d203b6 710
a5dcf618 711 Float_t gaininit = fCalDetGainUsed->GetValue(det);
712 Float_t gainout = calDetGain->GetValue(det);
713
ba1aa7a7 714 if(TMath::Abs(gainout-1.0) > 0.000001) {
715 Double_t newgain = gaininit*gainout;
716 if(newgain < 0.1) newgain = 0.1;
58e2b572 717 if(newgain > 1.9) newgain = 1.9;
ba1aa7a7 718 calDetGain->SetValue(det,newgain);
719 }
720 else {
721 Double_t newgain = mean;
722 if(newgain < 0.1) newgain = 0.1;
58e2b572 723 if(newgain > 1.9) newgain = 1.9;
ba1aa7a7 724 calDetGain->SetValue(det,newgain);
725 }
a5dcf618 726 }
727
728
729 }
730 //________________________________________________________________________________________________
731 void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
732 //
733 // Correct from the drift velocity
734 //
735
736 //printf("Correct for vdrift\n");
737
738 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
739 if(!calDetGain) return;
740
741 Int_t detVdrift = kVdriftPHDet;
742 if(fMethodSecond) detVdrift = kVdriftLinear;
743 AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
744 if(!calDetVdrift) return;
745
746 // Calculate mean
747
748 for(Int_t det = 0; det < 540; det++) {
749
750 Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
751 Float_t vdriftout = calDetVdrift->GetValue(det);
752
753 Float_t gain = calDetGain->GetValue(det);
754 if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
ba1aa7a7 755 if(gain < 0.1) gain = 0.1;
58e2b572 756 if(gain > 1.9) gain = 1.9;
a5dcf618 757 calDetGain->SetValue(det,gain);
758
759
760 }
761
762 }
763 //_________________________________________________________________________________________________________________
764 void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
765 //
766 // Update OCDB entry
767 //
768
769 AliCDBMetaData *metaData= new AliCDBMetaData();
770 metaData->SetObjectClassName("AliTRDCalDet");
771 metaData->SetResponsible("Raphaelle Bailhache");
772 metaData->SetBeamPeriod(1);
773
774 AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
775 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
776 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
777 if(calDet) gStorage->Put(calDet, id1, metaData);
778
779
780 }
781 //___________________________________________________________________________________________________________________
782 void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
783 //
784 // Update OCDB entry
785 //
786
787 Int_t detVdrift = kVdriftPHDet;
788
789 if(fMethodSecond) detVdrift = kVdriftLinear;
790
791 AliCDBMetaData *metaData= new AliCDBMetaData();
792 metaData->SetObjectClassName("AliTRDCalDet");
793 metaData->SetResponsible("Raphaelle Bailhache");
794 metaData->SetBeamPeriod(1);
795
796 AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
797 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
798 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
799 if(calDet) gStorage->Put(calDet, id1, metaData);
800
801 //
802
803 if(!fMethodSecond) {
804
805 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
806 metaDataPad->SetObjectClassName("AliTRDCalPad");
807 metaDataPad->SetResponsible("Raphaelle Bailhache");
808 metaDataPad->SetBeamPeriod(1);
809
810 AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
811 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
812 if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
813
814 }
815
816 }
817 //________________________________________________________________________________________________________________________
818 void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
819 //
820 // Update OCDB entry
821 //
822
823 AliCDBMetaData *metaData= new AliCDBMetaData();
824 metaData->SetObjectClassName("AliTRDCalDet");
825 metaData->SetResponsible("Raphaelle Bailhache");
826 metaData->SetBeamPeriod(1);
827
828 AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
829 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
830 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
831 if(calDet) gStorage->Put(calDet, id1, metaData);
832
833 //
834
835 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
836 metaDataPad->SetObjectClassName("AliTRDCalPad");
837 metaDataPad->SetResponsible("Raphaelle Bailhache");
838 metaDataPad->SetBeamPeriod(1);
839
840 AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
841 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
842 if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
843
844
845
846 }
847 //_________________________________________________________________________________________________________________
848 void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
849 //
850 // Update OCDB entry
851 //
852
853 AliCDBMetaData *metaData= new AliCDBMetaData();
854 metaData->SetObjectClassName("AliTRDCalPad");
855 metaData->SetResponsible("Raphaelle Bailhache");
856 metaData->SetBeamPeriod(1);
857
858 AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
859 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
860 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
861 if(calPad) gStorage->Put(calPad, id1, metaData);
862
863
864 }
865 //_________________________________________________________________________________________________________________
866 void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
867 //
868 // Update OCDB entry
869 //
870
871 AliCDBMetaData *metaData= new AliCDBMetaData();
872 metaData->SetObjectClassName("AliTRDCalChamberStatus");
873 metaData->SetResponsible("Raphaelle Bailhache");
874 metaData->SetBeamPeriod(1);
875
876 AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber);
877 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
878 AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
879 if(calChamberStatus) gStorage->Put(calChamberStatus, id1, metaData);
880
881
882 }
883 //__________________________________________________________________________________________________________________________
884 Bool_t AliTRDPreprocessorOffline::ValidateGain() const {
885 //
886 // Validate OCDB entry
887 //
888
889 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
890 if(calDet) {
891 Double_t mean = calDet->GetMean();
892 Double_t rms = calDet->GetRMSRobust();
893 if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
894 //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
895 else return kFALSE;
896 }
897 else return kFALSE;
898
899
900 }
901 //__________________________________________________________________________________________________________________________
902 Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
903 //
904 // Update OCDB entry
905 //
906
907 Int_t detVdrift = kVdriftPHDet;
908 Bool_t ok = kTRUE;
909
910 if(fMethodSecond) detVdrift = kVdriftLinear;
911
912 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
913 if(calDet) {
914 Double_t mean = calDet->GetMean();
915 Double_t rms = calDet->GetRMSRobust();
916 //printf("Vdrift::mean %f, rms %f\n",mean,rms);
917 if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE;
918 }
919 else return kFALSE;
920
921 if(!fMethodSecond) {
922 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
923 if(calPad) {
924 Double_t mean = calPad->GetMean();
925 Double_t rms = calPad->GetRMS();
926 //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
927 if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE;
928 }
929 else return kFALSE;
930 }
931
932 return ok;
933
934 }
935 //__________________________________________________________________________________________________________________________
936 Bool_t AliTRDPreprocessorOffline::ValidateT0(){
937 //
938 // Update OCDB entry
939 //
940
941 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
942 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
943 if(calDet && calPad) {
944 Double_t meandet = calDet->GetMean();
945 Double_t rmsdet = calDet->GetRMSRobust();
946 Double_t meanpad = calPad->GetMean();
947 //Double_t rmspad = calPad->GetRMS();
948 //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
949 if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
950 else return kFALSE;
951 }
952 else return kFALSE;
953
954 }
955 //__________________________________________________________________________________________________________________________
956 Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
957 //
958 // Update OCDB entry
959 //
960
961 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
962 if(calPad) {
963 Double_t meanpad = calPad->GetMean();
964 Double_t rmspad = calPad->GetRMS();
965 //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
966 if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
967 else return kFALSE;
968 }
969 else return kFALSE;
970
971
972 }
973 //__________________________________________________________________________________________________________________________
974Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus() const{
00d203b6 975 //
976 // Update OCDB entry
977 //
978
a5dcf618 979 AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
980 if(calChamberStatus) {
981 Int_t detectormasked = 0;
982 for(Int_t det = 0; det < 540; det++) {
983 if(calChamberStatus->IsMasked(det)) detectormasked++;
984 }
985 //printf("Number of chambers masked %d\n",detectormasked);
986 if(detectormasked > 29) return kFALSE;
987 else return kTRUE;
00d203b6 988 }
989 else return kFALSE;
990
b3fcfd96 991}
4c865c34 992//_____________________________________________________________________________
993Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
994{
995 //
996 // Get version from the title
997 //
998
999 // Some patterns
1000 const Char_t *version = "Ver";
1001 if(!strstr(name.Data(),version)) return -1;
1002
1003 for(Int_t ver = 0; ver < 999999999; ver++) {
1004
1005 TString vertry(version);
1006 vertry += ver;
1007 vertry += "Subver";
1008
1009 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1010
1011 if(strstr(name.Data(),vertry.Data())) return ver;
1012
1013 }
1014
1015 return -1;
1016
1017}
1018
1019//_____________________________________________________________________________
1020Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
1021{
1022 //
1023 // Get subversion from the title
1024 //
1025
1026 // Some patterns
1027 const Char_t *subversion = "Subver";
1028 if(!strstr(name.Data(),subversion)) return -1;
1029
1030 for(Int_t ver = 0; ver < 999999999; ver++) {
1031
1032 TString vertry(subversion);
1033 vertry += ver;
ca7e6e64 1034 vertry += "FirstRun";
1035
1036 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1037
1038 if(strstr(name.Data(),vertry.Data())) return ver;
1039
1040 }
1041
1042 return -1;
1043
1044}
1045
1046//_____________________________________________________________________________
1047Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const
1048{
1049 //
1050 // Get first run from the title
1051 //
1052
1053 // Some patterns
1054 const Char_t *firstrun = "FirstRun";
1055 if(!strstr(name.Data(),firstrun)) return -1;
1056
1057 for(Int_t ver = 0; ver < 999999999; ver++) {
1058
1059 TString vertry(firstrun);
1060 vertry += ver;
4c865c34 1061 vertry += "Nz";
1062
1063 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1064
1065 if(strstr(name.Data(),vertry.Data())) return ver;
1066
1067 }
1068
1069 return -1;
1070
1071}
01239968 1072