Bug fix in LUT
[u/mrichter/AliRoot.git] / TRD / AliTRDparameter.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 $Log$
18 Revision 1.6  2002/06/12 09:54:35  cblume
19 Update of tracking code provided by Sergei
20
21 Revision 1.5  2002/04/30 08:30:40  cblume
22 gAlice now only read by AliRunDigitizer. Therefore it is just deleted in AliTRDmerge.C
23
24 Revision 1.4  2002/04/12 12:13:23  cblume
25 Add Jiris changes
26
27 Revision 1.3  2002/03/28 14:59:07  cblume
28 Coding conventions
29
30 Revision 1.2  2002/03/28 10:00:36  hristov
31 Some additional initialisation
32
33 Revision 1.1  2002/03/25 20:01:18  cblume
34 Introduce parameter class
35
36 */
37
38 ///////////////////////////////////////////////////////////////////////////////
39 //                                                                           //
40 //  TRD parameter class                                                      //
41 //                                                                           //
42 ///////////////////////////////////////////////////////////////////////////////
43
44 #include "AliRun.h"
45 #include "AliMagF.h"
46
47 #include "AliTRD.h"
48 #include "AliTRDparameter.h"
49 #include "AliTRDgeometryFull.h"
50
51 ClassImp(AliTRDparameter)
52
53 //_____________________________________________________________________________
54 AliTRDparameter::AliTRDparameter():TNamed()
55 {
56   //
57   // AliTRDparameter default constructor
58   //
59
60   fGeo                = 0;
61   fPRFsmp             = 0;
62   fTRFsmp             = 0;
63   fCTsmp              = 0;
64   fGasGain            = 0.0;
65   fNoise              = 0.0;
66   fChipGain           = 0.0;
67   fADCoutRange        = 0.0;
68   fADCinRange         = 0.0;
69   fADCthreshold       = 0;
70   fDiffusionOn        = 0;
71   fDiffusionT         = 0.0;
72   fDiffusionL         = 0.0;
73   fElAttachOn         = 0;
74   fElAttachProp       = 0.0;
75   fExBOn              = 0;
76   fOmegaTau           = 0.0;
77   fPRFOn              = 0;
78   fTRFOn              = 0;
79   fCTOn               = 0;
80   fTCOn               = 0;
81   fDriftVelocity      = 0.0;
82   fPadCoupling        = 0.0;
83   fTimeCoupling       = 0.0;
84   fTimeBinWidth       = 0.0;
85   fField              = 0.0;
86   fTiltingAngle       = 0.0;
87   fPRFbin             = 0;
88   fPRFlo              = 0.0;
89   fPRFhi              = 0.0;
90   fPRFwid             = 0.0;
91   fPRFpad             = 0;
92   fTRFbin             = 0;
93   fTRFlo              = 0.0;
94   fTRFhi              = 0.0;
95   fTRFwid             = 0.0;
96   fTCnexp             = 0;
97
98   fLUTOn              = 0;  
99   fLUT                = 0;
100   fClusMaxThresh      = 0;
101   fClusSigThresh      = 0;
102
103 }
104
105 //_____________________________________________________________________________
106 AliTRDparameter::AliTRDparameter(const Text_t *name, const Text_t *title)
107                 :TNamed(name,title)
108 {
109   //
110   // AliTRDparameter constructor
111   //
112
113   fGeo                = new AliTRDgeometryFull();
114   fPRFsmp             = 0;
115   fTRFsmp             = 0;
116   fCTsmp              = 0;
117   fGasGain            = 0.0;
118   fNoise              = 0.0;
119   fChipGain           = 0.0;
120   fADCoutRange        = 0.0;
121   fADCinRange         = 0.0;
122   fADCthreshold       = 0;
123   fDiffusionOn        = 0;
124   fDiffusionT         = 0.0;
125   fDiffusionL         = 0.0;
126   fElAttachOn         = 0;
127   fElAttachProp       = 0.0;
128   fExBOn              = 0;
129   fOmegaTau           = 0.0;
130   fPRFOn              = 0;
131   fTRFOn              = 0;
132   fCTOn               = 0;
133   fTCOn               = 0;
134   fDriftVelocity      = 0.0;
135   fPadCoupling        = 0.0;
136   fTimeCoupling       = 0.0;
137   fTimeBinWidth       = 0.0;
138   fField              = 0.0;
139   fTiltingAngle       = 0.0;
140   fPRFbin             = 0;
141   fPRFlo              = 0.0;
142   fPRFhi              = 0.0;
143   fPRFwid             = 0.0;
144   fPRFpad             = 0;
145   fTRFbin             = 0;
146   fTRFlo              = 0.0;
147   fTRFhi              = 0.0;
148   fTRFwid             = 0.0;
149   fTCnexp             = 0;
150
151   fLUTOn              = 0;  
152   fLUT                = 0;
153   fClusMaxThresh      = 0;
154   fClusSigThresh      = 0;
155
156   Init();
157
158 }
159
160
161 //_____________________________________________________________________________
162 AliTRDparameter::AliTRDparameter(const AliTRDparameter &p)
163 {
164   //
165   // AliTRDparameter copy constructor
166   //
167
168   ((AliTRDparameter &) p).Copy(*this);
169
170 }
171
172 ///_____________________________________________________________________________
173 AliTRDparameter::~AliTRDparameter()
174 {
175   //
176   // AliTRDparameter destructor
177   //
178
179   if (fTRFsmp) {
180     delete [] fTRFsmp;
181     fTRFsmp = 0;
182   }
183
184   if (fPRFsmp) {
185     delete [] fPRFsmp;
186     fPRFsmp = 0;
187   }
188
189   if (fCTsmp) {
190     delete [] fCTsmp;
191     fCTsmp  = 0;
192   }
193
194   if (fLUT) {
195     delete [] fLUT;
196     fLUT    = 0;
197   }
198
199   if (fGeo) {
200     delete fGeo;
201     fGeo    = 0;
202   }
203
204 }
205
206 //_____________________________________________________________________________
207 AliTRDparameter &AliTRDparameter::operator=(const AliTRDparameter &p)
208 {
209   //
210   // Assignment operator
211   //
212
213   if (this != &p) ((AliTRDparameter &) p).Copy(*this);
214   return *this;
215
216 }
217
218 //_____________________________________________________________________________
219 void AliTRDparameter::Copy(TObject &p)
220 {
221   //
222   // Copy function
223   //
224
225   Int_t iBin;
226
227   ((AliTRDparameter &) p).fGasGain            = fGasGain;
228   ((AliTRDparameter &) p).fNoise              = fNoise;
229   ((AliTRDparameter &) p).fChipGain           = fChipGain;
230   ((AliTRDparameter &) p).fADCoutRange        = fADCoutRange;
231   ((AliTRDparameter &) p).fADCinRange         = fADCinRange;
232   ((AliTRDparameter &) p).fADCthreshold       = fADCthreshold;
233   ((AliTRDparameter &) p).fDiffusionOn        = fDiffusionOn; 
234   ((AliTRDparameter &) p).fDiffusionT         = fDiffusionT;
235   ((AliTRDparameter &) p).fDiffusionL         = fDiffusionL;
236   ((AliTRDparameter &) p).fElAttachOn         = fElAttachOn;
237   ((AliTRDparameter &) p).fElAttachProp       = fElAttachProp;
238   ((AliTRDparameter &) p).fExBOn              = fExBOn;
239   ((AliTRDparameter &) p).fOmegaTau           = fOmegaTau;
240   ((AliTRDparameter &) p).fLorentzFactor      = fLorentzFactor;
241   ((AliTRDparameter &) p).fDriftVelocity      = fDriftVelocity;
242   ((AliTRDparameter &) p).fPadCoupling        = fPadCoupling;
243   ((AliTRDparameter &) p).fTimeCoupling       = fTimeCoupling;
244   ((AliTRDparameter &) p).fTimeBinWidth       = fTimeBinWidth;
245   ((AliTRDparameter &) p).fField              = fField;
246   ((AliTRDparameter &) p).fPRFOn              = fPRFOn;
247   ((AliTRDparameter &) p).fTRFOn              = fTRFOn;
248   ((AliTRDparameter &) p).fCTOn               = fCTOn;
249   ((AliTRDparameter &) p).fTCOn               = fTCOn;
250   ((AliTRDparameter &) p).fTiltingAngle       = fTiltingAngle;
251   ((AliTRDparameter &) p).fPRFbin             = fPRFbin;
252   ((AliTRDparameter &) p).fPRFlo              = fPRFlo;
253   ((AliTRDparameter &) p).fPRFhi              = fPRFhi;
254   ((AliTRDparameter &) p).fPRFwid             = fPRFwid;
255   ((AliTRDparameter &) p).fPRFpad             = fPRFpad;
256   if (((AliTRDparameter &) p).fPRFsmp) delete [] ((AliTRDparameter &) p).fPRFsmp;
257   ((AliTRDparameter &) p).fPRFsmp = new Float_t[fPRFbin];
258   for (iBin = 0; iBin < fPRFbin; iBin++) {
259     ((AliTRDparameter &) p).fPRFsmp[iBin] = fPRFsmp[iBin];
260   }                                                                             
261   ((AliTRDparameter &) p).fTRFbin             = fTRFbin;
262   ((AliTRDparameter &) p).fTRFlo              = fTRFlo;
263   ((AliTRDparameter &) p).fTRFhi              = fTRFhi;
264   ((AliTRDparameter &) p).fTRFwid             = fTRFwid;
265   if (((AliTRDparameter &) p).fTRFsmp) delete [] ((AliTRDparameter &) p).fTRFsmp;
266   ((AliTRDparameter &) p).fTRFsmp = new Float_t[fTRFbin];
267   for (iBin = 0; iBin < fTRFbin; iBin++) {
268     ((AliTRDparameter &) p).fTRFsmp[iBin] = fTRFsmp[iBin];
269   }                                      
270   if (((AliTRDparameter &) p).fCTsmp)  delete [] ((AliTRDparameter &) p).fCTsmp;
271   ((AliTRDparameter &) p).fCTsmp  = new Float_t[fTRFbin];
272   for (iBin = 0; iBin < fTRFbin; iBin++) {
273     ((AliTRDparameter &) p).fCTsmp[iBin]  = fCTsmp[iBin];
274   }                                      
275   ((AliTRDparameter &) p).fTCnexp             = fTCnexp;
276
277   ((AliTRDparameter &) p).fLUTOn              = fLUTOn;
278   ((AliTRDparameter &) p).fLUTbin             = fLUTbin;
279   if (((AliTRDparameter &) p).fLUT)    delete [] ((AliTRDparameter &) p).fLUT;
280   ((AliTRDparameter &) p).fLUT  = new Float_t[fLUTbin];
281   for (iBin = 0; iBin < fLUTbin; iBin++) {
282     ((AliTRDparameter &) p).fLUT[iBin]  = fLUT[iBin];
283   }                                      
284   ((AliTRDparameter &) p).fClusMaxThresh      = fClusMaxThresh;
285   ((AliTRDparameter &) p).fClusSigThresh      = fClusSigThresh;
286
287 }
288
289 //_____________________________________________________________________________
290 void AliTRDparameter::Init()
291 {
292   //
293   // Initializes the parameter
294   //
295   // The maximum number of pads
296   // and the position of pad 0,0,0
297   //
298   // chambers seen from the top:
299   //     +----------------------------+
300   //     |                            |
301   //     |                            |      ^
302   //     |                            |  rphi|
303   //     |                            |      |
304   //     |0                           |      |
305   //     +----------------------------+      +------>
306   //                                             z
307   // chambers seen from the side:            ^
308   //     +----------------------------+ drift|
309   //     |0                           |      |
310   //     |                            |      |
311   //     +----------------------------+      +------>
312   //                                             z
313   //
314   // IMPORTANT: time bin 0 is now the first one in the drift region
315   // closest to the readout !!!
316   //
317
318   //
319   // ----------------------------------------------------------------------------
320   // The pad definition
321   // ----------------------------------------------------------------------------
322   //
323
324   // The pad size in column direction (rphi-direction)
325   SetColPadSize(0,0.65);
326   SetColPadSize(1,0.68);
327   SetColPadSize(2,0.71);
328   SetColPadSize(3,0.74);
329   SetColPadSize(4,0.77);
330   SetColPadSize(5,0.80);
331
332   // The pad row (z-direction)
333   SetNRowPad();
334
335   // The number of time bins. Default is 100 ns timbin size
336   SetNTimeBin(15);
337
338   // Additional time bins before and after the drift region.
339   // Default is to only sample the drift region
340   SetExpandTimeBin(0,0);
341
342   //
343   // ----------------------------------------------------------------------------
344   // The digitization parameter
345   // ----------------------------------------------------------------------------
346   //
347
348   // The default parameter for the digitization
349   fGasGain        = 4500.;
350   fChipGain       = 12.4;
351   fNoise          = 1000.;
352   fADCoutRange    = 1023.;          // 10-bit ADC
353   fADCinRange     = 1000.;          // 1V input range
354   fADCthreshold   = 1;
355
356   // The drift velocity (cm / mus)
357   fDriftVelocity  = 1.5;
358
359   // Diffusion on
360   fDiffusionOn    = 1;
361
362   // E x B effects
363   fExBOn          = 0;
364
365   // Propability for electron attachment
366   fElAttachOn     = 0;
367   fElAttachProp   = 0.0;
368
369   // The pad response function
370   fPRFOn          = 1;
371
372   // The time response function
373   fTRFOn          = 1;
374
375   // The cross talk
376   fCTOn           = 0;
377
378   // The tail cancelation
379   fTCOn           = 1;
380   
381   // The number of exponentials
382   fTCnexp         = 2;
383
384   // The pad coupling factor (same number as for the TPC)
385   fPadCoupling    = 0.5;
386
387   // The time coupling factor (same number as for the TPC)
388   fTimeCoupling   = 0.4;
389
390   // The tilting angle for the readout pads
391   //SetTiltingAngle(5.0);
392   SetTiltingAngle(0.0);
393
394   // The magnetic field strength in Tesla
395   //fField           = 0.2 * gAlice->Field()->Factor();
396   fField           = 0.4;
397
398   //
399   // ----------------------------------------------------------------------------
400   // The clusterization parameter
401   // ----------------------------------------------------------------------------
402   //
403
404   // The default parameter for the clustering
405   fClusMaxThresh = 3;
406   fClusSigThresh = 1;
407
408   // Use the LUT
409   fLUTOn         = 1;  
410
411   ReInit();
412
413 }
414
415 //_____________________________________________________________________________
416 void AliTRDparameter::ReInit()
417 {
418   //
419   // Reinitializes the parameter class after a change
420   //
421
422   // Calculate the time bin width in ns
423   fTimeBinWidth   = fTimeBinSize / fDriftVelocity * 1000.0;
424
425   // The range and the binwidth for the sampled TRF 
426   fTRFbin = 100;
427   // Start 0.2 mus before the signal
428   fTRFlo  = -0.2 * fDriftVelocity;
429   // End the maximum driftlength after the signal 
430   fTRFhi  = AliTRDgeometry::DrThick() 
431           + fTimeAfter * fTimeBinSize;
432   fTRFwid = (fTRFhi - fTRFlo) / ((Float_t) fTRFbin);
433
434   // Transverse and longitudinal diffusion coefficients (Xe/CO2)
435   fDiffusionT     = GetDiffusionT(fDriftVelocity,fField);
436   fDiffusionL     = GetDiffusionL(fDriftVelocity,fField);
437
438   // omega * tau.= tan(Lorentz-angle)
439   fOmegaTau       = GetOmegaTau(fDriftVelocity,fField);
440
441   // The Lorentz factor
442   if (fExBOn) {
443     fLorentzFactor = 1.0 / (1.0 + fOmegaTau*fOmegaTau);
444   }
445   else {
446     fLorentzFactor = 1.0;
447   }
448
449   // Create the sampled PRF
450   SamplePRF();
451
452   // Create the sampled TRF
453   SampleTRF();
454
455   // Create the LUT
456   FillLUT();
457
458 }
459
460 //_____________________________________________________________________________
461 void AliTRDparameter::SetNRowPad(const Int_t p, const Int_t c, const Int_t npad)
462 {
463   //
464   // Redefines the number of pads in raw direction for
465   // a given plane and chamber number
466   //
467
468   for (Int_t isect = 0; isect < AliTRDgeometry::Nsect(); isect++) {
469
470     fRowMax[p][c][isect] = npad;
471
472     fRowPadSize[p][c][isect] = (fGeo->GetChamberLength(p,c) 
473                                 - 2.* AliTRDgeometry::RpadW())
474                              / ((Float_t) npad);
475
476   }
477
478 }
479
480 //_____________________________________________________________________________
481 void AliTRDparameter::SetNRowPad()
482 {
483   //
484   // Defines the number of pads in row direction
485   //
486
487   Int_t isect;
488   Int_t icham;
489   Int_t iplan;
490
491   Int_t rowMax[kNplan][kNcham] = { { 16, 16, 12, 16, 16 }
492                                  , { 16, 16, 12, 16, 16 }
493                                  , { 16, 16, 12, 16, 16 }
494                                  , { 16, 16, 12, 16, 16 }
495                                  , { 14, 16, 12, 16, 14 }
496                                  , { 13, 16, 12, 16, 13 } };
497
498   Float_t rpadW = AliTRDgeometry::RpadW();
499
500   for (isect = 0; isect < kNsect; isect++) {
501     for (icham = 0; icham < kNcham; icham++) {
502       for (iplan = 0; iplan < kNplan; iplan++) {
503
504         fRowMax[iplan][icham][isect]     = rowMax[iplan][icham];
505
506         fRowPadSize[iplan][icham][isect] = (fGeo->GetChamberLength(iplan,icham) 
507                                             - 2.*rpadW)
508                                          / ((Float_t) rowMax[iplan][icham]);
509
510         Float_t row0 = rpadW - fGeo->GetChamberLength(iplan,0)
511                              - fGeo->GetChamberLength(iplan,1)
512                              - fGeo->GetChamberLength(iplan,2) / 2.;
513         for (Int_t ic = 0; ic < icham; ic++) {
514           row0 += fGeo->GetChamberLength(iplan,icham);
515         }
516         fRow0[iplan][icham][isect]       = row0;
517
518       }
519     }
520   }
521
522 }
523
524 //_____________________________________________________________________________
525 void AliTRDparameter::SetColPadSize(const Int_t p, const Float_t s)
526 {
527   //
528   // Redefines the pad size in column direction
529   //
530
531   Float_t cpadW  = AliTRDgeometry::CpadW();
532
533   fColPadSize[p] = s;
534   fCol0[p]       = - fGeo->GetChamberWidth(p)/2. + cpadW;
535   fColMax[p]     = ((Int_t) ((fGeo->GetChamberWidth(p) - 2.*cpadW) / s));
536
537 }
538
539 //_____________________________________________________________________________
540 void AliTRDparameter::SetNTimeBin(const Int_t nbin)
541 {
542   //
543   // Redefines the number of time bins in the drift region.
544   // The time bin width is defined by the length of the
545   // drift region divided by <nbin>.
546   //
547
548   fTimeMax     = nbin;
549   fTimeBinSize = AliTRDgeometry::DrThick() / ((Float_t) fTimeMax);
550   for (Int_t iplan = 0; iplan < AliTRDgeometry::Nplan(); iplan++) {
551     fTime0[iplan] = AliTRDgeometry::Rmin()
552                   + AliTRDgeometry::CraHght()
553                   + AliTRDgeometry::CdrHght()
554                   + iplan * (AliTRDgeometry::Cheight() 
555                            + AliTRDgeometry::Cspace());
556   }
557
558 }
559
560 //_____________________________________________________________________________
561 Float_t AliTRDparameter::CrossTalk(Float_t time) const
562 {
563   //
564   // Applies the pad-pad capacitive cross talk
565   //
566
567   Int_t iBin = ((Int_t) ((time - fTRFlo) / fTRFwid)); 
568   if ((iBin >= 0) && (iBin < fTRFbin)) {
569     return fCTsmp[iBin];
570   }
571   else {
572     return 0.0;
573   }    
574
575 }
576
577 //_____________________________________________________________________________
578 Int_t AliTRDparameter::Diffusion(Float_t driftlength, Float_t *xyz)
579 {
580   //
581   // Applies the diffusion smearing to the position of a single electron
582   //
583
584   Float_t driftSqrt = TMath::Sqrt(driftlength);
585   Float_t sigmaT = driftSqrt * fDiffusionT;
586   Float_t sigmaL = driftSqrt * fDiffusionL;
587   xyz[0] = gRandom->Gaus(xyz[0], sigmaL * fLorentzFactor);
588   xyz[1] = gRandom->Gaus(xyz[1], sigmaT * fLorentzFactor);
589   xyz[2] = gRandom->Gaus(xyz[2], sigmaT);
590
591   return 1;
592
593 }
594
595 //_____________________________________________________________________________
596 Int_t AliTRDparameter::ExB(Float_t driftlength, Float_t *xyz) const
597 {
598   //
599   // Applies E x B effects to the position of a single electron
600   //
601
602   xyz[0] = xyz[0];
603   xyz[1] = xyz[1] + fOmegaTau * driftlength;
604   xyz[2] = xyz[2];
605
606   return 1;
607
608 }
609
610 //_____________________________________________________________________________
611 Int_t AliTRDparameter::PadResponse(Float_t signal, Float_t dist
612                                  , Int_t plane, Float_t *pad) const
613 {
614   //
615   // Applies the pad response
616   //
617
618   const Int_t kNplan = AliTRDgeometry::kNplan;
619
620   Int_t iBin  = ((Int_t) (( - dist - fPRFlo) / fPRFwid));
621   Int_t iOff  = plane * fPRFbin;
622
623   Int_t iBin0 = iBin - fPRFpad + iOff;
624   Int_t iBin1 = iBin           + iOff;
625   Int_t iBin2 = iBin + fPRFpad + iOff;
626
627   pad[0] = 0.0;
628   pad[1] = 0.0;
629   pad[2] = 0.0;
630   if ((iBin1 >= 0) && (iBin1 < (fPRFbin*kNplan))) {
631
632     if (iBin0 >= 0) {
633       pad[0] = signal * fPRFsmp[iBin0];
634     }
635     pad[1] = signal * fPRFsmp[iBin1];
636     if (iBin2 < (fPRFbin*kNplan)) {
637       pad[2] = signal * fPRFsmp[iBin2];
638     }
639
640     return 1;
641
642   }
643   else {
644
645     return 0;
646
647   }
648
649 }
650
651 //_____________________________________________________________________________
652 Float_t AliTRDparameter::TimeResponse(Float_t time) const
653 {
654   //
655   // Applies the preamp shaper time response
656   //
657
658   Int_t iBin = ((Int_t) ((time - fTRFlo) / fTRFwid)); 
659   if ((iBin >= 0) && (iBin < fTRFbin)) {
660     return fTRFsmp[iBin];
661   }
662   else {
663     return 0.0;
664   }    
665
666 }
667
668 //_____________________________________________________________________________
669 Float_t AliTRDparameter::Col0Tilted(Float_t col0, Float_t rowOffset
670                                   , Int_t plane)
671 {
672   //
673   // Calculates col0 for tilted pads
674   //
675
676   Float_t diff = fTiltingAngle * rowOffset;
677   return (col0 + TMath::Power(-1.0,plane) * diff);
678
679 }
680
681 //_____________________________________________________________________________
682 void AliTRDparameter::SampleTRF()
683 {
684   //
685   // Samples the time response function
686   //
687   // New TRF from Venelin Angelov, simulated with CADENCE
688   // Pad-ground capacitance = 25 pF
689   // Pad-pad cross talk capacitance = 6 pF   
690   //
691
692   Int_t   ipos1;
693   Int_t   ipos2;
694   Float_t diff;
695
696   const Int_t kNpasa     = 252;
697
698   Float_t time[kNpasa]   = { -0.220000, -0.210000, -0.200000, -0.190000 
699                            , -0.180000, -0.170000, -0.160000, -0.150000 
700                            , -0.140000, -0.130000, -0.120000, -0.110000 
701                            , -0.100000, -0.090000, -0.080000, -0.070000 
702                            , -0.060000, -0.050000, -0.040000, -0.030000 
703                            , -0.020000, -0.010000, -0.000000,  0.010000 
704                            ,  0.020000,  0.030000,  0.040000,  0.050000 
705                            ,  0.060000,  0.070000,  0.080000,  0.090000 
706                            ,  0.100000,  0.110000,  0.120000,  0.130000 
707                            ,  0.140000,  0.150000,  0.160000,  0.170000 
708                            ,  0.180000,  0.190000,  0.200000,  0.210000 
709                            ,  0.220000,  0.230000,  0.240000,  0.250000 
710                            ,  0.260000,  0.270000,  0.280000,  0.290000 
711                            ,  0.300000,  0.310000,  0.320000,  0.330000 
712                            ,  0.340000,  0.350000,  0.360000,  0.370000 
713                            ,  0.380000,  0.390000,  0.400000,  0.410000 
714                            ,  0.420000,  0.430000,  0.440000,  0.450000 
715                            ,  0.460000,  0.470000,  0.480000,  0.490000 
716                            ,  0.500000,  0.510000,  0.520000,  0.530000 
717                            ,  0.540000,  0.550000,  0.560000,  0.570000 
718                            ,  0.580000,  0.590000,  0.600000,  0.610000 
719                            ,  0.620000,  0.630000,  0.640000,  0.650000 
720                            ,  0.660000,  0.670000,  0.680000,  0.690000 
721                            ,  0.700000,  0.710000,  0.720000,  0.730000 
722                            ,  0.740000,  0.750000,  0.760000,  0.770000 
723                            ,  0.780000,  0.790000,  0.800000,  0.810000 
724                            ,  0.820000,  0.830000,  0.840000,  0.850000 
725                            ,  0.860000,  0.870000,  0.880000,  0.890000 
726                            ,  0.900000,  0.910000,  0.920000,  0.930000 
727                            ,  0.940000,  0.950000,  0.960000,  0.970000 
728                            ,  0.980000,  0.990000,  1.000000,  1.010000 
729                            ,  1.020000,  1.030000,  1.040000,  1.050000 
730                            ,  1.060000,  1.070000,  1.080000,  1.090000 
731                            ,  1.100000,  1.110000,  1.120000,  1.130000 
732                            ,  1.140000,  1.150000,  1.160000,  1.170000 
733                            ,  1.180000,  1.190000,  1.200000,  1.210000 
734                            ,  1.220000,  1.230000,  1.240000,  1.250000 
735                            ,  1.260000,  1.270000,  1.280000,  1.290000 
736                            ,  1.300000,  1.310000,  1.320000,  1.330000 
737                            ,  1.340000,  1.350000,  1.360000,  1.370000 
738                            ,  1.380000,  1.390000,  1.400000,  1.410000 
739                            ,  1.420000,  1.430000,  1.440000,  1.450000 
740                            ,  1.460000,  1.470000,  1.480000,  1.490000 
741                            ,  1.500000,  1.510000,  1.520000,  1.530000 
742                            ,  1.540000,  1.550000,  1.560000,  1.570000 
743                            ,  1.580000,  1.590000,  1.600000,  1.610000 
744                            ,  1.620000,  1.630000,  1.640000,  1.650000 
745                            ,  1.660000,  1.670000,  1.680000,  1.690000 
746                            ,  1.700000,  1.710000,  1.720000,  1.730000 
747                            ,  1.740000,  1.750000,  1.760000,  1.770000 
748                            ,  1.780000,  1.790000,  1.800000,  1.810000 
749                            ,  1.820000,  1.830000,  1.840000,  1.850000 
750                            ,  1.860000,  1.870000,  1.880000,  1.890000 
751                            ,  1.900000,  1.910000,  1.920000,  1.930000 
752                            ,  1.940000,  1.950000,  1.960000,  1.970000 
753                            ,  1.980000,  1.990000,  2.000000,  2.010000 
754                            ,  2.020000,  2.030000,  2.040000,  2.050000 
755                            ,  2.060000,  2.070000,  2.080000,  2.090000 
756                            ,  2.100000,  2.110000,  2.120000,  2.130000 
757                            ,  2.140000,  2.150000,  2.160000,  2.170000 
758                            ,  2.180000,  2.190000,  2.200000,  2.210000 
759                            ,  2.220000,  2.230000,  2.240000,  2.250000 
760                            ,  2.260000,  2.270000,  2.280000,  2.290000 };
761
762   Float_t signal[kNpasa] = {  0.000000,  0.000000,  0.000000,  0.000000 
763                            ,  0.000000,  0.000000,  0.000000,  0.000396 
764                            ,  0.005096,  0.022877,  0.061891,  0.126614 
765                            ,  0.215798,  0.324406,  0.444507,  0.566817 
766                            ,  0.683465,  0.787089,  0.873159,  0.937146 
767                            ,  0.979049,  0.999434,  1.000000,  0.983579 
768                            ,  0.954134,  0.913364,  0.866365,  0.813703 
769                            ,  0.759910,  0.706116,  0.653454,  0.603624 
770                            ,  0.556625,  0.514156,  0.475085,  0.439977 
771                            ,  0.408834,  0.380578,  0.355549,  0.333352 
772                            ,  0.313647,  0.296093,  0.280351,  0.266195 
773                            ,  0.253397,  0.241789,  0.231257,  0.221574 
774                            ,  0.212627,  0.204417,  0.196772,  0.189581 
775                            ,  0.182956,  0.176784,  0.171008,  0.165515 
776                            ,  0.160419,  0.155606,  0.151076,  0.146716 
777                            ,  0.142639,  0.138845,  0.135221,  0.131767 
778                            ,  0.128482,  0.125368,  0.122424,  0.119592 
779                            ,  0.116931,  0.114326,  0.111891,  0.109513 
780                            ,  0.107248,  0.105096,  0.103058,  0.101019 
781                            ,  0.099151,  0.097282,  0.095527,  0.093715 
782                            ,  0.092129,  0.090544,  0.088958,  0.087429 
783                            ,  0.086014,  0.084598,  0.083239,  0.081880 
784                            ,  0.080634,  0.079388,  0.078143,  0.077010 
785                            ,  0.075878,  0.074745,  0.073669,  0.072593 
786                            ,  0.071574,  0.070612,  0.069649,  0.068686 
787                            ,  0.067780,  0.066874,  0.066025,  0.065176 
788                            ,  0.064326,  0.063533,  0.062684,  0.061948 
789                            ,  0.061212,  0.060419,  0.059740,  0.059003 
790                            ,  0.058324,  0.057644,  0.057022,  0.056342 
791                            ,  0.055663,  0.055096,  0.054473,  0.053851 
792                            ,  0.053284,  0.052718,  0.052152,  0.051585 
793                            ,  0.051019,  0.050566,  0.050000,  0.049490 
794                            ,  0.048981,  0.048528,  0.048018,  0.047508 
795                            ,  0.047055,  0.046602,  0.046149,  0.045696 
796                            ,  0.045300,  0.044904,  0.044451,  0.044054 
797                            ,  0.043658,  0.043205,  0.042865,  0.042469 
798                            ,  0.042072,  0.041733,  0.041336,  0.040997 
799                            ,  0.040657,  0.040260,  0.039921,  0.039581 
800                            ,  0.039241,  0.038958,  0.038618,  0.038335 
801                            ,  0.037995,  0.037656,  0.037373,  0.037089 
802                            ,  0.036806,  0.036467,  0.036183,  0.035900 
803                            ,  0.035617,  0.035334,  0.035108,  0.034824 
804                            ,  0.034541,  0.034315,  0.034032,  0.033805 
805                            ,  0.033522,  0.033296,  0.033069,  0.032786 
806                            ,  0.032559,  0.032333,  0.032106,  0.031880 
807                            ,  0.031653,  0.031427,  0.031200,  0.030974 
808                            ,  0.030804,  0.030578,  0.030351,  0.030125 
809                            ,  0.029955,  0.029785,  0.029558,  0.029332 
810                            ,  0.029162,  0.028992,  0.028766,  0.028596 
811                            ,  0.028426,  0.028199,  0.028086,  0.027860 
812                            ,  0.027746,  0.027633,  0.027463,  0.027293 
813                            ,  0.027180,  0.027067,  0.026954,  0.026954 
814                            ,  0.026840,  0.026727,  0.026727,  0.026614 
815                            ,  0.026614,  0.026614,  0.026557,  0.026501 
816                            ,  0.026501,  0.026501,  0.026501,  0.026501 
817                            ,  0.026501,  0.026501,  0.026501,  0.026387 
818                            ,  0.026387,  0.026387,  0.026387,  0.026387 
819                            ,  0.026387,  0.026387,  0.026387,  0.026387 
820                            ,  0.026387,  0.026387,  0.026387,  0.026387 
821                            ,  0.026387,  0.026274,  0.026274,  0.026274 
822                            ,  0.026274,  0.026274,  0.026274,  0.026274 
823                            ,  0.026274,  0.026274,  0.026274,  0.026274 
824                            ,  0.026274,  0.026274,  0.026274,  0.026161 };
825
826   Float_t xtalk[kNpasa]  = {  0.000000,  0.000000,  0.000000,  0.000000 
827                            ,  0.000000,  0.000000,  0.000000,  0.000113 
828                            ,  0.000793,  0.003058,  0.007305,  0.013194 
829                            ,  0.019706,  0.025821,  0.030634,  0.033465 
830                            ,  0.034145,  0.032729,  0.029615,  0.025198 
831                            ,  0.019989,  0.014496,  0.009003,  0.003964 
832                            , -0.000510, -0.004190, -0.007191, -0.009400 
833                            , -0.010872, -0.011835, -0.012288, -0.012288 
834                            , -0.012005, -0.011495, -0.010872, -0.010136 
835                            , -0.009343, -0.008607, -0.007871, -0.007191 
836                            , -0.006512, -0.005946, -0.005379, -0.004926 
837                            , -0.004473, -0.004077, -0.003737, -0.003398 
838                            , -0.003114, -0.002831, -0.002605, -0.002378 
839                            , -0.002208, -0.002039, -0.001869, -0.001699 
840                            , -0.001585, -0.001472, -0.001359, -0.001246 
841                            , -0.001132, -0.001019, -0.001019, -0.000906 
842                            , -0.000906, -0.000793, -0.000793, -0.000680 
843                            , -0.000680, -0.000680, -0.000566, -0.000566 
844                            , -0.000566, -0.000566, -0.000453, -0.000453 
845                            , -0.000453, -0.000453, -0.000453, -0.000453 
846                            , -0.000340, -0.000340, -0.000340, -0.000340 
847                            , -0.000340, -0.000340, -0.000340, -0.000340 
848                            , -0.000340, -0.000340, -0.000340, -0.000340 
849                            , -0.000340, -0.000227, -0.000227, -0.000227 
850                            , -0.000227, -0.000227, -0.000227, -0.000227 
851                            , -0.000227, -0.000227, -0.000227, -0.000227 
852                            , -0.000227, -0.000227, -0.000227, -0.000227 
853                            , -0.000227, -0.000227, -0.000227, -0.000227 
854                            , -0.000227, -0.000227, -0.000227, -0.000227 
855                            , -0.000227, -0.000227, -0.000227, -0.000227 
856                            , -0.000227, -0.000227, -0.000227, -0.000227 
857                            , -0.000227, -0.000227, -0.000227, -0.000227 
858                            , -0.000227, -0.000227, -0.000227, -0.000113 
859                            , -0.000113, -0.000113, -0.000113, -0.000113 
860                            , -0.000113, -0.000113, -0.000113, -0.000113 
861                            , -0.000113, -0.000113, -0.000113, -0.000113 
862                            , -0.000113, -0.000113, -0.000113, -0.000113 
863                            , -0.000113, -0.000113, -0.000113, -0.000113 
864                            , -0.000113, -0.000113, -0.000113, -0.000113 
865                            , -0.000113, -0.000113, -0.000113, -0.000113 
866                            , -0.000113, -0.000113, -0.000113, -0.000113 
867                            , -0.000113, -0.000113, -0.000113, -0.000113 
868                            , -0.000113, -0.000113, -0.000113, -0.000113 
869                            , -0.000113, -0.000113, -0.000113, -0.000113 
870                            , -0.000113, -0.000113, -0.000113, -0.000113 
871                            , -0.000113, -0.000113, -0.000113, -0.000113 
872                            , -0.000113, -0.000113, -0.000113, -0.000113 
873                            , -0.000113, -0.000113, -0.000113, -0.000113 
874                            , -0.000113, -0.000113, -0.000113, -0.000113 
875                            , -0.000113, -0.000113, -0.000113, -0.000113 
876                            , -0.000113, -0.000113, -0.000113, -0.000113 
877                            , -0.000113, -0.000113, -0.000113, -0.000113 
878                            , -0.000113, -0.000113, -0.000113,  0.000000 
879                            ,  0.000000,  0.000000,  0.000000,  0.000000 
880                            ,  0.000000,  0.000000,  0.000000,  0.000000 
881                            ,  0.000000,  0.000000,  0.000000,  0.000000 
882                            ,  0.000000,  0.000000,  0.000000,  0.000000 
883                            ,  0.000000,  0.000000,  0.000000,  0.000000 
884                            ,  0.000000,  0.000000,  0.000000,  0.000000 
885                            ,  0.000000,  0.000000,  0.000000,  0.000000 
886                            ,  0.000000,  0.000000,  0.000000,  0.000000 
887                            ,  0.000000,  0.000000,  0.000000,  0.000000 
888                            ,  0.000000,  0.000000,  0.000000,  0.000000 };
889
890   // increase CrossTalk to measurements
891   for (Int_t ipasa = 0; ipasa < kNpasa; ipasa++) {
892     xtalk[ipasa] *= 1.75;
893   }
894
895   if (fTRFsmp) delete [] fTRFsmp;
896   fTRFsmp = new Float_t[fTRFbin];
897   if (fCTsmp)  delete [] fCTsmp;
898   fCTsmp  = new Float_t[fTRFbin];
899
900   Float_t loTRF    = TMath::Max(fTRFlo / fDriftVelocity,time[0]);
901   Float_t hiTRF    = TMath::Min(fTRFhi / fDriftVelocity,time[kNpasa-1]);
902   Float_t binWidth = (hiTRF - loTRF) / ((Float_t) fTRFbin);
903
904   // Take the linear interpolation
905   for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
906
907     Float_t bin = (((Float_t) iBin) + 0.5) * binWidth + loTRF;
908     ipos1 = ipos2 = 0;
909     diff  = 0;
910     do {
911       diff = bin - time[ipos2++];
912     } while (diff > 0);
913     ipos2--;
914     if (ipos2 >= kNpasa) ipos2 = kNpasa - 1;
915     ipos1 = ipos2 - 1;
916
917     fTRFsmp[iBin] = signal[ipos2] 
918                   + diff * (signal[ipos2] - signal[ipos1]) 
919                          / (  time[ipos2] -   time[ipos1]);
920
921     fCTsmp[iBin]  = xtalk[ipos2] 
922                   + diff * (xtalk[ipos2]  -  xtalk[ipos1]) 
923                          / (  time[ipos2] -   time[ipos1]);
924
925   }
926
927 }
928
929 //_____________________________________________________________________________
930 void AliTRDparameter::SamplePRF()
931 {
932   //
933   // Samples the pad response function
934   //
935
936   const Int_t kNplan  = AliTRDgeometry::kNplan;
937   const Int_t kPRFbin = 61;
938
939   Float_t prf[kNplan][kPRFbin] = { { 0.018570, 0.022270, 0.026710, 0.032010
940                                    , 0.038350, 0.045920, 0.054930, 0.065650
941                                    , 0.078370, 0.093420, 0.111150, 0.131940
942                                    , 0.156160, 0.184160, 0.216220, 0.252470
943                                    , 0.292860, 0.337030, 0.384330, 0.433750
944                                    , 0.484010, 0.533630, 0.581150, 0.625200
945                                    , 0.664710, 0.698860, 0.727130, 0.749230
946                                    , 0.765050, 0.774540, 0.777700, 0.774540
947                                    , 0.765050, 0.749230, 0.727130, 0.698860
948                                    , 0.664710, 0.625200, 0.581150, 0.533630
949                                    , 0.484010, 0.433750, 0.384330, 0.337030
950                                    , 0.292860, 0.252470, 0.216220, 0.184160
951                                    , 0.156160, 0.131940, 0.111150, 0.093420
952                                    , 0.078370, 0.065650, 0.054930, 0.045920
953                                    , 0.038350, 0.032010, 0.026710, 0.022270
954                                    , 0.018570                               }
955                                  , { 0.015730, 0.019040, 0.023030, 0.027840
956                                    , 0.033650, 0.040650, 0.049060, 0.059160
957                                    , 0.071260, 0.085710, 0.102910, 0.123270
958                                    , 0.147240, 0.175220, 0.207590, 0.244540
959                                    , 0.286090, 0.331920, 0.381350, 0.433290
960                                    , 0.486290, 0.538710, 0.588870, 0.635280
961                                    , 0.676760, 0.712460, 0.741890, 0.764810
962                                    , 0.781150, 0.790930, 0.794180, 0.790930
963                                    , 0.781150, 0.764810, 0.741890, 0.712460
964                                    , 0.676760, 0.635280, 0.588870, 0.538710
965                                    , 0.486290, 0.433290, 0.381350, 0.331920
966                                    , 0.286090, 0.244540, 0.207590, 0.175220
967                                    , 0.147240, 0.123270, 0.102910, 0.085710
968                                    , 0.071260, 0.059160, 0.049060, 0.040650
969                                    , 0.033650, 0.027840, 0.023030, 0.019040
970                                    , 0.015730                               }
971                                  , { 0.013330, 0.016270, 0.019850, 0.024210
972                                    , 0.029510, 0.035960, 0.043790, 0.053280
973                                    , 0.064740, 0.078580, 0.095190, 0.115070
974                                    , 0.138700, 0.166570, 0.199120, 0.236660
975                                    , 0.279260, 0.326660, 0.378140, 0.432540
976                                    , 0.488260, 0.543440, 0.596200, 0.644900
977                                    , 0.688240, 0.725380, 0.755840, 0.779470
978                                    , 0.796260, 0.806280, 0.809610, 0.806280
979                                    , 0.796260, 0.779470, 0.755840, 0.725380
980                                    , 0.688240, 0.644900, 0.596200, 0.543440
981                                    , 0.488260, 0.432540, 0.378140, 0.326660
982                                    , 0.279260, 0.236660, 0.199120, 0.166570
983                                    , 0.138700, 0.115070, 0.095190, 0.078580
984                                    , 0.064740, 0.053280, 0.043790, 0.035960
985                                    , 0.029510, 0.024210, 0.019850, 0.016270
986                                    , 0.013330                               }
987                                  , { 0.011280, 0.013890, 0.017090, 0.021030
988                                    , 0.025870, 0.031800, 0.039060, 0.047940
989                                    , 0.058790, 0.071980, 0.087990, 0.107330
990                                    , 0.130550, 0.158220, 0.190850, 0.228870
991                                    , 0.272410, 0.321270, 0.374740, 0.431560
992                                    , 0.489960, 0.547870, 0.603180, 0.654080
993                                    , 0.699190, 0.737640, 0.769030, 0.793260
994                                    , 0.810410, 0.820620, 0.824010, 0.820620
995                                    , 0.810410, 0.793260, 0.769030, 0.737640
996                                    , 0.699190, 0.654080, 0.603180, 0.547870
997                                    , 0.489960, 0.431560, 0.374740, 0.321270
998                                    , 0.272410, 0.228870, 0.190850, 0.158220
999                                    , 0.130550, 0.107330, 0.087990, 0.071980
1000                                    , 0.058790, 0.047940, 0.039060, 0.031800
1001                                    , 0.025870, 0.021030, 0.017090, 0.013890
1002                                    , 0.011280                               }
1003                                  , { 0.009550, 0.011860, 0.014720, 0.018270
1004                                    , 0.022660, 0.028100, 0.034820, 0.043120
1005                                    , 0.053340, 0.065900, 0.081280, 0.100040
1006                                    , 0.122800, 0.150180, 0.182800, 0.221170
1007                                    , 0.265550, 0.315790, 0.371180, 0.430370
1008                                    , 0.491430, 0.552030, 0.609840, 0.662860
1009                                    , 0.709630, 0.749290, 0.781490, 0.806220
1010                                    , 0.823650, 0.834000, 0.837430, 0.834000
1011                                    , 0.823650, 0.806220, 0.781490, 0.749290
1012                                    , 0.709630, 0.662860, 0.609840, 0.552030
1013                                    , 0.491430, 0.430370, 0.371180, 0.315790
1014                                    , 0.265550, 0.221170, 0.182800, 0.150180
1015                                    , 0.122800, 0.100040, 0.081280, 0.065900
1016                                    , 0.053340, 0.043120, 0.034820, 0.028100
1017                                    , 0.022660, 0.018270, 0.014720, 0.011860
1018                                    , 0.009550                               }
1019                                  , { 0.008080, 0.010120, 0.012670, 0.015860
1020                                    , 0.019840, 0.024820, 0.031030, 0.038760
1021                                    , 0.048370, 0.060300, 0.075040, 0.093200
1022                                    , 0.115430, 0.142450, 0.174980, 0.213610
1023                                    , 0.258720, 0.310250, 0.367480, 0.429010
1024                                    , 0.492690, 0.555950, 0.616210, 0.671280
1025                                    , 0.719600, 0.760350, 0.793250, 0.818380
1026                                    , 0.836020, 0.846460, 0.849920, 0.846460
1027                                    , 0.836020, 0.818380, 0.793250, 0.760350
1028                                    , 0.719600, 0.671280, 0.616210, 0.555950
1029                                    , 0.492690, 0.429010, 0.367480, 0.310250
1030                                    , 0.258720, 0.213610, 0.174980, 0.142450
1031                                    , 0.115430, 0.093200, 0.075040, 0.060300
1032                                    , 0.048370, 0.038760, 0.031030, 0.024820
1033                                    , 0.019840, 0.015860, 0.012670, 0.010120
1034                                    , 0.008080                               } };
1035
1036   // More sampling precision with linear interpolation
1037   fPRFlo  = -1.5;
1038   fPRFhi  =  1.5;
1039   Float_t pad[kPRFbin];
1040   Int_t   sPRFbin = kPRFbin;  
1041   Float_t sPRFwid = (fPRFhi - fPRFlo) / ((Float_t) sPRFbin);
1042   for (Int_t iPad = 0; iPad < sPRFbin; iPad++) {
1043     pad[iPad] = ((Float_t) iPad + 0.5) * sPRFwid + fPRFlo;
1044   }
1045   fPRFbin = 500;  
1046   fPRFwid = (fPRFhi - fPRFlo) / ((Float_t) fPRFbin);
1047   fPRFpad = ((Int_t) (1.0 / fPRFwid));
1048
1049   if (fPRFsmp) delete [] fPRFsmp;
1050   fPRFsmp = new Float_t[kNplan*fPRFbin];
1051
1052   Int_t   ipos1;
1053   Int_t   ipos2;
1054   Float_t diff;
1055
1056   for (Int_t iPla = 0; iPla < kNplan; iPla++) {
1057
1058     for (Int_t iBin = 0; iBin < fPRFbin; iBin++) {
1059
1060       Float_t bin = (((Float_t) iBin) + 0.5) * fPRFwid + fPRFlo;
1061       ipos1 = ipos2 = 0;
1062       diff  = 0;
1063       do {
1064         diff = bin - pad[ipos2++];
1065       } while ((diff > 0) && (ipos2 < kPRFbin));
1066       if      (ipos2 == kPRFbin) {
1067         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2-1];
1068       }
1069       else if (ipos2 == 1) {
1070         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2-1];
1071       }
1072       else {
1073         ipos2--;
1074         if (ipos2 >= kPRFbin) ipos2 = kPRFbin - 1;
1075         ipos1 = ipos2 - 1;
1076         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2] 
1077                                    + diff * (prf[iPla][ipos2] - prf[iPla][ipos1]) 
1078                                           / sPRFwid;
1079       }
1080
1081     }
1082   } 
1083
1084 }
1085
1086 //_____________________________________________________________________________
1087 void AliTRDparameter::FillLUT()
1088 {
1089   //
1090   // Create the LUT
1091   //
1092
1093   const Int_t kNplan = AliTRDgeometry::kNplan;
1094   const Int_t kNlut  = 128;
1095
1096   fLUTbin = kNplan * kNlut;
1097
1098   // The lookup table from Bogdan
1099   Float_t lut[kNplan][kNlut] = {  
1100     {
1101       0.0070, 0.0150, 0.0224, 0.0298, 0.0374, 0.0454, 0.0533, 0.0611, 
1102       0.0684, 0.0755, 0.0827, 0.0900, 0.0975, 0.1049, 0.1120, 0.1187, 
1103       0.1253, 0.1318, 0.1385, 0.1453, 0.1519, 0.1584, 0.1646, 0.1704, 
1104       0.1762, 0.1821, 0.1879, 0.1938, 0.1996, 0.2053, 0.2108, 0.2160, 
1105       0.2210, 0.2260, 0.2310, 0.2361, 0.2411, 0.2461, 0.2509, 0.2557, 
1106       0.2602, 0.2646, 0.2689, 0.2732, 0.2774, 0.2816, 0.2859, 0.2901, 
1107       0.2942, 0.2983, 0.3022, 0.3061, 0.3099, 0.3136, 0.3172, 0.3207, 
1108       0.3242, 0.3278, 0.3312, 0.3347, 0.3382, 0.3416, 0.3450, 0.3483, 
1109       0.3515, 0.3547, 0.3579, 0.3609, 0.3639, 0.3669, 0.3698, 0.3727, 
1110       0.3756, 0.3785, 0.3813, 0.3842, 0.3870, 0.3898, 0.3926, 0.3952, 
1111       0.3979, 0.4005, 0.4032, 0.4057, 0.4082, 0.4108, 0.4132, 0.4157, 
1112       0.4181, 0.4205, 0.4228, 0.4252, 0.4275, 0.4299, 0.4322, 0.4345, 
1113       0.4367, 0.4390, 0.4412, 0.4434, 0.4456, 0.4478, 0.4499, 0.4520, 
1114       0.4541, 0.4562, 0.4583, 0.4603, 0.4623, 0.4643, 0.4663, 0.4683, 
1115       0.4702, 0.4722, 0.4741, 0.4758, 0.4774, 0.4790, 0.4805, 0.4824, 
1116       0.4844, 0.4863, 0.4883, 0.4902, 0.4921, 0.4940, 0.4959, 0.4978 
1117     },
1118     {
1119       0.0072, 0.0156, 0.0235, 0.0313, 0.0394, 0.0478, 0.0561, 0.0642, 
1120       0.0718, 0.0792, 0.0868, 0.0947, 0.1025, 0.1101, 0.1172, 0.1241, 
1121       0.1309, 0.1378, 0.1449, 0.1518, 0.1586, 0.1650, 0.1710, 0.1770, 
1122       0.1830, 0.1891, 0.1952, 0.2011, 0.2070, 0.2125, 0.2177, 0.2229, 
1123       0.2280, 0.2332, 0.2383, 0.2435, 0.2484, 0.2533, 0.2581, 0.2627, 
1124       0.2670, 0.2714, 0.2757, 0.2799, 0.2842, 0.2884, 0.2927, 0.2968, 
1125       0.3008, 0.3048, 0.3086, 0.3123, 0.3159, 0.3195, 0.3231, 0.3266, 
1126       0.3301, 0.3335, 0.3370, 0.3404, 0.3438, 0.3471, 0.3504, 0.3536, 
1127       0.3567, 0.3598, 0.3628, 0.3657, 0.3686, 0.3715, 0.3744, 0.3772, 
1128       0.3800, 0.3828, 0.3856, 0.3884, 0.3911, 0.3938, 0.3965, 0.3991, 
1129       0.4016, 0.4042, 0.4067, 0.4092, 0.4116, 0.4140, 0.4164, 0.4187, 
1130       0.4211, 0.4234, 0.4257, 0.4280, 0.4302, 0.4325, 0.4347, 0.4369, 
1131       0.4391, 0.4413, 0.4434, 0.4456, 0.4477, 0.4497, 0.4518, 0.4538, 
1132       0.4558, 0.4578, 0.4598, 0.4618, 0.4637, 0.4656, 0.4675, 0.4694, 
1133       0.4713, 0.4732, 0.4750, 0.4766, 0.4781, 0.4797, 0.4813, 0.4832, 
1134       0.4851, 0.4870, 0.4888, 0.4906, 0.4925, 0.4942, 0.4960, 0.4978
1135     },
1136     {
1137       0.0075, 0.0163, 0.0246, 0.0328, 0.0415, 0.0504, 0.0592, 0.0674, 
1138       0.0753, 0.0832, 0.0914, 0.0996, 0.1077, 0.1154, 0.1225, 0.1296, 
1139       0.1369, 0.1442, 0.1515, 0.1585, 0.1652, 0.1714, 0.1776, 0.1839, 
1140       0.1902, 0.1965, 0.2025, 0.2085, 0.2141, 0.2194, 0.2247, 0.2299, 
1141       0.2352, 0.2405, 0.2457, 0.2507, 0.2557, 0.2604, 0.2649, 0.2693, 
1142       0.2737, 0.2780, 0.2823, 0.2867, 0.2909, 0.2951, 0.2992, 0.3033, 
1143       0.3072, 0.3110, 0.3146, 0.3182, 0.3218, 0.3253, 0.3288, 0.3323, 
1144       0.3357, 0.3392, 0.3426, 0.3459, 0.3492, 0.3524, 0.3555, 0.3586, 
1145       0.3616, 0.3645, 0.3674, 0.3703, 0.3731, 0.3759, 0.3787, 0.3815, 
1146       0.3843, 0.3870, 0.3897, 0.3925, 0.3950, 0.3976, 0.4002, 0.4027, 
1147       0.4052, 0.4076, 0.4101, 0.4124, 0.4148, 0.4171, 0.4194, 0.4217, 
1148       0.4239, 0.4262, 0.4284, 0.4306, 0.4328, 0.4350, 0.4371, 0.4393, 
1149       0.4414, 0.4435, 0.4455, 0.4476, 0.4496, 0.4516, 0.4536, 0.4555, 
1150       0.4575, 0.4594, 0.4613, 0.4632, 0.4650, 0.4669, 0.4687, 0.4705, 
1151       0.4723, 0.4741, 0.4758, 0.4773, 0.4789, 0.4804, 0.4821, 0.4839, 
1152       0.4857, 0.4875, 0.4893, 0.4910, 0.4928, 0.4945, 0.4961, 0.4978
1153     },
1154     {
1155       0.0078, 0.0171, 0.0258, 0.0345, 0.0438, 0.0532, 0.0624, 0.0708, 
1156       0.0791, 0.0875, 0.0962, 0.1048, 0.1130, 0.1206, 0.1281, 0.1356, 
1157       0.1432, 0.1508, 0.1582, 0.1651, 0.1716, 0.1780, 0.1845, 0.1910, 
1158       0.1975, 0.2038, 0.2099, 0.2155, 0.2210, 0.2263, 0.2317, 0.2371, 
1159       0.2425, 0.2477, 0.2528, 0.2578, 0.2626, 0.2671, 0.2715, 0.2759, 
1160       0.2803, 0.2846, 0.2890, 0.2933, 0.2975, 0.3016, 0.3056, 0.3095, 
1161       0.3132, 0.3168, 0.3204, 0.3239, 0.3274, 0.3309, 0.3344, 0.3378, 
1162       0.3412, 0.3446, 0.3479, 0.3511, 0.3543, 0.3574, 0.3603, 0.3633, 
1163       0.3662, 0.3690, 0.3718, 0.3747, 0.3774, 0.3802, 0.3829, 0.3857, 
1164       0.3883, 0.3910, 0.3936, 0.3962, 0.3987, 0.4012, 0.4037, 0.4061, 
1165       0.4085, 0.4109, 0.4132, 0.4155, 0.4177, 0.4200, 0.4222, 0.4244, 
1166       0.4266, 0.4288, 0.4309, 0.4331, 0.4352, 0.4373, 0.4394, 0.4414, 
1167       0.4435, 0.4455, 0.4475, 0.4494, 0.4514, 0.4533, 0.4552, 0.4571, 
1168       0.4590, 0.4608, 0.4626, 0.4645, 0.4662, 0.4680, 0.4698, 0.4715, 
1169       0.4733, 0.4750, 0.4766, 0.4781, 0.4796, 0.4812, 0.4829, 0.4846, 
1170       0.4863, 0.4880, 0.4897, 0.4914, 0.4930, 0.4946, 0.4963, 0.4979
1171     },
1172     {
1173       0.0081, 0.0178, 0.0270, 0.0364, 0.0463, 0.0562, 0.0656, 0.0744, 
1174       0.0831, 0.0921, 0.1013, 0.1102, 0.1183, 0.1261, 0.1339, 0.1419, 
1175       0.1499, 0.1576, 0.1648, 0.1715, 0.1782, 0.1849, 0.1917, 0.1984, 
1176       0.2048, 0.2110, 0.2167, 0.2223, 0.2278, 0.2333, 0.2389, 0.2444, 
1177       0.2497, 0.2548, 0.2598, 0.2645, 0.2691, 0.2735, 0.2780, 0.2824, 
1178       0.2868, 0.2912, 0.2955, 0.2997, 0.3038, 0.3078, 0.3116, 0.3152, 
1179       0.3188, 0.3224, 0.3259, 0.3294, 0.3329, 0.3364, 0.3398, 0.3432, 
1180       0.3465, 0.3497, 0.3529, 0.3561, 0.3591, 0.3620, 0.3649, 0.3677, 
1181       0.3705, 0.3733, 0.3761, 0.3788, 0.3816, 0.3843, 0.3869, 0.3896, 
1182       0.3922, 0.3948, 0.3973, 0.3998, 0.4022, 0.4047, 0.4070, 0.4094, 
1183       0.4117, 0.4139, 0.4162, 0.4184, 0.4206, 0.4227, 0.4249, 0.4270, 
1184       0.4291, 0.4313, 0.4334, 0.4354, 0.4375, 0.4395, 0.4415, 0.4435, 
1185       0.4455, 0.4474, 0.4493, 0.4512, 0.4531, 0.4550, 0.4568, 0.4586, 
1186       0.4604, 0.4622, 0.4639, 0.4657, 0.4674, 0.4691, 0.4708, 0.4725, 
1187       0.4742, 0.4758, 0.4773, 0.4788, 0.4803, 0.4819, 0.4836, 0.4852, 
1188       0.4869, 0.4885, 0.4901, 0.4917, 0.4933, 0.4948, 0.4964, 0.4979
1189     },
1190     {
1191       0.0085, 0.0189, 0.0288, 0.0389, 0.0497, 0.0603, 0.0699, 0.0792, 
1192       0.0887, 0.0985, 0.1082, 0.1170, 0.1253, 0.1336, 0.1421, 0.1505, 
1193       0.1587, 0.1662, 0.1733, 0.1803, 0.1874, 0.1945, 0.2014, 0.2081, 
1194       0.2143, 0.2201, 0.2259, 0.2316, 0.2374, 0.2431, 0.2487, 0.2541, 
1195       0.2593, 0.2642, 0.2689, 0.2735, 0.2781, 0.2826, 0.2872, 0.2917, 
1196       0.2961, 0.3003, 0.3045, 0.3086, 0.3125, 0.3162, 0.3198, 0.3235, 
1197       0.3270, 0.3306, 0.3342, 0.3377, 0.3411, 0.3446, 0.3479, 0.3511, 
1198       0.3543, 0.3575, 0.3605, 0.3634, 0.3663, 0.3691, 0.3720, 0.3748, 
1199       0.3775, 0.3803, 0.3830, 0.3857, 0.3884, 0.3911, 0.3937, 0.3962, 
1200       0.3987, 0.4012, 0.4036, 0.4060, 0.4084, 0.4107, 0.4129, 0.4152, 
1201       0.4174, 0.4196, 0.4218, 0.4239, 0.4261, 0.4282, 0.4303, 0.4324, 
1202       0.4344, 0.4365, 0.4385, 0.4405, 0.4425, 0.4445, 0.4464, 0.4483, 
1203       0.4502, 0.4521, 0.4539, 0.4558, 0.4576, 0.4593, 0.4611, 0.4629, 
1204       0.4646, 0.4663, 0.4680, 0.4697, 0.4714, 0.4730, 0.4747, 0.4759, 
1205       0.4769, 0.4780, 0.4790, 0.4800, 0.4811, 0.4827, 0.4843, 0.4859, 
1206       0.4874, 0.4889, 0.4905, 0.4920, 0.4935, 0.4950, 0.4965, 0.4979
1207     }
1208   }; 
1209
1210   if (fLUT) delete [] fLUT;
1211   fLUT = new Float_t[fLUTbin];
1212
1213   for (Int_t iplan = 0; iplan < kNplan; iplan++) {
1214     for (Int_t ilut  = 0; ilut  < kNlut; ilut++) {
1215       fLUT[iplan*kNlut+ilut] = lut[iplan][ilut];
1216     }
1217   }
1218
1219 }
1220
1221 //_____________________________________________________________________________
1222 void AliTRDparameter::SetTiltingAngle(Float_t v)
1223 {
1224   //
1225   // Set the tilting angle for the readout pads
1226   //
1227
1228   fTiltingAngle = TMath::Tan(TMath::Pi()/180.0 * v);
1229
1230 }
1231
1232 //_____________________________________________________________________________
1233 Float_t AliTRDparameter::GetTiltingAngle() const
1234 {
1235   //
1236   // Get the tilting angle for the readout pads
1237   //
1238
1239   return TMath::ATan(180.0/TMath::Pi() * fTiltingAngle);
1240
1241 }
1242
1243 //_____________________________________________________________________________
1244 Float_t AliTRDparameter::GetDiffusionL(Float_t vd, Float_t b)
1245 {
1246   //
1247   // Returns the longitudinal diffusion coefficient for a given drift 
1248   // velocity <vd> and a B-field <b> for Xe/CO2 (15%).
1249   // The values are according to a GARFIELD simulation.
1250   //
1251
1252   const Int_t kNb = 5;
1253   Float_t p0[kNb] = {  0.007440,  0.007493,  0.007513,  0.007672,  0.007831 };
1254   Float_t p1[kNb] = {  0.019252,  0.018912,  0.018636,  0.018012,  0.017343 };
1255   Float_t p2[kNb] = { -0.005042, -0.004926, -0.004867, -0.004650, -0.004424 };
1256   Float_t p3[kNb] = {  0.000195,  0.000189,  0.000195,  0.000182,  0.000169 };
1257
1258   Int_t ib = ((Int_t) (10 * (b - 0.15)));
1259   ib       = TMath::Max(  0,ib);
1260   ib       = TMath::Min(kNb,ib);
1261
1262   Float_t diff = p0[ib] 
1263                + p1[ib] * vd
1264                + p2[ib] * vd*vd
1265                + p3[ib] * vd*vd*vd;
1266
1267   return diff;
1268
1269 }
1270
1271 //_____________________________________________________________________________
1272 Float_t AliTRDparameter::GetDiffusionT(Float_t vd, Float_t b)
1273 {
1274   //
1275   // Returns the transverse diffusion coefficient for a given drift 
1276   // velocity <vd> and a B-field <b> for Xe/CO2 (15%).
1277   // The values are according to a GARFIELD simulation.
1278   //
1279
1280   const Int_t kNb = 5;
1281   Float_t p0[kNb] = {  0.009550,  0.009599,  0.009674,  0.009757,  0.009850 };
1282   Float_t p1[kNb] = {  0.006667,  0.006539,  0.006359,  0.006153,  0.005925 };
1283   Float_t p2[kNb] = { -0.000853, -0.000798, -0.000721, -0.000635, -0.000541 };
1284   Float_t p3[kNb] = {  0.000131,  0.000122,  0.000111,  0.000098,  0.000085 };
1285
1286   Int_t ib = ((Int_t) (10 * (b - 0.15)));
1287   ib       = TMath::Max(  0,ib);
1288   ib       = TMath::Min(kNb,ib);
1289
1290   Float_t diff = p0[ib] 
1291                + p1[ib] * vd
1292                + p2[ib] * vd*vd
1293                + p3[ib] * vd*vd*vd;
1294
1295   return diff;
1296
1297 }
1298
1299 //_____________________________________________________________________________
1300 Float_t AliTRDparameter::GetOmegaTau(Float_t vd, Float_t b)
1301 {
1302   //
1303   // Returns omega*tau (tan(Lorentz-angle)) for a given drift velocity <vd> 
1304   // and a B-field <b> for Xe/CO2 (15%).
1305   // The values are according to a GARFIELD simulation.
1306   //
1307
1308   const Int_t kNb = 5;
1309   Float_t p0[kNb] = {  0.004810,  0.007412,  0.010252,  0.013409,  0.016888 };
1310   Float_t p1[kNb] = {  0.054875,  0.081534,  0.107333,  0.131983,  0.155455 };
1311   Float_t p2[kNb] = { -0.008682, -0.012896, -0.016987, -0.020880, -0.024623 };
1312   Float_t p3[kNb] = {  0.000155,  0.000238,  0.000330,  0.000428,  0.000541 };
1313
1314   Int_t ib = ((Int_t) (10 * (b - 0.15)));
1315   ib       = TMath::Max(  0,ib);
1316   ib       = TMath::Min(kNb,ib);
1317
1318   Float_t alphaL = p0[ib] 
1319                  + p1[ib] * vd
1320                  + p2[ib] * vd*vd
1321                  + p3[ib] * vd*vd*vd;
1322
1323   return TMath::Tan(alphaL);
1324
1325 }
1326
1327 //_____________________________________________________________________________
1328 Double_t AliTRDparameter::LUTposition(Int_t iplane, Double_t ampL 
1329                                                   , Double_t ampC
1330                                                   , Double_t ampR) const
1331 {
1332   //
1333   // Calculates the cluster position using the lookup table.
1334   // Method provided by Bogdan Vulpescu.
1335   //
1336
1337   const Int_t kNplan = AliTRDgeometry::kNplan;
1338   const Int_t kNlut  = 128;
1339
1340   Double_t pos;
1341   Double_t x = 0.0;
1342   Double_t xmin;
1343   Double_t xmax;
1344   Double_t xwid;
1345
1346   Int_t    side = 0;
1347   Int_t    ix;
1348
1349   Double_t xMin[kNplan] = { 0.006492, 0.006377, 0.006258, 0.006144, 0.006030, 0.005980 };
1350   Double_t xMax[kNplan] = { 0.960351, 0.965870, 0.970445, 0.974352, 0.977667, 0.996101 };
1351
1352   if      (ampL > ampR) {
1353     x    = (ampL - ampR) / ampC;
1354     side = -1;
1355   } 
1356   else if (ampL < ampR) {
1357     x    = (ampR - ampL) / ampC;
1358     side = +1;
1359   }
1360
1361   if (ampL != ampR) {
1362
1363     xmin = xMin[iplane] + 0.000005;
1364     xmax = xMax[iplane] - 0.000005;
1365     xwid = (xmax - xmin) / 127.0;
1366
1367     if      (x < xmin) {
1368       pos = 0.0000;
1369     } 
1370     else if (x > xmax) {
1371       pos = side * 0.5000;
1372     } 
1373     else {
1374       ix  = (Int_t) ((x - xmin) / xwid);
1375       pos = side * fLUT[iplane*kNlut+ix];
1376     }
1377        
1378   } 
1379   else {
1380
1381     pos = 0.0;
1382
1383   }
1384
1385   return pos;
1386
1387 }