965c6e5bf7cc1e79ce1ef74abf73cf23eaa69d35
[u/mrichter/AliRoot.git] / TRD / AliTRDgeometry.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 //  TRD geometry class                                                       //
21 //                                                                           //
22 ///////////////////////////////////////////////////////////////////////////////
23
24
25 #include <TError.h>
26 #include <TGeoManager.h>
27 #include <TGeoPhysicalNode.h>
28 #include <TGeoMatrix.h>
29
30
31 #include "AliRunLoader.h"
32 #include "AliTRDgeometry.h"
33 #include "AliTRDpadPlane.h"
34
35 #include "AliAlignObj.h"
36 #include "AliAlignObjAngles.h"
37
38 #include "AliRun.h"
39 #include "AliTRD.h"
40 #include "AliTRDcalibDB.h"
41 #include "AliTRDCommonParam.h"
42
43 ClassImp(AliTRDgeometry)
44
45 //_____________________________________________________________________________
46
47   //
48   // The geometry constants
49   //
50   const Int_t   AliTRDgeometry::fgkNsect   = kNsect;
51   const Int_t   AliTRDgeometry::fgkNplan   = kNplan;
52   const Int_t   AliTRDgeometry::fgkNcham   = kNcham;
53   const Int_t   AliTRDgeometry::fgkNdet    = kNdet;
54
55   //
56   // Dimensions of the detector
57   //
58
59   // Inner and outer radius of the mother volumes 
60   const Float_t AliTRDgeometry::fgkRmin    = 294.0;
61   const Float_t AliTRDgeometry::fgkRmax    = 368.0;
62
63   // Upper and lower length of the mother volumes 
64   const Float_t AliTRDgeometry::fgkZmax1   = 378.35; 
65   const Float_t AliTRDgeometry::fgkZmax2   = 302.0; 
66
67   // Parameter of the BTR mother volumes 
68   const Float_t AliTRDgeometry::fgkSheight =  77.9; 
69   const Float_t AliTRDgeometry::fgkSwidth1 =  94.881; 
70   const Float_t AliTRDgeometry::fgkSwidth2 = 122.353;
71   const Float_t AliTRDgeometry::fgkSlenTR1 = 751.0;
72   const Float_t AliTRDgeometry::fgkSlenTR2 = 313.5; 
73   const Float_t AliTRDgeometry::fgkSlenTR3 = 159.5;  
74
75   // The super module side plates
76   const Float_t AliTRDgeometry::fgkSMpltT  =   0.2;
77   //const Float_t AliTRDgeometry::fgkSMgapT  =   0.5;  
78
79   // Height of different chamber parts
80   // Radiator
81   const Float_t AliTRDgeometry::fgkCraH    =   4.8; 
82   // Drift region
83   const Float_t AliTRDgeometry::fgkCdrH    =   3.0;
84   // Amplification region
85   const Float_t AliTRDgeometry::fgkCamH    =   0.7;
86   // Readout
87   const Float_t AliTRDgeometry::fgkCroH    =   2.316;
88   // Total height
89   const Float_t AliTRDgeometry::fgkCH      = AliTRDgeometry::fgkCraH
90                                            + AliTRDgeometry::fgkCdrH
91                                            + AliTRDgeometry::fgkCamH
92                                            + AliTRDgeometry::fgkCroH;  
93
94   // Vertical spacing of the chambers
95   const Float_t AliTRDgeometry::fgkVspace  =   1.784;
96
97   // Horizontal spacing of the chambers
98   const Float_t AliTRDgeometry::fgkHspace  =   2.0;
99
100   // Radial distance of the first ROC to the outer plates of the SM
101   const Float_t AliTRDgeometry::fgkVrocsm  =   1.2;
102
103   // Thicknesses of different parts of the chamber frame
104   // Lower aluminum frame
105   const Float_t AliTRDgeometry::fgkCalT    =   0.3;
106   // Lower G10 frame sides
107   const Float_t AliTRDgeometry::fgkCclsT   =   0.3;
108   // Lower G10 frame front
109   const Float_t AliTRDgeometry::fgkCclfT   =   1.0;
110   // Upper G10 frame
111   const Float_t AliTRDgeometry::fgkCcuT    =   0.9;
112   // Upper Al frame
113   const Float_t AliTRDgeometry::fgkCauT    =   1.5;
114
115   // Additional width of the readout chamber frames
116   const Float_t AliTRDgeometry::fgkCroW    =   0.9;
117
118   // Difference of outer chamber width and pad plane width
119   //const Float_t AliTRDgeometry::fgkCpadW   =   1.0;
120   const Float_t AliTRDgeometry::fgkCpadW   =   0.0;
121   const Float_t AliTRDgeometry::fgkRpadW   =   1.0;
122
123   //
124   // Thickness of the the material layers
125   //
126   const Float_t AliTRDgeometry::fgkRaThick = 0.3646;  
127   const Float_t AliTRDgeometry::fgkMyThick = 0.005;
128   const Float_t AliTRDgeometry::fgkDrThick = AliTRDgeometry::fgkCdrH;    
129   const Float_t AliTRDgeometry::fgkAmThick = AliTRDgeometry::fgkCamH;
130   const Float_t AliTRDgeometry::fgkXeThick = AliTRDgeometry::fgkDrThick
131                                            + AliTRDgeometry::fgkAmThick;
132   const Float_t AliTRDgeometry::fgkCuThick = 0.0072; 
133   const Float_t AliTRDgeometry::fgkSuThick = 0.06; 
134   const Float_t AliTRDgeometry::fgkFeThick = 0.0044; 
135   const Float_t AliTRDgeometry::fgkCoThick = 0.02;
136   const Float_t AliTRDgeometry::fgkWaThick = 0.02;
137   const Float_t AliTRDgeometry::fgkRcThick = 0.0058;
138   const Float_t AliTRDgeometry::fgkRpThick = 0.0632;
139
140   //
141   // Position of the material layers
142   //
143   const Float_t AliTRDgeometry::fgkRaZpos  = -1.50;
144   const Float_t AliTRDgeometry::fgkMyZpos  =  0.895;
145   const Float_t AliTRDgeometry::fgkDrZpos  =  2.4;
146   const Float_t AliTRDgeometry::fgkAmZpos  =  0.0;
147   const Float_t AliTRDgeometry::fgkCuZpos  = -0.9995;
148   const Float_t AliTRDgeometry::fgkSuZpos  =  0.0000;
149   const Float_t AliTRDgeometry::fgkFeZpos  =  0.0322;
150   const Float_t AliTRDgeometry::fgkCoZpos  =  0.97;
151   const Float_t AliTRDgeometry::fgkWaZpos  =  0.99;
152   const Float_t AliTRDgeometry::fgkRcZpos  =  1.04;
153   const Float_t AliTRDgeometry::fgkRpZpos  =  1.0;
154   
155   const Double_t AliTRDgeometry::fgkTime0Base = Rmin() + CraHght() + CdrHght() + CamHght()/2.;
156   const Float_t  AliTRDgeometry::fgkTime0[6]  = { fgkTime0Base + 0 * (Cheight() + Cspace()), 
157                                                   fgkTime0Base + 1 * (Cheight() + Cspace()), 
158                                                   fgkTime0Base + 2 * (Cheight() + Cspace()), 
159                                                   fgkTime0Base + 3 * (Cheight() + Cspace()), 
160                                                   fgkTime0Base + 4 * (Cheight() + Cspace()), 
161                                                   fgkTime0Base + 5 * (Cheight() + Cspace()) };
162
163 //_____________________________________________________________________________
164 AliTRDgeometry::AliTRDgeometry():AliGeometry()
165 {
166   //
167   // AliTRDgeometry default constructor
168   //
169
170   fMatrixArray           = 0;
171   fMatrixCorrectionArray = 0;
172
173   Init();
174
175 }
176
177 //_____________________________________________________________________________
178 AliTRDgeometry::~AliTRDgeometry()
179 {
180   //
181   // AliTRDgeometry destructor
182   //
183
184   delete fMatrixArray;
185   delete fMatrixCorrectionArray;
186
187 }
188
189 //_____________________________________________________________________________
190 void AliTRDgeometry::Init()
191 {
192   //
193   // Initializes the geometry parameter
194   //
195   // The maximum number of pads
196   // and the position of pad 0,0,0 
197   // 
198   // chambers seen from the top:
199   //     +----------------------------+
200   //     |                            |
201   //     |                            |      ^
202   //     |                            |  rphi|
203   //     |                            |      |
204   //     |0                           |      | 
205   //     +----------------------------+      +------>
206   //                                             z 
207   // chambers seen from the side:            ^
208   //     +----------------------------+ drift|
209   //     |0                           |      |
210   //     |                            |      |
211   //     +----------------------------+      +------>
212   //                                             z
213   //                                             
214   // IMPORTANT: time bin 0 is now the first one in the drift region 
215   // closest to the readout !!!
216   //
217
218   Int_t icham;
219   Int_t iplan;
220   Int_t isect;
221
222   // The outer width of the chambers
223   fCwidth[0] =  90.4;
224   fCwidth[1] =  94.8;
225   fCwidth[2] =  99.3;
226   fCwidth[3] = 103.7;
227   fCwidth[4] = 108.1;
228   fCwidth[5] = 112.6;
229
230   // The outer lengths of the chambers
231   // Includes the spacings between the chambers!
232   Float_t length[kNplan][kNcham]   = { { 124.0, 124.0, 110.0, 124.0, 124.0 }
233                                      , { 124.0, 124.0, 110.0, 124.0, 124.0 }
234                                      , { 131.0, 131.0, 110.0, 131.0, 131.0 }
235                                      , { 138.0, 138.0, 110.0, 138.0, 138.0 }
236                                      , { 145.0, 145.0, 110.0, 145.0, 145.0 }
237                                      , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
238
239   for (icham = 0; icham < kNcham; icham++) {
240     for (iplan = 0; iplan < kNplan; iplan++) {
241       fClength[iplan][icham]   = length[iplan][icham];
242     }
243   }
244
245   // The rotation matrix elements
246   Float_t phi = 0;
247   for (isect = 0; isect < fgkNsect; isect++) {
248     phi = -2.0 * TMath::Pi() /  (Float_t) fgkNsect * ((Float_t) isect + 0.5);
249     fRotA11[isect] = TMath::Cos(phi);
250     fRotA12[isect] = TMath::Sin(phi);
251     fRotA21[isect] = TMath::Sin(phi);
252     fRotA22[isect] = TMath::Cos(phi);
253     phi = -1.0 * phi;
254     fRotB11[isect] = TMath::Cos(phi);
255     fRotB12[isect] = TMath::Sin(phi);
256     fRotB21[isect] = TMath::Sin(phi);
257     fRotB22[isect] = TMath::Cos(phi);
258   }
259
260   for (isect = 0; isect < fgkNsect; isect++) {
261     SetSMstatus(isect,1);
262   }
263  
264 }
265
266 //_____________________________________________________________________________
267 void AliTRDgeometry::CreateGeometry(Int_t *idtmed)
268 {
269   //
270   // Create the TRD geometry without hole
271   //
272   //
273   // Names of the TRD volumina (xx = detector number):
274   //
275   //      Volume (Air) wrapping the readout chamber components
276   //        UTxx    includes: UAxx, UDxx, UFxx, UUxx
277   //      Obs:
278   //        UUxx    the services volume has been reduced by 7.42 mm
279   //                in order to allow shifts in radial direction
280   //
281   //      Lower part of the readout chambers (gas volume + radiator)
282   //
283   //        UAxx    Aluminum frames             (Al)
284   //        UBxx    G10 frames                  (C)
285   //        UCxx    Inner volumes               (Air)
286   //
287   //      Upper part of the readout chambers (readout plane + fee)
288   //
289   //        UDxx    G10 frames                  (C)
290   //        UExx    Inner volumes of the G10    (Air)
291   //        UFxx    Aluminum frames             (Al)
292   //        UGxx    Inner volumes of the Al     (Air)
293   //
294   //      Inner material layers
295   //
296   //        UHxx    Radiator                    (Rohacell)
297   //        UIxx    Entrance window             (Mylar)
298   //        UJxx    Drift volume                (Xe/CO2)
299   //        UKxx    Amplification volume        (Xe/CO2)
300   //        ULxx    Pad plane                   (Cu)
301   //        UMxx    Support structure           (Rohacell)
302   //        UNxx    ROB base material           (C)
303   //        UOxx    ROB copper                  (Cu)
304   //
305
306   const Int_t kNparTrd = 4;
307   const Int_t kNparCha = 3;
308
309   Float_t xpos, ypos, zpos;
310
311   Float_t parTrd[kNparTrd];
312   Float_t parCha[kNparCha];
313
314   Char_t  cTagV[6];
315   Char_t  cTagM[5];
316
317   // The TRD mother volume for one sector (Air), full length in z-direction
318   // Provides material for side plates of super module
319   parTrd[0] = fgkSwidth1/2.;
320   parTrd[1] = fgkSwidth2/2.;
321   parTrd[2] = fgkSlenTR1/2.;
322   parTrd[3] = fgkSheight/2.;
323   gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
324
325   // 
326   // The outer aluminum plates of the super module (Al)
327   parTrd[0] = fgkSwidth1/2.;
328   parTrd[1] = fgkSwidth2/2.;
329   parTrd[2] = fgkSlenTR1/2.;
330   parTrd[3] = fgkSheight/2.;
331   gMC->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
332
333   // The inner part of the TRD mother volume for one sector (Air), 
334   // full length in z-direction
335   parTrd[0] = fgkSwidth1/2. - fgkSMpltT;
336   parTrd[1] = fgkSwidth2/2. - fgkSMpltT;
337   parTrd[2] = fgkSlenTR1/2.;
338   parTrd[3] = fgkSheight/2. - fgkSMpltT;
339   gMC->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
340
341   for (Int_t icham = 0; icham < kNcham; icham++) {
342     for (Int_t iplan = 0; iplan < kNplan; iplan++) {  
343
344       Int_t iDet = GetDetectorSec(iplan,icham);
345
346       // The lower part of the readout chambers (gas volume + radiator) 
347       // The aluminum frames 
348       sprintf(cTagV,"UA%02d",iDet);
349       parCha[0] = fCwidth[iplan]/2.;
350       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
351       parCha[2] = fgkCraH/2. + fgkCdrH/2.;
352       fChamberUAboxd[iDet][0] = parCha[0];
353       fChamberUAboxd[iDet][1] = parCha[1];
354       fChamberUAboxd[iDet][2] = parCha[2];
355       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
356       // The G10 frames 
357       sprintf(cTagV,"UB%02d",iDet);
358       parCha[0] = fCwidth[iplan]/2. - fgkCalT; 
359       parCha[1] = -1.;
360       parCha[2] = -1.;
361       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
362       // The inner part (air)
363       sprintf(cTagV,"UC%02d",iDet);
364       parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT; 
365       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
366       parCha[2] = -1.;
367       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
368
369       // The upper part of the readout chambers (readout plane)
370       // The G10 frames
371       sprintf(cTagV,"UD%02d",iDet);
372       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
373       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
374       parCha[2] = fgkCamH/2.;
375       fChamberUDboxd[iDet][0] = parCha[0];
376       fChamberUDboxd[iDet][1] = parCha[1];
377       fChamberUDboxd[iDet][2] = parCha[2];
378       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
379       // The inner part of the G10 frame (air)
380       sprintf(cTagV,"UE%02d",iDet);
381       parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT; 
382       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
383       parCha[2] = -1.;
384       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
385       // The aluminum frames
386       sprintf(cTagV,"UF%02d",iDet);
387       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
388       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
389       parCha[2] = fgkCroH/2.;
390       fChamberUFboxd[iDet][0] = parCha[0];
391       fChamberUFboxd[iDet][1] = parCha[1];
392       fChamberUFboxd[iDet][2] = parCha[2];
393       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
394       // The inner part of the aluminum frames
395       sprintf(cTagV,"UG%02d",iDet);
396       parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT; 
397       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
398       parCha[2] = -1.;
399       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
400
401       // The material layers inside the chambers
402       parCha[0] = -1.;
403       parCha[1] = -1.;
404       // Rohacell layer (radiator)
405       parCha[2] = fgkRaThick/2;
406       sprintf(cTagV,"UH%02d",iDet);
407       gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
408       // Mylar layer (entrance window + HV cathode) 
409       parCha[2] = fgkMyThick/2;
410       sprintf(cTagV,"UI%02d",iDet);
411       gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
412       // Xe/Isobutane layer (drift volume) 
413       parCha[2] = fgkDrThick/2.;
414       sprintf(cTagV,"UJ%02d",iDet);
415       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
416       // Xe/Isobutane layer (amplification volume)
417       parCha[2] = fgkAmThick/2.;
418       sprintf(cTagV,"UK%02d",iDet);
419       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);  
420       // Cu layer (pad plane)
421       parCha[2] = fgkCuThick/2;
422       sprintf(cTagV,"UL%02d",iDet);
423       gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
424       // G10 layer (support structure / honeycomb)
425       parCha[2] = fgkSuThick/2;
426       sprintf(cTagV,"UM%02d",iDet);
427       gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
428       // G10 layer (readout board)
429       parCha[2] = fgkRpThick/2;
430       sprintf(cTagV,"UN%02d",iDet);
431       gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
432       // Cu layer (readout board)
433       parCha[2] = fgkRcThick/2;
434       sprintf(cTagV,"UO%02d",iDet);
435       gMC->Gsvolu(cTagV,"BOX ",idtmed[1306-1],parCha,kNparCha);
436
437       // Position the layers in the chambers
438       xpos = 0;
439       ypos = 0;
440       // Lower part
441       // Rohacell layer (radiator)
442       zpos = fgkRaZpos;
443       sprintf(cTagV,"UH%02d",iDet);
444       sprintf(cTagM,"UC%02d",iDet);
445       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
446       // Mylar layer (entrance window + HV cathode)   
447       zpos = fgkMyZpos;
448       sprintf(cTagV,"UI%02d",iDet);
449       sprintf(cTagM,"UC%02d",iDet);
450       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
451       // Xe/Isobutane layer (drift volume) 
452       zpos = fgkDrZpos;
453       sprintf(cTagV,"UJ%02d",iDet);
454       sprintf(cTagM,"UC%02d",iDet);
455       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
456       // Upper part
457       // Xe/Isobutane layer (amplification volume)
458       zpos = fgkAmZpos;
459       sprintf(cTagV,"UK%02d",iDet);
460       sprintf(cTagM,"UE%02d",iDet);
461       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
462       // Readout part
463       // Cu layer (pad plane)
464       zpos = fgkCuZpos; 
465       sprintf(cTagV,"UL%02d",iDet);
466       sprintf(cTagM,"UG%02d",iDet);
467       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
468       // G10 layer (support structure)
469       zpos = fgkSuZpos;
470       sprintf(cTagV,"UM%02d",iDet);
471       sprintf(cTagM,"UG%02d",iDet);
472       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
473       // G10 layer (readout board)
474       zpos = fgkRpZpos;
475       sprintf(cTagV,"UN%02d",iDet);
476       sprintf(cTagM,"UG%02d",iDet);
477       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
478       // Cu layer (readout board)
479       zpos = fgkRcZpos;
480       sprintf(cTagV,"UO%02d",iDet);
481       sprintf(cTagM,"UG%02d",iDet);
482       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
483
484       // Position the inner volumes of the chambers in the frames
485       xpos      = 0.0;
486       ypos      = 0.0;
487       zpos      = 0.0;
488       // The inside of the lower G10 frame
489       sprintf(cTagV,"UC%02d",iDet);
490       sprintf(cTagM,"UB%02d",iDet);
491       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
492       // The lower G10 frame inside the aluminum frame
493       sprintf(cTagV,"UB%02d",iDet);
494       sprintf(cTagM,"UA%02d",iDet);
495       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
496       // The inside of the upper G10 frame
497       sprintf(cTagV,"UE%02d",iDet);
498       sprintf(cTagM,"UD%02d",iDet);
499       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
500       // The inside of the upper aluminum frame
501       sprintf(cTagV,"UG%02d",iDet);
502       sprintf(cTagM,"UF%02d",iDet);
503       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");      
504
505       // Position the frames of the chambers in the TRD mother volume
506       xpos  = 0.;
507       ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
508       for (Int_t ic = 0; ic < icham; ic++) {
509         ypos += fClength[iplan][ic];        
510       }
511       ypos += fClength[iplan][icham]/2.;
512       zpos  = fgkVrocsm + fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. 
513             + iplan * (fgkCH + fgkVspace);
514       // The lower aluminum frame, radiator + drift region
515       sprintf(cTagV,"UA%02d",iDet);      
516       fChamberUAorig[iDet][0] = xpos;
517       fChamberUAorig[iDet][1] = ypos;
518       fChamberUAorig[iDet][2] = zpos;
519       // The upper G10 frame, amplification region
520       sprintf(cTagV,"UD%02d",iDet);
521       zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;      
522       fChamberUDorig[iDet][0] = xpos;
523       fChamberUDorig[iDet][1] = ypos;
524       fChamberUDorig[iDet][2] = zpos;
525       // The upper aluminum frame
526       sprintf(cTagV,"UF%02d",iDet);
527       zpos += fgkCroH/2. + fgkCamH/2.;      
528       fChamberUForig[iDet][0] = xpos;
529       fChamberUForig[iDet][1] = ypos;
530       fChamberUForig[iDet][2] = zpos;
531
532     }
533   }
534
535   // Create the volumes of the super module frame
536   CreateFrame(idtmed);
537
538   // Create the volumes of the services
539   CreateServices(idtmed);
540   
541   for (Int_t icham = 0; icham < kNcham; icham++) {
542     for (Int_t iplan = 0; iplan < kNplan; iplan++) {  
543       GroupChamber(iplan,icham,idtmed);
544     }
545   }
546   
547   xpos = 0.;
548   ypos = 0.;
549   zpos = 0.;
550   gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
551
552   xpos = 0.;
553   ypos = 0.;
554   zpos = 0.;
555   gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
556
557   // Put the TRD volumes into the space frame mother volumes
558   // if enabled via status flag
559   xpos = 0.;
560   ypos = 0.;
561   zpos = 0.;
562   for (Int_t isect = 0; isect < kNsect; isect++) {
563     if (fSMstatus[isect]) {
564       sprintf(cTagV,"BTRD%d",isect);
565       gMC->Gspos("UTR1",1,cTagV,xpos,ypos,zpos,0,"ONLY");
566     }
567   }
568
569 }
570
571 //_____________________________________________________________________________
572 void AliTRDgeometry::CreateFrame(Int_t *idtmed)
573 {
574   //
575   // Create the geometry of the frame of the supermodule
576   //
577   // Names of the TRD services volumina
578   //
579   //        USRL    Support rails for the chambers (Al)
580   //        USxx    Support cross bars between the chambers (Al)
581   //
582
583   Int_t   iplan = 0;
584
585   Float_t xpos  = 0.0;
586   Float_t ypos  = 0.0;
587   Float_t zpos  = 0.0;
588
589   Char_t  cTagV[5];
590
591   //
592   // The chamber support rails
593   //
594
595   const Float_t kSRLwid  = 2.0;
596   const Float_t kSRLhgt  = 2.3;
597   const Float_t kSRLdst  = 0.6;
598   const Int_t   kNparSRL = 3;
599   Float_t parSRL[kNparSRL];
600   parSRL[0] = kSRLwid/2.;
601   parSRL[1] = fgkSlenTR1/2.;
602   parSRL[2] = kSRLhgt/2.;
603   gMC->Gsvolu("USRL","BOX ",idtmed[1301-1],parSRL,kNparSRL);
604
605   xpos  = 0.0;
606   ypos  = 0.0;
607   zpos  = 0.0;
608   for (iplan = 0; iplan < kNplan; iplan++) {
609     
610     xpos  = fCwidth[iplan]/2. + kSRLwid/2. + kSRLdst;
611     ypos  = 0.0;
612     zpos  = fgkVrocsm + fgkCraH + fgkCdrH - fgkSheight/2. - kSRLhgt/2. 
613           + iplan * (fgkCH + fgkVspace);
614     gMC->Gspos("USRL",iplan+1         ,"UTI1", xpos,ypos,zpos,0,"ONLY");
615     gMC->Gspos("USRL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,0,"ONLY");
616
617   }
618
619   //
620   // The cross bars between the chambers
621   //
622
623   const Float_t kSCBwid  = 1.0;
624   const Int_t   kNparSCB = 3;
625   Float_t parSCB[kNparSCB];
626   parSCB[1] = kSCBwid/2.;
627   parSCB[2] = fgkCH/2.;
628
629   xpos  = 0.0;
630   ypos  = 0.0;
631   zpos  = 0.0;
632   for (iplan = 0; iplan < kNplan; iplan++) {
633
634     parSCB[0] = fCwidth[iplan]/2. + kSRLdst/2.;
635
636     sprintf(cTagV,"US0%01d",iplan);
637     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
638     xpos  = 0.0;
639     ypos  =   fgkSlenTR1/2. - kSCBwid/2.;
640     zpos  = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
641     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
642
643     sprintf(cTagV,"US1%01d",iplan);
644     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
645     xpos  = 0.0;
646     ypos  = fClength[iplan][2]/2. + fClength[iplan][1];
647     zpos  = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
648     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
649
650     sprintf(cTagV,"US2%01d",iplan);
651     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
652     xpos  = 0.0;
653     ypos  = fClength[iplan][2]/2.;
654     zpos  = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
655     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
656
657     sprintf(cTagV,"US3%01d",iplan);
658     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
659     xpos  = 0.0;
660     ypos  = - fClength[iplan][2]/2.;
661     zpos  = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
662     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
663
664     sprintf(cTagV,"US4%01d",iplan);
665     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
666     xpos  = 0.0;
667     ypos  = - fClength[iplan][2]/2. - fClength[iplan][1];
668     zpos  = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
669     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
670
671     sprintf(cTagV,"US5%01d",iplan);
672     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
673     xpos  = 0.0;
674     ypos  = - fgkSlenTR1/2. + kSCBwid/2.;
675     zpos  = fgkVrocsm + fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
676     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
677
678   }
679
680 }
681
682 //_____________________________________________________________________________
683 void AliTRDgeometry::CreateServices(Int_t *idtmed)
684 {
685   //
686   // Create the geometry of the services
687   //
688   // Names of the TRD services volumina
689   //
690   //        UTCL    Cooling arterias (Al)
691   //        UTCW    Cooling arterias (Water)
692   //        UUxx    Volumes for the services at the chambers (Air)
693   //        UTPW    Power bars       (Cu)
694   //        UTCP    Cooling pipes    (Al)
695   //        UTCH    Cooling pipes    (Water)
696   //        UTPL    Power lines      (Cu)
697   //        UMCM    Readout MCMs     (G10/Cu/Si)
698   //
699
700   Int_t   iplan = 0;
701   Int_t   icham = 0;
702
703   Float_t xpos  = 0.0;
704   Float_t ypos  = 0.0;
705   Float_t zpos  = 0.0;
706
707   Char_t  cTagV[5];
708
709   // The rotation matrices
710   const Int_t kNmatrix = 3;
711   Int_t   matrix[kNmatrix];
712   gMC->Matrix(matrix[0],100.0,  0.0, 90.0, 90.0, 10.0,  0.0);
713   gMC->Matrix(matrix[1], 80.0,  0.0, 90.0, 90.0, 10.0,180.0);
714   gMC->Matrix(matrix[2],  0.0,  0.0, 90.0, 90.0, 90.0,  0.0);
715
716   AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
717   if (!commonParam)
718   {
719     AliError("Could not get common params\n");
720     return;
721   }
722     
723   //
724   // The cooling arterias
725   //
726
727   // Width of the cooling arterias
728   const Float_t kCOLwid  =  0.5; 
729   // Height of the cooling arterias
730   const Float_t kCOLhgt  =  5.5;
731   // Positioning of the cooling 
732   const Float_t kCOLposx =  1.6;
733   const Float_t kCOLposz = -0.2;
734   // Thickness of the walls of the cooling arterias
735   const Float_t kCOLthk  =  0.1;
736   const Int_t   kNparCOL = 3;
737   Float_t parCOL[kNparCOL];
738   parCOL[0]  = kCOLwid/2.;
739   parCOL[1]  = fgkSlenTR1/2.;
740   parCOL[2]  = kCOLhgt/2.;
741   gMC->Gsvolu("UTCL","BOX ",idtmed[1324-1],parCOL,kNparCOL);
742   parCOL[0] -= kCOLthk;
743   parCOL[1]  = fgkSlenTR1/2.;
744   parCOL[2] -= kCOLthk;
745   gMC->Gsvolu("UTCW","BOX ",idtmed[1314-1],parCOL,kNparCOL);
746
747   xpos  = 0.0;
748   ypos  = 0.0;
749   zpos  = 0.0;
750   gMC->Gspos("UTCW",1,"UTCL", xpos,ypos,zpos,0,"ONLY");
751
752   for (iplan = 0; iplan < kNplan; iplan++) { 
753     
754     xpos  = fCwidth[iplan]/2. + kCOLwid/2. + kCOLposx;
755     ypos  = 0.0;
756     zpos  = fgkVrocsm + kCOLhgt/2. - fgkSheight/2. + kCOLposz 
757           + iplan * (fgkCH + fgkVspace);
758     if (iplan == 0) zpos += 0.25;  // To avoid overlaps !
759     gMC->Gspos("UTCL",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
760     gMC->Gspos("UTCL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
761
762   }
763
764   //
765   // The power bars
766   //
767
768   const Float_t kPWRwid  =  0.6;
769   const Float_t kPWRhgt  =  4.5;
770   const Float_t kPWRposx =  1.05;
771   const Float_t kPWRposz =  0.9;
772   const Int_t   kNparPWR = 3;
773   Float_t parPWR[kNparPWR];
774   parPWR[0] = kPWRwid/2.;
775   parPWR[1] = fgkSlenTR1/2.;
776   parPWR[2] = kPWRhgt/2.;
777   gMC->Gsvolu("UTPW","BOX ",idtmed[1325-1],parPWR,kNparPWR);
778   
779   for (iplan = 0; iplan < kNplan; iplan++) { 
780     
781     xpos  = fCwidth[iplan]/2. + kPWRwid/2. + kPWRposx;
782     ypos  = 0.0;
783     zpos  = fgkVrocsm + kPWRhgt/2. - fgkSheight/2. + kPWRposz 
784           + iplan * (fgkCH + fgkVspace);
785     gMC->Gspos("UTPW",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
786     gMC->Gspos("UTPW",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
787
788   }
789
790   //
791   // The volumes for the services at the chambers
792   //
793
794   const Int_t kNparServ = 3;
795   Float_t parServ[kNparServ];
796
797   for (icham = 0; icham < kNcham; icham++) {
798     for (iplan = 0; iplan < kNplan; iplan++) {
799
800       Int_t iDet = GetDetectorSec(iplan,icham);
801
802       sprintf(cTagV,"UU%02d",iDet);
803       parServ[0] = fCwidth[iplan]/2.;
804       parServ[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
805       parServ[2] = fgkVspace/2. - 0.742/2.; //!!!!!!!!!!!!!!      
806       fChamberUUboxd[iDet][0] = parServ[0];
807       fChamberUUboxd[iDet][1] = parServ[1];
808       fChamberUUboxd[iDet][2] = parServ[2];
809       gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
810
811       xpos  = 0.;
812       ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
813       for (Int_t ic = 0; ic < icham; ic++) {
814         ypos += fClength[iplan][ic];        
815       }
816       ypos += fClength[iplan][icham]/2.;
817       zpos  = fgkVrocsm + fgkCH + fgkVspace/2. - fgkSheight/2. 
818             + iplan * (fgkCH + fgkVspace);
819       zpos -= 0.742/2.;
820       fChamberUUorig[iDet][0] = xpos;
821       fChamberUUorig[iDet][1] = ypos;
822       fChamberUUorig[iDet][2] = zpos;
823
824     }
825   }
826
827   //
828   // The cooling pipes inside the service volumes
829   //
830
831   const Int_t kNparTube = 3;
832   Float_t parTube[kNparTube];
833   // The aluminum pipe for the cooling
834   parTube[0] = 0.0;
835   parTube[1] = 0.0;
836   parTube[2] = 0.0;
837   gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
838   // The cooling water
839   parTube[0] =  0.0;
840   parTube[1] =  0.2/2.;
841   parTube[2] = -1.;
842   gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
843   // Water inside the cooling pipe
844   xpos = 0.0;
845   ypos = 0.0;
846   zpos = 0.0;
847   gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
848
849   // Position the cooling pipes in the mother volume
850   const Int_t kNpar = 3;
851   Float_t par[kNpar];
852   for (icham = 0; icham < kNcham;   icham++) {
853     for (iplan = 0; iplan < kNplan; iplan++) {
854       Int_t   iDet    = GetDetectorSec(iplan,icham);
855       Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
856       Int_t   nMCMrow = commonParam->GetRowMax(iplan,icham,0);
857       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
858                       / ((Float_t) nMCMrow);
859       sprintf(cTagV,"UU%02d",iDet);
860       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
861         xpos   = 0.0;
862         ypos   = (0.5 + iMCMrow) * ySize - 1.9 
863                - fClength[iplan][icham]/2. + fgkHspace/2.;
864         zpos   = 0.0 + 0.742/2.;                 
865         par[0] = 0.0;
866         par[1] = 0.3/2.; // Thickness of the cooling pipes
867         par[2] = fCwidth[iplan]/2.;
868         gMC->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
869                           ,matrix[2],"ONLY",par,kNpar);
870       }
871     }
872   }
873
874   //
875   // The power lines
876   //
877
878   // The copper power lines
879   parTube[0] = 0.0;
880   parTube[1] = 0.0;
881   parTube[2] = 0.0;
882   gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
883
884   // Position the power lines in the mother volume
885   for (icham = 0; icham < kNcham;   icham++) {
886     for (iplan = 0; iplan < kNplan; iplan++) {
887       Int_t   iDet    = GetDetectorSec(iplan,icham);
888       Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
889       Int_t   nMCMrow = commonParam->GetRowMax(iplan,icham,0);
890       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
891                       / ((Float_t) nMCMrow);
892       sprintf(cTagV,"UU%02d",iDet);
893       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
894         xpos   = 0.0;
895         ypos   = (0.5 + iMCMrow) * ySize - 1.0 
896                - fClength[iplan][icham]/2. + fgkHspace/2.;
897         zpos   = -0.4 + 0.742/2.;
898         par[0] = 0.0;
899         par[1] = 0.2/2.; // Thickness of the power lines
900         par[2] = fCwidth[iplan]/2.;
901         gMC->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
902                           ,matrix[2],"ONLY",par,kNpar);
903       }
904     }
905   }
906
907   //
908   // The MCMs
909   //
910
911   // The mother volume for the MCMs (air)
912   const Int_t kNparMCM = 3;
913   Float_t parMCM[kNparMCM];
914   parMCM[0] = 3.0/2.;
915   parMCM[1] = 3.0/2.;
916   parMCM[2] = 0.14/2.;
917   gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
918
919   // The MCM carrier G10 layer
920   parMCM[0] = 3.0/2.;
921   parMCM[1] = 3.0/2.;
922   parMCM[2] = 0.1/2.;
923   gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
924   // The MCM carrier Cu layer
925   parMCM[0] = 3.0/2.;
926   parMCM[1] = 3.0/2.;
927   parMCM[2] = 0.0162/2.;
928   gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
929   // The silicon of the chips
930   parMCM[0] = 3.0/2.;
931   parMCM[1] = 3.0/2.;
932   parMCM[2] = 0.003/2.;
933   gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
934
935   // Put the MCM material inside the MCM mother volume
936   xpos  =  0.0;
937   ypos  =  0.0;
938   zpos  = -0.07      + 0.1/2.;
939   gMC->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
940   zpos +=  0.1/2.    + 0.0162/2.;
941   gMC->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
942   zpos +=  0.00162/2 + 0.003/2.;
943   gMC->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
944
945   // Position the MCMs in the mother volume
946   for (icham = 0; icham < kNcham;   icham++) {
947     for (iplan = 0; iplan < kNplan; iplan++) {
948     // Take out upper plane until TRD mothervolume is adjusted
949     //for (iplan = 0; iplan < kNplan-1; iplan++) { 
950       Int_t   iDet    = GetDetectorSec(iplan,icham);
951       Int_t   iCopy   = GetDetector(iplan,icham,0) * 1000;
952       Int_t   nMCMrow = commonParam->GetRowMax(iplan,icham,0);
953       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
954                       / ((Float_t) nMCMrow);
955       Int_t   nMCMcol = 8;
956       Float_t xSize   = (GetChamberWidth(iplan) - 2.* fgkCpadW)
957                       / ((Float_t) nMCMcol);
958       sprintf(cTagV,"UU%02d",iDet);
959       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
960         for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
961           xpos   = (0.5 + iMCMcol) * xSize + 1.0 
962                  - fCwidth[iplan]/2.;
963           ypos   = (0.5 + iMCMrow) * ySize + 1.0 
964                  - fClength[iplan][icham]/2. + fgkHspace/2.;
965           zpos   = -0.4 + 0.742/2.;
966           par[0] = 0.0;
967           par[1] = 0.2/2.; // Thickness of the power lines
968           par[2] = fCwidth[iplan]/2.;
969           gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
970                            ,xpos,ypos,zpos,0,"ONLY");
971         }
972       }
973
974     }
975   }
976
977 }
978
979 //_____________________________________________________________________________
980 void AliTRDgeometry::GroupChamber(Int_t iplan, Int_t icham, Int_t *idtmed)
981 {
982   //
983   // Group volumes UA, UD, UF, UU in a single chamber (Air)
984   // UA, UD, UF, UU are boxes
985   // UT will be a box
986   //
987
988   const Int_t kNparCha = 3;
989
990   Int_t iDet = GetDetectorSec(iplan,icham);
991
992   Float_t xyzMin[3];
993   Float_t xyzMax[3];
994   Float_t xyzOrig[3];
995   Float_t xyzBoxd[3];
996
997   Char_t  cTagV[5];
998   Char_t  cTagM[5];
999
1000   for (Int_t i = 0; i < 3; i++) {
1001     xyzMin[i] = +9999; xyzMax[i] = -9999;
1002   }
1003
1004   for (Int_t i = 0; i < 3; i++) {
1005
1006     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUAorig[iDet][i]-fChamberUAboxd[iDet][i]);
1007     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUAorig[iDet][i]+fChamberUAboxd[iDet][i]);
1008
1009     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUDorig[iDet][i]-fChamberUDboxd[iDet][i]);
1010     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUDorig[iDet][i]+fChamberUDboxd[iDet][i]);
1011
1012     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUForig[iDet][i]-fChamberUFboxd[iDet][i]);
1013     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUForig[iDet][i]+fChamberUFboxd[iDet][i]);
1014
1015     xyzMin[i] = TMath::Min(xyzMin[i],fChamberUUorig[iDet][i]-fChamberUUboxd[iDet][i]);
1016     xyzMax[i] = TMath::Max(xyzMax[i],fChamberUUorig[iDet][i]+fChamberUUboxd[iDet][i]);
1017
1018     xyzOrig[i] = 0.5*(xyzMax[i]+xyzMin[i]);
1019     xyzBoxd[i] = 0.5*(xyzMax[i]-xyzMin[i]);
1020
1021   }
1022   
1023   sprintf(cTagM,"UT%02d",iDet);
1024
1025   gMC->Gsvolu(cTagM,"BOX ",idtmed[1302-1],xyzBoxd,kNparCha);
1026
1027   sprintf(cTagV,"UA%02d",iDet);
1028   gMC->Gspos(cTagV,1,cTagM,
1029              fChamberUAorig[iDet][0]-xyzOrig[0],
1030              fChamberUAorig[iDet][1]-xyzOrig[1],
1031              fChamberUAorig[iDet][2]-xyzOrig[2],
1032              0,"ONLY");
1033
1034   sprintf(cTagV,"UD%02d",iDet);
1035   gMC->Gspos(cTagV,1,cTagM,
1036              fChamberUDorig[iDet][0]-xyzOrig[0],
1037              fChamberUDorig[iDet][1]-xyzOrig[1],
1038              fChamberUDorig[iDet][2]-xyzOrig[2],
1039              0,"ONLY");
1040
1041   sprintf(cTagV,"UF%02d",iDet);
1042   gMC->Gspos(cTagV,1,cTagM,
1043              fChamberUForig[iDet][0]-xyzOrig[0],
1044              fChamberUForig[iDet][1]-xyzOrig[1],
1045              fChamberUForig[iDet][2]-xyzOrig[2],
1046              0,"ONLY");
1047   
1048   sprintf(cTagV,"UU%02d",iDet);
1049   gMC->Gspos(cTagV,1,cTagM,
1050              fChamberUUorig[iDet][0]-xyzOrig[0],
1051              fChamberUUorig[iDet][1]-xyzOrig[1],
1052              fChamberUUorig[iDet][2]-xyzOrig[2],
1053              0,"ONLY");
1054
1055   sprintf(cTagV,"UT%02d",iDet);
1056   gMC->Gspos(cTagV,1,"UTI1",xyzOrig[0],xyzOrig[1],xyzOrig[2],0,"ONLY");
1057
1058 }
1059
1060 //_____________________________________________________________________________
1061 Bool_t AliTRDgeometry::Local2Global(Int_t idet, Double_t *local
1062                                    , Double_t *global) const
1063 {
1064   //
1065   // Converts local pad-coordinates (row,col,time) into 
1066   // global ALICE reference frame coordinates (x,y,z)
1067   //
1068
1069   Int_t icham = GetChamber(idet);    // Chamber info (0-4)
1070   Int_t isect = GetSector(idet);     // Sector info  (0-17)
1071   Int_t iplan = GetPlane(idet);      // Plane info   (0-5)
1072
1073   return Local2Global(iplan,icham,isect,local,global);
1074
1075 }
1076  
1077 //_____________________________________________________________________________
1078 Bool_t AliTRDgeometry::Local2Global(Int_t iplan, Int_t icham, Int_t isect
1079                                   , Double_t *local, Double_t *global) const
1080 {
1081   //
1082   // Converts local pad-coordinates (row,col,time) into 
1083   // global ALICE reference frame coordinates (x,y,z)
1084   //
1085
1086   AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
1087   if (!commonParam)
1088     return kFALSE;
1089
1090   AliTRDcalibDB* calibration = AliTRDcalibDB::Instance();
1091   if (!calibration)
1092     return kFALSE;  
1093   
1094   AliTRDpadPlane *padPlane = commonParam->GetPadPlane(iplan,icham);
1095
1096   // calculate (x,y,z) position in rotated chamber
1097   Int_t    row       = ((Int_t) local[0]);
1098   Int_t    col       = ((Int_t) local[1]);
1099   Float_t  timeSlice = local[2] + 0.5;
1100   Float_t  time0     = GetTime0(iplan);
1101
1102   Int_t idet = GetDetector(iplan, icham, isect);
1103
1104   Double_t  rot[3];
1105   rot[0] = time0 - (timeSlice - calibration->GetT0(idet, col, row))
1106       * calibration->GetVdrift(idet, col, row)/calibration->GetSamplingFrequency();
1107   rot[1] = padPlane->GetColPos(col) - 0.5 * padPlane->GetColSize(col);
1108   rot[2] = padPlane->GetRowPos(row) - 0.5 * padPlane->GetRowSize(row);
1109
1110   // Rotate back to original position
1111   return RotateBack(idet,rot,global);
1112
1113 }
1114
1115 //_____________________________________________________________________________
1116 Bool_t AliTRDgeometry::Global2Local(Int_t mode, Double_t *local, Double_t *global
1117                                   , Int_t* index) const
1118 {
1119   //
1120   // Converts local pad-coordinates (row,col,time) into 
1121   // global ALICE reference frame coordinates (x,y,z)
1122   //
1123   // index[0] = plane number
1124   // index[1] = chamber number
1125   // index[2] = sector number
1126   //
1127   // mode=0  - local coordinate in y, z,             x - rotated global   
1128   // mode=2  - local coordinate in pad, and pad row, x - rotated global
1129   //
1130
1131   Int_t idet = GetDetector(index[0],index[1],index[2]); // Detector number
1132   RotateBack(idet,global,local);
1133   if (mode == 0) return kTRUE;
1134
1135   return kTRUE;
1136
1137 }
1138
1139 //_____________________________________________________________________________
1140 Bool_t AliTRDgeometry::Global2Detector(Double_t global[3], Int_t index[3])
1141 {
1142   //  
1143   //  Find detector for given global point - Ideal geometry 
1144   //  
1145   //
1146   // input    = global position
1147   // output   = index
1148   // index[0] = plane number
1149   // index[1] = chamber number
1150   // index[2] = sector number
1151   //
1152
1153   //
1154   // Find sector
1155   //
1156   Float_t fi = TMath::ATan2(global[1],global[0]);
1157   if (fi < 0) {
1158     fi += 2*TMath::Pi();
1159   }
1160   index[2] = fgkNsect - 1 - TMath::Nint((fi - GetAlpha()/2.)/GetAlpha());
1161
1162   //
1163   // Find plane
1164   //
1165   Float_t locx = global[0] * fRotA11[index[2]] + global[1] * fRotA12[index[2]];  
1166   index[0] = 0;
1167   Float_t max = locx - GetTime0(0);
1168   for (Int_t iplane=1; iplane<fgkNplan;iplane++){
1169     Float_t dist = TMath::Abs(locx - GetTime0(iplane));
1170     if (dist < max){
1171       index[0] = iplane;
1172       max = dist;
1173     }
1174   }
1175
1176   //
1177   // Find chamber
1178   //
1179   if (TMath::Abs(global[2]) < 0.5*GetChamberLength(index[0],2)){
1180     index[1]=2;
1181   }
1182   else{
1183     Double_t localZ = global[2];
1184     if (global[2] > 0){
1185       localZ -= 0.5*(GetChamberLength(index[0],2)+GetChamberLength(index[0],1));
1186       index[1] = (TMath::Abs(localZ) < 0.5*GetChamberLength(index[0],3)) ? 1:0;
1187     }
1188     else{
1189       localZ += 0.5*(GetChamberLength(index[0],2)+GetChamberLength(index[0],3));
1190       index[1] = (TMath::Abs(localZ) < 0.5*GetChamberLength(index[0],1)) ? 3:4;
1191     }
1192   }  
1193
1194   return kTRUE;
1195
1196 }
1197
1198 //_____________________________________________________________________________
1199 Bool_t AliTRDgeometry::Rotate(Int_t d, Double_t *pos, Double_t *rot) const
1200 {
1201   //
1202   // Rotates all chambers in the position of sector 0 and transforms
1203   // the coordinates in the ALICE restframe <pos> into the 
1204   // corresponding local frame <rot>.
1205   //
1206
1207   Int_t sector = GetSector(d);
1208
1209   rot[0] =  pos[0] * fRotA11[sector] + pos[1] * fRotA12[sector];
1210   rot[1] = -pos[0] * fRotA21[sector] + pos[1] * fRotA22[sector];
1211   rot[2] =  pos[2];
1212
1213   return kTRUE;
1214
1215 }
1216
1217 //_____________________________________________________________________________
1218 Bool_t AliTRDgeometry::RotateBack(Int_t d, Double_t *rot, Double_t *pos) const
1219 {
1220   //
1221   // Rotates a chambers from the position of sector 0 into its
1222   // original position and transforms the corresponding local frame 
1223   // coordinates <rot> into the coordinates of the ALICE restframe <pos>.
1224   //
1225
1226   Int_t sector = GetSector(d);
1227
1228   pos[0] =  rot[0] * fRotB11[sector] + rot[1] * fRotB12[sector];
1229   pos[1] = -rot[0] * fRotB21[sector] + rot[1] * fRotB22[sector];
1230   pos[2] =  rot[2];
1231
1232   return kTRUE;
1233
1234 }
1235
1236 //_____________________________________________________________________________
1237 Int_t AliTRDgeometry::GetDetectorSec(Int_t p, Int_t c)
1238 {
1239   //
1240   // Convert plane / chamber into detector number for one single sector
1241   //
1242
1243   return (p + c * fgkNplan);
1244
1245 }
1246
1247 //_____________________________________________________________________________
1248 Int_t AliTRDgeometry::GetDetector(Int_t p, Int_t c, Int_t s)
1249 {
1250   //
1251   // Convert plane / chamber / sector into detector number
1252   //
1253
1254   return (p + c * fgkNplan + s * fgkNplan * fgkNcham);
1255
1256 }
1257
1258 //_____________________________________________________________________________
1259 Int_t AliTRDgeometry::GetPlane(Int_t d) const
1260 {
1261   //
1262   // Reconstruct the plane number from the detector number
1263   //
1264
1265   return ((Int_t) (d % fgkNplan));
1266
1267 }
1268
1269 //_____________________________________________________________________________
1270 Int_t AliTRDgeometry::GetChamber(Int_t d) const
1271 {
1272   //
1273   // Reconstruct the chamber number from the detector number
1274   //
1275
1276   return ((Int_t) (d % (fgkNplan * fgkNcham)) / fgkNplan);
1277
1278 }
1279
1280 //_____________________________________________________________________________
1281 Int_t AliTRDgeometry::GetSector(Int_t d) const
1282 {
1283   //
1284   // Reconstruct the sector number from the detector number
1285   //
1286
1287   return ((Int_t) (d / (fgkNplan * fgkNcham)));
1288
1289 }
1290
1291 //_____________________________________________________________________________
1292 AliTRDgeometry* AliTRDgeometry::GetGeometry(AliRunLoader* runLoader)
1293 {
1294   //
1295   // load the geometry from the galice file
1296   //
1297
1298   if (!runLoader) runLoader = AliRunLoader::GetRunLoader();
1299   if (!runLoader) {
1300     ::Error("AliTRDgeometry::GetGeometry", "No run loader");
1301     return NULL;
1302   }
1303
1304   TDirectory* saveDir = gDirectory;
1305   runLoader->CdGAFile();
1306
1307   // Try from the galice.root file
1308   AliTRDgeometry* geom = (AliTRDgeometry*) gDirectory->Get("TRDgeometry");
1309
1310   if (!geom) {
1311     // It is not in the file, try to get it from gAlice, 
1312     // which corresponds to the run loader 
1313     AliTRD * trd = (AliTRD*)runLoader->GetAliRun()->GetDetector("TRD");
1314     geom = trd->GetGeometry();
1315   }
1316   if (!geom) ::Error("AliTRDgeometry::GetGeometry", "Geometry not found");
1317
1318   saveDir->cd();
1319   return geom;
1320
1321 }
1322
1323 //_____________________________________________________________________________
1324 Bool_t AliTRDgeometry::ReadGeoMatrices()
1325 {
1326   //
1327   // Read geo matrices from current gGeoManager for each TRD sector
1328   //
1329
1330   if (!gGeoManager) return kFALSE;
1331   fMatrixArray = new TObjArray(kNdet); 
1332   fMatrixCorrectionArray = new TObjArray(kNdet);
1333   fMatrixGeo   = new TObjArray(kNdet);
1334   AliAlignObjAngles o;
1335
1336   for (Int_t iLayer = AliAlignObj::kTRD1; iLayer <= AliAlignObj::kTRD6; iLayer++) {
1337     for (Int_t iModule = 0; iModule < AliAlignObj::LayerSize(iLayer); iModule++) {
1338       UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,iModule);
1339       const char *path = AliAlignObj::GetVolPath(volid);
1340       if (!gGeoManager->cd(path)) return kFALSE;      
1341       TGeoHMatrix* m = gGeoManager->GetCurrentMatrix();
1342       Int_t     iLayerTRD    = iLayer-AliAlignObj::kTRD1;
1343       Int_t     isector      = Nsect()-1-(iModule/Ncham());
1344       Int_t     ichamber     = Ncham()-1-(iModule%Ncham());
1345       Int_t     lid          = GetDetector(iLayerTRD,ichamber,isector);    
1346
1347       //
1348       // local geo system z-x-y  to x-y--z 
1349       //
1350       fMatrixGeo->AddAt(new TGeoHMatrix(*m),lid);
1351       
1352       TGeoRotation mchange; 
1353       mchange.RotateY(90); mchange.RotateX(90);
1354
1355       TGeoHMatrix gMatrix(mchange.Inverse());
1356       gMatrix.MultiplyLeft(m);
1357       fMatrixArray->AddAt(new TGeoHMatrix(gMatrix),lid); 
1358
1359       //
1360       //  Cluster transformation matrix
1361       //
1362       TGeoHMatrix  rotMatrix(mchange.Inverse());
1363       rotMatrix.MultiplyLeft(m);
1364       Double_t sectorAngle = 20.*(isector%18)+10;
1365       TGeoHMatrix  rotSector;
1366       rotSector.RotateZ(sectorAngle);
1367       rotMatrix.MultiplyLeft(&rotSector);      
1368
1369       fMatrixCorrectionArray->AddAt(new TGeoHMatrix(rotMatrix),lid);       
1370
1371     }    
1372   }
1373
1374   return kTRUE;
1375
1376 }
1377