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