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