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