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