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