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