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 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 //  TRD parameter class                                                      //
  21 //                                                                           //
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 #include <TRandom.h>
  25
  26 #include "AliRun.h"
  27 #include "AliMagF.h"
  28
  29 #include "AliTRDparameter.h"
  30 #include "AliTRDgeometryFull.h"
  31
  32 ClassImp(AliTRDparameter)
  33
  34 //_____________________________________________________________________________
  35 AliTRDparameter::AliTRDparameter():TNamed()
  36 {
  37   //
  38   // AliTRDparameter default constructor
  39   //
  40
  41   fGeo                = 0;
  42   fPRFsmp             = 0;
  43   fTRFsmp             = 0;
  44   fCTsmp              = 0;
  45   fGasGain            = 0.0;
  46   fNoise              = 0.0;
  47   fChipGain           = 0.0;
  48   fADCoutRange        = 0.0;
  49   fADCinRange         = 0.0;
  50   fADCthreshold       = 0;
  51   fADCbaseline        = 0;
  52   fDiffusionOn        = 0;
  53   fDiffusionT         = 0.0;
  54   fDiffusionL         = 0.0;
  55   fElAttachOn         = 0;
  56   fElAttachProp       = 0.0;
  57   fExBOn              = 0;
  58   fOmegaTau           = 0.0;
  59   fPRFOn              = 0;
  60   fTRFOn              = 0;
  61   fCTOn               = 0;
  62   fTCOn               = 0;
  63   fDriftVelocity      = 0.0;
  64   fPadCoupling        = 0.0;
  65   fTimeCoupling       = 0.0;
  66   fTimeBinWidth       = 0.0;
  67   fField              = 0.0;
  68   fTiltingAngle       = 0.0;
  69   fPRFbin             = 0;
  70   fPRFlo              = 0.0;
  71   fPRFhi              = 0.0;
  72   fPRFwid             = 0.0;
  73   fPRFpad             = 0;
  74   fTRFbin             = 0;
  75   fTRFlo              = 0.0;
  76   fTRFhi              = 0.0;
  77   fTRFwid             = 0.0;
  78   fTCnexp             = 0;
  79
  80   fLUTOn              = 0;
  81   fLUT                = 0;
  82   fClusMaxThresh      = 0;
  83   fClusSigThresh      = 0;
  84
  85   fTimeStructOn       = 0;
  86   fTimeStruct         = 0;
  87   fAnodeWireOffset    = 0.0;
  88
  89 }
  90
  91 //_____________________________________________________________________________
  92 AliTRDparameter::AliTRDparameter(const Text_t *name, const Text_t *title)
  93                 :TNamed(name,title)
  94 {
  95   //
  96   // AliTRDparameter constructor
  97   //
  98
  99   fGeo                = new AliTRDgeometryFull();
 100   fPRFsmp             = 0;
 101   fTRFsmp             = 0;
 102   fCTsmp              = 0;
 103   fGasGain            = 0.0;
 104   fNoise              = 0.0;
 105   fChipGain           = 0.0;
 106   fADCoutRange        = 0.0;
 107   fADCinRange         = 0.0;
 108   fADCthreshold       = 0;
 109   fADCbaseline        = 0;
 110   fDiffusionOn        = 0;
 111   fDiffusionT         = 0.0;
 112   fDiffusionL         = 0.0;
 113   fElAttachOn         = 0;
 114   fElAttachProp       = 0.0;
 115   fExBOn              = 0;
 116   fOmegaTau           = 0.0;
 117   fPRFOn              = 0;
 118   fTRFOn              = 0;
 119   fCTOn               = 0;
 120   fTCOn               = 0;
 121   fDriftVelocity      = 0.0;
 122   fPadCoupling        = 0.0;
 123   fTimeCoupling       = 0.0;
 124   fTimeBinWidth       = 0.0;
 125   fField              = 0.0;
 126   fTiltingAngle       = 0.0;
 127   fPRFbin             = 0;
 128   fPRFlo              = 0.0;
 129   fPRFhi              = 0.0;
 130   fPRFwid             = 0.0;
 131   fPRFpad             = 0;
 132   fTRFbin             = 0;
 133   fTRFlo              = 0.0;
 134   fTRFhi              = 0.0;
 135   fTRFwid             = 0.0;
 136   fTCnexp             = 0;
 137
 138   fLUTOn              = 0;
 139   fLUT                = 0;
 140   fClusMaxThresh      = 0;
 141   fClusSigThresh      = 0;
 142
 143   fTimeStructOn       = 0;
 144   fTimeStruct         = 0;
 145   fAnodeWireOffset    = 0.0;
 146
 147   Init();
 148
 149 }
 150
 151
 152 //_____________________________________________________________________________
 153 AliTRDparameter::AliTRDparameter(const AliTRDparameter &p):TNamed(p)
 154 {
 155   //
 156   // AliTRDparameter copy constructor
 157   //
 158
 159   ((AliTRDparameter &) p).Copy(*this);
 160
 161 }
 162
 163 ///_____________________________________________________________________________
 164 AliTRDparameter::~AliTRDparameter()
 165 {
 166   //
 167   // AliTRDparameter destructor
 168   //
 169
 170   if (fTRFsmp) {
 171     delete [] fTRFsmp;
 172     fTRFsmp = 0;
 173   }
 174
 175   if (fPRFsmp) {
 176     delete [] fPRFsmp;
 177     fPRFsmp = 0;
 178   }
 179
 180   if (fCTsmp) {
 181     delete [] fCTsmp;
 182     fCTsmp  = 0;
 183   }
 184
 185   if (fLUT) {
 186     delete [] fLUT;
 187     fLUT    = 0;
 188   }
 189
 190   if (fGeo) {
 191     delete fGeo;
 192     fGeo    = 0;
 193   }
 194
 195   if (fTimeStruct) {
 196     delete [] fTimeStruct;
 197     fTimeStruct = 0;
 198   }
 199
 200 }
 201
 202 //_____________________________________________________________________________
 203 AliTRDparameter &AliTRDparameter::operator=(const AliTRDparameter &p)
 204 {
 205   //
 206   // Assignment operator
 207   //
 208
 209   if (this != &p) ((AliTRDparameter &) p).Copy(*this);
 210   return *this;
 211
 212 }
 213
 214 //_____________________________________________________________________________
 215 void AliTRDparameter::Copy(TObject &p)
 216 {
 217   //
 218   // Copy function
 219   //
 220
 221   Int_t iBin;
 222
 223   ((AliTRDparameter &) p).fGasGain            = fGasGain;
 224   ((AliTRDparameter &) p).fNoise              = fNoise;
 225   ((AliTRDparameter &) p).fChipGain           = fChipGain;
 226   ((AliTRDparameter &) p).fADCoutRange        = fADCoutRange;
 227   ((AliTRDparameter &) p).fADCinRange         = fADCinRange;
 228   ((AliTRDparameter &) p).fADCthreshold       = fADCthreshold;
 229   ((AliTRDparameter &) p).fADCbaseline        = fADCbaseline;
 230   ((AliTRDparameter &) p).fDiffusionOn        = fDiffusionOn;
 231   ((AliTRDparameter &) p).fDiffusionT         = fDiffusionT;
 232   ((AliTRDparameter &) p).fDiffusionL         = fDiffusionL;
 233   ((AliTRDparameter &) p).fElAttachOn         = fElAttachOn;
 234   ((AliTRDparameter &) p).fElAttachProp       = fElAttachProp;
 235   ((AliTRDparameter &) p).fExBOn              = fExBOn;
 236   ((AliTRDparameter &) p).fOmegaTau           = fOmegaTau;
 237   ((AliTRDparameter &) p).fLorentzFactor      = fLorentzFactor;
 238   ((AliTRDparameter &) p).fDriftVelocity      = fDriftVelocity;
 239   ((AliTRDparameter &) p).fPadCoupling        = fPadCoupling;
 240   ((AliTRDparameter &) p).fTimeCoupling       = fTimeCoupling;
 241   ((AliTRDparameter &) p).fTimeBinWidth       = fTimeBinWidth;
 242   ((AliTRDparameter &) p).fField              = fField;
 243   ((AliTRDparameter &) p).fPRFOn              = fPRFOn;
 244   ((AliTRDparameter &) p).fTRFOn              = fTRFOn;
 245   ((AliTRDparameter &) p).fCTOn               = fCTOn;
 246   ((AliTRDparameter &) p).fTCOn               = fTCOn;
 247   ((AliTRDparameter &) p).fTiltingAngle       = fTiltingAngle;
 248   ((AliTRDparameter &) p).fPRFbin             = fPRFbin;
 249   ((AliTRDparameter &) p).fPRFlo              = fPRFlo;
 250   ((AliTRDparameter &) p).fPRFhi              = fPRFhi;
 251   ((AliTRDparameter &) p).fPRFwid             = fPRFwid;
 252   ((AliTRDparameter &) p).fPRFpad             = fPRFpad;
 253   if (((AliTRDparameter &) p).fPRFsmp) delete [] ((AliTRDparameter &) p).fPRFsmp;
 254   ((AliTRDparameter &) p).fPRFsmp = new Float_t[fPRFbin];
 255   for (iBin = 0; iBin < fPRFbin; iBin++) {
 256     ((AliTRDparameter &) p).fPRFsmp[iBin] = fPRFsmp[iBin];
 257   }
 258   ((AliTRDparameter &) p).fTRFbin             = fTRFbin;
 259   ((AliTRDparameter &) p).fTRFlo              = fTRFlo;
 260   ((AliTRDparameter &) p).fTRFhi              = fTRFhi;
 261   ((AliTRDparameter &) p).fTRFwid             = fTRFwid;
 262   if (((AliTRDparameter &) p).fTRFsmp) delete [] ((AliTRDparameter &) p).fTRFsmp;
 263   ((AliTRDparameter &) p).fTRFsmp = new Float_t[fTRFbin];
 264   for (iBin = 0; iBin < fTRFbin; iBin++) {
 265     ((AliTRDparameter &) p).fTRFsmp[iBin] = fTRFsmp[iBin];
 266   }
 267   if (((AliTRDparameter &) p).fCTsmp)  delete [] ((AliTRDparameter &) p).fCTsmp;
 268   ((AliTRDparameter &) p).fCTsmp  = new Float_t[fTRFbin];
 269   for (iBin = 0; iBin < fTRFbin; iBin++) {
 270     ((AliTRDparameter &) p).fCTsmp[iBin]  = fCTsmp[iBin];
 271   }
 272   ((AliTRDparameter &) p).fTCnexp             = fTCnexp;
 273
 274   ((AliTRDparameter &) p).fLUTOn              = fLUTOn;
 275   ((AliTRDparameter &) p).fLUTbin             = fLUTbin;
 276   if (((AliTRDparameter &) p).fLUT)    delete [] ((AliTRDparameter &) p).fLUT;
 277   ((AliTRDparameter &) p).fLUT  = new Float_t[fLUTbin];
 278   for (iBin = 0; iBin < fLUTbin; iBin++) {
 279     ((AliTRDparameter &) p).fLUT[iBin]  = fLUT[iBin];
 280   }
 281   ((AliTRDparameter &) p).fClusMaxThresh      = fClusMaxThresh;
 282   ((AliTRDparameter &) p).fClusSigThresh      = fClusSigThresh;
 283
 284   ((AliTRDparameter &) p).fAnodeWireOffset    = fAnodeWireOffset;
 285   ((AliTRDparameter &) p).fTimeStructOn       = fTimeStructOn;
 286   if (((AliTRDparameter &) p).fTimeStruct)
 287     delete [] ((AliTRDparameter &) p).fTimeStruct;
 288   ((AliTRDparameter &) p).fTimeStruct = new Float_t[38*11];
 289   for (Int_t i = 0; i < 38*11; i++) {
 290     ((AliTRDparameter &) p).fTimeStruct[i] = fTimeStruct[i];
 291   }
 292
 293 }
 294
 295 //_____________________________________________________________________________
 296 void AliTRDparameter::Init()
 297 {
 298   //
 299   // Initializes the parameter
 300   //
 301   // The maximum number of pads
 302   // and the position of pad 0,0,0
 303   //
 304   // chambers seen from the top:
 305   //     +----------------------------+
 306   //     |                            |
 307   //     |                            |      ^
 308   //     |                            |  rphi|
 309   //     |                            |      |
 310   //     |0                           |      |
 311   //     +----------------------------+      +------>
 312   //                                             z
 313   // chambers seen from the side:            ^
 314   //     +----------------------------+ drift|
 315   //     |0                           |      |
 316   //     |                            |      |
 317   //     +----------------------------+      +------>
 318   //                                             z
 319   //
 320   // IMPORTANT: time bin 0 is now the first one in the drift region
 321   // closest to the readout !!!
 322   //
 323
 324   //
 325   // ----------------------------------------------------------------------------
 326   // The pad definition
 327   // ----------------------------------------------------------------------------
 328   //
 329
 330   // The pad size in column direction (rphi-direction)
 331   //SetColPadSize(0,0.65);
 332   //SetColPadSize(1,0.68);
 333   //SetColPadSize(2,0.71);
 334   //SetColPadSize(3,0.74);
 335   //SetColPadSize(4,0.77);
 336   //SetColPadSize(5,0.80);
 337
 338   SetColPadSize(0,0.664);
 339   SetColPadSize(1,0.695);
 340   SetColPadSize(2,0.726);
 341   SetColPadSize(3,0.756);
 342   SetColPadSize(4,0.788);
 343   SetColPadSize(5,0.818);
 344
 345   // The pad row (z-direction)
 346   SetNRowPad();
 347
 348   // The number of time bins. Default is 100 ns timbin size
 349   SetNTimeBin(18);
 350
 351   // Additional time bins before and after the drift region.
 352   // Default is to only sample the drift region
 353   SetExpandTimeBin(0,0);
 354
 355   //
 356   // ----------------------------------------------------------------------------
 357   // The digitization parameter
 358   // ----------------------------------------------------------------------------
 359   //
 360
 361   // The default parameter for the digitization
 362   fGasGain        = 4000.;
 363   fChipGain       = 12.4;
 364   fNoise          = 1000.;
 365   fADCoutRange    = 1023.;          // 10-bit ADC
 366   fADCinRange     = 2000.;          // 2V input range
 367   fADCthreshold   = 1;
 368   fADCbaseline    = 0;
 369
 370   // The drift velocity (cm / mus)
 371   fDriftVelocity  = 1.62;
 372
 373   // Diffusion on
 374   fDiffusionOn    = 1;
 375
 376   // E x B effects
 377   fExBOn          = 1;
 378
 379   // Propability for electron attachment
 380   fElAttachOn     = 0;
 381   fElAttachProp   = 0.0;
 382
 383   // The pad response function
 384   fPRFOn          = 1;
 385
 386   // The time response function
 387   fTRFOn          = 1;
 388
 389   // The cross talk
 390   fCTOn           = 1;
 391
 392   // The tail cancelation
 393   fTCOn           = 1;
 394
 395   // The number of exponentials
 396   fTCnexp         = 1;
 397
 398   // The pad coupling factor
 399   //fPadCoupling    = 0.3;
 400   // Use 0.46 instead which reproduces better the test beam
 401   // data, even tough it is not understood why.
 402   fPadCoupling    = 0.46;
 403
 404   // The time coupling factor (same number as for the TPC)
 405   fTimeCoupling   = 0.4;
 406
 407   // Drift time non-isochronity on
 408   fTimeStructOn   = 1;
 409
 410   // Distance of first Anode wire from first pad edge
 411   fAnodeWireOffset = 0.25;
 412
 413   // The tilting angle for the readout pads
 414   SetTiltingAngle(2.0);
 415
 416   // The magnetic field strength in Tesla
 417   Double_t x[3] = { 0.0, 0.0, 0.0 };
 418   Double_t b[3];
 419   gAlice->Field(x,b);  // b[] is in kilo Gauss
 420   fField = b[2] * 0.1; // Tesla
 421
 422   //
 423   // ----------------------------------------------------------------------------
 424   // The clusterization parameter
 425   // ----------------------------------------------------------------------------
 426   //
 427
 428   // The default parameter for the clustering
 429   fClusMaxThresh = 3;
 430   fClusSigThresh = 1;
 431
 432   // Use the LUT
 433   fLUTOn         = 1;
 434
 435   ReInit();
 436
 437 }
 438
 439 //_____________________________________________________________________________
 440 void AliTRDparameter::ReInit()
 441 {
 442   //
 443   // Reinitializes the parameter class after a change
 444   //
 445
 446   // Create the sampled timing structure
 447   SampleTimeStruct();
 448
 449   // Calculate the time bin width in ns
 450   fTimeBinWidth   = fTimeBinSize / fDriftVelocity * 1000.0;
 451
 452   // The range and the binwidth for the sampled TRF
 453   fTRFbin = 100;
 454   // Start 0.2 mus before the signal
 455   fTRFlo  = -0.2 * fDriftVelocity;
 456   // End the maximum driftlength after the signal
 457   fTRFhi  = AliTRDgeometry::DrThick()
 458           + fTimeAfter * fTimeBinSize;
 459   fTRFwid = (fTRFhi - fTRFlo) / ((Float_t) fTRFbin);
 460
 461   // Transverse and longitudinal diffusion coefficients (Xe/CO2)
 462   fDiffusionT     = GetDiffusionT(fDriftVelocity,fField);
 463   fDiffusionL     = GetDiffusionL(fDriftVelocity,fField);
 464
 465   // omega * tau.= tan(Lorentz-angle)
 466   fOmegaTau       = GetOmegaTau(fDriftVelocity,fField);
 467
 468   // The Lorentz factor
 469   if (fExBOn) {
 470     fLorentzFactor = 1.0 / (1.0 + fOmegaTau*fOmegaTau);
 471   }
 472   else {
 473     fLorentzFactor = 1.0;
 474   }
 475
 476   // Create the sampled PRF
 477   SamplePRF();
 478
 479   // Create the sampled TRF
 480   SampleTRF();
 481
 482   // Create the LUT
 483   FillLUT();
 484
 485 }
 486
 487 //_____________________________________________________________________________
 488 void AliTRDparameter::SetNRowPad(Int_t p, Int_t c, Int_t npad)
 489 {
 490   //
 491   // Redefines the number of pads in raw direction for
 492   // a given plane and chamber number
 493   //
 494
 495   for (Int_t isect = 0; isect < AliTRDgeometry::Nsect(); isect++) {
 496
 497     fRowMax[p][c][isect] = npad;
 498
 499     fRowPadSize[p][c][isect] = (fGeo->GetChamberLength(p,c)
 500                                 - 2.* AliTRDgeometry::RpadW())
 501                              / ((Float_t) npad);
 502
 503   }
 504
 505 }
 506
 507 //_____________________________________________________________________________
 508 void AliTRDparameter::SetNRowPad()
 509 {
 510   //
 511   // Defines the number of pads in row direction
 512   //
 513
 514   Int_t isect;
 515   Int_t icham;
 516   Int_t iplan;
 517
 518   Int_t rowMax[kNplan][kNcham] = { { 16, 16, 12, 16, 16 }
 519                                  , { 16, 16, 12, 16, 16 }
 520                                  , { 16, 16, 12, 16, 16 }
 521                                  , { 16, 16, 12, 16, 16 }
 522                                  , { 16, 16, 12, 16, 16 }
 523                                  , { 16, 16, 12, 16, 16 } };
 524
 525   Float_t rpadW = AliTRDgeometry::RpadW();
 526
 527   for (isect = 0; isect < kNsect; isect++) {
 528     for (icham = 0; icham < kNcham; icham++) {
 529       for (iplan = 0; iplan < kNplan; iplan++) {
 530
 531         fRowMax[iplan][icham][isect]     = rowMax[iplan][icham];
 532
 533         fRowPadSize[iplan][icham][isect] = (fGeo->GetChamberLength(iplan,icham)
 534                                             - 2.*rpadW)
 535                                          / ((Float_t) rowMax[iplan][icham]);
 536
 537         Float_t row0 = rpadW - fGeo->GetChamberLength(iplan,0)
 538                              - fGeo->GetChamberLength(iplan,1)
 539                              - fGeo->GetChamberLength(iplan,2) / 2.;
 540         for (Int_t ic = 0; ic < icham; ic++) {
 541           row0 += fGeo->GetChamberLength(iplan,ic);
 542         }
 543
 544         fRow0[iplan][icham][isect]          = row0;
 545         // For new chamber ordering
 546         //fRow0[iplan][kNcham-icham-1][isect] = row0;
 547
 548       }
 549     }
 550   }
 551
 552 }
 553
 554 //_____________________________________________________________________________
 555 void AliTRDparameter::SetColPadSize(Int_t p, Float_t s)
 556 {
 557   //
 558   // Redefines the pad size in column direction
 559   //
 560
 561   Float_t cpadW  = AliTRDgeometry::CpadW();
 562
 563   fColPadSize[p] = s;
 564   fCol0[p]       = - fGeo->GetChamberWidth(p)/2. + cpadW;
 565   fColMax[p]     = ((Int_t) ((fGeo->GetChamberWidth(p) - 2.*cpadW) / s));
 566
 567 }
 568
 569 //_____________________________________________________________________________
 570 void AliTRDparameter::SetNTimeBin(Int_t nbin)
 571 {
 572   //
 573   // Redefines the number of time bins in the drift region.
 574   // The time bin width is defined by the length of the
 575   // drift region divided by <nbin>.
 576   //
 577
 578   fTimeMax     = nbin;
 579   fTimeBinSize = AliTRDgeometry::DrThick() / ((Float_t) fTimeMax);
 580   for (Int_t iplan = 0; iplan < AliTRDgeometry::Nplan(); iplan++) {
 581     fTime0[iplan] = AliTRDgeometry::Rmin()
 582                   + AliTRDgeometry::CraHght()
 583                   + AliTRDgeometry::CdrHght()
 584                   + iplan * (AliTRDgeometry::Cheight()
 585                            + AliTRDgeometry::Cspace());
 586   }
 587
 588 }
 589
 590 //_____________________________________________________________________________
 591 Float_t AliTRDparameter::CrossTalk(Float_t time) const
 592 {
 593   //
 594   // Applies the pad-pad capacitive cross talk
 595   //
 596
 597   Int_t iBin = ((Int_t) ((time - fTRFlo) / fTRFwid));
 598   if ((iBin >= 0) && (iBin < fTRFbin)) {
 599     return fCTsmp[iBin];
 600   }
 601   else {
 602     return 0.0;
 603   }
 604
 605 }
 606
 607 //_____________________________________________________________________________
 608 Int_t AliTRDparameter::TimeStruct(Float_t dist, Float_t z, Float_t *xyz) const
 609 {
 610   //
 611   // Applies the time structure of the drift cells (by C.Lippmann).
 612   // The drift time of electrons to the anode wires depends on the
 613   // distance to the wire (z) and on the position in the drift region.
 614   // Here we omnly reposition each electron, since the drift velocity
 615   // in the digitisation is still constant. If the electrons at a given
 616   // position has a long drift time, it is just moved further away from
 617   // the anode wire plane.
 618   //
 619   // input :
 620   // dist = radial distance from anode wire plane [cm]
 621   // z    = distance from anode wire (parallel to cathode planes) [cm]
 622   //
 623
 624
 625   // indices:
 626   Int_t r1 = (Int_t)(10*dist);
 627   Int_t r2 = r1+1;
 628   Int_t z1 = (Int_t)(100*z/2.5);
 629   Int_t z2 = z1+1;
 630
 631   if (r1<0 || r1>37 || z1<0 || z1>10) {
 632     printf("<AliTRDparameter::TimeStruct> Warning. Indices out of range: ");
 633     printf("dist=%.2f, z=%.2f, r1=%d, z1=%d\n",dist,z,r1,z1);
 634     return kFALSE;
 635   }
 636
 637   // 2D Interpolation:
 638   Float_t y11 = fTimeStruct[r1+38*z1];
 639   Float_t y22 = (r2 <= 37 && z2 <= 10) ? fTimeStruct[r2+38*z2] : fTimeStruct[37+38*10];
 640   Float_t y12 = (z2 <= 10)             ? fTimeStruct[r1+38*z2] : fTimeStruct[r1+38*10];
 641   Float_t y21 = (r2 <= 37)             ? fTimeStruct[r2+38*z1] : fTimeStruct[37+38*z1];
 642
 643   Float_t y1  = (y21-y11)*10*dist + y11 - (y21-y11)*r1;
 644   Float_t y2  = (y22-y12)*10*dist + y12 - (y22-y12)*r1;
 645
 646   Float_t AmTh = AliTRDgeometry::AmThick()/2.0;
 647
 648   // dist now is the drift distance to anode wires (negative if electrons are
 649   // between anode wire plane and cathode pad plane)
 650   dist -= AmTh;
 651
 652   // Get the drift time from the interpolation:
 653   Float_t tdrift =
 654     ( TMath::Abs(dist)>0.005 || z>0.005 ) ? tdrift = (y2-y1)*100*z/2.5+y1-(y2-y1)*z1 : 0.0;
 655
 656   // We move electrons further away from the anode wire plane, if the drift time is
 657   // larger than the one expected for that distance for a constant drift velocity. We
 658   // increase (decrease) the drift distance by a factor
 659   //
 660   //                           c = t(x0)*vd/x0 ,
 661   //
 662   // where x0 is the distance from the anode wire plane (dist), vd is the constant
 663   // drift velocity (fDriftVelocity) and t(x0) is the real drift time (tdrift, as
 664   // calculated with GARFIELD).
 665   //
 666   // The factor is negative for electrons between anode wire plane and cathode pads.
 667   //
 668   // The new position of the electron is then given by: t(x0)*vd:
 669
 670   Float_t zdrift = tdrift * fDriftVelocity;
 671   if (dist < 0.) zdrift *= -1.;
 672
 673   xyz[0] = xyz[0] + dist - zdrift;
 674   xyz[1] = xyz[1];
 675   xyz[2] = xyz[2];
 676
 677   return 1;
 678
 679 }
 680
 681 //_____________________________________________________________________________
 682 Int_t AliTRDparameter::Diffusion(Float_t driftlength, Float_t *xyz)
 683 {
 684   //
 685   // Applies the diffusion smearing to the position of a single electron
 686   //
 687
 688   Float_t driftSqrt = TMath::Sqrt(driftlength);
 689   Float_t sigmaT = driftSqrt * fDiffusionT;
 690   Float_t sigmaL = driftSqrt * fDiffusionL;
 691   xyz[0] = gRandom->Gaus(xyz[0], sigmaL * fLorentzFactor);
 692   xyz[1] = gRandom->Gaus(xyz[1], sigmaT * fLorentzFactor);
 693   xyz[2] = gRandom->Gaus(xyz[2], sigmaT);
 694
 695   return 1;
 696
 697 }
 698
 699 //_____________________________________________________________________________
 700 Int_t AliTRDparameter::ExB(Float_t driftlength, Float_t *xyz) const
 701 {
 702   //
 703   // Applies E x B effects to the position of a single electron
 704   //
 705
 706   xyz[0] = xyz[0];
 707   xyz[1] = xyz[1] + fOmegaTau * driftlength;
 708   xyz[2] = xyz[2];
 709
 710   return 1;
 711
 712 }
 713
 714 //_____________________________________________________________________________
 715 Int_t AliTRDparameter::PadResponse(Float_t signal, Float_t dist
 716                                  , Int_t plane, Float_t *pad) const
 717 {
 718   //
 719   // Applies the pad response
 720   //
 721
 722   const Int_t kNplan = AliTRDgeometry::kNplan;
 723
 724   Int_t iBin  = ((Int_t) (( - dist - fPRFlo) / fPRFwid));
 725   Int_t iOff  = plane * fPRFbin;
 726
 727   Int_t iBin0 = iBin - fPRFpad + iOff;
 728   Int_t iBin1 = iBin           + iOff;
 729   Int_t iBin2 = iBin + fPRFpad + iOff;
 730
 731   pad[0] = 0.0;
 732   pad[1] = 0.0;
 733   pad[2] = 0.0;
 734   if ((iBin1 >= 0) && (iBin1 < (fPRFbin*kNplan))) {
 735
 736     if (iBin0 >= 0) {
 737       pad[0] = signal * fPRFsmp[iBin0];
 738     }
 739     pad[1] = signal * fPRFsmp[iBin1];
 740     if (iBin2 < (fPRFbin*kNplan)) {
 741       pad[2] = signal * fPRFsmp[iBin2];
 742     }
 743
 744     return 1;
 745
 746   }
 747   else {
 748
 749     return 0;
 750
 751   }
 752
 753 }
 754
 755 //_____________________________________________________________________________
 756 Float_t AliTRDparameter::TimeResponse(Float_t time) const
 757 {
 758   //
 759   // Applies the preamp shaper time response
 760   //
 761
 762   Int_t iBin = ((Int_t) ((time) / fTRFwid));
 763   //Int_t iBin = ((Int_t) ((time - fTRFlo) / fTRFwid));
 764   if ((iBin >= 0) && (iBin < fTRFbin)) {
 765     return fTRFsmp[iBin];
 766   }
 767   else {
 768     return 0.0;
 769   }
 770
 771 }
 772
 773 //_____________________________________________________________________________
 774 Float_t AliTRDparameter::Col0Tilted(Float_t col0, Float_t rowOffset
 775                                   , Int_t plane)
 776 {
 777   //
 778   // Calculates col0 for tilted pads
 779   //
 780
 781   Float_t diff = fTiltingAngle * rowOffset;
 782   return (col0 + TMath::Power(-1.0,(plane+1)) * diff);
 783
 784 }
 785
 786 //_____________________________________________________________________________
 787 void AliTRDparameter::SampleTRF()
 788 {
 789   //
 790   // Samples the time response function
 791   //
 792   // New TRF from Venelin Angelov, simulated with CADENCE
 793   // Pad-ground capacitance = 25 pF
 794   // Pad-pad cross talk capacitance = 6 pF
 795   //
 796
 797   Int_t   ipos1;
 798   Int_t   ipos2;
 799   Float_t diff;
 800
 801   const Int_t kNpasa     = 252;
 802
 803   Float_t time[kNpasa]   = { -0.220000, -0.210000, -0.200000, -0.190000
 804                            , -0.180000, -0.170000, -0.160000, -0.150000
 805                            , -0.140000, -0.130000, -0.120000, -0.110000
 806                            , -0.100000, -0.090000, -0.080000, -0.070000
 807                            , -0.060000, -0.050000, -0.040000, -0.030000
 808                            , -0.020000, -0.010000, -0.000000,  0.010000
 809                            ,  0.020000,  0.030000,  0.040000,  0.050000
 810                            ,  0.060000,  0.070000,  0.080000,  0.090000
 811                            ,  0.100000,  0.110000,  0.120000,  0.130000
 812                            ,  0.140000,  0.150000,  0.160000,  0.170000
 813                            ,  0.180000,  0.190000,  0.200000,  0.210000
 814                            ,  0.220000,  0.230000,  0.240000,  0.250000
 815                            ,  0.260000,  0.270000,  0.280000,  0.290000
 816                            ,  0.300000,  0.310000,  0.320000,  0.330000
 817                            ,  0.340000,  0.350000,  0.360000,  0.370000
 818                            ,  0.380000,  0.390000,  0.400000,  0.410000
 819                            ,  0.420000,  0.430000,  0.440000,  0.450000
 820                            ,  0.460000,  0.470000,  0.480000,  0.490000
 821                            ,  0.500000,  0.510000,  0.520000,  0.530000
 822                            ,  0.540000,  0.550000,  0.560000,  0.570000
 823                            ,  0.580000,  0.590000,  0.600000,  0.610000
 824                            ,  0.620000,  0.630000,  0.640000,  0.650000
 825                            ,  0.660000,  0.670000,  0.680000,  0.690000
 826                            ,  0.700000,  0.710000,  0.720000,  0.730000
 827                            ,  0.740000,  0.750000,  0.760000,  0.770000
 828                            ,  0.780000,  0.790000,  0.800000,  0.810000
 829                            ,  0.820000,  0.830000,  0.840000,  0.850000
 830                            ,  0.860000,  0.870000,  0.880000,  0.890000
 831                            ,  0.900000,  0.910000,  0.920000,  0.930000
 832                            ,  0.940000,  0.950000,  0.960000,  0.970000
 833                            ,  0.980000,  0.990000,  1.000000,  1.010000
 834                            ,  1.020000,  1.030000,  1.040000,  1.050000
 835                            ,  1.060000,  1.070000,  1.080000,  1.090000
 836                            ,  1.100000,  1.110000,  1.120000,  1.130000
 837                            ,  1.140000,  1.150000,  1.160000,  1.170000
 838                            ,  1.180000,  1.190000,  1.200000,  1.210000
 839                            ,  1.220000,  1.230000,  1.240000,  1.250000
 840                            ,  1.260000,  1.270000,  1.280000,  1.290000
 841                            ,  1.300000,  1.310000,  1.320000,  1.330000
 842                            ,  1.340000,  1.350000,  1.360000,  1.370000
 843                            ,  1.380000,  1.390000,  1.400000,  1.410000
 844                            ,  1.420000,  1.430000,  1.440000,  1.450000
 845                            ,  1.460000,  1.470000,  1.480000,  1.490000
 846                            ,  1.500000,  1.510000,  1.520000,  1.530000
 847                            ,  1.540000,  1.550000,  1.560000,  1.570000
 848                            ,  1.580000,  1.590000,  1.600000,  1.610000
 849                            ,  1.620000,  1.630000,  1.640000,  1.650000
 850                            ,  1.660000,  1.670000,  1.680000,  1.690000
 851                            ,  1.700000,  1.710000,  1.720000,  1.730000
 852                            ,  1.740000,  1.750000,  1.760000,  1.770000
 853                            ,  1.780000,  1.790000,  1.800000,  1.810000
 854                            ,  1.820000,  1.830000,  1.840000,  1.850000
 855                            ,  1.860000,  1.870000,  1.880000,  1.890000
 856                            ,  1.900000,  1.910000,  1.920000,  1.930000
 857                            ,  1.940000,  1.950000,  1.960000,  1.970000
 858                            ,  1.980000,  1.990000,  2.000000,  2.010000
 859                            ,  2.020000,  2.030000,  2.040000,  2.050000
 860                            ,  2.060000,  2.070000,  2.080000,  2.090000
 861                            ,  2.100000,  2.110000,  2.120000,  2.130000
 862                            ,  2.140000,  2.150000,  2.160000,  2.170000
 863                            ,  2.180000,  2.190000,  2.200000,  2.210000
 864                            ,  2.220000,  2.230000,  2.240000,  2.250000
 865                            ,  2.260000,  2.270000,  2.280000,  2.290000 };
 866
 867   Float_t signal[kNpasa] = {  0.000000,  0.000000,  0.000000,  0.000000
 868                            ,  0.000000,  0.000000,  0.000000,  0.000396
 869                            ,  0.005096,  0.022877,  0.061891,  0.126614
 870                            ,  0.215798,  0.324406,  0.444507,  0.566817
 871                            ,  0.683465,  0.787089,  0.873159,  0.937146
 872                            ,  0.979049,  0.999434,  1.000000,  0.983579
 873                            ,  0.954134,  0.913364,  0.866365,  0.813703
 874                            ,  0.759910,  0.706116,  0.653454,  0.603624
 875                            ,  0.556625,  0.514156,  0.475085,  0.439977
 876                            ,  0.408834,  0.380578,  0.355549,  0.333352
 877                            ,  0.313647,  0.296093,  0.280351,  0.266195
 878                            ,  0.253397,  0.241789,  0.231257,  0.221574
 879                            ,  0.212627,  0.204417,  0.196772,  0.189581
 880                            ,  0.182956,  0.176784,  0.171008,  0.165515
 881                            ,  0.160419,  0.155606,  0.151076,  0.146716
 882                            ,  0.142639,  0.138845,  0.135221,  0.131767
 883                            ,  0.128482,  0.125368,  0.122424,  0.119592
 884                            ,  0.116931,  0.114326,  0.111891,  0.109513
 885                            ,  0.107248,  0.105096,  0.103058,  0.101019
 886                            ,  0.099151,  0.097282,  0.095527,  0.093715
 887                            ,  0.092129,  0.090544,  0.088958,  0.087429
 888                            ,  0.086014,  0.084598,  0.083239,  0.081880
 889                            ,  0.080634,  0.079388,  0.078143,  0.077010
 890                            ,  0.075878,  0.074745,  0.073669,  0.072593
 891                            ,  0.071574,  0.070612,  0.069649,  0.068686
 892                            ,  0.067780,  0.066874,  0.066025,  0.065176
 893                            ,  0.064326,  0.063533,  0.062684,  0.061948
 894                            ,  0.061212,  0.060419,  0.059740,  0.059003
 895                            ,  0.058324,  0.057644,  0.057022,  0.056342
 896                            ,  0.055663,  0.055096,  0.054473,  0.053851
 897                            ,  0.053284,  0.052718,  0.052152,  0.051585
 898                            ,  0.051019,  0.050566,  0.050000,  0.049490
 899                            ,  0.048981,  0.048528,  0.048018,  0.047508
 900                            ,  0.047055,  0.046602,  0.046149,  0.045696
 901                            ,  0.045300,  0.044904,  0.044451,  0.044054
 902                            ,  0.043658,  0.043205,  0.042865,  0.042469
 903                            ,  0.042072,  0.041733,  0.041336,  0.040997
 904                            ,  0.040657,  0.040260,  0.039921,  0.039581
 905                            ,  0.039241,  0.038958,  0.038618,  0.038335
 906                            ,  0.037995,  0.037656,  0.037373,  0.037089
 907                            ,  0.036806,  0.036467,  0.036183,  0.035900
 908                            ,  0.035617,  0.035334,  0.035108,  0.034824
 909                            ,  0.034541,  0.034315,  0.034032,  0.033805
 910                            ,  0.033522,  0.033296,  0.033069,  0.032786
 911                            ,  0.032559,  0.032333,  0.032106,  0.031880
 912                            ,  0.031653,  0.031427,  0.031200,  0.030974
 913                            ,  0.030804,  0.030578,  0.030351,  0.030125
 914                            ,  0.029955,  0.029785,  0.029558,  0.029332
 915                            ,  0.029162,  0.028992,  0.028766,  0.028596
 916                            ,  0.028426,  0.028199,  0.028086,  0.027860
 917                            ,  0.027746,  0.027633,  0.027463,  0.027293
 918                            ,  0.027180,  0.027067,  0.026954,  0.026954
 919                            ,  0.026840,  0.026727,  0.026727,  0.026614
 920                            ,  0.026614,  0.026614,  0.026557,  0.026501
 921                            ,  0.026501,  0.026501,  0.026501,  0.026501
 922                            ,  0.026501,  0.026501,  0.026501,  0.026387
 923                            ,  0.026387,  0.026387,  0.026387,  0.026387
 924                            ,  0.026387,  0.026387,  0.026387,  0.026387
 925                            ,  0.026387,  0.026387,  0.026387,  0.026387
 926                            ,  0.026387,  0.026274,  0.026274,  0.026274
 927                            ,  0.026274,  0.026274,  0.026274,  0.026274
 928                            ,  0.026274,  0.026274,  0.026274,  0.026274
 929                            ,  0.026274,  0.026274,  0.026274,  0.026161 };
 930
 931   Float_t xtalk[kNpasa]  = {  0.000000,  0.000000,  0.000000,  0.000000
 932                            ,  0.000000,  0.000000,  0.000000,  0.000113
 933                            ,  0.000793,  0.003058,  0.007305,  0.013194
 934                            ,  0.019706,  0.025821,  0.030634,  0.033465
 935                            ,  0.034145,  0.032729,  0.029615,  0.025198
 936                            ,  0.019989,  0.014496,  0.009003,  0.003964
 937                            , -0.000510, -0.004190, -0.007191, -0.009400
 938                            , -0.010872, -0.011835, -0.012288, -0.012288
 939                            , -0.012005, -0.011495, -0.010872, -0.010136
 940                            , -0.009343, -0.008607, -0.007871, -0.007191
 941                            , -0.006512, -0.005946, -0.005379, -0.004926
 942                            , -0.004473, -0.004077, -0.003737, -0.003398
 943                            , -0.003114, -0.002831, -0.002605, -0.002378
 944                            , -0.002208, -0.002039, -0.001869, -0.001699
 945                            , -0.001585, -0.001472, -0.001359, -0.001246
 946                            , -0.001132, -0.001019, -0.001019, -0.000906
 947                            , -0.000906, -0.000793, -0.000793, -0.000680
 948                            , -0.000680, -0.000680, -0.000566, -0.000566
 949                            , -0.000566, -0.000566, -0.000453, -0.000453
 950                            , -0.000453, -0.000453, -0.000453, -0.000453
 951                            , -0.000340, -0.000340, -0.000340, -0.000340
 952                            , -0.000340, -0.000340, -0.000340, -0.000340
 953                            , -0.000340, -0.000340, -0.000340, -0.000340
 954                            , -0.000340, -0.000227, -0.000227, -0.000227
 955                            , -0.000227, -0.000227, -0.000227, -0.000227
 956                            , -0.000227, -0.000227, -0.000227, -0.000227
 957                            , -0.000227, -0.000227, -0.000227, -0.000227
 958                            , -0.000227, -0.000227, -0.000227, -0.000227
 959                            , -0.000227, -0.000227, -0.000227, -0.000227
 960                            , -0.000227, -0.000227, -0.000227, -0.000227
 961                            , -0.000227, -0.000227, -0.000227, -0.000227
 962                            , -0.000227, -0.000227, -0.000227, -0.000227
 963                            , -0.000227, -0.000227, -0.000227, -0.000113
 964                            , -0.000113, -0.000113, -0.000113, -0.000113
 965                            , -0.000113, -0.000113, -0.000113, -0.000113
 966                            , -0.000113, -0.000113, -0.000113, -0.000113
 967                            , -0.000113, -0.000113, -0.000113, -0.000113
 968                            , -0.000113, -0.000113, -0.000113, -0.000113
 969                            , -0.000113, -0.000113, -0.000113, -0.000113
 970                            , -0.000113, -0.000113, -0.000113, -0.000113
 971                            , -0.000113, -0.000113, -0.000113, -0.000113
 972                            , -0.000113, -0.000113, -0.000113, -0.000113
 973                            , -0.000113, -0.000113, -0.000113, -0.000113
 974                            , -0.000113, -0.000113, -0.000113, -0.000113
 975                            , -0.000113, -0.000113, -0.000113, -0.000113
 976                            , -0.000113, -0.000113, -0.000113, -0.000113
 977                            , -0.000113, -0.000113, -0.000113, -0.000113
 978                            , -0.000113, -0.000113, -0.000113, -0.000113
 979                            , -0.000113, -0.000113, -0.000113, -0.000113
 980                            , -0.000113, -0.000113, -0.000113, -0.000113
 981                            , -0.000113, -0.000113, -0.000113, -0.000113
 982                            , -0.000113, -0.000113, -0.000113, -0.000113
 983                            , -0.000113, -0.000113, -0.000113,  0.000000
 984                            ,  0.000000,  0.000000,  0.000000,  0.000000
 985                            ,  0.000000,  0.000000,  0.000000,  0.000000
 986                            ,  0.000000,  0.000000,  0.000000,  0.000000
 987                            ,  0.000000,  0.000000,  0.000000,  0.000000
 988                            ,  0.000000,  0.000000,  0.000000,  0.000000
 989                            ,  0.000000,  0.000000,  0.000000,  0.000000
 990                            ,  0.000000,  0.000000,  0.000000,  0.000000
 991                            ,  0.000000,  0.000000,  0.000000,  0.000000
 992                            ,  0.000000,  0.000000,  0.000000,  0.000000
 993                            ,  0.000000,  0.000000,  0.000000,  0.000000 };
 994
 995   // increase CrossTalk to measurements
 996   for (Int_t ipasa = 0; ipasa < kNpasa; ipasa++) {
 997     xtalk[ipasa] *= 1.75;
 998   }
 999
1000   if (fTRFsmp) delete [] fTRFsmp;
1001   fTRFsmp = new Float_t[fTRFbin];
1002   if (fCTsmp)  delete [] fCTsmp;
1003   fCTsmp  = new Float_t[fTRFbin];
1004
1005   Float_t loTRF    = TMath::Max(fTRFlo / fDriftVelocity,time[0]);
1006   Float_t hiTRF    = TMath::Min(fTRFhi / fDriftVelocity,time[kNpasa-1]);
1007   Float_t binWidth = (hiTRF - loTRF) / ((Float_t) fTRFbin);
1008
1009   // Take the linear interpolation
1010   for (Int_t iBin = 0; iBin < fTRFbin; iBin++) {
1011
1012     Float_t bin = (((Float_t) iBin) + 0.5) * binWidth + loTRF;
1013     ipos1 = ipos2 = 0;
1014     diff  = 0;
1015     do {
1016       diff = bin - time[ipos2++];
1017     } while (diff > 0);
1018     ipos2--;
1019     if (ipos2 >= kNpasa) ipos2 = kNpasa - 1;
1020     ipos1 = ipos2 - 1;
1021
1022     fTRFsmp[iBin] = signal[ipos2]
1023                   + diff * (signal[ipos2] - signal[ipos1])
1024                          / (  time[ipos2] -   time[ipos1]);
1025
1026     fCTsmp[iBin]  = xtalk[ipos2]
1027                   + diff * (xtalk[ipos2]  -  xtalk[ipos1])
1028                          / (  time[ipos2] -   time[ipos1]);
1029
1030   }
1031
1032 }
1033
1034 //_____________________________________________________________________________
1035 void AliTRDparameter::SampleTimeStruct()
1036 {
1037   //
1038   // Samples the timing structure of a drift cell
1039   // Drift Time data calculated with Garfield (by C.Lippmann)
1040   //
1041
1042   const Int_t ktimebin  = 38;
1043   const Int_t kZbin = 11;
1044
1045   Float_t time[ktimebin][kZbin] =
1046     {{0.10176, 0.10197, 0.10356, 0.10479, 0.10497, 0.10500, 0.10500,
1047       0.10698, 0.12213, 0.16118, 0.22154},
1048      {0.07500, 0.07500, 0.07500, 0.07500, 0.07500, 0.07500, 0.07509,
1049       0.08010, 0.10176, 0.13244, 0.22848},
1050      {0.04500, 0.04500, 0.04500, 0.04500, 0.04500, 0.04503, 0.05130,
1051       0.07398, 0.07557, 0.11064, 0.26833},
1052      {0.01500, 0.01500, 0.01500, 0.01500, 0.03219, 0.04500, 0.04500,
1053       0.04500, 0.07482, 0.11628, 0.40846},
1054      {0.01500, 0.01500, 0.01500, 0.01500, 0.02886, 0.04500, 0.04500,
1055       0.04512, 0.07503, 0.13230, 0.43602},
1056      {0.04500, 0.04500, 0.04500, 0.04500, 0.04500, 0.04500, 0.04872,
1057       0.07437, 0.07635, 0.11925, 0.30372},
1058      {0.07500, 0.07497, 0.07500, 0.07500, 0.07500, 0.07500, 0.07500,
1059       0.08232, 0.10458, 0.14100, 0.24799},
1060      {0.10098, 0.10125, 0.10218, 0.10299, 0.10467, 0.15000, 0.10959,
1061       0.12207, 0.14241, 0.19485, 0.25688},
1062      {0.13500, 0.13503, 0.13509, 0.13782, 0.16182, 0.25076, 0.19593,
1063       0.19254, 0.21060, 0.25561, 0.29469},
1064      {0.19305, 0.19374, 0.19512, 0.19974, 0.22020, 0.29420, 0.25992,
1065       0.25461, 0.27515, 0.31938, 0.35238},
1066      {0.25143, 0.25320, 0.25476, 0.26166, 0.27993, 0.34470, 0.32160,
1067       0.31623, 0.33687, 0.37420, 0.40797},
1068      {0.31044, 0.31197, 0.31491, 0.32280, 0.34125, 0.39702, 0.38401,
1069       0.37794, 0.39545, 0.43494, 0.46956},
1070      {0.37128, 0.37146, 0.37668, 0.38424, 0.40326, 0.45271, 0.44643,
1071       0.43783, 0.45882, 0.49726, 0.52348},
1072      {0.43065, 0.43242, 0.43722, 0.44379, 0.46551, 0.51167, 0.50685,
1073       0.49924, 0.52016, 0.55609, 0.57829},
1074      {0.49161, 0.49329, 0.49725, 0.50629, 0.52803, 0.56777, 0.56755,
1075       0.56057, 0.58062, 0.61293, 0.63839},
1076      {0.55284, 0.55311, 0.55743, 0.56703, 0.58824, 0.62747, 0.62833,
1077       0.62083, 0.63899, 0.67412, 0.70006},
1078      {0.61323, 0.61494, 0.61782, 0.62802, 0.65025, 0.68675, 0.68847,
1079       0.68248, 0.70177, 0.73588, 0.76314},
1080      {0.67293, 0.67482, 0.68034, 0.68814, 0.71169, 0.74695, 0.75024,
1081       0.74462, 0.76083, 0.79194, 0.81463},
1082      {0.73470, 0.73665, 0.74013, 0.75054, 0.77107, 0.80588, 0.81071,
1083       0.80508, 0.82337, 0.85380, 0.87045},
1084      {0.79509, 0.79677, 0.80115, 0.81150, 0.83400, 0.86360, 0.87159,
1085       0.86608, 0.88323, 0.91756, 0.93721},
1086      {0.85695, 0.85800, 0.86307, 0.87276, 0.89599, 0.92639, 0.93266,
1087       0.92962, 0.94291, 0.97445, 0.99502},
1088      {0.91680, 0.91875, 0.92400, 0.93219, 0.95555, 0.98729, 0.99281,
1089       0.99145, 1.00683, 1.03343, 1.05299},
1090      {0.97833, 0.98058, 0.98421, 0.99357, 1.01602, 1.04438, 1.05299,
1091       1.05168, 1.06528, 1.09644, 1.11557},
1092      {1.03938, 1.04061, 1.04568, 1.05617, 1.07923, 1.10648, 1.11466,
1093       1.11385, 1.12606, 1.15817, 1.17352},
1094      {1.10166, 1.10268, 1.10766, 1.11785, 1.14014, 1.16717, 1.17496,
1095       1.17644, 1.19115, 1.21622, 1.23605},
1096      {1.16334, 1.16364, 1.16985, 1.17996, 1.19935, 1.22911, 1.23561,
1097       1.23526, 1.25144, 1.27936, 1.29018},
1098      {1.22403, 1.22598, 1.23000, 1.24092, 1.26173, 1.28817, 1.29991,
1099       1.29698, 1.31238, 1.33793, 1.35595},
1100      {1.28556, 1.28898, 1.29300, 1.30356, 1.32617, 1.34912, 1.35925,
1101       1.35835, 1.37312, 1.40111, 1.41497},
1102      {1.34787, 1.34877, 1.35468, 1.36449, 1.38654, 1.41077, 1.41975,
1103       1.42136, 1.43843, 1.45897, 1.48025},
1104      {1.41045, 1.41171, 1.41555, 1.42656, 1.44698, 1.47026, 1.48324,
1105       1.48479, 1.50180, 1.52354, 1.53392},
1106      {1.47090, 1.47354, 1.47647, 1.48905, 1.51211, 1.53038, 1.54349,
1107       1.54803, 1.56136, 1.58662, 1.60480},
1108      {1.53357, 1.53429, 1.54017, 1.55116, 1.57247, 1.59498, 1.60576,
1109       1.60746, 1.62389, 1.64239, 1.66245},
1110      {1.59522, 1.59636, 1.60247, 1.61385, 1.63641, 1.65659, 1.66619,
1111       1.67044, 1.68213, 1.70379, 1.72372},
1112      {1.65867, 1.65711, 1.66320, 1.67434, 1.69603, 1.71788, 1.72927,
1113       1.73214, 1.74713, 1.76485, 1.77775},
1114      {1.71825, 1.72074, 1.72497, 1.73712, 1.75690, 1.77755, 1.78711,
1115       1.79849, 1.80587, 1.82576, 1.84050},
1116      {1.78194, 1.78320, 1.78875, 1.80047, 1.81716, 1.84044, 1.85328,
1117       1.85511, 1.86911, 1.88919, 1.89926},
1118      {1.84335, 1.84431, 1.84938, 1.86063, 1.88022, 1.90234, 1.91177,
1119       1.92173, 1.93202, 1.95097, 1.97105},
1120      {1.90491, 1.90665, 1.91303, 1.92575, 1.94432, 1.96400, 1.97574,
1121       1.98378, 1.99368, 2.01964, 2.02605}};
1122
1123   if (fTimeStruct)  delete [] fTimeStruct;
1124   fTimeStruct  = new Float_t[ktimebin*kZbin];
1125
1126   for (Int_t ctrt = 0; ctrt<ktimebin; ctrt++)
1127     for (Int_t ctrz = 0; ctrz<kZbin; ctrz++) {
1128       fTimeStruct[ctrt+ctrz*ktimebin] = time[ctrt][ctrz];
1129     }
1130
1131 }
1132
1133 //_____________________________________________________________________________
1134 void AliTRDparameter::SamplePRF()
1135 {
1136   //
1137   // Samples the pad response function
1138   //
1139
1140   const Int_t kNplan  = AliTRDgeometry::kNplan;
1141   const Int_t kPRFbin = 61;
1142
1143   Float_t prf[kNplan][kPRFbin] = { {0.0267681, 0.031056,  0.036111,  0.0419945, 0.0489578,
1144                                     0.0571508, 0.0666984, 0.078064,  0.0912508, 0.106579,
1145                                     0.124429,  0.144803,  0.168187,  0.194645,  0.224143,
1146                                     0.25717,   0.293146,  0.331943,  0.373128,  0.415798,
1147                                     0.459149,  0.502028,  0.54349,   0.582109,  0.617335,
1148                                     0.648306,  0.674189,  0.695082,  0.710222,  0.719711,
1149                                     0.723751,  0.719711,  0.710222,  0.695082,  0.674189,
1150                                     0.648306,  0.617335,  0.582109,  0.54349,   0.502028,
1151                                     0.459149,  0.415798,  0.373128,  0.331943,  0.293146,
1152                                     0.25717,   0.224143,  0.194645,  0.168187,  0.144803,
1153                                     0.124429,  0.106579,  0.0912508, 0.078064,  0.0666984,
1154                                     0.0571508, 0.0489578, 0.0419945, 0.036111,  0.031056,
1155                                     0.0267681},
1156                                    {0.0240831, 0.0281427, 0.0328987, 0.0384801, 0.0451249,
1157                                     0.0530119, 0.0623139, 0.0733268, 0.0864095, 0.101704,
1158                                     0.119473,  0.140308,  0.164191,  0.191333,  0.222141,
1159                                     0.256551,  0.29433,   0.335294,  0.37892,   0.424206,
1160                                     0.470202,  0.515621,  0.559255,  0.600068,  0.636821,
1161                                     0.668836,  0.695767,  0.717076,  0.73233,   0.741818,
1162                                     0.745491,  0.741818,  0.73233,   0.717076,  0.695767,
1163                                     0.668836,  0.636821,  0.600068,  0.559255,  0.515621,
1164                                     0.470202,  0.424206,  0.37892,   0.335294,  0.29433,
1165                                     0.256551,  0.222141,  0.191333,  0.164191,  0.140308,
1166                                     0.119473,  0.101704,  0.0864095, 0.0733268, 0.0623139,
1167                                     0.0530119, 0.0451249, 0.0384801, 0.0328987, 0.0281427,
1168                                     0.0240831},
1169                                    {0.0206855, 0.0243011, 0.0285603, 0.0335902, 0.0396015,
1170                                     0.0467843, 0.0553424, 0.0655316, 0.0776688, 0.0921782,
1171                                     0.109269,  0.129259,  0.152459,  0.179369,  0.210091,
1172                                     0.244681,  0.283099,  0.325176,  0.370396,  0.417732,
1173                                     0.466086,  0.514192,  0.560518,  0.603805,  0.643028,
1174                                     0.67738,   0.706095,  0.728728,  0.745307,  0.755731,
1175                                     0.759954,  0.755731,  0.745307,  0.728728,  0.706095,
1176                                     0.67738,   0.643028,  0.603805,  0.560518,  0.514192,
1177                                     0.466086,  0.417732,  0.370396,  0.325176,  0.283099,
1178                                     0.244681,  0.210091,  0.179369,  0.152459,  0.129259,
1179                                     0.109269,  0.0921782, 0.0776688, 0.0655316, 0.0553424,
1180                                     0.0467843, 0.0396015, 0.0335902, 0.0285603, 0.0243011,
1181                                     0.0206855},
1182                                    {0.0186168, 0.0219999, 0.0260102, 0.0307769, 0.0364947,
1183                                     0.0433655, 0.0516213, 0.0615466, 0.0734611, 0.0877121,
1184                                     0.104666,  0.124855,  0.14853,   0.176033,  0.207639,
1185                                     0.243511,  0.283633,  0.327786,  0.37537,   0.425281,
1186                                     0.476227,  0.526727,  0.575268,  0.620462,  0.66101,
1187                                     0.69611,   0.725313,  0.748317,  0.764969,  0.775206,
1188                                     0.779006,  0.775206,  0.764969,  0.748317,  0.725313,
1189                                     0.69611,   0.66101,   0.620462,  0.575268,  0.526727,
1190                                     0.476227,  0.425281,  0.37537,   0.327786,  0.283633,
1191                                     0.243511,  0.207639,  0.176033,  0.14853,   0.124855,
1192                                     0.104666,  0.0877121, 0.0734611, 0.0615466, 0.0516213,
1193                                     0.0433655, 0.0364947, 0.0307769, 0.0260102, 0.0219999,
1194                                     0.0186168, },
1195                                    {0.0159737, 0.0189921, 0.0225916, 0.0268927, 0.0320634,
1196                                     0.0382995, 0.0458393, 0.0549765, 0.0660512, 0.0794439,
1197                                     0.095565,  0.114844,  0.137713,  0.164586,  0.195824,
1198                                     0.231681,  0.272223,  0.31727,   0.366248,  0.418078,
1199                                     0.471358,  0.524425,  0.575561,  0.623193,  0.666055,
1200                                     0.703243,  0.734192,  0.7586,    0.776331,  0.787347,
1201                                     0.791646,  0.787347,  0.776331,  0.7586,    0.734192,
1202                                     0.703243,  0.666055,  0.623193,  0.575561,  0.524425,
1203                                     0.471358,  0.418078,  0.366248,  0.31727,   0.272223,
1204                                     0.231681,  0.195824,  0.164586,  0.137713,  0.114844,
1205                                     0.095565,  0.0794439, 0.0660512, 0.0549765, 0.0458393,
1206                                     0.0382995, 0.0320634, 0.0268927, 0.0225916, 0.0189921,
1207                                     0.0159737},
1208                                    {0.0143532, 0.0171745, 0.0205622, 0.024635,  0.0295461,
1209                                     0.0354915, 0.0427198, 0.0515368, 0.0623058, 0.0754416,
1210                                     0.0913994, 0.110662,  0.133721,  0.161057,  0.193093,
1211                                     0.230138,  0.27229,   0.319327,  0.370597,  0.424961,
1212                                     0.480832,  0.536333,  0.589555,  0.638805,  0.682781,
1213                                     0.720621,  0.751845,  0.776243,  0.793764,  0.804426,
1214                                     0.808259,  0.804426,  0.793764,  0.776243,  0.751845,
1215                                     0.720621,  0.682781,  0.638805,  0.589555,  0.536333,
1216                                     0.480832,  0.424961,  0.370597,  0.319327,  0.27229,
1217                                     0.230138,  0.193093,  0.161057,  0.133721,  0.110662,
1218                                     0.0913994, 0.0754416, 0.0623058, 0.0515368, 0.0427198,
1219                                     0.0354915, 0.0295461, 0.024635,  0.0205622, 0.0171745,
1220                                     0.0143532} };
1221
1222   // More sampling precision with linear interpolation
1223   fPRFlo  = -1.5;
1224   fPRFhi  =  1.5;
1225   Float_t pad[kPRFbin];
1226   Int_t   sPRFbin = kPRFbin;
1227   Float_t sPRFwid = (fPRFhi - fPRFlo) / ((Float_t) sPRFbin);
1228   for (Int_t iPad = 0; iPad < sPRFbin; iPad++) {
1229     pad[iPad] = ((Float_t) iPad + 0.5) * sPRFwid + fPRFlo;
1230   }
1231   fPRFbin = 500;
1232   fPRFwid = (fPRFhi - fPRFlo) / ((Float_t) fPRFbin);
1233   fPRFpad = ((Int_t) (1.0 / fPRFwid));
1234
1235   if (fPRFsmp) delete [] fPRFsmp;
1236   fPRFsmp = new Float_t[kNplan*fPRFbin];
1237
1238   Int_t   ipos1;
1239   Int_t   ipos2;
1240   Float_t diff;
1241
1242   for (Int_t iPla = 0; iPla < kNplan; iPla++) {
1243
1244     for (Int_t iBin = 0; iBin < fPRFbin; iBin++) {
1245
1246       Float_t bin = (((Float_t) iBin) + 0.5) * fPRFwid + fPRFlo;
1247       ipos1 = ipos2 = 0;
1248       diff  = 0;
1249       do {
1250         diff = bin - pad[ipos2++];
1251       } while ((diff > 0) && (ipos2 < kPRFbin));
1252       if      (ipos2 == kPRFbin) {
1253         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2-1];
1254       }
1255       else if (ipos2 == 1) {
1256         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2-1];
1257       }
1258       else {
1259         ipos2--;
1260         if (ipos2 >= kPRFbin) ipos2 = kPRFbin - 1;
1261         ipos1 = ipos2 - 1;
1262         fPRFsmp[iPla*fPRFbin+iBin] = prf[iPla][ipos2]
1263                                    + diff * (prf[iPla][ipos2] - prf[iPla][ipos1])
1264                                           / sPRFwid;
1265       }
1266
1267     }
1268   }
1269
1270 }
1271
1272 //_____________________________________________________________________________
1273 void AliTRDparameter::FillLUT()
1274 {
1275   //
1276   // Create the LUT
1277   //
1278
1279   const Int_t kNplan = AliTRDgeometry::kNplan;
1280   const Int_t kNlut  = 128;
1281
1282   fLUTbin = kNplan * kNlut;
1283
1284   // The lookup table from Bogdan
1285   Float_t lut[kNplan][kNlut] = {
1286     {
1287       0.0070, 0.0150, 0.0224, 0.0298, 0.0374, 0.0454, 0.0533, 0.0611,
1288       0.0684, 0.0755, 0.0827, 0.0900, 0.0975, 0.1049, 0.1120, 0.1187,
1289       0.1253, 0.1318, 0.1385, 0.1453, 0.1519, 0.1584, 0.1646, 0.1704,
1290       0.1762, 0.1821, 0.1879, 0.1938, 0.1996, 0.2053, 0.2108, 0.2160,
1291       0.2210, 0.2260, 0.2310, 0.2361, 0.2411, 0.2461, 0.2509, 0.2557,
1292       0.2602, 0.2646, 0.2689, 0.2732, 0.2774, 0.2816, 0.2859, 0.2901,
1293       0.2942, 0.2983, 0.3022, 0.3061, 0.3099, 0.3136, 0.3172, 0.3207,
1294       0.3242, 0.3278, 0.3312, 0.3347, 0.3382, 0.3416, 0.3450, 0.3483,
1295       0.3515, 0.3547, 0.3579, 0.3609, 0.3639, 0.3669, 0.3698, 0.3727,
1296       0.3756, 0.3785, 0.3813, 0.3842, 0.3870, 0.3898, 0.3926, 0.3952,
1297       0.3979, 0.4005, 0.4032, 0.4057, 0.4082, 0.4108, 0.4132, 0.4157,
1298       0.4181, 0.4205, 0.4228, 0.4252, 0.4275, 0.4299, 0.4322, 0.4345,
1299       0.4367, 0.4390, 0.4412, 0.4434, 0.4456, 0.4478, 0.4499, 0.4520,
1300       0.4541, 0.4562, 0.4583, 0.4603, 0.4623, 0.4643, 0.4663, 0.4683,
1301       0.4702, 0.4722, 0.4741, 0.4758, 0.4774, 0.4790, 0.4805, 0.4824,
1302       0.4844, 0.4863, 0.4883, 0.4902, 0.4921, 0.4940, 0.4959, 0.4978
1303     },
1304     {
1305       0.0072, 0.0156, 0.0235, 0.0313, 0.0394, 0.0478, 0.0561, 0.0642,
1306       0.0718, 0.0792, 0.0868, 0.0947, 0.1025, 0.1101, 0.1172, 0.1241,
1307       0.1309, 0.1378, 0.1449, 0.1518, 0.1586, 0.1650, 0.1710, 0.1770,
1308       0.1830, 0.1891, 0.1952, 0.2011, 0.2070, 0.2125, 0.2177, 0.2229,
1309       0.2280, 0.2332, 0.2383, 0.2435, 0.2484, 0.2533, 0.2581, 0.2627,
1310       0.2670, 0.2714, 0.2757, 0.2799, 0.2842, 0.2884, 0.2927, 0.2968,
1311       0.3008, 0.3048, 0.3086, 0.3123, 0.3159, 0.3195, 0.3231, 0.3266,
1312       0.3301, 0.3335, 0.3370, 0.3404, 0.3438, 0.3471, 0.3504, 0.3536,
1313       0.3567, 0.3598, 0.3628, 0.3657, 0.3686, 0.3715, 0.3744, 0.3772,
1314       0.3800, 0.3828, 0.3856, 0.3884, 0.3911, 0.3938, 0.3965, 0.3991,
1315       0.4016, 0.4042, 0.4067, 0.4092, 0.4116, 0.4140, 0.4164, 0.4187,
1316       0.4211, 0.4234, 0.4257, 0.4280, 0.4302, 0.4325, 0.4347, 0.4369,
1317       0.4391, 0.4413, 0.4434, 0.4456, 0.4477, 0.4497, 0.4518, 0.4538,
1318       0.4558, 0.4578, 0.4598, 0.4618, 0.4637, 0.4656, 0.4675, 0.4694,
1319       0.4713, 0.4732, 0.4750, 0.4766, 0.4781, 0.4797, 0.4813, 0.4832,
1320       0.4851, 0.4870, 0.4888, 0.4906, 0.4925, 0.4942, 0.4960, 0.4978
1321     },
1322     {
1323       0.0075, 0.0163, 0.0246, 0.0328, 0.0415, 0.0504, 0.0592, 0.0674,
1324       0.0753, 0.0832, 0.0914, 0.0996, 0.1077, 0.1154, 0.1225, 0.1296,
1325       0.1369, 0.1442, 0.1515, 0.1585, 0.1652, 0.1714, 0.1776, 0.1839,
1326       0.1902, 0.1965, 0.2025, 0.2085, 0.2141, 0.2194, 0.2247, 0.2299,
1327       0.2352, 0.2405, 0.2457, 0.2507, 0.2557, 0.2604, 0.2649, 0.2693,
1328       0.2737, 0.2780, 0.2823, 0.2867, 0.2909, 0.2951, 0.2992, 0.3033,
1329       0.3072, 0.3110, 0.3146, 0.3182, 0.3218, 0.3253, 0.3288, 0.3323,
1330       0.3357, 0.3392, 0.3426, 0.3459, 0.3492, 0.3524, 0.3555, 0.3586,
1331       0.3616, 0.3645, 0.3674, 0.3703, 0.3731, 0.3759, 0.3787, 0.3815,
1332       0.3843, 0.3870, 0.3897, 0.3925, 0.3950, 0.3976, 0.4002, 0.4027,
1333       0.4052, 0.4076, 0.4101, 0.4124, 0.4148, 0.4171, 0.4194, 0.4217,
1334       0.4239, 0.4262, 0.4284, 0.4306, 0.4328, 0.4350, 0.4371, 0.4393,
1335       0.4414, 0.4435, 0.4455, 0.4476, 0.4496, 0.4516, 0.4536, 0.4555,
1336       0.4575, 0.4594, 0.4613, 0.4632, 0.4650, 0.4669, 0.4687, 0.4705,
1337       0.4723, 0.4741, 0.4758, 0.4773, 0.4789, 0.4804, 0.4821, 0.4839,
1338       0.4857, 0.4875, 0.4893, 0.4910, 0.4928, 0.4945, 0.4961, 0.4978
1339     },
1340     {
1341       0.0078, 0.0171, 0.0258, 0.0345, 0.0438, 0.0532, 0.0624, 0.0708,
1342       0.0791, 0.0875, 0.0962, 0.1048, 0.1130, 0.1206, 0.1281, 0.1356,
1343       0.1432, 0.1508, 0.1582, 0.1651, 0.1716, 0.1780, 0.1845, 0.1910,
1344       0.1975, 0.2038, 0.2099, 0.2155, 0.2210, 0.2263, 0.2317, 0.2371,
1345       0.2425, 0.2477, 0.2528, 0.2578, 0.2626, 0.2671, 0.2715, 0.2759,
1346       0.2803, 0.2846, 0.2890, 0.2933, 0.2975, 0.3016, 0.3056, 0.3095,
1347       0.3132, 0.3168, 0.3204, 0.3239, 0.3274, 0.3309, 0.3344, 0.3378,
1348       0.3412, 0.3446, 0.3479, 0.3511, 0.3543, 0.3574, 0.3603, 0.3633,
1349       0.3662, 0.3690, 0.3718, 0.3747, 0.3774, 0.3802, 0.3829, 0.3857,
1350       0.3883, 0.3910, 0.3936, 0.3962, 0.3987, 0.4012, 0.4037, 0.4061,
1351       0.4085, 0.4109, 0.4132, 0.4155, 0.4177, 0.4200, 0.4222, 0.4244,
1352       0.4266, 0.4288, 0.4309, 0.4331, 0.4352, 0.4373, 0.4394, 0.4414,
1353       0.4435, 0.4455, 0.4475, 0.4494, 0.4514, 0.4533, 0.4552, 0.4571,
1354       0.4590, 0.4608, 0.4626, 0.4645, 0.4662, 0.4680, 0.4698, 0.4715,
1355       0.4733, 0.4750, 0.4766, 0.4781, 0.4796, 0.4812, 0.4829, 0.4846,
1356       0.4863, 0.4880, 0.4897, 0.4914, 0.4930, 0.4946, 0.4963, 0.4979
1357     },
1358     {
1359       0.0081, 0.0178, 0.0270, 0.0364, 0.0463, 0.0562, 0.0656, 0.0744,
1360       0.0831, 0.0921, 0.1013, 0.1102, 0.1183, 0.1261, 0.1339, 0.1419,
1361       0.1499, 0.1576, 0.1648, 0.1715, 0.1782, 0.1849, 0.1917, 0.1984,
1362       0.2048, 0.2110, 0.2167, 0.2223, 0.2278, 0.2333, 0.2389, 0.2444,
1363       0.2497, 0.2548, 0.2598, 0.2645, 0.2691, 0.2735, 0.2780, 0.2824,
1364       0.2868, 0.2912, 0.2955, 0.2997, 0.3038, 0.3078, 0.3116, 0.3152,
1365       0.3188, 0.3224, 0.3259, 0.3294, 0.3329, 0.3364, 0.3398, 0.3432,
1366       0.3465, 0.3497, 0.3529, 0.3561, 0.3591, 0.3620, 0.3649, 0.3677,
1367       0.3705, 0.3733, 0.3761, 0.3788, 0.3816, 0.3843, 0.3869, 0.3896,
1368       0.3922, 0.3948, 0.3973, 0.3998, 0.4022, 0.4047, 0.4070, 0.4094,
1369       0.4117, 0.4139, 0.4162, 0.4184, 0.4206, 0.4227, 0.4249, 0.4270,
1370       0.4291, 0.4313, 0.4334, 0.4354, 0.4375, 0.4395, 0.4415, 0.4435,
1371       0.4455, 0.4474, 0.4493, 0.4512, 0.4531, 0.4550, 0.4568, 0.4586,
1372       0.4604, 0.4622, 0.4639, 0.4657, 0.4674, 0.4691, 0.4708, 0.4725,
1373       0.4742, 0.4758, 0.4773, 0.4788, 0.4803, 0.4819, 0.4836, 0.4852,
1374       0.4869, 0.4885, 0.4901, 0.4917, 0.4933, 0.4948, 0.4964, 0.4979
1375     },
1376     {
1377       0.0085, 0.0189, 0.0288, 0.0389, 0.0497, 0.0603, 0.0699, 0.0792,
1378       0.0887, 0.0985, 0.1082, 0.1170, 0.1253, 0.1336, 0.1421, 0.1505,
1379       0.1587, 0.1662, 0.1733, 0.1803, 0.1874, 0.1945, 0.2014, 0.2081,
1380       0.2143, 0.2201, 0.2259, 0.2316, 0.2374, 0.2431, 0.2487, 0.2541,
1381       0.2593, 0.2642, 0.2689, 0.2735, 0.2781, 0.2826, 0.2872, 0.2917,
1382       0.2961, 0.3003, 0.3045, 0.3086, 0.3125, 0.3162, 0.3198, 0.3235,
1383       0.3270, 0.3306, 0.3342, 0.3377, 0.3411, 0.3446, 0.3479, 0.3511,
1384       0.3543, 0.3575, 0.3605, 0.3634, 0.3663, 0.3691, 0.3720, 0.3748,
1385       0.3775, 0.3803, 0.3830, 0.3857, 0.3884, 0.3911, 0.3937, 0.3962,
1386       0.3987, 0.4012, 0.4036, 0.4060, 0.4084, 0.4107, 0.4129, 0.4152,
1387       0.4174, 0.4196, 0.4218, 0.4239, 0.4261, 0.4282, 0.4303, 0.4324,
1388       0.4344, 0.4365, 0.4385, 0.4405, 0.4425, 0.4445, 0.4464, 0.4483,
1389       0.4502, 0.4521, 0.4539, 0.4558, 0.4576, 0.4593, 0.4611, 0.4629,
1390       0.4646, 0.4663, 0.4680, 0.4697, 0.4714, 0.4730, 0.4747, 0.4759,
1391       0.4769, 0.4780, 0.4790, 0.4800, 0.4811, 0.4827, 0.4843, 0.4859,
1392       0.4874, 0.4889, 0.4905, 0.4920, 0.4935, 0.4950, 0.4965, 0.4979
1393     }
1394   };
1395
1396   if (fLUT) delete [] fLUT;
1397   fLUT = new Float_t[fLUTbin];
1398
1399   for (Int_t iplan = 0; iplan < kNplan; iplan++) {
1400     for (Int_t ilut  = 0; ilut  < kNlut; ilut++) {
1401       fLUT[iplan*kNlut+ilut] = lut[iplan][ilut];
1402     }
1403   }
1404
1405 }
1406
1407 //_____________________________________________________________________________
1408 void AliTRDparameter::SetTiltingAngle(Float_t v)
1409 {
1410   //
1411   // Set the tilting angle for the readout pads
1412   //
1413
1414   fTiltingAngle = TMath::Tan(TMath::Pi()/180.0 * v);
1415
1416 }
1417
1418 //_____________________________________________________________________________
1419 Float_t AliTRDparameter::GetTiltingAngle() const
1420 {
1421   //
1422   // Get the tilting angle for the readout pads
1423   //
1424
1425   return 180.0 / TMath::Pi() * TMath::ATan(fTiltingAngle);
1426
1427 }
1428
1429 //_____________________________________________________________________________
1430 Float_t AliTRDparameter::GetDiffusionL(Float_t vd, Float_t b)
1431 {
1432   //
1433   // Returns the longitudinal diffusion coefficient for a given drift
1434   // velocity <vd> and a B-field <b> for Xe/CO2 (15%).
1435   // The values are according to a GARFIELD simulation.
1436   //
1437
1438   const Int_t kNb = 5;
1439   Float_t p0[kNb] = {  0.007440,  0.007493,  0.007513,  0.007672,  0.007831 };
1440   Float_t p1[kNb] = {  0.019252,  0.018912,  0.018636,  0.018012,  0.017343 };
1441   Float_t p2[kNb] = { -0.005042, -0.004926, -0.004867, -0.004650, -0.004424 };
1442   Float_t p3[kNb] = {  0.000195,  0.000189,  0.000195,  0.000182,  0.000169 };
1443
1444   Int_t ib = ((Int_t) (10 * (b - 0.15)));
1445   ib       = TMath::Max(  0,ib);
1446   ib       = TMath::Min(kNb,ib);
1447
1448   Float_t diff = p0[ib]
1449                + p1[ib] * vd
1450                + p2[ib] * vd*vd
1451                + p3[ib] * vd*vd*vd;
1452
1453   return diff;
1454
1455 }
1456
1457 //_____________________________________________________________________________
1458 Float_t AliTRDparameter::GetDiffusionT(Float_t vd, Float_t b)
1459 {
1460   //
1461   // Returns the transverse diffusion coefficient for a given drift
1462   // velocity <vd> and a B-field <b> for Xe/CO2 (15%).
1463   // The values are according to a GARFIELD simulation.
1464   //
1465
1466   const Int_t kNb = 5;
1467   Float_t p0[kNb] = {  0.009550,  0.009599,  0.009674,  0.009757,  0.009850 };
1468   Float_t p1[kNb] = {  0.006667,  0.006539,  0.006359,  0.006153,  0.005925 };
1469   Float_t p2[kNb] = { -0.000853, -0.000798, -0.000721, -0.000635, -0.000541 };
1470   Float_t p3[kNb] = {  0.000131,  0.000122,  0.000111,  0.000098,  0.000085 };
1471
1472   Int_t ib = ((Int_t) (10 * (b - 0.15)));
1473   ib       = TMath::Max(  0,ib);
1474   ib       = TMath::Min(kNb,ib);
1475
1476   Float_t diff = p0[ib]
1477                + p1[ib] * vd
1478                + p2[ib] * vd*vd
1479                + p3[ib] * vd*vd*vd;
1480
1481   return diff;
1482
1483 }
1484
1485 //_____________________________________________________________________________
1486 Float_t AliTRDparameter::GetOmegaTau(Float_t vd, Float_t b)
1487 {
1488   //
1489   // Returns omega*tau (tan(Lorentz-angle)) for a given drift velocity <vd>
1490   // and a B-field <b> for Xe/CO2 (15%).
1491   // The values are according to a GARFIELD simulation.
1492   //
1493
1494   const Int_t kNb = 5;
1495   Float_t p0[kNb] = {  0.004810,  0.007412,  0.010252,  0.013409,  0.016888 };
1496   Float_t p1[kNb] = {  0.054875,  0.081534,  0.107333,  0.131983,  0.155455 };
1497   Float_t p2[kNb] = { -0.008682, -0.012896, -0.016987, -0.020880, -0.024623 };
1498   Float_t p3[kNb] = {  0.000155,  0.000238,  0.000330,  0.000428,  0.000541 };
1499
1500   Int_t ib = ((Int_t) (10 * (b - 0.15)));
1501   ib       = TMath::Max(  0,ib);
1502   ib       = TMath::Min(kNb,ib);
1503
1504   Float_t alphaL = p0[ib]
1505                  + p1[ib] * vd
1506                  + p2[ib] * vd*vd
1507                  + p3[ib] * vd*vd*vd;
1508
1509   return TMath::Tan(alphaL);
1510
1511 }
1512
1513 //_____________________________________________________________________________
1514 Double_t AliTRDparameter::LUTposition(Int_t iplane, Double_t ampL
1515                                                   , Double_t ampC
1516                                                   , Double_t ampR) const
1517 {
1518   //
1519   // Calculates the cluster position using the lookup table.
1520   // Method provided by Bogdan Vulpescu.
1521   //
1522
1523   const Int_t kNplan = AliTRDgeometry::kNplan;
1524   const Int_t kNlut  = 128;
1525
1526   Double_t pos;
1527   Double_t x = 0.0;
1528   Double_t xmin;
1529   Double_t xmax;
1530   Double_t xwid;
1531
1532   Int_t    side = 0;
1533   Int_t    ix;
1534
1535   Double_t xMin[kNplan] = { 0.006492, 0.006377, 0.006258, 0.006144, 0.006030, 0.005980 };
1536   Double_t xMax[kNplan] = { 0.960351, 0.965870, 0.970445, 0.974352, 0.977667, 0.996101 };
1537
1538   if      (ampL > ampR) {
1539     x    = (ampL - ampR) / ampC;
1540     side = -1;
1541   }
1542   else if (ampL < ampR) {
1543     x    = (ampR - ampL) / ampC;
1544     side = +1;
1545   }
1546
1547   if (ampL != ampR) {
1548
1549     xmin = xMin[iplane] + 0.000005;
1550     xmax = xMax[iplane] - 0.000005;
1551     xwid = (xmax - xmin) / 127.0;
1552
1553     if      (x < xmin) {
1554       pos = 0.0000;
1555     }
1556     else if (x > xmax) {
1557       pos = side * 0.5000;
1558     }
1559     else {
1560       ix  = (Int_t) ((x - xmin) / xwid);
1561       pos = side * fLUT[iplane*kNlut+ix];
1562     }
1563
1564   }
1565   else {
1566
1567     pos = 0.0;
1568
1569   }
1570
1571   return pos;
1572
1573 }