Fix definition of rotation matrices
[u/mrichter/AliRoot.git] / TRD / AliTRDgeometryFull.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /*
17 $Log$
18 Revision 1.12  2003/09/18 09:06:07  cblume
19 Geometry update, Removal of compiler warnings
20
21 Revision 1.10  2002/11/21 22:38:47  alibrary
22 Removing AliMC and AliMCProcess
23
24 Revision 1.9  2002/10/31 17:45:35  cblume
25 New chamber geometry
26
27 Revision 1.8  2002/02/11 14:21:16  cblume
28 Update of the geometry. Get rid of MANY
29
30 Revision 1.7  2001/05/11 07:56:12  hristov
31 Consistent declarations needed on Alpha
32
33 Revision 1.6  2001/02/14 18:22:26  cblume
34 Change in the geometry of the padplane
35
36 Revision 1.5  2000/11/01 14:53:21  cblume
37 Merge with TRD-develop
38
39 Revision 1.1.4.6  2000/10/15 23:40:01  cblume
40 Remove AliTRDconst
41
42 Revision 1.1.4.5  2000/10/06 16:49:46  cblume
43 Made Getters const
44
45 Revision 1.1.4.4  2000/10/04 16:34:58  cblume
46 Replace include files by forward declarations
47
48 Revision 1.1.4.3  2000/09/22 14:43:41  cblume
49 Allow the pad/timebin-dimensions to be changed after initialization
50
51 Revision 1.4  2000/10/02 21:28:19  fca
52 Removal of useless dependecies via forward declarations
53
54 Revision 1.3  2000/06/08 18:32:58  cblume
55 Make code compliant to coding conventions
56
57 Revision 1.2  2000/05/08 16:17:27  cblume
58 Merge TRD-develop
59
60 Revision 1.1.4.2  2000/05/08 14:46:44  cblume
61 Include options SetPHOShole() and SetRICHhole()
62
63 Revision 1.1.4.1  2000/04/27 12:46:04  cblume
64 Corrected bug in full geometry
65
66 Revision 1.1  2000/02/28 19:01:15  cblume
67 Add new TRD classes
68
69 */
70
71 ///////////////////////////////////////////////////////////////////////////////
72 //                                                                           //
73 //  TRD geometry for the spaceframe without holes                            //
74 //                                                                           //
75 ///////////////////////////////////////////////////////////////////////////////
76
77 #include "TVirtualMC.h"
78
79 #include "AliTRDgeometryFull.h"
80 #include "AliTRDparameter.h"
81
82 ClassImp(AliTRDgeometryFull)
83
84 //_____________________________________________________________________________
85 AliTRDgeometryFull::AliTRDgeometryFull():AliTRDgeometry()
86 {
87   //
88   // AliTRDgeometryFull default constructor
89   //
90
91   Init();
92
93 }
94
95 //_____________________________________________________________________________
96 AliTRDgeometryFull::~AliTRDgeometryFull()
97 {
98   //
99   // AliTRDgeometryFull destructor
100   //
101
102 }
103
104 //_____________________________________________________________________________
105 void AliTRDgeometryFull::Init()
106 {
107   //
108   // Initializes the geometry parameter
109   //
110
111   Int_t icham;
112   Int_t iplan;
113
114   fPHOShole = kFALSE;
115   fRICHhole = kFALSE;
116
117   // The outer lengths of the chambers for the sectors with holes for the PHOS
118   Float_t lengthPH[kNplan][kNcham] = { { 124.0, 117.0,   0.0, 117.0, 124.0 }
119                                      , { 131.0, 124.0,   0.0, 124.0, 131.0 }
120                                      , { 138.0, 131.0,   0.0, 131.0, 138.0 }
121                                      , { 145.0, 138.0,   0.0, 138.0, 145.0 }
122                                      , { 147.0, 140.0,   0.0, 140.0, 147.0 }
123                                      , { 147.0, 140.0,   0.0, 140.0, 147.0 } };
124
125   // The outer lengths of the chambers for the sectors with holes for the RICH
126   Float_t lengthRH[kNplan][kNcham] = { {  87.5,   0.0,   0.0,   0.0,  87.5 }
127                                      , { 101.5,   0.0,   0.0,   0.0, 101.5 }
128                                      , { 115.5,   0.0,   0.0,   0.0, 115.5 }
129                                      , { 129.5,   0.0,   0.0,   0.0, 129.5 }
130                                      , { 133.5,   0.0,   0.0,   0.0, 133.5 }
131                                      , { 133.5,   0.0,   0.0,   0.0, 133.5 } };
132
133   for (icham = 0; icham < kNcham; icham++) {
134     for (iplan = 0; iplan < kNplan; iplan++) {
135       fClengthPH[iplan][icham] = lengthPH[iplan][icham];
136       fClengthRH[iplan][icham] = lengthRH[iplan][icham];
137     }
138   }
139
140 }
141
142 //_____________________________________________________________________________
143 void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
144 {
145   //
146   // Create the TRD geometry without hole
147   //
148   //
149   // Names of the TRD volumina (xx = detector number):
150   //
151   //      Lower part of the readout chambers (gas volume + radiator)
152   //
153   //        UAxx    Aluminum frames             (Al)
154   //        UBxx    G10 frames                  (C)
155   //        UCxx    Inner volumes               (Air)
156   //
157   //      Upper part of the readout chambers (readout plane + fee)
158   //
159   //        UDxx    G10 frames                  (C)
160   //        UExx    Inner volumes of the G10    (Air)
161   //        UFxx    Aluminum frames             (Al)
162   //        UGxx    Inner volumes of the Al     (Air)
163   //
164   //      Inner material layers
165   //
166   //        UHxx    Radiator                    (Rohacell)
167   //        UIxx    Entrance window             (Mylar)
168   //        UJxx    Drift volume                (Xe/CO2)
169   //        UKxx    Amplification volume        (Xe/CO2)
170   //        ULxx    Pad plane                   (Cu)
171   //        UMxx    Support structure           (Rohacell)
172   //
173
174   const Int_t kNdet    = kNplan * kNcham;
175
176   const Int_t kNparTrd = 4;
177   const Int_t kNparCha = 3;
178
179   Float_t xpos, ypos, zpos;
180
181   Float_t parTrd[kNparTrd];
182   Float_t parCha[kNparCha];
183
184   Char_t  cTagV[5];
185   Char_t  cTagM[5];
186
187   AliTRDgeometry::CreateGeometry(idtmed);
188
189   // The TRD mother volume for one sector (Air), full length in z-direction
190   // Provides material for side plates of super module
191   parTrd[0] = fgkSwidth1/2.;
192   parTrd[1] = fgkSwidth2/2.;
193   parTrd[2] = fgkSlenTR1/2.;
194   parTrd[3] = fgkSheight/2.;
195   gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
196   // The TRD mother volume for one sector (Al), leaving hole for PHOS
197   if (fPHOShole) {
198     gMC->Gsvolu("UTR2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
199   }
200   // The TRD mother volume for one sector (Al), leaving hole for RICH
201   if (fRICHhole) {
202     gMC->Gsvolu("UTR3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
203   }  
204
205   // 
206   // The side plates of the super module (Al)
207   parTrd[0] = fgkSwidth1/2. - fgkSMgapT;
208   parTrd[1] = fgkSwidth2/2. - fgkSMgapT;
209   parTrd[2] = fgkSlenTR1/2.;
210   parTrd[3] = fgkSheight/2.;
211   gMC->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
212   // The TRD mother volume for one sector (Al), leaving hole for PHOS
213   if (fPHOShole) {
214     gMC->Gsvolu("UTS2","TRD1",idtmed[1301-1],parTrd,kNparTrd);
215   }
216   // The TRD mother volume for one sector (Al), leaving hole for RICH
217   if (fRICHhole) {
218     gMC->Gsvolu("UTS3","TRD1",idtmed[1301-1],parTrd,kNparTrd);
219   }  
220
221   // The inner part of the TRD mother volume for one sector (Air), 
222   // full length in z-direction
223   parTrd[0] = fgkSwidth1/2. - fgkSMgapT - fgkSMpltT;
224   parTrd[1] = fgkSwidth2/2. - fgkSMgapT - fgkSMpltT;
225   parTrd[2] = fgkSlenTR1/2.;
226   parTrd[3] = fgkSheight/2.;
227   gMC->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
228   // The TRD mother volume for one sector (Air), leaving hole for PHOS
229   if (fPHOShole) {
230     gMC->Gsvolu("UTI2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
231   }
232   // The TRD mother volume for one sector (Air), leaving hole for RICH
233   if (fRICHhole) {
234     gMC->Gsvolu("UTI3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
235   }  
236
237   for (Int_t icham = 0; icham < kNcham; icham++) {
238     for (Int_t iplan = 0; iplan < kNplan; iplan++) {  
239
240       Int_t iDet = GetDetectorSec(iplan,icham);
241
242       // The lower part of the readout chambers (gas volume + radiator) 
243       // The aluminum frames 
244       sprintf(cTagV,"UA%02d",iDet);
245       parCha[0] = fCwidth[iplan]/2.;
246       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
247       parCha[2] = fgkCraH/2. + fgkCdrH/2.;
248       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
249       // The G10 frames 
250       sprintf(cTagV,"UB%02d",iDet);
251       parCha[0] = fCwidth[iplan]/2. - fgkCalT; 
252       parCha[1] = -1.;
253       parCha[2] = -1.;
254       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
255       // The inner part (air)
256       sprintf(cTagV,"UC%02d",iDet);
257       parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT; 
258       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
259       parCha[2] = -1.;
260       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
261       if (fPHOShole) {
262         if (fClengthPH[iplan][icham] > 0.0) {
263           // The aluminum frames 
264           sprintf(cTagV,"UA%02d",iDet+kNdet);
265           parCha[0] = fCwidth[iplan]/2.;
266           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
267           parCha[2] = fgkCraH/2. + fgkCdrH/2.;
268           gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
269           // The G10 frames 
270           sprintf(cTagV,"UB%02d",iDet+kNdet);
271           parCha[0] = fCwidth[iplan]/2. - fgkCalT; 
272           parCha[1] = -1.;
273           parCha[2] = -1.;
274           gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
275           // The inner part (air)
276           sprintf(cTagV,"UC%02d",iDet+kNdet);
277           parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT; 
278           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
279           parCha[2] = -1.;
280           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
281         }
282       }
283       if (fRICHhole) {
284         if (fClengthRH[iplan][icham] > 0.0) {
285           // The aluminum frames 
286           sprintf(cTagV,"UA%02d",iDet+2*kNdet);
287           parCha[0] = fCwidth[iplan]/2.;
288           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
289           parCha[2] = fgkCraH/2. + fgkCdrH/2.;
290           gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
291           // The G10 frames 
292           sprintf(cTagV,"UB%02d",iDet+2*kNdet);
293           parCha[0] = fCwidth[iplan]/2. - fgkCalT; 
294           parCha[1] = -1.;
295           parCha[2] = -1.;
296           gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
297           // The inner part (air)
298           sprintf(cTagV,"UC%02d",iDet+2*kNdet);
299           parCha[0] = fCwidth[iplan]/2. - fgkCalT - fgkCclsT; 
300           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.- fgkCclfT;
301           parCha[2] = -1.;
302           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
303         }
304       }
305
306       // The upper part of the readout chambers (readout plane)
307       // The G10 frames
308       sprintf(cTagV,"UD%02d",iDet);
309       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
310       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
311       parCha[2] = fgkCamH/2.;
312       gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
313       // The inner part of the G10 frame (air)
314       sprintf(cTagV,"UE%02d",iDet);
315       parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT; 
316       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
317       parCha[2] = -1.;
318       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
319       // The aluminum frames
320       sprintf(cTagV,"UF%02d",iDet);
321       parCha[0] = fCwidth[iplan]/2. + fgkCroW;
322       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
323       parCha[2] = fgkCroH/2.;
324       gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
325       // The inner part of the aluminum frames
326       sprintf(cTagV,"UG%02d",iDet);
327       parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT; 
328       parCha[1] = fClength[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
329       parCha[2] = -1.;
330       gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
331       if (fPHOShole) {
332         if (fClengthPH[iplan][icham] > 0.0) {
333           sprintf(cTagV,"UD%02d",iDet+kNdet);
334           parCha[0] = fCwidth[iplan]/2. + fgkCroW;
335           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
336           parCha[2] = fgkCamH/2.;
337           gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
338           // The inner part of the G10 frame (air)
339           sprintf(cTagV,"UE%02d",iDet+kNdet);
340           parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT; 
341           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
342           parCha[2] = -1.;
343           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
344           // The aluminum frames
345           sprintf(cTagV,"UF%02d",iDet+kNdet);
346           parCha[0] = fCwidth[iplan]/2. + fgkCroW;
347           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
348           parCha[2] = fgkCroH/2.;
349           gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
350           // The inner part of the aluminum frames
351           sprintf(cTagV,"UG%02d",iDet+kNdet);
352           parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT; 
353           parCha[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
354           parCha[2] = -1.;
355           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
356         }
357       }
358       if (fRICHhole) {
359         if (fClengthRH[iplan][icham] > 0.0) {
360           sprintf(cTagV,"UD%02d",iDet+2*kNdet);
361           parCha[0] = fCwidth[iplan]/2. + fgkCroW;
362           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
363           parCha[2] = fgkCamH/2.;
364           gMC->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
365           // The inner part of the G10 frame (air)
366           sprintf(cTagV,"UE%02d",iDet+2*kNdet);
367           parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCcuT; 
368           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.- fgkCcuT;
369           parCha[2] = -1.;
370           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
371           // The aluminum frames
372           sprintf(cTagV,"UF%02d",iDet+2*kNdet);
373           parCha[0] = fCwidth[iplan]/2. + fgkCroW;
374           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
375           parCha[2] = fgkCroH/2.;
376           gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
377           // The inner part of the aluminum frames
378           sprintf(cTagV,"UG%02d",iDet+2*kNdet);
379           parCha[0] = fCwidth[iplan]/2. + fgkCroW - fgkCauT; 
380           parCha[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.- fgkCauT;
381           parCha[2] = -1.;
382           gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
383         }
384       }
385
386       // The material layers inside the chambers
387       parCha[0] = -1.;
388       parCha[1] = -1.;
389       // Rohacell layer (radiator)
390       parCha[2] = fgkRaThick/2;
391       sprintf(cTagV,"UH%02d",iDet);
392       gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
393       // Mylar layer (entrance window + HV cathode) 
394       parCha[2] = fgkMyThick/2;
395       sprintf(cTagV,"UI%02d",iDet);
396       gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
397       // Xe/Isobutane layer (drift volume) 
398       parCha[2] = fgkDrThick/2.;
399       sprintf(cTagV,"UJ%02d",iDet);
400       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
401       // Xe/Isobutane layer (amplification volume)
402       parCha[2] = fgkAmThick/2.;
403       sprintf(cTagV,"UK%02d",iDet);
404       gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);  
405       // Cu layer (pad plane)
406       parCha[2] = fgkCuThick/2;
407       sprintf(cTagV,"UL%02d",iDet);
408       gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
409       // G10 layer (support structure / honeycomb)
410       parCha[2] = fgkSuThick/2;
411       sprintf(cTagV,"UM%02d",iDet);
412       gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
413       if (fPHOShole) {
414         if (fClengthPH[iplan][icham] > 0.0) {
415           // Rohacell layer (radiator)
416           parCha[2] = fgkRaThick/2;
417           sprintf(cTagV,"UH%02d",iDet+kNdet);
418           gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
419           // Mylar layer (entrance window + HV cathode) 
420           parCha[2] = fgkMyThick/2;
421           sprintf(cTagV,"UI%02d",iDet+kNdet);
422           gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
423           // Xe/Isobutane layer (drift volume) 
424           parCha[2] = fgkDrThick/2.;
425           sprintf(cTagV,"UJ%02d",iDet+kNdet);
426           gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
427           // Xe/Isobutane layer (amplification volume)
428           parCha[2] = fgkAmThick/2.;
429           sprintf(cTagV,"UK%02d",iDet+kNdet);
430           gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);  
431           // Cu layer (pad plane)
432           parCha[2] = fgkCuThick/2;
433           sprintf(cTagV,"UL%02d",iDet+kNdet);
434           gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
435           // G10 layer (support structure / honeycomb)
436           parCha[2] = fgkSuThick/2;
437           sprintf(cTagV,"UM%02d",iDet+kNdet);
438           gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
439         }
440       }
441       if (fRICHhole) {
442         if (fClengthRH[iplan][icham] > 0.0) {
443           // Rohacell layer (radiator)
444           parCha[2] = fgkRaThick/2;
445           sprintf(cTagV,"UH%02d",iDet+2*kNdet);
446           gMC->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
447           // Mylar layer (entrance window + HV cathode) 
448           parCha[2] = fgkMyThick/2;
449           sprintf(cTagV,"UI%02d",iDet+2*kNdet);
450           gMC->Gsvolu(cTagV,"BOX ",idtmed[1308-1],parCha,kNparCha);
451           // Xe/Isobutane layer (drift volume) 
452           parCha[2] = fgkDrThick/2.;
453           sprintf(cTagV,"UJ%02d",iDet+2*kNdet);
454           gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
455           // Xe/Isobutane layer (amplification volume)
456           parCha[2] = fgkAmThick/2.;
457           sprintf(cTagV,"UK%02d",iDet+2*kNdet);
458           gMC->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);  
459           // Cu layer (pad plane)
460           parCha[2] = fgkCuThick/2;
461           sprintf(cTagV,"UL%02d",iDet+2*kNdet);
462           gMC->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
463           // G10 layer (support structure / honeycomb)
464           parCha[2] = fgkSuThick/2;
465           sprintf(cTagV,"UM%02d",iDet+2*kNdet);
466           gMC->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
467         }
468       }
469
470       // Position the layers in the chambers
471       xpos = 0;
472       ypos = 0;
473       // Lower part
474       // Rohacell layer (radiator)
475       zpos = fgkRaZpos;
476       sprintf(cTagV,"UH%02d",iDet);
477       sprintf(cTagM,"UC%02d",iDet);
478       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
479       // Mylar layer (entrance window + HV cathode)   
480       zpos = fgkMyZpos;
481       sprintf(cTagV,"UI%02d",iDet);
482       sprintf(cTagM,"UC%02d",iDet);
483       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
484       // Xe/Isobutane layer (drift volume) 
485       zpos = fgkDrZpos;
486       sprintf(cTagV,"UJ%02d",iDet);
487       sprintf(cTagM,"UC%02d",iDet);
488       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
489       // Upper part
490       // Xe/Isobutane layer (amplification volume)
491       zpos = fgkAmZpos;
492       sprintf(cTagV,"UK%02d",iDet);
493       sprintf(cTagM,"UE%02d",iDet);
494       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
495       // Readout part
496       // Cu layer (pad plane)
497       zpos = fgkCuZpos; 
498       sprintf(cTagV,"UL%02d",iDet);
499       sprintf(cTagM,"UG%02d",iDet);
500       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
501       // G10 layer (support structure)
502       zpos = fgkSuZpos;
503       sprintf(cTagV,"UM%02d",iDet);
504       sprintf(cTagM,"UG%02d",iDet);
505       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
506       if (fPHOShole) {
507         if (fClengthPH[iplan][icham] > 0.0) {
508           // Lower part
509           // Rohacell layer (radiator)
510           zpos = fgkRaZpos;
511           sprintf(cTagV,"UH%02d",iDet+kNdet);
512           sprintf(cTagM,"UC%02d",iDet+kNdet);
513           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
514           // Mylar layer (entrance window + HV cathode)   
515           zpos = fgkMyZpos;
516           sprintf(cTagV,"UI%02d",iDet+kNdet);
517           sprintf(cTagM,"UC%02d",iDet+kNdet);
518           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
519           // Xe/Isobutane layer (drift volume) 
520           zpos = fgkDrZpos;
521           sprintf(cTagV,"UJ%02d",iDet+kNdet);
522           sprintf(cTagM,"UC%02d",iDet+kNdet);
523           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
524           // Upper part
525           // Xe/Isobutane layer (amplification volume)
526           zpos = fgkAmZpos;
527           sprintf(cTagV,"UK%02d",iDet+kNdet);
528           sprintf(cTagM,"UE%02d",iDet+kNdet);
529           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
530           // Readout part
531           // Cu layer (pad plane)
532           zpos = fgkCuZpos; 
533           sprintf(cTagV,"UL%02d",iDet+kNdet);
534           sprintf(cTagM,"UG%02d",iDet+kNdet);
535           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
536           // G10 layer (support structure)
537           zpos = fgkSuZpos;
538           sprintf(cTagV,"UM%02d",iDet+kNdet);
539           sprintf(cTagM,"UG%02d",iDet+kNdet);
540           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
541         }
542       }
543       if (fRICHhole) {
544         if (fClengthRH[iplan][icham] > 0.0) {
545           // Lower part
546           // Rohacell layer (radiator)
547           zpos = fgkRaZpos;
548           sprintf(cTagV,"UH%02d",iDet+2*kNdet);
549           sprintf(cTagM,"UC%02d",iDet+2*kNdet);
550           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
551           // Mylar layer (entrance window + HV cathode)   
552           zpos = fgkMyZpos;
553           sprintf(cTagV,"UI%02d",iDet+2*kNdet);
554           sprintf(cTagM,"UC%02d",iDet+2*kNdet);
555           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
556           // Xe/Isobutane layer (drift volume) 
557           zpos = fgkDrZpos;
558           sprintf(cTagV,"UJ%02d",iDet+2*kNdet);
559           sprintf(cTagM,"UC%02d",iDet+2*kNdet);
560           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
561           // Upper part
562           // Xe/Isobutane layer (amplification volume)
563           zpos = fgkAmZpos;
564           sprintf(cTagV,"UK%02d",iDet+2*kNdet);
565           sprintf(cTagM,"UE%02d",iDet+2*kNdet);
566           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
567           // Readout part
568           // Cu layer (pad plane)
569           zpos = fgkCuZpos; 
570           sprintf(cTagV,"UL%02d",iDet+2*kNdet);
571           sprintf(cTagM,"UG%02d",iDet+2*kNdet);
572           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
573           // G10 layer (support structure)
574           zpos = fgkSuZpos;
575           sprintf(cTagV,"UM%02d",iDet+2*kNdet);
576           sprintf(cTagM,"UG%02d",iDet+2*kNdet);
577           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
578         }
579       }
580
581       // Position the inner volumes of the chambers in the frames
582       xpos      = 0.0;
583       ypos      = 0.0;
584       zpos      = 0.0;
585       // The inside of the lower G10 frame
586       sprintf(cTagV,"UC%02d",iDet);
587       sprintf(cTagM,"UB%02d",iDet);
588       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
589       // The lower G10 frame inside the aluminum frame
590       sprintf(cTagV,"UB%02d",iDet);
591       sprintf(cTagM,"UA%02d",iDet);
592       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
593       // The inside of the upper G10 frame
594       sprintf(cTagV,"UE%02d",iDet);
595       sprintf(cTagM,"UD%02d",iDet);
596       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
597       // The inside of the upper aluminum frame
598       sprintf(cTagV,"UG%02d",iDet);
599       sprintf(cTagM,"UF%02d",iDet);
600       gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");      
601       if (fPHOShole) {
602         if (fClengthPH[iplan][icham] > 0.0) {
603           // The inside of the lower G10 frame
604           sprintf(cTagV,"UC%02d",iDet+kNdet);
605           sprintf(cTagM,"UB%02d",iDet+kNdet);
606           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
607           // The lower G10 frame inside the aluminum frame
608           sprintf(cTagV,"UB%02d",iDet+kNdet);
609           sprintf(cTagM,"UA%02d",iDet+kNdet);
610           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
611           // The inside of the upper G10 frame
612           sprintf(cTagV,"UE%02d",iDet+kNdet);
613           sprintf(cTagM,"UD%02d",iDet+kNdet);
614           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
615           // The inside of the upper aluminum frame
616           sprintf(cTagV,"UG%02d",iDet+kNdet);
617           sprintf(cTagM,"UF%02d",iDet+kNdet);
618           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");      
619         }
620       }
621       if (fRICHhole) {
622         if (fClengthRH[iplan][icham] > 0.0) {
623           // The inside of the lower G10 frame
624           sprintf(cTagV,"UC%02d",iDet+2*kNdet);
625           sprintf(cTagM,"UB%02d",iDet+2*kNdet);
626           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
627           // The lower G10 frame inside the aluminum frame
628           sprintf(cTagV,"UB%02d",iDet+2*kNdet);
629           sprintf(cTagM,"UA%02d",iDet+2*kNdet);
630           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
631           // The inside of the upper G10 frame
632           sprintf(cTagV,"UE%02d",iDet+2*kNdet);
633           sprintf(cTagM,"UD%02d",iDet+2*kNdet);
634           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
635           // The inside of the upper aluminum frame
636           sprintf(cTagV,"UG%02d",iDet+2*kNdet);
637           sprintf(cTagM,"UF%02d",iDet+2*kNdet);
638           gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");      
639         }
640       }
641
642       // Position the frames of the chambers in the TRD mother volume
643       xpos  = 0.;
644       ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
645       for (Int_t ic = 0; ic < icham; ic++) {
646         ypos += fClength[iplan][ic];        
647       }
648       ypos += fClength[iplan][icham]/2.;
649       zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
650       // The lower aluminum frame, radiator + drift region
651       sprintf(cTagV,"UA%02d",iDet);
652       gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
653       // The upper G10 frame, amplification region
654       sprintf(cTagV,"UD%02d",iDet);
655       zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
656       gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
657       // The upper aluminum frame
658       sprintf(cTagV,"UF%02d",iDet);
659       zpos += fgkCroH/2. + fgkCamH/2.;
660       gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
661       if (fPHOShole) {
662         if (fClengthPH[iplan][icham] > 0.0) {
663           xpos  = 0.;
664           ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
665           for (Int_t ic = 0; ic < icham; ic++) {
666             ypos += fClength[iplan][ic];        
667           }
668           if (icham > 2) {
669             ypos += fClength[iplan][icham];
670             ypos -= fClengthPH[iplan][icham]/2.;
671           }
672           else {
673             ypos += fClengthPH[iplan][icham]/2.;
674           }
675           zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
676           // The lower aluminum frame, radiator + drift region
677           sprintf(cTagV,"UA%02d",iDet+kNdet);
678           gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
679           // The upper G10 frame, amplification region
680           sprintf(cTagV,"UD%02d",iDet+kNdet);
681           zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
682           gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
683           // The upper aluminum frame
684           sprintf(cTagV,"UF%02d",iDet+kNdet);
685           zpos += fgkCroH/2. + fgkCamH/2.;
686           gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
687         }
688       }
689       if (fRICHhole) {
690         if (fClengthRH[iplan][icham] > 0.0) {
691           xpos  = 0.;
692           ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
693           for (Int_t ic = 0; ic < icham; ic++) {
694             ypos += fClength[iplan][ic];        
695           }
696           if (icham > 2) {
697             ypos += fClength[iplan][icham];
698             ypos -= fClengthRH[iplan][icham]/2.;
699           }
700           else {
701             ypos += fClengthRH[iplan][icham]/2.;
702           }
703           zpos  = fgkCraH/2. + fgkCdrH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
704           // The lower aluminum frame, radiator + drift region
705           sprintf(cTagV,"UA%02d",iDet+2*kNdet);
706           gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
707           // The upper G10 frame, amplification region
708           sprintf(cTagV,"UD%02d",iDet+2*kNdet);
709           zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
710           gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
711           // The upper aluminum frame
712           sprintf(cTagV,"UF%02d",iDet+2*kNdet);
713           zpos += fgkCroH/2. + fgkCamH/2.;
714           gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
715         }
716       }
717
718     }
719   }
720
721   xpos = 0.;
722   ypos = 0.;
723   zpos = 0.;
724   gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
725   if (fPHOShole) {
726     gMC->Gspos("UTI2",2,"UTS2",xpos,ypos,zpos,0,"ONLY");
727   }
728   if (fRICHhole) {
729     gMC->Gspos("UTI3",3,"UTS3",xpos,ypos,zpos,0,"ONLY");
730   }
731
732   xpos = 0.;
733   ypos = 0.;
734   zpos = 0.;
735   gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
736   if (fPHOShole) {
737     gMC->Gspos("UTS2",2,"UTR2",xpos,ypos,zpos,0,"ONLY");
738   }
739   if (fRICHhole) {
740     gMC->Gspos("UTS3",3,"UTR3",xpos,ypos,zpos,0,"ONLY");
741   }
742
743   xpos = 0.;
744   ypos = 0.;
745   zpos = 0.;
746   gMC->Gspos("UTR1",1,"BTR1",xpos,ypos,zpos,0,"ONLY");
747   if (fPHOShole) {
748     gMC->Gspos("UTR2",2,"BTR2",xpos,ypos,zpos,0,"ONLY");
749   }
750   else {
751     gMC->Gspos("UTR1",2,"BTR2",xpos,ypos,zpos,0,"ONLY");
752   }
753   if (fRICHhole) {
754     gMC->Gspos("UTR3",3,"BTR3",xpos,ypos,zpos,0,"ONLY");
755   }
756   else {
757     gMC->Gspos("UTR1",3,"BTR3",xpos,ypos,zpos,0,"ONLY");
758   }
759
760   // Create the volumes of the super module frame
761   CreateFrame(idtmed);
762
763   // Create the volumes of the services
764   CreateServices(idtmed);
765
766 }
767
768 //_____________________________________________________________________________
769 void AliTRDgeometryFull::CreateFrame(Int_t *idtmed)
770 {
771   //
772   // Create the geometry of the frame of the supermodule
773   //
774   // Names of the TRD services volumina
775   //
776   //        USRL    Support rails for the chambers (Al)
777   //        USxx    Support cross bars between the chambers (Al)
778   //
779
780   Int_t   iplan = 0;
781
782   Float_t xpos  = 0.0;
783   Float_t ypos  = 0.0;
784   Float_t zpos  = 0.0;
785
786   Char_t  cTagV[5];
787
788   //
789   // The chamber support rails
790   //
791
792   const Float_t kSRLwid  = 2.0;
793   const Float_t kSRLhgt  = 2.3;
794   const Float_t kSRLdst  = 0.6;
795   const Int_t   kNparSRL = 3;
796   Float_t parSRL[kNparSRL];
797   parSRL[0] = kSRLwid/2.;
798   parSRL[1] = fgkSlenTR1/2.;
799   parSRL[2] = kSRLhgt/2.;
800   gMC->Gsvolu("USRL","BOX ",idtmed[1301-1],parSRL,kNparSRL);
801
802   xpos  = 0.0;
803   ypos  = 0.0;
804   zpos  = 0.0;
805   for (iplan = 0; iplan < kNplan; iplan++) {
806     
807     xpos  = fCwidth[iplan]/2. + kSRLwid/2. + kSRLdst;
808     ypos  = 0.0;
809     zpos  = fgkCraH + fgkCdrH - fgkSheight/2. - kSRLhgt/2. 
810           + iplan * (fgkCH + fgkVspace);
811     gMC->Gspos("USRL",iplan+1         ,"UTI1", xpos,ypos,zpos,0,"ONLY");
812     gMC->Gspos("USRL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,0,"ONLY");
813     if (fPHOShole) {
814       gMC->Gspos("USRL",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,0,"ONLY");
815       gMC->Gspos("USRL",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,0,"ONLY");
816     }
817     if (fRICHhole) {
818       gMC->Gspos("USRL",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,0,"ONLY");
819       gMC->Gspos("USRL",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,0,"ONLY");
820     }
821
822   }
823
824   //
825   // The cross bars between the chambers
826   //
827
828   const Float_t kSCBwid  = 1.0;
829   const Int_t   kNparSCB = 3;
830   Float_t parSCB[kNparSCB];
831   parSCB[1] = kSCBwid/2.;
832   parSCB[2] = fgkCH/2.;
833
834   xpos  = 0.0;
835   ypos  = 0.0;
836   zpos  = 0.0;
837   for (iplan = 0; iplan < kNplan; iplan++) {
838
839     parSCB[0] = fCwidth[iplan]/2. + kSRLdst/2.;
840
841     sprintf(cTagV,"US0%01d",iplan);
842     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
843     xpos  = 0.0;
844     ypos  =   fgkSlenTR1/2. - kSCBwid/2.;
845     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
846     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
847     if (fPHOShole) {
848       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
849     }
850     if (fRICHhole) {
851       gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
852     }
853
854     sprintf(cTagV,"US1%01d",iplan);
855     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
856     xpos  = 0.0;
857     ypos  = fClength[iplan][2]/2. + fClength[iplan][1];
858     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
859     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
860     if (fPHOShole) {
861       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
862     }
863     if (fRICHhole) {
864       ypos += fClength[iplan][0] - fClengthRH[iplan][0];
865       gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
866     }
867
868     sprintf(cTagV,"US2%01d",iplan);
869     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
870     xpos  = 0.0;
871     ypos  = fClength[iplan][2]/2.;
872     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
873     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
874     if (fPHOShole) {
875       ypos += fClength[iplan][1] - fClengthPH[iplan][1];
876       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
877     }
878
879     sprintf(cTagV,"US3%01d",iplan);
880     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
881     xpos  = 0.0;
882     ypos  = - fClength[iplan][2]/2.;
883     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
884     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
885     if (fPHOShole) {
886       ypos -= fClength[iplan][3] - fClengthPH[iplan][3];
887       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
888     }
889
890     sprintf(cTagV,"US4%01d",iplan);
891     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
892     xpos  = 0.0;
893     ypos  = - fClength[iplan][2]/2. - fClength[iplan][1];
894     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
895     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
896     if (fPHOShole) {
897       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
898     }
899     if (fRICHhole) {
900       ypos -= fClength[iplan][4] - fClengthRH[iplan][4];
901       gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
902     }
903
904     sprintf(cTagV,"US5%01d",iplan);
905     gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
906     xpos  = 0.0;
907     ypos  = - fgkSlenTR1/2. + kSCBwid/2.;
908     zpos  = fgkCH/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
909     gMC->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
910     if (fPHOShole) {
911       gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
912     }
913     if (fRICHhole) {
914       gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
915     }
916
917   }
918
919 }
920
921 //_____________________________________________________________________________
922 void AliTRDgeometryFull::CreateServices(Int_t *idtmed)
923 {
924   //
925   // Create the geometry of the services
926   //
927   // Names of the TRD services volumina
928   //
929   //        UTCL    Cooling arterias (Al)
930   //        UTCW    Cooling arterias (Water)
931   //        UUxx    Volumes for the services at the chambers (Air)
932   //        UTPW    Power bars       (Cu)
933   //        UTCP    Cooling pipes    (Al)
934   //        UTCH    Cooling pipes    (Water)
935   //        UTPL    Power lines      (Cu)
936   //        UMCM    Readout MCMs     (G10/Cu/Si)
937   //
938
939   const Int_t kNdet = kNplan * kNcham;
940
941   Int_t   iplan = 0;
942   Int_t   icham = 0;
943
944   Float_t xpos  = 0.0;
945   Float_t ypos  = 0.0;
946   Float_t zpos  = 0.0;
947
948   Char_t  cTagV[5];
949
950   // The rotation matrices
951   const Int_t kNmatrix = 3;
952   Int_t   matrix[kNmatrix];
953   gMC->Matrix(matrix[0],100.0,  0.0, 90.0, 90.0, 10.0,  0.0);
954   gMC->Matrix(matrix[1], 80.0,  0.0, 90.0, 90.0, 10.0,180.0);
955   gMC->Matrix(matrix[2],  0.0,  0.0, 90.0, 90.0, 90.0,  0.0);
956
957   AliTRDparameter *parameter = new AliTRDparameter("par","TRD parameter");
958
959   //
960   // The cooling arterias
961   //
962
963   // Width of the cooling arterias
964   const Float_t kCOLwid  =  0.5; 
965   // Height of the cooling arterias
966   const Float_t kCOLhgt  =  5.5;
967   // Positioning of the cooling 
968   const Float_t kCOLposx =  1.6;
969   const Float_t kCOLposz = -0.2;
970   // Thickness of the walls of the cooling arterias
971   const Float_t kCOLthk  =  0.1;
972   const Int_t   kNparCOL = 3;
973   Float_t parCOL[kNparCOL];
974   parCOL[0]  = kCOLwid/2.;
975   parCOL[1]  = fgkSlenTR1/2.;
976   parCOL[2]  = kCOLhgt/2.;
977   gMC->Gsvolu("UTCL","BOX ",idtmed[1324-1],parCOL,kNparCOL);
978   parCOL[0] -= kCOLthk;
979   parCOL[1]  = fgkSlenTR1/2.;
980   parCOL[2] -= kCOLthk;
981   gMC->Gsvolu("UTCW","BOX ",idtmed[1314-1],parCOL,kNparCOL);
982
983   xpos  = 0.0;
984   ypos  = 0.0;
985   zpos  = 0.0;
986   gMC->Gspos("UTCW",1,"UTCL", xpos,ypos,zpos,0,"ONLY");
987
988   for (iplan = 1; iplan < kNplan; iplan++) {
989     
990     xpos  = fCwidth[iplan]/2. + kCOLwid/2. + kCOLposx;
991     ypos  = 0.0;
992     zpos  = kCOLhgt/2. - fgkSheight/2. + kCOLposz + iplan * (fgkCH + fgkVspace);
993     gMC->Gspos("UTCL",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
994     gMC->Gspos("UTCL",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
995     if (fPHOShole) {
996       gMC->Gspos("UTCL",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,matrix[0],"ONLY");
997       gMC->Gspos("UTCL",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,matrix[1],"ONLY");
998     }
999     if (fRICHhole) {
1000       gMC->Gspos("UTCL",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,matrix[0],"ONLY");
1001       gMC->Gspos("UTCL",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,matrix[1],"ONLY");
1002     }
1003
1004   }
1005
1006   //
1007   // The power bars
1008   //
1009
1010   const Float_t kPWRwid  =  0.6;
1011   const Float_t kPWRhgt  =  4.5;
1012   const Float_t kPWRposx =  1.05;
1013   const Float_t kPWRposz =  0.9;
1014   const Int_t   kNparPWR = 3;
1015   Float_t parPWR[kNparPWR];
1016   parPWR[0] = kPWRwid/2.;
1017   parPWR[1] = fgkSlenTR1/2.;
1018   parPWR[2] = kPWRhgt/2.;
1019   gMC->Gsvolu("UTPW","BOX ",idtmed[1325-1],parPWR,kNparPWR);
1020
1021   for (iplan = 1; iplan < kNplan; iplan++) {
1022     
1023     xpos  = fCwidth[iplan]/2. + kPWRwid/2. + kPWRposx;
1024     ypos  = 0.0;
1025     zpos  = kPWRhgt/2. - fgkSheight/2. + kPWRposz + iplan * (fgkCH + fgkVspace);
1026     gMC->Gspos("UTPW",iplan+1         ,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
1027     gMC->Gspos("UTPW",iplan+1+  kNplan,"UTI1",-xpos,ypos,zpos,matrix[1],"ONLY");
1028     if (fPHOShole) {
1029       gMC->Gspos("UTPW",iplan+1+2*kNplan,"UTI2", xpos,ypos,zpos,matrix[0],"ONLY");
1030       gMC->Gspos("UTPW",iplan+1+3*kNplan,"UTI2",-xpos,ypos,zpos,matrix[1],"ONLY");
1031     }
1032     if (fRICHhole) {
1033       gMC->Gspos("UTPW",iplan+1+4*kNplan,"UTI3", xpos,ypos,zpos,matrix[0],"ONLY");
1034       gMC->Gspos("UTPW",iplan+1+5*kNplan,"UTI3",-xpos,ypos,zpos,matrix[1],"ONLY");
1035     }
1036
1037   }
1038
1039   //
1040   // The volumes for the services at the chambers
1041   //
1042
1043   const Int_t kNparServ = 3;
1044   Float_t parServ[kNparServ];
1045
1046   for (icham = 0; icham < kNcham; icham++) {
1047     //for (iplan = 0; iplan < kNplan; iplan++) {
1048     // Take out upper plane until TRD mothervolume is adjusted
1049     for (iplan = 0; iplan < kNplan-1; iplan++) {
1050
1051       Int_t iDet = GetDetectorSec(iplan,icham);
1052
1053       sprintf(cTagV,"UU%02d",iDet);
1054       parServ[0] = fCwidth[iplan]/2.;
1055       parServ[1] = fClength[iplan][icham]/2. - fgkHspace/2.;
1056       parServ[2] = fgkVspace/2.;
1057       gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
1058       xpos  = 0.;
1059       ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
1060       for (Int_t ic = 0; ic < icham; ic++) {
1061         ypos += fClength[iplan][ic];        
1062       }
1063       ypos += fClength[iplan][icham]/2.;
1064       zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
1065       gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
1066
1067       if (fPHOShole) {
1068         if (fClengthPH[iplan][icham] > 0.0) {
1069           sprintf(cTagV,"UU%02d",iDet+kNdet);
1070           parServ[0] = fCwidth[iplan]/2.;
1071           parServ[1] = fClengthPH[iplan][icham]/2. - fgkHspace/2.;
1072           parServ[2] = fgkVspace/2.;
1073           gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
1074           xpos  = 0.;
1075           ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
1076           for (Int_t ic = 0; ic < icham; ic++) {
1077             ypos += fClength[iplan][ic];        
1078           }
1079           if (icham > 2) {
1080             ypos += fClength[iplan][icham];
1081             ypos -= fClengthPH[iplan][icham]/2.;
1082           }
1083           else {
1084             ypos += fClengthPH[iplan][icham]/2.;
1085           }
1086           zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
1087           gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
1088         }
1089       }
1090
1091       if (fRICHhole) {
1092         if (fClengthRH[iplan][icham] > 0.0) {
1093           sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1094           parServ[0] = fCwidth[iplan]/2.;
1095           parServ[1] = fClengthRH[iplan][icham]/2. - fgkHspace/2.;
1096           parServ[2] = fgkVspace/2.;
1097           gMC->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
1098           xpos  = 0.;
1099           ypos  = - fClength[iplan][0] - fClength[iplan][1] - fClength[iplan][2]/2.;
1100           for (Int_t ic = 0; ic < icham; ic++) {
1101             ypos += fClength[iplan][ic];        
1102           }
1103           if (icham > 2) {
1104             ypos += fClength[iplan][icham];
1105             ypos -= fClengthRH[iplan][icham]/2.;
1106           }
1107           else {
1108             ypos += fClengthRH[iplan][icham]/2.;
1109           }
1110           zpos  = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
1111           gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
1112         }
1113       }
1114
1115     }
1116   }
1117
1118   //
1119   // The cooling pipes inside the service volumes
1120   //
1121
1122   const Int_t kNparTube = 3;
1123   Float_t parTube[kNparTube];
1124   // The aluminum pipe for the cooling
1125   parTube[0] = 0.0;
1126   parTube[1] = 0.0;
1127   parTube[2] = 0.0;
1128   gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
1129   // The cooling water
1130   parTube[0] =  0.0;
1131   parTube[1] =  0.2/2.;
1132   parTube[2] = -1.;
1133   gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
1134   // Water inside the cooling pipe
1135   xpos = 0.0;
1136   ypos = 0.0;
1137   zpos = 0.0;
1138   gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
1139
1140   // Position the cooling pipes in the mother volume
1141   const Int_t kNpar = 3;
1142   Float_t par[kNpar];
1143   for (icham = 0; icham < kNcham;   icham++) {
1144     //for (iplan = 0; iplan < kNplan; iplan++) {
1145     // Take out upper plane until TRD mothervolume is adjusted
1146     for (iplan = 0; iplan < kNplan-1; iplan++) { 
1147       Int_t   iDet    = GetDetectorSec(iplan,icham);
1148       Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
1149       Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
1150       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
1151                       / ((Float_t) nMCMrow);
1152       sprintf(cTagV,"UU%02d",iDet);
1153       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1154         xpos   = 0.0;
1155         ypos   = (0.5 + iMCMrow) * ySize - 1.9 
1156                - fClength[iplan][icham]/2. + fgkHspace/2.;
1157         zpos   = 0.0;                 
1158         par[0] = 0.0;
1159         par[1] = 0.3/2.; // Thickness of the cooling pipes
1160         par[2] = fCwidth[iplan]/2.;
1161         gMC->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
1162                           ,matrix[2],"ONLY",par,kNpar);
1163       }
1164       if (fPHOShole) {
1165         sprintf(cTagV,"UU%02d",iDet+kNdet);
1166         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1167           xpos   = 0.0;
1168           ypos   = (0.5 + iMCMrow) * ySize - 1.9 
1169                  - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
1170           zpos   = 0.0;                 
1171           if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
1172             par[0] = 0.0;
1173             par[1] = 0.3/2.; // Thickness of the cooling pipes
1174             par[2] = fCwidth[iplan]/2.;
1175             gMC->Gsposp("UTCP",iCopy+iMCMrow+nMCMrow,cTagV,xpos,ypos,zpos
1176                               ,matrix[2],"ONLY",par,kNpar);
1177           }
1178         }
1179       }
1180       if (fRICHhole) {
1181         sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1182         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1183           xpos   = 0.0;
1184           ypos   = (0.5 + iMCMrow) * ySize - 1.9 
1185                  - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
1186           zpos   = 0.0;                 
1187           if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
1188             par[0] = 0.0;
1189             par[1] = 0.3/2.; // Thickness of the cooling pipes
1190             par[2] = fCwidth[iplan]/2.;
1191             gMC->Gsposp("UTCP",iCopy+iMCMrow+2*nMCMrow,cTagV,xpos,ypos,zpos
1192                               ,matrix[2],"ONLY",par,kNpar);
1193           }
1194         }
1195       }
1196     }
1197   }
1198
1199   //
1200   // The power lines
1201   //
1202
1203   // The copper power lines
1204   parTube[0] = 0.0;
1205   parTube[1] = 0.0;
1206   parTube[2] = 0.0;
1207   gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
1208
1209   // Position the power lines in the mother volume
1210   for (icham = 0; icham < kNcham;   icham++) {
1211     //for (iplan = 0; iplan < kNplan; iplan++) {
1212     // Take out upper plane until TRD mothervolume is adjusted
1213     for (iplan = 0; iplan < kNplan-1; iplan++) { 
1214       Int_t   iDet    = GetDetectorSec(iplan,icham);
1215       Int_t   iCopy   = GetDetector(iplan,icham,0) * 100;
1216       Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
1217       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
1218                       / ((Float_t) nMCMrow);
1219       sprintf(cTagV,"UU%02d",iDet);
1220       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1221         xpos   = 0.0;
1222         ypos   = (0.5 + iMCMrow) * ySize - 1.0 
1223                - fClength[iplan][icham]/2. + fgkHspace/2.;
1224         zpos   = -0.4;
1225         par[0] = 0.0;
1226         par[1] = 0.2/2.; // Thickness of the power lines
1227         par[2] = fCwidth[iplan]/2.;
1228         gMC->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
1229                           ,matrix[2],"ONLY",par,kNpar);
1230       }
1231       if (fPHOShole) {
1232         sprintf(cTagV,"UU%02d",iDet+kNdet);
1233         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1234           xpos   = 0.0;
1235           ypos   = (0.5 + iMCMrow) * ySize - 1.0 
1236                  - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
1237           zpos   = -0.4;                 
1238           if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
1239             par[0] = 0.0;
1240             par[1] = 0.2/2.; // Thickness of the power lines
1241             par[2] = fCwidth[iplan]/2.;
1242             gMC->Gsposp("UTPL",iCopy+iMCMrow+nMCMrow,cTagV,xpos,ypos,zpos
1243                               ,matrix[2],"ONLY",par,kNpar);
1244           }
1245         }
1246       }
1247       if (fRICHhole) {
1248         sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1249         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1250           xpos   = 0.0;
1251           ypos   = (0.5 + iMCMrow) * ySize - 1.0 
1252                  - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
1253           zpos   = -0.4;                 
1254           if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
1255             par[0] = 0.0;
1256             par[1] = 0.2/2.; // Thickness of the power lines
1257             par[2] = fCwidth[iplan]/2.;
1258             gMC->Gsposp("UTPL",iCopy+iMCMrow+2*nMCMrow,cTagV,xpos,ypos,zpos
1259                               ,matrix[2],"ONLY",par,kNpar);
1260           }
1261         }
1262       }
1263     }
1264   }
1265
1266   //
1267   // The MCMs
1268   //
1269
1270   // The mother volume for the MCMs (air)
1271   const Int_t kNparMCM = 3;
1272   Float_t parMCM[kNparMCM];
1273   parMCM[0] = 3.0/2.;
1274   parMCM[1] = 3.0/2.;
1275   parMCM[2] = 0.14/2.;
1276   gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
1277
1278   // The MCM carrier G10 layer
1279   parMCM[0] = 3.0/2.;
1280   parMCM[1] = 3.0/2.;
1281   parMCM[2] = 0.1/2.;
1282   gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
1283   // The MCM carrier Cu layer
1284   parMCM[0] = 3.0/2.;
1285   parMCM[1] = 3.0/2.;
1286   parMCM[2] = 0.0162/2.;
1287   gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
1288   // The silicon of the chips
1289   parMCM[0] = 3.0/2.;
1290   parMCM[1] = 3.0/2.;
1291   parMCM[2] = 0.003/2.;
1292   gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
1293
1294   // Put the MCM material inside the MCM mother volume
1295   xpos  =  0.0;
1296   ypos  =  0.0;
1297   zpos  = -0.07      + 0.1/2.;
1298   gMC->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
1299   zpos +=  0.1/2.    + 0.0162/2.;
1300   gMC->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
1301   zpos +=  0.00162/2 + 0.003/2.;
1302   gMC->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
1303
1304   // Position the MCMs in the mother volume
1305   for (icham = 0; icham < kNcham;   icham++) {
1306     //for (iplan = 0; iplan < kNplan; iplan++) {
1307     // Take out upper plane until TRD mothervolume is adjusted
1308     for (iplan = 0; iplan < kNplan-1; iplan++) { 
1309       Int_t   iDet    = GetDetectorSec(iplan,icham);
1310       Int_t   iCopy   = GetDetector(iplan,icham,0) * 1000;
1311       Int_t   nMCMrow = parameter->GetRowMax(iplan,icham,0);
1312       Float_t ySize   = (GetChamberLength(iplan,icham) - 2.*fgkRpadW) 
1313                       / ((Float_t) nMCMrow);
1314       Int_t   nMCMcol = 8;
1315       Float_t xSize   = (GetChamberWidth(iplan) - 2.* fgkCpadW)
1316                       / ((Float_t) nMCMcol);
1317       sprintf(cTagV,"UU%02d",iDet);
1318       for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1319         for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
1320           xpos   = (0.5 + iMCMcol) * xSize + 1.0 
1321                  - fCwidth[iplan]/2.;
1322           ypos   = (0.5 + iMCMrow) * ySize + 1.0 
1323                  - fClength[iplan][icham]/2. + fgkHspace/2.;
1324           zpos   = -0.4;
1325           par[0] = 0.0;
1326           par[1] = 0.2/2.; // Thickness of the power lines
1327           par[2] = fCwidth[iplan]/2.;
1328           gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
1329                            ,xpos,ypos,zpos,0,"ONLY");
1330         }
1331       }
1332       if (fPHOShole) {
1333         sprintf(cTagV,"UU%02d",iDet+kNdet);
1334         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1335           for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
1336             xpos   = (0.5 + iMCMcol) * xSize + 1.0 
1337                    - fCwidth[iplan]/2.;
1338             ypos   = (0.5 + iMCMrow) * ySize + 1.0 
1339                    - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
1340             zpos   = -0.4;
1341             if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
1342               par[0] = 0.0;
1343               par[1] = 0.2/2.; // Thickness of the power lines
1344               par[2] = fCwidth[iplan]/2.;
1345               gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol+10*nMCMrow,cTagV
1346                                ,xpos,ypos,zpos,0,"ONLY");
1347             }
1348           }
1349         }
1350       }
1351       if (fPHOShole) {
1352         sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1353         for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1354           for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
1355             xpos   = (0.5 + iMCMcol) * xSize + 1.0 
1356                    - fCwidth[iplan]/2.;
1357             ypos   = (0.5 + iMCMrow) * ySize + 1.0 
1358                    - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
1359             zpos   = -0.4;
1360             if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
1361               par[0] = 0.0;
1362               par[1] = 0.2/2.; // Thickness of the power lines
1363               par[2] = fCwidth[iplan]/2.;
1364               gMC->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol+20*nMCMrow,cTagV
1365                                ,xpos,ypos,zpos,0,"ONLY");
1366             }
1367           }
1368         }
1369       }
1370
1371     }
1372   }
1373
1374   delete parameter;
1375
1376 }
1377
1378 //_____________________________________________________________________________
1379 void AliTRDgeometryFull::SetOldGeometry()
1380 {
1381   //
1382   // Use the old chamber lengths
1383   //
1384
1385   Int_t icham;
1386   Int_t iplan;
1387
1388   AliTRDgeometry::SetOldGeometry();
1389
1390   Float_t lengthPH[kNplan][kNcham] = { { 123.5, 116.5,   0.0, 116.5, 123.5 }
1391                                      , { 131.0, 124.0,   0.0, 124.0, 131.0 }
1392                                      , { 134.5, 131.5,   0.0, 131.5, 134.5 }
1393                                      , { 142.0, 139.0,   0.0, 139.0, 142.0 }
1394                                      , { 142.0, 146.0,   0.0, 146.0, 142.0 }
1395                                      , { 134.5, 153.5,   0.0, 153.5, 134.5 } };
1396
1397   Float_t lengthRH[kNplan][kNcham] = { {  86.5,   0.0,   0.0,   0.0,  86.5 }
1398                                      , { 101.5,   0.0,   0.0,   0.0, 101.5 }
1399                                      , { 112.5,   0.0,   0.0,   0.0, 112.5 }
1400                                      , { 127.5,   0.0,   0.0,   0.0, 127.5 }
1401                                      , { 134.5,   0.0,   0.0,   0.0, 134.5 }
1402                                      , { 134.5,   0.0,   0.0,   0.0, 134.5 } };
1403                                                                                
1404   for (icham = 0; icham < kNcham; icham++) {
1405     for (iplan = 0; iplan < kNplan; iplan++) {
1406       fClengthPH[iplan][icham] = lengthPH[iplan][icham];
1407       fClengthRH[iplan][icham] = lengthRH[iplan][icham];
1408     }
1409   }
1410
1411 }