TPC/AliTPCROC.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 ///////////////////////////////////////////////////////////////////////////////
  18 //                                                                           //
  19 //  Geometry        class for a single ROC                                   //
  20 //                                                                           //
  21 //                                                                           //
  22 ///////////////////////////////////////////////////////////////////////////////
  23 #include "AliTPCROC.h"
  24 #include "TMath.h"
  25
  26 ClassImp(AliTPCROC)
  27
  28
  29 AliTPCROC* AliTPCROC::fgInstance = 0;
  30
  31
  32
  33
  34 //_ singleton implementation __________________________________________________
  35 AliTPCROC* AliTPCROC::Instance()
  36 {
  37   //
  38   // Singleton implementation
  39   // Returns an instance of this class, it is created if neccessary
  40   //
  41   if (fgInstance == 0){
  42     fgInstance = new AliTPCROC();
  43     fgInstance->Init();
  44   }
  45   return fgInstance;
  46 }
  47
  48
  49
  50
  51 void AliTPCROC::Init(){
  52   //
  53   // initialize static variables
  54   //
  55   if (AliTPCROC::fNSectorsAll>0) return;
  56   fNSectorsAll =72;
  57   fNSectors[0] =36;
  58   fNSectors[1] =36;
  59   //
  60   fNRows[0]= 63;
  61   fNRows[1]= 96;
  62   //
  63   // number of pads in padrow
  64   fNPads[0] = new UInt_t[fNRows[0]];
  65   fNPads[1] = new UInt_t[fNRows[1]];
  66   //
  67   // padrow index in array
  68   //
  69   fRowPosIndex[0] = new UInt_t[fNRows[0]];
  70   fRowPosIndex[1] = new UInt_t[fNRows[1]];
  71   //
  72   // inner sectors
  73   //
  74   UInt_t index =0;
  75   for (UInt_t irow=0; irow<fNRows[0];irow++){
  76     UInt_t npads = (irow==0) ? 68 : 2 *Int_t(Double_t(irow)/3. +33.67);
  77     fNPads[0][irow] = npads;
  78     fRowPosIndex[0][irow] = index;
  79     index+=npads;
  80   }
  81   fNChannels[0] = index;
  82   //
  83   index =0;
  84   Double_t k1 = 10.*TMath::Tan(10*TMath::DegToRad())/6.;
  85   Double_t k2 = 15.*TMath::Tan(10*TMath::DegToRad())/6.;
  86   for (UInt_t irow=0; irow<fNRows[1];irow++){
  87     UInt_t npads = (irow<64) ?
  88       2*Int_t(k1*Double_t(irow)+37.75):
  89       2*Int_t(k2*Double_t(irow-64)+56.66);
  90     fNPads[1][irow] = npads;
  91     fRowPosIndex[1][irow] = index;
  92     index+=npads;
  93   }
  94   fNChannels[1] = index;
  95   SetGeometry();
  96 }
  97
  98
  99
 100
 101 void AliTPCROC::SetGeometry()
 102 {
 103   //
 104   //set ROC geometry parameters
 105   //
 106   const  Float_t kInnerRadiusLow = 83.65;
 107   const  Float_t kInnerRadiusUp  = 133.3;
 108   const  Float_t kOuterRadiusLow = 133.5;
 109   const  Float_t kOuterRadiusUp  = 247.7;
 110   const  Float_t kInnerFrameSpace = 1.5;
 111   const  Float_t kOuterFrameSpace = 1.5;
 112   const  Float_t kInnerWireMount = 1.2;
 113   const  Float_t kOuterWireMount = 1.4;
 114   const  Float_t kZLength =250.;
 115   const  UInt_t   kNRowLow = 63;
 116   const  UInt_t   kNRowUp1 = 64;
 117   const  UInt_t   kNRowUp2 = 32;
 118   const  UInt_t   kNRowUp  = 96;
 119   const  Float_t kInnerAngle = 20; // 20 degrees
 120   const  Float_t kOuterAngle = 20; // 20 degrees
 121   //
 122   //  pad     parameters
 123   //
 124   const Float_t  kInnerPadPitchLength = 0.75;
 125   const Float_t  kInnerPadPitchWidth = 0.40;
 126   const Float_t  kInnerPadLength = 0.75;
 127   const Float_t  kInnerPadWidth = 0.40;
 128   const Float_t  kOuter1PadPitchLength = 1.0;
 129   const Float_t  kOuterPadPitchWidth = 0.6;
 130   const Float_t  kOuter1PadLength = 1.0;
 131   const Float_t  kOuterPadWidth = 0.6;
 132   const Float_t  kOuter2PadPitchLength = 1.5;
 133   const Float_t  kOuter2PadLength = 1.5;
 134
 135   //
 136   //wires default parameters
 137   //
 138 //   const UInt_t    kNInnerWiresPerPad = 3;
 139 //   const UInt_t    kInnerDummyWire = 2;
 140 //   const Float_t  kInnerWWPitch = 0.25;
 141 //   const Float_t  kRInnerFirstWire = 84.475;
 142 //   const Float_t  kRInnerLastWire = 132.475;
 143 //   const Float_t  kInnerOffWire = 0.5;
 144 //   const UInt_t    kNOuter1WiresPerPad = 4;
 145 //   const UInt_t    kNOuter2WiresPerPad = 6;
 146 //   const Float_t  kOuterWWPitch = 0.25;
 147 //   const Float_t  kROuterFirstWire = 134.225;
 148 //   const Float_t  kROuterLastWire = 246.975;
 149 //   const UInt_t    kOuterDummyWire = 2;
 150 //   const Float_t  kOuterOffWire = 0.5;
 151   //
 152   //set sector parameters
 153   //
 154   fInnerRadiusLow = kInnerRadiusLow;
 155   fOuterRadiusLow = kOuterRadiusLow;
 156   fInnerRadiusUp  = kInnerRadiusUp;
 157   fOuterRadiusUp  = kOuterRadiusUp;
 158   fInnerFrameSpace = kInnerFrameSpace;
 159   fOuterFrameSpace = kOuterFrameSpace;
 160   fInnerWireMount  = kInnerWireMount;
 161   fOuterWireMount  = kOuterWireMount;
 162   fZLength         = kZLength;
 163   fInnerAngle      =  TMath::DegToRad()*kInnerAngle;
 164   fOuterAngle      =  TMath::DegToRad()*kOuterAngle;
 165
 166   fNRowLow       = kNRowLow;
 167   fNRowUp1      = kNRowUp1;
 168   fNRowUp2       = kNRowUp2;
 169   fNRowUp        = kNRowUp;
 170   //
 171   //set pad parameter
 172   //
 173   fInnerPadPitchLength = kInnerPadPitchLength;
 174   fInnerPadPitchWidth  = kInnerPadPitchWidth;
 175   fInnerPadLength      = kInnerPadLength;
 176   fInnerPadWidth       = kInnerPadWidth;
 177   fOuter1PadPitchLength = kOuter1PadPitchLength;
 178   fOuter2PadPitchLength = kOuter2PadPitchLength;
 179   fOuterPadPitchWidth   = kOuterPadPitchWidth;
 180   fOuter1PadLength      = kOuter1PadLength;
 181   fOuter2PadLength      = kOuter2PadLength;
 182   fOuterPadWidth        = kOuterPadWidth;
 183
 184   //
 185   //set wire parameters
 186   //
 187   // SetInnerNWires(kNInnerWiresPerPad);
 188   //   SetInnerDummyWire(kInnerDummyWire);
 189   //   SetInnerOffWire(kInnerOffWire);
 190   //   SetOuter1NWires(kNOuter1WiresPerPad);
 191   //   SetOuter2NWire(kNOuter2WiresPerPad);
 192   //   SetOuterDummyWire(kOuterDummyWire);
 193   //   SetOuterOffWire(kOuterOffWire);
 194   //   SetInnerWWPitch(kInnerWWPitch);
 195   //   SetRInnerFirstWire(kRInnerFirstWire);
 196   //   SetRInnerLastWire(kRInnerLastWire);
 197   //   SetOuterWWPitch(kOuterWWPitch);
 198   //   SetROuterFirstWire(kROuterFirstWire);
 199   //   SetROuterLastWire(kROuterLastWire);
 200
 201   UInt_t i=0;
 202   Float_t firstrow = fInnerRadiusLow + 1.575;
 203   for( i= 0;i<fNRowLow;i++)
 204     {
 205       Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;
 206       fPadRowLow[i]=x;
 207       fYInner[i+1]  = x*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
 208       fNPadsLow[i] = GetNPads(0,i) ;     // ROC implement
 209     }
 210   // cross talk rows
 211   fYInner[0]=(fPadRowLow[0]-fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
 212   fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
 213   firstrow = fOuterRadiusLow + 1.6;
 214   for(i=0;i<fNRowUp;i++)
 215     {
 216       if(i<fNRowUp1){
 217         Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i;
 218         fPadRowUp[i]=x;
 219         fYOuter[i+1]= x*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
 220         fNPadsUp[i] =  GetNPads(36,i) ;     // ROC implement
 221         if(i==fNRowUp1-1) {
 222           fLastWireUp1=fPadRowUp[i] +0.625;
 223           firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
 224         }
 225       }
 226       else
 227         {
 228           Float_t x = firstrow + fOuter2PadPitchLength*(Float_t)(i-64);
 229           fPadRowUp[i]=x;
 230           fNPadsUp[i] =  GetNPads(36,i) ;     // ROC implement
 231         }
 232       fYOuter[i+1]  = fPadRowUp[i]*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
 233     }
 234
 235
 236
 237 }
 238
 239
 240
 241
 242 //_____________________________________________________________________________
 243 AliTPCROC::AliTPCROC()
 244           :TObject(),
 245            fNSectorsAll(0),
 246            fInnerRadiusLow(0.),
 247            fInnerRadiusUp(0.),
 248            fOuterRadiusUp(0.),
 249            fOuterRadiusLow(0.),
 250            fInnerFrameSpace(0.),
 251            fOuterFrameSpace(0.),
 252            fInnerWireMount(0.),
 253            fOuterWireMount(0.),
 254            fZLength(0.),
 255            fInnerAngle(0.),
 256            fOuterAngle(0.),
 257            fNInnerWiresPerPad(0),
 258            fInnerWWPitch(0.),
 259            fInnerDummyWire(0),
 260            fInnerOffWire(0.),
 261            fRInnerFirstWire(0.),
 262            fRInnerLastWire(0.),
 263            fLastWireUp1(0.),
 264            fNOuter1WiresPerPad(0),
 265            fNOuter2WiresPerPad(0),
 266            fOuterWWPitch(0.),
 267            fOuterDummyWire(0),
 268            fOuterOffWire(0),
 269            fROuterFirstWire(0.),
 270            fROuterLastWire(0),
 271            fInnerPadPitchLength(0.),
 272            fInnerPadPitchWidth(0.),
 273            fInnerPadLength(0.),
 274            fInnerPadWidth(0.),
 275            fOuter1PadPitchLength(0.),
 276            fOuter2PadPitchLength(0),
 277            fOuterPadPitchWidth(0),
 278            fOuter1PadLength(0.),
 279            fOuter2PadLength(0),
 280            fOuterPadWidth(0),
 281            fNRowLow(0),
 282            fNRowUp1(0),
 283            fNRowUp2(0),
 284            fNRowUp(0),
 285            fNtRows(0)
 286 {
 287   //
 288   // Default constructor
 289   for (UInt_t i=0;i<2;i++){
 290     fNSectors[i]  = 0;
 291     fNRows[i]     = 0;
 292     fNChannels[i] = 0;
 293     fNPads[i]     = 0;
 294     fRowPosIndex[i]= 0;
 295   }
 296 }
 297
 298
 299 //_____________________________________________________________________________
 300 AliTPCROC::AliTPCROC(const AliTPCROC &roc)
 301           :TObject(roc),
 302            fNSectorsAll(0),
 303            fInnerRadiusLow(0.),
 304            fInnerRadiusUp(0.),
 305            fOuterRadiusUp(0.),
 306            fOuterRadiusLow(0.),
 307            fInnerFrameSpace(0.),
 308            fOuterFrameSpace(0.),
 309            fInnerWireMount(0.),
 310            fOuterWireMount(0.),
 311            fZLength(0.),
 312            fInnerAngle(0.),
 313            fOuterAngle(0.),
 314            fNInnerWiresPerPad(0),
 315            fInnerWWPitch(0.),
 316            fInnerDummyWire(0),
 317            fInnerOffWire(0.),
 318            fRInnerFirstWire(0.),
 319            fRInnerLastWire(0.),
 320            fLastWireUp1(0.),
 321            fNOuter1WiresPerPad(0),
 322            fNOuter2WiresPerPad(0),
 323            fOuterWWPitch(0.),
 324            fOuterDummyWire(0),
 325            fOuterOffWire(0),
 326            fROuterFirstWire(0.),
 327            fROuterLastWire(0),
 328            fInnerPadPitchLength(0.),
 329            fInnerPadPitchWidth(0.),
 330            fInnerPadLength(0.),
 331            fInnerPadWidth(0.),
 332            fOuter1PadPitchLength(0.),
 333            fOuter2PadPitchLength(0),
 334            fOuterPadPitchWidth(0),
 335            fOuter1PadLength(0.),
 336            fOuter2PadLength(0),
 337            fOuterPadWidth(0),
 338            fNRowLow(0),
 339            fNRowUp1(0),
 340            fNRowUp2(0),
 341            fNRowUp(0),
 342            fNtRows(0)
 343
 344 {
 345   //
 346   // AliTPCROC copy constructor
 347   //
 348   fNSectorsAll = roc.fNSectorsAll;
 349   fNSectors[0] = roc.fNSectors[0];
 350   fNSectors[1] = roc.fNSectors[1];
 351   fNRows[0]    = roc.fNRows[0];
 352   fNRows[1]    = roc.fNRows[1];
 353   fNChannels[0]= roc.fNChannels[0];
 354   fNChannels[1]= roc.fNChannels[1];
 355   //
 356   // number of pads in padrow
 357   fNPads[0] = new UInt_t[fNRows[0]];
 358   fNPads[1] = new UInt_t[fNRows[1]];
 359   //
 360   // padrow index in array
 361   //
 362   fRowPosIndex[0] = new UInt_t[fNRows[0]];
 363   fRowPosIndex[1] = new UInt_t[fNRows[1]];
 364   //
 365   for (UInt_t irow =0; irow<fNRows[0];irow++){
 366     fNPads[0][irow]       = roc.fNPads[0][irow];
 367     fRowPosIndex[0][irow] = roc.fRowPosIndex[0][irow];
 368   }
 369   for (UInt_t irow =0; irow<fNRows[1];irow++){
 370     fNPads[1][irow]       = roc.fNPads[1][irow];
 371     fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
 372   }
 373 }
 374 //____________________________________________________________________________
 375 AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
 376 {
 377   //
 378   // assignment operator - dummy
 379   //
 380   fZLength = roc.fZLength;
 381   return (*this);
 382 }
 383 //_____________________________________________________________________________
 384 AliTPCROC::~AliTPCROC()
 385 {
 386   //
 387   // AliTPCROC destructor
 388   //
 389   delete [] fNPads[0];
 390   delete [] fNPads[1];
 391   delete [] fRowPosIndex[0];
 392   delete [] fRowPosIndex[1];
 393   fgInstance = 0x0;
 394
 395 }
 396
 397
 398
 399
 400 void AliTPCROC::GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
 401   //
 402   // get position of center of pad - ideal frame used
 403   //
 404   pos[2]=fZLength;
 405   if (sector<36){
 406    pos[0] = fPadRowLow[row];
 407    pos[1] = fInnerPadPitchWidth*(Int_t(pad)-Int_t(fNPads[0][row])/2);
 408   }else{
 409     pos[0] = fPadRowUp[row];
 410     pos[1] = fOuterPadPitchWidth*(Int_t(pad)-Int_t(fNPads[1][row])/2);
 411   }
 412   if ((sector%36)>=18){
 413     pos[2] *= -1.;
 414     pos[1] *= -1.;
 415   }
 416 }
 417
 418
 419 void AliTPCROC::GetPositionGlobal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
 420   //
 421   // get position of center of pad - ideal frame used
 422   //
 423   GetPositionLocal(sector,row,pad,pos);
 424   Double_t alpha = TMath::DegToRad()*(10.+20.*(sector%18));
 425   Float_t gx = pos[0]*TMath::Cos(alpha)-pos[1]*TMath::Sin(alpha);
 426   Float_t gy = pos[1]*TMath::Cos(alpha)+pos[0]*TMath::Sin(alpha);
 427   pos[0] = gx;
 428   pos[1] = gy;
 429 }