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