TRD/AliTRDpadPlane.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 //  Describes a pad plane of a TRD ROC                                       //
  21 //                                                                           //
  22 //  Contains the information on pad postions, pad dimensions,                //
  23 //  tilting angle, etc.                                                      //
  24 //  It also provides methods to identify the current pad number from         //
  25 //  global coordinates.                                                      //
  26 //  The numbering and coordinates should follow the official convention      //
  27 //  (see David Emschermanns note on TRD convention                           //
  28 //                                                                           //
  29 ///////////////////////////////////////////////////////////////////////////////
  30
  31 #include <TMath.h>
  32
  33 #include "AliTRDpadPlane.h"
  34 #include "AliTRDgeometry.h"
  35
  36 ClassImp(AliTRDpadPlane)
  37
  38 //_____________________________________________________________________________
  39 AliTRDpadPlane::AliTRDpadPlane()
  40   :TObject()
  41   ,fGeo(0)
  42   ,fPla(0)
  43   ,fCha(0)
  44   ,fLength(0)
  45   ,fWidth(0)
  46   ,fLengthRim(0)
  47   ,fWidthRim(0)
  48   ,fLengthOPad(0)
  49   ,fWidthOPad(0)
  50   ,fLengthIPad(0)
  51   ,fWidthIPad(0)
  52   ,fRowSpacing(0)
  53   ,fColSpacing(0)
  54   ,fNrows(0)
  55   ,fNcols(0)
  56   ,fTiltingAngle(0)
  57   ,fTiltingTan(0)
  58   ,fPadRow(0)
  59   ,fPadCol(0)
  60   ,fPadRowSMOffset(0)
  61 {
  62   //
  63   // Default constructor
  64   //
  65
  66 }
  67
  68 //_____________________________________________________________________________
  69 AliTRDpadPlane::AliTRDpadPlane(Int_t p, Int_t c)
  70   :TObject()
  71   ,fGeo(0)
  72   ,fPla(0)
  73   ,fCha(0)
  74   ,fLength(0)
  75   ,fWidth(0)
  76   ,fLengthRim(0)
  77   ,fWidthRim(0)
  78   ,fLengthOPad(0)
  79   ,fWidthOPad(0)
  80   ,fLengthIPad(0)
  81   ,fWidthIPad(0)
  82   ,fRowSpacing(0)
  83   ,fColSpacing(0)
  84   ,fNrows(0)
  85   ,fNcols(0)
  86   ,fTiltingAngle(0)
  87   ,fTiltingTan(0)
  88   ,fPadRow(0)
  89   ,fPadCol(0)
  90   ,fPadRowSMOffset(0)
  91 {
  92   //
  93   // Constructor that initializes a given pad plane type
  94   //
  95
  96   fGeo = new AliTRDgeometry();
  97
  98   fPla = p;
  99   fCha = c;
 100
 101   fRowSpacing = 0.0;
 102   fColSpacing = 0.0;
 103
 104   fLengthRim  = 1.0;
 105   fWidthRim   = 0.5;
 106
 107   fNcols      = 144;
 108
 109   //
 110   // The pad plane parameter
 111   //
 112   switch (p) {
 113   case 0:
 114     if (c == 2) {
 115       // L0C0 type
 116       fNrows        =  12;
 117       fLength       = 108.0;
 118       fWidth        =  92.2;
 119       fLengthOPad   =   8.0;
 120       fWidthOPad    =   0.515;
 121       fLengthIPad   =   9.0;
 122       fWidthIPad    =   0.635;
 123       fTiltingAngle =  -2.0;
 124     }
 125     else {
 126       // L0C1 type
 127       fNrows        =  16;
 128       fLength       = 122.0;
 129       fWidth        =  92.2;
 130       fLengthOPad   =   7.5;
 131       fWidthOPad    =   0.515;
 132       fLengthIPad   =   7.5;
 133       fWidthIPad    =   0.635;
 134       fTiltingAngle =  -2.0;
 135     }
 136     break;
 137   case 1:
 138     if (c == 2) {
 139       // L1C0 type
 140       fNrows        =  12;
 141       fLength       = 108.0;
 142       fWidth        =  96.6;
 143       fLengthOPad   =   8.0;
 144       fWidthOPad    =   0.585;
 145       fLengthIPad   =   9.0;
 146       fWidthIPad    =   0.665;
 147       fTiltingAngle =   2.0;
 148     }
 149     else {
 150       // L1C1 type
 151       fNrows        =  16;
 152       fLength       = 122.0;
 153       fWidth        =  96.6;
 154       fLengthOPad   =   7.5;
 155       fWidthOPad    =   0.585;
 156       fLengthIPad   =   7.5;
 157       fWidthIPad    =   0.665;
 158       fTiltingAngle =   2.0;
 159     }
 160     break;
 161   case 2:
 162     if (c == 2) {
 163       // L2C0 type
 164       fNrows        =  12;
 165       fLength       = 108.0;
 166       fWidth        = 101.1;
 167       fLengthOPad   =   8.0;
 168       fWidthOPad    =   0.705;
 169       fLengthIPad   =   9.0;
 170       fWidthIPad    =   0.695;
 171       fTiltingAngle =  -2.0;
 172     }
 173     else {
 174       // L2C1 type
 175       fNrows        =  16;
 176       fLength       = 129.0;
 177       fWidth        = 101.1;
 178       fLengthOPad   =   7.5;
 179       fWidthOPad    =   0.705;
 180       fLengthIPad   =   8.0;
 181       fWidthIPad    =   0.695;
 182       fTiltingAngle =  -2.0;
 183     }
 184     break;
 185   case 3:
 186     if (c == 2) {
 187       // L3C0 type
 188       fNrows        =  12;
 189       fLength       = 108.0;
 190       fWidth        = 105.5;
 191       fLengthOPad   =   8.0;
 192       fWidthOPad    =   0.775;
 193       fLengthIPad   =   9.0;
 194       fWidthIPad    =   0.725;
 195       fTiltingAngle =   2.0;
 196     }
 197     else {
 198       // L3C1 type
 199       fNrows        =  16;
 200       fLength       = 136.0;
 201       fWidth        = 105.5;
 202       fLengthOPad   =   7.5;
 203       fWidthOPad    =   0.775;
 204       fLengthIPad   =   8.5;
 205       fWidthIPad    =   0.725;
 206       fTiltingAngle =   2.0;
 207     }
 208     break;
 209   case 4:
 210     if (c == 2) {
 211       // L4C0 type
 212       fNrows        =  12;
 213       fLength       = 108.0;
 214       fWidth        = 109.9;
 215       fLengthOPad   =   8.0;
 216       fWidthOPad    =   0.845;
 217       fLengthIPad   =   9.0;
 218       fWidthIPad    =   0.755;
 219       fTiltingAngle =  -2.0;
 220     }
 221     else {
 222       // L4C1 type
 223       fNrows        =  16;
 224       fLength       = 143.0;
 225       fWidth        = 109.9;
 226       fLengthOPad   =   7.5;
 227       fWidthOPad    =   0.845;
 228       fLengthIPad   =   9.0;
 229       fWidthIPad    =   0.755;
 230       fTiltingAngle =  -2.0;
 231     }
 232     break;
 233   case 5:
 234     if (c == 2) {
 235       // L5C0 type
 236       fNrows        =  12;
 237       fLength       = 108.0;
 238       fWidth        = 114.4;
 239       fLengthOPad   =   8.0;
 240       fWidthOPad    =   0.965;
 241       fLengthIPad   =   9.0;
 242       fWidthIPad    =   0.785;
 243       fTiltingAngle =   2.0;
 244     }
 245     else {
 246       // L5C1 type
 247       fNrows        =  16;
 248       fLength       = 145.0;
 249       fWidth        = 114.4;
 250       fLengthOPad   =   8.5;
 251       fWidthOPad    =   0.965;
 252       fLengthIPad   =   9.0;
 253       fWidthIPad    =   0.785;
 254       fTiltingAngle =   2.0;
 255     }
 256     break;
 257   };
 258
 259   //
 260   // Store tilting angle as tangens
 261   //
 262   fTiltingTan = TMath::Tan(TMath::Pi()/180.0 * fTiltingAngle);
 263
 264   //
 265   // The positions of the borders of the pads
 266   //
 267   // Row direction
 268   //
 269   fPadRow = new Double_t[fNrows];
 270   Double_t row = fGeo->GetChamberLength(p,c) / 2.0
 271                - fGeo->RpadW()
 272                - fLengthRim;
 273   for (Int_t ir = 0; ir < fNrows; ir++) {
 274     fPadRow[ir] = row;
 275     row -= fRowSpacing;
 276     if (ir == 0) {
 277       row -= fLengthOPad;
 278     }
 279     else {
 280       row -= fLengthIPad;
 281     }
 282   }
 283   //
 284   // Column direction
 285   //
 286   fPadCol = new Double_t[fNcols];
 287   Double_t col = fGeo->GetChamberWidth(p) / 2.0
 288                + fGeo->CroWid()
 289                - fWidthRim;
 290   for (Int_t ic = 0; ic < fNcols; ic++) {
 291     fPadCol[ic] = col;
 292     col -= fColSpacing;
 293     if (ic == 0) {
 294       col -= fWidthOPad;
 295     }
 296     else {
 297       col -= fWidthIPad;
 298     }
 299   }
 300   // Calculate the offset to translate from the local ROC system into
 301   // the local supermodule system, which is used for clusters
 302   Double_t rowTmp = fGeo->GetChamberLength(p,0)
 303                   + fGeo->GetChamberLength(p,1)
 304                   + fGeo->GetChamberLength(p,2) / 2.0;
 305   for (Int_t ic = 0; ic < c; ic++) {
 306     rowTmp -= fGeo->GetChamberLength(p,ic);
 307   }
 308   fPadRowSMOffset = rowTmp - fGeo->GetChamberLength(p,c)/2.0;
 309
 310 }
 311
 312 //_____________________________________________________________________________
 313 AliTRDpadPlane::AliTRDpadPlane(const AliTRDpadPlane &p)
 314   :TObject(p)
 315   ,fGeo(0)
 316   ,fPla(p.fPla)
 317   ,fCha(p.fCha)
 318   ,fLength(p.fLength)
 319   ,fWidth(p.fWidth)
 320   ,fLengthRim(p.fLengthRim)
 321   ,fWidthRim(p.fLengthRim)
 322   ,fLengthOPad(p.fLengthOPad)
 323   ,fWidthOPad(p.fWidthOPad)
 324   ,fLengthIPad(p.fLengthIPad)
 325   ,fWidthIPad(p.fWidthIPad)
 326   ,fRowSpacing(p.fRowSpacing)
 327   ,fColSpacing(p.fColSpacing)
 328   ,fNrows(p.fNrows)
 329   ,fNcols(p.fNcols)
 330   ,fTiltingAngle(p.fTiltingAngle)
 331   ,fTiltingTan(p.fTiltingTan)
 332   ,fPadRow(0)
 333   ,fPadCol(0)
 334   ,fPadRowSMOffset(p.fPadRowSMOffset)
 335 {
 336   //
 337   // AliTRDpadPlane copy constructor
 338   //
 339
 340   Int_t iBin = 0;
 341
 342   if (((AliTRDpadPlane &) p).fPadRow) {
 343     delete [] ((AliTRDpadPlane &) p).fPadRow;
 344   }
 345   ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
 346   for (iBin = 0; iBin < fNrows; iBin++) {
 347     ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
 348   }
 349
 350   if (((AliTRDpadPlane &) p).fPadCol) {
 351     delete [] ((AliTRDpadPlane &) p).fPadCol;
 352   }
 353   ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
 354   for (iBin = 0; iBin < fNrows; iBin++) {
 355     ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
 356   }
 357
 358 }
 359
 360 //_____________________________________________________________________________
 361 AliTRDpadPlane::~AliTRDpadPlane()
 362 {
 363   //
 364   // AliTRDpadPlane destructor
 365   //
 366
 367   if (fGeo) {
 368     delete fGeo;
 369     fGeo    = 0;
 370   }
 371
 372   if (fPadRow) {
 373     delete [] fPadRow;
 374     fPadRow = 0;
 375   }
 376
 377   if (fPadCol) {
 378     delete [] fPadCol;
 379     fPadCol = 0;
 380   }
 381
 382 }
 383
 384 //_____________________________________________________________________________
 385 AliTRDpadPlane &AliTRDpadPlane::operator=(const AliTRDpadPlane &p)
 386 {
 387   //
 388   // Assignment operator
 389   //
 390
 391   if (this != &p) {
 392     ((AliTRDpadPlane &) p).Copy(*this);
 393   }
 394
 395   return *this;
 396
 397 }
 398
 399 //_____________________________________________________________________________
 400 void AliTRDpadPlane::Copy(TObject &p) const
 401 {
 402   //
 403   // Copy function
 404   //
 405
 406   Int_t iBin = 0;
 407
 408   ((AliTRDpadPlane &) p).fGeo            = 0;
 409
 410   ((AliTRDpadPlane &) p).fPla            = fPla;
 411   ((AliTRDpadPlane &) p).fCha            = fCha;
 412
 413   ((AliTRDpadPlane &) p).fLength         = fLength;
 414   ((AliTRDpadPlane &) p).fWidth          = fWidth;
 415   ((AliTRDpadPlane &) p).fLengthRim      = fLengthRim;
 416   ((AliTRDpadPlane &) p).fWidthRim       = fWidthRim;
 417   ((AliTRDpadPlane &) p).fLengthOPad     = fLengthOPad;
 418   ((AliTRDpadPlane &) p).fWidthOPad      = fWidthOPad;
 419   ((AliTRDpadPlane &) p).fLengthIPad     = fLengthIPad;
 420   ((AliTRDpadPlane &) p).fWidthIPad      = fWidthIPad;
 421
 422   ((AliTRDpadPlane &) p).fRowSpacing     = fRowSpacing;
 423   ((AliTRDpadPlane &) p).fColSpacing     = fColSpacing;
 424
 425   ((AliTRDpadPlane &) p).fNrows          = fNrows;
 426   ((AliTRDpadPlane &) p).fNcols          = fNcols;
 427
 428   ((AliTRDpadPlane &) p).fTiltingAngle   = fTiltingAngle;
 429   ((AliTRDpadPlane &) p).fTiltingTan     = fTiltingTan;
 430
 431   ((AliTRDpadPlane &) p).fPadRowSMOffset = fPadRowSMOffset;
 432
 433   if (((AliTRDpadPlane &) p).fPadRow) {
 434     delete [] ((AliTRDpadPlane &) p).fPadRow;
 435   }
 436   ((AliTRDpadPlane &) p).fPadRow = new Double_t[fNrows];
 437   for (iBin = 0; iBin < fNrows; iBin++) {
 438     ((AliTRDpadPlane &) p).fPadRow[iBin] = fPadRow[iBin];
 439   }
 440
 441   if (((AliTRDpadPlane &) p).fPadCol) {
 442     delete [] ((AliTRDpadPlane &) p).fPadCol;
 443   }
 444   ((AliTRDpadPlane &) p).fPadCol = new Double_t[fNrows];
 445   for (iBin = 0; iBin < fNrows; iBin++) {
 446     ((AliTRDpadPlane &) p).fPadCol[iBin] = fPadCol[iBin];
 447   }
 448
 449   TObject::Copy(p);
 450
 451 }
 452
 453 //_____________________________________________________________________________
 454 Int_t AliTRDpadPlane::GetPadRowNumber(Double_t z) const
 455 {
 456   //
 457   // Finds the pad row number for a given z-position in local supermodule system
 458   //
 459
 460   Int_t row    = 0;
 461   Int_t nabove = 0;
 462   Int_t nbelow = 0;
 463   Int_t middle = 0;
 464
 465   if ((z > GetRow0()  ) ||
 466       (z < GetRowEnd())) {
 467
 468     row = -1;
 469
 470   }
 471   else {
 472
 473     nabove = fNrows + 1;
 474     nbelow = 0;
 475     while (nabove - nbelow > 1) {
 476       middle = (nabove + nbelow) / 2;
 477       if (z == (fPadRow[middle-1] + fPadRowSMOffset)) {
 478         row    = middle;
 479       }
 480       if (z  > (fPadRow[middle-1] + fPadRowSMOffset)) {
 481         nabove = middle;
 482       }
 483       else {
 484         nbelow = middle;
 485       }
 486     }
 487     row = nbelow - 1;
 488
 489   }
 490
 491   return row;
 492
 493 }
 494
 495 //_____________________________________________________________________________
 496 Int_t AliTRDpadPlane::GetPadRowNumberROC(Double_t z) const
 497 {
 498   //
 499   // Finds the pad row number for a given z-position in local ROC system
 500   //
 501
 502   Int_t row    = 0;
 503   Int_t nabove = 0;
 504   Int_t nbelow = 0;
 505   Int_t middle = 0;
 506
 507   if ((z > GetRow0ROC()  ) ||
 508       (z < GetRowEndROC())) {
 509
 510     row = -1;
 511
 512   }
 513   else {
 514
 515     nabove = fNrows + 1;
 516     nbelow = 0;
 517     while (nabove - nbelow > 1) {
 518       middle = (nabove + nbelow) / 2;
 519       if (z == fPadRow[middle-1]) {
 520         row    = middle;
 521       }
 522       if (z  > fPadRow[middle-1]) {
 523         nabove = middle;
 524       }
 525       else {
 526         nbelow = middle;
 527       }
 528     }
 529     row = nbelow - 1;
 530
 531   }
 532
 533   return row;
 534
 535 }
 536
 537 //_____________________________________________________________________________
 538 Int_t AliTRDpadPlane::GetPadColNumber(Double_t rphi) const
 539 {
 540   //
 541   // Finds the pad column number for a given global rphi-position
 542   //
 543
 544   Int_t col    = 0;
 545   Int_t nabove = 0;
 546   Int_t nbelow = 0;
 547   Int_t middle = 0;
 548
 549   if ((rphi > GetCol0()  ) ||
 550       (rphi < GetColEnd())) {
 551
 552     col = -1;
 553
 554   }
 555   else {
 556
 557     nabove = fNcols + 1;
 558     nbelow = 0;
 559     while (nabove - nbelow > 1) {
 560       middle = (nabove + nbelow) / 2;
 561       if (rphi == fPadCol[middle-1]) {
 562         col    = middle;
 563       }
 564       if (rphi  > fPadCol[middle-1]) {
 565         nabove = middle;
 566       }
 567       else {
 568         nbelow = middle;
 569       }
 570     }
 571     col = nbelow - 1;
 572
 573   }
 574
 575   return col;
 576
 577 }