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