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