Change for reprocessing 2010 data (Raphaelle)
[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
171}
83d0cc79 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
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
380}
a5dcf618 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
405//________________________________________________________________________________________________________________
a5dcf618 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
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");
542 }else{
543 TH2I *ch2d = (TH2I *) fcalib.Get("CH2d");
544 if(!ch2d) return kFALSE;
545 fCH2d = (TH2I*)ch2d->Clone();
546 //fNEvents = (TH1I *) fcalib.Get("NEvents");
547 //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain");
548 }
549 fCH2d->SetDirectory(0);
550 //printf("title of CH2d %s\n",fCH2d->GetTitle());
551
552 return kTRUE;
553
554}
00d203b6 555//_________________________________________________________________________________________________________________
b3fcfd96 556
557Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){
558 //
559 // read calibration entries from file
560 //
4c865c34 561 if(fPH2d) return kTRUE;
b3fcfd96 562 TFile fcalib(fileName);
01239968 563 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 564 if (array){
565 TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d");
566 if(!ph2d) return kFALSE;
567 fPH2d = (TProfile2D*)ph2d->Clone();
568 //fNEvents = (TH1I *) array->FindObject("NEvents");
569 }else{
570 TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d");
571 if(!ph2d) return kFALSE;
572 fPH2d = (TProfile2D*)ph2d->Clone();
573 //fNEvents = (TH1I *) fcalib.Get("NEvents");
574 }
575 fPH2d->SetDirectory(0);
576 //printf("title of PH2d %s\n",fPH2d->GetTitle());
577
578 return kTRUE;
579
580}
00d203b6 581//___________________________________________________________________________________________________________________
b3fcfd96 582
583Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){
584 //
585 // read calibration entries from file
586 //
4c865c34 587 if(fAliTRDCalibraVdriftLinearFit) return kTRUE;
b3fcfd96 588 TFile fcalib(fileName);
01239968 589 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 590 if (array){
591 fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit");
592 //fNEvents = (TH1I *) array->FindObject("NEvents");
593 }else{
594 fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit");
595 //fNEvents = (TH1I *) fcalib.Get("NEvents");
596 }
597 if(!fAliTRDCalibraVdriftLinearFit) {
598 //printf("No AliTRDCalibraVdriftLinearFit\n");
599 return kFALSE;
600 }
601 return kTRUE;
602
603}
00d203b6 604//_____________________________________________________________________________________________________________
a0bb5615 605Bool_t AliTRDPreprocessorOffline::ReadExbAltFitGlobal(const Char_t* fileName){
606 //
607 // read calibration entries from file
608 //
609 if(fAliTRDCalibraExbAltFit) return kTRUE;
610 TFile fcalib(fileName);
611 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
612 if (array){
613 fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) array->FindObject("AliTRDCalibraExbAltFit");
614 //fNEvents = (TH1I *) array->FindObject("NEvents");
615 }else{
616 fAliTRDCalibraExbAltFit = (AliTRDCalibraExbAltFit *) fcalib.Get("AliTRDCalibraExbAltFit");
617 //fNEvents = (TH1I *) fcalib.Get("NEvents");
618 }
619 if(!fAliTRDCalibraExbAltFit) {
620 //printf("No AliTRDCalibraExbAltFit\n");
621 return kFALSE;
622 }
623 return kTRUE;
624
625}
626//_____________________________________________________________________________________________________________
b3fcfd96 627
628Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
629 //
630 // read calibration entries from file
631 //
4c865c34 632 if(fPRF2d) return kTRUE;
b3fcfd96 633 TFile fcalib(fileName);
01239968 634 TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
b3fcfd96 635 if (array){
636 TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d");
637 if(!prf2d) return kFALSE;
638 fPRF2d = (TProfile2D*)prf2d->Clone();
639 //fNEvents = (TH1I *) array->FindObject("NEvents");
640 }else{
641 TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d");
642 if(!prf2d) return kFALSE;
643 fPRF2d = (TProfile2D*)prf2d->Clone();
644 //fNEvents = (TH1I *) fcalib.Get("NEvents");
645 }
646 fPRF2d->SetDirectory(0);
647 //printf("title of PRF2d %s\n",fPRF2d->GetTitle());
648
649 return kTRUE;
650
651}
00d203b6 652//__________________________________________________________________________________________________________
b3fcfd96 653
654Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
655 //
656 // Analyze gain - produce the calibration objects
657 //
658
659 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
595cfc12 660 calibra->ChooseMethod(fMethodeGain);
661 calibra->SetBeginFitCharge(fBeginFitCharge);
662 calibra->SetFitOutliersChargeLow(fOutliersFitChargeLow);
663 calibra->SetFitOutliersChargeHigh(fOutliersFitChargeHigh);
a2a4ec8e 664 calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 665 calibra->AnalyseCH(fCH2d);
666
667 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
668 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
669 Int_t nbfit = calibra->GetNumberFit();
670 Int_t nbE = calibra->GetNumberEnt();
671
672
673 Bool_t ok = kFALSE;
4c865c34 674 Bool_t meanother = kFALSE;
b3fcfd96 675 // enough statistics
676 if ((nbtg > 0) &&
677 (nbfit >= 0.5*nbE) && (nbE > 30)) {
678 // create the cal objects
54f2ff1c 679 if(!fBackCorrectGain) {
4c865c34 680 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
681 meanother = kTRUE;
682 }
b3fcfd96 683 TObjArray object = calibra->GetVectorFit();
4c865c34 684 AliTRDCalDet *calDetGain = calibra->CreateDetObjectGain(&object,meanother);
b3fcfd96 685 TH1F *coefGain = calDetGain->MakeHisto1DAsFunctionOfDet();
686 // Put them in the array
687 fCalibObjects->AddAt(calDetGain,kGain);
688 fPlots->AddAt(coefGain,kGain);
689 //
690 ok = kTRUE;
691 }
54f2ff1c 692 else {
693 fNotEnoughStatisticsForTheGain = kTRUE;
dee5f636 694 Int_t minStatsGain = fMinStatsGain*30;
695 calibra->SetMinEntries(minStatsGain); // Because we do it for all, we increase this
54f2ff1c 696 Double_t gainoverallnotnormalized = calibra->AnalyseCHAllTogether(fCH2d);
697 if(fCalDetGainUsed && (gainoverallnotnormalized > 0.0)) {
698 AliTRDCalDet *calDetGain = new AliTRDCalDet(*fCalDetGainUsed);
699 Double_t oldmean = fCalDetGainUsed->CalcMean(kFALSE);
700 //printf("oldmean %f\n",oldmean);
701 if(oldmean > 0.0) {
702 Double_t scalefactor = calibra->GetScaleFactorGain();
703 //printf("Correction factor %f\n",gainoverallnotnormalized*scalefactor);
704 calDetGain->Multiply(gainoverallnotnormalized*scalefactor/oldmean);
705 //printf("newmean %f\n",calDetGain->CalcMean(kFALSE));
706 TH1F *coefGain = calDetGain->MakeHisto1DAsFunctionOfDet();
707 fCalibObjects->AddAt(calDetGain,kGain);
708 fPlots->AddAt(coefGain,kGain);
709 //
710 ok = kTRUE;
82b413fd 711 fStatusNeg = fStatusNeg | kGainNotEnoughStatsButFill;
54f2ff1c 712 }
713 else {
82b413fd 714 fStatusPos = fStatusPos | kGainErrorOld;
54f2ff1c 715 }
716 }
717 else {
82b413fd 718 if(gainoverallnotnormalized <= 0.0) fStatusNeg = fStatusNeg | kGainNotEnoughStatsNotFill;
719 if(!fCalDetGainUsed) fStatusPos = fStatusPos | kGainErrorOld;
54f2ff1c 720 }
721 }
b3fcfd96 722
723 calibra->ResetVectorFit();
724
725 return ok;
726
727}
00d203b6 728//_____________________________________________________________________________________________________
b3fcfd96 729Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
730 //
731 // Analyze VdriftT0 - produce the calibration objects
732 //
733
734 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
4f3bd513 735 calibra->SetT0Shift0(fT0Shift0);
736 calibra->SetT0Shift1(fT0Shift1);
a2a4ec8e 737 calibra->SetMinEntries(fMinStatsVdriftT0PH); // If there is less than 1000 entries in the histo: no fit
4f3bd513 738 calibra->AnalysePH(fPH2d);
739 //calibra->SetDebugLevel(2);
b3fcfd96 740
741 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
742 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
743 Int_t nbfit = calibra->GetNumberFit();
744 Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
745 Int_t nbE = calibra->GetNumberEnt();
746
747 //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
748
749 Bool_t ok = kFALSE;
750 if ((nbtg > 0) &&
751 (nbfit >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
4f3bd513 752 //printf("nbtg %d, nbfit %d, nbE %d, nbfitSucess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
b3fcfd96 753 //printf("Pass the cut for VdriftT0\n");
754 // create the cal objects
01239968 755 calibra->RemoveOutliers(1,kFALSE);
756 calibra->PutMeanValueOtherVectorFit(1,kFALSE);
757 calibra->RemoveOutliers2(kFALSE);
758 calibra->PutMeanValueOtherVectorFit2(1,kFALSE);
759 //
b3fcfd96 760 TObjArray object = calibra->GetVectorFit();
761 AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object);
762 TH1F *coefVdriftPH = calDetVdrift->MakeHisto1DAsFunctionOfDet();
763 AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift);
764 TH1F *coefPadVdrift = calPadVdrift->MakeHisto1D();
765 object = calibra->GetVectorFit2();
766 AliTRDCalDet *calDetT0 = calibra->CreateDetObjectT0(&object);
767 TH1F *coefT0 = calDetT0->MakeHisto1DAsFunctionOfDet();
768 AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0);
769 TH1F *coefPadT0 = calPadT0->MakeHisto1D();
770 // Put them in the array
771 fCalibObjects->AddAt(calDetT0,kT0PHDet);
772 fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet);
773 fCalibObjects->AddAt(calPadT0,kT0PHPad);
774 fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad);
775 fPlots->AddAt(coefVdriftPH,kVdriftPHDet);
776 fPlots->AddAt(coefT0,kT0PHDet);
777 fPlots->AddAt(coefPadVdrift,kVdriftPHPad);
778 fPlots->AddAt(coefPadT0,kT0PHPad);
779 //
780 ok = kTRUE;
781 }
54f2ff1c 782 else {
840ec79d 783 //printf("Not enough stats timeoffset\n");
82b413fd 784 fStatusNeg = fStatusNeg | kTimeOffsetNotEnoughStatsNotFill;
54f2ff1c 785 }
b3fcfd96 786 calibra->ResetVectorFit();
787
788 return ok;
789
790}
00d203b6 791//____________________________________________________________________________________________________________________
b3fcfd96 792Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
793 //
794 // Analyze vdrift linear fit - produce the calibration objects
795 //
796
a5dcf618 797 //printf("Analyse linear fit\n");
798
f558cb62 799
b3fcfd96 800 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
840ec79d 801 calibra->SetCalDetVdriftExB(fCalDetVdriftUsed,fCalDetExBUsed);
a2a4ec8e 802 calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
4f3bd513 803 //printf("The mean stat is by %d for VdriftLinear\n",fMinStatsVdriftLinear);
67abca5c 804 //fAliTRDCalibraVdriftLinearFit->SetSeeDetector(0);
805 //fAliTRDCalibraVdriftLinearFit->SetDebugLevel(1);
a5dcf618 806 //printf("Fill PE Array\n");
2a1a7b36 807 fAliTRDCalibraVdriftLinearFit->SetRobustFit(fRobustFitDriftVelocity);
532be2d4 808 fAliTRDCalibraVdriftLinearFit->SetMinNumberOfPointsForFit(fMinNbOfPointVdriftFit);
661c7be6 809 if(!fAlternativeVdrfitFit)
810 fAliTRDCalibraVdriftLinearFit->FillPEArray();
811 else
812 fAliTRDCalibraVdriftLinearFit->FillPEArray2();
a5dcf618 813 //printf("AliTRDCalibraFit\n");
b3fcfd96 814 calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
a5dcf618 815 //printf("After\n");
b3fcfd96 816
817 //Int_t nbtg = 540;
818 Int_t nbfit = calibra->GetNumberFit();
819 Int_t nbE = calibra->GetNumberEnt();
820
821
822 Bool_t ok = kFALSE;
823 // enough statistics
824 if ((nbfit >= 0.5*nbE) && (nbE > 30)) {
825 // create the cal objects
01239968 826 //calibra->RemoveOutliers(1,kTRUE);
827 calibra->PutMeanValueOtherVectorFit(1,kTRUE);
828 //calibra->RemoveOutliers2(kTRUE);
829 calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
830 //
b3fcfd96 831 TObjArray object = calibra->GetVectorFit();
832 AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE);
833 TH1F *coefDriftLinear = calDetVdrift->MakeHisto1DAsFunctionOfDet();
834 object = calibra->GetVectorFit2();
835 AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
836 TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
eec29d56 837 //if(!calDetLorentz) printf("No lorentz created\n");
b3fcfd96 838 // Put them in the array
839 fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
840 fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
841 fPlots->AddAt(coefDriftLinear,kVdriftLinear);
842 fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
843 //
844 ok = kTRUE;
845 }
54f2ff1c 846 else {
847 fNotEnoughStatisticsForTheVdriftLinear = kTRUE;
dee5f636 848 Int_t minNumberOfEntriesForAll = fMinStatsVdriftLinear*30;
849 calibra->SetMinEntries(minNumberOfEntriesForAll); // Because we do it for all, we increase this
840ec79d 850 Double_t vdriftoverall = -100.0;
851 Double_t exboverall = 100.0;
852 calibra->AnalyseLinearFittersAllTogether(fAliTRDCalibraVdriftLinearFit,vdriftoverall,exboverall);
853 //printf("Found mean vdrift %f and exb %f\n",vdriftoverall,exboverall);
854 if(fCalDetVdriftUsed && (vdriftoverall > 0.0) && (exboverall < 70.0)) {
54f2ff1c 855 AliTRDCalDet *calDetVdrift = new AliTRDCalDet(*fCalDetVdriftUsed);
840ec79d 856 AliTRDCalDet *calDetLorentz = new AliTRDCalDet(*fCalDetExBUsed);
857 Double_t oldmeanvdrift = fCalDetVdriftUsed->CalcMean(kFALSE);
858 Double_t oldmeanexb = fCalDetExBUsed->CalcMean(kFALSE);
54f2ff1c 859 //printf("oldmean %f\n",oldmean);
840ec79d 860 if((oldmeanvdrift > 0.0) && (oldmeanexb < 70.0)) {
54f2ff1c 861 //printf("Correction factor %f\n",vdriftoverall);
840ec79d 862 calDetVdrift->Multiply(vdriftoverall/oldmeanvdrift);
a50946d4 863 if(TMath::Abs(oldmeanexb) > 0.0001) calDetLorentz->Multiply(exboverall/oldmeanexb);
54f2ff1c 864 //printf("newmean %f\n",calDetVdrift->CalcMean(kFALSE));
865 TH1F *coefDriftLinear = calDetVdrift->MakeHisto1DAsFunctionOfDet();
840ec79d 866 TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
54f2ff1c 867 // Put them in the array
868 fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
840ec79d 869 fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
54f2ff1c 870 fPlots->AddAt(coefDriftLinear,kVdriftLinear);
840ec79d 871 fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
54f2ff1c 872 //
873 ok = kTRUE;
82b413fd 874 fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsButFill;
54f2ff1c 875 }
82b413fd 876 else {
840ec79d 877 if(oldmeanvdrift) fStatusPos = fStatusPos | kVdriftErrorOld;
878 if(oldmeanexb) fStatusPos = fStatusPos | kExBErrorOld;
82b413fd 879 }
880 }
881 else {
840ec79d 882 if((vdriftoverall <= 0.0) && (exboverall > 70.0)) fStatusNeg = fStatusNeg | kVdriftNotEnoughStatsNotFill;
82b413fd 883 if(!fCalDetVdriftUsed) fStatusPos = fStatusPos | kVdriftErrorOld;
840ec79d 884 if(!fCalDetExBUsed) fStatusPos = fStatusPos | kExBErrorOld;
54f2ff1c 885 }
54f2ff1c 886 }
b3fcfd96 887
888 calibra->ResetVectorFit();
889
890 return ok;
891
892}
00d203b6 893//________________________________________________________________________________________________________________
b3fcfd96 894
a0bb5615 895Bool_t AliTRDPreprocessorOffline::AnalyzeExbAltFit(){
896 //
897 // Analyze vdrift linear fit - produce the calibration objects
898 //
899
900 //printf("Analyse linear fit\n");
901
902
903 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
904 calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
905 //printf("Fill PE Array\n");
2a1a7b36 906 fAliTRDCalibraExbAltFit->SetRobustFit(fRobustFitExbAlt);
661c7be6 907 if(!fAlternativeExbAltFit)
908 fAliTRDCalibraExbAltFit->FillPEArray();
909 else
910 fAliTRDCalibraExbAltFit->FillPEArray2();
a0bb5615 911 //printf("AliTRDCalibraFit\n");
912 calibra->AnalyseExbAltFit(fAliTRDCalibraExbAltFit);
913 //printf("After\n");
914
915 //Int_t nbtg = 540;
916 Int_t nbfit = calibra->GetNumberFit();
917 Int_t nbE = calibra->GetNumberEnt();
918
919
920 Bool_t ok = kFALSE;
921 // enough statistics
922 if ((nbfit >= 0.5*nbE) && (nbE > 30)) {
923 // create the cal objects
924 //calibra->RemoveOutliers(1,kTRUE);
925 calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
926 //
927 TObjArray object = calibra->GetVectorFit2();
928 AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectExbAlt(&object);
929 TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
930 //if(!calDetLorentz) printf("No lorentz created\n");
931 // Put them in the array
932 fCalibObjects->AddAt(calDetLorentz,kExbAlt);
933 fPlots->AddAt(coefLorentzAngle,kExbAlt);
934 //
935 ok = kTRUE;
936 }
937
938 calibra->ResetVectorFit();
939
940 return ok;
941
942}
943//________________________________________________________________________________________________________________
944
b3fcfd96 945Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
946 //
947 // Analyze PRF - produce the calibration objects
948 //
949
950 AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
a2a4ec8e 951 calibra->SetMinEntries(fMinStatsPRF); // If there is less than 1000 entries in the histo: no fit
b3fcfd96 952 calibra->AnalysePRFMarianFit(fPRF2d);
953
954 Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
955 + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
956 Int_t nbfit = calibra->GetNumberFit();
957 Int_t nbE = calibra->GetNumberEnt();
958
959
960 Bool_t ok = kFALSE;
961 // enough statistics
962 if ((nbtg > 0) &&
963 (nbfit >= 0.95*nbE) && (nbE > 30)) {
964 // create the cal objects
965 TObjArray object = calibra->GetVectorFit();
966 AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object);
967 TH1F *coefPRF = calPadPRF->MakeHisto1D();
968 // Put them in the array
969 fCalibObjects->AddAt(calPadPRF,kPRF);
970 fPlots->AddAt(coefPRF,kPRF);
971 //
972 ok = kTRUE;
973 }
974
975 calibra->ResetVectorFit();
976
977 return ok;
978
979}
a5dcf618 980
981//_____________________________________________________________________________
e2a1c98b 982Bool_t AliTRDPreprocessorOffline::AnalyzePHQ(Int_t startRunNumber)
983{
984 //
985 //Produce PHQ calibration results
986 //
687aa844 987 TList *lout = 0x0;
988 TTreeSRedirector *calibStream = 0x0;
989 if(IsDebugPHQon()){
990 lout = new TList;
991 lout->SetOwner();
992
993 calibStream = new TTreeSRedirector(Form("TRDCalibStream_%010d.root", startRunNumber));
994 }
995
6951a056 996 for(Int_t iter=0; iter<AliTRDdEdxCalibUtils::GetHistArray()->GetSize(); iter++){
997 THnBase *hi = (THnBase*) AliTRDdEdxCalibUtils::GetHistAt(iter);
687aa844 998 TObjArray *obji = AliTRDdEdxCalibUtils::HistToObj(hi, startRunNumber, lout, calibStream);
e2a1c98b 999 //printf("test analyze %s\n", obji->GetName());
6951a056 1000 AliTRDdEdxCalibUtils::GetObjArray()->AddAt(obji, iter);
e2a1c98b 1001 }
1002
6951a056 1003 fCalibObjects->AddAt(AliTRDdEdxCalibUtils::GetObjArray(), kPHQ);
687aa844 1004
1005 if(lout){
1006 TFile *fout=new TFile(Form("TRDCalibList_%010d.root", startRunNumber),"recreate");
1007 fout->cd();
1008 lout->Write();
1009 fout->Save();
1010 fout->Close();
1011 delete fout;
1012 }
1013 delete calibStream;
1014 delete lout;
1015
e2a1c98b 1016 return kTRUE;
1017}
1018
1019//_____________________________________________________________________________
a5dcf618 1020Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
1021{
4c865c34 1022 //
a5dcf618 1023 // Produce AliTRDCalChamberStatus out of calibration results
4c865c34 1024 //
b61b92a0 1025
83d0cc79 1026 // set up AliTRDCalibChamberStatus
92df0132 1027 AliTRDCalibChamberStatus *chamberStatus = new AliTRDCalibChamberStatus();
1028 chamberStatus->SetSparseI(fSparse);
1029 chamberStatus->AnalyseHisto(fMinStatsChamberStatus, fMinSingleStatsChamberStatus);
83d0cc79 1030 // get AliTRDCalChamberStatus
92df0132 1031 AliTRDCalChamberStatus *calChamberStatus = chamberStatus->GetCalChamberStatus();
01239968 1032
a5dcf618 1033 // get calibration objects
1034 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
1035 AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear);
840ec79d 1036 AliTRDCalDet *calDetExB = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear);
a5dcf618 1037
1038 // Check
92df0132 1039 if((!calDetGain) || (!calDetVDrift) || (!fCH2d) || (!calDetExB) || (!calChamberStatus)) return kFALSE;
a5dcf618 1040
1041 // Gain
83d0cc79 1042 Double_t gainmean = calDetGain->GetMean();
a5dcf618 1043 Double_t vdriftmean = calDetVDrift->GetMean();
83d0cc79 1044 Double_t exbmean = calDetExB->GetMean();
a5dcf618 1045
83d0cc79 1046 Double_t gainrms = calDetGain->GetRMSRobust();
1047 Double_t vdriftrms = calDetVDrift->GetRMSRobust();
1048 Double_t exbrms = calDetExB->GetRMSRobust();
a5dcf618 1049
1050 //printf("Gain mean: %f, rms: %f\n",gainmean,gainrms);
1051 //printf("Vdrift mean: %f, rms: %f\n",vdriftmean,vdriftrms);
840ec79d 1052 //printf("ExB mean: %f, rms: %f\n",exbmean,exbrms);
1053
a5dcf618 1054 // Check
840ec79d 1055 if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001) || (TMath::Abs(exbrms) < 0.0000001)) return kFALSE;
01239968 1056
67abca5c 1057 // Take mean each SM
1058 Double_t *gainmeanSM = new Double_t[18];
1059 Double_t *vdriftmeanSM = new Double_t[18];
1060 Double_t *exbmeanSM = new Double_t[18];
1061 //Double_t *t0meanSM = new Double_t[18];
1062 for(Int_t sm=0; sm< 18; sm++) {
1063 gainmeanSM[sm] = calDetGain->GetMeanSM(kFALSE,sm);
1064 vdriftmeanSM[sm] = calDetVDrift->GetMeanSM(kFALSE,sm);
1065 exbmeanSM[sm] = calDetExB->GetMeanSM(kFALSE,sm);
1066 //t0meanSM[sm] = calDetGain->GetMeanSM(kFALSE);
1067 }
1068
1069
a5dcf618 1070 // mask chambers with empty gain entries
1071 //Int_t counter = 0;
1072 for (Int_t idet = 0; idet < 540; idet++) {
01239968 1073
a5dcf618 1074 // ch2d
1075 TH1I *projch = (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e");
1076 Double_t entries = projch->GetEntries();
83d0cc79 1077 //printf("Number of entries %f for det %d\n",entries,idet);
4c865c34 1078
67abca5c 1079 // sm number
1080 Int_t smnumber = (Int_t) idet/30;
1081
a5dcf618 1082 // gain
1083 Double_t gain = calDetGain->GetValue(idet);
4c865c34 1084
a5dcf618 1085 // vdrift
1086 Double_t vdrift = calDetVDrift->GetValue(idet);
4c865c34 1087
840ec79d 1088 // exb
1089 Double_t exb = calDetExB->GetValue(idet);
1090
4c865c34 1091
92df0132 1092 if( (entries<50 && !calChamberStatus->IsNoData(idet)) ||
83d0cc79 1093 TMath::Abs(gainmean-gain) > (fRMSBadCalibratedGain*gainrms) ||
1094 TMath::Abs(vdriftmean-vdrift) > (fRMSBadCalibratedVdrift*vdriftrms) ||
1095 TMath::Abs(exbmean-exb) > (fRMSBadCalibratedExB*exbrms) ) {
a5dcf618 1096
1097 //printf(" chamber det %03d masked \n",idet);
1098 //printf(" gainmean %f and gain %f, gainrms %f \n",gainmean,gain,gainrms);
1099 //printf(" vdriftmean %f and vdrift %f, vdriftrms %f \n",vdriftmean,vdrift,vdriftrms);
840ec79d 1100 //printf(" exbmean %f and exb %f, exbrms %f \n",exbmean,exb,exbrms);
1101
92df0132 1102 calChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kBadCalibrated);
a5dcf618 1103 //counter++;
1104 }
4c865c34 1105
67abca5c 1106 if(TMath::Abs(gainmeanSM[smnumber]-gain) < 0.000001 ||
1107 TMath::Abs(vdriftmeanSM[smnumber]-vdrift) < 0.000001 ||
1108 TMath::Abs(exbmeanSM[smnumber]-exb) < 0.000001) {
1109
1110 //printf(" chamber det %03d notcalibrated sm %d \n",idet,smnumber);
1111 //printf(" gainmeanSM %f and gain %f\n",gainmeanSM[smnumber],gain);
1112 //printf(" vdriftmeanSM %f and vdrift %f \n",vdriftmeanSM[smnumber],vdrift);
1113 //printf(" exbmeanSM %f and exb %f \n",exbmeanSM[smnumber],exb);
1114
1115 calChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kNotCalibrated);
1116 }
1117
1118
b61b92a0 1119 delete projch;
1120
a5dcf618 1121 }
b3fcfd96 1122
83d0cc79 1123 // Security
1124 for(Int_t sm=0; sm < 18; sm++) {
1125 Int_t smnodata = 0;
1126 Int_t smbadcalib = 0;
1127 for(Int_t det = 0; det < 30; det++){
1128 Int_t detector = sm*30+det;
92df0132 1129 if(calChamberStatus->IsNoData(detector)) smnodata++;
83d0cc79 1130 else {
92df0132 1131 if(calChamberStatus->IsBadCalibrated(detector)) smbadcalib++;
83d0cc79 1132 }
1133 }
1134 fNoData[sm] = smnodata;
1135 fBadCalib[sm]= smbadcalib;
1136 //printf("No Data %d, bad calibrated %d for %d\n",fNoData[sm],fBadCalib[sm],sm);
1137 }
67abca5c 1138
1139 // delete
1140 delete []gainmeanSM;
1141 delete []vdriftmeanSM;
1142 delete []exbmeanSM;
83d0cc79 1143
1144 // Security
1145 // for(Int_t sm=0; sm < 18; sm++) {
1146 // Int_t counter = 0;
1147 // for(Int_t det = 0; det < 30; det++){
1148 // Int_t detector = sm*30+det;
92df0132 1149 // if(calChamberStatus->IsBadCalibrated(detector)) counter++;
83d0cc79 1150 // }
1151 // if(counter >= 20) {
1152 // for(Int_t det = 0; det < 30; det++){
1153 // Int_t detector = sm*30+det;
92df0132 1154 // calChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood);
83d0cc79 1155 // }
1156 // }
1157 // }
b3fcfd96 1158
92df0132 1159 fCalibObjects->AddAt(calChamberStatus,kChamberStatus);
a5dcf618 1160 return kTRUE;
b3fcfd96 1161
a5dcf618 1162 }
b3fcfd96 1163
b3fcfd96 1164
a5dcf618 1165 //________________________________________________________________________________________________
1166 void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
1167 //
1168 // Correct from the gas gain used afterwards
1169 //
1170 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
1171 if(!calDetGain) return;
b3fcfd96 1172
a5dcf618 1173 // Calculate mean
1174 Double_t mean = 0.0;
1175 Int_t nbdet = 0;
b3fcfd96 1176
a5dcf618 1177 for(Int_t det = 0; det < 540; det++) {
00d203b6 1178
a5dcf618 1179 Float_t gaininit = fCalDetGainUsed->GetValue(det);
1180 Float_t gainout = calDetGain->GetValue(det);
00d203b6 1181
00d203b6 1182
a5dcf618 1183 if(TMath::Abs(gainout-1.0) > 0.000001) {
1184 mean += (gaininit*gainout);
1185 nbdet++;
1186 }
1187 }
1188 if(nbdet > 0) mean = mean/nbdet;
00d203b6 1189
a5dcf618 1190 for(Int_t det = 0; det < 540; det++) {
00d203b6 1191
a5dcf618 1192 Float_t gaininit = fCalDetGainUsed->GetValue(det);
1193 Float_t gainout = calDetGain->GetValue(det);
1194
ba1aa7a7 1195 if(TMath::Abs(gainout-1.0) > 0.000001) {
1196 Double_t newgain = gaininit*gainout;
1197 if(newgain < 0.1) newgain = 0.1;
58e2b572 1198 if(newgain > 1.9) newgain = 1.9;
ba1aa7a7 1199 calDetGain->SetValue(det,newgain);
1200 }
1201 else {
1202 Double_t newgain = mean;
1203 if(newgain < 0.1) newgain = 0.1;
58e2b572 1204 if(newgain > 1.9) newgain = 1.9;
ba1aa7a7 1205 calDetGain->SetValue(det,newgain);
1206 }
a5dcf618 1207 }
1208
1209
1210 }
1211 //________________________________________________________________________________________________
1212 void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
1213 //
1214 // Correct from the drift velocity
1215 //
1216
1217 //printf("Correct for vdrift\n");
1218
1219 AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
1220 if(!calDetGain) return;
1221
1222 Int_t detVdrift = kVdriftPHDet;
1223 if(fMethodSecond) detVdrift = kVdriftLinear;
1224 AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
1225 if(!calDetVdrift) return;
1226
1227 // Calculate mean
8dac2af1 1228 if(!fNotEnoughStatisticsForTheVdriftLinear) {
54f2ff1c 1229 for(Int_t det = 0; det < 540; det++) {
1230
1231 Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
1232 Float_t vdriftout = calDetVdrift->GetValue(det);
1233
1234 Float_t gain = calDetGain->GetValue(det);
1235 if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
1236 if(gain < 0.1) gain = 0.1;
1237 if(gain > 1.9) gain = 1.9;
1238 calDetGain->SetValue(det,gain);
1239 }
a5dcf618 1240 }
54f2ff1c 1241 else {
1242
1243 Float_t vdriftinit = fCalDetVdriftUsed->CalcMean(kFALSE);
1244 Float_t vdriftout = calDetVdrift->CalcMean(kFALSE);
1245 Float_t factorcorrectif = 1.0;
1246 if(vdriftout > 0.0) factorcorrectif = vdriftinit/vdriftout;
1247 for(Int_t det = 0; det < 540; det++) {
1248 Float_t gain = calDetGain->GetValue(det);
1249 gain = gain*factorcorrectif;
1250 if(gain < 0.1) gain = 0.1;
1251 if(gain > 1.9) gain = 1.9;
1252 calDetGain->SetValue(det,gain);
1253 }
1254
1255 }
1256
a5dcf618 1257 }
54f2ff1c 1258//_________________________________________________________________________________________________________________
a9f9c69b 1259 void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage *storage){
a5dcf618 1260 //
1261 // Update OCDB entry
1262 //
1263
1264 AliCDBMetaData *metaData= new AliCDBMetaData();
1265 metaData->SetObjectClassName("AliTRDCalDet");
1266 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1267 metaData->AddDateToComment();
a5dcf618 1268 metaData->SetBeamPeriod(1);
1269
1270 AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
a5dcf618 1271 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
a9f9c69b 1272 if(calDet) storage->Put(calDet, id1, metaData);
a5dcf618 1273
1274
1275 }
1276 //___________________________________________________________________________________________________________________
a9f9c69b 1277 void AliTRDPreprocessorOffline::UpdateOCDBExB(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage *storage){
eec29d56 1278 //
1279 // Update OCDB entry
1280 //
1281
1282 Int_t detExB = kLorentzLinear;
1283 if(!fMethodSecond) return;
1284
1285 //printf("Pass\n");
1286
1287 AliCDBMetaData *metaData= new AliCDBMetaData();
1288 metaData->SetObjectClassName("AliTRDCalDet");
1289 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1290 metaData->AddDateToComment();
eec29d56 1291 metaData->SetBeamPeriod(1);
1292
1293 AliCDBId id1("TRD/Calib/ChamberExB", startRunNumber, endRunNumber);
eec29d56 1294 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
a9f9c69b 1295 if(calDet) storage->Put(calDet, id1, metaData);
eec29d56 1296 //if(!calDet) printf("No caldet\n");
1297
1298 }
a0bb5615 1299//___________________________________________________________________________________________________________________
a9f9c69b 1300void AliTRDPreprocessorOffline::UpdateOCDBExBAlt(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage *storage){
a0bb5615 1301 //
1302 // Update OCDB entry
1303 //
1304
1305 Int_t detExB = kExbAlt;
1306 if(!fMethodSecond) return;
1307
1308 //printf("Pass\n");
1309
1310 AliCDBMetaData *metaData= new AliCDBMetaData();
1311 metaData->SetObjectClassName("AliTRDCalDet");
58006729 1312 metaData->SetResponsible("Theo Rascanu");
1313 metaData->AddDateToComment();
a0bb5615 1314 metaData->SetBeamPeriod(1);
1315
1316 AliCDBId id1("TRD/Calib/ChamberExBAlt", startRunNumber, endRunNumber);
a0bb5615 1317 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detExB);
a9f9c69b 1318 if(calDet) storage->Put(calDet, id1, metaData);
a0bb5615 1319 //if(!calDet) printf("No caldet\n");
1320
1321}
eec29d56 1322 //___________________________________________________________________________________________________________________
a9f9c69b 1323 void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage){
a5dcf618 1324 //
1325 // Update OCDB entry
1326 //
1327
1328 Int_t detVdrift = kVdriftPHDet;
1329
1330 if(fMethodSecond) detVdrift = kVdriftLinear;
1331
1332 AliCDBMetaData *metaData= new AliCDBMetaData();
1333 metaData->SetObjectClassName("AliTRDCalDet");
1334 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1335 metaData->AddDateToComment();
a5dcf618 1336 metaData->SetBeamPeriod(1);
1337
1338 AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
a5dcf618 1339 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
a9f9c69b 1340 if(calDet) storage->Put(calDet, id1, metaData);
a5dcf618 1341
1342 //
1343
1344 if(!fMethodSecond) {
1345
1346 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
1347 metaDataPad->SetObjectClassName("AliTRDCalPad");
1348 metaDataPad->SetResponsible("Raphaelle Bailhache");
58006729 1349 metaDataPad->AddDateToComment();
a5dcf618 1350 metaDataPad->SetBeamPeriod(1);
1351
1352 AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
1353 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
a9f9c69b 1354 if(calPad) storage->Put(calPad, id1Pad, metaDataPad);
a5dcf618 1355
1356 }
1357
1358 }
1359 //________________________________________________________________________________________________________________________
a9f9c69b 1360 void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage){
a5dcf618 1361 //
1362 // Update OCDB entry
1363 //
1364
1365 AliCDBMetaData *metaData= new AliCDBMetaData();
1366 metaData->SetObjectClassName("AliTRDCalDet");
1367 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1368 metaData->AddDateToComment();
a5dcf618 1369 metaData->SetBeamPeriod(1);
1370
1371 AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
a5dcf618 1372 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
a9f9c69b 1373 if(calDet) storage->Put(calDet, id1, metaData);
a5dcf618 1374
1375 //
1376
1377 AliCDBMetaData *metaDataPad= new AliCDBMetaData();
1378 metaDataPad->SetObjectClassName("AliTRDCalPad");
1379 metaDataPad->SetResponsible("Raphaelle Bailhache");
58006729 1380 metaDataPad->AddDateToComment();
a5dcf618 1381 metaDataPad->SetBeamPeriod(1);
1382
1383 AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
1384 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
a9f9c69b 1385 if(calPad) storage->Put(calPad, id1Pad, metaDataPad);
a5dcf618 1386
1387
1388
1389 }
1390 //_________________________________________________________________________________________________________________
a9f9c69b 1391 void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage){
a5dcf618 1392 //
1393 // Update OCDB entry
1394 //
1395
1396 AliCDBMetaData *metaData= new AliCDBMetaData();
1397 metaData->SetObjectClassName("AliTRDCalPad");
1398 metaData->SetResponsible("Raphaelle Bailhache");
58006729 1399 metaData->AddDateToComment();
a5dcf618 1400 metaData->SetBeamPeriod(1);
1401
58006729 1402
a5dcf618 1403 AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
a5dcf618 1404 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
a9f9c69b 1405 if(calPad) storage->Put(calPad, id1, metaData);
a5dcf618 1406
1407
1408 }
e2a1c98b 1409//_________________________________________________________________________________________________________________
a9f9c69b 1410void AliTRDPreprocessorOffline::UpdateOCDBPHQ(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage)
e2a1c98b 1411{
1412 //
1413 // Update OCDB entry
1414 //
1415 AliCDBMetaData *metaData= new AliCDBMetaData();
1416 metaData->SetObjectClassName("TObjArray");
1417 metaData->SetResponsible("Raphaelle Bailhache and Xianguo Lu");
1418 metaData->AddDateToComment();
1419 metaData->SetBeamPeriod(1);
1420
1421 AliCDBId id1("TRD/Calib/PHQ", startRunNumber, endRunNumber);
e2a1c98b 1422 TObjArray *cobj = (TObjArray *) fCalibObjects->At(kPHQ);
1423 if(cobj){
1424 //cobj->Print();
a9f9c69b 1425 storage->Put(cobj, id1, metaData);
e2a1c98b 1426 }
1427}
1428
a5dcf618 1429 //_________________________________________________________________________________________________________________
a9f9c69b 1430 void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, AliCDBStorage* storage){
a5dcf618 1431 //
1432 // Update OCDB entry
1433 //
1434
1435 AliCDBMetaData *metaData= new AliCDBMetaData();
1436 metaData->SetObjectClassName("AliTRDCalChamberStatus");
58006729 1437 metaData->SetResponsible("Raphaelle Bailhache and Julian Book");
1438 metaData->AddDateToComment();
a5dcf618 1439 metaData->SetBeamPeriod(1);
1440
1441 AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber);
a5dcf618 1442 AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
a9f9c69b 1443 if(calChamberStatus) storage->Put(calChamberStatus, id1, metaData);
a5dcf618 1444
1445
1446 }
1447 //__________________________________________________________________________________________________________________________
54f2ff1c 1448 Bool_t AliTRDPreprocessorOffline::ValidateGain() {
a5dcf618 1449 //
1450 // Validate OCDB entry
1451 //
1452
1453 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
1454 if(calDet) {
1455 Double_t mean = calDet->GetMean();
1456 Double_t rms = calDet->GetRMSRobust();
1457 if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
1458 //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
54f2ff1c 1459 else {
82b413fd 1460 fStatusPos = fStatusPos | kGainErrorRange;
54f2ff1c 1461 return kFALSE;
1462 }
a5dcf618 1463 }
1464 else return kFALSE;
54f2ff1c 1465
a5dcf618 1466
1467
1468 }
1469 //__________________________________________________________________________________________________________________________
1470 Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
1471 //
1472 // Update OCDB entry
1473 //
1474
1475 Int_t detVdrift = kVdriftPHDet;
1476 Bool_t ok = kTRUE;
1477
1478 if(fMethodSecond) detVdrift = kVdriftLinear;
1479
1480 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
1481 if(calDet) {
1482 Double_t mean = calDet->GetMean();
1483 Double_t rms = calDet->GetRMSRobust();
1484 //printf("Vdrift::mean %f, rms %f\n",mean,rms);
54f2ff1c 1485 if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) {
82b413fd 1486 fStatusPos = fStatusPos | kVdriftErrorRange;
54f2ff1c 1487 ok = kFALSE;
1488 }
a5dcf618 1489 }
1490 else return kFALSE;
1491
1492 if(!fMethodSecond) {
1493 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
1494 if(calPad) {
1495 Double_t mean = calPad->GetMean();
1496 Double_t rms = calPad->GetRMS();
1497 //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
54f2ff1c 1498 if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) {
82b413fd 1499 fStatusPos = fStatusPos | kVdriftErrorRange;
54f2ff1c 1500 ok = kFALSE;
1501 }
a5dcf618 1502 }
1503 else return kFALSE;
1504 }
1505
1506 return ok;
1507
1508 }
1509 //__________________________________________________________________________________________________________________________
840ec79d 1510 Bool_t AliTRDPreprocessorOffline::ValidateExB(){
1511 //
1512 // Update OCDB entry
1513 //
1514
1515 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kLorentzLinear);
1516 if(calDet) {
1517 Double_t mean = calDet->GetMean();
1518 Double_t rms = calDet->GetRMSRobust();
1519 //printf("Vdrift::mean %f, rms %f\n",mean,rms);
1520 if(!((mean > -1.0) && (mean < 1.0) && (rms < 0.5))) {
1521 fStatusNeg = fStatusNeg | kExBErrorRange;
1522 return kFALSE;
1523 }
1524 else return kTRUE;
1525 }
1526 else return kFALSE;
1527
1528 }
1529 //__________________________________________________________________________________________________________________________
a5dcf618 1530 Bool_t AliTRDPreprocessorOffline::ValidateT0(){
1531 //
1532 // Update OCDB entry
1533 //
1534
1535 AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
1536 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
1537 if(calDet && calPad) {
1538 Double_t meandet = calDet->GetMean();
1539 Double_t rmsdet = calDet->GetRMSRobust();
1540 Double_t meanpad = calPad->GetMean();
1541 //Double_t rmspad = calPad->GetRMS();
4f3bd513 1542 printf("T0::meandet %f, rmsdet %f,meanpad %f\n",meandet,rmsdet,meanpad);
d82bad1e 1543 if((meandet > fMinTimeOffsetValidate) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
54f2ff1c 1544 else {
82b413fd 1545 fStatusPos = fStatusPos | kTimeOffsetErrorRange;
54f2ff1c 1546 return kFALSE;
1547 }
a5dcf618 1548 }
1549 else return kFALSE;
1550
1551 }
1552 //__________________________________________________________________________________________________________________________
1553 Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
1554 //
1555 // Update OCDB entry
1556 //
1557
1558 AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
1559 if(calPad) {
1560 Double_t meanpad = calPad->GetMean();
1561 Double_t rmspad = calPad->GetRMS();
1562 //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
1563 if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
1564 else return kFALSE;
1565 }
1566 else return kFALSE;
1567
1568
1569 }
1570 //__________________________________________________________________________________________________________________________
82b413fd 1571Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus(){
00d203b6 1572 //
1573 // Update OCDB entry
1574 //
1575
a5dcf618 1576 AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
1577 if(calChamberStatus) {
83d0cc79 1578
1579 Int_t detectornodata = 0;
1580 Int_t detectorbadcalib = 0;
1581
1582 for(Int_t sm=0; sm < 18; sm++) {
1583 //printf("%d chambers w/o data in sm %d\n",fNoData[sm],sm);
1584 //printf("%d bad calibrated chambers in sm %d\n",fBadCalib[sm],sm);
1585 if(fNoData[sm] != 30) detectornodata += fNoData[sm];
1586 detectorbadcalib+=fBadCalib[sm];
a5dcf618 1587 }
83d0cc79 1588 //printf("Number of chambers w/o data %d\n",detectornodata);
1589 //printf("Number of chambers bad calibrated %d\n",detectorbadcalib);
1590
1591 if((detectornodata > fNoDataValidate) ||
1592 (detectorbadcalib > fBadCalibValidate)){
82b413fd 1593 fStatusPos = fStatusPos | kChamberStatusErrorRange;
1594 return kFALSE;
1595 }
83d0cc79 1596 return kTRUE;
00d203b6 1597 }
1598 else return kFALSE;
83d0cc79 1599
00d203b6 1600}
4c865c34 1601//_____________________________________________________________________________
1602Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
1603{
1604 //
1605 // Get version from the title
1606 //
1607
1608 // Some patterns
1609 const Char_t *version = "Ver";
1610 if(!strstr(name.Data(),version)) return -1;
f558cb62 1611 const Char_t *after = "Subver";
1612 if(!strstr(name.Data(),after)) return -1;
1613
4c865c34 1614 for(Int_t ver = 0; ver < 999999999; ver++) {
1615
1616 TString vertry(version);
1617 vertry += ver;
f558cb62 1618 vertry += after;
4c865c34 1619
1620 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1621
1622 if(strstr(name.Data(),vertry.Data())) return ver;
1623
1624 }
1625
1626 return -1;
1627
1628}
1629
1630//_____________________________________________________________________________
1631Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
1632{
1633 //
1634 // Get subversion from the title
1635 //
1636
1637 // Some patterns
1638 const Char_t *subversion = "Subver";
1639 if(!strstr(name.Data(),subversion)) return -1;
f558cb62 1640 const Char_t *after = "FirstRun";
1641 if(!strstr(name.Data(),after)) {
1642 after = "Nz";
1643 }
1644 if(!strstr(name.Data(),after)) return -1;
1645
4c865c34 1646
1647 for(Int_t ver = 0; ver < 999999999; ver++) {
1648
1649 TString vertry(subversion);
1650 vertry += ver;
f558cb62 1651 vertry += after;
ca7e6e64 1652
1653 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1654
1655 if(strstr(name.Data(),vertry.Data())) return ver;
1656
1657 }
1658
1659 return -1;
1660
1661}
1662
1663//_____________________________________________________________________________
1664Int_t AliTRDPreprocessorOffline::GetFirstRun(TString name) const
1665{
1666 //
1667 // Get first run from the title
1668 //
1669
1670 // Some patterns
1671 const Char_t *firstrun = "FirstRun";
1672 if(!strstr(name.Data(),firstrun)) return -1;
f558cb62 1673 const Char_t *after = "Nz";
1674 if(!strstr(name.Data(),after)) return -1;
1675
ca7e6e64 1676
1677 for(Int_t ver = 0; ver < 999999999; ver++) {
1678
1679 TString vertry(firstrun);
1680 vertry += ver;
f558cb62 1681 vertry += after;
4c865c34 1682
1683 //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
1684
1685 if(strstr(name.Data(),vertry.Data())) return ver;
1686
1687 }
1688
1689 return -1;
1690
1691}
82b413fd 1692//_____________________________________________________________________________
1693Bool_t AliTRDPreprocessorOffline::CheckStatus(Int_t status, Int_t bitMask) const
1694{
1695 //
1696 // Checks the status
1697 //
1698
1699 return (status & bitMask) ? kTRUE : kFALSE;
1700
1701}
1702//_____________________________________________________________________________
1703Int_t AliTRDPreprocessorOffline::GetStatus() const
1704{
1705 //
1706 // Checks the status
1707 // fStatusPos: errors
1708 // fStatusNeg: only info
1709 //
1710
1711 if(fStatusPos > 0) return fStatusPos;
1712 else return (-TMath::Abs(fStatusNeg));
1713
1714}
1715//_____________________________________________________________________________
1716void AliTRDPreprocessorOffline::PrintStatus() const
1717{
1718 //
1719 // Do Summary
1720 //
1721
1722 AliInfo(Form("The error status is %d",fStatusPos));
1723 AliInfo(Form("IsGainErrorOld? %d",(Int_t)IsGainErrorOld()));
1724 AliInfo(Form("IsVdriftErrorOld? %d",(Int_t)IsVdriftErrorOld()));
1725 AliInfo(Form("IsGainErrorRange? %d",(Int_t)IsGainErrorRange()));
1726 AliInfo(Form("IsVdriftErrorRange? %d",(Int_t)IsVdriftErrorRange()));
1727 AliInfo(Form("IsTimeOffsetErrorRange? %d",(Int_t)IsTimeOffsetErrorRange()));
1728 AliInfo(Form("IsChamberStatusErrorRange? %d",(Int_t)IsChamberStatusErrorRange()));
1729
1730
1731 AliInfo(Form("The info status is %d",fStatusNeg));
1732 AliInfo(Form("IsGainNotEnoughStatsButFill? %d",(Int_t)IsGainNotEnoughStatsButFill()));
1733 AliInfo(Form("IsVdriftNotEnoughStatsButFill? %d",(Int_t)IsVdriftNotEnoughStatsButFill()));
1734 AliInfo(Form("IsGainNotEnoughStatsNotFill? %d",(Int_t)IsGainNotEnoughStatsNotFill()));
1735 AliInfo(Form("IsVdriftNotEnoughStatsNotFill? %d",(Int_t)IsVdriftNotEnoughStatsNotFill()));
1736 AliInfo(Form("IsTimeOffsetNotEnoughStatsNotFill? %d",(Int_t)IsTimeOffsetNotEnoughStatsNotFill()));
840ec79d 1737
1738 AliInfo(Form("IsExBErrorRange? %d",(Int_t)IsExBErrorRange()));
1739 AliInfo(Form("IsExBErrorOld? %d",(Int_t)IsExBErrorOld()));
82b413fd 1740
1741}
840ec79d 1742//___________________________________________________________________________________
1743void AliTRDPreprocessorOffline::SetCalDetVdrift(AliTRDCalDet *calDetVdriftUsed)
1744{
1745
1746 fCalDetVdriftUsed = calDetVdriftUsed;
1747
1748 fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1749 for(Int_t k = 0; k < 540; k++){
1750 fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1751 //printf("Set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1752 }
1753
1754};
83d0cc79 1755//___________________________________________________________________________________
1756Bool_t AliTRDPreprocessorOffline::SetCalDetGain(Int_t runNumber, Int_t version, Int_t subversion)
1757{
1758 //
1759 // Set the fCalDetGainUsed
1760 //
1761
1762 if((version == 0) && (subversion == 0)) return kFALSE;
82b413fd 1763
83d0cc79 1764 AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor",runNumber, version, subversion);
1765 if(!entry) {
1766 AliError("Found no entry\n");
1767 fStatusPos = fStatusPos | kGainErrorOld;
1768 return kFALSE;
1769 }
1770 //const AliCDBId id = entry->GetId();
1771 //version = id.GetVersion();
1772 //subversion = id.GetSubVersion();
1773 //printf("Found version %d and subversion %d for vdrift\n",version,subversion);
1774 AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject();
1775 if(calDet) fCalDetGainUsed = calDet;
1776 else {
1777 fStatusPos = fStatusPos | kGainErrorOld;
1778 return kFALSE;
1779 }
1780
1781 return kTRUE;
1782
1783}
1784//___________________________________________________________________________________
1785Bool_t AliTRDPreprocessorOffline::SetCalDetVdriftExB(Int_t runNumber, Int_t versionv, Int_t subversionv, Int_t versionexb, Int_t subversionexb)
1786{
1787 //
1788 // Set the fCalDetVdriftUsed and fCalDetExBUsed
1789 //
1790
1791 if((versionv == 0) && (subversionv == 0)) return kFALSE;
1792
1793 AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberVdrift",runNumber, versionv, subversionv);
1794 if(!entry) {
1795 AliError("Found no entry\n");
1796 fStatusPos = fStatusPos | kVdriftErrorOld;
1797 return kFALSE;
1798 }
1799 AliTRDCalDet* calDet = (AliTRDCalDet *)entry->GetObject();
1800 if(calDet) fCalDetVdriftUsed = calDet;
1801 else {
1802 fStatusPos = fStatusPos | kVdriftErrorOld;
1803 return kFALSE;
1804 }
1805
1806 // ExB object
1807
1808 if((versionexb == 0) && (subversionexb == 0)) {
1809
1810 fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1811 for(Int_t k = 0; k < 540; k++){
1812 fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1813 //printf("Nothing found: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1814 }
1815 }
1816 else {
1817
1818 entry = 0x0;
1819 entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberExB",runNumber, versionexb, subversionexb);
1820 if(!entry) {
1821 //printf("Found no entry\n");
1822 fStatusPos = fStatusPos | kExBErrorOld;
1823 return kFALSE;
1824 }
1825 AliTRDCalDet* calDetexb = (AliTRDCalDet *)entry->GetObject();
1826 if(!calDetexb) {
1827 fStatusPos = fStatusPos | kExBErrorOld;
1828 return kFALSE;
1829 }
1830
1831 Double_t meanexb = calDetexb->GetMean();
1832 //printf("Mean value %f\n",meanexb);
1833 if((meanexb > 70) || (fNoExBUsedInReco)) {
1834 fCalDetExBUsed = new AliTRDCalDet("lorentz angle tan","lorentz angle tan (detector value)");
1835 for(Int_t k = 0; k < 540; k++){
1836 fCalDetExBUsed->SetValue(k,AliTRDCommonParam::Instance()->GetOmegaTau(fCalDetVdriftUsed->GetValue(k)));
1837 //printf("Found but: set the exb object for detector %d, vdrift %f and exb %f\n",k,fCalDetVdriftUsed->GetValue(k),fCalDetExBUsed->GetValue(k));
1838 }
1839 }
1840 else {
1841 fCalDetExBUsed = calDetexb;
1842 }
1843
1844 }
1845
1846
1847 return kTRUE;
1848
1849}
01239968 1850