TRD/AliTRDRecParam.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 // Class containing constant reconstruction parameters                       //
  21 //                                                                           //
  22 // Request an instance with AliTRDRecParam::Instance()                       //
  23 // Then request the needed values                                            //
  24 //                                                                           //
  25 ///////////////////////////////////////////////////////////////////////////////
  26
  27 #include "AliTRDRecParam.h"
  28
  29 ClassImp(AliTRDRecParam)
  30
  31 AliTRDRecParam* AliTRDRecParam::fgInstance = 0;
  32 Bool_t AliTRDRecParam::fgTerminated = kFALSE;
  33
  34 //_ singleton implementation __________________________________________________
  35 AliTRDRecParam* AliTRDRecParam::Instance()
  36 {
  37   //
  38   // Singleton implementation
  39   // Returns an instance of this class, it is created if neccessary
  40   //
  41
  42   if (fgTerminated != kFALSE) {
  43     return 0;
  44   }
  45
  46   if (fgInstance == 0) {
  47     fgInstance = new AliTRDRecParam();
  48   }
  49
  50   return fgInstance;
  51
  52 }
  53
  54 //_____________________________________________________________________________
  55 void AliTRDRecParam::Terminate()
  56 {
  57   //
  58   // Singleton implementation
  59   // Deletes the instance of this class and sets the terminated flag,
  60   // instances cannot be requested anymore
  61   // This function can be called several times.
  62   //
  63
  64   fgTerminated = kTRUE;
  65
  66   if (fgInstance != 0) {
  67     delete fgInstance;
  68     fgInstance = 0;
  69   }
  70
  71 }
  72
  73 //_____________________________________________________________________________
  74 AliTRDRecParam::AliTRDRecParam()
  75   :TObject()
  76   ,fClusMaxThresh(0)
  77   ,fClusSigThresh(0)
  78   ,fLUTOn(kFALSE)
  79   ,fLUTbin(0)
  80   ,fLUT(0)
  81   ,fTCOn(kFALSE)
  82   ,fTCnexp(0)
  83 {
  84   //
  85   // Constructor
  86   //
  87
  88   Init();
  89
  90 }
  91
  92 //_____________________________________________________________________________
  93 AliTRDRecParam::~AliTRDRecParam()
  94 {
  95   //
  96   // Destructor
  97   //
  98
  99   if (fLUT) {
 100     delete [] fLUT;
 101     fLUT = 0;
 102   }
 103
 104 }
 105
 106 //_____________________________________________________________________________
 107 AliTRDRecParam::AliTRDRecParam(const AliTRDRecParam &p)
 108   :TObject(p)
 109   ,fClusMaxThresh(p.fClusMaxThresh)
 110   ,fClusSigThresh(p.fClusSigThresh)
 111   ,fLUTOn(p.fLUTOn)
 112   ,fLUTbin(p.fLUTbin)
 113   ,fLUT(0)
 114   ,fTCOn(p.fTCOn)
 115   ,fTCnexp(p.fTCnexp)
 116 {
 117   //
 118   // Copy constructor
 119   //
 120
 121   if (((AliTRDRecParam &) p).fLUT) {
 122     delete [] ((AliTRDRecParam &) p).fLUT;
 123   }
 124   ((AliTRDRecParam &) p).fLUT = new Float_t[fLUTbin];
 125   for (Int_t iBin = 0; iBin < fLUTbin; iBin++) {
 126     ((AliTRDRecParam &) p).fLUT[iBin] = fLUT[iBin];
 127   }
 128
 129 }
 130
 131 //_____________________________________________________________________________
 132 AliTRDRecParam &AliTRDRecParam::operator=(const AliTRDRecParam &p)
 133 {
 134   //
 135   // Assignment operator
 136   //
 137
 138   if (this != &p) {
 139     ((AliTRDRecParam &) p).Copy(*this);
 140   }
 141
 142   return *this;
 143
 144 }
 145
 146 //_____________________________________________________________________________
 147 void AliTRDRecParam::Copy(TObject &p) const
 148 {
 149   //
 150   // Copy function
 151   //
 152
 153   AliTRDRecParam* target = dynamic_cast<AliTRDRecParam*> (&p);
 154   if (!target) {
 155     return;
 156   }
 157
 158   target->fLUTOn         = fLUTOn;
 159   target->fLUTbin        = fLUTbin;
 160
 161   target->fClusMaxThresh = fClusMaxThresh;
 162   target->fClusSigThresh = fClusSigThresh;
 163
 164   target->fTCOn          = fTCOn;
 165   target->fTCnexp        = fTCnexp;
 166
 167   if (target->fLUT) {
 168     delete [] target->fLUT;
 169   }
 170   target->fLUT = new Float_t[fLUTbin];
 171   for (Int_t iBin = 0; iBin < fLUTbin; iBin++) {
 172     target->fLUT[iBin] = fLUT[iBin];
 173   }
 174
 175 }
 176
 177 //_____________________________________________________________________________
 178 void AliTRDRecParam::Init()
 179 {
 180   //
 181   // Constructor helper
 182   //
 183
 184   // The default parameter for the clustering
 185   fClusMaxThresh = 4.5;
 186   fClusSigThresh = 3.5;
 187
 188   // Use the LUT
 189   fLUTOn         = kTRUE;
 190
 191   // Create the LUT
 192   FillLUT();
 193
 194   // The tail cancelation
 195   fTCOn          = kTRUE;
 196
 197   // The number of exponentials
 198   fTCnexp        = 1;
 199
 200 }
 201
 202 //_____________________________________________________________________________
 203 void AliTRDRecParam::FillLUT()
 204 {
 205   //
 206   // Create the LUT
 207   //
 208
 209   const Int_t kNlut = 128;
 210
 211   fLUTbin = kNplan * kNlut;
 212
 213   // The lookup table from Bogdan
 214   Float_t lut[kNplan][kNlut] = {
 215     {
 216       0.0070, 0.0150, 0.0224, 0.0298, 0.0374, 0.0454, 0.0533, 0.0611,
 217       0.0684, 0.0755, 0.0827, 0.0900, 0.0975, 0.1049, 0.1120, 0.1187,
 218       0.1253, 0.1318, 0.1385, 0.1453, 0.1519, 0.1584, 0.1646, 0.1704,
 219       0.1762, 0.1821, 0.1879, 0.1938, 0.1996, 0.2053, 0.2108, 0.2160,
 220       0.2210, 0.2260, 0.2310, 0.2361, 0.2411, 0.2461, 0.2509, 0.2557,
 221       0.2602, 0.2646, 0.2689, 0.2732, 0.2774, 0.2816, 0.2859, 0.2901,
 222       0.2942, 0.2983, 0.3022, 0.3061, 0.3099, 0.3136, 0.3172, 0.3207,
 223       0.3242, 0.3278, 0.3312, 0.3347, 0.3382, 0.3416, 0.3450, 0.3483,
 224       0.3515, 0.3547, 0.3579, 0.3609, 0.3639, 0.3669, 0.3698, 0.3727,
 225       0.3756, 0.3785, 0.3813, 0.3842, 0.3870, 0.3898, 0.3926, 0.3952,
 226       0.3979, 0.4005, 0.4032, 0.4057, 0.4082, 0.4108, 0.4132, 0.4157,
 227       0.4181, 0.4205, 0.4228, 0.4252, 0.4275, 0.4299, 0.4322, 0.4345,
 228       0.4367, 0.4390, 0.4412, 0.4434, 0.4456, 0.4478, 0.4499, 0.4520,
 229       0.4541, 0.4562, 0.4583, 0.4603, 0.4623, 0.4643, 0.4663, 0.4683,
 230       0.4702, 0.4722, 0.4741, 0.4758, 0.4774, 0.4790, 0.4805, 0.4824,
 231       0.4844, 0.4863, 0.4883, 0.4902, 0.4921, 0.4940, 0.4959, 0.4978
 232     },
 233     {
 234       0.0072, 0.0156, 0.0235, 0.0313, 0.0394, 0.0478, 0.0561, 0.0642,
 235       0.0718, 0.0792, 0.0868, 0.0947, 0.1025, 0.1101, 0.1172, 0.1241,
 236       0.1309, 0.1378, 0.1449, 0.1518, 0.1586, 0.1650, 0.1710, 0.1770,
 237       0.1830, 0.1891, 0.1952, 0.2011, 0.2070, 0.2125, 0.2177, 0.2229,
 238       0.2280, 0.2332, 0.2383, 0.2435, 0.2484, 0.2533, 0.2581, 0.2627,
 239       0.2670, 0.2714, 0.2757, 0.2799, 0.2842, 0.2884, 0.2927, 0.2968,
 240       0.3008, 0.3048, 0.3086, 0.3123, 0.3159, 0.3195, 0.3231, 0.3266,
 241       0.3301, 0.3335, 0.3370, 0.3404, 0.3438, 0.3471, 0.3504, 0.3536,
 242       0.3567, 0.3598, 0.3628, 0.3657, 0.3686, 0.3715, 0.3744, 0.3772,
 243       0.3800, 0.3828, 0.3856, 0.3884, 0.3911, 0.3938, 0.3965, 0.3991,
 244       0.4016, 0.4042, 0.4067, 0.4092, 0.4116, 0.4140, 0.4164, 0.4187,
 245       0.4211, 0.4234, 0.4257, 0.4280, 0.4302, 0.4325, 0.4347, 0.4369,
 246       0.4391, 0.4413, 0.4434, 0.4456, 0.4477, 0.4497, 0.4518, 0.4538,
 247       0.4558, 0.4578, 0.4598, 0.4618, 0.4637, 0.4656, 0.4675, 0.4694,
 248       0.4713, 0.4732, 0.4750, 0.4766, 0.4781, 0.4797, 0.4813, 0.4832,
 249       0.4851, 0.4870, 0.4888, 0.4906, 0.4925, 0.4942, 0.4960, 0.4978
 250     },
 251     {
 252       0.0075, 0.0163, 0.0246, 0.0328, 0.0415, 0.0504, 0.0592, 0.0674,
 253       0.0753, 0.0832, 0.0914, 0.0996, 0.1077, 0.1154, 0.1225, 0.1296,
 254       0.1369, 0.1442, 0.1515, 0.1585, 0.1652, 0.1714, 0.1776, 0.1839,
 255       0.1902, 0.1965, 0.2025, 0.2085, 0.2141, 0.2194, 0.2247, 0.2299,
 256       0.2352, 0.2405, 0.2457, 0.2507, 0.2557, 0.2604, 0.2649, 0.2693,
 257       0.2737, 0.2780, 0.2823, 0.2867, 0.2909, 0.2951, 0.2992, 0.3033,
 258       0.3072, 0.3110, 0.3146, 0.3182, 0.3218, 0.3253, 0.3288, 0.3323,
 259       0.3357, 0.3392, 0.3426, 0.3459, 0.3492, 0.3524, 0.3555, 0.3586,
 260       0.3616, 0.3645, 0.3674, 0.3703, 0.3731, 0.3759, 0.3787, 0.3815,
 261       0.3843, 0.3870, 0.3897, 0.3925, 0.3950, 0.3976, 0.4002, 0.4027,
 262       0.4052, 0.4076, 0.4101, 0.4124, 0.4148, 0.4171, 0.4194, 0.4217,
 263       0.4239, 0.4262, 0.4284, 0.4306, 0.4328, 0.4350, 0.4371, 0.4393,
 264       0.4414, 0.4435, 0.4455, 0.4476, 0.4496, 0.4516, 0.4536, 0.4555,
 265       0.4575, 0.4594, 0.4613, 0.4632, 0.4650, 0.4669, 0.4687, 0.4705,
 266       0.4723, 0.4741, 0.4758, 0.4773, 0.4789, 0.4804, 0.4821, 0.4839,
 267       0.4857, 0.4875, 0.4893, 0.4910, 0.4928, 0.4945, 0.4961, 0.4978
 268     },
 269     {
 270       0.0078, 0.0171, 0.0258, 0.0345, 0.0438, 0.0532, 0.0624, 0.0708,
 271       0.0791, 0.0875, 0.0962, 0.1048, 0.1130, 0.1206, 0.1281, 0.1356,
 272       0.1432, 0.1508, 0.1582, 0.1651, 0.1716, 0.1780, 0.1845, 0.1910,
 273       0.1975, 0.2038, 0.2099, 0.2155, 0.2210, 0.2263, 0.2317, 0.2371,
 274       0.2425, 0.2477, 0.2528, 0.2578, 0.2626, 0.2671, 0.2715, 0.2759,
 275       0.2803, 0.2846, 0.2890, 0.2933, 0.2975, 0.3016, 0.3056, 0.3095,
 276       0.3132, 0.3168, 0.3204, 0.3239, 0.3274, 0.3309, 0.3344, 0.3378,
 277       0.3412, 0.3446, 0.3479, 0.3511, 0.3543, 0.3574, 0.3603, 0.3633,
 278       0.3662, 0.3690, 0.3718, 0.3747, 0.3774, 0.3802, 0.3829, 0.3857,
 279       0.3883, 0.3910, 0.3936, 0.3962, 0.3987, 0.4012, 0.4037, 0.4061,
 280       0.4085, 0.4109, 0.4132, 0.4155, 0.4177, 0.4200, 0.4222, 0.4244,
 281       0.4266, 0.4288, 0.4309, 0.4331, 0.4352, 0.4373, 0.4394, 0.4414,
 282       0.4435, 0.4455, 0.4475, 0.4494, 0.4514, 0.4533, 0.4552, 0.4571,
 283       0.4590, 0.4608, 0.4626, 0.4645, 0.4662, 0.4680, 0.4698, 0.4715,
 284       0.4733, 0.4750, 0.4766, 0.4781, 0.4796, 0.4812, 0.4829, 0.4846,
 285       0.4863, 0.4880, 0.4897, 0.4914, 0.4930, 0.4946, 0.4963, 0.4979
 286     },
 287     {
 288       0.0081, 0.0178, 0.0270, 0.0364, 0.0463, 0.0562, 0.0656, 0.0744,
 289       0.0831, 0.0921, 0.1013, 0.1102, 0.1183, 0.1261, 0.1339, 0.1419,
 290       0.1499, 0.1576, 0.1648, 0.1715, 0.1782, 0.1849, 0.1917, 0.1984,
 291       0.2048, 0.2110, 0.2167, 0.2223, 0.2278, 0.2333, 0.2389, 0.2444,
 292       0.2497, 0.2548, 0.2598, 0.2645, 0.2691, 0.2735, 0.2780, 0.2824,
 293       0.2868, 0.2912, 0.2955, 0.2997, 0.3038, 0.3078, 0.3116, 0.3152,
 294       0.3188, 0.3224, 0.3259, 0.3294, 0.3329, 0.3364, 0.3398, 0.3432,
 295       0.3465, 0.3497, 0.3529, 0.3561, 0.3591, 0.3620, 0.3649, 0.3677,
 296       0.3705, 0.3733, 0.3761, 0.3788, 0.3816, 0.3843, 0.3869, 0.3896,
 297       0.3922, 0.3948, 0.3973, 0.3998, 0.4022, 0.4047, 0.4070, 0.4094,
 298       0.4117, 0.4139, 0.4162, 0.4184, 0.4206, 0.4227, 0.4249, 0.4270,
 299       0.4291, 0.4313, 0.4334, 0.4354, 0.4375, 0.4395, 0.4415, 0.4435,
 300       0.4455, 0.4474, 0.4493, 0.4512, 0.4531, 0.4550, 0.4568, 0.4586,
 301       0.4604, 0.4622, 0.4639, 0.4657, 0.4674, 0.4691, 0.4708, 0.4725,
 302       0.4742, 0.4758, 0.4773, 0.4788, 0.4803, 0.4819, 0.4836, 0.4852,
 303       0.4869, 0.4885, 0.4901, 0.4917, 0.4933, 0.4948, 0.4964, 0.4979
 304     },
 305     {
 306       0.0085, 0.0189, 0.0288, 0.0389, 0.0497, 0.0603, 0.0699, 0.0792,
 307       0.0887, 0.0985, 0.1082, 0.1170, 0.1253, 0.1336, 0.1421, 0.1505,
 308       0.1587, 0.1662, 0.1733, 0.1803, 0.1874, 0.1945, 0.2014, 0.2081,
 309       0.2143, 0.2201, 0.2259, 0.2316, 0.2374, 0.2431, 0.2487, 0.2541,
 310       0.2593, 0.2642, 0.2689, 0.2735, 0.2781, 0.2826, 0.2872, 0.2917,
 311       0.2961, 0.3003, 0.3045, 0.3086, 0.3125, 0.3162, 0.3198, 0.3235,
 312       0.3270, 0.3306, 0.3342, 0.3377, 0.3411, 0.3446, 0.3479, 0.3511,
 313       0.3543, 0.3575, 0.3605, 0.3634, 0.3663, 0.3691, 0.3720, 0.3748,
 314       0.3775, 0.3803, 0.3830, 0.3857, 0.3884, 0.3911, 0.3937, 0.3962,
 315       0.3987, 0.4012, 0.4036, 0.4060, 0.4084, 0.4107, 0.4129, 0.4152,
 316       0.4174, 0.4196, 0.4218, 0.4239, 0.4261, 0.4282, 0.4303, 0.4324,
 317       0.4344, 0.4365, 0.4385, 0.4405, 0.4425, 0.4445, 0.4464, 0.4483,
 318       0.4502, 0.4521, 0.4539, 0.4558, 0.4576, 0.4593, 0.4611, 0.4629,
 319       0.4646, 0.4663, 0.4680, 0.4697, 0.4714, 0.4730, 0.4747, 0.4759,
 320       0.4769, 0.4780, 0.4790, 0.4800, 0.4811, 0.4827, 0.4843, 0.4859,
 321       0.4874, 0.4889, 0.4905, 0.4920, 0.4935, 0.4950, 0.4965, 0.4979
 322     }
 323   };
 324
 325   if (fLUT) {
 326     delete [] fLUT;
 327   }
 328   fLUT = new Float_t[fLUTbin];
 329
 330   for (Int_t iplan = 0; iplan < kNplan; iplan++) {
 331     for (Int_t ilut  = 0; ilut  <  kNlut; ilut++  ) {
 332       fLUT[iplan*kNlut+ilut] = lut[iplan][ilut];
 333     }
 334   }
 335
 336 }
 337
 338 //_____________________________________________________________________________
 339 Double_t AliTRDRecParam::LUTposition(Int_t iplane, Double_t ampL
 340                                   , Double_t ampC, Double_t ampR) const
 341 {
 342   //
 343   // Calculates the cluster position using the lookup table.
 344   // Method provided by Bogdan Vulpescu.
 345   //
 346
 347   const Int_t kNlut = 128;
 348
 349   Double_t pos;
 350   Double_t x    = 0.0;
 351   Double_t xmin;
 352   Double_t xmax;
 353   Double_t xwid;
 354
 355   Int_t    side = 0;
 356   Int_t    ix;
 357
 358   Double_t xMin[kNplan] = { 0.006492, 0.006377, 0.006258
 359                           , 0.006144, 0.006030, 0.005980 };
 360   Double_t xMax[kNplan] = { 0.960351, 0.965870, 0.970445
 361                           , 0.974352, 0.977667, 0.996101 };
 362
 363   if      (ampL > ampR) {
 364     x    = (ampL - ampR) / ampC;
 365     side = -1;
 366   }
 367   else if (ampL < ampR) {
 368     x    = (ampR - ampL) / ampC;
 369     side = +1;
 370   }
 371
 372   if (ampL != ampR) {
 373
 374     xmin = xMin[iplane] + 0.000005;
 375     xmax = xMax[iplane] - 0.000005;
 376     xwid = (xmax - xmin) / 127.0;
 377
 378     if      (x < xmin) {
 379       pos = 0.0000;
 380     }
 381     else if (x > xmax) {
 382       pos = side * 0.5000;
 383     }
 384     else {
 385       ix  = (Int_t) ((x - xmin) / xwid);
 386       pos = side * fLUT[iplane*kNlut+ix];
 387     }
 388
 389   }
 390   else {
 391
 392     pos = 0.0;
 393
 394   }
 395
 396   return pos;
 397
 398 }