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