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