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