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