TRD/AliTRDCalibraMode.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 // AliTRDCalibraMode
  21 //
  22 // This class is for the modes of the TRD calibration.
  23 // The user has to choose with the functions SetNz and SetNrphi
  24 // the precision of the calibration.
  25 // Author:
  26 //   R. Bailhache (R.Bailhache@gsi.de)
  27 //
  28 //Begin_Html
  29 /*
  30 <br>
  31 <CENTER>
  32 <TABLE border=1>
  33 <TR><TD><center>Nz</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD></TR>
  34 <TR><TD><CENTER>group of row pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>6(chamb2)<br> 8(others chambers)</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD></TR>
  35 <TR><TD><CENTER>row pads per group</CENTER></TD><TD><CENTER>12 (chamb2)<br> 16 (chamb0)</CENTER></TD><TD><CENTER>6 (chamb2)<br> 8 (chamb0)</CENTER></TD><TD><CENTER>3 (chamb2)<br> 4 (chamb0)</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>1</CENTER></TD></TR>
  36 <TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>106 (chamb2)<br> 130 (chamb0)</CENTER></TD><TD><CENTER>53 (chamb2)<br> 65 (chamb0)</CENTER></TD><TD><CENTER>26.5 (chamb2)<br> 32.5 (chamb0)</CENTER></TD><TD><CENTER>17 (chamb2)<br> 17 (chamb0)</CENTER></TD><TD><CENTER>9 (chamb2)<br> 9 (chamb0)</CENTER></TD></TR>
  37 <CAPTION>In the z direction</CAPTION>
  38 </TABLE>
  39 </CENTER>
  40 <CENTER>
  41 <br>
  42 <TABLE border=1>
  43 <TR><TD><center>Nrphi</center></TD><TD><center> 0 </center></TD><TD><center> 1 </center></TD><TD><center> 2 </center></TD><TD><center> 3 </center></TD><TD><center> 4 </center></TD><TD><center> 5 </center></TD><TD><center> 6 </center></TD></TR>
  44 <TR><TD><CENTER>group of col pads per detector</CENTER></TD><TD><CENTER>1</CENTER></TD><TD><CENTER>2</CENTER></TD><TD><CENTER>4</CENTER></TD><TD><CENTER>8</CENTER></TD><TD><CENTER>16</CENTER></TD><TD><center>36</center></TD><TD><center>144</center></TD></TR>
  45 <TR><TD><CENTER>col pads per group</CENTER></TD><TD><CENTER>144</CENTER></TD><TD><CENTER>72</CENTER></TD><TD><CENTER>36</CENTER></TD><TD><CENTER>18</CENTER></TD><TD><CENTER>9</CENTER></TD><TD><center>4</center></TD><TD><center>1</center></TD></TR>
  46 <TR><TD><CENTER>~distance [cm]</CENTER></TD><TD><CENTER>113.4</CENTER></TD><TD><CENTER>56.7</CENTER></TD><TD><CENTER>25.3</CENTER></TD><TD><CENTER>14.3</CENTER></TD><TD><CENTER>7.25</CENTER></TD><TD><center>3.2</center></TD><TD><center>0.8</center></TD></TR>
  47 <CAPTION>In the rphi direction</CAPTION>
  48 </TABLE>
  49 </CENTER>
  50 <br>
  51 */
  52 //End_Html
  53 //
  54 //
  55 // Moreover two other more general granularities:
  56 // It can not work with AliTRDCalibraVector
  57 // 10 corresponds to per supermodule
  58 // 100 all together
  59 //
  60 //////////////////////////////////////////////////////////////////////////////////////
  61
  62 #include "AliLog.h"
  63
  64 #include "AliTRDCalibraMode.h"
  65 #include "AliTRDgeometry.h"
  66
  67 ClassImp(AliTRDCalibraMode)
  68
  69 //______________________________________________________________________________________
  70 AliTRDCalibraMode::AliTRDCalibraMode()
  71   :TObject()
  72   ,fGeo(0)
  73 {
  74   //
  75   // Default constructor
  76   //
  77
  78   for (Int_t i = 0; i < 3; i++) {
  79     fNz[i]    = 0;
  80     fNrphi[i] = 0;
  81   }
  82
  83   for (Int_t k = 0; k < 3; k++) {
  84     fDetChamb2[k] = 0;
  85     fDetChamb0[k] = 0;
  86   }
  87
  88   for (Int_t i = 0; i < 3; i++) {
  89     fRowMin[i]    = -1;
  90     fRowMax[i]    = -1;
  91     fColMax[i]    = -1;
  92     fColMin[i]    = -1;
  93     fNnZ[i]       = -1;
  94     fNnRphi[i]    = -1;
  95     fNfragZ[i]    = -1;
  96     fNfragRphi[i] = -1;
  97     fXbins[i]     = -1;
  98   }
  99
 100   fGeo = new AliTRDgeometry();
 101
 102 }
 103
 104 //______________________________________________________________________________________
 105 AliTRDCalibraMode::AliTRDCalibraMode(const AliTRDCalibraMode &c)
 106   :TObject(c)
 107   ,fGeo(0)
 108 {
 109   //
 110   // Copy constructor
 111   //
 112
 113   for(Int_t k = 0; k < 3; k++){
 114     fNz[k]        = c.fNz[k];
 115     fNrphi[k]     = c.fNrphi[k];
 116     fNnZ[k]       = c.fNnZ[k];
 117     fNnRphi[k]    = c.fNnRphi[k];
 118     fNfragZ[k]    = c.fNfragZ[k];
 119     fNfragRphi[k] = c.fNfragRphi[k];
 120     fRowMin[k]    = c.fRowMin[k];
 121     fRowMax[k]    = c.fRowMax[k];
 122     fColMin[k]    = c.fColMin[k];
 123     fColMax[k]    = c.fColMax[k];
 124     fXbins[k]     = c.fXbins[k];
 125     fDetChamb0[k] = c.fDetChamb0[k];
 126     fDetChamb2[k] = c.fDetChamb2[k];
 127   }
 128
 129   if (fGeo) {
 130     delete fGeo;
 131   }
 132   fGeo = new AliTRDgeometry();
 133
 134 }
 135
 136 //____________________________________________________________________________________
 137 AliTRDCalibraMode::~AliTRDCalibraMode()
 138 {
 139   //
 140   // AliTRDCalibraMode destructor
 141   //
 142
 143   if (fGeo) {
 144     delete fGeo;
 145   }
 146
 147 }
 148
 149 //_____________________________________________________________________________
 150 void AliTRDCalibraMode::SetPerSuperModule(Int_t i)
 151 {
 152   //
 153   // Set the mode of calibration group per supermodule
 154   //
 155
 156   fNz[i] = 10;
 157   fNrphi[i] = 10;
 158 }
 159
 160 //_____________________________________________________________________________
 161 void AliTRDCalibraMode::SetAllTogether(Int_t i)
 162 {
 163   //
 164   // Set the mode of calibration group all together
 165   //
 166
 167   fNz[i] = 100;
 168   fNrphi[i] = 100;
 169 }
 170
 171 //_____________________________________________________________________________
 172 void AliTRDCalibraMode::SetNz(Int_t i, Short_t Nz)
 173 {
 174   //
 175   // Set the mode of calibration group in the z direction for the parameter i
 176   //
 177
 178   if ((Nz >= 0) &&
 179       (Nz <  5)) {
 180     fNz[i] = Nz;
 181   }
 182   else {
 183     AliInfo("You have to choose between 0 and 4.");
 184   }
 185
 186 }
 187
 188 //_____________________________________________________________________________
 189 void AliTRDCalibraMode::SetNrphi(Int_t i, Short_t Nrphi)
 190 {
 191   //
 192   // Set the mode of calibration group in the rphi direction for the parameter i
 193   //
 194
 195   if ((Nrphi >= 0) &&
 196       (Nrphi <  7)) {
 197     fNrphi[i] = Nrphi;
 198   }
 199   else {
 200     AliInfo("You have to choose between 0 and 6 or 10/100.");
 201   }
 202
 203 }
 204
 205 //_______________________________________________________________________________________
 206 void AliTRDCalibraMode::ModePadCalibration(Int_t iChamb, Int_t i)
 207 {
 208   //
 209   // Definition of the calibration mode
 210   // from Nz and Nrphi, the number of row and col pads per calibration groups are setted
 211   //
 212
 213
 214   fNnZ[i]    = 0;
 215   fNnRphi[i] = 0;
 216
 217   if (((fNz[i] == 0) || (fNz[i] == 10) || (fNz[i] == 100)) && (iChamb == 2)) {
 218     fNnZ[i] = 12;
 219   }
 220   if (((fNz[i] == 0) || (fNz[i] == 10) || (fNz[i] == 100)) && (iChamb != 2)) {
 221     fNnZ[i] = 16;
 222   }
 223   if ((fNz[i] == 1) && (iChamb == 2)) {
 224     fNnZ[i] = 6;
 225   }
 226   if ((fNz[i] == 1) && (iChamb != 2)) {
 227     fNnZ[i] = 8;
 228   }
 229   if ((fNz[i] == 2) && (iChamb == 2)) {
 230     fNnZ[i] = 3;
 231   }
 232   if ((fNz[i] == 2) && (iChamb != 2)) {
 233     fNnZ[i] = 4;
 234   }
 235   if (fNz[i] == 3) {
 236     fNnZ[i] = 2;
 237   }
 238   if (fNz[i] == 4) {
 239     fNnZ[i] = 1;
 240   }
 241
 242   if ((fNrphi[i] == 0) || (fNrphi[i] == 10) || (fNrphi[i] == 100)) {
 243     fNnRphi[i] = 144;
 244   }
 245   if (fNrphi[i] == 1) {
 246     fNnRphi[i] = 72;
 247   }
 248   if (fNrphi[i] == 2) {
 249     fNnRphi[i] = 36;
 250   }
 251   if (fNrphi[i] == 3) {
 252     fNnRphi[i] = 18;
 253   }
 254   if (fNrphi[i] == 4) {
 255     fNnRphi[i] = 9;
 256   }
 257   if (fNrphi[i] == 5) {
 258     fNnRphi[i] = 4;
 259   }
 260   if (fNrphi[i] == 6) {
 261     fNnRphi[i] = 1;
 262   }
 263
 264 }
 265
 266 //_____________________________________________________________________________________________
 267 Bool_t AliTRDCalibraMode::ModePadFragmentation(Int_t iLayer,Int_t iStack, Int_t iSect, Int_t i)
 268 {
 269   //
 270   // Definition of the calibration mode
 271   // From the number of row and col pads per calibration groups the
 272   // number of calibration groups are setted
 273   //
 274
 275   fNfragZ[i]    = 0;
 276   fNfragRphi[i] = 0;
 277
 278   // A little geometry:
 279   Int_t rowMax = fGeo->GetRowMax(iLayer,iStack,iSect);
 280   Int_t colMax = fGeo->GetColMax(iLayer);
 281
 282   // The fragmentation
 283   if (fNnZ[i]    != 0) {
 284     fNfragZ[i]    = (Int_t) rowMax / fNnZ[i];
 285   }
 286
 287   if (fNnRphi[i] != 0) {
 288     fNfragRphi[i] = (Int_t) colMax / fNnRphi[i];
 289   }
 290
 291   return kTRUE;
 292
 293 }
 294
 295 //_____________________________________________________________________________
 296 void AliTRDCalibraMode::ReconstructionRowPadGroup(Int_t idect, Int_t i)
 297 {
 298   //
 299   // For the calibration group idect in a detector calculate the
 300   // first and last row pad and col pad.
 301   // The pads in the interval will have the same calibrated coefficients
 302   //
 303
 304   Int_t posc = -1;
 305   Int_t posr = -1;
 306   fRowMin[i] = -1;
 307   fRowMax[i] = -1;
 308   fColMin[i] = -1;
 309   fColMax[i] = -1;
 310
 311   if (fNfragZ[i]    != 0) {
 312     posc = (Int_t) idect / fNfragZ[i];
 313   }
 314   if (fNfragRphi[i] != 0) {
 315     posr = (Int_t) idect % fNfragZ[i];
 316   }
 317   fRowMin[i] = posr     * fNnZ[i];
 318   fRowMax[i] = (posr+1) * fNnZ[i];
 319   fColMin[i] = posc     * fNnRphi[i];
 320   fColMax[i] = (posc+1) * fNnRphi[i];
 321
 322 }
 323
 324 //_____________________________________________________________________________
 325 void AliTRDCalibraMode::CalculXBins(Int_t idect, Int_t i)
 326 {
 327   //
 328   // For the detector idect calcul the first Xbins
 329   //
 330
 331   fXbins[i] = 0;
 332   AliDebug(2, Form("detector: %d", idect));
 333
 334   // Total
 335   if((fNz[i] == 100) && (fNrphi[i] == 100)) {
 336     fXbins[i] = 0;
 337     return;
 338   }
 339
 340   // In which sector?
 341   Int_t sector = GetSector(idect);
 342
 343
 344   // First per supermodule
 345   if((fNz[i] == 10) && (fNrphi[i] == 10)) {
 346     fXbins[i] = sector;
 347     return;
 348   }
 349
 350   fXbins[i] += sector*(6*fDetChamb2[i]+6*4*fDetChamb0[i]);
 351
 352   // In which stack?
 353   Int_t stack = GetStack(idect);
 354   Int_t kc      = 0;
 355   while (kc < stack) {
 356     if (kc == 2) {
 357       fXbins[i] += 6 * fDetChamb2[i];
 358     }
 359     else {
 360       fXbins[i] += 6 * fDetChamb0[i];
 361     }
 362     kc ++;
 363   }
 364
 365   // In which layer?
 366   Int_t layer = GetLayer(idect);
 367   if (stack == 2) {
 368     fXbins[i] += layer*fDetChamb2[i];
 369   }
 370   else {
 371     fXbins[i] += layer*fDetChamb0[i];
 372   }
 373
 374 }
 375
 376 //_____________________________________________________________________________
 377 void AliTRDCalibraMode::ResetMinMax(Int_t i)
 378 {
 379   //
 380   // Reset fRowMin fRowMax fColMin fColMax [i]
 381   //
 382
 383   fRowMin[i] = -1;
 384   fRowMax[i] = -1;
 385   fColMin[i] = -1;
 386   fColMax[i] = -1;
 387
 388 }
 389
 390 //_____________________________________________________________________________
 391 void AliTRDCalibraMode::SetDetChamb0(Int_t i)
 392 {
 393   //
 394   // Set the number of calibration group per detector != 2
 395   //
 396
 397   fDetChamb0[i] = fNfragZ[i] * fNfragRphi[i];
 398
 399 }
 400
 401 //_____________________________________________________________________________
 402 void AliTRDCalibraMode::SetDetChamb2(Int_t i)
 403 {
 404   //
 405   // Set the number of calibration group per detector == 2
 406   //
 407
 408   fDetChamb2[i] = fNfragZ[i] * fNfragRphi[i];
 409
 410 }
 411
 412 //_____________________________________________________________________________
 413 Int_t AliTRDCalibraMode::GetLayer(Int_t d) const
 414 {
 415   //
 416   // Reconstruct the plane number from the detector number
 417   //
 418
 419   return ((Int_t) (d % 6));
 420
 421 }
 422
 423 //_____________________________________________________________________________
 424 Int_t AliTRDCalibraMode::GetStack(Int_t d) const
 425 {
 426   //
 427   // Reconstruct the stack number from the detector number
 428   //
 429
 430   const Int_t kNlayer = 6;
 431
 432   return ((Int_t) (d % 30) / kNlayer);
 433
 434 }
 435
 436 //_____________________________________________________________________________
 437 Int_t AliTRDCalibraMode::GetSector(Int_t d) const
 438 {
 439   //
 440   // Reconstruct the sector number from the detector number
 441   //
 442
 443   Int_t fg = 30;
 444
 445   return ((Int_t) (d / fg));
 446
 447 }