TPC/AliTPCParam.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 //  Manager and of geomety  classes for set: TPC                     //
  20 //                                                                   //
  21 //  !sectors are numbered from  0                                     //
  22 //  !pad rows are numbered from 0                                     //
  23 //
  24 //  12.6.   changed z relative
  25 //  Origin:  Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk //
  26 //                                                                   //
  27 ///////////////////////////////////////////////////////////////////////
  28
  29 //
  30
  31 #include <AliTPCParam.h>
  32
  33 #include <TGeoManager.h>
  34 #include <TGeoPhysicalNode.h>
  35 #include "AliAlignObj.h"
  36 #include "AliAlignObjAngles.h"
  37 #include "AliLog.h"
  38
  39 ClassImp(AliTPCParam)
  40
  41
  42 //___________________________________________
  43 AliTPCParam::AliTPCParam()
  44 {
  45   //
  46   //constructor sets the default parameters
  47   //
  48
  49   fResponseBin = 0;
  50   fResponseWeight = 0;
  51   fRotAngle = 0;
  52   fTrackingMatrix = fClusterMatrix = fGlobalMatrix = 0;
  53   SetTitle("75x40_100x60_150x60");
  54   SetDefault();
  55 }
  56
  57 AliTPCParam::~AliTPCParam()
  58 {
  59   //
  60   //destructor deletes some dynamicaly alocated variables
  61   //
  62
  63   if (fResponseBin!=0)    delete [] fResponseBin;
  64   if (fResponseWeight!=0) delete [] fResponseWeight;
  65   if (fRotAngle      !=0) delete [] fRotAngle;
  66
  67   if (fTrackingMatrix) {
  68     for(Int_t i = 0; i < fNSector; i++)
  69       delete fTrackingMatrix[i];
  70     delete [] fTrackingMatrix;
  71   }
  72
  73   if (fClusterMatrix) {
  74     for(Int_t i = 0; i < fNSector; i++)
  75       delete fClusterMatrix[i];
  76     delete [] fClusterMatrix;
  77   }
  78
  79   if (fGlobalMatrix) {
  80     for(Int_t i = 0; i < fNSector; i++)
  81       delete fGlobalMatrix[i];
  82     delete [] fGlobalMatrix;
  83   }
  84
  85 }
  86
  87
  88
  89
  90 Int_t  AliTPCParam::Transform0to1(Float_t *xyz, Int_t * index)  const
  91 {
  92   //
  93   // calculates sector number (index[1], undefined on input)
  94   // xyz intact
  95   //
  96
  97   Float_t angle,x1;
  98   Int_t sector;
  99   Float_t r = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
 100   if ((xyz[0]==0)&&(xyz[1]==0)) angle = 0.;
 101   else
 102     {
 103       angle =TMath::ASin(xyz[1]/r);
 104       if   (xyz[0]<0)   angle=TMath::Pi()-angle;
 105       if ( (xyz[0]>0) && (xyz[1]<0) ) angle=2*TMath::Pi()+angle;
 106     }
 107
 108   sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
 109
 110   Float_t cos,sin;
 111   AdjustCosSin(sector,cos,sin);
 112   x1=xyz[0]*cos + xyz[1]*sin;
 113
 114   if (x1>fOuterRadiusLow)
 115     {
 116       sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
 117       if (xyz[2]<0)     sector+=(fNOuterSector>>1);
 118     }
 119     else
 120       if (xyz[2]<0) sector+=(fNInnerSector>>1);
 121   index[1]=sector; // calculated sector number
 122   index[0]=1; // indicates system after transformation
 123   return sector;
 124 }
 125
 126 Bool_t  AliTPCParam::Transform(Float_t */*xyz*/, Int_t *index, Int_t* /*oindex*/)
 127 {
 128   //transformation from input coodination system to output coordination system
 129   switch (index[0]){
 130   case 0:
 131     break;
 132   };
 133
 134   return kFALSE;
 135
 136 }
 137
 138 Int_t AliTPCParam::GetPadRow(Float_t *xyz, Int_t *index) const
 139 {
 140   //
 141   //calculates pad row of point xyz - transformation to system 8 (digit system)
 142   //
 143   Int_t system = index[0];
 144   if (0==system) {
 145     Transform0to1(xyz,index);
 146     system=1;
 147   }
 148   if (1==system) {
 149     Transform1to2(xyz,index);
 150     system=2;
 151   }
 152
 153   if (fGeometryType==0){ //straight row
 154     if (2==system) {
 155       Transform2to3(xyz,index);
 156       system=3;
 157     }
 158     if (3==system) {
 159       Transform3to4(xyz,index);
 160       system=4;
 161     }
 162     if (4==system) {
 163       Transform4to8(xyz,index);
 164       system=8;
 165     }
 166     if (8==system) {
 167       index[0]=8;
 168       return index[2];
 169     }
 170   }
 171
 172   if (fGeometryType==1){ //cylindrical geometry
 173     if (2==system) {
 174       Transform2to5(xyz,index);
 175       system=5;
 176     }
 177     if (5==system) {
 178       Transform2to3(xyz,index);
 179       system=6;
 180     }
 181     if (6==system) {
 182       Transform3to4(xyz,index);
 183       system=7;
 184     }
 185     if (8==system) {
 186       index[0]=8;
 187       return index[2];
 188     }
 189   }
 190   index[0]=system;
 191   return -1; //if no reasonable system
 192 }
 193
 194 void  AliTPCParam::SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle,
 195                         Float_t outershift)
 196 {
 197   //
 198   // set opening angles
 199   static const  Float_t  kDegtoRad = 0.01745329251994;
 200   fInnerAngle = innerangle;       //opening angle of Inner sector
 201   fInnerAngleShift = innershift;  //shift of first inner sector center to the 0
 202   fOuterAngle = outerangle;       //opening angle of outer sector
 203   fOuterAngleShift = outershift;  //shift of first sector center to the 0
 204   fInnerAngle *=kDegtoRad;
 205   fInnerAngleShift *=kDegtoRad;
 206   fOuterAngle *=kDegtoRad;
 207   fOuterAngleShift *=kDegtoRad;
 208 }
 209
 210 Float_t  AliTPCParam::GetInnerAngle() const
 211 {
 212   //return angle
 213   return fInnerAngle;
 214
 215 }
 216
 217 Float_t  AliTPCParam::GetInnerAngleShift() const
 218 {
 219   //return angle
 220   return fInnerAngleShift;
 221 }
 222 Float_t  AliTPCParam::GetOuterAngle() const
 223 {
 224   //return angle
 225   return fOuterAngle;
 226 }
 227 Float_t  AliTPCParam::GetOuterAngleShift() const
 228 {
 229   //return angle
 230
 231      return fOuterAngleShift;
 232 }
 233
 234
 235 Int_t AliTPCParam::GetIndex(Int_t sector, Int_t row) const
 236 {
 237   //
 238   //give index of the given sector and pad row
 239   //no control if the sectors and rows  are reasonable !!!
 240   //
 241   if (sector<fNInnerSector) return sector*fNRowLow+row;
 242   return (fNInnerSector*fNRowLow)+(sector-fNInnerSector)*fNRowUp+row;
 243 }
 244
 245 Bool_t   AliTPCParam::AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const
 246 {
 247   //
 248   //return sector and padrow for given index
 249   //if index is reasonable returns true else return false
 250   //
 251   if ( (index<0) || (index>fNtRows))  return kFALSE;
 252   Int_t outindex = fNInnerSector*fNRowLow;
 253   if (index<outindex) {
 254     sector = index/fNRowLow;
 255     row    = index - sector*fNRowLow;
 256     return kTRUE;
 257   }
 258   index-= outindex;
 259   sector = index/fNRowUp;
 260   row    = index - sector*fNRowUp;
 261   sector += fNInnerSector;
 262   return kTRUE;
 263 }
 264
 265 void AliTPCParam::SetDefault()
 266 {
 267   //
 268   //set default parameters
 269   //
 270   //const static  Int_t kMaxRows=600;
 271   //
 272   //sector default parameters
 273   //
 274   static const  Float_t kInnerRadiusLow = 83.65;
 275   static const  Float_t kInnerRadiusUp  = 133.3;
 276   static const  Float_t kOuterRadiusLow = 133.5;
 277   static const  Float_t kOuterRadiusUp  = 247.7;
 278   static const  Float_t kInnerAngle = 20; // 20 degrees
 279   static const  Float_t kInnerAngleShift = 10;
 280   static const  Float_t kOuterAngle = 20; //  20 degrees
 281   static const  Float_t kOuterAngleShift = 10;
 282   static const  Float_t kInnerFrameSpace = 1.5;
 283   static const  Float_t kOuterFrameSpace = 1.5;
 284   static const  Float_t kInnerWireMount = 1.2;
 285   static const  Float_t kOuterWireMount = 1.4;
 286   static const  Float_t kZLength =250.;
 287   static const  Int_t   kGeometryType = 0; //straight rows
 288   static const Int_t kNRowLow = 63;
 289   static const Int_t kNRowUp1 = 64;
 290   static const Int_t kNRowUp2 = 32;
 291   static const Int_t  kNRowUp = 96;
 292   //
 293   //wires default parameters
 294   //
 295   static const Int_t    kNInnerWiresPerPad = 3;
 296   static const Int_t    kInnerDummyWire = 2;
 297   static const Float_t  kInnerWWPitch = 0.25;
 298   static const Float_t  kRInnerFirstWire = 84.475;
 299   static const Float_t  kRInnerLastWire = 132.475;
 300   static const Float_t  kInnerOffWire = 0.5;
 301   static const Int_t    kNOuter1WiresPerPad = 4;
 302   static const Int_t    kNOuter2WiresPerPad = 6;
 303   static const Float_t  kOuterWWPitch = 0.25;
 304   static const Float_t  kROuterFirstWire = 134.225;
 305   static const Float_t  kROuterLastWire = 246.975;
 306   static const Int_t    kOuterDummyWire = 2;
 307   static const Float_t  kOuterOffWire = 0.5;
 308   //
 309   //pad default parameters
 310   //
 311   static const Float_t  kInnerPadPitchLength = 0.75;
 312   static const Float_t  kInnerPadPitchWidth = 0.40;
 313   static const Float_t  kInnerPadLength = 0.75;
 314   static const Float_t  kInnerPadWidth = 0.40;
 315   static const Float_t  kOuter1PadPitchLength = 1.0;
 316   static const Float_t  kOuterPadPitchWidth = 0.6;
 317   static const Float_t  kOuter1PadLength = 1.0;
 318   static const Float_t  kOuterPadWidth = 0.6;
 319   static const Float_t  kOuter2PadPitchLength = 1.5;
 320   static const Float_t  kOuter2PadLength = 1.5;
 321
 322   static const Bool_t   kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM
 323   static const Int_t    kNCrossRows = 1; //number of rows to cross-talk
 324
 325   //
 326   //gas default parameters
 327   //
 328   static const  Float_t  kDiffT = 2.2e-2;
 329   static const  Float_t  kDiffL = 2.2e-2;
 330   static const  Float_t  kGasGain = 2.e4;
 331   static const  Float_t  kDriftV  =2.83e6;
 332   static const  Float_t  kOmegaTau = 0.145;
 333   static const  Float_t  kAttCoef = 250.;
 334   static const  Float_t  kOxyCont = 5.e-6;
 335   //
 336   //electronic default parameters
 337   //
 338   static const  Float_t  kPadCoupling=0.5;
 339   static const  Int_t    kZeroSup=2;
 340   static const  Float_t  kNoise = 1000;
 341   static const  Float_t  kChipGain = 12;
 342   static const  Float_t  kChipNorm = 0.4;
 343   static const  Float_t  kTSample = 2.e-7;
 344   static const  Float_t  kTFWHM   = 1.9e-7;  //fwhm of charge distribution
 345   static const  Int_t    kMaxTBin =445;
 346   static const  Int_t    kADCSat  =1024;
 347   static const  Float_t  kADCDynRange =2000.;
 348   //
 349   //response constants
 350   //
 351   static const Int_t     kNResponseMax=100;
 352   static const Float_t   kResponseThreshold=0.01;
 353   //L1 constants
 354   //  static const Float_t   kGateDelay=6.1e-6; //In s
 355   static const Float_t   kGateDelay=0.; //For the moment no gating
 356   //  static const Float_t   kL1Delay=6.5e-6; //In s
 357   static const Float_t   kL1Delay=0.; //For the moment no delay
 358   //  static const UShort_t  kNTBinsBeforeL1=14;
 359   static const UShort_t  kNTBinsBeforeL1=0; //For the moment no shift
 360   fbStatus = kFALSE;
 361   //
 362   //set sector parameters
 363   //
 364   SetInnerRadiusLow(kInnerRadiusLow);
 365   SetOuterRadiusLow(kOuterRadiusLow);
 366   SetInnerRadiusUp(kInnerRadiusUp);
 367   SetOuterRadiusUp(kOuterRadiusUp);
 368   SetInnerFrameSpace(kInnerFrameSpace);
 369   SetOuterFrameSpace(kOuterFrameSpace);
 370   SetInnerWireMount(kInnerWireMount);
 371   SetOuterWireMount(kOuterWireMount);
 372   SetSectorAngles(kInnerAngle,kInnerAngleShift,kOuterAngle,kOuterAngleShift);
 373   SetZLength(kZLength);
 374   SetGeometryType(kGeometryType);
 375   SetRowNLow(kNRowLow);
 376   SetRowNUp1 (kNRowUp1);
 377   SetRowNUp2(kNRowUp2);
 378   SetRowNUp(kNRowUp);
 379   //
 380   //set wire parameters
 381   //
 382   SetInnerNWires(kNInnerWiresPerPad);
 383   SetInnerDummyWire(kInnerDummyWire);
 384   SetInnerOffWire(kInnerOffWire);
 385   SetOuter1NWires(kNOuter1WiresPerPad);
 386   SetOuter2NWire(kNOuter2WiresPerPad);
 387   SetOuterDummyWire(kOuterDummyWire);
 388   SetOuterOffWire(kOuterOffWire);
 389   SetInnerWWPitch(kInnerWWPitch);
 390   SetRInnerFirstWire(kRInnerFirstWire);
 391   SetRInnerLastWire(kRInnerLastWire);
 392   SetOuterWWPitch(kOuterWWPitch);
 393   SetROuterFirstWire(kROuterFirstWire);
 394   SetROuterLastWire(kROuterLastWire);
 395   //
 396   //set pad parameter
 397   //
 398   SetInnerPadPitchLength(kInnerPadPitchLength);
 399   SetInnerPadPitchWidth(kInnerPadPitchWidth);
 400   SetInnerPadLength(kInnerPadLength);
 401   SetInnerPadWidth(kInnerPadWidth);
 402   SetOuter1PadPitchLength(kOuter1PadPitchLength);
 403   SetOuter2PadPitchLength(kOuter2PadPitchLength);
 404   SetOuterPadPitchWidth(kOuterPadPitchWidth);
 405   SetOuter1PadLength(kOuter1PadLength);
 406   SetOuter2PadLength(kOuter2PadLength);
 407   SetOuterPadWidth(kOuterPadWidth);
 408   SetMWPCReadout(kBMWPCReadout);
 409   SetNCrossRows(kNCrossRows);
 410   //
 411   //set gas paremeters
 412   //
 413   SetDiffT(kDiffT);
 414   SetDiffL(kDiffL);
 415   SetGasGain(kGasGain);
 416   SetDriftV(kDriftV);
 417   SetOmegaTau(kOmegaTau);
 418   SetAttCoef(kAttCoef);
 419   SetOxyCont(kOxyCont);
 420   //
 421   //set electronivc parameters
 422   //
 423   SetPadCoupling(kPadCoupling);
 424   SetZeroSup(kZeroSup);
 425   SetNoise(kNoise);
 426   SetChipGain(kChipGain);
 427   SetChipNorm(kChipNorm);
 428   SetTSample(kTSample);
 429   SetTFWHM(kTFWHM);
 430   SetMaxTBin(kMaxTBin);
 431   SetADCSat(kADCSat);
 432   SetADCDynRange(kADCDynRange);
 433 //   //set magnetic field
 434 //   SetBField(kBField);
 435 //   SetNPrimLoss(kNPrimLoss);
 436 //   SetNTotalLoss(kNTotalLoss);
 437   //
 438   //set response  parameters
 439   //
 440   SetNResponseMax(kNResponseMax);
 441   SetResponseThreshold(static_cast<int>(kResponseThreshold));
 442   //L1 data
 443   SetGateDelay(kGateDelay);
 444   SetL1Delay(kL1Delay);
 445   SetNTBinsBeforeL1(kNTBinsBeforeL1);
 446 }
 447
 448
 449 Bool_t AliTPCParam::Update()
 450 {
 451   //
 452   // update some calculated parameter which must be updated after changing "base"
 453   // parameters
 454   // for example we can change size of pads and according this recalculate number
 455   // of pad rows, number of of pads in given row ....
 456   //
 457   const Float_t kQel = 1.602e-19; // elementary charge
 458   fbStatus = kFALSE;
 459
 460   Int_t i,j;  //loop variables because HP
 461   //-----------------Sector section------------------------------------------
 462   //calclulate number of sectors
 463   fNInnerSector = Int_t(4*TMath::Pi()/fInnerAngle+0.2);
 464        // number of inner sectors - factor 0.2 to don't be influnced by inprecision
 465   if (fNInnerSector%2) return kFALSE;
 466   fNOuterSector = Int_t(4*TMath::Pi()/fOuterAngle+0.2);
 467   if (fNOuterSector%2) return kFALSE;
 468   fNSector  = fNInnerSector+fNOuterSector;
 469
 470   if (fRotAngle!=0) delete [] fRotAngle;
 471   fRotAngle = new Float_t[4*fNSector];
 472   //calculate sin and cosine of rotations angle
 473   //sectors angles numbering from 0
 474
 475   j=fNInnerSector*2;
 476   Float_t angle = fInnerAngleShift;
 477   for (i=0; j<fNInnerSector*4; i+=4, j+=4 , angle +=fInnerAngle){
 478     fRotAngle[i]=TMath::Cos(angle);
 479     fRotAngle[i+1]=TMath::Sin(angle);
 480     fRotAngle[j] =  fRotAngle[i];
 481     fRotAngle[j+1] =  fRotAngle[i+1];
 482     fRotAngle[i+2] =angle;
 483     fRotAngle[j+2] =angle;
 484   }
 485   angle = fOuterAngleShift;
 486   j=(fNInnerSector+fNOuterSector/2)*4;
 487   for (i=fNInnerSector*4; j<fNSector*4; i+=4,j+=4, angle +=fOuterAngle){
 488     fRotAngle[i]=TMath::Cos(angle);
 489     fRotAngle[i+1]=TMath::Sin(angle);
 490     fRotAngle[j] =  fRotAngle[i];
 491     fRotAngle[j+1] =  fRotAngle[i+1];
 492     fRotAngle[i+2] =angle;
 493     fRotAngle[j+2] =angle;
 494   }
 495
 496   fZWidth = fTSample*fDriftV;
 497   fTotalNormFac = fPadCoupling*fChipNorm*kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
 498   fNoiseNormFac = kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
 499   //wire section
 500   /*  Int_t nwire;
 501   Float_t wspace; //available space for wire
 502   Float_t dummyspace; //dummyspace for wire
 503
 504   wspace =fInnerRadiusUp-fInnerRadiusLow-2*fInnerOffWire;
 505   nwire = Int_t(wspace/fInnerWWPitch);
 506   wspace = Float_t(nwire)*fInnerWWPitch;
 507   dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.;
 508   wspace =fOuterRadiusUp-fOuterRadiusLow-2*fOuterOffWire;
 509   nwire = Int_t(wspace/fOuterWWPitch);
 510   wspace = Float_t(nwire)*fOuterWWPitch;
 511   dummyspace =(fOuterRadiusUp-fOuterRadiusLow-wspace)/2.;
 512   fROuterFirstWire = fOuterRadiusLow+dummyspace;
 513   fROuterLastWire = fROuterFirstWire+fOuterWWPitch*(Float_t)(nwire);
 514   */
 515
 516   //
 517   //response data
 518   //
 519   if (fResponseBin==0) delete [] fResponseBin;
 520   if (fResponseWeight==0) delete [] fResponseBin;
 521   fResponseBin    = new Int_t[3*fNResponseMax];
 522   fResponseWeight = new Float_t[fNResponseMax];
 523
 524   //L1 data
 525   fNTBinsL1 = fL1Delay/fTSample - (Float_t)fNTBinsBeforeL1;
 526   fbStatus = kTRUE;
 527   return kTRUE;
 528 }
 529
 530
 531
 532 Bool_t AliTPCParam::ReadGeoMatrices(){
 533   //
 534   // read geo matrixes
 535   //
 536   if (!gGeoManager){
 537     AliFatal("Geo manager not initialized\n");
 538   }
 539   AliAlignObjAngles o;
 540   //
 541   if (fTrackingMatrix) delete [] fTrackingMatrix;
 542   fTrackingMatrix = new TGeoHMatrix*[fNSector];
 543   if (fClusterMatrix) delete [] fClusterMatrix;
 544   fClusterMatrix = new TGeoHMatrix*[fNSector];
 545   if (fGlobalMatrix) delete [] fGlobalMatrix;
 546   fGlobalMatrix = new TGeoHMatrix*[fNSector];
 547   //
 548   for (Int_t isec=0; isec<fNSector; isec++) {
 549     fGlobalMatrix[isec] = 0;
 550     fClusterMatrix[isec]= 0;
 551     fTrackingMatrix[isec]=0;
 552     AliAlignObj::ELayerID iLayer;
 553     Int_t iModule;
 554
 555     if(isec<fNInnerSector) {
 556       iLayer = AliAlignObj::kTPC1;
 557       iModule = isec;
 558     }
 559     else {
 560       iLayer = AliAlignObj::kTPC2;
 561       iModule = isec - fNInnerSector;
 562     }
 563
 564     UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
 565     const char *symname = AliAlignObj::SymName(volid);
 566     TGeoPNEntry* pne = gGeoManager->GetAlignableEntry(symname);
 567     const char *path = symname;
 568     if(pne) path=pne->GetTitle();
 569     if (!gGeoManager->cd(path)) return kFALSE;
 570     TGeoHMatrix *m = gGeoManager->GetCurrentMatrix();
 571
 572     //
 573     TGeoRotation mchange;
 574     mchange.RotateY(90); mchange.RotateX(90);
 575     Float_t ROCcenter[3];
 576     GetChamberCenter(isec,ROCcenter);
 577     //
 578     // Convert to global coordinate system
 579     //
 580     fGlobalMatrix[isec] = new TGeoHMatrix(*m);
 581     fGlobalMatrix[isec]->Multiply(&(mchange.Inverse()));
 582     TGeoTranslation center("center",-ROCcenter[0],-ROCcenter[1],-ROCcenter[2]);
 583     fGlobalMatrix[isec]->Multiply(&center);
 584     //
 585     //  cluster correction matrix
 586     //
 587     fClusterMatrix[isec] = new TGeoHMatrix;
 588     Double_t sectorAngle = 20.*(isec%18)+10;
 589     TGeoHMatrix  rotMatrix;
 590     rotMatrix.RotateZ(sectorAngle);
 591     if (GetGlobalMatrix(isec)->GetTranslation()[2]>0){
 592       //
 593       // mirrored system
 594       //
 595       TGeoRotation mirrorZ;
 596       mirrorZ.SetAngles(90,0,90,90,180,0);
 597       fClusterMatrix[isec]->Multiply(&mirrorZ);
 598     }
 599     TGeoTranslation trans(0,0,GetZLength());
 600     fClusterMatrix[isec]->MultiplyLeft(&trans);
 601     fClusterMatrix[isec]->MultiplyLeft((GetGlobalMatrix(isec)));
 602     fClusterMatrix[isec]->MultiplyLeft(&(rotMatrix.Inverse()));
 603   }
 604   return kTRUE;
 605 }
 606
 607
 608 Bool_t AliTPCParam::GetStatus() const
 609 {
 610   //get information about object consistency
 611   return fbStatus;
 612 }
 613
 614 Int_t AliTPCParam::GetNRowLow() const
 615 {
 616   //get the number of pad rows in low sector
 617   return fNRowLow;
 618 }
 619 Int_t AliTPCParam::GetNRowUp() const
 620 {
 621   //get the number of pad rows in up sector
 622   return fNRowUp;
 623 }
 624 Int_t AliTPCParam::GetNRowUp1() const
 625 {
 626   //get the number of pad rows in up1 sector
 627   return fNRowUp1;
 628 }
 629 Int_t AliTPCParam::GetNRowUp2() const
 630 {
 631   //get the number of pad rows in up2 sector
 632   return fNRowUp2;
 633 }
 634 Float_t AliTPCParam::GetPadRowRadiiLow(Int_t irow) const
 635 {
 636   //get the pad row (irow) radii
 637   if ( !(irow<0) && (irow<fNRowLow) )
 638     return  fPadRowLow[irow];
 639   else
 640     return 0;
 641 }
 642
 643 Float_t AliTPCParam::GetPadRowRadiiUp(Int_t irow) const
 644 {
 645   //get the pad row (irow) radii
 646  if ( !(irow<0) && (irow<fNRowUp) )
 647     return  fPadRowUp[irow];
 648   else
 649     return 0;
 650 }
 651
 652 Int_t AliTPCParam::GetNPadsLow(Int_t irow) const
 653 {
 654   //get the number of pads in row irow
 655   if ( !(irow<0) && (irow<fNRowLow) )
 656     return  fNPadsLow[irow];
 657   else
 658     return 0;
 659 }
 660
 661
 662 Int_t AliTPCParam::GetNPadsUp(Int_t irow) const
 663 {
 664   //get the number of pads in row irow
 665   if ( !(irow<0) && (irow<fNRowUp) )
 666     return  fNPadsUp[irow];
 667   else
 668     return 0;
 669 }
 670 Float_t AliTPCParam::GetYInner(Int_t irow) const
 671 {
 672   return fYInner[irow];
 673 }
 674
 675
 676 Float_t AliTPCParam::GetYOuter(Int_t irow) const
 677 {
 678   return fYOuter[irow];
 679 }
 680
 681 Int_t AliTPCParam::GetSectorIndex(Float_t angle, Int_t row, Float_t z) const
 682 {
 683   // returns the sector index
 684   // takes as input the angle, index of the pad row and z position
 685   if(row<0) return -1;
 686
 687   if (angle > 2.*TMath::Pi()) angle -= 2.*TMath::Pi();
 688   if (angle < 0.            ) angle += 2.*TMath::Pi();
 689
 690   Int_t sector;
 691   if(row<fNRowLow) {
 692     sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
 693     if (z<0) sector += (fNInnerSector>>1);
 694   }
 695   else {
 696     sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
 697     if (z<0) sector += (fNOuterSector>>1);
 698   }
 699
 700   return sector;
 701 }
 702
 703 Float_t AliTPCParam::GetChamberCenter(Int_t isec, Float_t * center) const
 704 {
 705   // returns the default radial position
 706   // of the readout chambers
 707
 708   const Float_t kROCcenterIn = 110.2;
 709   const Float_t kROCcenterOut = 188.45;
 710
 711   if (isec<fNInnerSector){
 712     if (center){
 713       center[0] = kROCcenterIn;
 714       center[1] = 0;
 715       center[2] = -5.51;
 716     }
 717     return kROCcenterIn;
 718   }
 719   else{
 720     if (center){
 721       center[0] = kROCcenterOut;
 722       center[1] = 0;
 723       center[2] = -5.61;
 724     }
 725     return kROCcenterOut;
 726   }
 727 }
 728
 729
 730