1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 Revision 1.10 2002/11/21 22:38:47 alibrary
19 Removing AliMC and AliMCProcess
21 Revision 1.9 2002/10/31 17:45:35 cblume
24 Revision 1.8 2002/02/11 14:21:16 cblume
25 Update of the geometry. Get rid of MANY
27 Revision 1.7 2001/05/11 07:56:12 hristov
28 Consistent declarations needed on Alpha
30 Revision 1.6 2001/02/14 18:22:26 cblume
31 Change in the geometry of the padplane
33 Revision 1.5 2000/11/01 14:53:21 cblume
34 Merge with TRD-develop
36 Revision 1.1.4.6 2000/10/15 23:40:01 cblume
39 Revision 1.1.4.5 2000/10/06 16:49:46 cblume
42 Revision 1.1.4.4 2000/10/04 16:34:58 cblume
43 Replace include files by forward declarations
45 Revision 1.1.4.3 2000/09/22 14:43:41 cblume
46 Allow the pad/timebin-dimensions to be changed after initialization
48 Revision 1.4 2000/10/02 21:28:19 fca
49 Removal of useless dependecies via forward declarations
51 Revision 1.3 2000/06/08 18:32:58 cblume
52 Make code compliant to coding conventions
54 Revision 1.2 2000/05/08 16:17:27 cblume
57 Revision 1.1.4.2 2000/05/08 14:46:44 cblume
58 Include options SetPHOShole() and SetRICHhole()
60 Revision 1.1.4.1 2000/04/27 12:46:04 cblume
61 Corrected bug in full geometry
63 Revision 1.1 2000/02/28 19:01:15 cblume
68 ///////////////////////////////////////////////////////////////////////////////
70 // TRD geometry for the spaceframe without holes //
72 ///////////////////////////////////////////////////////////////////////////////
74 #include "TVirtualMC.h"
76 #include "AliTRDgeometryFull.h"
77 #include "AliTRDparameter.h"
79 ClassImp(AliTRDgeometryFull)
81 //_____________________________________________________________________________
82 AliTRDgeometryFull::AliTRDgeometryFull():AliTRDgeometry()
85 // AliTRDgeometryFull default constructor
92 //_____________________________________________________________________________
93 AliTRDgeometryFull::~AliTRDgeometryFull()
96 // AliTRDgeometryFull destructor
101 //_____________________________________________________________________________
102 void AliTRDgeometryFull::Init()
105 // Initializes the geometry parameter
114 // The outer lengths of the chambers for the sectors with holes for the PHOS
115 Float_t lengthPH[kNplan][kNcham] = { { 124.0, 117.0, 0.0, 117.0, 124.0 }
116 , { 131.0, 124.0, 0.0, 124.0, 131.0 }
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 } };
122 // The outer lengths of the chambers for the sectors with holes for the RICH
123 Float_t lengthRH[kNplan][kNcham] = { { 87.5, 0.0, 0.0, 0.0, 87.5 }
124 , { 101.5, 0.0, 0.0, 0.0, 101.5 }
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 } };
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];
139 //_____________________________________________________________________________
140 void AliTRDgeometryFull::CreateGeometry(Int_t *idtmed)
143 // Create the TRD geometry without hole
146 // Names of the TRD volumina (xx = detector number):
148 // Lower part of the readout chambers (gas volume + radiator)
150 // UAxx Aluminum frames (Al)
151 // UBxx G10 frames (C)
152 // UCxx Inner volumes (Air)
154 // Upper part of the readout chambers (readout plane + fee)
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)
161 // Inner material layers
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)
171 const Int_t kNdet = kNplan * kNcham;
173 const Int_t kNparTrd = 4;
174 const Int_t kNparCha = 3;
176 Float_t xpos, ypos, zpos;
178 Float_t parTrd[kNparTrd];
179 Float_t parCha[kNparCha];
184 AliTRDgeometry::CreateGeometry(idtmed);
186 // The TRD mother volume for one sector (Air), full length in z-direction
187 // Provides material for side plates of super module
188 parTrd[0] = fgkSwidth1/2.;
189 parTrd[1] = fgkSwidth2/2.;
190 parTrd[2] = fgkSlenTR1/2.;
191 parTrd[3] = fgkSheight/2.;
192 gMC->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
193 // The TRD mother volume for one sector (Al), leaving hole for PHOS
195 gMC->Gsvolu("UTR2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
197 // The TRD mother volume for one sector (Al), leaving hole for RICH
199 gMC->Gsvolu("UTR3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
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
211 gMC->Gsvolu("UTS2","TRD1",idtmed[1301-1],parTrd,kNparTrd);
213 // The TRD mother volume for one sector (Al), leaving hole for RICH
215 gMC->Gsvolu("UTS3","TRD1",idtmed[1301-1],parTrd,kNparTrd);
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
227 gMC->Gsvolu("UTI2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
229 // The TRD mother volume for one sector (Air), leaving hole for RICH
231 gMC->Gsvolu("UTI3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
234 for (Int_t icham = 0; icham < kNcham; icham++) {
235 for (Int_t iplan = 0; iplan < kNplan; iplan++) {
237 Int_t iDet = GetDetectorSec(iplan,icham);
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);
247 sprintf(cTagV,"UB%02d",iDet);
248 parCha[0] = fCwidth[iplan]/2. - fgkCalT;
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;
257 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
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);
267 sprintf(cTagV,"UB%02d",iDet+kNdet);
268 parCha[0] = fCwidth[iplan]/2. - fgkCalT;
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;
277 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
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);
289 sprintf(cTagV,"UB%02d",iDet+2*kNdet);
290 parCha[0] = fCwidth[iplan]/2. - fgkCalT;
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;
299 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
303 // The upper part of the readout chambers (readout plane)
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;
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;
327 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
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;
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;
352 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
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;
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;
379 gMC->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
383 // The material layers inside the chambers
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);
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);
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);
467 // Position the layers in the chambers
471 // Rohacell layer (radiator)
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)
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)
483 sprintf(cTagV,"UJ%02d",iDet);
484 sprintf(cTagM,"UC%02d",iDet);
485 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
487 // Xe/Isobutane layer (amplification volume)
489 sprintf(cTagV,"UK%02d",iDet);
490 sprintf(cTagM,"UE%02d",iDet);
491 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
493 // Cu layer (pad plane)
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)
500 sprintf(cTagV,"UM%02d",iDet);
501 sprintf(cTagM,"UG%02d",iDet);
502 gMC->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
504 if (fClengthPH[iplan][icham] > 0.0) {
506 // Rohacell layer (radiator)
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)
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)
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");
522 // Xe/Isobutane layer (amplification volume)
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");
528 // Cu layer (pad plane)
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)
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");
541 if (fClengthRH[iplan][icham] > 0.0) {
543 // Rohacell layer (radiator)
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)
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)
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");
559 // Xe/Isobutane layer (amplification volume)
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");
565 // Cu layer (pad plane)
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)
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");
578 // Position the inner volumes of the chambers in the frames
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");
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");
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");
639 // Position the frames of the chambers in the TRD mother volume
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];
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);
649 gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
650 // The upper G10 frame, amplification region
651 sprintf(cTagV,"UD%02d",iDet);
652 zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
653 gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
654 // The upper aluminum frame
655 sprintf(cTagV,"UF%02d",iDet);
656 zpos += fgkCroH/2. + fgkCamH/2.;
657 gMC->Gspos(cTagV,1,"UTI1",xpos,ypos,zpos,0,"ONLY");
659 if (fClengthPH[iplan][icham] > 0.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];
666 ypos += fClength[iplan][icham];
667 ypos -= fClengthPH[iplan][icham]/2.;
670 ypos += fClengthPH[iplan][icham]/2.;
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);
675 gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
676 // The upper G10 frame, amplification region
677 sprintf(cTagV,"UD%02d",iDet+kNdet);
678 zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
679 gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
680 // The upper aluminum frame
681 sprintf(cTagV,"UF%02d",iDet+kNdet);
682 zpos += fgkCroH/2. + fgkCamH/2.;
683 gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
687 if (fClengthRH[iplan][icham] > 0.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];
694 ypos += fClength[iplan][icham];
695 ypos -= fClengthRH[iplan][icham]/2.;
698 ypos += fClengthRH[iplan][icham]/2.;
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);
703 gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
704 // The upper G10 frame, amplification region
705 sprintf(cTagV,"UD%02d",iDet+2*kNdet);
706 zpos += fgkCamH/2. + fgkCraH/2. + fgkCdrH/2.;
707 gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
708 // The upper aluminum frame
709 sprintf(cTagV,"UF%02d",iDet+2*kNdet);
710 zpos += fgkCroH/2. + fgkCamH/2.;
711 gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
721 gMC->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
723 gMC->Gspos("UTI2",2,"UTS2",xpos,ypos,zpos,0,"ONLY");
726 gMC->Gspos("UTI3",3,"UTS3",xpos,ypos,zpos,0,"ONLY");
732 gMC->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
734 gMC->Gspos("UTS2",2,"UTR2",xpos,ypos,zpos,0,"ONLY");
737 gMC->Gspos("UTS3",3,"UTR3",xpos,ypos,zpos,0,"ONLY");
743 gMC->Gspos("UTR1",1,"BTR1",xpos,ypos,zpos,0,"ONLY");
745 gMC->Gspos("UTR2",2,"BTR2",xpos,ypos,zpos,0,"ONLY");
748 gMC->Gspos("UTR1",2,"BTR2",xpos,ypos,zpos,0,"ONLY");
751 gMC->Gspos("UTR3",3,"BTR3",xpos,ypos,zpos,0,"ONLY");
754 gMC->Gspos("UTR1",3,"BTR3",xpos,ypos,zpos,0,"ONLY");
757 // Create the volumes of the super module frame
760 // Create the volumes of the services
761 CreateServices(idtmed);
765 //_____________________________________________________________________________
766 void AliTRDgeometryFull::CreateFrame(Int_t *idtmed)
769 // Create the geometry of the frame of the supermodule
771 // Names of the TRD services volumina
773 // USRL Support rails for the chambers (Al)
774 // USxx Support cross bars between the chambers (Al)
786 // The chamber support rails
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);
802 for (iplan = 0; iplan < kNplan; iplan++) {
804 xpos = fCwidth[iplan]/2. + kSRLwid/2. + kSRLdst;
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");
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");
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");
822 // The cross bars between the chambers
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.;
834 for (iplan = 0; iplan < kNplan; iplan++) {
836 parSCB[0] = fCwidth[iplan]/2. + kSRLdst/2.;
838 sprintf(cTagV,"US0%01d",iplan);
839 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
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");
845 gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
848 gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
851 sprintf(cTagV,"US1%01d",iplan);
852 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
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");
858 gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
861 ypos += fClength[iplan][0] - fClengthRH[iplan][0];
862 gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
865 sprintf(cTagV,"US2%01d",iplan);
866 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
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");
872 ypos += fClength[iplan][1] - fClengthPH[iplan][1];
873 gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
876 sprintf(cTagV,"US3%01d",iplan);
877 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
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");
883 ypos -= fClength[iplan][3] - fClengthPH[iplan][3];
884 gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
887 sprintf(cTagV,"US4%01d",iplan);
888 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
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");
894 gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
897 ypos -= fClength[iplan][4] - fClengthRH[iplan][4];
898 gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
901 sprintf(cTagV,"US5%01d",iplan);
902 gMC->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
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");
908 gMC->Gspos(cTagV,2,"UTI2", xpos,ypos,zpos,0,"ONLY");
911 gMC->Gspos(cTagV,3,"UTI3", xpos,ypos,zpos,0,"ONLY");
918 //_____________________________________________________________________________
919 void AliTRDgeometryFull::CreateServices(Int_t *idtmed)
922 // Create the geometry of the services
924 // Names of the TRD services volumina
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)
936 const Int_t kNdet = kNplan * kNcham;
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);
954 AliTRDparameter *parameter = new AliTRDparameter("par","TRD parameter");
957 // The cooling arterias
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);
983 gMC->Gspos("UTCW",1,"UTCL", xpos,ypos,zpos,0,"ONLY");
985 for (iplan = 1; iplan < kNplan; iplan++) {
987 xpos = fCwidth[iplan]/2. + kCOLwid/2. + kCOLposx;
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");
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");
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");
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);
1018 for (iplan = 1; iplan < kNplan; iplan++) {
1020 xpos = fCwidth[iplan]/2. + kPWRwid/2. + kPWRposx;
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");
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");
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");
1037 // The volumes for the services at the chambers
1040 const Int_t kNparServ = 3;
1041 Float_t parServ[kNparServ];
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++) {
1048 Int_t iDet = GetDetectorSec(iplan,icham);
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);
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];
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");
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);
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];
1077 ypos += fClength[iplan][icham];
1078 ypos -= fClengthPH[iplan][icham]/2.;
1081 ypos += fClengthPH[iplan][icham]/2.;
1083 zpos = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
1084 gMC->Gspos(cTagV,1,"UTI2",xpos,ypos,zpos,0,"ONLY");
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);
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];
1101 ypos += fClength[iplan][icham];
1102 ypos -= fClengthRH[iplan][icham]/2.;
1105 ypos += fClengthRH[iplan][icham]/2.;
1107 zpos = fgkCH + fgkVspace/2. - fgkSheight/2. + iplan * (fgkCH + fgkVspace);
1108 gMC->Gspos(cTagV,1,"UTI3",xpos,ypos,zpos,0,"ONLY");
1116 // The cooling pipes inside the service volumes
1119 const Int_t kNparTube = 3;
1120 Float_t parTube[kNparTube];
1121 // The aluminum pipe for the cooling
1125 gMC->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
1126 // The cooling water
1128 parTube[1] = 0.2/2.;
1130 gMC->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
1131 // Water inside the cooling pipe
1135 gMC->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
1137 // Position the cooling pipes in the mother volume
1138 const Int_t kNpar = 3;
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++) {
1152 ypos = (0.5 + iMCMrow) * ySize - 1.9
1153 - fClength[iplan][icham]/2. + fgkHspace/2.;
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);
1162 sprintf(cTagV,"UU%02d",iDet+kNdet);
1163 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1165 ypos = (0.5 + iMCMrow) * ySize - 1.9
1166 - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
1168 if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
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);
1178 sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1179 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1181 ypos = (0.5 + iMCMrow) * ySize - 1.9
1182 - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
1184 if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
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);
1200 // The copper power lines
1204 gMC->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
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++) {
1219 ypos = (0.5 + iMCMrow) * ySize - 1.0
1220 - fClength[iplan][icham]/2. + fgkHspace/2.;
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);
1229 sprintf(cTagV,"UU%02d",iDet+kNdet);
1230 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1232 ypos = (0.5 + iMCMrow) * ySize - 1.0
1233 - fClengthPH[iplan][icham]/2. + fgkHspace/2.;
1235 if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
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);
1245 sprintf(cTagV,"UU%02d",iDet+2*kNdet);
1246 for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
1248 ypos = (0.5 + iMCMrow) * ySize - 1.0
1249 - fClengthRH[iplan][icham]/2. + fgkHspace/2.;
1251 if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
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);
1267 // The mother volume for the MCMs (air)
1268 const Int_t kNparMCM = 3;
1269 Float_t parMCM[kNparMCM];
1272 parMCM[2] = 0.14/2.;
1273 gMC->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
1275 // The MCM carrier G10 layer
1279 gMC->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
1280 // The MCM carrier Cu layer
1283 parMCM[2] = 0.0162/2.;
1284 gMC->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
1285 // The silicon of the chips
1288 parMCM[2] = 0.003/2.;
1289 gMC->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
1291 // Put the MCM material inside the MCM mother volume
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");
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);
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.;
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");
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.;
1338 if (ypos < (fClengthPH[iplan][icham]/2. - fgkHspace/2.)) {
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");
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.;
1357 if (ypos < (fClengthRH[iplan][icham]/2. - fgkHspace/2.)) {
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");
1375 //_____________________________________________________________________________
1376 void AliTRDgeometryFull::SetOldGeometry()
1379 // Use the old chamber lengths
1385 AliTRDgeometry::SetOldGeometry();
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 } };
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 } };
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];