TRD/AliTRDcluster.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18
  19 ///////////////////////////////////////////////////////////////////////////////
  20 //                                                                           //
  21 //  TRD cluster                                                              //
  22 //                                                                           //
  23 ///////////////////////////////////////////////////////////////////////////////
  24
  25 #include "TMath.h"
  26
  27 #include "AliLog.h"
  28 #include "AliTRDcluster.h"
  29 #include "AliTRDgeometry.h"
  30 #include "AliTRDCommonParam.h"
  31
  32 ClassImp(AliTRDcluster)
  33
  34 const Int_t AliTRDcluster::fgkNlut = 128;
  35 Double_t *AliTRDcluster::fgLUT = 0x0;
  36
  37 //___________________________________________________________________________
  38 AliTRDcluster::AliTRDcluster()
  39   :AliCluster()
  40   ,fPadCol(0)
  41   ,fPadRow(0)
  42   ,fPadTime(0)
  43   ,fLocalTimeBin(0)
  44   ,fNPads(0)
  45   ,fClusterMasking(0)
  46   ,fDetector(0)
  47   ,fQ(0)
  48   ,fCenter(0)
  49 {
  50   //
  51   // Default constructor
  52   //
  53
  54   for (Int_t i = 0; i < 7; i++) {
  55     fSignals[i] = 0;
  56   }
  57
  58 }
  59
  60 //___________________________________________________________________________
  61 AliTRDcluster::AliTRDcluster(Int_t det, UChar_t col, UChar_t row, UChar_t time, const Short_t *sig, UShort_t vid)
  62   :AliCluster()
  63   ,fPadCol(col)
  64   ,fPadRow(row)
  65   ,fPadTime(time)
  66   ,fLocalTimeBin(0)
  67   ,fNPads(0)
  68   ,fClusterMasking(0)
  69   ,fDetector(det)
  70   ,fQ(0.)
  71   ,fCenter(0.)
  72 {
  73   //
  74   // Constructor for self constructing cluster. In this approach the information is inserted gradualy into the
  75   // cluster and all dependencies are (re)calculated inside the cluster itself.
  76   //
  77   // A.Bercuci <A.Bercuci@gsi.de>
  78
  79   memcpy(&fSignals, sig, 7*sizeof(Short_t));
  80   fQ = fSignals[2]+fSignals[3]+fSignals[4];
  81   SetVolumeId(vid);
  82 }
  83
  84 //___________________________________________________________________________
  85 AliTRDcluster::AliTRDcluster(Int_t det, Float_t q
  86                            , Float_t *pos, Float_t *sig
  87                            , Int_t *tracks, Char_t npads, Short_t *signals
  88                            , UChar_t col, UChar_t row, UChar_t time
  89                            , Char_t timebin, Float_t center, UShort_t volid)
  90   :AliCluster(volid,pos[0],pos[1],pos[2],sig[0],sig[1],0.0,0x0)
  91   ,fPadCol(col)
  92   ,fPadRow(row)
  93   ,fPadTime(time)
  94   ,fLocalTimeBin(timebin)
  95   ,fNPads(npads)
  96   ,fClusterMasking(0)
  97   ,fDetector(det)
  98   ,fQ(q)
  99   ,fCenter(center)
 100 {
 101   //
 102   // Constructor
 103   //
 104
 105   for (Int_t i = 0; i < 7; i++) {
 106     fSignals[i] = signals[i];
 107   }
 108
 109   if (tracks) {
 110     AddTrackIndex(tracks);
 111   }
 112
 113 }
 114
 115 //_____________________________________________________________________________
 116 AliTRDcluster::AliTRDcluster(const AliTRDcluster &c)
 117   :AliCluster(c)
 118   ,fPadCol(c.fPadCol)
 119   ,fPadRow(c.fPadRow)
 120   ,fPadTime(c.fPadTime)
 121   ,fLocalTimeBin(c.fLocalTimeBin)
 122   ,fNPads(c.fNPads)
 123   ,fClusterMasking(c.fClusterMasking)
 124   ,fDetector(c.fDetector)
 125   ,fQ(c.fQ)
 126   ,fCenter(c.fCenter)
 127 {
 128   //
 129   // Copy constructor
 130   //
 131
 132   SetBit(kInChamber, c.IsInChamber());
 133   SetLabel(c.GetLabel(0),0);
 134   SetLabel(c.GetLabel(1),1);
 135   SetLabel(c.GetLabel(2),2);
 136
 137   SetY(c.GetY());
 138   SetZ(c.GetZ());
 139   SetSigmaY2(c.GetSigmaY2());
 140   SetSigmaZ2(c.GetSigmaZ2());
 141
 142   for (Int_t i = 0; i < 7; i++) {
 143     fSignals[i] = c.fSignals[i];
 144   }
 145
 146 }
 147
 148 //_____________________________________________________________________________
 149 void AliTRDcluster::AddTrackIndex(Int_t *track)
 150 {
 151   //
 152   // Adds track index. Currently assumed that track is an array of
 153   // size 9, and up to 3 track indexes are stored in fTracks[3].
 154   // Indexes are sorted according to:
 155   //  1) index of max number of appearances is stored first
 156   //  2) if two or more indexes appear equal number of times, the lowest
 157   //     ones are stored first;
 158   //
 159
 160   const Int_t kSize = 9;
 161   Int_t  entries[kSize][2];
 162
 163   Int_t  i = 0;
 164   Int_t  j = 0;
 165   Int_t  k = 0;
 166   Int_t  index;
 167   Bool_t indexAdded;
 168
 169   for (i = 0; i < kSize; i++) {
 170     entries[i][0] = -1;
 171     entries[i][1] =  0;
 172   }
 173
 174   for (k = 0; k < kSize; k++) {
 175
 176     index      = track[k];
 177     indexAdded = kFALSE;
 178
 179     j = 0;
 180     if (index >= 0) {
 181       while ((!indexAdded) && (j < kSize)) {
 182         if ((entries[j][0] == index) ||
 183             (entries[j][1] ==     0)) {
 184           entries[j][0] = index;
 185           entries[j][1] = entries[j][1] + 1;
 186           indexAdded    = kTRUE;
 187         }
 188         j++;
 189       }
 190     }
 191
 192   }
 193
 194   // Sort by number of appearances and index value
 195   Int_t swap = 1;
 196   Int_t tmp0;
 197   Int_t tmp1;
 198   while (swap > 0) {
 199     swap = 0;
 200     for (i = 0; i < (kSize - 1); i++) {
 201       if ((entries[i][0]   >= 0) &&
 202           (entries[i+1][0] >= 0)) {
 203         if ((entries[i][1] < entries[i+1][1]) ||
 204             ((entries[i][1] == entries[i+1][1]) &&
 205              (entries[i][0] >  entries[i+1][0]))) {
 206           tmp0            = entries[i][0];
 207           tmp1            = entries[i][1];
 208           entries[i][0]   = entries[i+1][0];
 209           entries[i][1]   = entries[i+1][1];
 210           entries[i+1][0] = tmp0;
 211           entries[i+1][1] = tmp1;
 212           swap++;
 213         }
 214       }
 215     }
 216   }
 217
 218   // Set track indexes
 219   for (i = 0; i < 3; i++) {
 220     SetLabel(entries[i][0],i);
 221   }
 222
 223   return;
 224
 225 }
 226
 227 //_____________________________________________________________________________
 228 void AliTRDcluster::Clear(Option_t *)
 229 {
 230   //
 231   // Reset all member to the default value
 232   //
 233   fPadCol=0;
 234   fPadRow=0;
 235   fPadTime=0;
 236   fLocalTimeBin=0;
 237   fNPads=0;
 238   fClusterMasking=0;
 239   fDetector=0;
 240   for (Int_t i=0; i < 7; i++) fSignals[i]=0;
 241   fQ = 0;
 242   fCenter = 0;
 243   for (Int_t i = 0; i < 3; i++) SetLabel(0,i);
 244   SetX(0);
 245   SetY(0);
 246   SetZ(0);
 247   SetSigmaY2(0);
 248   SetSigmaZ2(0);
 249   SetVolumeId(0);
 250 }
 251
 252 //_____________________________________________________________________________
 253 Float_t AliTRDcluster::GetSumS() const
 254 {
 255   //
 256   // Returns the total charge from a not unfolded cluster
 257   //
 258
 259   Float_t sum = 0.0;
 260   for (Int_t i = 0; i < 7; i++) {
 261     sum += fSignals[i];
 262   }
 263
 264   return sum;
 265
 266 }
 267
 268 //___________________________________________________________________________
 269 Double_t AliTRDcluster::GetSX(Int_t tb, Double_t z)
 270 {
 271   if(tb<1 || tb>=24) return 10.; // return huge [10cm]
 272   const Double_t sx[24][10]={
 273     {0.000e+00, 9.352e-01, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 2.309e+00},
 274     {8.387e-02, 8.718e-02, 8.816e-02, 9.444e-02, 9.993e-02, 1.083e-01, 1.161e-01, 1.280e-01, 1.417e-01, 1.406e-01},
 275     {1.097e-01, 1.105e-01, 1.127e-01, 1.151e-01, 1.186e-01, 1.223e-01, 1.272e-01, 1.323e-01, 1.389e-01, 1.490e-01},
 276     {1.407e-01, 1.404e-01, 1.414e-01, 1.430e-01, 1.429e-01, 1.449e-01, 1.476e-01, 1.494e-01, 1.515e-01, 1.589e-01},
 277     {1.681e-01, 1.679e-01, 1.666e-01, 1.657e-01, 1.656e-01, 1.649e-01, 1.652e-01, 1.662e-01, 1.671e-01, 1.694e-01},
 278     {1.745e-01, 1.737e-01, 1.707e-01, 1.690e-01, 1.643e-01, 1.610e-01, 1.612e-01, 1.628e-01, 1.638e-01, 1.659e-01},
 279     {1.583e-01, 1.558e-01, 1.535e-01, 1.488e-01, 1.445e-01, 1.419e-01, 1.428e-01, 1.451e-01, 1.462e-01, 1.494e-01},
 280     {1.414e-01, 1.391e-01, 1.368e-01, 1.300e-01, 1.256e-01, 1.259e-01, 1.285e-01, 1.326e-01, 1.358e-01, 1.406e-01},
 281     {1.307e-01, 1.289e-01, 1.261e-01, 1.216e-01, 1.193e-01, 1.165e-01, 1.201e-01, 1.241e-01, 1.274e-01, 1.344e-01},
 282     {1.251e-01, 1.227e-01, 1.208e-01, 1.155e-01, 1.110e-01, 1.116e-01, 1.133e-01, 1.187e-01, 1.229e-01, 1.308e-01},
 283     {1.234e-01, 1.209e-01, 1.175e-01, 1.127e-01, 1.094e-01, 1.093e-01, 1.109e-01, 1.155e-01, 1.210e-01, 1.275e-01},
 284     {1.215e-01, 1.187e-01, 1.156e-01, 1.108e-01, 1.070e-01, 1.065e-01, 1.090e-01, 1.134e-01, 1.196e-01, 1.251e-01},
 285     {1.202e-01, 1.180e-01, 1.151e-01, 1.108e-01, 1.070e-01, 1.058e-01, 1.089e-01, 1.127e-01, 1.183e-01, 1.256e-01},
 286     {1.207e-01, 1.176e-01, 1.142e-01, 1.109e-01, 1.072e-01, 1.069e-01, 1.088e-01, 1.122e-01, 1.182e-01, 1.252e-01},
 287     {1.213e-01, 1.182e-01, 1.156e-01, 1.102e-01, 1.076e-01, 1.063e-01, 1.091e-01, 1.132e-01, 1.181e-01, 1.243e-01},
 288     {1.205e-01, 1.180e-01, 1.150e-01, 1.104e-01, 1.072e-01, 1.063e-01, 1.083e-01, 1.132e-01, 1.183e-01, 1.243e-01},
 289     {1.212e-01, 1.195e-01, 1.135e-01, 1.107e-01, 1.070e-01, 1.065e-01, 1.097e-01, 1.126e-01, 1.185e-01, 1.238e-01},
 290     {1.201e-01, 1.184e-01, 1.155e-01, 1.111e-01, 1.088e-01, 1.075e-01, 1.089e-01, 1.131e-01, 1.189e-01, 1.237e-01},
 291     {1.197e-01, 1.186e-01, 1.147e-01, 1.113e-01, 1.085e-01, 1.077e-01, 1.105e-01, 1.137e-01, 1.188e-01, 1.245e-01},
 292     {1.213e-01, 1.194e-01, 1.154e-01, 1.114e-01, 1.091e-01, 1.082e-01, 1.098e-01, 1.140e-01, 1.194e-01, 1.247e-01},
 293     {1.210e-01, 1.189e-01, 1.155e-01, 1.119e-01, 1.088e-01, 1.080e-01, 1.105e-01, 1.141e-01, 1.195e-01, 1.244e-01},
 294     {1.196e-01, 1.189e-01, 1.145e-01, 1.105e-01, 1.095e-01, 1.083e-01, 1.087e-01, 1.121e-01, 1.173e-01, 1.208e-01},
 295     {1.123e-01, 1.129e-01, 1.108e-01, 1.110e-01, 1.080e-01, 1.065e-01, 1.056e-01, 1.066e-01, 1.071e-01, 1.095e-01},
 296     {1.136e-01, 1.135e-01, 1.130e-01, 1.122e-01, 1.113e-01, 1.071e-01, 1.041e-01, 1.025e-01, 1.014e-01, 9.973e-02}
 297   };
 298   if(z>=0. && z<.25) return sx[tb][Int_t(z/.025)];
 299
 300   Double_t m = 1.e-8; for(Int_t id=10; id--;) if(sx[tb][id]>m) m=sx[tb][id];
 301   return m;
 302 }
 303
 304 //___________________________________________________________________________
 305 Double_t AliTRDcluster::GetSY(Int_t tb, Double_t z)
 306 {
 307   if(tb<1 || tb>=24) return 10.; // return huge [10cm]
 308   const Double_t sy[24][10]={
 309     {0.000e+00, 2.610e-01, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 4.680e-01},
 310     {3.019e-02, 3.036e-02, 3.131e-02, 3.203e-02, 3.294e-02, 3.407e-02, 3.555e-02, 3.682e-02, 3.766e-02, 3.824e-02},
 311     {1.773e-02, 1.778e-02, 1.772e-02, 1.790e-02, 1.807e-02, 1.833e-02, 1.873e-02, 1.905e-02, 1.958e-02, 2.029e-02},
 312     {1.774e-02, 1.772e-02, 1.746e-02, 1.738e-02, 1.756e-02, 1.756e-02, 1.739e-02, 1.720e-02, 1.743e-02, 1.769e-02},
 313     {2.064e-02, 2.078e-02, 2.069e-02, 2.060e-02, 2.033e-02, 2.024e-02, 2.022e-02, 1.961e-02, 1.922e-02, 1.901e-02},
 314     {2.382e-02, 2.379e-02, 2.371e-02, 2.333e-02, 2.318e-02, 2.285e-02, 2.255e-02, 2.244e-02, 2.174e-02, 2.132e-02},
 315     {2.615e-02, 2.589e-02, 2.539e-02, 2.493e-02, 2.420e-02, 2.396e-02, 2.362e-02, 2.342e-02, 2.321e-02, 2.330e-02},
 316     {2.640e-02, 2.638e-02, 2.577e-02, 2.548e-02, 2.477e-02, 2.436e-02, 2.416e-02, 2.401e-02, 2.399e-02, 2.402e-02},
 317     {2.647e-02, 2.632e-02, 2.587e-02, 2.546e-02, 2.465e-02, 2.447e-02, 2.429e-02, 2.415e-02, 2.429e-02, 2.475e-02},
 318     {2.657e-02, 2.637e-02, 2.580e-02, 2.525e-02, 2.492e-02, 2.441e-02, 2.446e-02, 2.441e-02, 2.478e-02, 2.491e-02},
 319     {2.640e-02, 2.608e-02, 2.583e-02, 2.539e-02, 2.478e-02, 2.440e-02, 2.456e-02, 2.464e-02, 2.486e-02, 2.533e-02},
 320     {2.636e-02, 2.630e-02, 2.584e-02, 2.542e-02, 2.483e-02, 2.451e-02, 2.449e-02, 2.467e-02, 2.496e-02, 2.554e-02},
 321     {2.634e-02, 2.629e-02, 2.583e-02, 2.526e-02, 2.480e-02, 2.460e-02, 2.458e-02, 2.472e-02, 2.518e-02, 2.549e-02},
 322     {2.629e-02, 2.621e-02, 2.581e-02, 2.527e-02, 2.480e-02, 2.458e-02, 2.451e-02, 2.485e-02, 2.516e-02, 2.547e-02},
 323     {2.629e-02, 2.607e-02, 2.573e-02, 2.543e-02, 2.485e-02, 2.464e-02, 2.452e-02, 2.476e-02, 2.505e-02, 2.550e-02},
 324     {2.635e-02, 2.613e-02, 2.578e-02, 2.523e-02, 2.491e-02, 2.465e-02, 2.470e-02, 2.467e-02, 2.515e-02, 2.564e-02},
 325     {2.613e-02, 2.602e-02, 2.587e-02, 2.526e-02, 2.507e-02, 2.482e-02, 2.456e-02, 2.486e-02, 2.509e-02, 2.572e-02},
 326     {2.620e-02, 2.599e-02, 2.563e-02, 2.528e-02, 2.484e-02, 2.462e-02, 2.464e-02, 2.476e-02, 2.513e-02, 2.571e-02},
 327     {2.634e-02, 2.596e-02, 2.565e-02, 2.519e-02, 2.497e-02, 2.457e-02, 2.450e-02, 2.481e-02, 2.511e-02, 2.540e-02},
 328     {2.593e-02, 2.589e-02, 2.563e-02, 2.511e-02, 2.472e-02, 2.453e-02, 2.452e-02, 2.474e-02, 2.501e-02, 2.543e-02},
 329     {2.576e-02, 2.582e-02, 2.526e-02, 2.505e-02, 2.462e-02, 2.446e-02, 2.445e-02, 2.466e-02, 2.486e-02, 2.510e-02},
 330     {2.571e-02, 2.549e-02, 2.533e-02, 2.501e-02, 2.453e-02, 2.443e-02, 2.445e-02, 2.450e-02, 2.448e-02, 2.469e-02},
 331     {2.812e-02, 2.786e-02, 2.776e-02, 2.723e-02, 2.695e-02, 2.650e-02, 2.642e-02, 2.617e-02, 2.612e-02, 2.610e-02},
 332     {3.251e-02, 3.267e-02, 3.223e-02, 3.183e-02, 3.125e-02, 3.106e-02, 3.067e-02, 3.010e-02, 2.936e-02, 2.927e-02}
 333   };
 334   if(z>=0. && z<.25) return sy[tb][Int_t(z/.025)];
 335
 336   Double_t m = 1.e-8; for(Int_t id=10; id--;) if(sy[tb][id]>m) m=sy[tb][id];
 337
 338   return m;
 339 }
 340
 341 //___________________________________________________________________________
 342 Double_t AliTRDcluster::GetXcorr(Int_t tb, Double_t z)
 343 {
 344   // drift length correction [cm]
 345   // TODO to be parametrized in term of drift velocity
 346   // A.Bercuci (Mar 28 2009)
 347
 348   if(tb<0 || tb>=24) return 0.;
 349   const Int_t nd = 5;
 350   const Double_t dx[24][nd]={
 351     {+1.747e-01,+3.195e-01,+1.641e-01,+1.607e-01,+6.002e-01},
 352     {+5.468e-02,+5.760e-02,+6.365e-02,+8.003e-02,+1.067e-01},
 353     {-6.327e-02,-6.339e-02,-6.423e-02,-6.900e-02,-7.949e-02},
 354     {-1.417e-01,-1.424e-01,-1.450e-01,-1.465e-01,-1.514e-01},
 355     {-1.637e-01,-1.619e-01,-1.622e-01,-1.613e-01,-1.648e-01},
 356     {-1.386e-01,-1.334e-01,-1.261e-01,-1.276e-01,-1.314e-01},
 357     {-8.799e-02,-8.299e-02,-7.861e-02,-8.038e-02,-8.436e-02},
 358     {-5.139e-02,-4.849e-02,-4.641e-02,-4.965e-02,-5.286e-02},
 359     {-2.927e-02,-2.773e-02,-2.807e-02,-3.021e-02,-3.378e-02},
 360     {-1.380e-02,-1.229e-02,-1.335e-02,-1.547e-02,-1.984e-02},
 361     {-4.168e-03,-4.601e-03,-5.462e-03,-8.164e-03,-1.035e-02},
 362     {+2.044e-03,+1.889e-03,+9.603e-04,-1.342e-03,-3.736e-03},
 363     {+3.568e-03,+3.581e-03,+2.391e-03,+2.942e-05,-1.585e-03},
 364     {+4.403e-03,+4.571e-03,+3.509e-03,+8.703e-04,-1.425e-03},
 365     {+4.941e-03,+4.808e-03,+3.284e-03,+1.105e-03,-1.208e-03},
 366     {+5.124e-03,+5.022e-03,+4.305e-03,+2.023e-03,-1.145e-03},
 367     {+4.882e-03,+4.008e-03,+3.408e-03,+7.886e-04,-1.356e-03},
 368     {+3.852e-03,+3.539e-03,+2.057e-03,+1.670e-04,-1.993e-03},
 369     {+2.154e-03,+2.111e-03,+5.723e-04,-1.254e-03,-3.256e-03},
 370     {+1.755e-03,+2.101e-03,+9.516e-04,-1.649e-03,-3.394e-03},
 371     {+1.617e-03,+1.662e-03,+4.169e-04,-9.843e-04,-4.309e-03},
 372     {-9.204e-03,-9.069e-03,-1.182e-02,-1.458e-02,-1.880e-02},
 373     {-6.727e-02,-6.820e-02,-6.804e-02,-7.134e-02,-7.615e-02},
 374     {-1.802e-01,-1.733e-01,-1.633e-01,-1.601e-01,-1.632e-01}
 375   };
 376 //   const Double_t dx[24][nd]={
 377 //     {+0.000e+00,+0.000e+00,+0.000e+00,+0.000e+00,+0.000e+00,+0.000e+00,+0.000e+00,+0.000e+00,+0.000e+00,+0.000e+00},
 378 //     {-2.763e-04,-2.380e-04,-6.286e-04,-9.424e-04,+1.046e-03,+1.932e-03,+1.620e-03,+1.951e-03,-1.321e-03,-1.115e-03},
 379 //     {-1.825e-03,-9.245e-04,-1.012e-03,-8.215e-04,+2.703e-05,+1.403e-03,+2.340e-03,+2.577e-03,+2.017e-03,+8.006e-04},
 380 //     {-3.070e-03,-8.563e-04,-1.257e-03,+8.491e-05,+4.503e-04,-2.467e-05,-1.793e-04,+5.085e-04,+1.321e-03,+4.056e-04},
 381 //     {-3.637e-03,-2.857e-03,-3.098e-03,-2.304e-03,-1.467e-03,-1.755e-03,+4.585e-04,+2.757e-03,+3.184e-03,+3.525e-03},
 382 //     {-9.884e-03,-7.695e-03,-7.290e-03,-3.990e-03,-9.982e-04,+2.226e-03,+3.375e-03,+6.419e-03,+7.209e-03,+6.891e-03},
 383 //     {-6.844e-03,-5.807e-03,-4.012e-03,-1.566e-03,+5.035e-04,+2.024e-03,+3.225e-03,+3.918e-03,+5.942e-03,+6.024e-03},
 384 //     {-2.628e-03,-2.201e-03,-4.562e-04,+9.832e-04,+3.411e-03,+2.062e-03,+1.526e-03,+9.350e-04,+8.842e-04,+1.007e-03},
 385 //     {+6.603e-04,+1.545e-03,+1.681e-03,+1.918e-03,+2.165e-03,+1.825e-03,+1.691e-03,-1.923e-04,+1.835e-04,-1.284e-03},
 386 //     {+1.895e-03,+1.586e-03,+2.000e-03,+3.537e-03,+2.526e-03,+1.316e-03,+8.229e-04,-7.671e-05,-2.175e-03,-3.528e-03},
 387 //     {+2.927e-03,+3.369e-03,+3.603e-03,+2.675e-03,+2.737e-03,+1.133e-03,+4.318e-04,-1.215e-03,-2.443e-03,-3.116e-03},
 388 //     {+3.072e-03,+3.564e-03,+3.612e-03,+3.149e-03,+2.768e-03,+1.186e-03,+3.083e-04,-1.447e-03,-2.480e-03,-3.263e-03},
 389 //     {+2.697e-03,+3.565e-03,+3.759e-03,+2.855e-03,+2.909e-03,+6.564e-04,-5.224e-04,-3.309e-04,-1.636e-03,-3.739e-03},
 390 //     {+3.633e-03,+3.232e-03,+3.727e-03,+3.024e-03,+3.365e-03,+1.598e-03,-6.903e-04,-1.039e-03,-3.176e-03,-4.472e-03},
 391 //     {+2.999e-03,+3.942e-03,+3.322e-03,+3.162e-03,+1.978e-03,+1.657e-03,-4.760e-04,-8.343e-04,-2.346e-03,-3.281e-03},
 392 //     {+3.734e-03,+3.098e-03,+3.435e-03,+2.512e-03,+2.651e-03,+1.745e-03,+9.424e-04,-1.404e-03,-3.177e-03,-4.444e-03},
 393 //     {+3.204e-03,+4.003e-03,+3.068e-03,+2.697e-03,+3.187e-03,+3.878e-04,-1.124e-04,-1.855e-03,-2.584e-03,-3.807e-03},
 394 //     {+2.653e-03,+3.631e-03,+2.327e-03,+3.460e-03,+1.810e-03,+1.244e-03,-3.651e-04,-2.664e-04,-2.307e-03,-3.642e-03},
 395 //     {+2.538e-03,+3.208e-03,+2.390e-03,+3.519e-03,+1.763e-03,+1.330e-04,+1.669e-04,-1.422e-03,-1.685e-03,-3.519e-03},
 396 //     {+2.605e-03,+2.465e-03,+2.771e-03,+2.966e-03,+2.361e-03,+6.029e-04,-4.435e-04,-1.876e-03,-1.694e-03,-3.757e-03},
 397 //     {+2.866e-03,+3.315e-03,+3.146e-03,+2.117e-03,+1.933e-03,+9.339e-04,+9.556e-04,-1.314e-03,-3.615e-03,-3.558e-03},
 398 //     {+4.002e-03,+3.543e-03,+3.631e-03,+4.127e-03,+1.919e-03,-2.852e-04,-9.484e-04,-2.060e-03,-4.477e-03,-5.491e-03},
 399 //     {+6.029e-03,+5.147e-03,+4.286e-03,+2.215e-03,+9.240e-04,-1.554e-03,-2.366e-03,-3.635e-03,-5.372e-03,-6.467e-03},
 400 //     {+3.941e-03,+3.995e-03,+5.638e-04,-3.332e-04,-2.539e-03,-3.764e-03,-3.647e-03,-4.900e-03,-5.414e-03,-5.202e-03}
 401 //   };
 402   if(z>=0. && z<.25) return dx[tb][Int_t(z/.025)];
 403
 404   Double_t m = 0.; for(Int_t id=nd; id--;) m+=dx[tb][id];
 405   return m/nd;
 406 }
 407
 408 //___________________________________________________________________________
 409 Double_t AliTRDcluster::GetYcorr(Int_t ly, Float_t y)
 410 {
 411 // PRF correction TODO to be replaced by the gaussian
 412 // approximation with full error parametrization
 413   const Float_t cy[AliTRDgeometry::kNlayer][3] = {
 414     { 4.014e-04, 8.605e-03, -6.880e+00},
 415     {-3.061e-04, 9.663e-03, -6.789e+00},
 416     { 1.124e-03, 1.105e-02, -6.825e+00},
 417     {-1.527e-03, 1.231e-02, -6.777e+00},
 418     { 2.150e-03, 1.387e-02, -6.783e+00},
 419     {-1.296e-03, 1.486e-02, -6.825e+00}
 420   };
 421
 422   return cy[ly][0] + cy[ly][1] * TMath::Sin(cy[ly][2] * y);
 423 }
 424
 425 //_____________________________________________________________________________
 426 Float_t AliTRDcluster::GetXloc(Double_t t0, Double_t vd, Double_t *const /*q*/, Double_t *const /*xq*/, Double_t /*z*/)
 427 {
 428 //
 429 // (Re)Calculate cluster position in the x direction in local chamber coordinates (with respect to the anode wire
 430 // position) using all available information from tracking.
 431 // Input parameters:
 432 //   t0 - calibration aware trigger delay [us]
 433 //   vd - drift velocity in the region of the cluster [cm/us]
 434 //   z  - distance to the anode wire [cm]. By default 0.2 !!
 435 //   q & xq - array of charges and cluster positions from previous clusters in the tracklet [a.u.]
 436 // Output values :
 437 //   return x position of the cluster with respect to the
 438 //   anode wire using all tracking information
 439 //
 440 // The estimation of the radial position is based on calculating the drift time and the drift velocity at the point of
 441 // estimation. The drift time can be estimated according to the expression:
 442 // BEGIN_LATEX
 443 // t_{drift} = t_{bin} - t_{0} - t_{cause}(x) - t_{TC}(q_{i-1}, q_{i-2}, ...)
 444 // END_LATEX
 445 // where t_0 is the delay of the trigger signal. t_cause is the causality delay between ionisation electrons hitting
 446 // the anode and the registration of maximum signal by the electronics - it is due to the rising time of the TRF
 447 // convoluted with the diffusion width. t_TC is the residual charge from previous bins due to residual tails after tail
 448 // cancellation.
 449 //
 450 // The drift velocity is considered to vary linearly with the drift length (independent of the distance to the anode wire
 451 // in the z direction). Thus one can write the calculate iteratively the drift length from the expression:
 452 // BEGIN_LATEX
 453 // x = t_{drift}(x)*v_{drfit}(x)
 454 // END_LATEX
 455 //
 456 // Authors
 457 // Alex Bercuci <A.Bercuci@gsi.de>
 458 //
 459
 460   AliTRDCommonParam *cp = AliTRDCommonParam::Instance();
 461   Double_t fFreq = cp->GetSamplingFrequency();
 462
 463   // calculate t0 corrected time bin
 464   Double_t td = fPadTime - t0;
 465   fLocalTimeBin = TMath::Nint(td);
 466   //drift time corresponding to the center of the time bin
 467   td = (td + .5)/fFreq; // [us]
 468   // correction for t0
 469   td -= t0;
 470   // calculate radial posion of clusters in the drift region
 471   if(td < .2) return 0.;
 472   // TRF rising time (fitted)
 473   // It should be absorbed by the t0. For the moment t0 is 0 for simulations.
 474   // A.Bercuci (Mar 26 2009)
 475   td -= 0.189;
 476
 477   // apply fitted correction
 478   Float_t x = td*vd + GetXcorr(fLocalTimeBin);
 479   if(x>0.&&x<.5*AliTRDgeometry::CamHght()+AliTRDgeometry::CdrHght()) SetInChamber();
 480
 481   return x;
 482
 483 /*
 484   // invert drift time function
 485   Double_t xM= AliTRDgeometry::CamHght()+AliTRDgeometry::CdrHght(),
 486            x = vd*td + .5*AliTRDgeometry::CamHght(),
 487            t = cp->TimeStruct(vd, x, z), dx1=0.,dx2;
 488   while(TMath::Abs(td-t)>1.e-4){ // convergence on 100ps
 489     dx2 = vd*(td-t);
 490     if(TMath::Abs(TMath::Abs(dx2)-TMath::Abs(dx1))<1.e-6){
 491       x+=.5*dx2;
 492       break;
 493     } else x+=dx2;
 494
 495     if(x<0. || x>xM) return 0.;
 496     t = cp->TimeStruct(vd, x, z);
 497     dx1 = dx2;
 498   }
 499
 500   return x-.5*AliTRDgeometry::CamHght();
 501 */
 502 }
 503
 504 //_____________________________________________________________________________
 505 Float_t AliTRDcluster::GetYloc(Double_t y0, Double_t s2, Double_t W, Double_t *const y1, Double_t *const y2)
 506 {
 507
 508   //printf("  s[%3d %3d %3d] w[%f %f] yr[%f %f]\n", fSignals[2], fSignals[3], fSignals[4], w1/(w1+w2), w2/(w1+w2), y1r*W, y2r*W);
 509   if(IsRPhiMethod(kCOG)) GetDYcog();
 510   else if(IsRPhiMethod(kLUT)) GetDYlut();
 511   if(IsRPhiMethod(kGAUS)) GetDYgauss(s2/W/W, y1, y2);
 512
 513   if(y1) (*y1)*=W;
 514   if(y2) (*y2)*=W;
 515
 516   return y0+fCenter*W;
 517 }
 518
 519 //_____________________________________________________________________________
 520 Bool_t AliTRDcluster::IsEqual(const TObject *o) const
 521 {
 522   //
 523   // Compare relevant information of this cluster with another one
 524   //
 525
 526   const AliTRDcluster *inCluster = dynamic_cast<const AliTRDcluster*>(o);
 527   if (!o || !inCluster) return kFALSE;
 528
 529   if ( AliCluster::GetX() != inCluster->GetX() ) return kFALSE;
 530   if ( AliCluster::GetY() != inCluster->GetY() ) return kFALSE;
 531   if ( AliCluster::GetZ() != inCluster->GetZ() ) return kFALSE;
 532   if ( fQ != inCluster->fQ ) return kFALSE;
 533   if ( fDetector != inCluster->fDetector ) return kFALSE;
 534   if ( fPadCol != inCluster->fPadCol ) return kFALSE;
 535   if ( fPadRow != inCluster->fPadRow ) return kFALSE;
 536   if ( fPadTime != inCluster->fPadTime ) return kFALSE;
 537   if ( fClusterMasking != inCluster->fClusterMasking ) return kFALSE;
 538   if ( IsInChamber() != inCluster->IsInChamber() ) return kFALSE;
 539   if ( IsShared() != inCluster->IsShared() ) return kFALSE;
 540   if ( IsUsed() != inCluster->IsUsed() ) return kFALSE;
 541
 542   return kTRUE;
 543 }
 544
 545 //_____________________________________________________________________________
 546 void AliTRDcluster::Print(Option_t *o) const
 547 {
 548   AliInfo(Form("Det[%3d] LTrC[%+6.2f %+6.2f %+6.2f] Q[%5.1f] FLAG[in(%c) use(%c) sh(%c)] Y[%s]",
 549     fDetector, GetX(), GetY(), GetZ(), fQ,
 550     IsInChamber() ? 'y' : 'n',
 551     IsUsed() ? 'y' : 'n',
 552     IsShared() ? 'y' : 'n',
 553     IsRPhiMethod(kGAUS)?"GAUS":(IsRPhiMethod(kLUT)?"LUT":"COG")
 554   ));
 555
 556   if(strcmp(o, "a")!=0) return;
 557   AliInfo(Form("LChC[c(%3d) r(%2d) t(%2d)] t-t0[%2d] Npad[%d] cen[%5.3f] mask[%d]", fPadCol, fPadRow, fPadTime, fLocalTimeBin, fNPads, fCenter, fClusterMasking));
 558   AliInfo(Form("Signals[%3d %3d %3d %3d %3d %3d %3d]", fSignals[0], fSignals[1], fSignals[2], fSignals[3], fSignals[4], fSignals[5], fSignals[6]));
 559 }
 560
 561
 562 //_____________________________________________________________________________
 563 void AliTRDcluster::SetPadMaskedPosition(UChar_t position)
 564 {
 565   //
 566   // store the pad corruption position code
 567   //
 568   // Code: 1 = left cluster
 569   //       2 = middle cluster;
 570   //       4 = right cluster
 571   //
 572   for(Int_t ipos = 0; ipos < 3; ipos++)
 573     if(TESTBIT(position, ipos))
 574       SETBIT(fClusterMasking, ipos);
 575 }
 576
 577 //_____________________________________________________________________________
 578 void AliTRDcluster::SetPadMaskedStatus(UChar_t status)
 579 {
 580   //
 581   // store the status of the corrupted pad
 582   //
 583   // Code: 2 = noisy
 584   //       4 = Bridged Left
 585   //       8 = Bridged Right
 586   //      32 = Not Connected
 587   for(Int_t ipos = 0; ipos < 5; ipos++)
 588     if(TESTBIT(status, ipos))
 589       SETBIT(fClusterMasking, ipos + 3);
 590 }
 591
 592 //___________________________________________________________________________
 593 Float_t AliTRDcluster::GetDYcog(Double_t *const, Double_t *const)
 594 {
 595 //
 596 // Get COG position
 597 // Used for clusters with more than 3 pads - where LUT not applicable
 598 //
 599
 600   Double_t sum = fSignals[1]
 601                 +fSignals[2]
 602                 +fSignals[3]
 603                 +fSignals[4]
 604                 +fSignals[5];
 605
 606   // ???????????? CBL
 607   // Go to 3 pad COG ????
 608   // ???????????? CBL
 609   fCenter = (0.0 * (-fSignals[1] + fSignals[5])
 610                       + (-fSignals[2] + fSignals[4])) / sum;
 611
 612   return fCenter;
 613 }
 614
 615 //___________________________________________________________________________
 616 Float_t AliTRDcluster::GetDYlut(Double_t *const, Double_t *const)
 617 {
 618   //
 619   // Calculates the cluster position using the lookup table.
 620   // Method provided by Bogdan Vulpescu.
 621   //
 622
 623   if(!fgLUT) FillLUT();
 624
 625   Double_t ampL = fSignals[2],
 626            ampC = fSignals[3],
 627            ampR = fSignals[4];
 628   Int_t ilayer = AliTRDgeometry::GetLayer(fDetector);
 629
 630   Double_t x    = 0.0;
 631   Double_t xmin, xmax, xwid;
 632
 633   Int_t    side = 0;
 634   Int_t    ix;
 635
 636   Double_t xMin[AliTRDgeometry::kNlayer] = {
 637     0.006492, 0.006377, 0.006258, 0.006144, 0.006030, 0.005980
 638   };
 639   Double_t xMax[AliTRDgeometry::kNlayer] = {
 640     0.960351, 0.965870, 0.970445, 0.974352, 0.977667, 0.996101
 641   };
 642
 643   if      (ampL > ampR) {
 644     x    = (ampL - ampR) / ampC;
 645     side = -1;
 646   }
 647   else if (ampL < ampR) {
 648     x    = (ampR - ampL) / ampC;
 649     side = +1;
 650   }
 651
 652   if (ampL != ampR) {
 653
 654     xmin = xMin[ilayer] + 0.000005;
 655     xmax = xMax[ilayer] - 0.000005;
 656     xwid = (xmax - xmin) / 127.0;
 657
 658     if      (x < xmin) fCenter = 0.0000;
 659     else if (x > xmax) fCenter = side * 0.5000;
 660     else {
 661       ix      = (Int_t) ((x - xmin) / xwid);
 662       fCenter = side * fgLUT[ilayer*fgkNlut+ix];
 663     }
 664   } else fCenter = 0.0;
 665
 666   return fCenter;
 667 }
 668
 669 //___________________________________________________________________________
 670 Float_t AliTRDcluster::GetDYgauss(Double_t s2w, Double_t *const y1, Double_t *const y2)
 671 {
 672 //
 673 // (Re)Calculate cluster position in the y direction in local chamber coordinates using all available information from tracking.
 674 //
 675 // Input parameters:
 676 //   s2 - sigma of gaussian parameterization (see bellow for the exact parameterization)
 677 //   W  - pad width
 678 //   xd - drift length (with respect to the anode wire) [cm]
 679 //   wt - omega*tau = tg(a_L)
 680 // Output values :
 681 //   y1 and y2 - partial positions based on 2 pads clusters
 682 //   return y position of the cluster from all information
 683 //
 684 // Estimation of y coordinate is based on the gaussian approximation of the PRF. Thus one may
 685 // calculate the y position knowing the signals q_i-1, q_i and q_i+1 in the 3 adiacent pads by:
 686 // BEGIN_LATEX
 687 // y = #frac{1}{w_{1}+w_{2}}#[]{w_{1}#(){y_{0}-#frac{W}{2}+#frac{s^{2}}{W}ln#frac{q_{i}}{q_{i-1}}}+w_{2}#(){y_{0}+ #frac{W}{2}+#frac{s^{2}}{W}ln#frac{q_{i+1}}{q_{i}}}}
 688 // END_LATEX
 689 // where W is the pad width, y_0 is the position of the center pad and s^2 is given by
 690 // BEGIN_LATEX
 691 // s^{2} = s^{2}_{0} + s^{2}_{diff} (x,B) + #frac{tg^{2}(#phi-#alpha_{L})*l^{2}}{12}
 692 // END_LATEX
 693 // with s_0 being the PRF for 0 drift and track incidence phi equal to the lorentz angle a_L and the diffusion term
 694 // being described by:
 695 // BEGIN_LATEX
 696 // s_{diff} (x,B) = #frac{D_{L}#sqrt{x}}{1+#(){#omega#tau}^{2}}
 697 // END_LATEX
 698 // with x being the drift length. The weights w_1 and w_2 are taken to be q_i-1^2 and q_i+1^2 respectively
 699 //
 700 // Authors
 701 // Alex Bercuci <A.Bercuci@gsi.de>
 702 // Theodor Rascanu <trascanu@stud.uni-frankfurt.de>
 703 //
 704   Double_t w1  = fSignals[2]*fSignals[2];
 705   Double_t w2  = fSignals[4]*fSignals[4];
 706   //Double_t s2w = s2/W/W;
 707   Float_t y1r  = fSignals[2]>0 ? (-0.5 + s2w*TMath::Log(fSignals[3]/(Float_t)fSignals[2])) : 0.;
 708   Float_t y2r  = fSignals[4]>0 ? (0.5 + s2w*TMath::Log(fSignals[4]/(Float_t)fSignals[3])) : 0.;
 709
 710   if(y1) (*y1) = y1r;
 711   if(y2) (*y2) = y2r;
 712
 713   return fCenter      = (w1*y1r+w2*y2r)/(w1+w2);
 714 }
 715
 716
 717
 718 //_____________________________________________________________________________
 719 void AliTRDcluster::FillLUT()
 720 {
 721   //
 722   // Create the LUT
 723   //
 724
 725   // The lookup table from Bogdan
 726   Float_t lut[AliTRDgeometry::kNlayer][fgkNlut] = {
 727     {
 728       0.0070, 0.0150, 0.0224, 0.0298, 0.0374, 0.0454, 0.0533, 0.0611,
 729       0.0684, 0.0755, 0.0827, 0.0900, 0.0975, 0.1049, 0.1120, 0.1187,
 730       0.1253, 0.1318, 0.1385, 0.1453, 0.1519, 0.1584, 0.1646, 0.1704,
 731       0.1762, 0.1821, 0.1879, 0.1938, 0.1996, 0.2053, 0.2108, 0.2160,
 732       0.2210, 0.2260, 0.2310, 0.2361, 0.2411, 0.2461, 0.2509, 0.2557,
 733       0.2602, 0.2646, 0.2689, 0.2732, 0.2774, 0.2816, 0.2859, 0.2901,
 734       0.2942, 0.2983, 0.3022, 0.3061, 0.3099, 0.3136, 0.3172, 0.3207,
 735       0.3242, 0.3278, 0.3312, 0.3347, 0.3382, 0.3416, 0.3450, 0.3483,
 736       0.3515, 0.3547, 0.3579, 0.3609, 0.3639, 0.3669, 0.3698, 0.3727,
 737       0.3756, 0.3785, 0.3813, 0.3842, 0.3870, 0.3898, 0.3926, 0.3952,
 738       0.3979, 0.4005, 0.4032, 0.4057, 0.4082, 0.4108, 0.4132, 0.4157,
 739       0.4181, 0.4205, 0.4228, 0.4252, 0.4275, 0.4299, 0.4322, 0.4345,
 740       0.4367, 0.4390, 0.4412, 0.4434, 0.4456, 0.4478, 0.4499, 0.4520,
 741       0.4541, 0.4562, 0.4583, 0.4603, 0.4623, 0.4643, 0.4663, 0.4683,
 742       0.4702, 0.4722, 0.4741, 0.4758, 0.4774, 0.4790, 0.4805, 0.4824,
 743       0.4844, 0.4863, 0.4883, 0.4902, 0.4921, 0.4940, 0.4959, 0.4978
 744     },
 745     {
 746       0.0072, 0.0156, 0.0235, 0.0313, 0.0394, 0.0478, 0.0561, 0.0642,
 747       0.0718, 0.0792, 0.0868, 0.0947, 0.1025, 0.1101, 0.1172, 0.1241,
 748       0.1309, 0.1378, 0.1449, 0.1518, 0.1586, 0.1650, 0.1710, 0.1770,
 749       0.1830, 0.1891, 0.1952, 0.2011, 0.2070, 0.2125, 0.2177, 0.2229,
 750       0.2280, 0.2332, 0.2383, 0.2435, 0.2484, 0.2533, 0.2581, 0.2627,
 751       0.2670, 0.2714, 0.2757, 0.2799, 0.2842, 0.2884, 0.2927, 0.2968,
 752       0.3008, 0.3048, 0.3086, 0.3123, 0.3159, 0.3195, 0.3231, 0.3266,
 753       0.3301, 0.3335, 0.3370, 0.3404, 0.3438, 0.3471, 0.3504, 0.3536,
 754       0.3567, 0.3598, 0.3628, 0.3657, 0.3686, 0.3715, 0.3744, 0.3772,
 755       0.3800, 0.3828, 0.3856, 0.3884, 0.3911, 0.3938, 0.3965, 0.3991,
 756       0.4016, 0.4042, 0.4067, 0.4092, 0.4116, 0.4140, 0.4164, 0.4187,
 757       0.4211, 0.4234, 0.4257, 0.4280, 0.4302, 0.4325, 0.4347, 0.4369,
 758       0.4391, 0.4413, 0.4434, 0.4456, 0.4477, 0.4497, 0.4518, 0.4538,
 759       0.4558, 0.4578, 0.4598, 0.4618, 0.4637, 0.4656, 0.4675, 0.4694,
 760       0.4713, 0.4732, 0.4750, 0.4766, 0.4781, 0.4797, 0.4813, 0.4832,
 761       0.4851, 0.4870, 0.4888, 0.4906, 0.4925, 0.4942, 0.4960, 0.4978
 762     },
 763     {
 764       0.0075, 0.0163, 0.0246, 0.0328, 0.0415, 0.0504, 0.0592, 0.0674,
 765       0.0753, 0.0832, 0.0914, 0.0996, 0.1077, 0.1154, 0.1225, 0.1296,
 766       0.1369, 0.1442, 0.1515, 0.1585, 0.1652, 0.1714, 0.1776, 0.1839,
 767       0.1902, 0.1965, 0.2025, 0.2085, 0.2141, 0.2194, 0.2247, 0.2299,
 768       0.2352, 0.2405, 0.2457, 0.2507, 0.2557, 0.2604, 0.2649, 0.2693,
 769       0.2737, 0.2780, 0.2823, 0.2867, 0.2909, 0.2951, 0.2992, 0.3033,
 770       0.3072, 0.3110, 0.3146, 0.3182, 0.3218, 0.3253, 0.3288, 0.3323,
 771       0.3357, 0.3392, 0.3426, 0.3459, 0.3492, 0.3524, 0.3555, 0.3586,
 772       0.3616, 0.3645, 0.3674, 0.3703, 0.3731, 0.3759, 0.3787, 0.3815,
 773       0.3843, 0.3870, 0.3897, 0.3925, 0.3950, 0.3976, 0.4002, 0.4027,
 774       0.4052, 0.4076, 0.4101, 0.4124, 0.4148, 0.4171, 0.4194, 0.4217,
 775       0.4239, 0.4262, 0.4284, 0.4306, 0.4328, 0.4350, 0.4371, 0.4393,
 776       0.4414, 0.4435, 0.4455, 0.4476, 0.4496, 0.4516, 0.4536, 0.4555,
 777       0.4575, 0.4594, 0.4613, 0.4632, 0.4650, 0.4669, 0.4687, 0.4705,
 778       0.4723, 0.4741, 0.4758, 0.4773, 0.4789, 0.4804, 0.4821, 0.4839,
 779       0.4857, 0.4875, 0.4893, 0.4910, 0.4928, 0.4945, 0.4961, 0.4978
 780     },
 781     {
 782       0.0078, 0.0171, 0.0258, 0.0345, 0.0438, 0.0532, 0.0624, 0.0708,
 783       0.0791, 0.0875, 0.0962, 0.1048, 0.1130, 0.1206, 0.1281, 0.1356,
 784       0.1432, 0.1508, 0.1582, 0.1651, 0.1716, 0.1780, 0.1845, 0.1910,
 785       0.1975, 0.2038, 0.2099, 0.2155, 0.2210, 0.2263, 0.2317, 0.2371,
 786       0.2425, 0.2477, 0.2528, 0.2578, 0.2626, 0.2671, 0.2715, 0.2759,
 787       0.2803, 0.2846, 0.2890, 0.2933, 0.2975, 0.3016, 0.3056, 0.3095,
 788       0.3132, 0.3168, 0.3204, 0.3239, 0.3274, 0.3309, 0.3344, 0.3378,
 789       0.3412, 0.3446, 0.3479, 0.3511, 0.3543, 0.3574, 0.3603, 0.3633,
 790       0.3662, 0.3690, 0.3718, 0.3747, 0.3774, 0.3802, 0.3829, 0.3857,
 791       0.3883, 0.3910, 0.3936, 0.3962, 0.3987, 0.4012, 0.4037, 0.4061,
 792       0.4085, 0.4109, 0.4132, 0.4155, 0.4177, 0.4200, 0.4222, 0.4244,
 793       0.4266, 0.4288, 0.4309, 0.4331, 0.4352, 0.4373, 0.4394, 0.4414,
 794       0.4435, 0.4455, 0.4475, 0.4494, 0.4514, 0.4533, 0.4552, 0.4571,
 795       0.4590, 0.4608, 0.4626, 0.4645, 0.4662, 0.4680, 0.4698, 0.4715,
 796       0.4733, 0.4750, 0.4766, 0.4781, 0.4796, 0.4812, 0.4829, 0.4846,
 797       0.4863, 0.4880, 0.4897, 0.4914, 0.4930, 0.4946, 0.4963, 0.4979
 798     },
 799     {
 800       0.0081, 0.0178, 0.0270, 0.0364, 0.0463, 0.0562, 0.0656, 0.0744,
 801       0.0831, 0.0921, 0.1013, 0.1102, 0.1183, 0.1261, 0.1339, 0.1419,
 802       0.1499, 0.1576, 0.1648, 0.1715, 0.1782, 0.1849, 0.1917, 0.1984,
 803       0.2048, 0.2110, 0.2167, 0.2223, 0.2278, 0.2333, 0.2389, 0.2444,
 804       0.2497, 0.2548, 0.2598, 0.2645, 0.2691, 0.2735, 0.2780, 0.2824,
 805       0.2868, 0.2912, 0.2955, 0.2997, 0.3038, 0.3078, 0.3116, 0.3152,
 806       0.3188, 0.3224, 0.3259, 0.3294, 0.3329, 0.3364, 0.3398, 0.3432,
 807       0.3465, 0.3497, 0.3529, 0.3561, 0.3591, 0.3620, 0.3649, 0.3677,
 808       0.3705, 0.3733, 0.3761, 0.3788, 0.3816, 0.3843, 0.3869, 0.3896,
 809       0.3922, 0.3948, 0.3973, 0.3998, 0.4022, 0.4047, 0.4070, 0.4094,
 810       0.4117, 0.4139, 0.4162, 0.4184, 0.4206, 0.4227, 0.4249, 0.4270,
 811       0.4291, 0.4313, 0.4334, 0.4354, 0.4375, 0.4395, 0.4415, 0.4435,
 812       0.4455, 0.4474, 0.4493, 0.4512, 0.4531, 0.4550, 0.4568, 0.4586,
 813       0.4604, 0.4622, 0.4639, 0.4657, 0.4674, 0.4691, 0.4708, 0.4725,
 814       0.4742, 0.4758, 0.4773, 0.4788, 0.4803, 0.4819, 0.4836, 0.4852,
 815       0.4869, 0.4885, 0.4901, 0.4917, 0.4933, 0.4948, 0.4964, 0.4979
 816     },
 817     {
 818       0.0085, 0.0189, 0.0288, 0.0389, 0.0497, 0.0603, 0.0699, 0.0792,
 819       0.0887, 0.0985, 0.1082, 0.1170, 0.1253, 0.1336, 0.1421, 0.1505,
 820       0.1587, 0.1662, 0.1733, 0.1803, 0.1874, 0.1945, 0.2014, 0.2081,
 821       0.2143, 0.2201, 0.2259, 0.2316, 0.2374, 0.2431, 0.2487, 0.2541,
 822       0.2593, 0.2642, 0.2689, 0.2735, 0.2781, 0.2826, 0.2872, 0.2917,
 823       0.2961, 0.3003, 0.3045, 0.3086, 0.3125, 0.3162, 0.3198, 0.3235,
 824       0.3270, 0.3306, 0.3342, 0.3377, 0.3411, 0.3446, 0.3479, 0.3511,
 825       0.3543, 0.3575, 0.3605, 0.3634, 0.3663, 0.3691, 0.3720, 0.3748,
 826       0.3775, 0.3803, 0.3830, 0.3857, 0.3884, 0.3911, 0.3937, 0.3962,
 827       0.3987, 0.4012, 0.4036, 0.4060, 0.4084, 0.4107, 0.4129, 0.4152,
 828       0.4174, 0.4196, 0.4218, 0.4239, 0.4261, 0.4282, 0.4303, 0.4324,
 829       0.4344, 0.4365, 0.4385, 0.4405, 0.4425, 0.4445, 0.4464, 0.4483,
 830       0.4502, 0.4521, 0.4539, 0.4558, 0.4576, 0.4593, 0.4611, 0.4629,
 831       0.4646, 0.4663, 0.4680, 0.4697, 0.4714, 0.4730, 0.4747, 0.4759,
 832       0.4769, 0.4780, 0.4790, 0.4800, 0.4811, 0.4827, 0.4843, 0.4859,
 833       0.4874, 0.4889, 0.4905, 0.4920, 0.4935, 0.4950, 0.4965, 0.4979
 834     }
 835   };
 836
 837   if(!fgLUT) fgLUT = new Double_t[AliTRDgeometry::kNlayer*fgkNlut];
 838
 839   for (Int_t ilayer = 0; ilayer < AliTRDgeometry::kNlayer; ilayer++) {
 840     for (Int_t ilut  = 0; ilut  < fgkNlut; ilut++  ) {
 841       fgLUT[ilayer*fgkNlut+ilut] = lut[ilayer][ilut];
 842     }
 843   }
 844 }
 845