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