]> 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
test Id (Ivana)
[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;
717 calDetGain->SetValue(det,newgain);
718 }
719 else {
720 Double_t newgain = mean;
721 if(newgain < 0.1) newgain = 0.1;
722 calDetGain->SetValue(det,newgain);
723 }
a5dcf618 724 }
725
726
727 }
728 //________________________________________________________________________________________________
729 void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
730 //
731 // Correct from the drift velocity
732 //
733
734 //printf("Correct for vdrift\n");
735
736 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
737 if(!calDetGain) return;
738
739 Int_t detVdrift = kVdriftPHDet;
740 if(fMethodSecond) detVdrift = kVdriftLinear;
741 AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
742 if(!calDetVdrift) return;
743
744 // Calculate mean
745
746 for(Int_t det = 0; det < 540; det++) {
747
748 Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
749 Float_t vdriftout = calDetVdrift->GetValue(det);
750
751 Float_t gain = calDetGain->GetValue(det);
752 if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
ba1aa7a7 753 if(gain < 0.1) gain = 0.1;
a5dcf618 754 calDetGain->SetValue(det,gain);
755
756
757 }
758
759 }
760 //_________________________________________________________________________________________________________________
761 void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
762 //
763 // Update OCDB entry
764 //
765
766 AliCDBMetaData *metaData= new AliCDBMetaData();
767 metaData->SetObjectClassName("AliTRDCalDet");
768 metaData->SetResponsible("Raphaelle Bailhache");
769 metaData->SetBeamPeriod(1);
770
771 AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
772 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
773 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
774 if(calDet) gStorage->Put(calDet, id1, metaData);
775
776
777 }
778 //___________________________________________________________________________________________________________________
779 void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
780 //
781 // Update OCDB entry
782 //
783
784 Int_t detVdrift = kVdriftPHDet;
785
786 if(fMethodSecond) detVdrift = kVdriftLinear;
787
788 AliCDBMetaData *metaData= new AliCDBMetaData();
789 metaData->SetObjectClassName("AliTRDCalDet");
790 metaData->SetResponsible("Raphaelle Bailhache");
791 metaData->SetBeamPeriod(1);
792
793 AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
794 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
795 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
796 if(calDet) gStorage->Put(calDet, id1, metaData);
797
798 //
799
800 if(!fMethodSecond) {
801
802 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
803 metaDataPad->SetObjectClassName("AliTRDCalPad");
804 metaDataPad->SetResponsible("Raphaelle Bailhache");
805 metaDataPad->SetBeamPeriod(1);
806
807 AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
808 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
809 if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
810
811 }
812
813 }
814 //________________________________________________________________________________________________________________________
815 void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
816 //
817 // Update OCDB entry
818 //
819
820 AliCDBMetaData *metaData= new AliCDBMetaData();
821 metaData->SetObjectClassName("AliTRDCalDet");
822 metaData->SetResponsible("Raphaelle Bailhache");
823 metaData->SetBeamPeriod(1);
824
825 AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
826 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
827 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
828 if(calDet) gStorage->Put(calDet, id1, metaData);
829
830 //
831
832 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
833 metaDataPad->SetObjectClassName("AliTRDCalPad");
834 metaDataPad->SetResponsible("Raphaelle Bailhache");
835 metaDataPad->SetBeamPeriod(1);
836
837 AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
838 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
839 if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
840
841
842
843 }
844 //_________________________________________________________________________________________________________________
845 void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
846 //
847 // Update OCDB entry
848 //
849
850 AliCDBMetaData *metaData= new AliCDBMetaData();
851 metaData->SetObjectClassName("AliTRDCalPad");
852 metaData->SetResponsible("Raphaelle Bailhache");
853 metaData->SetBeamPeriod(1);
854
855 AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
856 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
857 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
858 if(calPad) gStorage->Put(calPad, id1, metaData);
859
860
861 }
862 //_________________________________________________________________________________________________________________
863 void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
864 //
865 // Update OCDB entry
866 //
867
868 AliCDBMetaData *metaData= new AliCDBMetaData();
869 metaData->SetObjectClassName("AliTRDCalChamberStatus");
870 metaData->SetResponsible("Raphaelle Bailhache");
871 metaData->SetBeamPeriod(1);
872
873 AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber);
874 AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
875 AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
876 if(calChamberStatus) gStorage->Put(calChamberStatus, id1, metaData);
877
878
879 }
880 //__________________________________________________________________________________________________________________________
881 Bool_t AliTRDPreprocessorOffline::ValidateGain() const {
882 //
883 // Validate OCDB entry
884 //
885
886 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
887 if(calDet) {
888 Double_t mean = calDet->GetMean();
889 Double_t rms = calDet->GetRMSRobust();
890 if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
891 //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
892 else return kFALSE;
893 }
894 else return kFALSE;
895
896
897 }
898 //__________________________________________________________________________________________________________________________
899 Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
900 //
901 // Update OCDB entry
902 //
903
904 Int_t detVdrift = kVdriftPHDet;
905 Bool_t ok = kTRUE;
906
907 if(fMethodSecond) detVdrift = kVdriftLinear;
908
909 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
910 if(calDet) {
911 Double_t mean = calDet->GetMean();
912 Double_t rms = calDet->GetRMSRobust();
913 //printf("Vdrift::mean %f, rms %f\n",mean,rms);
914 if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE;
915 }
916 else return kFALSE;
917
918 if(!fMethodSecond) {
919 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
920 if(calPad) {
921 Double_t mean = calPad->GetMean();
922 Double_t rms = calPad->GetRMS();
923 //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
924 if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE;
925 }
926 else return kFALSE;
927 }
928
929 return ok;
930
931 }
932 //__________________________________________________________________________________________________________________________
933 Bool_t AliTRDPreprocessorOffline::ValidateT0(){
934 //
935 // Update OCDB entry
936 //
937
938 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
939 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
940 if(calDet && calPad) {
941 Double_t meandet = calDet->GetMean();
942 Double_t rmsdet = calDet->GetRMSRobust();
943 Double_t meanpad = calPad->GetMean();
944 //Double_t rmspad = calPad->GetRMS();
945 //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
946 if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
947 else return kFALSE;
948 }
949 else return kFALSE;
950
951 }
952 //__________________________________________________________________________________________________________________________
953 Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
954 //
955 // Update OCDB entry
956 //
957
958 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
959 if(calPad) {
960 Double_t meanpad = calPad->GetMean();
961 Double_t rmspad = calPad->GetRMS();
962 //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
963 if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
964 else return kFALSE;
965 }
966 else return kFALSE;
967
968
969 }
970 //__________________________________________________________________________________________________________________________
971Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus() const{
00d203b6 972 //
973 // Update OCDB entry
974 //
975
a5dcf618 976 AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
977 if(calChamberStatus) {
978 Int_t detectormasked = 0;
979 for(Int_t det = 0; det < 540; det++) {
980 if(calChamberStatus->IsMasked(det)) detectormasked++;
981 }
982 //printf("Number of chambers masked %d\n",detectormasked);
983 if(detectormasked > 29) return kFALSE;
984 else return kTRUE;
00d203b6 985 }
986 else return kFALSE;
987
b3fcfd96 988}
4c865c34 989//_____________________________________________________________________________
990Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
991{
992 //
993 // Get version from the title
994 //
995
996 // Some patterns
997 const Char_t *version = "Ver";
998 if(!strstr(name.Data(),version)) return -1;
999
1000 for(Int_t ver = 0; ver < 999999999; ver++) {
1001
1002 TString vertry(version);
1003 vertry += ver;
1004 vertry += "Subver";
1005
1006 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1007
1008 if(strstr(name.Data(),vertry.Data())) return ver;
1009
1010 }
1011
1012 return -1;
1013
1014}
1015
1016//_____________________________________________________________________________
1017Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
1018{
1019 //
1020 // Get subversion from the title
1021 //
1022
1023 // Some patterns
1024 const Char_t *subversion = "Subver";
1025 if(!strstr(name.Data(),subversion)) return -1;
1026
1027 for(Int_t ver = 0; ver < 999999999; ver++) {
1028
1029 TString vertry(subversion);
1030 vertry += ver;
ca7e6e64 1031 vertry += "FirstRun";
1032
1033 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1034
1035 if(strstr(name.Data(),vertry.Data())) return ver;
1036
1037 }
1038
1039 return -1;
1040
1041}
1042
1043//_____________________________________________________________________________
1044Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const
1045{
1046 //
1047 // Get first run from the title
1048 //
1049
1050 // Some patterns
1051 const Char_t *firstrun = "FirstRun";
1052 if(!strstr(name.Data(),firstrun)) return -1;
1053
1054 for(Int_t ver = 0; ver < 999999999; ver++) {
1055
1056 TString vertry(firstrun);
1057 vertry += ver;
4c865c34 1058 vertry += "Nz";
1059
1060 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1061
1062 if(strstr(name.Data(),vertry.Data())) return ver;
1063
1064 }
1065
1066 return -1;
1067
1068}
01239968 1069