]> 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
Update of mergeMakeOCDB script: possibility to avoid parallel aliroot sessions +...
[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"
82b413fd 49#include "TMath.h"
83d0cc79 50#include "THnSparse.h"
b3fcfd96 51#include "TProfile2D.h"
52#include "AliTRDCalDet.h"
53#include "AliTRDCalPad.h"
54#include "AliCDBMetaData.h"
55#include "AliCDBId.h"
56#include "AliCDBManager.h"
57#include "AliCDBStorage.h"
58#include "AliTRDCalibraMode.h"
59#include "AliTRDCalibraFit.h"
60#include "AliTRDCalibraVdriftLinearFit.h"
a0bb5615 61#include "AliTRDCalibraExbAltFit.h"
b3fcfd96 62#include "AliTRDPreprocessorOffline.h"
81a5aeca 63#include "AliTRDCalChamberStatus.h"
83d0cc79 64#include "AliTRDCalibChamberStatus.h"
840ec79d 65#include "AliTRDCommonParam.h"
83d0cc79 66#include "AliCDBManager.h"
67#include "AliCDBEntry.h"
6951a056 68#include "AliTRDdEdxBaseUtils.h"
69#include "AliTRDdEdxCalibHistArray.h"
70#include "AliTRDdEdxCalibUtils.h"
b3fcfd96 71
b3fcfd96 72ClassImp(AliTRDPreprocessorOffline)
73
54f2ff1c 74 AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
01239968 75 TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"),
b3fcfd96 76 fMethodSecond(kTRUE),
01239968 77 fNameList("TRDCalib"),
78 fCalDetGainUsed(0x0),
4c865c34 79 fCalDetVdriftUsed(0x0),
840ec79d 80 fCalDetExBUsed(0x0),
b3fcfd96 81 fCH2d(0x0),
82 fPH2d(0x0),
83 fPRF2d(0x0),
83d0cc79 84 fSparse(0x0),
b3fcfd96 85 fAliTRDCalibraVdriftLinearFit(0x0),
a0bb5615 86 fAliTRDCalibraExbAltFit(0x0),
b3fcfd96 87 fNEvents(0x0),
88 fAbsoluteGain(0x0),
a0bb5615 89 fPlots(new TObjArray(kNumCalibObjs)),
90 fCalibObjects(new TObjArray(kNumCalibObjs)),
83d0cc79 91 fFirstRunGainUsed(0),
4c865c34 92 fVersionGainUsed(0),
93 fSubVersionGainUsed(0),
ca7e6e64 94 fFirstRunVdriftUsed(0),
4c865c34 95 fVersionVdriftUsed(0),
00d203b6 96 fSubVersionVdriftUsed(0),
83d0cc79 97 fFirstRunExBUsed(0),
98 fVersionExBUsed(0),
99 fSubVersionExBUsed(0),
100 fNoExBUsedInReco(kFALSE),
00d203b6 101 fSwitchOnValidation(kTRUE),
66c56ac7 102 fSwitchOnChamberStatus(kTRUE),
00d203b6 103 fVdriftValidated(kFALSE),
840ec79d 104 fExBValidated(kFALSE),
a2a4ec8e 105 fT0Validated(kFALSE),
106 fMinStatsVdriftT0PH(800*20),
107 fMinStatsVdriftLinear(800),
108 fMinStatsGain(800),
54f2ff1c 109 fMinStatsPRF(600),
83d0cc79 110 fMinStatsChamberStatus(20),
17aa2935 111 fMinSingleStatsChamberStatus(0.05),
54f2ff1c 112 fBackCorrectGain(kFALSE),
113 fBackCorrectVdrift(kTRUE),
114 fNotEnoughStatisticsForTheGain(kFALSE),
115 fNotEnoughStatisticsForTheVdriftLinear(kFALSE),
82b413fd 116 fStatusNeg(0),
83d0cc79 117 fStatusPos(0),
661c7be6 118 fBadCalibValidate(40),
119 fNoDataValidate(40),
83d0cc79 120 fRMSBadCalibratedGain(20.0),
121 fRMSBadCalibratedVdrift(20.0),
661c7be6 122 fRMSBadCalibratedExB(20.0),
d82bad1e 123 fMinTimeOffsetValidate(-1.6),
2a1a7b36 124 fRobustFitDriftVelocity(kTRUE),
661c7be6 125 fRobustFitExbAlt(kFALSE),
126 fAlternativeVdrfitFit(kFALSE),
595cfc12 127 fAlternativeExbAltFit(kFALSE),
532be2d4 128 fMinNbOfPointVdriftFit(11),
595cfc12 129 fMethodeGain(0),
130 fOutliersFitChargeLow(0.03),
131 fOutliersFitChargeHigh(0.7),
9a8b0e85 132 fBeginFitCharge(3.5),
4f3bd513 133 fT0Shift0(0.124797),
134 fT0Shift1(0.267451),
687aa844 135 fPHQon(kTRUE),
136 fDebugPHQon(kFALSE)
b3fcfd96 137{
138 //
139 // default constructor
140 //
83d0cc79 141
142 memset(fBadCalib, 0, sizeof(Int_t) * 18);
143 memset(fNoData, 0, sizeof(Int_t) * 18);
b3fcfd96 144}
00d203b6 145//_________________________________________________________________________________________________________________
b3fcfd96 146AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
147 //
148 // Destructor
149 //
150
01239968 151 if(fCalDetGainUsed) delete fCalDetGainUsed;
4c865c34 152 if(fCalDetVdriftUsed) delete fCalDetVdriftUsed;
840ec79d 153 if(fCalDetExBUsed) delete fCalDetExBUsed;
b3fcfd96 154 if(fCH2d) delete fCH2d;
155 if(fPH2d) delete fPH2d;
156 if(fPRF2d) delete fPRF2d;
83d0cc79 157 if(fSparse) delete fSparse;
9a8b0e85 158
159 if(IsPHQon()){
6951a056 160 AliTRDdEdxCalibUtils::DeleteHistArray();
161 AliTRDdEdxCalibUtils::DeleteObjArray();
9a8b0e85 162 }
163
b3fcfd96 164 if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
a0bb5615 165 if(fAliTRDCalibraExbAltFit) delete fAliTRDCalibraExbAltFit;
b3fcfd96 166 if(fNEvents) delete fNEvents;
167 if(fAbsoluteGain) delete fAbsoluteGain;
168 if(fPlots) delete fPlots;
169 if(fCalibObjects) delete fCalibObjects;
170
83d0cc79 171}
172//___________________________________________________________________________________
a9f9c69b 173void AliTRDPreprocessorOffline::Process(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* ocdbStorage)
83d0cc79 174{
175 //
176 // Process to the gain, vdrift, timeoffset, exb and chamber status calibration
177 //
178
179 if(SetCalDetGain(startRunNumber,fVersionGainUsed,fSubVersionGainUsed) && SetCalDetVdriftExB(startRunNumber,fVersionVdriftUsed,fSubVersionVdriftUsed,fVersionExBUsed,fSubVersionExBUsed)) {
180
181 CalibVdriftT0(file,startRunNumber,endRunNumber,ocdbStorage);
182 CalibGain(file,startRunNumber,endRunNumber,ocdbStorage);
66c56ac7 183 if(fSwitchOnChamberStatus) CalibChamberStatus(file,startRunNumber,endRunNumber,ocdbStorage);
f29cf84c 184 CalibExbAlt(file,startRunNumber,endRunNumber,ocdbStorage);
e2a1c98b 185
83d0cc79 186 }
e2a1c98b 187
9a8b0e85 188 if(IsPHQon()){
189 printf("\n AliTRDPreprocessorOffline PHQ on!!\n\n");
6951a056 190 AliTRDdEdxBaseUtils::PrintControl();
9a8b0e85 191 CalibPHQ(file, startRunNumber, endRunNumber, ocdbStorage);
192 }
193 else{
194 printf("\n AliTRDPreprocessorOffline PHQ off!!\n\n");
195 }
196
83d0cc79 197 PrintStatus();
198
b3fcfd96 199}
00d203b6 200//___________________________________________________________________________________________________________________
b3fcfd96 201
a9f9c69b 202void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* ocdbStorage){
b3fcfd96 203 //
204 // make calibration of the drift velocity
205 // Input parameters:
206 // file - the location of input file
207 // startRunNumber, endRunNumber - run validity period
a9f9c69b 208 // ocdbStorage - OCDB storage
b3fcfd96 209 // - if empty - local storage 'pwd' uesed
a9f9c69b 210 if (ocdbStorage==0x0) {
211 TString localStorage = "local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
212 ocdbStorage=AliCDBManager::Instance()->GetStorage(localStorage.Data());
213 }
b3fcfd96 214 //
215 // 1. Initialization
216 //
008817a3 217 fVdriftValidated = kTRUE;
218 fT0Validated = kTRUE;
840ec79d 219 fExBValidated = kTRUE;
54f2ff1c 220 fNotEnoughStatisticsForTheVdriftLinear = kFALSE;
b3fcfd96 221 //
222 // 2. extraction of the information
223 //
840ec79d 224 if(ReadVdriftLinearFitGlobal(file) && fCalDetVdriftUsed && fCalDetExBUsed) AnalyzeVdriftLinearFit();
54f2ff1c 225 if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
b3fcfd96 226 //
227 // 3. Append QA plots
228 //
229 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
230 //
231 //
00d203b6 232 // 4. validate OCDB entries
b3fcfd96 233 //
00d203b6 234 if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) {
82b413fd 235 //AliError("TRD vdrift OCDB parameters out of range!");
00d203b6 236 fVdriftValidated = kFALSE;
237 }
238 if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) {
82b413fd 239 //AliError("TRD t0 OCDB parameters out of range!");
00d203b6 240 fT0Validated = kFALSE;
241 }
840ec79d 242 if(fSwitchOnValidation==kTRUE && ValidateExB()==kFALSE) {
243 //AliError("TRD t0 OCDB parameters out of range!");
244 fExBValidated = kFALSE;
245 }
b3fcfd96 246 //
00d203b6 247 // 5. update of OCDB
248 //
249 //
250 if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage);
251 if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage);
840ec79d 252 if(fExBValidated) UpdateOCDBExB(startRunNumber,endRunNumber,ocdbStorage);
00d203b6 253
b3fcfd96 254}
a0bb5615 255//___________________________________________________________________________________________________________________
256
a9f9c69b 257void AliTRDPreprocessorOffline::CalibExbAlt(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* ocdbStorage){
a0bb5615 258 //
259 // make calibration of the drift velocity
260 // Input parameters:
261 // file - the location of input file
262 // startRunNumber, endRunNumber - run validity period
a9f9c69b 263 // ocdbStorage - OCDB storage
a0bb5615 264 // - if empty - local storage 'pwd' uesed
a9f9c69b 265 if (ocdbStorage==0x0) {
266 TString localStorage = "local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
267 ocdbStorage=AliCDBManager::Instance()->GetStorage(localStorage.Data());
268 }
a0bb5615 269 //
270 // 1. Initialization
271 //
272
273 //
274 // 2. extraction of the information
275 //
276 if(ReadExbAltFitGlobal(file)) AnalyzeExbAltFit();
277 //
278 // 3. Append QA plots
279 //
280 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
281 //
282 //
283 // 4. validate OCDB entries
284 //
285 //
286 // 5. update of OCDB
287 //
288 //
289 UpdateOCDBExBAlt(startRunNumber,endRunNumber,ocdbStorage);
290
291}
292
00d203b6 293//_________________________________________________________________________________________________________________
b3fcfd96 294
a9f9c69b 295void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* ocdbStorage){
b3fcfd96 296 //
297 // make calibration of the drift velocity
298 // Input parameters:
299 // file - the location of input file
300 // startRunNumber, endRunNumber - run validity period
a9f9c69b 301 // ocdbStorage - OCDB storage
b3fcfd96 302 // - if empty - local storage 'pwd' uesed
a9f9c69b 303 if (ocdbStorage==0x0) {
304 TString localStorage = "local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
305 ocdbStorage=AliCDBManager::Instance()->GetStorage(localStorage.Data());
306 }
b3fcfd96 307 //
54f2ff1c 308 fNotEnoughStatisticsForTheGain = kFALSE;
309 //
b3fcfd96 310 // 1. Initialization
311 if(!ReadGainGlobal(file)) return;
312 //
313 //
314 // 2. extraction of the information
315 //
316 AnalyzeGain();
54f2ff1c 317 if(fBackCorrectGain) CorrectFromDetGainUsed();
a0bb5615 318 //if(fBackCorrectVdrift) CorrectFromDetVdriftUsed();
b3fcfd96 319 //
320 // 3. Append QA plots
321 //
322 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
323 //
324 //
00d203b6 325 // 4. validate OCDB entries
326 //
327 if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) {
82b413fd 328 //AliError("TRD gain OCDB parameters out of range!");
00d203b6 329 return;
330 }
b3fcfd96 331 //
00d203b6 332 // 5. update of OCDB
b3fcfd96 333 //
00d203b6 334 //
335 if((!fCalDetVdriftUsed) || (fCalDetVdriftUsed && fVdriftValidated)) UpdateOCDBGain(startRunNumber,endRunNumber,ocdbStorage);
336
b3fcfd96 337
338}
00d203b6 339//________________________________________________________________________________________________________________
b3fcfd96 340
a9f9c69b 341void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* ocdbStorage){
b3fcfd96 342 //
343 // make calibration of the drift velocity
344 // Input parameters:
345 // file - the location of input file
346 // startRunNumber, endRunNumber - run validity period
a9f9c69b 347 // ocdbStorage - OCDB storage
b3fcfd96 348 // - if empty - local storage 'pwd' uesed
a9f9c69b 349 if (ocdbStorage==0x0) {
350 TString localStorage = "local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
351 ocdbStorage=AliCDBManager::Instance()->GetStorage(localStorage.Data());
352 }
b3fcfd96 353 //
354 // 1. Initialization
355 if(!ReadPRFGlobal(file)) return;
356 //
357 //
358 // 2. extraction of the information
359 //
360 AnalyzePRF();
361 //
362 // 3. Append QA plots
363 //
364 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
365 //
366 //
00d203b6 367 //
368 // 4. validate OCDB entries
369 //
370 if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) {
82b413fd 371 //AliError("TRD prf OCDB parameters out of range!");
00d203b6 372 return;
373 }
374 //
375 // 5. update of OCDB
b3fcfd96 376 //
377 //
378 UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage);
379
a5dcf618 380}
e2a1c98b 381//________________________________________________________________________________________________________________
a9f9c69b 382void AliTRDPreprocessorOffline::CalibPHQ(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* ocdbStorage)
e2a1c98b 383{
384 //
385 // make calibration of puls height Q
386 // Input parameters:
387 // startRunNumber, endRunNumber - run validity period
a9f9c69b 388 // ocdbStorage - OCDB storage
e2a1c98b 389 // - if empty - local storage 'pwd' uesed
390 //
391
a9f9c69b 392 if (ocdbStorage==0x0) {
393 TString localStorage = "local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
394 ocdbStorage=AliCDBManager::Instance()->GetStorage(localStorage.Data());
395 }
e2a1c98b 396 //printf("test %s\n", ocdbStorage.Data());
397
398 if(!ReadPHQGlobal(file)) return;
399
400 if(!AnalyzePHQ(startRunNumber)) return;
401
402 UpdateOCDBPHQ(startRunNumber,endRunNumber,ocdbStorage);
403}
404
a5dcf618 405//________________________________________________________________________________________________________________
406
a9f9c69b 407void AliTRDPreprocessorOffline::CalibChamberStatus(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* ocdbStorage){
a5dcf618 408 //
409 // make calibration of the chamber status
410 // Input parameters:
411 // startRunNumber, endRunNumber - run validity period
a9f9c69b 412 // ocdbStorage - OCDB storage
a5dcf618 413 // - if empty - local storage 'pwd' uesed
a9f9c69b 414 if (ocdbStorage==0x0) {
415 TString localStorage = "local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
416 ocdbStorage=AliCDBManager::Instance()->GetStorage(localStorage.Data());
417 }
a5dcf618 418 //
419 //
83d0cc79 420 // 1. Initialization
421 if(!ReadStatusGlobal(file)) return;
422 //
423 //
424 //
a5dcf618 425 // 2. extraction of the information
426 //
427 if(!AnalyzeChamberStatus()) return;
428 //
429 // 3. Append QA plots
430 //
431 //MakeDefaultPlots(fVdriftArray,fVdriftArray);
432 //
433 //
434 //
435 // 4. validate OCDB entries
436 //
7954133b 437 //printf("Enough stats for vdrift? %d\n",(Int_t)fNotEnoughStatisticsForTheVdriftLinear);
438 //printf("Enough stats for gain? %d\n",(Int_t)fNotEnoughStatisticsForTheGain);
439 if((!fNotEnoughStatisticsForTheVdriftLinear) && (!fNotEnoughStatisticsForTheGain)) {
440 if(fSwitchOnValidation==kTRUE && ValidateChamberStatus()==kFALSE) {
441 //AliError("TRD Chamber status OCDB parameters not ok!");
442 return;
443 }
444 //
445 // 5. update of OCDB
446 //
447 //
448 UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
a5dcf618 449 }
a5dcf618 450
b3fcfd96 451}
00d203b6 452//______________________________________________________________________________________________________
4c865c34 453Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
454 //
455 // read the calibration used during the reconstruction
456 //
457
458 if(ReadVdriftT0Global(fileName)) {
459
460 TString nameph = fPH2d->GetTitle();
ca7e6e64 461 fFirstRunVdriftUsed = GetFirstRun(nameph);
4c865c34 462 fVersionVdriftUsed = GetVersion(nameph);
463 fSubVersionVdriftUsed = GetSubVersion(nameph);
464
465 //printf("Found Version %d, Subversion %d for vdrift\n",fVersionVdriftUsed,fSubVersionVdriftUsed);
466
467 }
468
469 if(ReadGainGlobal(fileName)) {
470
471 TString namech = fCH2d->GetTitle();
83d0cc79 472 fFirstRunGainUsed = GetFirstRun(namech);
4c865c34 473 fVersionGainUsed = GetVersion(namech);
474 fSubVersionGainUsed = GetSubVersion(namech);
475
476 //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed);
477
478 }
83d0cc79 479
480 if(ReadVdriftLinearFitGlobal(fileName)) {
481
482 TString namelinear = fAliTRDCalibraVdriftLinearFit->GetNameCalibUsed();
483 fFirstRunExBUsed = GetFirstRun(namelinear);
484 fVersionExBUsed = GetVersion(namelinear);
485 fSubVersionExBUsed = GetSubVersion(namelinear);
486
487 //printf("Found Version %d, Subversion %d, run %d for ExB\n",fVersionExBUsed,fSubVersionExBUsed,fFirstRunExBUsed);
488
489 }
4c865c34 490
82b413fd 491 if(fVersionVdriftUsed == 0) fStatusPos = fStatusPos |kVdriftErrorOld;
492 if(fVersionGainUsed == 0) fStatusPos = fStatusPos | kGainErrorOld;
e2a1c98b 493
4c865c34 494 return kTRUE;
495
496}
00d203b6 497//___________________________________________________________________________________________________________________
b3fcfd96 498
83d0cc79 499Bool_t AliTRDPreprocessorOffline::ReadStatusGlobal(const Char_t* fileName){
500 //
501 // read calibration entries from file
502 //
503 if(fSparse) return kTRUE;
504 TFile fcalib(fileName);
505 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
506 if (array){
507 fSparse = (THnSparseI *) array->FindObject("NumberOfEntries");
508 if(!fSparse) return kFALSE;
509 }
510 else
511 return kFALSE;
512
513 return kTRUE;
514
515}
516//___________________________________________________________________________________________________________________
517
e2a1c98b 518Bool_t AliTRDPreprocessorOffline::ReadPHQGlobal(const Char_t* fileName)
519{
520 //
521 // read calibration entries from file
522 //
523
6951a056 524 return AliTRDdEdxCalibUtils::ReadHistArray(fileName, fNameList);
e2a1c98b 525}
526
527//___________________________________________________________________________________________________________________
528
b3fcfd96 529Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){
530 //
531 // read calibration entries from file
532 //
4c865c34 533 if(fCH2d) return kTRUE;
b3fcfd96 534 TFile fcalib(fileName);
01239968 535 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 536 if (array){
537 TH2I *ch2d = (TH2I *) array->FindObject("CH2d");
538 if(!ch2d) return kFALSE;
539 fCH2d = (TH2I*)ch2d->Clone();
540 //fNEvents = (TH1I *) array->FindObject("NEvents");
541 //fAbsoluteGain = (TH2F *) array->FindObject("AbsoluteGain");
177f532f 542 delete array;
b3fcfd96 543 }else{
544 TH2I *ch2d = (TH2I *) fcalib.Get("CH2d");
545 if(!ch2d) return kFALSE;
546 fCH2d = (TH2I*)ch2d->Clone();
547 //fNEvents = (TH1I *) fcalib.Get("NEvents");
548 //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain");
549 }
550 fCH2d->SetDirectory(0);
551 //printf("title of CH2d %s\n",fCH2d->GetTitle());
552
553 return kTRUE;
554
555}
00d203b6 556//_________________________________________________________________________________________________________________
b3fcfd96 557
558Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){
559 //
560 // read calibration entries from file
561 //
4c865c34 562 if(fPH2d) return kTRUE;
b3fcfd96 563 TFile fcalib(fileName);
01239968 564 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 565 if (array){
566 TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d");
567 if(!ph2d) return kFALSE;
568 fPH2d = (TProfile2D*)ph2d->Clone();
569 //fNEvents = (TH1I *) array->FindObject("NEvents");
177f532f 570 delete array;
b3fcfd96 571 }else{
572 TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d");
573 if(!ph2d) return kFALSE;
574 fPH2d = (TProfile2D*)ph2d->Clone();
575 //fNEvents = (TH1I *) fcalib.Get("NEvents");
576 }
577 fPH2d->SetDirectory(0);
578 //printf("title of PH2d %s\n",fPH2d->GetTitle());
579
580 return kTRUE;
581
582}
00d203b6 583//___________________________________________________________________________________________________________________
b3fcfd96 584
585Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){
586 //
587 // read calibration entries from file
588 //
4c865c34 589 if(fAliTRDCalibraVdriftLinearFit) return kTRUE;
b3fcfd96 590 TFile fcalib(fileName);
01239968 591 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 592 if (array){
593 fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit");
594 //fNEvents = (TH1I *) array->FindObject("NEvents");
177f532f 595 delete array;
b3fcfd96 596 }else{
597 fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit");
598 //fNEvents = (TH1I *) fcalib.Get("NEvents");
599 }
600 if(!fAliTRDCalibraVdriftLinearFit) {
601 //printf("No AliTRDCalibraVdriftLinearFit\n");
602 return kFALSE;
603 }
604 return kTRUE;
605
a0bb5615 606}
607//_____________________________________________________________________________________________________________
608Bool_t AliTRDPreprocessorOffline::ReadExbAltFitGlobal(const Char_t* fileName){
609 //
610 // read calibration entries from file
611 //
612 if(fAliTRDCalibraExbAltFit) return kTRUE;
613 TFile fcalib(fileName);
614 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
615 if (array){
616 fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) array->FindObject("AliTRDCalibraExbAltFit");
617 //fNEvents = (TH1I *) array->FindObject("NEvents");
177f532f 618 delete array;
a0bb5615 619 }else{
620 fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) fcalib.Get("AliTRDCalibraExbAltFit");
621 //fNEvents = (TH1I *) fcalib.Get("NEvents");
622 }
623 if(!fAliTRDCalibraExbAltFit) {
624 //printf("No AliTRDCalibraExbAltFit\n");
625 return kFALSE;
626 }
627 return kTRUE;
628
b3fcfd96 629}
00d203b6 630//_____________________________________________________________________________________________________________
b3fcfd96 631
632Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
633 //
634 // read calibration entries from file
635 //
4c865c34 636 if(fPRF2d) return kTRUE;
b3fcfd96 637 TFile fcalib(fileName);
01239968 638 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 639 if (array){
640 TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d");
641 if(!prf2d) return kFALSE;
642 fPRF2d = (TProfile2D*)prf2d->Clone();
643 //fNEvents = (TH1I *) array->FindObject("NEvents");
644 }else{
645 TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d");
646 if(!prf2d) return kFALSE;
647 fPRF2d = (TProfile2D*)prf2d->Clone();
648 //fNEvents = (TH1I *) fcalib.Get("NEvents");
649 }
650 fPRF2d->SetDirectory(0);
651 //printf("title of PRF2d %s\n",fPRF2d->GetTitle());
652
653 return kTRUE;
654
655}
00d203b6 656//__________________________________________________________________________________________________________
b3fcfd96 657
658Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
659 //
660 // Analyze gain - produce the calibration objects
661 //
662
663 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
595cfc12 664 calibra->ChooseMethod(fMethodeGain);
665 calibra->SetBeginFitCharge(fBeginFitCharge);
666 calibra->SetFitOutliersChargeLow(fOutliersFitChargeLow);
667 calibra->SetFitOutliersChargeHigh(fOutliersFitChargeHigh);
a2a4ec8e 668 calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 669 calibra->AnalyseCH(fCH2d);
670
671 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
672 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
673 Int_t nbfit = calibra->GetNumberFit();
674 Int_t nbE = calibra->GetNumberEnt();
675
676
677 Bool_t ok = kFALSE;
4c865c34 678 Bool_t meanother = kFALSE;
b3fcfd96 679 // enough statistics
680 if ((nbtg > 0) &&
681 (nbfit >= 0.5*nbE) && (nbE > 30)) {
682 // create the cal objects
54f2ff1c 683 if(!fBackCorrectGain) {
4c865c34 684 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
685 meanother = kTRUE;
686 }
b3fcfd96 687 TObjArray object = calibra->GetVectorFit();
4c865c34 688 AliTRDCalDet *calDetGain = calibra->CreateDetObjectGain(&object,meanother);
b3fcfd96 689 TH1F *coefGain = calDetGain->MakeHisto1DAsFunctionOfDet();
690 // Put them in the array
691 fCalibObjects->AddAt(calDetGain,kGain);
692 fPlots->AddAt(coefGain,kGain);
693 //
694 ok = kTRUE;
695 }
54f2ff1c 696 else {
697 fNotEnoughStatisticsForTheGain = kTRUE;
dee5f636 698 Int_t minStatsGain = fMinStatsGain*30;
699 calibra->SetMinEntries(minStatsGain); // Because we do it for all, we increase this
54f2ff1c 700 Double_t gainoverallnotnormalized = calibra->AnalyseCHAllTogether(fCH2d);
701 if(fCalDetGainUsed && (gainoverallnotnormalized > 0.0)) {
702 AliTRDCalDet *calDetGain = new AliTRDCalDet(*fCalDetGainUsed);
703 Double_t oldmean = fCalDetGainUsed->CalcMean(kFALSE);
704 //printf("oldmean %f\n",oldmean);
705 if(oldmean > 0.0) {
706 Double_t scalefactor = calibra->GetScaleFactorGain();
707 //printf("Correction factor %f\n",gainoverallnotnormalized*scalefactor);
708 calDetGain->Multiply(gainoverallnotnormalized*scalefactor/oldmean);
709 //printf("newmean %f\n",calDetGain->CalcMean(kFALSE));
710 TH1F *coefGain = calDetGain->MakeHisto1DAsFunctionOfDet();
711 fCalibObjects->AddAt(calDetGain,kGain);
712 fPlots->AddAt(coefGain,kGain);
713 //
714 ok = kTRUE;
82b413fd 715 fStatusNeg = fStatusNeg | kGainNotEnoughStatsButFill;
54f2ff1c 716 }
717 else {
82b413fd 718 fStatusPos = fStatusPos | kGainErrorOld;
54f2ff1c 719 }
720 }
721 else {
82b413fd 722 if(gainoverallnotnormalized <= 0.0) fStatusNeg = fStatusNeg | kGainNotEnoughStatsNotFill;
723 if(!fCalDetGainUsed) fStatusPos = fStatusPos | kGainErrorOld;
54f2ff1c 724 }
725 }
b3fcfd96 726
727 calibra->ResetVectorFit();
728
729 return ok;
730
731}
00d203b6 732//_____________________________________________________________________________________________________
b3fcfd96 733Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
734 //
735 // Analyze VdriftT0 - produce the calibration objects
736 //
737
738 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
4f3bd513 739 calibra->SetT0Shift0(fT0Shift0);
740 calibra->SetT0Shift1(fT0Shift1);
a2a4ec8e 741 calibra->SetMinEntries(fMinStatsVdriftT0PH); // If there is less than 1000 entries in the histo: no fit
4f3bd513 742 calibra->AnalysePH(fPH2d);
743 //calibra->SetDebugLevel(2);
b3fcfd96 744
745 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
746 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
747 Int_t nbfit = calibra->GetNumberFit();
748 Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
749 Int_t nbE = calibra->GetNumberEnt();
750
751 //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
752
753 Bool_t ok = kFALSE;
754 if ((nbtg > 0) &&
755 (nbfit >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
4f3bd513 756 //printf("nbtg %d, nbfit %d, nbE %d, nbfitSucess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
b3fcfd96 757 //printf("Pass the cut for VdriftT0\n");
758 // create the cal objects
01239968 759 calibra->RemoveOutliers(1,kFALSE);
760 calibra->PutMeanValueOtherVectorFit(1,kFALSE);
761 calibra->RemoveOutliers2(kFALSE);
762 calibra->PutMeanValueOtherVectorFit2(1,kFALSE);
763 //
b3fcfd96 764 TObjArray object = calibra->GetVectorFit();
765 AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object);
766 TH1F *coefVdriftPH = calDetVdrift->MakeHisto1DAsFunctionOfDet();
767 AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift);
768 TH1F *coefPadVdrift = calPadVdrift->MakeHisto1D();
769 object = calibra->GetVectorFit2();
770 AliTRDCalDet *calDetT0 = calibra->CreateDetObjectT0(&object);
771 TH1F *coefT0 = calDetT0->MakeHisto1DAsFunctionOfDet();
772 AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0);
773 TH1F *coefPadT0 = calPadT0->MakeHisto1D();
774 // Put them in the array
775 fCalibObjects->AddAt(calDetT0,kT0PHDet);
776 fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet);
777 fCalibObjects->AddAt(calPadT0,kT0PHPad);
778 fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad);
779 fPlots->AddAt(coefVdriftPH,kVdriftPHDet);
780 fPlots->AddAt(coefT0,kT0PHDet);
781 fPlots->AddAt(coefPadVdrift,kVdriftPHPad);
782 fPlots->AddAt(coefPadT0,kT0PHPad);
783 //
784 ok = kTRUE;
785 }
54f2ff1c 786 else {
840ec79d 787 //printf("Not enough stats timeoffset\n");
82b413fd 788 fStatusNeg = fStatusNeg | kTimeOffsetNotEnoughStatsNotFill;
54f2ff1c 789 }
b3fcfd96 790 calibra->ResetVectorFit();
791
792 return ok;
793
794}
00d203b6 795//____________________________________________________________________________________________________________________
b3fcfd96 796Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
797 //
798 // Analyze vdrift linear fit - produce the calibration objects
799 //
800
a5dcf618 801 //printf("Analyse linear fit\n");
802
f558cb62 803
b3fcfd96 804 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
840ec79d 805 calibra->SetCalDetVdriftExB(fCalDetVdriftUsed,fCalDetExBUsed);
a2a4ec8e 806 calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
4f3bd513 807 //printf("The mean stat is by %d for VdriftLinear\n",fMinStatsVdriftLinear);
67abca5c 808 //fAliTRDCalibraVdriftLinearFit->SetSeeDetector(0);
809 //fAliTRDCalibraVdriftLinearFit->SetDebugLevel(1);
a5dcf618 810 //printf("Fill PE Array\n");
2a1a7b36 811 fAliTRDCalibraVdriftLinearFit->SetRobustFit(fRobustFitDriftVelocity);
532be2d4 812 fAliTRDCalibraVdriftLinearFit->SetMinNumberOfPointsForFit(fMinNbOfPointVdriftFit);
661c7be6 813 if(!fAlternativeVdrfitFit)
814 fAliTRDCalibraVdriftLinearFit->FillPEArray();
815 else
816 fAliTRDCalibraVdriftLinearFit->FillPEArray2();
a5dcf618 817 //printf("AliTRDCalibraFit\n");
b3fcfd96 818 calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
a5dcf618 819 //printf("After\n");
b3fcfd96 820
821 //Int_t nbtg = 540;
822 Int_t nbfit = calibra->GetNumberFit();
823 Int_t nbE = calibra->GetNumberEnt();
824
825
826 Bool_t ok = kFALSE;
827 // enough statistics
828 if ((nbfit >= 0.5*nbE) && (nbE > 30)) {
829 // create the cal objects
01239968 830 //calibra->RemoveOutliers(1,kTRUE);
831 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
832 //calibra->RemoveOutliers2(kTRUE);
833 calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
834 //
b3fcfd96 835 TObjArray object = calibra->GetVectorFit();
836 AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE);
837 TH1F *coefDriftLinear = calDetVdrift->MakeHisto1DAsFunctionOfDet();
838 object = calibra->GetVectorFit2();
839 AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
840 TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
eec29d56 841 //if(!calDetLorentz) printf("No lorentz created\n");
b3fcfd96 842 // Put them in the array
843 fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
844 fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
845 fPlots->AddAt(coefDriftLinear,kVdriftLinear);
846 fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
847 //
848 ok = kTRUE;
849 }
54f2ff1c 850 else {
851 fNotEnoughStatisticsForTheVdriftLinear = kTRUE;
dee5f636 852 Int_t minNumberOfEntriesForAll = fMinStatsVdriftLinear*30;
853 calibra->SetMinEntries(minNumberOfEntriesForAll); // Because we do it for all, we increase this
840ec79d 854 Double_t vdriftoverall = -100.0;
855 Double_t exboverall = 100.0;
856 calibra->AnalyseLinearFittersAllTogether(fAliTRDCalibraVdriftLinearFit,vdriftoverall,exboverall);
857 //printf("Found mean vdrift %f and exb %f\n",vdriftoverall,exboverall);
858 if(fCalDetVdriftUsed && (vdriftoverall > 0.0) && (exboverall < 70.0)) {
54f2ff1c 859 AliTRDCalDet *calDetVdrift = new AliTRDCalDet(*fCalDetVdriftUsed);
840ec79d 860 AliTRDCalDet *calDetLorentz = new AliTRDCalDet(*fCalDetExBUsed);
861 Double_t oldmeanvdrift = fCalDetVdriftUsed->CalcMean(kFALSE);
862 Double_t oldmeanexb = fCalDetExBUsed->CalcMean(kFALSE);
54f2ff1c 863 //printf("oldmean %f\n",oldmean);
840ec79d 864 if((oldmeanvdrift > 0.0) && (oldmeanexb < 70.0)) {
54f2ff1c 865 //printf("Correction factor %f\n",vdriftoverall);
840ec79d 866 calDetVdrift->Multiply(vdriftoverall/oldmeanvdrift);
a50946d4 867 if(TMath::Abs(oldmeanexb) > 0.0001) calDetLorentz->Multiply(exboverall/oldmeanexb);
54f2ff1c 868 //printf("newmean %f\n",calDetVdrift->CalcMean(kFALSE));
869 TH1F *coefDriftLinear = calDetVdrift->MakeHisto1DAsFunctionOfDet();
840ec79d 870 TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
54f2ff1c 871 // Put them in the array
872 fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
840ec79d 873 fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
54f2ff1c 874 fPlots->AddAt(coefDriftLinear,kVdriftLinear);
840ec79d 875 fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
54f2ff1c 876 //
877 ok = kTRUE;
82b413fd 878 fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsButFill;
54f2ff1c 879 }
82b413fd 880 else {
840ec79d 881 if(oldmeanvdrift) fStatusPos = fStatusPos | kVdriftErrorOld;
882 if(oldmeanexb) fStatusPos = fStatusPos | kExBErrorOld;
82b413fd 883 }
884 }
885 else {
840ec79d 886 if((vdriftoverall <= 0.0) && (exboverall > 70.0)) fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsNotFill;
82b413fd 887 if(!fCalDetVdriftUsed) fStatusPos = fStatusPos | kVdriftErrorOld;
840ec79d 888 if(!fCalDetExBUsed) fStatusPos = fStatusPos | kExBErrorOld;
54f2ff1c 889 }
54f2ff1c 890 }
b3fcfd96 891
892 calibra->ResetVectorFit();
893
894 return ok;
895
896}
00d203b6 897//________________________________________________________________________________________________________________
b3fcfd96 898
a0bb5615 899Bool_t AliTRDPreprocessorOffline::AnalyzeExbAltFit(){
900 //
901 // Analyze vdrift linear fit - produce the calibration objects
902 //
903
904 //printf("Analyse linear fit\n");
905
906
907 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
908 calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
909 //printf("Fill PE Array\n");
2a1a7b36 910 fAliTRDCalibraExbAltFit->SetRobustFit(fRobustFitExbAlt);
661c7be6 911 if(!fAlternativeExbAltFit)
912 fAliTRDCalibraExbAltFit->FillPEArray();
913 else
914 fAliTRDCalibraExbAltFit->FillPEArray2();
a0bb5615 915 //printf("AliTRDCalibraFit\n");
916 calibra->AnalyseExbAltFit(fAliTRDCalibraExbAltFit);
917 //printf("After\n");
918
919 //Int_t nbtg = 540;
920 Int_t nbfit = calibra->GetNumberFit();
921 Int_t nbE = calibra->GetNumberEnt();
922
923
924 Bool_t ok = kFALSE;
925 // enough statistics
926 if ((nbfit >= 0.5*nbE) && (nbE > 30)) {
927 // create the cal objects
928 //calibra->RemoveOutliers(1,kTRUE);
929 calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
930 //
931 TObjArray object = calibra->GetVectorFit2();
932 AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectExbAlt(&object);
933 TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
934 //if(!calDetLorentz) printf("No lorentz created\n");
935 // Put them in the array
936 fCalibObjects->AddAt(calDetLorentz,kExbAlt);
937 fPlots->AddAt(coefLorentzAngle,kExbAlt);
938 //
939 ok = kTRUE;
940 }
941
942 calibra->ResetVectorFit();
943
944 return ok;
945
946}
947//________________________________________________________________________________________________________________
948
b3fcfd96 949Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
950 //
951 // Analyze PRF - produce the calibration objects
952 //
953
954 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 955 calibra->SetMinEntries(fMinStatsPRF); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 956 calibra->AnalysePRFMarianFit(fPRF2d);
957
958 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
959 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
960 Int_t nbfit = calibra->GetNumberFit();
961 Int_t nbE = calibra->GetNumberEnt();
962
963
964 Bool_t ok = kFALSE;
965 // enough statistics
966 if ((nbtg > 0) &&
967 (nbfit >= 0.95*nbE) && (nbE > 30)) {
968 // create the cal objects
969 TObjArray object = calibra->GetVectorFit();
970 AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object);
971 TH1F *coefPRF = calPadPRF->MakeHisto1D();
972 // Put them in the array
973 fCalibObjects->AddAt(calPadPRF,kPRF);
974 fPlots->AddAt(coefPRF,kPRF);
975 //
976 ok = kTRUE;
977 }
978
979 calibra->ResetVectorFit();
980
981 return ok;
982
983}
a5dcf618 984
e2a1c98b 985//_____________________________________________________________________________
986Bool_t AliTRDPreprocessorOffline::AnalyzePHQ(Int_t startRunNumber)
987{
988 //
989 //Produce PHQ calibration results
990 //
687aa844 991 TList *lout = 0x0;
992 TTreeSRedirector *calibStream = 0x0;
993 if(IsDebugPHQon()){
994 lout = new TList;
995 lout->SetOwner();
996
997 calibStream = new TTreeSRedirector(Form("TRDCalibStream_%010d.root", startRunNumber));
998 }
999
6951a056 1000 for(Int_t iter=0; iter<AliTRDdEdxCalibUtils::GetHistArray()->GetSize(); iter++){
1001 THnBase *hi = (THnBase*) AliTRDdEdxCalibUtils::GetHistAt(iter);
687aa844 1002 TObjArray *obji = AliTRDdEdxCalibUtils::HistToObj(hi, startRunNumber, lout, calibStream);
e2a1c98b 1003 //printf("test analyze %s\n", obji->GetName());
6951a056 1004 AliTRDdEdxCalibUtils::GetObjArray()->AddAt(obji, iter);
e2a1c98b 1005 }
1006
6951a056 1007 fCalibObjects->AddAt(AliTRDdEdxCalibUtils::GetObjArray(), kPHQ);
687aa844 1008
1009 if(lout){
1010 TFile *fout=new TFile(Form("TRDCalibList_%010d.root", startRunNumber),"recreate");
1011 fout->cd();
1012 lout->Write();
1013 fout->Save();
1014 fout->Close();
1015 delete fout;
1016 }
1017 delete calibStream;
1018 delete lout;
1019
e2a1c98b 1020 return kTRUE;
1021}
1022
a5dcf618 1023//_____________________________________________________________________________
1024Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
1025{
4c865c34 1026 //
a5dcf618 1027 // Produce AliTRDCalChamberStatus out of calibration results
4c865c34 1028 //
b61b92a0 1029
83d0cc79 1030 // set up AliTRDCalibChamberStatus
92df0132 1031 AliTRDCalibChamberStatus *chamberStatus = new AliTRDCalibChamberStatus();
1032 chamberStatus->SetSparseI(fSparse);
1033 chamberStatus->AnalyseHisto(fMinStatsChamberStatus, fMinSingleStatsChamberStatus);
83d0cc79 1034 // get AliTRDCalChamberStatus
92df0132 1035 AliTRDCalChamberStatus *calChamberStatus = chamberStatus->GetCalChamberStatus();
01239968 1036
a5dcf618 1037 // get calibration objects
1038 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
1039 AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear);
840ec79d 1040 AliTRDCalDet *calDetExB = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear);
a5dcf618 1041
1042 // Check
92df0132 1043 if((!calDetGain) || (!calDetVDrift) || (!fCH2d) || (!calDetExB) || (!calChamberStatus)) return kFALSE;
a5dcf618 1044
1045 // Gain
83d0cc79 1046 Double_t gainmean = calDetGain->GetMean();
a5dcf618 1047 Double_t vdriftmean = calDetVDrift->GetMean();
83d0cc79 1048 Double_t exbmean = calDetExB->GetMean();
a5dcf618 1049
83d0cc79 1050 Double_t gainrms = calDetGain->GetRMSRobust();
1051 Double_t vdriftrms = calDetVDrift->GetRMSRobust();
1052 Double_t exbrms = calDetExB->GetRMSRobust();
a5dcf618 1053
1054 //printf("Gain mean: %f, rms: %f\n",gainmean,gainrms);
1055 //printf("Vdrift mean: %f, rms: %f\n",vdriftmean,vdriftrms);
840ec79d 1056 //printf("ExB mean: %f, rms: %f\n",exbmean,exbrms);
1057
a5dcf618 1058 // Check
840ec79d 1059 if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001) || (TMath::Abs(exbrms) < 0.0000001)) return kFALSE;
01239968 1060
67abca5c 1061 // Take mean each SM
1062 Double_t *gainmeanSM = new Double_t[18];
1063 Double_t *vdriftmeanSM = new Double_t[18];
1064 Double_t *exbmeanSM = new Double_t[18];
1065 //Double_t *t0meanSM = new Double_t[18];
1066 for(Int_t sm=0; sm< 18; sm++) {
1067 gainmeanSM[sm] = calDetGain->GetMeanSM(kFALSE,sm);
1068 vdriftmeanSM[sm] = calDetVDrift->GetMeanSM(kFALSE,sm);
1069 exbmeanSM[sm] = calDetExB->GetMeanSM(kFALSE,sm);
1070 //t0meanSM[sm] = calDetGain->GetMeanSM(kFALSE);
1071 }
1072
1073
a5dcf618 1074 // mask chambers with empty gain entries
1075 //Int_t counter = 0;
1076 for (Int_t idet = 0; idet < 540; idet++) {
01239968 1077
a5dcf618 1078 // ch2d
1079 TH1I *projch = (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e");
1080 Double_t entries = projch->GetEntries();
83d0cc79 1081 //printf("Number of entries %f for det %d\n",entries,idet);
4c865c34 1082
67abca5c 1083 // sm number
1084 Int_t smnumber = (Int_t) idet/30;
1085
a5dcf618 1086 // gain
1087 Double_t gain = calDetGain->GetValue(idet);
4c865c34 1088
a5dcf618 1089 // vdrift
1090 Double_t vdrift = calDetVDrift->GetValue(idet);
4c865c34 1091
840ec79d 1092 // exb
1093 Double_t exb = calDetExB->GetValue(idet);
1094
4c865c34 1095
92df0132 1096 if( (entries<50 && !calChamberStatus->IsNoData(idet)) ||
83d0cc79 1097 TMath::Abs(gainmean-gain) > (fRMSBadCalibratedGain*gainrms) ||
1098 TMath::Abs(vdriftmean-vdrift) > (fRMSBadCalibratedVdrift*vdriftrms) ||
1099 TMath::Abs(exbmean-exb) > (fRMSBadCalibratedExB*exbrms) ) {
a5dcf618 1100
1101 //printf(" chamber det %03d masked \n",idet);
1102 //printf(" gainmean %f and gain %f, gainrms %f \n",gainmean,gain,gainrms);
1103 //printf(" vdriftmean %f and vdrift %f, vdriftrms %f \n",vdriftmean,vdrift,vdriftrms);
840ec79d 1104 //printf(" exbmean %f and exb %f, exbrms %f \n",exbmean,exb,exbrms);
1105
92df0132 1106 calChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kBadCalibrated);
a5dcf618 1107 //counter++;
1108 }
4c865c34 1109
67abca5c 1110 if(TMath::Abs(gainmeanSM[smnumber]-gain) < 0.000001 ||
1111 TMath::Abs(vdriftmeanSM[smnumber]-vdrift) < 0.000001 ||
1112 TMath::Abs(exbmeanSM[smnumber]-exb) < 0.000001) {
1113
1114 //printf(" chamber det %03d notcalibrated sm %d \n",idet,smnumber);
1115 //printf(" gainmeanSM %f and gain %f\n",gainmeanSM[smnumber],gain);
1116 //printf(" vdriftmeanSM %f and vdrift %f \n",vdriftmeanSM[smnumber],vdrift);
1117 //printf(" exbmeanSM %f and exb %f \n",exbmeanSM[smnumber],exb);
1118
1119 calChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kNotCalibrated);
1120 }
1121
1122
b61b92a0 1123 delete projch;
1124
a5dcf618 1125 }
b3fcfd96 1126
83d0cc79 1127 // Security
1128 for(Int_t sm=0; sm < 18; sm++) {
1129 Int_t smnodata = 0;
1130 Int_t smbadcalib = 0;
1131 for(Int_t det = 0; det < 30; det++){
1132 Int_t detector = sm*30+det;
92df0132 1133 if(calChamberStatus->IsNoData(detector)) smnodata++;
83d0cc79 1134 else {
92df0132 1135 if(calChamberStatus->IsBadCalibrated(detector)) smbadcalib++;
83d0cc79 1136 }
1137 }
1138 fNoData[sm] = smnodata;
1139 fBadCalib[sm]= smbadcalib;
1140 //printf("No Data %d, bad calibrated %d for %d\n",fNoData[sm],fBadCalib[sm],sm);
1141 }
67abca5c 1142
1143 // delete
1144 delete []gainmeanSM;
1145 delete []vdriftmeanSM;
1146 delete []exbmeanSM;
83d0cc79 1147
1148 // Security
1149 // for(Int_t sm=0; sm < 18; sm++) {
1150 // Int_t counter = 0;
1151 // for(Int_t det = 0; det < 30; det++){
1152 // Int_t detector = sm*30+det;
92df0132 1153 // if(calChamberStatus->IsBadCalibrated(detector)) counter++;
83d0cc79 1154 // }
1155 // if(counter >= 20) {
1156 // for(Int_t det = 0; det < 30; det++){
1157 // Int_t detector = sm*30+det;
92df0132 1158 // calChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood);
83d0cc79 1159 // }
1160 // }
1161 // }
b3fcfd96 1162
92df0132 1163 fCalibObjects->AddAt(calChamberStatus,kChamberStatus);
a5dcf618 1164 return kTRUE;
b3fcfd96 1165
a5dcf618 1166 }
b3fcfd96 1167
b3fcfd96 1168
a5dcf618 1169 //________________________________________________________________________________________________
1170 void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
1171 //
1172 // Correct from the gas gain used afterwards
1173 //
1174 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
1175 if(!calDetGain) return;
b3fcfd96 1176
a5dcf618 1177 // Calculate mean
1178 Double_t mean = 0.0;
1179 Int_t nbdet = 0;
b3fcfd96 1180
a5dcf618 1181 for(Int_t det = 0; det < 540; det++) {
00d203b6 1182
a5dcf618 1183 Float_t gaininit = fCalDetGainUsed->GetValue(det);
1184 Float_t gainout = calDetGain->GetValue(det);
00d203b6 1185
00d203b6 1186
a5dcf618 1187 if(TMath::Abs(gainout-1.0) > 0.000001) {
1188 mean += (gaininit*gainout);
1189 nbdet++;
1190 }
1191 }
1192 if(nbdet > 0) mean = mean/nbdet;
00d203b6 1193
a5dcf618 1194 for(Int_t det = 0; det < 540; det++) {
00d203b6 1195
a5dcf618 1196 Float_t gaininit = fCalDetGainUsed->GetValue(det);
1197 Float_t gainout = calDetGain->GetValue(det);
1198
ba1aa7a7 1199 if(TMath::Abs(gainout-1.0) > 0.000001) {
1200 Double_t newgain = gaininit*gainout;
1201 if(newgain < 0.1) newgain = 0.1;
58e2b572 1202 if(newgain > 1.9) newgain = 1.9;
ba1aa7a7 1203 calDetGain->SetValue(det,newgain);
1204 }
1205 else {
1206 Double_t newgain = mean;
1207 if(newgain < 0.1) newgain = 0.1;
58e2b572 1208 if(newgain > 1.9) newgain = 1.9;
ba1aa7a7 1209 calDetGain->SetValue(det,newgain);
1210 }
a5dcf618 1211 }
1212
1213
1214 }
1215 //________________________________________________________________________________________________
1216 void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
1217 //
1218 // Correct from the drift velocity
1219 //
1220
1221 //printf("Correct for vdrift\n");
1222
1223 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
1224 if(!calDetGain) return;
1225
1226 Int_t detVdrift = kVdriftPHDet;
1227 if(fMethodSecond) detVdrift = kVdriftLinear;
1228 AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
1229 if(!calDetVdrift) return;
1230
1231 // Calculate mean
8dac2af1 1232 if(!fNotEnoughStatisticsForTheVdriftLinear) {
54f2ff1c 1233 for(Int_t det = 0; det < 540; det++) {
1234
1235 Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
1236 Float_t vdriftout = calDetVdrift->GetValue(det);
1237
1238 Float_t gain = calDetGain->GetValue(det);
1239 if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
1240 if(gain < 0.1) gain = 0.1;
1241 if(gain > 1.9) gain = 1.9;
1242 calDetGain->SetValue(det,gain);
1243 }
a5dcf618 1244 }
54f2ff1c 1245 else {
1246
1247 Float_t vdriftinit = fCalDetVdriftUsed->CalcMean(kFALSE);
1248 Float_t vdriftout = calDetVdrift->CalcMean(kFALSE);
1249 Float_t factorcorrectif = 1.0;
1250 if(vdriftout > 0.0) factorcorrectif = vdriftinit/vdriftout;
1251 for(Int_t det = 0; det < 540; det++) {
1252 Float_t gain = calDetGain->GetValue(det);
1253 gain = gain*factorcorrectif;
1254 if(gain < 0.1) gain = 0.1;
1255 if(gain > 1.9) gain = 1.9;
1256 calDetGain->SetValue(det,gain);
1257 }
1258
1259 }
1260
a5dcf618 1261 }
54f2ff1c 1262//_________________________________________________________________________________________________________________
a9f9c69b 1263 void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage *storage){
a5dcf618 1264 //
1265 // Update OCDB entry
1266 //
1267
1268 AliCDBMetaData *metaData= new AliCDBMetaData();
1269 metaData->SetObjectClassName("AliTRDCalDet");
1270 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1271 metaData->AddDateToComment();
a5dcf618 1272 metaData->SetBeamPeriod(1);
1273
1274 AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
a5dcf618 1275 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
a9f9c69b 1276 if(calDet) storage->Put(calDet, id1, metaData);
a5dcf618 1277
1278
eec29d56 1279 }
1280 //___________________________________________________________________________________________________________________
a9f9c69b 1281 void AliTRDPreprocessorOffline::UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage *storage){
eec29d56 1282 //
1283 // Update OCDB entry
1284 //
1285
1286 Int_t detExB = kLorentzLinear;
1287 if(!fMethodSecond) return;
1288
1289 //printf("Pass\n");
1290
1291 AliCDBMetaData *metaData= new AliCDBMetaData();
1292 metaData->SetObjectClassName("AliTRDCalDet");
1293 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1294 metaData->AddDateToComment();
eec29d56 1295 metaData->SetBeamPeriod(1);
1296
1297 AliCDBId id1("TRD/Calib/ChamberExB", startRunNumber, endRunNumber);
eec29d56 1298 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
a9f9c69b 1299 if(calDet) storage->Put(calDet, id1, metaData);
eec29d56 1300 //if(!calDet) printf("No caldet\n");
1301
a5dcf618 1302 }
a0bb5615 1303//___________________________________________________________________________________________________________________
a9f9c69b 1304void AliTRDPreprocessorOffline::UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage *storage){
a0bb5615 1305 //
1306 // Update OCDB entry
1307 //
1308
1309 Int_t detExB = kExbAlt;
1310 if(!fMethodSecond) return;
1311
1312 //printf("Pass\n");
1313
1314 AliCDBMetaData *metaData= new AliCDBMetaData();
1315 metaData->SetObjectClassName("AliTRDCalDet");
58006729 1316 metaData->SetResponsible("Theo Rascanu");
1317 metaData->AddDateToComment();
a0bb5615 1318 metaData->SetBeamPeriod(1);
1319
1320 AliCDBId id1("TRD/Calib/ChamberExBAlt", startRunNumber, endRunNumber);
a0bb5615 1321 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
a9f9c69b 1322 if(calDet) storage->Put(calDet, id1, metaData);
a0bb5615 1323 //if(!calDet) printf("No caldet\n");
1324
1325}
a5dcf618 1326 //___________________________________________________________________________________________________________________
a9f9c69b 1327 void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage){
a5dcf618 1328 //
1329 // Update OCDB entry
1330 //
1331
1332 Int_t detVdrift = kVdriftPHDet;
1333
1334 if(fMethodSecond) detVdrift = kVdriftLinear;
1335
1336 AliCDBMetaData *metaData= new AliCDBMetaData();
1337 metaData->SetObjectClassName("AliTRDCalDet");
1338 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1339 metaData->AddDateToComment();
a5dcf618 1340 metaData->SetBeamPeriod(1);
1341
1342 AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
a5dcf618 1343 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
a9f9c69b 1344 if(calDet) storage->Put(calDet, id1, metaData);
a5dcf618 1345
1346 //
1347
1348 if(!fMethodSecond) {
1349
1350 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
1351 metaDataPad->SetObjectClassName("AliTRDCalPad");
1352 metaDataPad->SetResponsible("Raphaelle Bailhache");
58006729 1353 metaDataPad->AddDateToComment();
a5dcf618 1354 metaDataPad->SetBeamPeriod(1);
1355
1356 AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
1357 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
a9f9c69b 1358 if(calPad) storage->Put(calPad, id1Pad, metaDataPad);
a5dcf618 1359
1360 }
1361
1362 }
1363 //________________________________________________________________________________________________________________________
a9f9c69b 1364 void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage){
a5dcf618 1365 //
1366 // Update OCDB entry
1367 //
1368
1369 AliCDBMetaData *metaData= new AliCDBMetaData();
1370 metaData->SetObjectClassName("AliTRDCalDet");
1371 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1372 metaData->AddDateToComment();
a5dcf618 1373 metaData->SetBeamPeriod(1);
1374
1375 AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
a5dcf618 1376 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
a9f9c69b 1377 if(calDet) storage->Put(calDet, id1, metaData);
a5dcf618 1378
1379 //
1380
1381 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
1382 metaDataPad->SetObjectClassName("AliTRDCalPad");
1383 metaDataPad->SetResponsible("Raphaelle Bailhache");
58006729 1384 metaDataPad->AddDateToComment();
a5dcf618 1385 metaDataPad->SetBeamPeriod(1);
1386
1387 AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
1388 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
a9f9c69b 1389 if(calPad) storage->Put(calPad, id1Pad, metaDataPad);
a5dcf618 1390
1391
1392
1393 }
1394 //_________________________________________________________________________________________________________________
a9f9c69b 1395 void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage){
a5dcf618 1396 //
1397 // Update OCDB entry
1398 //
1399
1400 AliCDBMetaData *metaData= new AliCDBMetaData();
1401 metaData->SetObjectClassName("AliTRDCalPad");
1402 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1403 metaData->AddDateToComment();
a5dcf618 1404 metaData->SetBeamPeriod(1);
1405
58006729 1406
a5dcf618 1407 AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
a5dcf618 1408 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
a9f9c69b 1409 if(calPad) storage->Put(calPad, id1, metaData);
a5dcf618 1410
1411
1412 }
e2a1c98b 1413//_________________________________________________________________________________________________________________
a9f9c69b 1414void AliTRDPreprocessorOffline::UpdateOCDBPHQ(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage)
e2a1c98b 1415{
1416 //
1417 // Update OCDB entry
1418 //
1419 AliCDBMetaData *metaData= new AliCDBMetaData();
1420 metaData->SetObjectClassName("TObjArray");
1421 metaData->SetResponsible("Raphaelle Bailhache and Xianguo Lu");
1422 metaData->AddDateToComment();
1423 metaData->SetBeamPeriod(1);
1424
1425 AliCDBId id1("TRD/Calib/PHQ", startRunNumber, endRunNumber);
e2a1c98b 1426 TObjArray *cobj = (TObjArray *) fCalibObjects->At(kPHQ);
1427 if(cobj){
1428 //cobj->Print();
a9f9c69b 1429 storage->Put(cobj, id1, metaData);
e2a1c98b 1430 }
1431}
1432
a5dcf618 1433 //_________________________________________________________________________________________________________________
a9f9c69b 1434 void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage){
a5dcf618 1435 //
1436 // Update OCDB entry
1437 //
1438
1439 AliCDBMetaData *metaData= new AliCDBMetaData();
1440 metaData->SetObjectClassName("AliTRDCalChamberStatus");
58006729 1441 metaData->SetResponsible("Raphaelle Bailhache and Julian Book");
1442 metaData->AddDateToComment();
a5dcf618 1443 metaData->SetBeamPeriod(1);
1444
1445 AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber);
a5dcf618 1446 AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
a9f9c69b 1447 if(calChamberStatus) storage->Put(calChamberStatus, id1, metaData);
a5dcf618 1448
1449
1450 }
1451 //__________________________________________________________________________________________________________________________
54f2ff1c 1452 Bool_t AliTRDPreprocessorOffline::ValidateGain() {
a5dcf618 1453 //
1454 // Validate OCDB entry
1455 //
1456
1457 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
1458 if(calDet) {
1459 Double_t mean = calDet->GetMean();
1460 Double_t rms = calDet->GetRMSRobust();
1461 if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
1462 //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
54f2ff1c 1463 else {
82b413fd 1464 fStatusPos = fStatusPos | kGainErrorRange;
54f2ff1c 1465 return kFALSE;
1466 }
a5dcf618 1467 }
1468 else return kFALSE;
54f2ff1c 1469
a5dcf618 1470
1471
1472 }
1473 //__________________________________________________________________________________________________________________________
1474 Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
1475 //
1476 // Update OCDB entry
1477 //
1478
1479 Int_t detVdrift = kVdriftPHDet;
1480 Bool_t ok = kTRUE;
1481
1482 if(fMethodSecond) detVdrift = kVdriftLinear;
1483
1484 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
1485 if(calDet) {
1486 Double_t mean = calDet->GetMean();
1487 Double_t rms = calDet->GetRMSRobust();
1488 //printf("Vdrift::mean %f, rms %f\n",mean,rms);
54f2ff1c 1489 if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) {
82b413fd 1490 fStatusPos = fStatusPos | kVdriftErrorRange;
54f2ff1c 1491 ok = kFALSE;
1492 }
a5dcf618 1493 }
1494 else return kFALSE;
1495
1496 if(!fMethodSecond) {
1497 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
1498 if(calPad) {
1499 Double_t mean = calPad->GetMean();
1500 Double_t rms = calPad->GetRMS();
1501 //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
54f2ff1c 1502 if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) {
82b413fd 1503 fStatusPos = fStatusPos | kVdriftErrorRange;
54f2ff1c 1504 ok = kFALSE;
1505 }
a5dcf618 1506 }
1507 else return kFALSE;
1508 }
1509
1510 return ok;
1511
840ec79d 1512 }
1513 //__________________________________________________________________________________________________________________________
1514 Bool_t AliTRDPreprocessorOffline::ValidateExB(){
1515 //
1516 // Update OCDB entry
1517 //
1518
1519 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear);
1520 if(calDet) {
1521 Double_t mean = calDet->GetMean();
1522 Double_t rms = calDet->GetRMSRobust();
1523 //printf("Vdrift::mean %f, rms %f\n",mean,rms);
1524 if(!((mean > -1.0) && (mean < 1.0) && (rms < 0.5))) {
1525 fStatusNeg = fStatusNeg | kExBErrorRange;
1526 return kFALSE;
1527 }
1528 else return kTRUE;
1529 }
1530 else return kFALSE;
1531
a5dcf618 1532 }
1533 //__________________________________________________________________________________________________________________________
1534 Bool_t AliTRDPreprocessorOffline::ValidateT0(){
1535 //
1536 // Update OCDB entry
1537 //
1538
1539 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
1540 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
1541 if(calDet && calPad) {
1542 Double_t meandet = calDet->GetMean();
1543 Double_t rmsdet = calDet->GetRMSRobust();
1544 Double_t meanpad = calPad->GetMean();
1545 //Double_t rmspad = calPad->GetRMS();
4f3bd513 1546 printf("T0::meandet %f, rmsdet %f,meanpad %f\n",meandet,rmsdet,meanpad);
d82bad1e 1547 if((meandet > fMinTimeOffsetValidate) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
54f2ff1c 1548 else {
82b413fd 1549 fStatusPos = fStatusPos | kTimeOffsetErrorRange;
54f2ff1c 1550 return kFALSE;
1551 }
a5dcf618 1552 }
1553 else return kFALSE;
1554
1555 }
1556 //__________________________________________________________________________________________________________________________
1557 Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
1558 //
1559 // Update OCDB entry
1560 //
1561
1562 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
1563 if(calPad) {
1564 Double_t meanpad = calPad->GetMean();
1565 Double_t rmspad = calPad->GetRMS();
1566 //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
1567 if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
1568 else return kFALSE;
1569 }
1570 else return kFALSE;
1571
1572
1573 }
1574 //__________________________________________________________________________________________________________________________
82b413fd 1575Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus(){
00d203b6 1576 //
1577 // Update OCDB entry
1578 //
1579
a5dcf618 1580 AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
1581 if(calChamberStatus) {
83d0cc79 1582
1583 Int_t detectornodata = 0;
1584 Int_t detectorbadcalib = 0;
1585
1586 for(Int_t sm=0; sm < 18; sm++) {
1587 //printf("%d chambers w/o data in sm %d\n",fNoData[sm],sm);
1588 //printf("%d bad calibrated chambers in sm %d\n",fBadCalib[sm],sm);
1589 if(fNoData[sm] != 30) detectornodata += fNoData[sm];
1590 detectorbadcalib+=fBadCalib[sm];
a5dcf618 1591 }
83d0cc79 1592 //printf("Number of chambers w/o data %d\n",detectornodata);
1593 //printf("Number of chambers bad calibrated %d\n",detectorbadcalib);
1594
1595 if((detectornodata > fNoDataValidate) ||
1596 (detectorbadcalib > fBadCalibValidate)){
82b413fd 1597 fStatusPos = fStatusPos | kChamberStatusErrorRange;
1598 return kFALSE;
1599 }
83d0cc79 1600 return kTRUE;
00d203b6 1601 }
1602 else return kFALSE;
83d0cc79 1603
b3fcfd96 1604}
4c865c34 1605//_____________________________________________________________________________
1606Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
1607{
1608 //
1609 // Get version from the title
1610 //
1611
1612 // Some patterns
1613 const Char_t *version = "Ver";
1614 if(!strstr(name.Data(),version)) return -1;
f558cb62 1615 const Char_t *after = "Subver";
1616 if(!strstr(name.Data(),after)) return -1;
1617
4c865c34 1618 for(Int_t ver = 0; ver < 999999999; ver++) {
1619
1620 TString vertry(version);
1621 vertry += ver;
f558cb62 1622 vertry += after;
4c865c34 1623
1624 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1625
1626 if(strstr(name.Data(),vertry.Data())) return ver;
1627
1628 }
1629
1630 return -1;
1631
1632}
1633
1634//_____________________________________________________________________________
1635Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
1636{
1637 //
1638 // Get subversion from the title
1639 //
1640
1641 // Some patterns
1642 const Char_t *subversion = "Subver";
1643 if(!strstr(name.Data(),subversion)) return -1;
f558cb62 1644 const Char_t *after = "FirstRun";
1645 if(!strstr(name.Data(),after)) {
1646 after = "Nz";
1647 }
1648 if(!strstr(name.Data(),after)) return -1;
1649
4c865c34 1650
1651 for(Int_t ver = 0; ver < 999999999; ver++) {
1652
1653 TString vertry(subversion);
1654 vertry += ver;
f558cb62 1655 vertry += after;
ca7e6e64 1656
1657 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1658
1659 if(strstr(name.Data(),vertry.Data())) return ver;
1660
1661 }
1662
1663 return -1;
1664
1665}
1666
1667//_____________________________________________________________________________
1668Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const
1669{
1670 //
1671 // Get first run from the title
1672 //
1673
1674 // Some patterns
1675 const Char_t *firstrun = "FirstRun";
1676 if(!strstr(name.Data(),firstrun)) return -1;
f558cb62 1677 const Char_t *after = "Nz";
1678 if(!strstr(name.Data(),after)) return -1;
1679
ca7e6e64 1680
1681 for(Int_t ver = 0; ver < 999999999; ver++) {
1682
1683 TString vertry(firstrun);
1684 vertry += ver;
f558cb62 1685 vertry += after;
4c865c34 1686
1687 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1688
1689 if(strstr(name.Data(),vertry.Data())) return ver;
1690
1691 }
1692
1693 return -1;
1694
1695}
82b413fd 1696//_____________________________________________________________________________
1697Bool_t AliTRDPreprocessorOffline::CheckStatus(Int_t status, Int_t bitMask) const
1698{
1699 //
1700 // Checks the status
1701 //
1702
1703 return (status & bitMask) ? kTRUE : kFALSE;
1704
1705}
1706//_____________________________________________________________________________
1707Int_t AliTRDPreprocessorOffline::GetStatus() const
1708{
1709 //
1710 // Checks the status
1711 // fStatusPos: errors
1712 // fStatusNeg: only info
1713 //
1714
1715 if(fStatusPos > 0) return fStatusPos;
1716 else return (-TMath::Abs(fStatusNeg));
1717
1718}
1719//_____________________________________________________________________________
1720void AliTRDPreprocessorOffline::PrintStatus() const
1721{
1722 //
1723 // Do Summary
1724 //
1725
1726 AliInfo(Form("The error status is %d",fStatusPos));
1727 AliInfo(Form("IsGainErrorOld? %d",(Int_t)IsGainErrorOld()));
1728 AliInfo(Form("IsVdriftErrorOld? %d",(Int_t)IsVdriftErrorOld()));
1729 AliInfo(Form("IsGainErrorRange? %d",(Int_t)IsGainErrorRange()));
1730 AliInfo(Form("IsVdriftErrorRange? %d",(Int_t)IsVdriftErrorRange()));
1731 AliInfo(Form("IsTimeOffsetErrorRange? %d",(Int_t)IsTimeOffsetErrorRange()));
1732 AliInfo(Form("IsChamberStatusErrorRange? %d",(Int_t)IsChamberStatusErrorRange()));
1733
1734
1735 AliInfo(Form("The info status is %d",fStatusNeg));
1736 AliInfo(Form("IsGainNotEnoughStatsButFill? %d",(Int_t)IsGainNotEnoughStatsButFill()));
1737 AliInfo(Form("IsVdriftNotEnoughStatsButFill? %d",(Int_t)IsVdriftNotEnoughStatsButFill()));
1738 AliInfo(Form("IsGainNotEnoughStatsNotFill? %d",(Int_t)IsGainNotEnoughStatsNotFill()));
1739 AliInfo(Form("IsVdriftNotEnoughStatsNotFill? %d",(Int_t)IsVdriftNotEnoughStatsNotFill()));
1740 AliInfo(Form("IsTimeOffsetNotEnoughStatsNotFill? %d",(Int_t)IsTimeOffsetNotEnoughStatsNotFill()));
840ec79d 1741
1742 AliInfo(Form("IsExBErrorRange? %d",(Int_t)IsExBErrorRange()));
1743 AliInfo(Form("IsExBErrorOld? %d",(Int_t)IsExBErrorOld()));
82b413fd 1744
1745}
840ec79d 1746//___________________________________________________________________________________
1747void AliTRDPreprocessorOffline::SetCalDetVdrift(AliTRDCalDet *calDetVdriftUsed)
1748{
1749
1750 fCalDetVdriftUsed = calDetVdriftUsed;
1751
1752 fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1753 for(Int_t k = 0; k < 540; k++){
1754 fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1755 //printf("Set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1756 }
1757
1758};
83d0cc79 1759//___________________________________________________________________________________
1760Bool_t AliTRDPreprocessorOffline::SetCalDetGain(Int_t runNumber, Int_t version, Int_t subversion)
1761{
1762 //
1763 // Set the fCalDetGainUsed
1764 //
1765
1766 if((version == 0) && (subversion == 0)) return kFALSE;
82b413fd 1767
83d0cc79 1768 AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor",runNumber, version, subversion);
1769 if(!entry) {
1770 AliError("Found no entry\n");
1771 fStatusPos = fStatusPos | kGainErrorOld;
1772 return kFALSE;
1773 }
1774 //const AliCDBId id = entry->GetId();
1775 //version = id.GetVersion();
1776 //subversion = id.GetSubVersion();
1777 //printf("Found version %d and subversion %d for vdrift\n",version,subversion);
1778 AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject();
1779 if(calDet) fCalDetGainUsed = calDet;
1780 else {
1781 fStatusPos = fStatusPos | kGainErrorOld;
1782 return kFALSE;
1783 }
1784
1785 return kTRUE;
1786
1787}
1788//___________________________________________________________________________________
1789Bool_t AliTRDPreprocessorOffline::SetCalDetVdriftExB(Int_t runNumber, Int_t versionv, Int_t subversionv, Int_t versionexb, Int_t subversionexb)
1790{
1791 //
1792 // Set the fCalDetVdriftUsed and fCalDetExBUsed
1793 //
1794
1795 if((versionv == 0) && (subversionv == 0)) return kFALSE;
1796
1797 AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberVdrift",runNumber, versionv, subversionv);
1798 if(!entry) {
1799 AliError("Found no entry\n");
1800 fStatusPos = fStatusPos | kVdriftErrorOld;
1801 return kFALSE;
1802 }
1803 AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject();
1804 if(calDet) fCalDetVdriftUsed = calDet;
1805 else {
1806 fStatusPos = fStatusPos | kVdriftErrorOld;
1807 return kFALSE;
1808 }
1809
1810 // ExB object
1811
1812 if((versionexb == 0) && (subversionexb == 0)) {
1813
1814 fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1815 for(Int_t k = 0; k < 540; k++){
1816 fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1817 //printf("Nothing found: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1818 }
1819 }
1820 else {
1821
1822 entry = 0x0;
1823 entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberExB",runNumber, versionexb, subversionexb);
1824 if(!entry) {
1825 //printf("Found no entry\n");
1826 fStatusPos = fStatusPos | kExBErrorOld;
1827 return kFALSE;
1828 }
1829 AliTRDCalDet* calDetexb = (AliTRDCalDet *)entry->GetObject();
1830 if(!calDetexb) {
1831 fStatusPos = fStatusPos | kExBErrorOld;
1832 return kFALSE;
1833 }
1834
1835 Double_t meanexb = calDetexb->GetMean();
1836 //printf("Mean value %f\n",meanexb);
1837 if((meanexb > 70) || (fNoExBUsedInReco)) {
1838 fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1839 for(Int_t k = 0; k < 540; k++){
1840 fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1841 //printf("Found but: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1842 }
1843 }
1844 else {
1845 fCalDetExBUsed = calDetexb;
1846 }
1847
1848 }
1849
1850
1851 return kTRUE;
1852
1853}
01239968 1854