Update of the TRD PID Response:
[u/mrichter/AliRoot.git] / TRD / AliTRDcalibDB.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 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 // Class providing the calibration parameters by accessing the CDB           //
21 //                                                                           //
22 // Request an instance with AliTRDcalibDB::Instance()                        //
23 // If a new event is processed set the event number with SetRun              //
24 // Then request the calibration data                                         // 
25 //                                                                           //
26 // Author:                                                                   //
27 //   Jan Fiete Grosse-Oetringhaus (Jan.Fiete.Grosse-Oetringhaus@cern.ch)     //
28 //                                                                           //
29 ///////////////////////////////////////////////////////////////////////////////
30
31 #include <TClonesArray.h>
32 #include <TObjArray.h>
33
34 #include "AliCDBManager.h"
35 #include "AliCDBEntry.h"
36 #include "AliLog.h"
37
38 #include "AliTRDPIDReference.h"
39 #include "AliTRDcalibDB.h"
40
41 #include "Cal/AliTRDCalROC.h"
42 #include "Cal/AliTRDCalPad.h"
43 #include "Cal/AliTRDCalDet.h"
44 #include "Cal/AliTRDCalDCS.h"
45 #include "Cal/AliTRDCalDCSv2.h"
46 #include "Cal/AliTRDCalPID.h"
47 #include "Cal/AliTRDCalMonitoring.h"
48 #include "Cal/AliTRDCalChamberStatus.h"
49 #include "Cal/AliTRDCalPadStatus.h"
50 #include "Cal/AliTRDCalSingleChamberStatus.h"
51 #include "Cal/AliTRDCalTrkAttach.h"
52
53 ClassImp(AliTRDcalibDB)
54
55 AliTRDcalibDB *AliTRDcalibDB::fgInstance   = 0;
56 Bool_t         AliTRDcalibDB::fgTerminated = kFALSE;
57
58 //_ singleton implementation __________________________________________________
59 AliTRDcalibDB* AliTRDcalibDB::Instance()
60 {
61   //
62   // Singleton implementation
63   // Returns an instance of this class, it is created if neccessary
64   //
65   
66   if (fgTerminated != kFALSE) {
67     return 0;
68   }
69
70   if (fgInstance == 0) {
71     fgInstance = new AliTRDcalibDB();
72   }
73
74   return fgInstance;
75
76 }
77
78 //_____________________________________________________________________________
79 void AliTRDcalibDB::Terminate()
80 {
81   //
82   // Singleton implementation
83   // Deletes the instance of this class and sets the terminated flag,
84   // instances cannot be requested anymore
85   // This function can be called several times.
86   //
87   
88   fgTerminated = kTRUE;
89   
90   if (fgInstance != 0) {
91     delete fgInstance;
92     fgInstance = 0;
93   }
94
95 }
96
97 //_____________________________________________________________________________
98 AliTRDcalibDB::AliTRDcalibDB()
99   :TObject()
100   ,fRun(-1)
101   ,fPRFsmp(0)
102   ,fPRFbin(0)
103   ,fPRFlo(0)
104   ,fPRFhi(0)
105   ,fPRFwid(0)
106   ,fPRFpad(0)
107   ,fPIDResponse(NULL)
108 {
109   //
110   // Default constructor
111   //
112   // TODO Default runnumber is set to 0, this should be changed later
113   //      to an invalid value (e.g. -1) to prevent
114   // TODO invalid calibration data to be used.
115   //
116
117   for (Int_t i = 0; i < kCDBCacheSize; ++i) {
118     fCDBCache[i]   = 0;
119     fCDBEntries[i] = 0;
120   }
121   
122   // Create the sampled PRF
123   SamplePRF();
124   
125 }
126
127 //_____________________________________________________________________________
128 AliTRDcalibDB::AliTRDcalibDB(const AliTRDcalibDB &c)
129   :TObject(c)
130   ,fRun(-1)
131   ,fPRFsmp(0)
132   ,fPRFbin(0)
133   ,fPRFlo(0)
134   ,fPRFhi(0)
135   ,fPRFwid(0)
136   ,fPRFpad(0)
137   ,fPIDResponse(NULL)
138 {
139   //
140   // Copy constructor (not that it make any sense for a singleton...)
141   //
142
143   for (Int_t i = 0; i < kCDBCacheSize; ++i) {
144     fCDBCache[i]   = 0;
145     fCDBEntries[i] = 0;
146   }
147   
148   // Create the sampled PRF
149   SamplePRF();
150
151 }
152
153 //_____________________________________________________________________________
154 AliTRDcalibDB &AliTRDcalibDB::operator=(const AliTRDcalibDB &c) 
155 {
156   //
157   // Assignment operator (same as above ...)
158   //
159
160   if (this != &c) {
161     AliFatal("No assignment operator defined");
162   }
163
164   return *this;
165
166 }
167
168 //_____________________________________________________________________________
169 AliTRDcalibDB::~AliTRDcalibDB() 
170 {
171   //
172   // destructor
173   //
174   
175   if (fPRFsmp) {
176     delete [] fPRFsmp;
177     fPRFsmp = 0;
178   }
179   if(fPIDResponse) delete fPIDResponse;
180
181   Invalidate();
182
183 }
184
185 //_caching functions____________________________________________________________
186 const TObject *AliTRDcalibDB::GetCachedCDBObject(Int_t id)
187 {
188   //
189   // Retrieves a cdb object with the given id. The objects are cached as
190   // long as the run number is not changed.
191   //
192   // Put together the available objects here by using the lines
193   //   a) For usual calibration objects:
194   //      case kID<Name> : 
195   //        return CacheCDBEntry(kID<Name>,"TRD/Calib/<Path>"); 
196   //        break;
197   //      See function CacheCDBEntry for details.
198   //   and
199   //   b) For calibration data which depends on two objects: One containing 
200   //      a value per detector and one the local fluctuations per pad:
201   //      case kID<Name> :
202   //        return CacheMergeCDBEntry(kID<Name>,"TRD/Calib/<padPath>","TRD/Calib/<chamberPath>"); 
203   //        break;
204   //      See function CacheMergeCDBEntry for details.
205   //
206     
207   switch (id) {
208
209     // Parameters defined per pad and chamber
210     case kIDVdriftPad : 
211       return CacheCDBEntry(kIDVdriftPad         ,"TRD/Calib/LocalVdrift"); 
212       break;
213     case kIDVdriftChamber : 
214       return CacheCDBEntry(kIDVdriftChamber     ,"TRD/Calib/ChamberVdrift"); 
215       break;
216     case kIDT0Pad : 
217       return CacheCDBEntry(kIDT0Pad             ,"TRD/Calib/LocalT0"); 
218       break;
219     case kIDT0Chamber : 
220       return CacheCDBEntry(kIDT0Chamber         ,"TRD/Calib/ChamberT0"); 
221       break;
222     case kIDGainFactorPad : 
223       return CacheCDBEntry(kIDGainFactorPad     ,"TRD/Calib/LocalGainFactor"); 
224       break;
225     case kIDGainFactorChamber : 
226       return CacheCDBEntry(kIDGainFactorChamber ,"TRD/Calib/ChamberGainFactor"); 
227       break;
228     case kIDNoiseChamber : 
229       return CacheCDBEntry(kIDNoiseChamber ,"TRD/Calib/DetNoise"); 
230       break;
231     case kIDNoisePad : 
232       return CacheCDBEntry(kIDNoisePad ,"TRD/Calib/PadNoise"); 
233       break;
234
235
236     // Parameters defined per pad
237     case kIDPRFWidth : 
238       return CacheCDBEntry(kIDPRFWidth          ,"TRD/Calib/PRFWidth"); 
239       break;
240
241     // Status values
242     case kIDChamberStatus : 
243       return CacheCDBEntry(kIDChamberStatus     ,"TRD/Calib/ChamberStatus"); 
244       break;
245     case kIDPadStatus : 
246       return CacheCDBEntry(kIDPadStatus         ,"TRD/Calib/PadStatus"); 
247       break;
248
249     // Global parameters
250     case kIDMonitoringData : 
251       return CacheCDBEntry(kIDMonitoringData    ,"TRD/Calib/MonitoringData"); 
252       break;
253     case kIDFEE : 
254       return CacheCDBEntry(kIDFEE               ,"TRD/Calib/FEE"); 
255       break;
256     case kIDDCS :
257       return CacheCDBEntry(kIDDCS               ,"TRD/Calib/DCS");
258       break;
259     case kIDPIDNN : 
260       return CacheCDBEntry(kIDPIDNN             ,"TRD/Calib/PIDNN");
261     case kIDPIDLQ : 
262       return CacheCDBEntry(kIDPIDLQ             ,"TRD/Calib/PIDLQ"); 
263       break;
264     case kIDPIDLQ1D:
265       return CacheCDBEntry(kIDPIDLQ1D           ,"TRD/Calib/PIDLQ1D");
266       break;
267     case kIDRecoParam : 
268       return CacheCDBEntry(kIDRecoParam         ,"TRD/Calib/RecoParam"); 
269       break;
270     case kIDAttach : 
271       return CacheCDBEntry(kIDAttach            ,"TRD/Calib/TrkAttach"); 
272       break;
273   }
274
275   return 0;
276
277 }
278
279 //_____________________________________________________________________________
280 AliCDBEntry *AliTRDcalibDB::GetCDBEntry(const char *cdbPath)
281 {
282   // 
283   // Retrieves an entry with path <cdbPath> from the CDB.
284   //
285     
286   AliCDBEntry *entry = AliCDBManager::Instance()->Get(cdbPath,fRun);
287   if (!entry) { 
288     AliError(Form("Failed to get entry: %s",cdbPath));
289     return 0; 
290   }
291   
292   return entry;
293
294 }
295
296 //_____________________________________________________________________________
297 const TObject *AliTRDcalibDB::CacheCDBEntry(Int_t id, const char *cdbPath)
298 {
299   //
300   // Caches the entry <id> with cdb path <cdbPath>
301   //
302
303   if (!fCDBCache[id]) {
304     fCDBEntries[id] = GetCDBEntry(cdbPath);
305     if (fCDBEntries[id]) {
306       fCDBCache[id] = fCDBEntries[id]->GetObject();
307     }
308   } 
309   
310   return fCDBCache[id];
311 }
312
313 //_____________________________________________________________________________
314 void AliTRDcalibDB::SetRun(Long64_t run)
315 {
316   //
317   // Sets current run number. Calibration data is read from the corresponding file.
318   // When the run number changes the caching is invalidated.
319   //
320
321   if (fRun == run) {
322     return;
323   }
324
325   fRun = run;
326
327   Invalidate();
328
329 }
330
331 //_____________________________________________________________________________
332 void AliTRDcalibDB::Invalidate()
333 {
334   //
335   // Invalidates cache (when run number is changed).
336   //
337   
338   for (Int_t i = 0; i < kCDBCacheSize; ++i) {
339     if (fCDBEntries[i]) {
340       if (AliCDBManager::Instance()->GetCacheFlag() == kFALSE) {
341         if ((fCDBEntries[i]->IsOwner() == kFALSE) && 
342             (fCDBCache[i])) {
343           delete fCDBCache[i];
344         }
345         delete fCDBEntries[i];
346       }
347       fCDBEntries[i] = 0;
348       fCDBCache[i]   = 0;
349     }
350   }
351
352 }
353 //_____________________________________________________________________________
354 Float_t AliTRDcalibDB::GetNoise(Int_t det, Int_t col, Int_t row)
355 {
356   //
357   // Returns the noise level in ADC counts for the given pad.
358   //
359
360   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *> 
361                                    (GetCachedCDBObject(kIDNoisePad));
362   if (!calPad) {
363     return -1;
364   }
365
366   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
367   if (!roc) {
368     return -1;
369   }
370
371   const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *> 
372                                    (GetCachedCDBObject(kIDNoiseChamber));
373   if (!calChamber) {
374     return -1;
375   }
376
377   return calChamber->GetValue(det) * roc->GetValue(col,row);
378
379 }
380  
381 //_____________________________________________________________________________
382 AliTRDCalROC *AliTRDcalibDB::GetNoiseROC(Int_t det)
383 {
384   //
385   // Returns the Vdrift calibration object for a given ROC
386   // containing one number per pad 
387   //
388   
389   const AliTRDCalPad     *calPad     = dynamic_cast<const AliTRDCalPad *> 
390                                        (GetCachedCDBObject(kIDNoisePad));
391   if (!calPad) {
392     return 0;
393   }
394
395   AliTRDCalROC           *roc        = calPad->GetCalROC(det);
396   if (!roc) {
397     return 0;
398   }
399   else {
400     return roc;
401   }
402
403 }
404
405 //_____________________________________________________________________________
406 const AliTRDCalDet *AliTRDcalibDB::GetNoiseDet()
407 {
408   //
409   // Returns the Vdrift calibration object
410   // containing one number per detector
411   //
412   
413   const AliTRDCalDet     *calChamber = dynamic_cast<const AliTRDCalDet *> 
414                                        (GetCachedCDBObject(kIDNoiseChamber));
415   if (!calChamber) {
416     return 0;
417   }
418   else {
419     return calChamber;
420   }
421
422 }
423
424 //_____________________________________________________________________________
425 Float_t AliTRDcalibDB::GetVdrift(Int_t det, Int_t col, Int_t row)
426 {
427   //
428   // Returns the drift velocity for the given pad.
429   //
430
431   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *> 
432                                    (GetCachedCDBObject(kIDVdriftPad));
433   if (!calPad) {
434     return -1;
435   }
436
437   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
438   if (!roc) {
439     return -1;
440   }
441
442   const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *> 
443                                    (GetCachedCDBObject(kIDVdriftChamber));
444   if (!calChamber) {
445     return -1;
446   }
447
448   return calChamber->GetValue(det) * roc->GetValue(col,row);
449
450 }
451  
452 //_____________________________________________________________________________
453 AliTRDCalROC *AliTRDcalibDB::GetVdriftROC(Int_t det)
454 {
455   //
456   // Returns the Vdrift calibration object for a given ROC
457   // containing one number per pad 
458   //
459   
460   const AliTRDCalPad     *calPad     = dynamic_cast<const AliTRDCalPad *> 
461                                        (GetCachedCDBObject(kIDVdriftPad));
462   if (!calPad) {
463     return 0;
464   }
465
466   AliTRDCalROC           *roc        = calPad->GetCalROC(det);
467   if (!roc) {
468     return 0;
469   }
470   else {
471     return roc;
472   }
473
474 }
475
476 //_____________________________________________________________________________
477 const AliTRDCalDet *AliTRDcalibDB::GetVdriftDet()
478 {
479   //
480   // Returns the Vdrift calibration object
481   // containing one number per detector
482   //
483   
484   const AliTRDCalDet     *calChamber = dynamic_cast<const AliTRDCalDet *> 
485                                        (GetCachedCDBObject(kIDVdriftChamber));
486   if (!calChamber) {
487     return 0;
488   }
489   else {
490     return calChamber;
491   }
492
493 }
494
495 //_____________________________________________________________________________
496 Float_t AliTRDcalibDB::GetVdriftAverage(Int_t det)
497 {
498   //
499   // Returns the average drift velocity for the given detector
500   //
501
502   const AliTRDCalDet *calDet     = dynamic_cast<const AliTRDCalDet *> 
503                                    (GetCachedCDBObject(kIDVdriftChamber));
504   if (!calDet) {
505     return -1;
506   }
507
508   return calDet->GetValue(det);
509
510 }
511
512 //_____________________________________________________________________________
513 Float_t AliTRDcalibDB::GetT0(Int_t det, Int_t col, Int_t row)
514 {
515   //
516   // Returns t0 for the given pad.
517   //
518   
519   const AliTRDCalPad     *calPad     = dynamic_cast<const AliTRDCalPad *> 
520                                        (GetCachedCDBObject(kIDT0Pad));
521   if (!calPad) {
522     return -1;
523   }
524
525   AliTRDCalROC           *roc        = calPad->GetCalROC(det);
526   if (!roc) {
527     return -1;
528   }
529
530   const AliTRDCalDet     *calChamber = dynamic_cast<const AliTRDCalDet *> 
531                                        (GetCachedCDBObject(kIDT0Chamber));
532   if (!calChamber) {
533     return -1;
534   }
535
536   return calChamber->GetValue(det) + roc->GetValue(col,row);
537
538 }
539  
540 //_____________________________________________________________________________
541 AliTRDCalROC *AliTRDcalibDB::GetT0ROC(Int_t det)
542 {
543   //
544   // Returns the t0 calibration object for a given ROC
545   // containing one number per pad 
546   //
547   
548   const AliTRDCalPad     *calPad     = dynamic_cast<const AliTRDCalPad *> 
549                                        (GetCachedCDBObject(kIDT0Pad));
550   if (!calPad) {
551     return 0;
552   }
553
554   AliTRDCalROC           *roc        = calPad->GetCalROC(det);
555   if (!roc) {
556     return 0;
557   }
558   else {
559     return roc;
560   }
561
562 }
563
564 //_____________________________________________________________________________
565 const AliTRDCalDet *AliTRDcalibDB::GetT0Det()
566 {
567   //
568   // Returns the t0 calibration object
569   // containing one number per detector
570   //
571   
572   const AliTRDCalDet     *calChamber = dynamic_cast<const AliTRDCalDet *> 
573                                        (GetCachedCDBObject(kIDT0Chamber));
574   if (!calChamber) {
575     return 0;
576   }
577   else {
578     return calChamber;
579   }
580
581 }
582
583 //_____________________________________________________________________________
584 Float_t AliTRDcalibDB::GetT0Average(Int_t det)
585 {
586   //
587   // Returns the average t0 for the given detector
588   //
589
590   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *> 
591                                    (GetCachedCDBObject(kIDT0Pad));
592   if (!calPad) {
593     return -1;
594   }
595
596   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
597   if (!roc) {
598     return -1;
599   }
600
601   const AliTRDCalDet *calDet     = dynamic_cast<const AliTRDCalDet *> 
602                                    (GetCachedCDBObject(kIDT0Chamber));
603   if (!calDet) {
604     return -1;
605   }
606
607   Double_t sum = 0.0; 
608   for (Int_t channel = 0; channel < roc->GetNchannels(); ++channel) {
609     sum += roc->GetValue(channel);
610   }
611   sum /= roc->GetNchannels();
612   sum += calDet->GetValue(det);
613   return sum;
614
615 }
616
617 //_____________________________________________________________________________
618 Float_t AliTRDcalibDB::GetGainFactor(Int_t det, Int_t col, Int_t row)
619 {
620   //
621   // Returns the gain factor for the given pad.
622   //
623   
624   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *> 
625                                    (GetCachedCDBObject(kIDGainFactorPad));
626   if (!calPad) {
627     return -1;
628   }
629
630   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
631   if (!roc) {
632     return -1;
633   }
634
635   const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *> 
636                                    (GetCachedCDBObject(kIDGainFactorChamber));
637   if (!calChamber) {
638     return -1;
639   }
640
641   return calChamber->GetValue(det) * roc->GetValue(col,row);
642
643 }
644
645 //_____________________________________________________________________________
646 AliTRDCalROC *AliTRDcalibDB::GetGainFactorROC(Int_t det)
647 {
648   //
649   // Returns the gain factor calibration object for a given ROC
650   //
651   
652   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *> 
653                                    (GetCachedCDBObject(kIDGainFactorPad));
654   if (!calPad) {
655     return 0;
656   }
657
658   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
659   if (!roc) {
660     return 0;
661   }
662   else {
663     return roc;
664   }
665
666 }
667
668 //_____________________________________________________________________________
669 const AliTRDCalDet *AliTRDcalibDB::GetGainFactorDet()
670 {
671   //
672   // Returns the gain factor calibration object
673   // containing one number per detector
674   //
675
676   const AliTRDCalDet *calChamber = dynamic_cast<const AliTRDCalDet *> 
677                                    (GetCachedCDBObject(kIDGainFactorChamber));
678   if (!calChamber) {
679     return 0;
680   }
681   else {
682     return calChamber;
683   }
684
685 }
686
687 //_____________________________________________________________________________
688 Float_t AliTRDcalibDB::GetGainFactorAverage(Int_t det)
689 {
690   //
691   // Returns the average gain factor for the given detector
692   //
693
694   const AliTRDCalDet *calDet     = dynamic_cast<const AliTRDCalDet *> 
695                                    (GetCachedCDBObject(kIDGainFactorChamber));
696   if (!calDet) {
697     return -1;
698   }
699
700   return calDet->GetValue(det);
701
702 }
703
704 //_____________________________________________________________________________
705 AliTRDCalROC *AliTRDcalibDB::GetPRFROC(Int_t det)
706 {
707   //
708   // Returns the PRF calibration object for a given ROC
709   // containing one number per pad 
710   //
711   
712   const AliTRDCalPad     *calPad     = dynamic_cast<const AliTRDCalPad *> 
713                                        (GetCachedCDBObject(kIDPRFWidth));
714   if (!calPad) {
715     return 0;
716   }
717
718   AliTRDCalROC           *roc        = calPad->GetCalROC(det);
719   if (!roc) {
720     return 0;
721   }
722   else {
723     return roc;
724   }
725
726 }
727
728 //_____________________________________________________________________________
729 Float_t AliTRDcalibDB::GetPRFWidth(Int_t det, Int_t col, Int_t row)
730 {
731   //
732   // Returns the PRF width for the given pad.
733   //
734   
735   const AliTRDCalPad *calPad     = dynamic_cast<const AliTRDCalPad *> 
736                                    (GetCachedCDBObject(kIDPRFWidth));
737   if (!calPad) {
738     return -1;
739   }
740
741   AliTRDCalROC       *roc        = calPad->GetCalROC(det);
742   if (!roc) {
743     return -1;
744   }
745
746   return roc->GetValue(col,row);
747
748 }
749   
750 //_____________________________________________________________________________
751 Int_t AliTRDcalibDB::GetNumberOfTimeBinsDCS()
752 {
753   //
754   // Returns Number of time bins from the DCS
755   //
756
757   Int_t nMixed = -2; // not the same number for all chambers
758   Int_t nUndef = -1; // default value - has not been set!
759   Int_t nTbSor = nUndef;
760   Int_t nTbEor = nUndef;
761   Int_t calver = 0; // Check CalDCS version
762
763   const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
764   if (!dcsArr) {
765     AliError("No DCS object found!");
766     return nUndef;
767   }
768
769   if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS"))   calver = 1;
770   if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
771
772   if (calver == 1) {
773     // DCS object
774     const AliTRDCalDCS *calDCSsor = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(0));
775     const AliTRDCalDCS *calDCSeor = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(1));
776     if (!calDCSsor) {
777       // the SOR file is mandatory
778       AliError("NO SOR AliTRDCalDCS object found in CDB file!");
779       return nUndef;
780     }
781     if (!calDCSeor) {
782       // this can happen if the run is shorter than a couple of seconds.
783       AliWarning("NO EOR AliTRDCalDCS object found in CDB file.");
784     }
785
786     // get the numbers
787     nTbSor = calDCSsor->GetGlobalNumberOfTimeBins();
788     if (calDCSeor) nTbEor = calDCSeor->GetGlobalNumberOfTimeBins();
789
790   } else if (calver == 2) {
791     // DCSv2 object
792     const AliTRDCalDCSv2 *calDCSsorv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(0));
793     const AliTRDCalDCSv2 *calDCSeorv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(1));
794     if (!calDCSsorv2) {
795       // the SOR file is mandatory
796       AliError("NO SOR AliTRDCalDCSv2 object found in CDB file!");
797       return nUndef;
798     }
799     if (!calDCSeorv2) {
800       // this can happen if the run is shorter than a couple of seconds.
801       AliWarning("NO EOR AliTRDCalDCSv2 object found in CDB file.");
802     }
803
804     // get the numbers
805     nTbSor = calDCSsorv2->GetGlobalNumberOfTimeBins();
806     if (calDCSeorv2) nTbEor = calDCSeorv2->GetGlobalNumberOfTimeBins();
807
808   } else AliError("NO DCS/DCSv2 OCDB entry found!");
809
810   // if they're the same return the value
811   // -2 means mixed, -1: no data, >= 0: good number of time bins
812   if (nTbSor == nTbEor) return nTbSor;
813
814   // if they're differing:
815   if (nTbSor == nMixed || nTbEor == nMixed) {
816     AliWarning("Inconsistent number of time bins found!");
817     return nMixed;
818   }
819
820   // one is undefined, the other ok -> return that one
821   if (nTbSor == nUndef) return nTbEor;
822   if (nTbEor == nUndef) return nTbSor;
823
824   // only remains: two different numbers >= 0
825   return nMixed;
826 }
827
828 //_____________________________________________________________________________
829 void AliTRDcalibDB::GetFilterType(TString &filterType)
830 {
831   //
832   // Returns the filter type
833   //
834
835   const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
836   if(!dcsArr){
837     filterType = "";
838     return;
839   }
840
841   Int_t esor   = 0; // Take SOR
842   Int_t calver = 0; // Check CalDCS version
843   if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS"))   calver = 1;
844   if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
845
846   if (calver == 1) {
847     // DCS object
848     const AliTRDCalDCS *calDCS = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(esor));
849     if(!calDCS){
850       filterType = "";
851       return;
852     } 
853     filterType = calDCS->GetGlobalFilterType();
854   } else if (calver == 2) {
855     // DCSv2 object
856     const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
857     if(!calDCSv2){
858       filterType = "";
859       return;
860     } 
861     filterType = calDCSv2->GetGlobalFilterType();
862   } else AliError("NO DCS/DCSv2 OCDB entry found!"); 
863
864 }
865
866 //_____________________________________________________________________________
867 void AliTRDcalibDB::GetGlobalConfiguration(TString &config){
868   //
869   // Get Configuration from the DCS
870   //
871
872   const TObjArray *dcsArr = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDDCS));
873   if(!dcsArr){
874     config = "";
875     return;
876   }
877
878   Int_t esor   = 0; // Take SOR
879   Int_t calver = 0; // Check CalDCS version
880   if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCS"))   calver = 1;
881   if (!strcmp(dcsArr->At(0)->ClassName(),"AliTRDCalDCSv2")) calver = 2;
882
883   if (calver == 1) {
884     // DCS object
885     const AliTRDCalDCS *calDCS = dynamic_cast<const AliTRDCalDCS *>(dcsArr->At(esor));
886     if(!calDCS){
887       config = "";
888       return;
889     } 
890     config = calDCS->GetGlobalConfigName();
891   } else if (calver == 2) {
892     // DCSv2 object
893     const AliTRDCalDCSv2 *calDCSv2 = dynamic_cast<const AliTRDCalDCSv2 *>(dcsArr->At(esor));
894     if(!calDCSv2){
895       config = "";
896       return;
897     } 
898     config = calDCSv2->GetGlobalConfigName();
899   } else AliError("NO DCS/DCSv2 OCDB entry found!");
900
901 }
902
903 //_____________________________________________________________________________
904 Bool_t AliTRDcalibDB::HasOnlineFilterPedestal()
905 {
906   //
907   // Checks whether pedestal filter was applied online
908   //
909   TString cname;
910   // Temporary: Get the filter config from the configuration name
911   GetGlobalConfiguration(cname);
912   TString filterconfig = cname(cname.First("_") + 1, cname.First("-") - cname.First("_") - 1);
913   // TString filterconfig;
914   //GetFilterType(filterconfig);
915   return filterconfig.Contains("p");
916 }
917
918 //_____________________________________________________________________________
919 Bool_t AliTRDcalibDB::HasOnlineFilterGain(){
920   //
921   // Checks whether online gain filter was applied
922   //
923   TString cname;
924   // Temporary: Get the filter config from the configuration name
925   GetGlobalConfiguration(cname);
926   TString filterconfig = cname(cname.First("_") + 1, cname.First("-") - cname.First("_") - 1);
927   //TString filterconfig;
928   //GetFilterType(filterconfig);
929   return filterconfig.Contains("g");
930 }
931
932 //_____________________________________________________________________________
933 Bool_t AliTRDcalibDB::HasOnlineTailCancellation(){
934   //
935   // Checks whether online tail cancellation was applied
936   //
937   TString cname;
938   // Temporary: Get the filter config from the configuration name
939   GetGlobalConfiguration(cname);
940   TString filterconfig = cname(cname.First("_") + 1, cname.First("-") - cname.First("_") - 1);
941   //TString filterconfig;
942   //GetFilterType(filterconfig);
943   return filterconfig.Contains("t");
944 }
945
946 //_____________________________________________________________________________
947 Char_t AliTRDcalibDB::GetPadStatus(Int_t det, Int_t col, Int_t row)
948 {
949   //
950   // Returns the status of the given pad
951   //
952
953   const AliTRDCalPadStatus *cal  = dynamic_cast<const AliTRDCalPadStatus *> 
954                                    (GetCachedCDBObject(kIDPadStatus));
955   if (!cal) {
956     return -1;
957   }
958
959   const AliTRDCalSingleChamberStatus *roc = cal->GetCalROC(det);
960   if (!roc) {
961     return -1;
962   }
963
964   return roc->GetStatus(col,row);
965
966 }
967
968 //_____________________________________________________________________________
969 AliTRDCalSingleChamberStatus* AliTRDcalibDB::GetPadStatusROC(Int_t det)
970 {
971   //
972   // Returns the pad status calibration object for a given ROC
973   //
974
975   const AliTRDCalPadStatus *cal  = dynamic_cast<const AliTRDCalPadStatus *> 
976                                    (GetCachedCDBObject(kIDPadStatus));
977   if (!cal) {
978     return 0;
979   }
980
981   AliTRDCalSingleChamberStatus *roc = cal->GetCalROC(det);
982   if (!roc) {
983     return 0;
984   }
985   else {
986     return roc;
987   }
988
989 }
990
991 //_____________________________________________________________________________
992 Char_t AliTRDcalibDB::GetChamberStatus(Int_t det)
993 {
994   //
995   // Returns the status of the given chamber
996   //
997
998   const AliTRDCalChamberStatus *cal = dynamic_cast<const AliTRDCalChamberStatus *> 
999                                       (GetCachedCDBObject(kIDChamberStatus));
1000   if (!cal) {
1001     return -1;
1002   }
1003
1004   return cal->GetStatus(det);
1005
1006 }
1007
1008 //_____________________________________________________________________________
1009 AliTRDrecoParam* AliTRDcalibDB::GetRecoParam(Int_t */*eventtype*/)
1010 {
1011   //
1012   // Returns the TRD reconstruction parameters from the OCDB
1013   //
1014
1015   const TClonesArray *recos = dynamic_cast<const TClonesArray*>(GetCachedCDBObject(kIDRecoParam));
1016   if (!recos) return 0x0;
1017
1018   // calculate entry based on event type info
1019   Int_t n = 0; //f(eventtype[0], eventtype[1], ....)
1020
1021   return (AliTRDrecoParam*)recos->UncheckedAt(n);
1022
1023 }
1024
1025 //_____________________________________________________________________________
1026 Bool_t AliTRDcalibDB::IsPadMasked(Int_t det, Int_t col, Int_t row)
1027 {
1028   //
1029   // Returns status, see name of functions for details ;-)
1030   //
1031
1032   const AliTRDCalPadStatus         *cal = dynamic_cast<const AliTRDCalPadStatus *> 
1033                                           (GetCachedCDBObject(kIDPadStatus));
1034   if (!cal) {
1035     return -1;
1036   }
1037
1038   return cal->IsMasked(det,col,row);
1039
1040 }
1041
1042 //_____________________________________________________________________________
1043 Bool_t AliTRDcalibDB::IsPadBridgedLeft(Int_t det, Int_t col, Int_t row)
1044 {
1045   //
1046   // Returns status, see name of functions for details ;-)
1047   //
1048
1049   const AliTRDCalPadStatus         *cal = dynamic_cast<const AliTRDCalPadStatus *> 
1050                                           (GetCachedCDBObject(kIDPadStatus));
1051   if (!cal) {
1052     return -1;
1053   }
1054
1055   return cal->IsBridgedLeft(det,col,row);
1056
1057 }
1058
1059 //_____________________________________________________________________________
1060 Bool_t AliTRDcalibDB::IsPadBridgedRight(Int_t det, Int_t col, Int_t row)
1061 {
1062   //
1063   // Returns status, see name of functions for details ;-)
1064   //
1065
1066   const AliTRDCalPadStatus         * cal = dynamic_cast<const AliTRDCalPadStatus *> 
1067                                            (GetCachedCDBObject(kIDPadStatus));
1068   if (!cal) {
1069     return -1;
1070   }
1071
1072   return cal->IsBridgedRight(det,col,row);
1073
1074 }
1075
1076 //_____________________________________________________________________________
1077 Bool_t AliTRDcalibDB::IsPadNotConnected(Int_t det, Int_t col, Int_t row)
1078 {
1079   //
1080   // Returns status, see name of functions for details ;-)
1081   //
1082
1083   const AliTRDCalPadStatus         * cal = dynamic_cast<const AliTRDCalPadStatus *> 
1084                                            (GetCachedCDBObject(kIDPadStatus));
1085   if (!cal) {
1086     return -1;
1087   }
1088
1089   return cal->IsNotConnected(det,col,row);
1090
1091 }
1092
1093 //_____________________________________________________________________________
1094 Bool_t AliTRDcalibDB::IsChamberInstalled(Int_t det)
1095 {
1096   //
1097   // Returns status, see name of functions for details ;-)
1098   //
1099
1100   const AliTRDCalChamberStatus     * cal = dynamic_cast<const AliTRDCalChamberStatus *> 
1101                                            (GetCachedCDBObject(kIDChamberStatus));
1102   if (!cal) {
1103     return -1;
1104   }
1105
1106   return cal->IsInstalled(det);
1107
1108 }
1109
1110 //_____________________________________________________________________________
1111 Bool_t AliTRDcalibDB::IsChamberMasked(Int_t det)
1112 {
1113   //
1114   // Returns status, see name of functions for details ;-)
1115   //
1116
1117   const AliTRDCalChamberStatus     * cal = dynamic_cast<const AliTRDCalChamberStatus *> 
1118                                            (GetCachedCDBObject(kIDChamberStatus));
1119   if (!cal) {
1120     return -1;
1121   }
1122
1123   return cal->IsMasked(det);
1124
1125 }
1126 //_____________________________________________________________________________
1127 Bool_t AliTRDcalibDB::IsHalfChamberMasked(Int_t det, Int_t side){
1128   //
1129   // Returns status, see name of functions for details ;-)
1130   //
1131
1132   const AliTRDCalChamberStatus     * cal = dynamic_cast<const AliTRDCalChamberStatus *> 
1133                                            (GetCachedCDBObject(kIDChamberStatus));
1134   if (!cal) {
1135     return -1;
1136   }
1137
1138   return side > 0 ? cal->IsHalfChamberSideBMasked(det) : cal->IsHalfChamberSideAMasked(det);
1139
1140 }
1141 //_____________________________________________________________________________
1142 const AliTRDCalPID *AliTRDcalibDB::GetPIDObject(AliTRDpidUtil::ETRDPIDMethod method)
1143 {
1144   //
1145   // Returns the object storing the distributions for PID with likelihood
1146   //
1147
1148   switch(method) {
1149   case AliTRDpidUtil::kLQ: 
1150     return dynamic_cast<const AliTRDCalPID *>(GetCachedCDBObject(kIDPIDLQ));
1151   case AliTRDpidUtil::kNN: 
1152     return dynamic_cast<const AliTRDCalPID *>(GetCachedCDBObject(kIDPIDNN));
1153   case AliTRDpidUtil::kESD:
1154     return 0x0; // To avoid compiler warnings 
1155   }
1156
1157   return 0x0;
1158
1159 }
1160
1161 //_____________________________________________________________________________
1162 AliTRDPIDResponse *AliTRDcalibDB::GetPIDResponse(AliTRDPIDResponse::ETRDPIDMethod method){
1163   if(!fPIDResponse){
1164     fPIDResponse = new AliTRDPIDResponse;
1165     // Load Reference Histos from OCDB
1166     fPIDResponse->SetPIDmethod(method);
1167     const TObjArray *references = dynamic_cast<const TObjArray *>(GetCachedCDBObject(kIDPIDLQ1D));
1168     TIter refs(references);
1169     TObject *obj = NULL;
1170     AliTRDPIDReference *ref = NULL;
1171     Bool_t hasReference = kFALSE;
1172     while((obj = refs())){
1173         if((ref = dynamic_cast<AliTRDPIDReference *>(obj))){
1174                 fPIDResponse->Load(ref);
1175                 hasReference = kTRUE;
1176                 break;
1177         }
1178     }
1179     if(!hasReference) AliError("Reference histograms not found in the OCDB");
1180   }
1181   return fPIDResponse;
1182 }
1183
1184 //_____________________________________________________________________________
1185 const AliTRDCalTrkAttach* AliTRDcalibDB::GetAttachObject()
1186 {
1187   //
1188   // Returns the object storing likelihood distributions for cluster to track attachment
1189   //
1190   return dynamic_cast<const AliTRDCalTrkAttach*>(GetCachedCDBObject(kIDAttach));
1191 }
1192
1193
1194 //_____________________________________________________________________________
1195 const AliTRDCalMonitoring *AliTRDcalibDB::GetMonitoringObject()
1196 {
1197   //
1198   // Returns the object storing the monitoring data
1199   //
1200
1201   return dynamic_cast<const AliTRDCalMonitoring *> 
1202          (GetCachedCDBObject(kIDMonitoringData));
1203    
1204 }
1205
1206 //_____________________________________________________________________________
1207 void AliTRDcalibDB::SamplePRF()
1208 {
1209   //
1210   // Samples the pad response function (should maybe go somewhere else ...)
1211   //
1212
1213   const Int_t kPRFbin = 61;
1214
1215   Float_t prf[kNlayer][kPRFbin] = { 
1216                    {2.9037e-02, 3.3608e-02, 3.9020e-02, 4.5292e-02,
1217                     5.2694e-02, 6.1362e-02, 7.1461e-02, 8.3362e-02,
1218                     9.7063e-02, 1.1307e-01, 1.3140e-01, 1.5235e-01,
1219                     1.7623e-01, 2.0290e-01, 2.3294e-01, 2.6586e-01,
1220                     3.0177e-01, 3.4028e-01, 3.8077e-01, 4.2267e-01,
1221                     4.6493e-01, 5.0657e-01, 5.4655e-01, 5.8397e-01,
1222                     6.1767e-01, 6.4744e-01, 6.7212e-01, 6.9188e-01,
1223                     7.0627e-01, 7.1499e-01, 7.1851e-01, 7.1499e-01,
1224                     7.0627e-01, 6.9188e-01, 6.7212e-01, 6.4744e-01,
1225                     6.1767e-01, 5.8397e-01, 5.4655e-01, 5.0657e-01,
1226                     4.6493e-01, 4.2267e-01, 3.8077e-01, 3.4028e-01,
1227                     3.0177e-01, 2.6586e-01, 2.3294e-01, 2.0290e-01,
1228                     1.7623e-01, 1.5235e-01, 1.3140e-01, 1.1307e-01,
1229                     9.7063e-02, 8.3362e-02, 7.1461e-02, 6.1362e-02,
1230                     5.2694e-02, 4.5292e-02, 3.9020e-02, 3.3608e-02,
1231                     2.9037e-02},
1232                    {2.5478e-02, 2.9695e-02, 3.4655e-02, 4.0454e-02,
1233                     4.7342e-02, 5.5487e-02, 6.5038e-02, 7.6378e-02,
1234                     8.9696e-02, 1.0516e-01, 1.2327e-01, 1.4415e-01,
1235                     1.6794e-01, 1.9516e-01, 2.2573e-01, 2.5959e-01,
1236                     2.9694e-01, 3.3719e-01, 3.7978e-01, 4.2407e-01,
1237                     4.6889e-01, 5.1322e-01, 5.5569e-01, 5.9535e-01,
1238                     6.3141e-01, 6.6259e-01, 6.8882e-01, 7.0983e-01,
1239                     7.2471e-01, 7.3398e-01, 7.3761e-01, 7.3398e-01,
1240                     7.2471e-01, 7.0983e-01, 6.8882e-01, 6.6259e-01,
1241                     6.3141e-01, 5.9535e-01, 5.5569e-01, 5.1322e-01,
1242                     4.6889e-01, 4.2407e-01, 3.7978e-01, 3.3719e-01,
1243                     2.9694e-01, 2.5959e-01, 2.2573e-01, 1.9516e-01,
1244                     1.6794e-01, 1.4415e-01, 1.2327e-01, 1.0516e-01,
1245                     8.9696e-02, 7.6378e-02, 6.5038e-02, 5.5487e-02,
1246                     4.7342e-02, 4.0454e-02, 3.4655e-02, 2.9695e-02,
1247                     2.5478e-02},
1248                    {2.2363e-02, 2.6233e-02, 3.0782e-02, 3.6140e-02,
1249                     4.2535e-02, 5.0157e-02, 5.9197e-02, 6.9900e-02,
1250                     8.2707e-02, 9.7811e-02, 1.1548e-01, 1.3601e-01,
1251                     1.5998e-01, 1.8739e-01, 2.1840e-01, 2.5318e-01,
1252                     2.9182e-01, 3.3373e-01, 3.7837e-01, 4.2498e-01,
1253                     4.7235e-01, 5.1918e-01, 5.6426e-01, 6.0621e-01,
1254                     6.4399e-01, 6.7700e-01, 7.0472e-01, 7.2637e-01,
1255                     7.4206e-01, 7.5179e-01, 7.5551e-01, 7.5179e-01,
1256                     7.4206e-01, 7.2637e-01, 7.0472e-01, 6.7700e-01,
1257                     6.4399e-01, 6.0621e-01, 5.6426e-01, 5.1918e-01,
1258                     4.7235e-01, 4.2498e-01, 3.7837e-01, 3.3373e-01,
1259                     2.9182e-01, 2.5318e-01, 2.1840e-01, 1.8739e-01,
1260                     1.5998e-01, 1.3601e-01, 1.1548e-01, 9.7811e-02,
1261                     8.2707e-02, 6.9900e-02, 5.9197e-02, 5.0157e-02,
1262                     4.2535e-02, 3.6140e-02, 3.0782e-02, 2.6233e-02,
1263                     2.2363e-02},
1264                    {1.9635e-02, 2.3167e-02, 2.7343e-02, 3.2293e-02,
1265                     3.8224e-02, 4.5335e-02, 5.3849e-02, 6.4039e-02,
1266                     7.6210e-02, 9.0739e-02, 1.0805e-01, 1.2841e-01,
1267                     1.5216e-01, 1.7960e-01, 2.1099e-01, 2.4671e-01,
1268                     2.8647e-01, 3.2996e-01, 3.7660e-01, 4.2547e-01,
1269                     4.7536e-01, 5.2473e-01, 5.7215e-01, 6.1632e-01,
1270                     6.5616e-01, 6.9075e-01, 7.1939e-01, 7.4199e-01,
1271                     7.5838e-01, 7.6848e-01, 7.7227e-01, 7.6848e-01,
1272                     7.5838e-01, 7.4199e-01, 7.1939e-01, 6.9075e-01,
1273                     6.5616e-01, 6.1632e-01, 5.7215e-01, 5.2473e-01,
1274                     4.7536e-01, 4.2547e-01, 3.7660e-01, 3.2996e-01,
1275                     2.8647e-01, 2.4671e-01, 2.1099e-01, 1.7960e-01,
1276                     1.5216e-01, 1.2841e-01, 1.0805e-01, 9.0739e-02,
1277                     7.6210e-02, 6.4039e-02, 5.3849e-02, 4.5335e-02,
1278                     3.8224e-02, 3.2293e-02, 2.7343e-02, 2.3167e-02,
1279                     1.9635e-02},
1280                    {1.7224e-02, 2.0450e-02, 2.4286e-02, 2.8860e-02,
1281                     3.4357e-02, 4.0979e-02, 4.8966e-02, 5.8612e-02,
1282                     7.0253e-02, 8.4257e-02, 1.0102e-01, 1.2094e-01,
1283                     1.4442e-01, 1.7196e-01, 2.0381e-01, 2.4013e-01,
1284                     2.8093e-01, 3.2594e-01, 3.7450e-01, 4.2563e-01,
1285                     4.7796e-01, 5.2991e-01, 5.7974e-01, 6.2599e-01,
1286                     6.6750e-01, 7.0344e-01, 7.3329e-01, 7.5676e-01,
1287                     7.7371e-01, 7.8410e-01, 7.8793e-01, 7.8410e-01,
1288                     7.7371e-01, 7.5676e-01, 7.3329e-01, 7.0344e-01,
1289                     6.6750e-01, 6.2599e-01, 5.7974e-01, 5.2991e-01,
1290                     4.7796e-01, 4.2563e-01, 3.7450e-01, 3.2594e-01,
1291                     2.8093e-01, 2.4013e-01, 2.0381e-01, 1.7196e-01,
1292                     1.4442e-01, 1.2094e-01, 1.0102e-01, 8.4257e-02,
1293                     7.0253e-02, 5.8612e-02, 4.8966e-02, 4.0979e-02,
1294                     3.4357e-02, 2.8860e-02, 2.4286e-02, 2.0450e-02,
1295                     1.7224e-02},
1296                    {1.5096e-02, 1.8041e-02, 2.1566e-02, 2.5793e-02,
1297                     3.0886e-02, 3.7044e-02, 4.4515e-02, 5.3604e-02,
1298                     6.4668e-02, 7.8109e-02, 9.4364e-02, 1.1389e-01,
1299                     1.3716e-01, 1.6461e-01, 1.9663e-01, 2.3350e-01,
1300                     2.7527e-01, 3.2170e-01, 3.7214e-01, 4.2549e-01,
1301                     4.8024e-01, 5.3460e-01, 5.8677e-01, 6.3512e-01,
1302                     6.7838e-01, 7.1569e-01, 7.4655e-01, 7.7071e-01,
1303                     7.8810e-01, 7.9871e-01, 8.0255e-01, 7.9871e-01,
1304                     7.8810e-01, 7.7071e-01, 7.4655e-01, 7.1569e-01,
1305                     6.7838e-01, 6.3512e-01, 5.8677e-01, 5.3460e-01,
1306                     4.8024e-01, 4.2549e-01, 3.7214e-01, 3.2170e-01,
1307                     2.7527e-01, 2.3350e-01, 1.9663e-01, 1.6461e-01,
1308                     1.3716e-01, 1.1389e-01, 9.4364e-02, 7.8109e-02,
1309                     6.4668e-02, 5.3604e-02, 4.4515e-02, 3.7044e-02,
1310                     3.0886e-02, 2.5793e-02, 2.1566e-02, 1.8041e-02,
1311                     1.5096e-02}};
1312
1313   // More sampling precision with linear interpolation
1314   fPRFlo  = -1.5;
1315   fPRFhi  =  1.5;
1316   Float_t pad[kPRFbin];
1317   Int_t   sPRFbin = kPRFbin;  
1318   Float_t sPRFwid = (fPRFhi - fPRFlo) / ((Float_t) sPRFbin);
1319   for (Int_t iPad = 0; iPad < sPRFbin; iPad++) {
1320     pad[iPad] = ((Float_t) iPad + 0.5) * sPRFwid + fPRFlo;
1321   }
1322   fPRFbin = 500;  
1323   fPRFwid = (fPRFhi - fPRFlo) / ((Float_t) fPRFbin);
1324   fPRFpad = ((Int_t) (1.0 / fPRFwid));
1325
1326   if (fPRFsmp) delete [] fPRFsmp;
1327   fPRFsmp = new Float_t[kNlayer*fPRFbin];
1328
1329   Int_t   ipos1;
1330   Int_t   ipos2;
1331   Float_t diff;
1332
1333   for (Int_t iLayer = 0; iLayer < kNlayer; iLayer++) {
1334
1335     for (Int_t iBin = 0; iBin < fPRFbin; iBin++) {
1336
1337       Float_t bin = (((Float_t) iBin) + 0.5) * fPRFwid + fPRFlo;
1338       ipos1 = ipos2 = 0;
1339       diff  = 0;
1340       do {
1341         diff = bin - pad[ipos2++];
1342       } while ((diff > 0) && (ipos2 < kPRFbin));
1343       if      (ipos2 == kPRFbin) {
1344         fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2-1];
1345       }
1346       else if (ipos2 == 1) {
1347         fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2-1];
1348       }
1349       else {
1350         ipos2--;
1351         if (ipos2 >= kPRFbin) ipos2 = kPRFbin - 1;
1352         ipos1 = ipos2 - 1;
1353         fPRFsmp[iLayer*fPRFbin+iBin] = prf[iLayer][ipos2] 
1354                                      + diff * (prf[iLayer][ipos2] - prf[iLayer][ipos1]) 
1355                                      / sPRFwid;
1356       }
1357
1358     }
1359   } 
1360
1361 }
1362
1363 //_____________________________________________________________________________
1364 Int_t AliTRDcalibDB::PadResponse(Double_t signal, Double_t dist
1365                                , Int_t layer, Double_t *pad) const
1366 {
1367   //
1368   // Applies the pad response
1369   // So far this is the fixed parametrization and should be replaced by
1370   // something dependent on calibration values
1371   //
1372
1373   Int_t iBin  = ((Int_t) ((-dist - fPRFlo) / fPRFwid));
1374   Int_t iOff  = layer * fPRFbin;
1375
1376   Int_t iBin0 = iBin - fPRFpad + iOff;
1377   Int_t iBin1 = iBin           + iOff;
1378   Int_t iBin2 = iBin + fPRFpad + iOff;
1379
1380   pad[0] = 0.0;
1381   pad[1] = 0.0;
1382   pad[2] = 0.0;
1383   if ((iBin1 >= 0) && (iBin1 < (fPRFbin*kNlayer))) {
1384
1385     if (iBin0 >= 0) {
1386       pad[0] = signal * fPRFsmp[iBin0];
1387     }
1388     pad[1] = signal * fPRFsmp[iBin1];
1389     if (iBin2 < (fPRFbin*kNlayer)) {
1390       pad[2] = signal * fPRFsmp[iBin2];
1391     }
1392
1393     return 1;
1394
1395   }
1396   else {
1397
1398     return 0;
1399
1400   }
1401
1402 }
1403
1404