Take automaticaly the gain factors used during the reconstruction
[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 "TProfile2D.h"
50 #include "AliTRDCalDet.h"
51 #include "AliTRDCalPad.h"
52 #include "AliCDBMetaData.h"
53 #include "AliCDBId.h"
54 #include "AliCDBManager.h"
55 #include "AliCDBStorage.h"
56 #include "AliTRDCalibraMode.h"
57 #include "AliTRDCalibraFit.h"
58 #include "AliTRDCalibraVdriftLinearFit.h"
59 #include "AliTRDPreprocessorOffline.h"
60
61
62 ClassImp(AliTRDPreprocessorOffline)
63
64 AliTRDPreprocessorOffline::AliTRDPreprocessorOffline():
65   TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"),
66   fMethodSecond(kTRUE),
67   fNameList("TRDCalib"),
68   fCalDetGainUsed(0x0),
69   fCalDetVdriftUsed(0x0),
70   fCH2d(0x0),
71   fPH2d(0x0),
72   fPRF2d(0x0),
73   fAliTRDCalibraVdriftLinearFit(0x0),
74   fNEvents(0x0),
75   fAbsoluteGain(0x0),
76   fPlots(new TObjArray(8)),
77   fCalibObjects(new TObjArray(8)),
78   fVersionGainUsed(0),
79   fSubVersionGainUsed(0),
80   fVersionVdriftUsed(0), 
81   fSubVersionVdriftUsed(0),
82   fSwitchOnValidation(kTRUE),
83   fVdriftValidated(kFALSE),
84   fT0Validated(kFALSE),
85   fMinStatsVdriftT0PH(800*20),
86   fMinStatsVdriftLinear(800),
87   fMinStatsGain(800),
88   fMinStatsPRF(600)
89 {
90   //
91   // default constructor
92   //
93 }
94 //_________________________________________________________________________________________________________________
95 AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() {
96   //
97   // Destructor
98   //
99
100   if(fCalDetGainUsed) delete fCalDetGainUsed;
101   if(fCalDetVdriftUsed) delete fCalDetVdriftUsed;
102   if(fCH2d) delete fCH2d;
103   if(fPH2d) delete fPH2d;
104   if(fPRF2d) delete fPRF2d;
105   if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit;
106   if(fNEvents) delete fNEvents;
107   if(fAbsoluteGain) delete fAbsoluteGain;
108   if(fPlots) delete fPlots;
109   if(fCalibObjects) delete fCalibObjects;
110   
111 }
112 //___________________________________________________________________________________________________________________
113
114 void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
115   //
116   // make calibration of the drift velocity
117   // Input parameters:
118   //      file                             - the location of input file
119   //      startRunNumber, endRunNumber     - run validity period 
120   //      ocdbStorage                      - path to the OCDB storage
121   //                                       - if empty - local storage 'pwd' uesed
122   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
123   //
124   // 1. Initialization 
125   //
126   fVdriftValidated = kTRUE;
127   fT0Validated = kTRUE;
128   //
129   // 2. extraction of the information
130   //
131   if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
132   if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit();
133   //
134   // 3. Append QA plots
135   //
136   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
137   //
138   //
139   // 4. validate OCDB entries
140   //
141   if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) { 
142     AliError("TRD vdrift OCDB parameters out of range!");
143     fVdriftValidated = kFALSE;
144   }
145   if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) { 
146     AliError("TRD t0 OCDB parameters out of range!");
147     fT0Validated = kFALSE;
148   }
149   //
150   // 5. update of OCDB
151   //
152   //
153   if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage);
154   if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage);
155   
156 }
157 //_________________________________________________________________________________________________________________
158
159 void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
160   //
161   // make calibration of the drift velocity
162   // Input parameters:
163   //      file                             - the location of input file
164   //      startRunNumber, endRunNumber     - run validity period 
165   //      ocdbStorage                      - path to the OCDB storage
166   //                                       - if empty - local storage 'pwd' uesed
167   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
168   //
169   // 1. Initialization 
170   if(!ReadGainGlobal(file)) return;
171   //
172   //
173   // 2. extraction of the information
174   //
175   AnalyzeGain();
176   if(fCalDetGainUsed) CorrectFromDetGainUsed();
177   if(fCalDetVdriftUsed) CorrectFromDetVdriftUsed();
178   //
179   // 3. Append QA plots
180   //
181   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
182   //
183   //
184   // 4. validate OCDB entries
185   //
186   if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) { 
187     AliError("TRD gain OCDB parameters out of range!");
188     return;
189   }
190   //
191   // 5. update of OCDB
192   //
193   //
194   if((!fCalDetVdriftUsed) || (fCalDetVdriftUsed && fVdriftValidated)) UpdateOCDBGain(startRunNumber,endRunNumber,ocdbStorage);
195   
196   
197 }
198 //________________________________________________________________________________________________________________
199
200 void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
201   //
202   // make calibration of the drift velocity
203   // Input parameters:
204   //      file                             - the location of input file
205   //      startRunNumber, endRunNumber     - run validity period 
206   //      ocdbStorage                      - path to the OCDB storage
207   //                                       - if empty - local storage 'pwd' uesed
208   if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
209   //
210   // 1. Initialization 
211   if(!ReadPRFGlobal(file)) return;
212   //
213   //
214   // 2. extraction of the information
215   //
216   AnalyzePRF();
217   //
218   // 3. Append QA plots
219   //
220   //MakeDefaultPlots(fVdriftArray,fVdriftArray);
221   //
222   //
223   //
224   // 4. validate OCDB entries
225   //
226   if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) { 
227     AliError("TRD prf OCDB parameters out of range!");
228     return;
229   }
230   //
231   // 5. update of OCDB
232   //
233   //
234   UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage);
235   
236 }
237 //______________________________________________________________________________________________________
238 Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
239   //
240   // read the calibration used during the reconstruction
241   // 
242
243   if(ReadVdriftT0Global(fileName)) {
244     
245     TString nameph = fPH2d->GetTitle();
246     fVersionVdriftUsed = GetVersion(nameph);  
247     fSubVersionVdriftUsed = GetSubVersion(nameph);    
248
249     //printf("Found Version %d, Subversion %d for vdrift\n",fVersionVdriftUsed,fSubVersionVdriftUsed);
250   
251   }
252
253   if(ReadGainGlobal(fileName)) {
254
255     TString namech = fCH2d->GetTitle();
256     fVersionGainUsed = GetVersion(namech);  
257     fSubVersionGainUsed = GetSubVersion(namech);    
258
259     //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed);
260
261   }
262    
263   return kTRUE;
264   
265 }
266 //___________________________________________________________________________________________________________________
267
268 Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){
269   //
270   // read calibration entries from file
271   // 
272   if(fCH2d) return kTRUE;
273   TFile fcalib(fileName);
274   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
275   if (array){
276     TH2I *ch2d = (TH2I *) array->FindObject("CH2d");
277     if(!ch2d) return kFALSE;
278     fCH2d = (TH2I*)ch2d->Clone();
279     //fNEvents = (TH1I *) array->FindObject("NEvents");
280     //fAbsoluteGain = (TH2F *) array->FindObject("AbsoluteGain");
281   }else{
282     TH2I *ch2d = (TH2I *) fcalib.Get("CH2d");
283     if(!ch2d) return kFALSE;
284     fCH2d = (TH2I*)ch2d->Clone();
285     //fNEvents = (TH1I *) fcalib.Get("NEvents");
286     //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain");
287   }
288   fCH2d->SetDirectory(0);
289   //printf("title of CH2d %s\n",fCH2d->GetTitle());
290
291   return kTRUE;
292   
293 }
294 //_________________________________________________________________________________________________________________
295
296 Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){
297   //
298   // read calibration entries from file
299   // 
300   if(fPH2d) return kTRUE;
301   TFile fcalib(fileName);
302   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
303   if (array){
304     TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d");
305     if(!ph2d) return kFALSE;
306     fPH2d = (TProfile2D*)ph2d->Clone();
307     //fNEvents = (TH1I *) array->FindObject("NEvents");
308   }else{
309     TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d");
310     if(!ph2d) return kFALSE;
311     fPH2d = (TProfile2D*)ph2d->Clone();
312     //fNEvents = (TH1I *) fcalib.Get("NEvents");
313   }
314   fPH2d->SetDirectory(0);
315   //printf("title of PH2d %s\n",fPH2d->GetTitle());
316   
317   return kTRUE;
318   
319 }
320 //___________________________________________________________________________________________________________________
321
322 Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){
323   //
324   // read calibration entries from file
325   // 
326   if(fAliTRDCalibraVdriftLinearFit) return kTRUE;
327   TFile fcalib(fileName);
328   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
329   if (array){
330     fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit");
331     //fNEvents = (TH1I *) array->FindObject("NEvents");
332   }else{
333     fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit");
334     //fNEvents = (TH1I *) fcalib.Get("NEvents");
335   }
336   if(!fAliTRDCalibraVdriftLinearFit) {
337     //printf("No AliTRDCalibraVdriftLinearFit\n");
338     return kFALSE;
339   }
340   return kTRUE;
341   
342 }
343 //_____________________________________________________________________________________________________________
344
345 Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){
346   //
347   // read calibration entries from file
348   // 
349   if(fPRF2d) return kTRUE;
350   TFile fcalib(fileName);
351   TObjArray * array = (TObjArray*)fcalib.Get(fNameList);
352   if (array){
353     TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d");
354     if(!prf2d) return kFALSE;
355     fPRF2d = (TProfile2D*)prf2d->Clone();
356     //fNEvents = (TH1I *) array->FindObject("NEvents");
357   }else{
358     TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d");
359     if(!prf2d) return kFALSE;
360     fPRF2d = (TProfile2D*)prf2d->Clone();
361     //fNEvents = (TH1I *) fcalib.Get("NEvents");
362   }
363   fPRF2d->SetDirectory(0);
364   //printf("title of PRF2d %s\n",fPRF2d->GetTitle());
365   
366   return kTRUE;
367
368 }
369 //__________________________________________________________________________________________________________
370
371 Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){
372   //
373   // Analyze gain - produce the calibration objects
374   //
375
376   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
377   calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit
378   calibra->AnalyseCH(fCH2d);
379
380   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
381     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
382   Int_t nbfit       = calibra->GetNumberFit();
383   Int_t nbE         = calibra->GetNumberEnt();
384
385
386   Bool_t ok = kFALSE;
387   Bool_t meanother = kFALSE;
388   // enough statistics
389   if ((nbtg >                  0) && 
390       (nbfit        >= 0.5*nbE) && (nbE > 30)) {
391     // create the cal objects
392     if(!fCalDetGainUsed) {
393       calibra->PutMeanValueOtherVectorFit(1,kTRUE);
394       meanother = kTRUE;
395     }
396     TObjArray object           = calibra->GetVectorFit();
397     AliTRDCalDet *calDetGain   = calibra->CreateDetObjectGain(&object,meanother);
398     TH1F *coefGain  = calDetGain->MakeHisto1DAsFunctionOfDet();
399     // Put them in the array
400     fCalibObjects->AddAt(calDetGain,kGain);
401     fPlots->AddAt(coefGain,kGain);
402     //
403     ok = kTRUE;
404   }
405   
406   calibra->ResetVectorFit();
407   
408   return ok;
409   
410 }
411 //_____________________________________________________________________________________________________
412 Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){
413   //
414   // Analyze VdriftT0 - produce the calibration objects
415   //
416
417   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
418   calibra->SetMinEntries(fMinStatsVdriftT0PH); // If there is less than 1000 entries in the histo: no fit
419   calibra->AnalysePH(fPH2d);
420
421   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
422     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
423   Int_t nbfit       = calibra->GetNumberFit();
424   Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
425   Int_t nbE         = calibra->GetNumberEnt();
426
427   //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess);
428
429   Bool_t ok = kFALSE;
430   if ((nbtg >                  0) && 
431       (nbfit        >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
432     //printf("Pass the cut for VdriftT0\n");
433     // create the cal objects
434     calibra->RemoveOutliers(1,kFALSE);
435     calibra->PutMeanValueOtherVectorFit(1,kFALSE);
436     calibra->RemoveOutliers2(kFALSE);
437     calibra->PutMeanValueOtherVectorFit2(1,kFALSE);
438     //
439     TObjArray object = calibra->GetVectorFit();
440     AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object);
441     TH1F *coefVdriftPH  = calDetVdrift->MakeHisto1DAsFunctionOfDet();
442     AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift);
443     TH1F *coefPadVdrift   = calPadVdrift->MakeHisto1D();
444     object       = calibra->GetVectorFit2();
445     AliTRDCalDet *calDetT0  = calibra->CreateDetObjectT0(&object);
446     TH1F *coefT0  = calDetT0->MakeHisto1DAsFunctionOfDet();
447     AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0);
448     TH1F *coefPadT0  = calPadT0->MakeHisto1D();
449     // Put them in the array
450     fCalibObjects->AddAt(calDetT0,kT0PHDet);
451     fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet);
452     fCalibObjects->AddAt(calPadT0,kT0PHPad);
453     fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad);
454     fPlots->AddAt(coefVdriftPH,kVdriftPHDet);
455     fPlots->AddAt(coefT0,kT0PHDet);
456     fPlots->AddAt(coefPadVdrift,kVdriftPHPad);
457     fPlots->AddAt(coefPadT0,kT0PHPad);
458     //
459     ok = kTRUE;
460   }
461   calibra->ResetVectorFit();
462  
463   return ok;
464   
465 }
466 //____________________________________________________________________________________________________________________
467 Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
468   //
469   // Analyze vdrift linear fit - produce the calibration objects
470   //
471
472   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
473   calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
474   fAliTRDCalibraVdriftLinearFit->FillPEArray();
475   calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
476
477   //Int_t nbtg        = 540;
478   Int_t nbfit       = calibra->GetNumberFit();
479   Int_t nbE         = calibra->GetNumberEnt();
480
481   
482   Bool_t ok = kFALSE;
483   // enough statistics
484   if ((nbfit        >= 0.5*nbE) && (nbE > 30)) {
485     // create the cal objects
486     //calibra->RemoveOutliers(1,kTRUE);
487     calibra->PutMeanValueOtherVectorFit(1,kTRUE);
488     //calibra->RemoveOutliers2(kTRUE);
489     calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
490     //
491     TObjArray object  = calibra->GetVectorFit();
492     AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE);
493     TH1F *coefDriftLinear      = calDetVdrift->MakeHisto1DAsFunctionOfDet();
494     object                     = calibra->GetVectorFit2();
495     AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object);
496     TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet();
497     // Put them in the array
498     fCalibObjects->AddAt(calDetVdrift,kVdriftLinear);
499     fCalibObjects->AddAt(calDetLorentz,kLorentzLinear);
500     fPlots->AddAt(coefDriftLinear,kVdriftLinear);
501     fPlots->AddAt(coefLorentzAngle,kLorentzLinear);
502     //
503     ok = kTRUE;
504   }
505   
506   calibra->ResetVectorFit();
507   
508   return ok;
509   
510 }
511 //________________________________________________________________________________________________________________
512
513 Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
514   //
515   // Analyze PRF - produce the calibration objects
516   //
517
518   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
519   calibra->SetMinEntries(fMinStatsPRF); // If there is less than 1000 entries in the histo: no fit
520   calibra->AnalysePRFMarianFit(fPRF2d);
521
522   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
523     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
524   Int_t nbfit       = calibra->GetNumberFit();
525   Int_t nbE         = calibra->GetNumberEnt();
526
527   
528   Bool_t ok = kFALSE;
529   // enough statistics
530   if ((nbtg >                  0) && 
531       (nbfit        >= 0.95*nbE) && (nbE > 30)) {
532     // create the cal objects
533     TObjArray object  = calibra->GetVectorFit();
534     AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object);
535     TH1F *coefPRF           = calPadPRF->MakeHisto1D();
536     // Put them in the array
537     fCalibObjects->AddAt(calPadPRF,kPRF);
538     fPlots->AddAt(coefPRF,kPRF);
539     //
540     ok = kTRUE;
541   }
542   
543   calibra->ResetVectorFit();
544   
545   return ok;
546   
547 }
548 //________________________________________________________________________________________________
549 void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
550   //
551   // Correct from the gas gain used afterwards
552   //
553   AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
554   if(!calDetGain) return;
555
556   // Calculate mean
557   Double_t mean = 0.0;
558   Int_t nbdet = 0;
559   
560   for(Int_t det = 0; det < 540; det++) {
561     
562     Float_t gaininit = fCalDetGainUsed->GetValue(det);
563     Float_t gainout = calDetGain->GetValue(det);
564
565    
566     if(TMath::Abs(gainout-1.0) > 0.000001) {
567       mean += (gaininit*gainout);
568       nbdet++;
569     }  
570   }
571   if(nbdet > 0) mean = mean/nbdet;
572    
573   for(Int_t det = 0; det < 540; det++) {
574     
575     Float_t gaininit = fCalDetGainUsed->GetValue(det);
576     Float_t gainout = calDetGain->GetValue(det);
577   
578     if(TMath::Abs(gainout-1.0) > 0.000001) calDetGain->SetValue(det,gaininit*gainout);
579     else calDetGain->SetValue(det,mean);
580   }
581
582
583 }
584 //________________________________________________________________________________________________
585 void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
586   //
587   // Correct from the drift velocity
588   //
589
590   //printf("Correct for vdrift\n");
591
592   AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
593   if(!calDetGain) return;
594
595   Int_t detVdrift = kVdriftPHDet;
596   if(fMethodSecond) detVdrift = kVdriftLinear;
597   AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
598   if(!calDetVdrift) return;
599
600   // Calculate mean
601   
602   for(Int_t det = 0; det < 540; det++) {
603     
604     Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
605     Float_t vdriftout = calDetVdrift->GetValue(det);
606
607     Float_t gain = calDetGain->GetValue(det);
608     if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
609     calDetGain->SetValue(det,gain);
610
611     
612   }
613  
614 }
615 //_________________________________________________________________________________________________________________
616 void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
617   //
618   // Update OCDB entry
619   //
620   
621   AliCDBMetaData *metaData= new AliCDBMetaData();
622   metaData->SetObjectClassName("AliTRDCalDet");
623   metaData->SetResponsible("Raphaelle Bailhache");
624   metaData->SetBeamPeriod(1);
625   
626   AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
627   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
628   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
629   if(calDet) gStorage->Put(calDet, id1, metaData);
630     
631
632 }
633 //___________________________________________________________________________________________________________________
634 void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
635   //
636   // Update OCDB entry
637   //
638
639   Int_t detVdrift = kVdriftPHDet;
640   
641   if(fMethodSecond) detVdrift = kVdriftLinear;
642   
643   AliCDBMetaData *metaData= new AliCDBMetaData();
644   metaData->SetObjectClassName("AliTRDCalDet");
645   metaData->SetResponsible("Raphaelle Bailhache");
646   metaData->SetBeamPeriod(1);
647   
648   AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
649   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
650   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
651   if(calDet) gStorage->Put(calDet, id1, metaData);
652   
653   //
654
655   if(!fMethodSecond) {
656     
657     AliCDBMetaData *metaDataPad= new AliCDBMetaData();
658     metaDataPad->SetObjectClassName("AliTRDCalPad");
659     metaDataPad->SetResponsible("Raphaelle Bailhache");
660     metaDataPad->SetBeamPeriod(1);
661     
662     AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
663     AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
664     if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
665      
666   }
667
668 }
669 //________________________________________________________________________________________________________________________
670 void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
671   //
672   // Update OCDB entry
673   //
674   
675   AliCDBMetaData *metaData= new AliCDBMetaData();
676   metaData->SetObjectClassName("AliTRDCalDet");
677   metaData->SetResponsible("Raphaelle Bailhache");
678   metaData->SetBeamPeriod(1);
679   
680   AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
681   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
682   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
683   if(calDet) gStorage->Put(calDet, id1, metaData);
684  
685   //
686
687   AliCDBMetaData *metaDataPad= new AliCDBMetaData();
688   metaDataPad->SetObjectClassName("AliTRDCalPad");
689   metaDataPad->SetResponsible("Raphaelle Bailhache");
690   metaDataPad->SetBeamPeriod(1);
691   
692   AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
693   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
694   if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
695  
696
697
698 }
699 //_________________________________________________________________________________________________________________
700 void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
701   //
702   // Update OCDB entry
703   //
704   
705   AliCDBMetaData *metaData= new AliCDBMetaData();
706   metaData->SetObjectClassName("AliTRDCalPad");
707   metaData->SetResponsible("Raphaelle Bailhache");
708   metaData->SetBeamPeriod(1);
709   
710   AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
711   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
712   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
713   if(calPad) gStorage->Put(calPad, id1, metaData);
714  
715
716 }
717 //__________________________________________________________________________________________________________________________
718 Bool_t AliTRDPreprocessorOffline::ValidateGain() const {
719   //
720   // Validate OCDB entry
721   //
722
723   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
724   if(calDet) {
725     Double_t mean = calDet->GetMean();
726     Double_t rms = calDet->GetRMS();
727     if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
728     else return kFALSE;
729   }
730   else return kFALSE;
731     
732
733 }
734 //__________________________________________________________________________________________________________________________
735 Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
736   //
737   // Update OCDB entry
738   //
739
740   Int_t detVdrift = kVdriftPHDet;
741   Bool_t ok = kTRUE;
742   
743   if(fMethodSecond) detVdrift = kVdriftLinear;
744   
745   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
746   if(calDet) {
747     Double_t mean = calDet->GetMean();
748     Double_t rms = calDet->GetRMS();
749     //printf("Vdrift::mean %f, rms %f\n",mean,rms);
750     if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE;
751   }
752   else return kFALSE; 
753
754   if(!fMethodSecond) {
755     AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
756     if(calPad) {
757       Double_t mean = calPad->GetMean();
758       Double_t rms = calPad->GetRMS();
759       //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
760       if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE;
761     }
762     else return kFALSE;
763   }
764
765   return ok;
766
767 }
768 //__________________________________________________________________________________________________________________________
769 Bool_t AliTRDPreprocessorOffline::ValidateT0(){
770   //
771   // Update OCDB entry
772   //
773   
774   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
775   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
776   if(calDet && calPad) {
777     Double_t meandet = calDet->GetMean();
778     Double_t rmsdet = calDet->GetRMS();
779     Double_t meanpad = calPad->GetMean();
780     //Double_t rmspad = calPad->GetRMS();
781     //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
782     if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
783     else return kFALSE;
784   }
785   else return kFALSE;
786  
787 }
788 //__________________________________________________________________________________________________________________________
789 Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
790   //
791   // Update OCDB entry
792   //
793   
794   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
795   if(calPad) {
796     Double_t meanpad = calPad->GetMean();
797     Double_t rmspad = calPad->GetRMS();
798     //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
799     if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
800     else return kFALSE;
801   }
802   else return kFALSE;
803  
804
805 }
806 //_____________________________________________________________________________
807 Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
808 {
809   //
810   // Get version from the title
811   //
812   
813   // Some patterns
814   const Char_t *version = "Ver";
815   if(!strstr(name.Data(),version)) return -1;
816   
817   for(Int_t ver = 0; ver < 999999999; ver++) {
818
819     TString vertry(version);
820     vertry += ver;
821     vertry += "Subver";
822
823     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
824
825     if(strstr(name.Data(),vertry.Data())) return ver;
826     
827   }
828   
829   return -1;
830
831 }
832
833 //_____________________________________________________________________________
834 Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
835 {
836   //
837   // Get subversion from the title
838   //
839   
840   // Some patterns
841   const Char_t *subversion = "Subver";
842   if(!strstr(name.Data(),subversion)) return -1;
843   
844   for(Int_t ver = 0; ver < 999999999; ver++) {
845     
846     TString vertry(subversion);
847     vertry += ver;
848     vertry += "Nz";
849
850     //printf("vertry %s and name %s\n",vertry.Data(),name.Data());
851
852     if(strstr(name.Data(),vertry.Data())) return ver;
853     
854   }
855   
856   return -1;
857
858 }
859