Line data Source code
1 : /**************************************************************************
2 : * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 : * *
4 : * Author: The ALICE Off-line Project. *
5 : * Contributors are mentioned in the code where appropriate. *
6 : * *
7 : * Permission to use, copy, modify and distribute this software and its *
8 : * documentation strictly for non-commercial purposes is hereby granted *
9 : * without fee, provided that the above copyright notice appears in all *
10 : * copies and that both the copyright notice and this permission notice *
11 : * appear in the supporting documentation. The authors make no claims *
12 : * about the suitability of this software for any purpose. It is *
13 : * provided "as is" without express or implied warranty. *
14 : **************************************************************************/
15 :
16 : /* $Id$ */
17 :
18 : ///////////////////////////////////////////////////////////////////////////////
19 : // //
20 : // TRD geometry class //
21 : // //
22 : ///////////////////////////////////////////////////////////////////////////////
23 :
24 : #include <TGeoManager.h>
25 : #include <TGeoPhysicalNode.h>
26 : #include <TVirtualMC.h>
27 : #include <TMath.h>
28 :
29 : #include "AliLog.h"
30 : #include "AliAlignObjParams.h"
31 :
32 : #include "AliTRDgeometry.h"
33 : #include "AliTRDpadPlane.h"
34 :
35 48 : ClassImp(AliTRDgeometry)
36 :
37 : //_____________________________________________________________________________
38 :
39 : //
40 : // The geometry constants
41 : //
42 : const Int_t AliTRDgeometry::fgkNsector = kNsector;
43 : const Int_t AliTRDgeometry::fgkNlayer = kNlayer;
44 : const Int_t AliTRDgeometry::fgkNstack = kNstack;
45 : const Int_t AliTRDgeometry::fgkNdet = kNdet;
46 :
47 : //
48 : // Dimensions of the detector
49 : //
50 :
51 : // Total length of the TRD mother volume
52 : const Float_t AliTRDgeometry::fgkTlength = 751.0;
53 :
54 : // Parameter of the super module mother volumes
55 : const Float_t AliTRDgeometry::fgkSheight = 77.9;
56 : const Float_t AliTRDgeometry::fgkSwidth1 = 94.881;
57 : const Float_t AliTRDgeometry::fgkSwidth2 = 122.353;
58 : const Float_t AliTRDgeometry::fgkSlength = 702.0;
59 :
60 : // Length of the additional space in front of the supermodule
61 : // used for services
62 : const Float_t AliTRDgeometry::fgkFlength = (AliTRDgeometry::fgkTlength
63 : - AliTRDgeometry::fgkSlength) / 2.0;
64 :
65 : // The super module side plates
66 : const Float_t AliTRDgeometry::fgkSMpltT = 0.2;
67 :
68 : // Vertical spacing of the chambers
69 : const Float_t AliTRDgeometry::fgkVspace = 1.784;
70 : // Horizontal spacing of the chambers
71 : const Float_t AliTRDgeometry::fgkHspace = 2.0;
72 : // Radial distance of the first ROC to the outer plates of the SM
73 : const Float_t AliTRDgeometry::fgkVrocsm = 1.2;
74 :
75 : // Height of different chamber parts
76 : // Radiator
77 : const Float_t AliTRDgeometry::fgkCraH = 4.8;
78 : // Drift region
79 : const Float_t AliTRDgeometry::fgkCdrH = 3.0;
80 : // Amplification region
81 : const Float_t AliTRDgeometry::fgkCamH = 0.7;
82 : // Readout
83 : const Float_t AliTRDgeometry::fgkCroH = 2.316;
84 : // Additional width of the readout chamber frames
85 : const Float_t AliTRDgeometry::fgkCroW = 0.9;
86 : // Services on top of ROC
87 : const Float_t AliTRDgeometry::fgkCsvH = AliTRDgeometry::fgkVspace
88 : - 0.742;
89 : // Total height (w/o services)
90 : const Float_t AliTRDgeometry::fgkCH = AliTRDgeometry::fgkCraH
91 : + AliTRDgeometry::fgkCdrH
92 : + AliTRDgeometry::fgkCamH
93 : + AliTRDgeometry::fgkCroH;
94 : // Total height (with services)
95 :
96 : const Float_t AliTRDgeometry::fgkCHsv = AliTRDgeometry::fgkCH
97 : + AliTRDgeometry::fgkCsvH;
98 :
99 : // Distance of anode wire plane relative to middle of alignable volume
100 : const Float_t AliTRDgeometry::fgkAnodePos = AliTRDgeometry::fgkCraH
101 : + AliTRDgeometry::fgkCdrH
102 : + AliTRDgeometry::fgkCamH/2.0
103 : - AliTRDgeometry::fgkCHsv/2.0;
104 :
105 : // Thicknesses of different parts of the chamber frame
106 : // Lower aluminum frame
107 : const Float_t AliTRDgeometry::fgkCalT = 0.4;
108 : // Lower Wacosit frame sides
109 : const Float_t AliTRDgeometry::fgkCclsT = 0.21;
110 : // Lower Wacosit frame front
111 : const Float_t AliTRDgeometry::fgkCclfT = 1.0;
112 : // Thickness of glue around radiator
113 : const Float_t AliTRDgeometry::fgkCglT = 0.25;
114 : // Upper Wacosit frame around amplification region
115 : const Float_t AliTRDgeometry::fgkCcuTa = 1.0;
116 : const Float_t AliTRDgeometry::fgkCcuTb = 0.8;
117 : // Al frame of back panel
118 : const Float_t AliTRDgeometry::fgkCauT = 1.5;
119 : // Additional Al ledge at the lower chamber frame
120 : // Actually the dimensions are not realistic, but
121 : // modified in order to allow to mis-alignment.
122 : // The amount of material is, however, correct
123 : const Float_t AliTRDgeometry::fgkCalW = 2.5;
124 : const Float_t AliTRDgeometry::fgkCalH = 0.4;
125 : const Float_t AliTRDgeometry::fgkCalWmod = 0.4;
126 : const Float_t AliTRDgeometry::fgkCalHmod = 2.5;
127 : // Additional Wacosit ledge at the lower chamber frame
128 : const Float_t AliTRDgeometry::fgkCwsW = 1.2;
129 : const Float_t AliTRDgeometry::fgkCwsH = 0.3;
130 :
131 : // Difference of outer chamber width and pad plane width
132 : const Float_t AliTRDgeometry::fgkCpadW = 0.0;
133 : const Float_t AliTRDgeometry::fgkRpadW = 1.0;
134 :
135 : //
136 : // Thickness of the the material layers
137 : //
138 : const Float_t AliTRDgeometry::fgkDrThick = AliTRDgeometry::fgkCdrH;
139 : const Float_t AliTRDgeometry::fgkAmThick = AliTRDgeometry::fgkCamH;
140 : const Float_t AliTRDgeometry::fgkXeThick = AliTRDgeometry::fgkDrThick
141 : + AliTRDgeometry::fgkAmThick;
142 : const Float_t AliTRDgeometry::fgkWrThick = 0.00011;
143 :
144 : const Float_t AliTRDgeometry::fgkRMyThick = 0.0015;
145 : const Float_t AliTRDgeometry::fgkRCbThick = 0.0055;
146 : const Float_t AliTRDgeometry::fgkRGlThick = 0.0065;
147 : const Float_t AliTRDgeometry::fgkRRhThick = 0.8;
148 : const Float_t AliTRDgeometry::fgkRFbThick = fgkCraH - 2.0 * (fgkRMyThick
149 : + fgkRCbThick
150 : + fgkRRhThick);
151 :
152 : const Float_t AliTRDgeometry::fgkPPdThick = 0.0025;
153 : const Float_t AliTRDgeometry::fgkPPpThick = 0.0356;
154 : const Float_t AliTRDgeometry::fgkPGlThick = 0.1428;
155 : const Float_t AliTRDgeometry::fgkPCbThick = 0.019;
156 : const Float_t AliTRDgeometry::fgkPPcThick = 0.0486;
157 : const Float_t AliTRDgeometry::fgkPRbThick = 0.0057;
158 : const Float_t AliTRDgeometry::fgkPElThick = 0.0029;
159 : const Float_t AliTRDgeometry::fgkPHcThick = fgkCroH - fgkPPdThick
160 : - fgkPPpThick
161 : - fgkPGlThick
162 : - fgkPCbThick * 2.0
163 : - fgkPPcThick
164 : - fgkPRbThick
165 : - fgkPElThick;
166 :
167 : //
168 : // Position of the material layers
169 : //
170 : const Float_t AliTRDgeometry::fgkDrZpos = 2.4;
171 : const Float_t AliTRDgeometry::fgkAmZpos = 0.0;
172 : const Float_t AliTRDgeometry::fgkWrZposA = 0.0;
173 : const Float_t AliTRDgeometry::fgkWrZposB = -fgkAmThick/2.0 + 0.001;
174 : const Float_t AliTRDgeometry::fgkCalZpos = 0.3;
175 :
176 : const Int_t AliTRDgeometry::fgkMCMmax = 16;
177 : const Int_t AliTRDgeometry::fgkMCMrow = 4;
178 : const Int_t AliTRDgeometry::fgkROBmaxC0 = 6;
179 : const Int_t AliTRDgeometry::fgkROBmaxC1 = 8;
180 : const Int_t AliTRDgeometry::fgkADCmax = 21;
181 : const Int_t AliTRDgeometry::fgkTBmax = 60;
182 : const Int_t AliTRDgeometry::fgkPadmax = 18;
183 : const Int_t AliTRDgeometry::fgkColmax = 144;
184 : const Int_t AliTRDgeometry::fgkRowmaxC0 = 12;
185 : const Int_t AliTRDgeometry::fgkRowmaxC1 = 16;
186 :
187 : const Double_t AliTRDgeometry::fgkTime0Base = 300.65;
188 168 : const Float_t AliTRDgeometry::fgkTime0[6] = { static_cast<Float_t>(fgkTime0Base + 0 * (Cheight() + Cspace()))
189 24 : , static_cast<Float_t>(fgkTime0Base + 1 * (Cheight() + Cspace()))
190 24 : , static_cast<Float_t>(fgkTime0Base + 2 * (Cheight() + Cspace()))
191 24 : , static_cast<Float_t>(fgkTime0Base + 3 * (Cheight() + Cspace()))
192 24 : , static_cast<Float_t>(fgkTime0Base + 4 * (Cheight() + Cspace()))
193 48 : , static_cast<Float_t>(fgkTime0Base + 5 * (Cheight() + Cspace()))};
194 :
195 : const Double_t AliTRDgeometry::fgkXtrdBeg = 288.43; // Values depend on position of TRD
196 : const Double_t AliTRDgeometry::fgkXtrdEnd = 366.33; // mother volume inside space frame !!!
197 :
198 : // The outer width of the chambers
199 : const Float_t AliTRDgeometry::fgkCwidth[kNlayer] = { 90.4, 94.8, 99.3, 103.7, 108.1, 112.6 };
200 :
201 : // The outer lengths of the chambers
202 : // Includes the spacings between the chambers!
203 : const Float_t AliTRDgeometry::fgkClength[kNlayer][kNstack] = { { 124.0, 124.0, 110.0, 124.0, 124.0 }
204 : , { 124.0, 124.0, 110.0, 124.0, 124.0 }
205 : , { 131.0, 131.0, 110.0, 131.0, 131.0 }
206 : , { 138.0, 138.0, 110.0, 138.0, 138.0 }
207 : , { 145.0, 145.0, 110.0, 145.0, 145.0 }
208 : , { 147.0, 147.0, 110.0, 147.0, 147.0 } };
209 :
210 : Char_t AliTRDgeometry::fgSMstatus[kNsector] = { 1, 1, 1, 1, 1, 1, 1, 1, 1
211 : , 1, 1, 1, 1, 1, 1, 1, 1, 1 };
212 :
213 : TObjArray* AliTRDgeometry::fgClusterMatrixArray = NULL;
214 :
215 : TObjArray* AliTRDgeometry::fgPadPlaneArray = NULL;
216 :
217 : //_____________________________________________________________________________
218 1709 : AliTRDgeometry::AliTRDgeometry()
219 8545 : {
220 : //
221 : // AliTRDgeometry default constructor
222 : //
223 :
224 3418 : }
225 :
226 : //_____________________________________________________________________________
227 : AliTRDgeometry::~AliTRDgeometry()
228 3952 : {
229 : //
230 : // AliTRDgeometry destructor
231 : //
232 :
233 4142 : }
234 :
235 : //_____________________________________________________________________________
236 : void AliTRDgeometry::CreatePadPlaneArray()
237 : {
238 : //
239 : // Creates the array of AliTRDpadPlane objects
240 : //
241 :
242 6 : if (fgPadPlaneArray)
243 : return;
244 :
245 12 : static TObjArray padPlaneArray(fgkNlayer * fgkNstack);
246 3 : padPlaneArray.SetOwner(kTRUE);
247 :
248 3 : fgPadPlaneArray = &padPlaneArray;
249 42 : for (Int_t ilayer = 0; ilayer < fgkNlayer; ilayer++) {
250 216 : for (Int_t istack = 0; istack < fgkNstack; istack++) {
251 90 : Int_t ipp = GetDetectorSec(ilayer,istack);
252 90 : fgPadPlaneArray->AddAt(CreatePadPlane(ilayer,istack),ipp);
253 : }
254 : }
255 :
256 3 : }
257 :
258 : //_____________________________________________________________________________
259 : AliTRDpadPlane *AliTRDgeometry::CreatePadPlane(Int_t ilayer, Int_t istack)
260 : {
261 : //
262 : // Creates an AliTRDpadPlane object
263 : //
264 :
265 180 : AliTRDpadPlane *padPlane = new AliTRDpadPlane();
266 :
267 180 : padPlane->SetLayer(ilayer);
268 180 : padPlane->SetStack(istack);
269 :
270 180 : padPlane->SetRowSpacing(0.0);
271 180 : padPlane->SetColSpacing(0.0);
272 :
273 180 : padPlane->SetLengthRim(1.0);
274 180 : padPlane->SetWidthRim(0.5);
275 :
276 180 : padPlane->SetNcols(144);
277 :
278 180 : padPlane->SetAnodeWireOffset(0.25);
279 :
280 : //
281 : // The pad plane parameter
282 : //
283 : const Float_t kTiltAngle = 2.0;
284 180 : switch (ilayer) {
285 : case 0:
286 15 : if (istack == 2) {
287 : // L0C0 type
288 3 : padPlane->SetNrows(12);
289 3 : padPlane->SetLength(108.0);
290 3 : padPlane->SetLengthOPad(8.0);
291 3 : padPlane->SetLengthIPad(9.0);
292 3 : }
293 : else {
294 : // L0C1 type
295 12 : padPlane->SetNrows(16);
296 12 : padPlane->SetLength(122.0);
297 12 : padPlane->SetLengthOPad(7.5);
298 12 : padPlane->SetLengthIPad(7.5);
299 : }
300 15 : padPlane->SetWidth(92.2);
301 15 : padPlane->SetWidthOPad(0.515);
302 15 : padPlane->SetWidthIPad(0.635);
303 15 : padPlane->SetTiltingAngle(-kTiltAngle);
304 15 : break;
305 : case 1:
306 15 : if (istack == 2) {
307 : // L1C0 type
308 3 : padPlane->SetNrows(12);
309 3 : padPlane->SetLength(108.0);
310 3 : padPlane->SetLengthOPad(8.0);
311 3 : padPlane->SetLengthIPad(9.0);
312 3 : }
313 : else {
314 : // L1C1 type
315 12 : padPlane->SetNrows(16);
316 12 : padPlane->SetLength(122.0);
317 12 : padPlane->SetLengthOPad(7.5);
318 12 : padPlane->SetLengthIPad(7.5);
319 : }
320 15 : padPlane->SetWidth(96.6);
321 15 : padPlane->SetWidthOPad(0.585);
322 15 : padPlane->SetWidthIPad(0.665);
323 15 : padPlane->SetTiltingAngle(kTiltAngle);
324 15 : break;
325 : case 2:
326 15 : if (istack == 2) {
327 : // L2C0 type
328 3 : padPlane->SetNrows(12);
329 3 : padPlane->SetLength(108.0);
330 3 : padPlane->SetLengthOPad(8.0);
331 3 : padPlane->SetLengthIPad(9.0);
332 3 : }
333 : else {
334 : // L2C1 type
335 12 : padPlane->SetNrows(16);
336 12 : padPlane->SetLength(129.0);
337 12 : padPlane->SetLengthOPad(7.5);
338 12 : padPlane->SetLengthIPad(8.0);
339 : }
340 15 : padPlane->SetWidth(101.1);
341 15 : padPlane->SetWidthOPad(0.705);
342 15 : padPlane->SetWidthIPad(0.695);
343 15 : padPlane->SetTiltingAngle(-kTiltAngle);
344 15 : break;
345 : case 3:
346 15 : if (istack == 2) {
347 : // L3C0 type
348 3 : padPlane->SetNrows(12);
349 3 : padPlane->SetLength(108.0);
350 3 : padPlane->SetLengthOPad(8.0);
351 3 : padPlane->SetLengthIPad(9.0);
352 3 : }
353 : else {
354 : // L3C1 type
355 12 : padPlane->SetNrows(16);
356 12 : padPlane->SetLength(136.0);
357 12 : padPlane->SetLengthOPad(7.5);
358 12 : padPlane->SetLengthIPad(8.5);
359 : }
360 15 : padPlane->SetWidth(105.5);
361 15 : padPlane->SetWidthOPad(0.775);
362 15 : padPlane->SetWidthIPad(0.725);
363 15 : padPlane->SetTiltingAngle(kTiltAngle);
364 15 : break;
365 : case 4:
366 15 : if (istack == 2) {
367 : // L4C0 type
368 3 : padPlane->SetNrows(12);
369 3 : padPlane->SetLength(108.0);
370 3 : padPlane->SetLengthOPad(8.0);
371 3 : }
372 : else {
373 : // L4C1 type
374 12 : padPlane->SetNrows(16);
375 12 : padPlane->SetLength(143.0);
376 12 : padPlane->SetLengthOPad(7.5);
377 : }
378 15 : padPlane->SetWidth(109.9);
379 15 : padPlane->SetWidthOPad(0.845);
380 15 : padPlane->SetLengthIPad(9.0);
381 15 : padPlane->SetWidthIPad(0.755);
382 15 : padPlane->SetTiltingAngle(-kTiltAngle);
383 15 : break;
384 : case 5:
385 15 : if (istack == 2) {
386 : // L5C0 type
387 3 : padPlane->SetNrows(12);
388 3 : padPlane->SetLength(108.0);
389 3 : padPlane->SetLengthOPad(8.0);
390 3 : }
391 : else {
392 : // L5C1 type
393 12 : padPlane->SetNrows(16);
394 12 : padPlane->SetLength(145.0);
395 12 : padPlane->SetLengthOPad(8.5);
396 : }
397 15 : padPlane->SetWidth(114.4);
398 15 : padPlane->SetWidthOPad(0.965);
399 15 : padPlane->SetLengthIPad(9.0);
400 15 : padPlane->SetWidthIPad(0.785);
401 15 : padPlane->SetTiltingAngle(kTiltAngle);
402 15 : break;
403 : };
404 :
405 : //
406 : // The positions of the borders of the pads
407 : //
408 : // Row direction
409 : //
410 90 : Double_t row = fgkClength[ilayer][istack] / 2.0
411 90 : - fgkRpadW
412 90 : - padPlane->GetLengthRim();
413 2916 : for (Int_t ir = 0; ir < padPlane->GetNrows(); ir++) {
414 1368 : padPlane->SetPadRow(ir,row);
415 1368 : row -= padPlane->GetRowSpacing();
416 1368 : if (ir == 0) {
417 90 : row -= padPlane->GetLengthOPad();
418 90 : }
419 : else {
420 1278 : row -= padPlane->GetLengthIPad();
421 : }
422 : }
423 : //
424 : // Column direction
425 : //
426 90 : Double_t col = - fgkCwidth[ilayer] / 2.0
427 90 : - fgkCroW
428 90 : + padPlane->GetWidthRim();
429 26100 : for (Int_t ic = 0; ic < padPlane->GetNcols(); ic++) {
430 12960 : padPlane->SetPadCol(ic,col);
431 12960 : col += padPlane->GetColSpacing();
432 12960 : if (ic == 0) {
433 90 : col += padPlane->GetWidthOPad();
434 90 : }
435 : else {
436 12870 : col += padPlane->GetWidthIPad();
437 : }
438 : }
439 : // Calculate the offset to translate from the local ROC system into
440 : // the local supermodule system, which is used for clusters
441 180 : Double_t rowTmp = fgkClength[ilayer][0]
442 90 : + fgkClength[ilayer][1]
443 90 : + fgkClength[ilayer][2] / 2.0;
444 540 : for (Int_t jstack = 0; jstack < istack; jstack++) {
445 180 : rowTmp -= fgkClength[ilayer][jstack];
446 : }
447 90 : padPlane->SetPadRowSMOffset(rowTmp - fgkClength[ilayer][istack]/2.0);
448 :
449 90 : return padPlane;
450 :
451 0 : }
452 :
453 : //_____________________________________________________________________________
454 : void AliTRDgeometry::CreateGeometry(Int_t *idtmed)
455 : {
456 : //
457 : // Create the TRD geometry
458 : //
459 : //
460 : // Names of the TRD volumina (xx = detector number):
461 : //
462 : // Volume (Air) wrapping the readout chamber components
463 : // UTxx includes: UAxx, UDxx, UFxx, UUxx
464 : //
465 : // Lower part of the readout chambers (drift volume + radiator)
466 : // UAxx Aluminum frames (Al)
467 : //
468 : // Upper part of the readout chambers (readout plane + fee)
469 : // UDxx Wacosit frames of amp. region (Wacosit)
470 : // UFxx Aluminum frame of back panel (Al)
471 : //
472 : // Services on chambers (cooling, cables, MCMs, DCS boards, ...)
473 : // UUxx Volume containing the services (Air)
474 : //
475 : // Material layers inside sensitive area:
476 : // Name Description Mat. Thick. Dens. Radl. X/X_0
477 : //
478 : // URMYxx Mylar layers (x2) Mylar 0.0015 1.39 28.5464 0.005%
479 : // URCBxx Carbon layer (x2) Carbon 0.0055 1.75 24.2824 0.023%
480 : // URGLxx Glue on the carbon layers (x2) Araldite 0.0065 1.12 37.0664 0.018%
481 : // URRHxx Rohacell layer (x2) Rohacell 0.8 0.075 536.005 0.149%
482 : // URFBxx Fiber mat layer PP 3.186 0.068 649.727 0.490%
483 : //
484 : // UJxx Drift region Xe/CO2 3.0 0.00495 1792.37 0.167%
485 : // UKxx Amplification region Xe/CO2 0.7 0.00495 1792.37 0.039%
486 : // UWxx Wire planes (x2) Copper 0.00011 8.96 1.43503 0.008%
487 : //
488 : // UPPDxx Copper of pad plane Copper 0.0025 8.96 1.43503 0.174%
489 : // UPPPxx PCB of pad plane G10 0.0356 2.0 14.9013 0.239%
490 : // UPGLxx Glue on pad planes Araldite 0.0923 1.12 37.0664 0.249%
491 : // + add. glue (ca. 600g) Araldite 0.0505 1.12 37.0663 0.107%
492 : // UPCBxx Carbon fiber mats (x2) Carbon 0.019 1.75 24.2824 0.078%
493 : // UPHCxx Honeycomb structure Aramide 2.0299 0.032 1198.84 0.169%
494 : // UPPCxx PCB of readout board G10 0.0486 2.0 14.9013 0.326%
495 : // UPRDxx Copper of readout board Copper 0.0057 8.96 1.43503 0.404%
496 : // UPELxx Electronics + cables Copper 0.0029 8.96 1.43503 0.202%
497 : //
498 :
499 : const Int_t kNparTrd = 4;
500 : const Int_t kNparCha = 3;
501 :
502 : Float_t xpos;
503 : Float_t ypos;
504 : Float_t zpos;
505 :
506 2 : Float_t parTrd[kNparTrd];
507 1 : Float_t parCha[kNparCha];
508 :
509 : const Int_t kTag = 100;
510 1 : Char_t cTagV[kTag];
511 1 : Char_t cTagM[kTag];
512 :
513 : // There are three TRD volumes for the supermodules in order to accomodate
514 : // the different arrangements in front of PHOS
515 : // UTR1: Default supermodule
516 : // UTR2: Supermodule in front of PHOS with double carbon cover
517 : // UTR3: As UTR2, but w/o middle stack
518 : // UTR4: Sector 17 with missing chamber L4S4
519 : //
520 : // The mother volume for one sector (Air), full length in z-direction
521 : // Provides material for side plates of super module
522 1 : parTrd[0] = fgkSwidth1/2.0;
523 1 : parTrd[1] = fgkSwidth2/2.0;
524 1 : parTrd[2] = fgkSlength/2.0;
525 1 : parTrd[3] = fgkSheight/2.0;
526 1 : TVirtualMC::GetMC()->Gsvolu("UTR1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
527 1 : TVirtualMC::GetMC()->Gsvolu("UTR2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
528 1 : TVirtualMC::GetMC()->Gsvolu("UTR3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
529 1 : TVirtualMC::GetMC()->Gsvolu("UTR4","TRD1",idtmed[1302-1],parTrd,kNparTrd);
530 : // The outer aluminum plates of the super module (Al)
531 1 : parTrd[0] = fgkSwidth1/2.0;
532 1 : parTrd[1] = fgkSwidth2/2.0;
533 1 : parTrd[2] = fgkSlength/2.0;
534 1 : parTrd[3] = fgkSheight/2.0;
535 1 : TVirtualMC::GetMC()->Gsvolu("UTS1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
536 1 : TVirtualMC::GetMC()->Gsvolu("UTS2","TRD1",idtmed[1301-1],parTrd,kNparTrd);
537 1 : TVirtualMC::GetMC()->Gsvolu("UTS3","TRD1",idtmed[1301-1],parTrd,kNparTrd);
538 1 : TVirtualMC::GetMC()->Gsvolu("UTS4","TRD1",idtmed[1301-1],parTrd,kNparTrd);
539 : // The inner part of the TRD mother volume for one sector (Air),
540 : // full length in z-direction
541 1 : parTrd[0] = fgkSwidth1/2.0 - fgkSMpltT;
542 1 : parTrd[1] = fgkSwidth2/2.0 - fgkSMpltT;
543 1 : parTrd[2] = fgkSlength/2.0;
544 1 : parTrd[3] = fgkSheight/2.0 - fgkSMpltT;
545 1 : TVirtualMC::GetMC()->Gsvolu("UTI1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
546 1 : TVirtualMC::GetMC()->Gsvolu("UTI2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
547 1 : TVirtualMC::GetMC()->Gsvolu("UTI3","TRD1",idtmed[1302-1],parTrd,kNparTrd);
548 1 : TVirtualMC::GetMC()->Gsvolu("UTI4","TRD1",idtmed[1302-1],parTrd,kNparTrd);
549 :
550 : // The inner part of the TRD mother volume for services in front
551 : // of the supermodules (Air),
552 1 : parTrd[0] = fgkSwidth1/2.0;
553 1 : parTrd[1] = fgkSwidth2/2.0;
554 1 : parTrd[2] = fgkFlength/2.0;
555 1 : parTrd[3] = fgkSheight/2.0;
556 1 : TVirtualMC::GetMC()->Gsvolu("UTF1","TRD1",idtmed[1302-1],parTrd,kNparTrd);
557 1 : TVirtualMC::GetMC()->Gsvolu("UTF2","TRD1",idtmed[1302-1],parTrd,kNparTrd);
558 :
559 12 : for (Int_t istack = 0; istack < kNstack; istack++) {
560 70 : for (Int_t ilayer = 0; ilayer < kNlayer; ilayer++) {
561 :
562 30 : Int_t iDet = GetDetectorSec(ilayer,istack);
563 :
564 : // The lower part of the readout chambers (drift volume + radiator)
565 : // The aluminum frames
566 30 : snprintf(cTagV,kTag,"UA%02d",iDet);
567 30 : parCha[0] = fgkCwidth[ilayer]/2.0;
568 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0;
569 30 : parCha[2] = fgkCraH/2.0 + fgkCdrH/2.0;
570 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
571 : // The additional aluminum on the frames
572 : // This part has not the correct shape but is just supposed to
573 : // represent the missing material. The correct form of the L-shaped
574 : // profile would not fit into the alignable volume.
575 30 : snprintf(cTagV,kTag,"UZ%02d",iDet);
576 30 : parCha[0] = fgkCalWmod/2.0;
577 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0;
578 30 : parCha[2] = fgkCalHmod/2.0;
579 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
580 : // The additional Wacosit on the frames
581 30 : snprintf(cTagV,kTag,"UP%02d",iDet);
582 30 : parCha[0] = fgkCwsW/2.0;
583 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0;
584 30 : parCha[2] = fgkCwsH/2.0;
585 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
586 : // The Wacosit frames
587 30 : snprintf(cTagV,kTag,"UB%02d",iDet);
588 30 : parCha[0] = fgkCwidth[ilayer]/2.0 - fgkCalT;
589 30 : parCha[1] = -1.0;
590 30 : parCha[2] = -1.0;
591 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
592 : // The glue around the radiator
593 30 : snprintf(cTagV,kTag,"UX%02d",iDet);
594 30 : parCha[0] = fgkCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT;
595 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT;
596 30 : parCha[2] = fgkCraH/2.0;
597 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1311-1],parCha,kNparCha);
598 : // The inner part of radiator (air)
599 30 : snprintf(cTagV,kTag,"UC%02d",iDet);
600 30 : parCha[0] = fgkCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT - fgkCglT;
601 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT - fgkCglT;
602 30 : parCha[2] = -1.0;
603 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
604 :
605 : // The upper part of the readout chambers (amplification volume)
606 : // The Wacosit frames
607 30 : snprintf(cTagV,kTag,"UD%02d",iDet);
608 30 : parCha[0] = fgkCwidth[ilayer]/2.0 + fgkCroW;
609 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0;
610 30 : parCha[2] = fgkCamH/2.0;
611 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1307-1],parCha,kNparCha);
612 : // The inner part of the Wacosit frame (air)
613 30 : snprintf(cTagV,kTag,"UE%02d",iDet);
614 30 : parCha[0] = fgkCwidth[ilayer]/2.0 + fgkCroW - fgkCcuTb;
615 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCcuTa;
616 30 : parCha[2] = -1.;
617 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
618 :
619 : // The back panel, including pad plane and readout boards
620 : // The aluminum frames
621 30 : snprintf(cTagV,kTag,"UF%02d",iDet);
622 30 : parCha[0] = fgkCwidth[ilayer]/2.0 + fgkCroW;
623 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0;
624 30 : parCha[2] = fgkCroH/2.0;
625 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parCha,kNparCha);
626 : // The inner part of the aluminum frames
627 30 : snprintf(cTagV,kTag,"UG%02d",iDet);
628 30 : parCha[0] = fgkCwidth[ilayer]/2.0 + fgkCroW - fgkCauT;
629 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCauT;
630 30 : parCha[2] = -1.0;
631 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parCha,kNparCha);
632 :
633 : //
634 : // The material layers inside the chambers
635 : //
636 :
637 : // Mylar layer (radiator)
638 30 : parCha[0] = -1.0;
639 30 : parCha[1] = -1.0;
640 30 : parCha[2] = fgkRMyThick/2.0;
641 30 : snprintf(cTagV,kTag,"URMY%02d",iDet);
642 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1327-1],parCha,kNparCha);
643 : // Carbon layer (radiator)
644 30 : parCha[0] = -1.0;
645 30 : parCha[1] = -1.0;
646 30 : parCha[2] = fgkRCbThick/2.0;
647 30 : snprintf(cTagV,kTag,"URCB%02d",iDet);
648 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1326-1],parCha,kNparCha);
649 : // Araldite layer (radiator)
650 30 : parCha[0] = -1.0;
651 30 : parCha[1] = -1.0;
652 30 : parCha[2] = fgkRGlThick/2.0;
653 30 : snprintf(cTagV,kTag,"URGL%02d",iDet);
654 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1311-1],parCha,kNparCha);
655 : // Rohacell layer (radiator)
656 30 : parCha[0] = -1.0;
657 30 : parCha[1] = -1.0;
658 30 : parCha[2] = fgkRRhThick/2.0;
659 30 : snprintf(cTagV,kTag,"URRH%02d",iDet);
660 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1315-1],parCha,kNparCha);
661 : // Fiber layer (radiator)
662 30 : parCha[0] = -1.0;
663 30 : parCha[1] = -1.0;
664 30 : parCha[2] = fgkRFbThick/2.0;
665 30 : snprintf(cTagV,kTag,"URFB%02d",iDet);
666 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1328-1],parCha,kNparCha);
667 :
668 : // Xe/Isobutane layer (drift volume)
669 30 : parCha[0] = fgkCwidth[ilayer]/2.0 - fgkCalT - fgkCclsT;
670 30 : parCha[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0 - fgkCclfT;
671 30 : parCha[2] = fgkDrThick/2.0;
672 30 : snprintf(cTagV,kTag,"UJ%02d",iDet);
673 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
674 :
675 : // Xe/Isobutane layer (amplification volume)
676 30 : parCha[0] = -1.0;
677 30 : parCha[1] = -1.0;
678 30 : parCha[2] = fgkAmThick/2.0;
679 30 : snprintf(cTagV,kTag,"UK%02d",iDet);
680 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1309-1],parCha,kNparCha);
681 : // Cu layer (wire plane)
682 30 : parCha[0] = -1.0;
683 30 : parCha[1] = -1.0;
684 30 : parCha[2] = fgkWrThick/2.0;
685 30 : snprintf(cTagV,kTag,"UW%02d",iDet);
686 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1303-1],parCha,kNparCha);
687 :
688 : // Cu layer (pad plane)
689 30 : parCha[0] = -1.0;
690 30 : parCha[1] = -1.0;
691 30 : parCha[2] = fgkPPdThick/2.0;
692 30 : snprintf(cTagV,kTag,"UPPD%02d",iDet);
693 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1305-1],parCha,kNparCha);
694 : // G10 layer (pad plane)
695 30 : parCha[0] = -1.0;
696 30 : parCha[1] = -1.0;
697 30 : parCha[2] = fgkPPpThick/2.0;
698 30 : snprintf(cTagV,kTag,"UPPP%02d",iDet);
699 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
700 : // Araldite layer (glue)
701 30 : parCha[0] = -1.0;
702 30 : parCha[1] = -1.0;
703 30 : parCha[2] = fgkPGlThick/2.0;
704 30 : snprintf(cTagV,kTag,"UPGL%02d",iDet);
705 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1311-1],parCha,kNparCha);
706 : // Carbon layer (carbon fiber mats)
707 30 : parCha[0] = -1.0;
708 30 : parCha[1] = -1.0;
709 30 : parCha[2] = fgkPCbThick/2.0;
710 30 : snprintf(cTagV,kTag,"UPCB%02d",iDet);
711 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1326-1],parCha,kNparCha);
712 : // Aramide layer (honeycomb)
713 30 : parCha[0] = -1.0;
714 30 : parCha[1] = -1.0;
715 30 : parCha[2] = fgkPHcThick/2.0;
716 30 : snprintf(cTagV,kTag,"UPHC%02d",iDet);
717 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1310-1],parCha,kNparCha);
718 : // G10 layer (PCB readout board)
719 30 : parCha[0] = -1.0;
720 30 : parCha[1] = -1.0;
721 30 : parCha[2] = fgkPPcThick/2;
722 30 : snprintf(cTagV,kTag,"UPPC%02d",iDet);
723 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1313-1],parCha,kNparCha);
724 : // Cu layer (traces in readout board)
725 30 : parCha[0] = -1.0;
726 30 : parCha[1] = -1.0;
727 30 : parCha[2] = fgkPRbThick/2.0;
728 30 : snprintf(cTagV,kTag,"UPRB%02d",iDet);
729 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1306-1],parCha,kNparCha);
730 : // Cu layer (other material on in readout board, incl. screws)
731 30 : parCha[0] = -1.0;
732 30 : parCha[1] = -1.0;
733 30 : parCha[2] = fgkPElThick/2.0;
734 30 : snprintf(cTagV,kTag,"UPEL%02d",iDet);
735 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1304-1],parCha,kNparCha);
736 :
737 : //
738 : // Position the layers in the chambers
739 : //
740 : xpos = 0.0;
741 : ypos = 0.0;
742 :
743 : // Lower part
744 : // Mylar layers (radiator)
745 : zpos = fgkRMyThick/2.0 - fgkCraH/2.0;
746 30 : snprintf(cTagV,kTag,"URMY%02d",iDet);
747 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
748 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
749 : zpos = -fgkRMyThick/2.0 + fgkCraH/2.0;
750 30 : snprintf(cTagV,kTag,"URMY%02d",iDet);
751 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
752 30 : TVirtualMC::GetMC()->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
753 : // Carbon layers (radiator)
754 : zpos = fgkRCbThick/2.0 + fgkRMyThick - fgkCraH/2.0;
755 30 : snprintf(cTagV,kTag,"URCB%02d",iDet);
756 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
757 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
758 : zpos = -fgkRCbThick/2.0 - fgkRMyThick + fgkCraH/2.0;
759 30 : snprintf(cTagV,kTag,"URCB%02d",iDet);
760 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
761 30 : TVirtualMC::GetMC()->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
762 : // Carbon layers (radiator)
763 : zpos = fgkRGlThick/2.0 + fgkRCbThick + fgkRMyThick - fgkCraH/2.0;
764 30 : snprintf(cTagV,kTag,"URGL%02d",iDet);
765 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
766 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
767 : zpos = -fgkRGlThick/2.0 - fgkRCbThick - fgkRMyThick + fgkCraH/2.0;
768 30 : snprintf(cTagV,kTag,"URGL%02d",iDet);
769 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
770 30 : TVirtualMC::GetMC()->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
771 : // Rohacell layers (radiator)
772 : zpos = fgkRRhThick/2.0 + fgkRGlThick + fgkRCbThick + fgkRMyThick - fgkCraH/2.0;
773 30 : snprintf(cTagV,kTag,"URRH%02d",iDet);
774 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
775 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
776 : zpos = -fgkRRhThick/2.0 - fgkRGlThick - fgkRCbThick - fgkRMyThick + fgkCraH/2.0;
777 30 : snprintf(cTagV,kTag,"URRH%02d",iDet);
778 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
779 30 : TVirtualMC::GetMC()->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
780 : // Fiber layers (radiator)
781 : zpos = 0.0;
782 30 : snprintf(cTagV,kTag,"URFB%02d",iDet);
783 30 : snprintf(cTagM,kTag,"UC%02d",iDet);
784 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
785 :
786 : // Xe/Isobutane layer (drift volume)
787 : zpos = fgkDrZpos;
788 30 : snprintf(cTagV,kTag,"UJ%02d",iDet);
789 30 : snprintf(cTagM,kTag,"UB%02d",iDet);
790 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
791 :
792 : // Upper part
793 : // Xe/Isobutane layer (amplification volume)
794 : zpos = fgkAmZpos;
795 30 : snprintf(cTagV,kTag,"UK%02d",iDet);
796 30 : snprintf(cTagM,kTag,"UE%02d",iDet);
797 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
798 : // Cu layer (wire planes inside amplification volume)
799 : zpos = fgkWrZposA;
800 30 : snprintf(cTagV,kTag,"UW%02d",iDet);
801 30 : snprintf(cTagM,kTag,"UK%02d",iDet);
802 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
803 : zpos = fgkWrZposB;
804 30 : snprintf(cTagV,kTag,"UW%02d",iDet);
805 30 : snprintf(cTagM,kTag,"UK%02d",iDet);
806 30 : TVirtualMC::GetMC()->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
807 :
808 : // Back panel + pad plane + readout part
809 : // Cu layer (pad plane)
810 : zpos = fgkPPdThick/2.0 - fgkCroH/2.0;
811 30 : snprintf(cTagV,kTag,"UPPD%02d",iDet);
812 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
813 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
814 : // G10 layer (pad plane)
815 : zpos = fgkPPpThick/2.0 + fgkPPdThick - fgkCroH/2.0;
816 30 : snprintf(cTagV,kTag,"UPPP%02d",iDet);
817 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
818 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
819 : // Araldite layer (glue)
820 : zpos = fgkPGlThick/2.0 + fgkPPpThick + fgkPPdThick - fgkCroH/2.0;
821 30 : snprintf(cTagV,kTag,"UPGL%02d",iDet);
822 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
823 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
824 : // Carbon layers (carbon fiber mats)
825 : zpos = fgkPCbThick/2.0 + fgkPGlThick + fgkPPpThick + fgkPPdThick - fgkCroH/2.0;
826 30 : snprintf(cTagV,kTag,"UPCB%02d",iDet);
827 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
828 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
829 : zpos = -fgkPCbThick/2.0 - fgkPPcThick - fgkPRbThick - fgkPElThick + fgkCroH/2.0;
830 30 : snprintf(cTagV,kTag,"UPCB%02d",iDet);
831 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
832 30 : TVirtualMC::GetMC()->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
833 : // Aramide layer (honeycomb)
834 : zpos = fgkPHcThick/2.0 + fgkPCbThick + fgkPGlThick + fgkPPpThick + fgkPPdThick - fgkCroH/2.0;
835 30 : snprintf(cTagV,kTag,"UPHC%02d",iDet);
836 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
837 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
838 : // G10 layer (PCB readout board)
839 : zpos = -fgkPPcThick/2.0 - fgkPRbThick - fgkPElThick + fgkCroH/2.0;
840 30 : snprintf(cTagV,kTag,"UPPC%02d",iDet);
841 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
842 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
843 : // Cu layer (traces in readout board)
844 : zpos = -fgkPRbThick/2.0 - fgkPElThick + fgkCroH/2.0;
845 30 : snprintf(cTagV,kTag,"UPRB%02d",iDet);
846 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
847 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
848 : // Cu layer (other materials on readout board, incl. screws)
849 : zpos = -fgkPElThick/2.0 + fgkCroH/2.0;
850 30 : snprintf(cTagV,kTag,"UPEL%02d",iDet);
851 30 : snprintf(cTagM,kTag,"UG%02d",iDet);
852 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
853 :
854 : // Position the inner volumes of the chambers in the frames
855 : xpos = 0.0;
856 : ypos = 0.0;
857 :
858 : // The inner part of the radiator (air)
859 : zpos = 0.0;
860 30 : snprintf(cTagV,kTag,"UC%02d",iDet);
861 30 : snprintf(cTagM,kTag,"UX%02d",iDet);
862 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
863 : // The glue around the radiator
864 : zpos = fgkCraH/2.0 - fgkCdrH/2.0 - fgkCraH/2.0;
865 30 : snprintf(cTagV,kTag,"UX%02d",iDet);
866 30 : snprintf(cTagM,kTag,"UB%02d",iDet);
867 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
868 : // The lower Wacosit frame inside the aluminum frame
869 : zpos = 0.0;
870 30 : snprintf(cTagV,kTag,"UB%02d",iDet);
871 30 : snprintf(cTagM,kTag,"UA%02d",iDet);
872 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
873 :
874 : // The inside of the upper Wacosit frame
875 : zpos = 0.0;
876 30 : snprintf(cTagV,kTag,"UE%02d",iDet);
877 30 : snprintf(cTagM,kTag,"UD%02d",iDet);
878 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
879 :
880 : // The inside of the upper aluminum frame
881 : zpos = 0.0;
882 30 : snprintf(cTagV,kTag,"UG%02d",iDet);
883 30 : snprintf(cTagM,kTag,"UF%02d",iDet);
884 30 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
885 :
886 : }
887 : }
888 :
889 : // Create the volumes of the super module frame
890 1 : CreateFrame(idtmed);
891 :
892 : // Create the volumes of the services
893 1 : CreateServices(idtmed);
894 :
895 12 : for (Int_t istack = 0; istack < kNstack; istack++) {
896 70 : for (Int_t ilayer = 0; ilayer < kNlayer; ilayer++) {
897 30 : AssembleChamber(ilayer,istack);
898 : }
899 : }
900 :
901 : xpos = 0.0;
902 : ypos = 0.0;
903 : zpos = 0.0;
904 1 : TVirtualMC::GetMC()->Gspos("UTI1",1,"UTS1",xpos,ypos,zpos,0,"ONLY");
905 1 : TVirtualMC::GetMC()->Gspos("UTI2",1,"UTS2",xpos,ypos,zpos,0,"ONLY");
906 1 : TVirtualMC::GetMC()->Gspos("UTI3",1,"UTS3",xpos,ypos,zpos,0,"ONLY");
907 1 : TVirtualMC::GetMC()->Gspos("UTI4",1,"UTS4",xpos,ypos,zpos,0,"ONLY");
908 :
909 : xpos = 0.0;
910 : ypos = 0.0;
911 : zpos = 0.0;
912 1 : TVirtualMC::GetMC()->Gspos("UTS1",1,"UTR1",xpos,ypos,zpos,0,"ONLY");
913 1 : TVirtualMC::GetMC()->Gspos("UTS2",1,"UTR2",xpos,ypos,zpos,0,"ONLY");
914 1 : TVirtualMC::GetMC()->Gspos("UTS3",1,"UTR3",xpos,ypos,zpos,0,"ONLY");
915 1 : TVirtualMC::GetMC()->Gspos("UTS4",1,"UTR4",xpos,ypos,zpos,0,"ONLY");
916 :
917 : // Put the TRD volumes into the space frame mother volumes
918 : // if enabled via status flag
919 : xpos = 0.0;
920 : ypos = 0.0;
921 : zpos = 0.0;
922 38 : for (Int_t isector = 0; isector < kNsector; isector++) {
923 18 : if (GetSMstatus(isector)) {
924 7 : snprintf(cTagV,kTag,"BTRD%d",isector);
925 7 : switch (isector) {
926 : case 17:
927 : // Missing L4S4 chamber
928 1 : TVirtualMC::GetMC()->Gspos("UTR4",1,cTagV,xpos,ypos,zpos,0,"ONLY");
929 1 : break;
930 : case 13:
931 : case 14:
932 : case 15:
933 : // Double carbon, w/o middle stack
934 0 : TVirtualMC::GetMC()->Gspos("UTR3",1,cTagV,xpos,ypos,zpos,0,"ONLY");
935 0 : break;
936 : case 11:
937 : case 12:
938 : // Double carbon, all stacks
939 0 : TVirtualMC::GetMC()->Gspos("UTR2",1,cTagV,xpos,ypos,zpos,0,"ONLY");
940 0 : break;
941 : default:
942 : // Standard supermodule
943 6 : TVirtualMC::GetMC()->Gspos("UTR1",1,cTagV,xpos,ypos,zpos,0,"ONLY");
944 6 : };
945 : }
946 : }
947 :
948 : // Put the TRD volumes into the space frame mother volumes
949 : // if enabled via status flag
950 : xpos = 0.0;
951 : ypos = 0.5*fgkSlength + 0.5*fgkFlength;
952 : zpos = 0.0;
953 38 : for (Int_t isector = 0; isector < kNsector; isector++) {
954 18 : if (GetSMstatus(isector)) {
955 7 : snprintf(cTagV,kTag,"BTRD%d",isector);
956 7 : TVirtualMC::GetMC()->Gspos("UTF1",1,cTagV,xpos, ypos,zpos,0,"ONLY");
957 7 : TVirtualMC::GetMC()->Gspos("UTF2",1,cTagV,xpos,-ypos,zpos,0,"ONLY");
958 7 : }
959 : }
960 :
961 1 : }
962 :
963 : //_____________________________________________________________________________
964 : void AliTRDgeometry::CreateFrame(Int_t *idtmed)
965 : {
966 : //
967 : // Create the geometry of the frame of the supermodule
968 : //
969 : // Names of the TRD services volumina
970 : //
971 : // USRL Support rails for the chambers (Al)
972 : // USxx Support cross bars between the chambers (Al)
973 : // USHx Horizontal connection between the cross bars (Al)
974 : // USLx Long corner ledges (Al)
975 : //
976 :
977 : Int_t ilayer = 0;
978 :
979 : Float_t xpos = 0.0;
980 : Float_t ypos = 0.0;
981 : Float_t zpos = 0.0;
982 :
983 : const Int_t kTag = 100;
984 2 : Char_t cTagV[kTag];
985 1 : Char_t cTagM[kTag];
986 :
987 : const Int_t kNparTRD = 4;
988 1 : Float_t parTRD[kNparTRD];
989 : const Int_t kNparBOX = 3;
990 1 : Float_t parBOX[kNparBOX];
991 : const Int_t kNparTRP = 11;
992 1 : Float_t parTRP[kNparTRP];
993 :
994 : // The rotation matrices
995 : const Int_t kNmatrix = 7;
996 1 : Int_t matrix[kNmatrix];
997 1 : TVirtualMC::GetMC()->Matrix(matrix[0], 100.0, 0.0, 90.0, 90.0, 10.0, 0.0);
998 1 : TVirtualMC::GetMC()->Matrix(matrix[1], 80.0, 0.0, 90.0, 90.0, 10.0, 180.0);
999 1 : TVirtualMC::GetMC()->Matrix(matrix[2], 90.0, 0.0, 0.0, 0.0, 90.0, 90.0);
1000 1 : TVirtualMC::GetMC()->Matrix(matrix[3], 90.0, 180.0, 0.0, 180.0, 90.0, 90.0);
1001 1 : TVirtualMC::GetMC()->Matrix(matrix[4], 170.0, 0.0, 80.0, 0.0, 90.0, 90.0);
1002 1 : TVirtualMC::GetMC()->Matrix(matrix[5], 170.0, 180.0, 80.0, 180.0, 90.0, 90.0);
1003 1 : TVirtualMC::GetMC()->Matrix(matrix[6], 180.0, 180.0, 90.0, 180.0, 90.0, 90.0);
1004 :
1005 : //
1006 : // The carbon inserts in the top/bottom aluminum plates
1007 : //
1008 :
1009 : const Int_t kNparCrb = 3;
1010 1 : Float_t parCrb[kNparCrb];
1011 1 : parCrb[0] = 0.0;
1012 1 : parCrb[1] = 0.0;
1013 1 : parCrb[2] = 0.0;
1014 1 : TVirtualMC::GetMC()->Gsvolu("USCR","BOX ",idtmed[1326-1],parCrb,0);
1015 : // Bottom 1 (all sectors)
1016 1 : parCrb[0] = 77.49/2.0;
1017 1 : parCrb[1] = 104.60/2.0;
1018 1 : parCrb[2] = fgkSMpltT/2.0;
1019 : xpos = 0.0;
1020 : ypos = 0.0;
1021 : zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1022 1 : TVirtualMC::GetMC()->Gsposp("USCR", 1,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1023 1 : TVirtualMC::GetMC()->Gsposp("USCR", 2,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1024 1 : TVirtualMC::GetMC()->Gsposp("USCR", 3,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1025 1 : TVirtualMC::GetMC()->Gsposp("USCR", 4,"UTS4", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1026 : // Bottom 2 (all sectors)
1027 1 : parCrb[0] = 77.49/2.0;
1028 1 : parCrb[1] = 55.80/2.0;
1029 1 : parCrb[2] = fgkSMpltT/2.0;
1030 : xpos = 0.0;
1031 : ypos = 85.6;
1032 : zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1033 1 : TVirtualMC::GetMC()->Gsposp("USCR", 5,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1034 1 : TVirtualMC::GetMC()->Gsposp("USCR", 6,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1035 1 : TVirtualMC::GetMC()->Gsposp("USCR", 7,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1036 1 : TVirtualMC::GetMC()->Gsposp("USCR", 8,"UTS4", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1037 1 : TVirtualMC::GetMC()->Gsposp("USCR", 9,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1038 1 : TVirtualMC::GetMC()->Gsposp("USCR",10,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1039 1 : TVirtualMC::GetMC()->Gsposp("USCR",11,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1040 1 : TVirtualMC::GetMC()->Gsposp("USCR",12,"UTS4", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1041 : // Bottom 3 (all sectors)
1042 1 : parCrb[0] = 77.49/2.0;
1043 1 : parCrb[1] = 56.00/2.0;
1044 1 : parCrb[2] = fgkSMpltT/2.0;
1045 : xpos = 0.0;
1046 : ypos = 148.5;
1047 : zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1048 1 : TVirtualMC::GetMC()->Gsposp("USCR",13,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1049 1 : TVirtualMC::GetMC()->Gsposp("USCR",14,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1050 1 : TVirtualMC::GetMC()->Gsposp("USCR",15,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1051 1 : TVirtualMC::GetMC()->Gsposp("USCR",16,"UTS4", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1052 1 : TVirtualMC::GetMC()->Gsposp("USCR",17,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1053 1 : TVirtualMC::GetMC()->Gsposp("USCR",18,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1054 1 : TVirtualMC::GetMC()->Gsposp("USCR",19,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1055 1 : TVirtualMC::GetMC()->Gsposp("USCR",20,"UTS4", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1056 : // Bottom 4 (all sectors)
1057 1 : parCrb[0] = 77.49/2.0;
1058 1 : parCrb[1] = 118.00/2.0;
1059 1 : parCrb[2] = fgkSMpltT/2.0;
1060 : xpos = 0.0;
1061 : ypos = 240.5;
1062 : zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1063 1 : TVirtualMC::GetMC()->Gsposp("USCR",21,"UTS1", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1064 1 : TVirtualMC::GetMC()->Gsposp("USCR",22,"UTS2", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1065 1 : TVirtualMC::GetMC()->Gsposp("USCR",23,"UTS3", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1066 1 : TVirtualMC::GetMC()->Gsposp("USCR",24,"UTS4", xpos, ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1067 1 : TVirtualMC::GetMC()->Gsposp("USCR",25,"UTS1", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1068 1 : TVirtualMC::GetMC()->Gsposp("USCR",26,"UTS2", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1069 1 : TVirtualMC::GetMC()->Gsposp("USCR",27,"UTS3", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1070 1 : TVirtualMC::GetMC()->Gsposp("USCR",28,"UTS4", xpos,-ypos, zpos,0,"ONLY",parCrb,kNparCrb);
1071 : // Top 1 (only in front of PHOS)
1072 1 : parCrb[0] = 111.48/2.0;
1073 1 : parCrb[1] = 105.00/2.0;
1074 1 : parCrb[2] = fgkSMpltT/2.0;
1075 : xpos = 0.0;
1076 : ypos = 0.0;
1077 : zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1078 1 : TVirtualMC::GetMC()->Gsposp("USCR",29,"UTS2", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1079 1 : TVirtualMC::GetMC()->Gsposp("USCR",30,"UTS3", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1080 : // Top 2 (only in front of PHOS)
1081 1 : parCrb[0] = 111.48/2.0;
1082 1 : parCrb[1] = 56.00/2.0;
1083 1 : parCrb[2] = fgkSMpltT/2.0;
1084 : xpos = 0.0;
1085 : ypos = 85.5;
1086 : zpos = fgkSMpltT/2.0 - fgkSheight/2.0;
1087 1 : TVirtualMC::GetMC()->Gsposp("USCR",31,"UTS2", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1088 1 : TVirtualMC::GetMC()->Gsposp("USCR",32,"UTS3", xpos, ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1089 1 : TVirtualMC::GetMC()->Gsposp("USCR",33,"UTS2", xpos,-ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1090 1 : TVirtualMC::GetMC()->Gsposp("USCR",34,"UTS3", xpos,-ypos,-zpos,0,"ONLY",parCrb,kNparCrb);
1091 :
1092 : //
1093 : // The chamber support rails
1094 : //
1095 :
1096 : const Float_t kSRLhgt = 2.00;
1097 : const Float_t kSRLwidA = 2.3;
1098 : const Float_t kSRLwidB = 1.947;
1099 : const Float_t kSRLdst = 1.135;
1100 : const Int_t kNparSRL = 11;
1101 1 : Float_t parSRL[kNparSRL];
1102 : // Trapezoidal shape
1103 1 : parSRL[ 0] = fgkSlength/2.0;
1104 1 : parSRL[ 1] = 0.0;
1105 1 : parSRL[ 2] = 0.0;
1106 1 : parSRL[ 3] = kSRLhgt /2.0;
1107 1 : parSRL[ 4] = kSRLwidB /2.0;
1108 1 : parSRL[ 5] = kSRLwidA /2.0;
1109 1 : parSRL[ 6] = 5.0;
1110 1 : parSRL[ 7] = kSRLhgt /2.0;
1111 1 : parSRL[ 8] = kSRLwidB /2.0;
1112 1 : parSRL[ 9] = kSRLwidA /2.0;
1113 1 : parSRL[10] = 5.0;
1114 1 : TVirtualMC::GetMC()->Gsvolu("USRL","TRAP",idtmed[1301-1],parSRL,kNparSRL);
1115 :
1116 : xpos = 0.0;
1117 : ypos = 0.0;
1118 : zpos = 0.0;
1119 12 : for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1120 5 : xpos = fgkCwidth[ilayer]/2.0 + kSRLwidA/2.0 + kSRLdst;
1121 : ypos = 0.0;
1122 5 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos - fgkSheight/2.0
1123 : + fgkCraH + fgkCdrH - fgkCalH - kSRLhgt/2.0
1124 5 : + ilayer * (fgkCH + fgkVspace);
1125 5 : TVirtualMC::GetMC()->Gspos("USRL",ilayer+1 ,"UTI1", xpos,ypos,zpos,matrix[2],"ONLY");
1126 5 : TVirtualMC::GetMC()->Gspos("USRL",ilayer+1+ kNlayer,"UTI1",-xpos,ypos,zpos,matrix[3],"ONLY");
1127 5 : TVirtualMC::GetMC()->Gspos("USRL",ilayer+1+2*kNlayer,"UTI2", xpos,ypos,zpos,matrix[2],"ONLY");
1128 5 : TVirtualMC::GetMC()->Gspos("USRL",ilayer+1+3*kNlayer,"UTI2",-xpos,ypos,zpos,matrix[3],"ONLY");
1129 5 : TVirtualMC::GetMC()->Gspos("USRL",ilayer+1+4*kNlayer,"UTI3", xpos,ypos,zpos,matrix[2],"ONLY");
1130 5 : TVirtualMC::GetMC()->Gspos("USRL",ilayer+1+5*kNlayer,"UTI3",-xpos,ypos,zpos,matrix[3],"ONLY");
1131 5 : TVirtualMC::GetMC()->Gspos("USRL",ilayer+1+6*kNlayer,"UTI4", xpos,ypos,zpos,matrix[2],"ONLY");
1132 5 : TVirtualMC::GetMC()->Gspos("USRL",ilayer+1+7*kNlayer,"UTI4",-xpos,ypos,zpos,matrix[3],"ONLY");
1133 : }
1134 :
1135 : //
1136 : // The cross bars between the chambers
1137 : //
1138 :
1139 : const Float_t kSCBwid = 1.0;
1140 : const Float_t kSCBthk = 2.0;
1141 : const Float_t kSCHhgt = 0.3;
1142 :
1143 : const Int_t kNparSCB = 3;
1144 1 : Float_t parSCB[kNparSCB];
1145 1 : parSCB[1] = kSCBwid/2.0;
1146 1 : parSCB[2] = fgkCH /2.0 + fgkVspace/2.0 - kSCHhgt;
1147 :
1148 : const Int_t kNparSCI = 3;
1149 1 : Float_t parSCI[kNparSCI];
1150 1 : parSCI[1] = -1;
1151 :
1152 : xpos = 0.0;
1153 : ypos = 0.0;
1154 : zpos = 0.0;
1155 14 : for (ilayer = 0; ilayer < kNlayer; ilayer++) {
1156 :
1157 : // The aluminum of the cross bars
1158 6 : parSCB[0] = fgkCwidth[ilayer]/2.0 + kSRLdst/2.0;
1159 6 : snprintf(cTagV,kTag,"USF%01d",ilayer);
1160 6 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCB,kNparSCB);
1161 :
1162 : // The empty regions in the cross bars
1163 : Float_t thkSCB = kSCBthk;
1164 6 : if (ilayer < 2) {
1165 : thkSCB *= 1.5;
1166 2 : }
1167 6 : parSCI[2] = parSCB[2] - thkSCB;
1168 6 : parSCI[0] = parSCB[0]/4.0 - kSCBthk;
1169 6 : snprintf(cTagV,kTag,"USI%01d",ilayer);
1170 6 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1302-1],parSCI,kNparSCI);
1171 :
1172 6 : snprintf(cTagV,kTag,"USI%01d",ilayer);
1173 6 : snprintf(cTagM,kTag,"USF%01d",ilayer);
1174 : ypos = 0.0;
1175 : zpos = 0.0;
1176 6 : xpos = parSCI[0] + thkSCB/2.0;
1177 6 : TVirtualMC::GetMC()->Gspos(cTagV,1,cTagM,xpos,ypos,zpos,0,"ONLY");
1178 6 : xpos = - parSCI[0] - thkSCB/2.0;
1179 6 : TVirtualMC::GetMC()->Gspos(cTagV,2,cTagM,xpos,ypos,zpos,0,"ONLY");
1180 6 : xpos = 3.0 * parSCI[0] + 1.5 * thkSCB;
1181 6 : TVirtualMC::GetMC()->Gspos(cTagV,3,cTagM,xpos,ypos,zpos,0,"ONLY");
1182 6 : xpos = - 3.0 * parSCI[0] - 1.5 * thkSCB;
1183 6 : TVirtualMC::GetMC()->Gspos(cTagV,4,cTagM,xpos,ypos,zpos,0,"ONLY");
1184 :
1185 6 : snprintf(cTagV,kTag,"USF%01d",ilayer);
1186 : xpos = 0.0;
1187 12 : zpos = fgkVrocsm + fgkSMpltT + parSCB[2] - fgkSheight/2.0
1188 6 : + ilayer * (fgkCH + fgkVspace);
1189 :
1190 6 : ypos = fgkClength[ilayer][2]/2.0 + fgkClength[ilayer][1];
1191 6 : TVirtualMC::GetMC()->Gspos(cTagV, 1,"UTI1", xpos,ypos,zpos,0,"ONLY");
1192 6 : TVirtualMC::GetMC()->Gspos(cTagV, 3,"UTI2", xpos,ypos,zpos,0,"ONLY");
1193 6 : TVirtualMC::GetMC()->Gspos(cTagV, 5,"UTI3", xpos,ypos,zpos,0,"ONLY");
1194 6 : TVirtualMC::GetMC()->Gspos(cTagV, 7,"UTI4", xpos,ypos,zpos,0,"ONLY");
1195 :
1196 6 : ypos = - fgkClength[ilayer][2]/2.0 - fgkClength[ilayer][1];
1197 6 : TVirtualMC::GetMC()->Gspos(cTagV, 2,"UTI1", xpos,ypos,zpos,0,"ONLY");
1198 6 : TVirtualMC::GetMC()->Gspos(cTagV, 4,"UTI2", xpos,ypos,zpos,0,"ONLY");
1199 6 : TVirtualMC::GetMC()->Gspos(cTagV, 6,"UTI3", xpos,ypos,zpos,0,"ONLY");
1200 6 : TVirtualMC::GetMC()->Gspos(cTagV, 8,"UTI4", xpos,ypos,zpos,0,"ONLY");
1201 :
1202 : }
1203 :
1204 : //
1205 : // The horizontal connections between the cross bars
1206 : //
1207 :
1208 : const Int_t kNparSCH = 3;
1209 1 : Float_t parSCH[kNparSCH];
1210 :
1211 10 : for (ilayer = 1; ilayer < kNlayer-1; ilayer++) {
1212 :
1213 4 : parSCH[0] = fgkCwidth[ilayer]/2.0;
1214 8 : parSCH[1] = (fgkClength[ilayer+1][2]/2.0 + fgkClength[ilayer+1][1]
1215 4 : - fgkClength[ilayer ][2]/2.0 - fgkClength[ilayer ][1])/2.0;
1216 4 : parSCH[2] = kSCHhgt/2.0;
1217 :
1218 4 : snprintf(cTagV,kTag,"USH%01d",ilayer);
1219 4 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX ",idtmed[1301-1],parSCH,kNparSCH);
1220 : xpos = 0.0;
1221 4 : ypos = fgkClength[ilayer][2]/2.0 + fgkClength[ilayer][1] + parSCH[1];
1222 4 : zpos = fgkVrocsm + fgkSMpltT - kSCHhgt/2.0 - fgkSheight/2.0
1223 4 : + (ilayer+1) * (fgkCH + fgkVspace);
1224 4 : TVirtualMC::GetMC()->Gspos(cTagV,1,"UTI1", xpos,ypos,zpos,0,"ONLY");
1225 4 : TVirtualMC::GetMC()->Gspos(cTagV,3,"UTI2", xpos,ypos,zpos,0,"ONLY");
1226 4 : TVirtualMC::GetMC()->Gspos(cTagV,5,"UTI3", xpos,ypos,zpos,0,"ONLY");
1227 4 : TVirtualMC::GetMC()->Gspos(cTagV,7,"UTI4", xpos,ypos,zpos,0,"ONLY");
1228 4 : ypos = -ypos;
1229 4 : TVirtualMC::GetMC()->Gspos(cTagV,2,"UTI1", xpos,ypos,zpos,0,"ONLY");
1230 4 : TVirtualMC::GetMC()->Gspos(cTagV,4,"UTI2", xpos,ypos,zpos,0,"ONLY");
1231 4 : TVirtualMC::GetMC()->Gspos(cTagV,6,"UTI3", xpos,ypos,zpos,0,"ONLY");
1232 4 : TVirtualMC::GetMC()->Gspos(cTagV,8,"UTI4", xpos,ypos,zpos,0,"ONLY");
1233 :
1234 : }
1235 :
1236 : //
1237 : // The aymmetric flat frame in the middle
1238 : //
1239 :
1240 : // The envelope volume (aluminum)
1241 1 : parTRD[0] = 87.60/2.0;
1242 1 : parTRD[1] = 114.00/2.0;
1243 1 : parTRD[2] = 1.20/2.0;
1244 1 : parTRD[3] = 71.30/2.0;
1245 1 : TVirtualMC::GetMC()->Gsvolu("USDB","TRD1",idtmed[1301-1],parTRD,kNparTRD);
1246 : // Empty spaces (air)
1247 1 : parTRP[ 0] = 1.20/2.0;
1248 1 : parTRP[ 1] = 0.0;
1249 1 : parTRP[ 2] = 0.0;
1250 1 : parTRP[ 3] = 27.00/2.0;
1251 1 : parTRP[ 4] = 50.60/2.0;
1252 1 : parTRP[ 5] = 5.00/2.0;
1253 1 : parTRP[ 6] = 3.5;
1254 1 : parTRP[ 7] = 27.00/2.0;
1255 1 : parTRP[ 8] = 50.60/2.0;
1256 1 : parTRP[ 9] = 5.00/2.0;
1257 1 : parTRP[10] = 3.5;
1258 1 : TVirtualMC::GetMC()->Gsvolu("USD1","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1259 : xpos = 18.0;
1260 : ypos = 0.0;
1261 : zpos = 27.00/2.0 - 71.3/2.0;
1262 1 : TVirtualMC::GetMC()->Gspos("USD1",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1263 : // Empty spaces (air)
1264 1 : parTRP[ 0] = 1.20/2.0;
1265 1 : parTRP[ 1] = 0.0;
1266 1 : parTRP[ 2] = 0.0;
1267 1 : parTRP[ 3] = 33.00/2.0;
1268 1 : parTRP[ 4] = 5.00/2.0;
1269 1 : parTRP[ 5] = 62.10/2.0;
1270 1 : parTRP[ 6] = 3.5;
1271 1 : parTRP[ 7] = 33.00/2.0;
1272 1 : parTRP[ 8] = 5.00/2.0;
1273 1 : parTRP[ 9] = 62.10/2.0;
1274 1 : parTRP[10] = 3.5;
1275 1 : TVirtualMC::GetMC()->Gsvolu("USD2","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1276 : xpos = 21.0;
1277 : ypos = 0.0;
1278 : zpos = 71.3/2.0 - 33.0/2.0;
1279 1 : TVirtualMC::GetMC()->Gspos("USD2",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1280 : // Empty spaces (air)
1281 1 : parBOX[ 0] = 22.50/2.0;
1282 1 : parBOX[ 1] = 1.20/2.0;
1283 1 : parBOX[ 2] = 70.50/2.0;
1284 1 : TVirtualMC::GetMC()->Gsvolu("USD3","BOX ",idtmed[1302-1],parBOX,kNparBOX);
1285 : xpos = -25.75;
1286 : ypos = 0.0;
1287 : zpos = 0.4;
1288 1 : TVirtualMC::GetMC()->Gspos("USD3",1,"USDB", xpos, ypos, zpos, 0,"ONLY");
1289 : // Empty spaces (air)
1290 1 : parTRP[ 0] = 1.20/2.0;
1291 1 : parTRP[ 1] = 0.0;
1292 1 : parTRP[ 2] = 0.0;
1293 1 : parTRP[ 3] = 25.50/2.0;
1294 1 : parTRP[ 4] = 5.00/2.0;
1295 1 : parTRP[ 5] = 65.00/2.0;
1296 1 : parTRP[ 6] = -1.0;
1297 1 : parTRP[ 7] = 25.50/2.0;
1298 1 : parTRP[ 8] = 5.00/2.0;
1299 1 : parTRP[ 9] = 65.00/2.0;
1300 1 : parTRP[10] = -1.0;
1301 1 : TVirtualMC::GetMC()->Gsvolu("USD4","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1302 : xpos = 2.0;
1303 : ypos = 0.0;
1304 : zpos = -1.6;
1305 1 : TVirtualMC::GetMC()->Gspos("USD4",1,"USDB", xpos, ypos, zpos,matrix[6],"ONLY");
1306 : // Empty spaces (air)
1307 1 : parTRP[ 0] = 1.20/2.0;
1308 1 : parTRP[ 1] = 0.0;
1309 1 : parTRP[ 2] = 0.0;
1310 1 : parTRP[ 3] = 23.50/2.0;
1311 1 : parTRP[ 4] = 63.50/2.0;
1312 1 : parTRP[ 5] = 5.00/2.0;
1313 1 : parTRP[ 6] = 16.0;
1314 1 : parTRP[ 7] = 23.50/2.0;
1315 1 : parTRP[ 8] = 63.50/2.0;
1316 1 : parTRP[ 9] = 5.00/2.0;
1317 1 : parTRP[10] = 16.0;
1318 1 : TVirtualMC::GetMC()->Gsvolu("USD5","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1319 : xpos = 36.5;
1320 : ypos = 0.0;
1321 : zpos = -1.5;
1322 1 : TVirtualMC::GetMC()->Gspos("USD5",1,"USDB", xpos, ypos, zpos,matrix[5],"ONLY");
1323 : // Empty spaces (air)
1324 1 : parTRP[ 0] = 1.20/2.0;
1325 1 : parTRP[ 1] = 0.0;
1326 1 : parTRP[ 2] = 0.0;
1327 1 : parTRP[ 3] = 70.50/2.0;
1328 1 : parTRP[ 4] = 4.50/2.0;
1329 1 : parTRP[ 5] = 16.50/2.0;
1330 1 : parTRP[ 6] = -5.0;
1331 1 : parTRP[ 7] = 70.50/2.0;
1332 1 : parTRP[ 8] = 4.50/2.0;
1333 1 : parTRP[ 9] = 16.50/2.0;
1334 1 : parTRP[10] = -5.0;
1335 1 : TVirtualMC::GetMC()->Gsvolu("USD6","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1336 : xpos = -43.7;
1337 : ypos = 0.0;
1338 : zpos = 0.4;
1339 1 : TVirtualMC::GetMC()->Gspos("USD6",1,"USDB", xpos, ypos, zpos,matrix[2],"ONLY");
1340 : xpos = 0.0;
1341 1 : ypos = fgkClength[5][2]/2.0;
1342 : zpos = 0.04;
1343 1 : TVirtualMC::GetMC()->Gspos("USDB",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1344 1 : TVirtualMC::GetMC()->Gspos("USDB",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1345 1 : TVirtualMC::GetMC()->Gspos("USDB",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1346 1 : TVirtualMC::GetMC()->Gspos("USDB",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1347 1 : TVirtualMC::GetMC()->Gspos("USDB",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1348 1 : TVirtualMC::GetMC()->Gspos("USDB",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1349 1 : TVirtualMC::GetMC()->Gspos("USDB",7,"UTI4", xpos, ypos, zpos, 0,"ONLY");
1350 1 : TVirtualMC::GetMC()->Gspos("USDB",8,"UTI4", xpos,-ypos, zpos, 0,"ONLY");
1351 : // Upper bar (aluminum)
1352 1 : parBOX[0] = 95.00/2.0;
1353 1 : parBOX[1] = 1.20/2.0;
1354 1 : parBOX[2] = 3.00/2.0;
1355 1 : TVirtualMC::GetMC()->Gsvolu("USD7","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1356 : xpos = 0.0;
1357 : ypos = fgkClength[5][2]/2.0;
1358 : zpos = fgkSheight/2.0 - fgkSMpltT - 3.00/2.0;
1359 1 : TVirtualMC::GetMC()->Gspos("USD7",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1360 1 : TVirtualMC::GetMC()->Gspos("USD7",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1361 1 : TVirtualMC::GetMC()->Gspos("USD7",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1362 1 : TVirtualMC::GetMC()->Gspos("USD7",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1363 1 : TVirtualMC::GetMC()->Gspos("USD7",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1364 1 : TVirtualMC::GetMC()->Gspos("USD7",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1365 1 : TVirtualMC::GetMC()->Gspos("USD7",7,"UTI4", xpos, ypos, zpos, 0,"ONLY");
1366 1 : TVirtualMC::GetMC()->Gspos("USD7",8,"UTI4", xpos,-ypos, zpos, 0,"ONLY");
1367 : // Lower bar (aluminum)
1368 1 : parBOX[0] = 90.22/2.0;
1369 1 : parBOX[1] = 1.20/2.0;
1370 1 : parBOX[2] = 1.74/2.0;
1371 1 : TVirtualMC::GetMC()->Gsvolu("USD8","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1372 : xpos = 0.0;
1373 1 : ypos = fgkClength[5][2]/2.0 - 0.1;
1374 : zpos = -fgkSheight/2.0 + fgkSMpltT + 2.27;
1375 1 : TVirtualMC::GetMC()->Gspos("USD8",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1376 1 : TVirtualMC::GetMC()->Gspos("USD8",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1377 1 : TVirtualMC::GetMC()->Gspos("USD8",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1378 1 : TVirtualMC::GetMC()->Gspos("USD8",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1379 1 : TVirtualMC::GetMC()->Gspos("USD8",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1380 1 : TVirtualMC::GetMC()->Gspos("USD8",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1381 1 : TVirtualMC::GetMC()->Gspos("USD8",7,"UTI4", xpos, ypos, zpos, 0,"ONLY");
1382 1 : TVirtualMC::GetMC()->Gspos("USD8",8,"UTI4", xpos,-ypos, zpos, 0,"ONLY");
1383 : // Lower bar (aluminum)
1384 1 : parBOX[0] = 82.60/2.0;
1385 1 : parBOX[1] = 1.20/2.0;
1386 1 : parBOX[2] = 1.40/2.0;
1387 1 : TVirtualMC::GetMC()->Gsvolu("USD9","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1388 : xpos = 0.0;
1389 : ypos = fgkClength[5][2]/2.0;
1390 : zpos = -fgkSheight/2.0 + fgkSMpltT + 1.40/2.0;
1391 1 : TVirtualMC::GetMC()->Gspos("USD9",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1392 1 : TVirtualMC::GetMC()->Gspos("USD9",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1393 1 : TVirtualMC::GetMC()->Gspos("USD9",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1394 1 : TVirtualMC::GetMC()->Gspos("USD9",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1395 1 : TVirtualMC::GetMC()->Gspos("USD9",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1396 1 : TVirtualMC::GetMC()->Gspos("USD9",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1397 1 : TVirtualMC::GetMC()->Gspos("USD9",7,"UTI4", xpos, ypos, zpos, 0,"ONLY");
1398 1 : TVirtualMC::GetMC()->Gspos("USD9",8,"UTI4", xpos,-ypos, zpos, 0,"ONLY");
1399 : // Front sheet (aluminum)
1400 1 : parTRP[ 0] = 0.10/2.0;
1401 1 : parTRP[ 1] = 0.0;
1402 1 : parTRP[ 2] = 0.0;
1403 1 : parTRP[ 3] = 74.50/2.0;
1404 1 : parTRP[ 4] = 31.70/2.0;
1405 1 : parTRP[ 5] = 44.00/2.0;
1406 1 : parTRP[ 6] = -5.0;
1407 1 : parTRP[ 7] = 74.50/2.0;
1408 1 : parTRP[ 8] = 31.70/2.0;
1409 1 : parTRP[ 9] = 44.00/2.0;
1410 1 : parTRP[10] = -5.0;
1411 1 : TVirtualMC::GetMC()->Gsvolu("USDF","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1412 : xpos = -32.0;
1413 1 : ypos = fgkClength[5][2]/2.0 + 1.20/2.0 + 0.10/2.0;
1414 : zpos = 0.0;
1415 1 : TVirtualMC::GetMC()->Gspos("USDF",1,"UTI1", xpos, ypos, zpos,matrix[2],"ONLY");
1416 1 : TVirtualMC::GetMC()->Gspos("USDF",2,"UTI1", xpos,-ypos, zpos,matrix[2],"ONLY");
1417 1 : TVirtualMC::GetMC()->Gspos("USDF",3,"UTI2", xpos, ypos, zpos,matrix[2],"ONLY");
1418 1 : TVirtualMC::GetMC()->Gspos("USDF",4,"UTI2", xpos,-ypos, zpos,matrix[2],"ONLY");
1419 1 : TVirtualMC::GetMC()->Gspos("USDF",5,"UTI3", xpos, ypos, zpos,matrix[2],"ONLY");
1420 1 : TVirtualMC::GetMC()->Gspos("USDF",6,"UTI3", xpos,-ypos, zpos,matrix[2],"ONLY");
1421 1 : TVirtualMC::GetMC()->Gspos("USDF",7,"UTI4", xpos, ypos, zpos,matrix[2],"ONLY");
1422 1 : TVirtualMC::GetMC()->Gspos("USDF",8,"UTI4", xpos,-ypos, zpos,matrix[2],"ONLY");
1423 :
1424 : //
1425 : // The flat frame in front of the chambers
1426 : //
1427 :
1428 : // The envelope volume (aluminum)
1429 1 : parTRD[0] = 90.00/2.0 - 0.1;
1430 1 : parTRD[1] = 114.00/2.0 - 0.1;
1431 1 : parTRD[2] = 1.50/2.0;
1432 1 : parTRD[3] = 70.30/2.0;
1433 1 : TVirtualMC::GetMC()->Gsvolu("USCB","TRD1",idtmed[1301-1],parTRD,kNparTRD);
1434 : // Empty spaces (air)
1435 1 : parTRD[0] = 87.00/2.0;
1436 1 : parTRD[1] = 10.00/2.0;
1437 1 : parTRD[2] = 1.50/2.0;
1438 1 : parTRD[3] = 26.35/2.0;
1439 1 : TVirtualMC::GetMC()->Gsvolu("USC1","TRD1",idtmed[1302-1],parTRD,kNparTRD);
1440 : xpos = 0.0;
1441 : ypos = 0.0;
1442 : zpos = 26.35/2.0 - 70.3/2.0;
1443 1 : TVirtualMC::GetMC()->Gspos("USC1",1,"USCB",xpos,ypos,zpos,0,"ONLY");
1444 : // Empty spaces (air)
1445 1 : parTRD[0] = 10.00/2.0;
1446 1 : parTRD[1] = 111.00/2.0;
1447 1 : parTRD[2] = 1.50/2.0;
1448 1 : parTRD[3] = 35.05/2.0;
1449 1 : TVirtualMC::GetMC()->Gsvolu("USC2","TRD1",idtmed[1302-1],parTRD,kNparTRD);
1450 : xpos = 0.0;
1451 : ypos = 0.0;
1452 : zpos = 70.3/2.0 - 35.05/2.0;
1453 1 : TVirtualMC::GetMC()->Gspos("USC2",1,"USCB",xpos,ypos,zpos,0,"ONLY");
1454 : // Empty spaces (air)
1455 1 : parTRP[ 0] = 1.50/2.0;
1456 1 : parTRP[ 1] = 0.0;
1457 1 : parTRP[ 2] = 0.0;
1458 1 : parTRP[ 3] = 37.60/2.0;
1459 1 : parTRP[ 4] = 63.90/2.0;
1460 1 : parTRP[ 5] = 8.86/2.0;
1461 1 : parTRP[ 6] = 16.0;
1462 1 : parTRP[ 7] = 37.60/2.0;
1463 1 : parTRP[ 8] = 63.90/2.0;
1464 1 : parTRP[ 9] = 8.86/2.0;
1465 1 : parTRP[10] = 16.0;
1466 1 : TVirtualMC::GetMC()->Gsvolu("USC3","TRAP",idtmed[1302-1],parTRP,kNparTRP);
1467 : xpos = -30.5;
1468 : ypos = 0.0;
1469 : zpos = -2.0;
1470 1 : TVirtualMC::GetMC()->Gspos("USC3",1,"USCB", xpos, ypos, zpos,matrix[4],"ONLY");
1471 1 : TVirtualMC::GetMC()->Gspos("USC3",2,"USCB",-xpos, ypos, zpos,matrix[5],"ONLY");
1472 : xpos = 0.0;
1473 1 : ypos = fgkClength[5][2]/2.0 + fgkClength[5][1] + fgkClength[5][0];
1474 : zpos = 0.0;
1475 1 : TVirtualMC::GetMC()->Gspos("USCB",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1476 1 : TVirtualMC::GetMC()->Gspos("USCB",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1477 1 : TVirtualMC::GetMC()->Gspos("USCB",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1478 1 : TVirtualMC::GetMC()->Gspos("USCB",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1479 1 : TVirtualMC::GetMC()->Gspos("USCB",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1480 1 : TVirtualMC::GetMC()->Gspos("USCB",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1481 1 : TVirtualMC::GetMC()->Gspos("USCB",7,"UTI4", xpos, ypos, zpos, 0,"ONLY");
1482 1 : TVirtualMC::GetMC()->Gspos("USCB",8,"UTI4", xpos,-ypos, zpos, 0,"ONLY");
1483 : // Upper bar (aluminum)
1484 1 : parBOX[0] = 95.00/2.0;
1485 1 : parBOX[1] = 1.50/2.0;
1486 1 : parBOX[2] = 3.00/2.0;
1487 1 : TVirtualMC::GetMC()->Gsvolu("USC4","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1488 : xpos = 0.0;
1489 : ypos = fgkClength[5][2]/2.0 + fgkClength[5][1] + fgkClength[5][0];
1490 : zpos = fgkSheight/2.0 - fgkSMpltT - 3.00/2.0;
1491 1 : TVirtualMC::GetMC()->Gspos("USC4",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1492 1 : TVirtualMC::GetMC()->Gspos("USC4",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1493 1 : TVirtualMC::GetMC()->Gspos("USC4",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1494 1 : TVirtualMC::GetMC()->Gspos("USC4",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1495 1 : TVirtualMC::GetMC()->Gspos("USC4",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1496 1 : TVirtualMC::GetMC()->Gspos("USC4",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1497 1 : TVirtualMC::GetMC()->Gspos("USC4",7,"UTI4", xpos, ypos, zpos, 0,"ONLY");
1498 1 : TVirtualMC::GetMC()->Gspos("USC4",8,"UTI4", xpos,-ypos, zpos, 0,"ONLY");
1499 : // Lower bar (aluminum)
1500 1 : parBOX[0] = 90.22/2.0;
1501 1 : parBOX[1] = 1.50/2.0;
1502 1 : parBOX[2] = 2.00/2.0;
1503 1 : TVirtualMC::GetMC()->Gsvolu("USC5","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1504 : xpos = 0.0;
1505 : ypos = fgkClength[5][2]/2.0 + fgkClength[5][1] + fgkClength[5][0];
1506 : zpos = -fgkSheight/2.0 + fgkSMpltT + 2.60;
1507 1 : TVirtualMC::GetMC()->Gspos("USC5",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1508 1 : TVirtualMC::GetMC()->Gspos("USC5",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1509 1 : TVirtualMC::GetMC()->Gspos("USC5",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1510 1 : TVirtualMC::GetMC()->Gspos("USC5",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1511 1 : TVirtualMC::GetMC()->Gspos("USC5",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1512 1 : TVirtualMC::GetMC()->Gspos("USC5",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1513 1 : TVirtualMC::GetMC()->Gspos("USC5",7,"UTI4", xpos, ypos, zpos, 0,"ONLY");
1514 1 : TVirtualMC::GetMC()->Gspos("USC5",8,"UTI4", xpos,-ypos, zpos, 0,"ONLY");
1515 : // Lower bar (aluminum)
1516 1 : parBOX[0] = 82.60/2.0;
1517 1 : parBOX[1] = 1.50/2.0;
1518 1 : parBOX[2] = 1.60/2.0;
1519 1 : TVirtualMC::GetMC()->Gsvolu("USC6","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1520 : xpos = 0.0;
1521 : ypos = fgkClength[5][2]/2.0 + fgkClength[5][1] + fgkClength[5][0];
1522 : zpos = -fgkSheight/2.0 + fgkSMpltT + 1.60/2.0;
1523 1 : TVirtualMC::GetMC()->Gspos("USC6",1,"UTI1", xpos, ypos, zpos, 0,"ONLY");
1524 1 : TVirtualMC::GetMC()->Gspos("USC6",2,"UTI1", xpos,-ypos, zpos, 0,"ONLY");
1525 1 : TVirtualMC::GetMC()->Gspos("USC6",3,"UTI2", xpos, ypos, zpos, 0,"ONLY");
1526 1 : TVirtualMC::GetMC()->Gspos("USC6",4,"UTI2", xpos,-ypos, zpos, 0,"ONLY");
1527 1 : TVirtualMC::GetMC()->Gspos("USC6",5,"UTI3", xpos, ypos, zpos, 0,"ONLY");
1528 1 : TVirtualMC::GetMC()->Gspos("USC6",6,"UTI3", xpos,-ypos, zpos, 0,"ONLY");
1529 1 : TVirtualMC::GetMC()->Gspos("USC6",7,"UTI4", xpos, ypos, zpos, 0,"ONLY");
1530 1 : TVirtualMC::GetMC()->Gspos("USC6",8,"UTI4", xpos,-ypos, zpos, 0,"ONLY");
1531 :
1532 : //
1533 : // The long corner ledges
1534 : //
1535 :
1536 : const Int_t kNparSCL = 3;
1537 1 : Float_t parSCL[kNparSCL];
1538 : const Int_t kNparSCLb = 11;
1539 1 : Float_t parSCLb[kNparSCLb];
1540 :
1541 : // Upper ledges
1542 : // Thickness of the corner ledges
1543 : const Float_t kSCLthkUa = 0.6;
1544 : const Float_t kSCLthkUb = 0.6;
1545 : // Width of the corner ledges
1546 : const Float_t kSCLwidUa = 3.2;
1547 : const Float_t kSCLwidUb = 4.8;
1548 : // Position of the corner ledges
1549 : const Float_t kSCLposxUa = 0.7;
1550 : const Float_t kSCLposxUb = 3.3;
1551 : const Float_t kSCLposzUa = 1.65;
1552 : const Float_t kSCLposzUb = 0.3;
1553 : // Vertical
1554 1 : parSCL[0] = kSCLthkUa /2.0;
1555 1 : parSCL[1] = fgkSlength/2.0;
1556 1 : parSCL[2] = kSCLwidUa /2.0;
1557 1 : TVirtualMC::GetMC()->Gsvolu("USL1","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1558 : xpos = fgkSwidth2/2.0 - fgkSMpltT - kSCLposxUa;
1559 : ypos = 0.0;
1560 : zpos = fgkSheight/2.0 - fgkSMpltT - kSCLposzUa;
1561 1 : TVirtualMC::GetMC()->Gspos("USL1",1,"UTI1", xpos,ypos,zpos,matrix[0],"ONLY");
1562 1 : TVirtualMC::GetMC()->Gspos("USL1",3,"UTI4", xpos,ypos,zpos,matrix[0],"ONLY");
1563 : xpos = -xpos;
1564 1 : TVirtualMC::GetMC()->Gspos("USL1",2,"UTI1", xpos,ypos,zpos,matrix[1],"ONLY");
1565 1 : TVirtualMC::GetMC()->Gspos("USL1",4,"UTI4", xpos,ypos,zpos,matrix[1],"ONLY");
1566 : // Horizontal
1567 1 : parSCL[0] = kSCLwidUb /2.0;
1568 1 : parSCL[1] = fgkSlength/2.0;
1569 1 : parSCL[2] = kSCLthkUb /2.0;
1570 1 : TVirtualMC::GetMC()->Gsvolu("USL2","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1571 : xpos = fgkSwidth2/2.0 - fgkSMpltT - kSCLposxUb;
1572 : ypos = 0.0;
1573 : zpos = fgkSheight/2.0 - fgkSMpltT - kSCLposzUb;
1574 1 : TVirtualMC::GetMC()->Gspos("USL2",1,"UTI1", xpos,ypos,zpos, 0,"ONLY");
1575 1 : TVirtualMC::GetMC()->Gspos("USL2",3,"UTI2", xpos,ypos,zpos, 0,"ONLY");
1576 1 : TVirtualMC::GetMC()->Gspos("USL2",5,"UTI3", xpos,ypos,zpos, 0,"ONLY");
1577 1 : TVirtualMC::GetMC()->Gspos("USL2",7,"UTI4", xpos,ypos,zpos, 0,"ONLY");
1578 : xpos = -xpos;
1579 1 : TVirtualMC::GetMC()->Gspos("USL2",2,"UTI1", xpos,ypos,zpos, 0,"ONLY");
1580 1 : TVirtualMC::GetMC()->Gspos("USL2",4,"UTI2", xpos,ypos,zpos, 0,"ONLY");
1581 1 : TVirtualMC::GetMC()->Gspos("USL2",6,"UTI3", xpos,ypos,zpos, 0,"ONLY");
1582 1 : TVirtualMC::GetMC()->Gspos("USL2",8,"UTI4", xpos,ypos,zpos, 0,"ONLY");
1583 :
1584 : // Lower ledges
1585 : // Thickness of the corner ledges
1586 : const Float_t kSCLthkLa = 2.464;
1587 : const Float_t kSCLthkLb = 1.0;
1588 : // Width of the corner ledges
1589 : const Float_t kSCLwidLa = 8.3;
1590 : const Float_t kSCLwidLb = 4.0;
1591 : // Position of the corner ledges
1592 : const Float_t kSCLposxLa = (3.0 * kSCLthkLb - kSCLthkLa) / 4.0 + 0.05;
1593 : const Float_t kSCLposxLb = kSCLthkLb + kSCLwidLb/2.0 + 0.05;
1594 : const Float_t kSCLposzLa = kSCLwidLa/2.0;
1595 : const Float_t kSCLposzLb = kSCLthkLb/2.0;
1596 : // Vertical
1597 : // Trapezoidal shape
1598 1 : parSCLb[ 0] = fgkSlength/2.0;
1599 1 : parSCLb[ 1] = 0.0;
1600 1 : parSCLb[ 2] = 0.0;
1601 1 : parSCLb[ 3] = kSCLwidLa /2.0;
1602 1 : parSCLb[ 4] = kSCLthkLb /2.0;
1603 1 : parSCLb[ 5] = kSCLthkLa /2.0;
1604 1 : parSCLb[ 6] = 5.0;
1605 1 : parSCLb[ 7] = kSCLwidLa /2.0;
1606 1 : parSCLb[ 8] = kSCLthkLb /2.0;
1607 1 : parSCLb[ 9] = kSCLthkLa /2.0;
1608 1 : parSCLb[10] = 5.0;
1609 1 : TVirtualMC::GetMC()->Gsvolu("USL3","TRAP",idtmed[1301-1],parSCLb,kNparSCLb);
1610 : xpos = fgkSwidth1/2.0 - fgkSMpltT - kSCLposxLa;
1611 : ypos = 0.0;
1612 : zpos = - fgkSheight/2.0 + fgkSMpltT + kSCLposzLa;
1613 1 : TVirtualMC::GetMC()->Gspos("USL3",1,"UTI1", xpos,ypos,zpos,matrix[2],"ONLY");
1614 1 : TVirtualMC::GetMC()->Gspos("USL3",3,"UTI2", xpos,ypos,zpos,matrix[2],"ONLY");
1615 1 : TVirtualMC::GetMC()->Gspos("USL3",5,"UTI3", xpos,ypos,zpos,matrix[2],"ONLY");
1616 1 : TVirtualMC::GetMC()->Gspos("USL3",7,"UTI4", xpos,ypos,zpos,matrix[2],"ONLY");
1617 : xpos = -xpos;
1618 1 : TVirtualMC::GetMC()->Gspos("USL3",2,"UTI1", xpos,ypos,zpos,matrix[3],"ONLY");
1619 1 : TVirtualMC::GetMC()->Gspos("USL3",4,"UTI2", xpos,ypos,zpos,matrix[3],"ONLY");
1620 1 : TVirtualMC::GetMC()->Gspos("USL3",6,"UTI3", xpos,ypos,zpos,matrix[3],"ONLY");
1621 1 : TVirtualMC::GetMC()->Gspos("USL3",8,"UTI4", xpos,ypos,zpos,matrix[3],"ONLY");
1622 : // Horizontal part
1623 1 : parSCL[0] = kSCLwidLb /2.0;
1624 1 : parSCL[1] = fgkSlength/2.0;
1625 1 : parSCL[2] = kSCLthkLb /2.0;
1626 1 : TVirtualMC::GetMC()->Gsvolu("USL4","BOX ",idtmed[1301-1],parSCL,kNparSCL);
1627 : xpos = fgkSwidth1/2.0 - fgkSMpltT - kSCLposxLb;
1628 : ypos = 0.0;
1629 : zpos = - fgkSheight/2.0 + fgkSMpltT + kSCLposzLb;
1630 1 : TVirtualMC::GetMC()->Gspos("USL4",1,"UTI1", xpos,ypos,zpos, 0,"ONLY");
1631 1 : TVirtualMC::GetMC()->Gspos("USL4",3,"UTI2", xpos,ypos,zpos, 0,"ONLY");
1632 1 : TVirtualMC::GetMC()->Gspos("USL4",5,"UTI3", xpos,ypos,zpos, 0,"ONLY");
1633 1 : TVirtualMC::GetMC()->Gspos("USL4",7,"UTI4", xpos,ypos,zpos, 0,"ONLY");
1634 : xpos = -xpos;
1635 1 : TVirtualMC::GetMC()->Gspos("USL4",2,"UTI1", xpos,ypos,zpos, 0,"ONLY");
1636 1 : TVirtualMC::GetMC()->Gspos("USL4",4,"UTI2", xpos,ypos,zpos, 0,"ONLY");
1637 1 : TVirtualMC::GetMC()->Gspos("USL4",6,"UTI3", xpos,ypos,zpos, 0,"ONLY");
1638 1 : TVirtualMC::GetMC()->Gspos("USL4",8,"UTI4", xpos,ypos,zpos, 0,"ONLY");
1639 :
1640 : //
1641 : // Aluminum plates in the front part of the super modules
1642 : //
1643 :
1644 : const Int_t kNparTrd = 4;
1645 1 : Float_t parTrd[kNparTrd];
1646 1 : parTrd[0] = fgkSwidth1/2.0 - 2.5;
1647 1 : parTrd[1] = fgkSwidth2/2.0 - 2.5;
1648 1 : parTrd[2] = fgkSMpltT /2.0;
1649 1 : parTrd[3] = fgkSheight/2.0 - 1.0;
1650 1 : TVirtualMC::GetMC()->Gsvolu("UTA1","TRD1",idtmed[1301-1],parTrd,kNparTrd);
1651 : xpos = 0.0;
1652 : ypos = fgkSMpltT/2.0 - fgkFlength/2.0;
1653 : zpos = -0.5;
1654 1 : TVirtualMC::GetMC()->Gspos("UTA1",1,"UTF1",xpos, ypos,zpos, 0,"ONLY");
1655 1 : TVirtualMC::GetMC()->Gspos("UTA1",2,"UTF2",xpos,-ypos,zpos, 0,"ONLY");
1656 :
1657 : const Int_t kNparPlt = 3;
1658 1 : Float_t parPlt[kNparPlt];
1659 1 : parPlt[0] = 0.0;
1660 1 : parPlt[1] = 0.0;
1661 1 : parPlt[2] = 0.0;
1662 1 : TVirtualMC::GetMC()->Gsvolu("UTA2","BOX ",idtmed[1301-1],parPlt,0);
1663 : xpos = 0.0;
1664 : ypos = 0.0;
1665 : zpos = fgkSheight/2.0 - fgkSMpltT/2.0;
1666 1 : parPlt[0] = fgkSwidth2/2.0 - 0.2;
1667 1 : parPlt[1] = fgkFlength/2.0;
1668 1 : parPlt[2] = fgkSMpltT /2.0;
1669 1 : TVirtualMC::GetMC()->Gsposp("UTA2",1,"UTF2",xpos,ypos,zpos
1670 : , 0,"ONLY",parPlt,kNparPlt);
1671 : xpos = (fgkSwidth1 + fgkSwidth2)/4.0 - fgkSMpltT/2.0 - 0.0016;
1672 : ypos = 0.0;
1673 : zpos = 0.0;
1674 1 : parPlt[0] = fgkSMpltT /2.0;
1675 1 : parPlt[1] = fgkFlength/2.0;
1676 1 : parPlt[2] = fgkSheight/2.0;
1677 2 : TVirtualMC::GetMC()->Gsposp("UTA2",2,"UTF2", xpos,ypos,zpos
1678 1 : ,matrix[0],"ONLY",parPlt,kNparPlt);
1679 2 : TVirtualMC::GetMC()->Gsposp("UTA2",3,"UTF2",-xpos,ypos,zpos
1680 1 : ,matrix[1],"ONLY",parPlt,kNparPlt);
1681 :
1682 : // Additional aluminum bar
1683 1 : parBOX[0] = 80.0/2.0;
1684 1 : parBOX[1] = 1.0/2.0;
1685 1 : parBOX[2] = 10.0/2.0;
1686 1 : TVirtualMC::GetMC()->Gsvolu("UTA3","BOX ",idtmed[1301-1],parBOX,kNparBOX);
1687 : xpos = 0.0;
1688 : ypos = 1.0/2.0 + fgkSMpltT - fgkFlength/2.0;
1689 : zpos = fgkSheight/2.0 - 1.5 - 10.0/2.0;
1690 1 : TVirtualMC::GetMC()->Gspos("UTA3",1,"UTF1", xpos, ypos, zpos, 0,"ONLY");
1691 1 : TVirtualMC::GetMC()->Gspos("UTA3",2,"UTF2", xpos,-ypos, zpos, 0,"ONLY");
1692 :
1693 1 : }
1694 :
1695 : //_____________________________________________________________________________
1696 : void AliTRDgeometry::CreateServices(Int_t *idtmed)
1697 : {
1698 : //
1699 : // Create the geometry of the services
1700 : //
1701 : // Names of the TRD services volumina
1702 : //
1703 : // UTC1 Cooling arterias (Al)
1704 : // UTC2 Cooling arterias (Water)
1705 : // UUxx Volumes for the services at the chambers (Air)
1706 : // UMCM Readout MCMs (G10/Cu/Si)
1707 : // UDCS DCSs boards (G10/Cu)
1708 : // UTP1 Power bars (Cu)
1709 : // UTCP Cooling pipes (Fe)
1710 : // UTCH Cooling pipes (Water)
1711 : // UTPL Power lines (Cu)
1712 : // UTGD Gas distribution box (V2A)
1713 : //
1714 :
1715 : Int_t ilayer = 0;
1716 : Int_t istack = 0;
1717 :
1718 : Float_t xpos = 0.0;
1719 : Float_t ypos = 0.0;
1720 : Float_t zpos = 0.0;
1721 :
1722 : const Int_t kTag = 100;
1723 2 : Char_t cTagV[kTag];
1724 :
1725 : const Int_t kNparBox = 3;
1726 1 : Float_t parBox[kNparBox];
1727 :
1728 : const Int_t kNparTube = 3;
1729 1 : Float_t parTube[kNparTube];
1730 :
1731 : // Services inside the baby frame
1732 : const Float_t kBBMdz = 223.0;
1733 : const Float_t kBBSdz = 8.5;
1734 :
1735 : // Services inside the back frame
1736 : const Float_t kBFMdz = 118.0;
1737 : const Float_t kBFSdz = 8.5;
1738 :
1739 : // The rotation matrices
1740 : const Int_t kNmatrix = 10;
1741 1 : Int_t matrix[kNmatrix];
1742 1 : TVirtualMC::GetMC()->Matrix(matrix[0], 100.0, 0.0, 90.0, 90.0, 10.0, 0.0); // rotation around y-axis
1743 1 : TVirtualMC::GetMC()->Matrix(matrix[1], 80.0, 0.0, 90.0, 90.0, 10.0, 180.0); // rotation around y-axis
1744 1 : TVirtualMC::GetMC()->Matrix(matrix[2], 0.0, 0.0, 90.0, 90.0, 90.0, 0.0);
1745 1 : TVirtualMC::GetMC()->Matrix(matrix[3], 180.0, 0.0, 90.0, 90.0, 90.0, 180.0);
1746 1 : TVirtualMC::GetMC()->Matrix(matrix[4], 90.0, 0.0, 0.0, 0.0, 90.0, 90.0);
1747 1 : TVirtualMC::GetMC()->Matrix(matrix[5], 100.0, 0.0, 90.0, 270.0, 10.0, 0.0);
1748 1 : TVirtualMC::GetMC()->Matrix(matrix[6], 80.0, 0.0, 90.0, 270.0, 10.0, 180.0);
1749 1 : TVirtualMC::GetMC()->Matrix(matrix[7], 90.0, 10.0, 90.0, 100.0, 0.0, 0.0); // rotation around z-axis
1750 1 : TVirtualMC::GetMC()->Matrix(matrix[8], 90.0, 350.0, 90.0, 80.0, 0.0, 0.0); // rotation around z-axis
1751 1 : TVirtualMC::GetMC()->Matrix(matrix[9], 90.0, 90.0, 90.0, 180.0, 0.0, 0.0); // rotation around z-axis
1752 :
1753 : //
1754 : // The cooling arterias
1755 : //
1756 :
1757 : // Width of the cooling arterias
1758 : const Float_t kCOLwid = 0.8;
1759 : // Height of the cooling arterias
1760 : const Float_t kCOLhgt = 6.5;
1761 : // Positioning of the cooling
1762 : const Float_t kCOLposx = 1.0;
1763 : const Float_t kCOLposz = -1.2;
1764 : // Thickness of the walls of the cooling arterias
1765 : const Float_t kCOLthk = 0.1;
1766 : const Int_t kNparCOL = 3;
1767 1 : Float_t parCOL[kNparCOL];
1768 1 : parCOL[0] = 0.0;
1769 1 : parCOL[1] = 0.0;
1770 1 : parCOL[2] = 0.0;
1771 1 : TVirtualMC::GetMC()->Gsvolu("UTC1","BOX ",idtmed[1308-1],parCOL,0);
1772 1 : TVirtualMC::GetMC()->Gsvolu("UTC3","BOX ",idtmed[1308-1],parCOL,0);
1773 1 : parCOL[0] = kCOLwid/2.0 - kCOLthk;
1774 1 : parCOL[1] = -1.0;
1775 1 : parCOL[2] = kCOLhgt/2.0 - kCOLthk;
1776 1 : TVirtualMC::GetMC()->Gsvolu("UTC2","BOX ",idtmed[1314-1],parCOL,kNparCOL);
1777 1 : TVirtualMC::GetMC()->Gsvolu("UTC4","BOX ",idtmed[1314-1],parCOL,kNparCOL);
1778 :
1779 : xpos = 0.0;
1780 : ypos = 0.0;
1781 : zpos = 0.0;
1782 1 : TVirtualMC::GetMC()->Gspos("UTC2",1,"UTC1", xpos,ypos,zpos,0,"ONLY");
1783 1 : TVirtualMC::GetMC()->Gspos("UTC4",1,"UTC3", xpos,ypos,zpos,0,"ONLY");
1784 :
1785 12 : for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1786 :
1787 : // Along the chambers
1788 5 : xpos = fgkCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx;
1789 : ypos = 0.0;
1790 5 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1791 : + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1792 5 : + ilayer * (fgkCH + fgkVspace);
1793 5 : parCOL[0] = kCOLwid /2.0;
1794 5 : parCOL[1] = fgkSlength/2.0;
1795 5 : parCOL[2] = kCOLhgt /2.0;
1796 10 : TVirtualMC::GetMC()->Gsposp("UTC1",ilayer ,"UTI1", xpos,ypos,zpos
1797 5 : ,matrix[0],"ONLY",parCOL,kNparCOL);
1798 10 : TVirtualMC::GetMC()->Gsposp("UTC1",ilayer+ kNlayer,"UTI1",-xpos,ypos,zpos
1799 5 : ,matrix[1],"ONLY",parCOL,kNparCOL);
1800 10 : TVirtualMC::GetMC()->Gsposp("UTC1",ilayer+ 6*kNlayer,"UTI2", xpos,ypos,zpos
1801 5 : ,matrix[0],"ONLY",parCOL,kNparCOL);
1802 10 : TVirtualMC::GetMC()->Gsposp("UTC1",ilayer+ 7*kNlayer,"UTI2",-xpos,ypos,zpos
1803 5 : ,matrix[1],"ONLY",parCOL,kNparCOL);
1804 10 : TVirtualMC::GetMC()->Gsposp("UTC1",ilayer+ 8*kNlayer,"UTI3", xpos,ypos,zpos
1805 5 : ,matrix[0],"ONLY",parCOL,kNparCOL);
1806 10 : TVirtualMC::GetMC()->Gsposp("UTC1",ilayer+ 9*kNlayer,"UTI3",-xpos,ypos,zpos
1807 5 : ,matrix[1],"ONLY",parCOL,kNparCOL);
1808 10 : TVirtualMC::GetMC()->Gsposp("UTC1",ilayer+10*kNlayer,"UTI4", xpos,ypos,zpos
1809 5 : ,matrix[0],"ONLY",parCOL,kNparCOL);
1810 10 : TVirtualMC::GetMC()->Gsposp("UTC1",ilayer+11*kNlayer,"UTI4",-xpos,ypos,zpos
1811 5 : ,matrix[1],"ONLY",parCOL,kNparCOL);
1812 :
1813 : // Front of supermodules
1814 5 : xpos = fgkCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx;
1815 : ypos = 0.0;
1816 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1817 : + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1818 : + ilayer * (fgkCH + fgkVspace);
1819 5 : parCOL[0] = kCOLwid /2.0;
1820 5 : parCOL[1] = fgkFlength/2.0;
1821 5 : parCOL[2] = kCOLhgt /2.0;
1822 10 : TVirtualMC::GetMC()->Gsposp("UTC3",ilayer+2*kNlayer,"UTF1", xpos,ypos,zpos
1823 5 : ,matrix[0],"ONLY",parCOL,kNparCOL);
1824 10 : TVirtualMC::GetMC()->Gsposp("UTC3",ilayer+3*kNlayer,"UTF1",-xpos,ypos,zpos
1825 5 : ,matrix[1],"ONLY",parCOL,kNparCOL);
1826 10 : TVirtualMC::GetMC()->Gsposp("UTC3",ilayer+4*kNlayer,"UTF2", xpos,ypos,zpos
1827 5 : ,matrix[0],"ONLY",parCOL,kNparCOL);
1828 10 : TVirtualMC::GetMC()->Gsposp("UTC3",ilayer+5*kNlayer,"UTF2",-xpos,ypos,zpos
1829 5 : ,matrix[1],"ONLY",parCOL,kNparCOL);
1830 :
1831 : }
1832 :
1833 12 : for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1834 :
1835 : // In baby frame
1836 5 : xpos = fgkCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx - 2.5;
1837 : ypos = kBBSdz/2.0 - kBBMdz/2.0;
1838 5 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1839 : + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1840 5 : + ilayer * (fgkCH + fgkVspace);
1841 5 : parCOL[0] = kCOLwid/2.0;
1842 5 : parCOL[1] = kBBSdz /2.0;
1843 5 : parCOL[2] = kCOLhgt/2.0;
1844 10 : TVirtualMC::GetMC()->Gsposp("UTC3",ilayer+6*kNlayer,"BBTRD", xpos, ypos, zpos
1845 5 : ,matrix[0],"ONLY",parCOL,kNparCOL);
1846 10 : TVirtualMC::GetMC()->Gsposp("UTC3",ilayer+7*kNlayer,"BBTRD",-xpos, ypos, zpos
1847 5 : ,matrix[1],"ONLY",parCOL,kNparCOL);
1848 :
1849 : }
1850 :
1851 12 : for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1852 :
1853 : // In back frame
1854 5 : xpos = fgkCwidth[ilayer]/2.0 + kCOLwid/2.0 + kCOLposx - 0.3;
1855 : ypos = -kBFSdz/2.0 + kBFMdz/2.0;
1856 5 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1857 : + kCOLhgt/2.0 - fgkSheight/2.0 + kCOLposz
1858 5 : + ilayer * (fgkCH + fgkVspace);
1859 5 : parCOL[0] = kCOLwid/2.0;
1860 5 : parCOL[1] = kBFSdz /2.0;
1861 5 : parCOL[2] = kCOLhgt/2.0;
1862 10 : TVirtualMC::GetMC()->Gsposp("UTC3",ilayer+6*kNlayer,"BFTRD", xpos,ypos,zpos
1863 5 : ,matrix[0],"ONLY",parCOL,kNparCOL);
1864 10 : TVirtualMC::GetMC()->Gsposp("UTC3",ilayer+7*kNlayer,"BFTRD",-xpos,ypos,zpos
1865 5 : ,matrix[1],"ONLY",parCOL,kNparCOL);
1866 :
1867 : }
1868 :
1869 : // The upper most layer
1870 : // Along the chambers
1871 1 : xpos = fgkCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1872 : ypos = 0.0;
1873 : zpos = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1874 1 : parCOL[0] = kCOLwid /2.0;
1875 1 : parCOL[1] = fgkSlength/2.0;
1876 1 : parCOL[2] = kCOLhgt /2.0;
1877 2 : TVirtualMC::GetMC()->Gsposp("UTC1",6 ,"UTI1", xpos,ypos,zpos
1878 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1879 2 : TVirtualMC::GetMC()->Gsposp("UTC1",6+ kNlayer,"UTI1",-xpos,ypos,zpos
1880 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1881 2 : TVirtualMC::GetMC()->Gsposp("UTC1",6+ 6*kNlayer,"UTI2", xpos,ypos,zpos
1882 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1883 2 : TVirtualMC::GetMC()->Gsposp("UTC1",6+ 7*kNlayer,"UTI2",-xpos,ypos,zpos
1884 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1885 2 : TVirtualMC::GetMC()->Gsposp("UTC1",6+ 8*kNlayer,"UTI3", xpos,ypos,zpos
1886 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1887 2 : TVirtualMC::GetMC()->Gsposp("UTC1",6+ 9*kNlayer,"UTI3",-xpos,ypos,zpos
1888 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1889 2 : TVirtualMC::GetMC()->Gsposp("UTC1",6+10*kNlayer,"UTI4", xpos,ypos,zpos
1890 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1891 2 : TVirtualMC::GetMC()->Gsposp("UTC1",6+11*kNlayer,"UTI4",-xpos,ypos,zpos
1892 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1893 : // Front of supermodules
1894 : xpos = fgkCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1895 : ypos = 0.0;
1896 : zpos = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1897 1 : parCOL[0] = kCOLwid /2.0;
1898 1 : parCOL[1] = fgkFlength/2.0;
1899 1 : parCOL[2] = kCOLhgt /2.0;
1900 2 : TVirtualMC::GetMC()->Gsposp("UTC3",6+ 2*kNlayer,"UTF1", xpos,ypos,zpos
1901 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1902 2 : TVirtualMC::GetMC()->Gsposp("UTC3",6+ 3*kNlayer,"UTF1",-xpos,ypos,zpos
1903 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1904 2 : TVirtualMC::GetMC()->Gsposp("UTC3",6+ 4*kNlayer,"UTF2", xpos,ypos,zpos
1905 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1906 2 : TVirtualMC::GetMC()->Gsposp("UTC3",6+ 5*kNlayer,"UTF2",-xpos,ypos,zpos
1907 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1908 : // In baby frame
1909 1 : xpos = fgkCwidth[5]/2.0 - kCOLhgt/2.0 - 3.1;
1910 : ypos = kBBSdz/2.0 - kBBMdz/2.0;
1911 : zpos = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1912 1 : parCOL[0] = kCOLwid/2.0;
1913 1 : parCOL[1] = kBBSdz /2.0;
1914 1 : parCOL[2] = kCOLhgt/2.0;
1915 2 : TVirtualMC::GetMC()->Gsposp("UTC3",6+6*kNlayer,"BBTRD", xpos, ypos, zpos
1916 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1917 2 : TVirtualMC::GetMC()->Gsposp("UTC3",6+7*kNlayer,"BBTRD",-xpos, ypos, zpos
1918 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1919 : // In back frame
1920 : xpos = fgkCwidth[5]/2.0 - kCOLhgt/2.0 - 1.3;
1921 : ypos = -kBFSdz/2.0 + kBFMdz/2.0;
1922 : zpos = fgkSheight/2.0 - fgkSMpltT - 0.4 - kCOLwid/2.0;
1923 1 : parCOL[0] = kCOLwid/2.0;
1924 1 : parCOL[1] = kBFSdz /2.0;
1925 1 : parCOL[2] = kCOLhgt/2.0;
1926 2 : TVirtualMC::GetMC()->Gsposp("UTC3",6+6*kNlayer,"BFTRD", xpos,ypos,zpos
1927 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1928 2 : TVirtualMC::GetMC()->Gsposp("UTC3",6+7*kNlayer,"BFTRD",-xpos,ypos,zpos
1929 1 : ,matrix[3],"ONLY",parCOL,kNparCOL);
1930 :
1931 : //
1932 : // The power bus bars
1933 : //
1934 :
1935 : const Float_t kPWRwid = 0.6;
1936 : // Increase the height of the power bus bars to take into
1937 : // account the material of additional cables, etc.
1938 : const Float_t kPWRhgtA = 5.0 + 0.2;
1939 : const Float_t kPWRhgtB = 5.0;
1940 : const Float_t kPWRposx = 2.0;
1941 : const Float_t kPWRposz = 0.1;
1942 : const Int_t kNparPWR = 3;
1943 1 : Float_t parPWR[kNparPWR];
1944 1 : parPWR[0] = 0.0;
1945 1 : parPWR[1] = 0.0;
1946 1 : parPWR[2] = 0.0;
1947 1 : TVirtualMC::GetMC()->Gsvolu("UTP1","BOX ",idtmed[1325-1],parPWR,0);
1948 1 : TVirtualMC::GetMC()->Gsvolu("UTP3","BOX ",idtmed[1325-1],parPWR,0);
1949 :
1950 12 : for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1951 :
1952 : // Along the chambers
1953 5 : xpos = fgkCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx;
1954 : ypos = 0.0;
1955 5 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1956 : + kPWRhgtA/2.0 - fgkSheight/2.0 + kPWRposz
1957 5 : + ilayer * (fgkCH + fgkVspace);
1958 5 : parPWR[0] = kPWRwid /2.0;
1959 5 : parPWR[1] = fgkSlength/2.0;
1960 5 : parPWR[2] = kPWRhgtA /2.0;
1961 10 : TVirtualMC::GetMC()->Gsposp("UTP1",ilayer ,"UTI1", xpos,ypos,zpos
1962 5 : ,matrix[0],"ONLY",parPWR,kNparPWR);
1963 10 : TVirtualMC::GetMC()->Gsposp("UTP1",ilayer+ kNlayer,"UTI1",-xpos,ypos,zpos
1964 5 : ,matrix[1],"ONLY",parPWR,kNparPWR);
1965 10 : TVirtualMC::GetMC()->Gsposp("UTP1",ilayer+ 6*kNlayer,"UTI2", xpos,ypos,zpos
1966 5 : ,matrix[0],"ONLY",parPWR,kNparPWR);
1967 10 : TVirtualMC::GetMC()->Gsposp("UTP1",ilayer+ 7*kNlayer,"UTI2",-xpos,ypos,zpos
1968 5 : ,matrix[1],"ONLY",parPWR,kNparPWR);
1969 10 : TVirtualMC::GetMC()->Gsposp("UTP1",ilayer+ 8*kNlayer,"UTI3", xpos,ypos,zpos
1970 5 : ,matrix[0],"ONLY",parPWR,kNparPWR);
1971 10 : TVirtualMC::GetMC()->Gsposp("UTP1",ilayer+ 9*kNlayer,"UTI3",-xpos,ypos,zpos
1972 5 : ,matrix[1],"ONLY",parPWR,kNparPWR);
1973 10 : TVirtualMC::GetMC()->Gsposp("UTP1",ilayer+10*kNlayer,"UTI4", xpos,ypos,zpos
1974 5 : ,matrix[0],"ONLY",parPWR,kNparPWR);
1975 10 : TVirtualMC::GetMC()->Gsposp("UTP1",ilayer+11*kNlayer,"UTI4",-xpos,ypos,zpos
1976 5 : ,matrix[1],"ONLY",parPWR,kNparPWR);
1977 :
1978 : // Front of supermodule
1979 5 : xpos = fgkCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx;
1980 : ypos = 0.0;
1981 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
1982 : + kPWRhgtA/2.0 - fgkSheight/2.0 + kPWRposz
1983 : + ilayer * (fgkCH + fgkVspace);
1984 5 : parPWR[0] = kPWRwid /2.0;
1985 5 : parPWR[1] = fgkFlength/2.0;
1986 5 : parPWR[2] = kPWRhgtA /2.0;
1987 10 : TVirtualMC::GetMC()->Gsposp("UTP3",ilayer+ 2*kNlayer,"UTF1", xpos,ypos,zpos
1988 5 : ,matrix[0],"ONLY",parPWR,kNparPWR);
1989 10 : TVirtualMC::GetMC()->Gsposp("UTP3",ilayer+ 3*kNlayer,"UTF1",-xpos,ypos,zpos
1990 5 : ,matrix[1],"ONLY",parPWR,kNparPWR);
1991 10 : TVirtualMC::GetMC()->Gsposp("UTP3",ilayer+ 4*kNlayer,"UTF2", xpos,ypos,zpos
1992 5 : ,matrix[0],"ONLY",parPWR,kNparPWR);
1993 10 : TVirtualMC::GetMC()->Gsposp("UTP3",ilayer+ 5*kNlayer,"UTF2",-xpos,ypos,zpos
1994 5 : ,matrix[1],"ONLY",parPWR,kNparPWR);
1995 :
1996 : }
1997 :
1998 12 : for (ilayer = 1; ilayer < kNlayer; ilayer++) {
1999 :
2000 : // In baby frame
2001 5 : xpos = fgkCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx - 2.5;
2002 : ypos = kBBSdz/2.0 - kBBMdz/2.0;
2003 5 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
2004 : + kPWRhgtB/2.0 - fgkSheight/2.0 + kPWRposz
2005 5 : + ilayer * (fgkCH + fgkVspace);
2006 5 : parPWR[0] = kPWRwid /2.0;
2007 5 : parPWR[1] = kBBSdz /2.0;
2008 5 : parPWR[2] = kPWRhgtB/2.0;
2009 10 : TVirtualMC::GetMC()->Gsposp("UTP3",ilayer+6*kNlayer,"BBTRD", xpos, ypos, zpos
2010 5 : ,matrix[0],"ONLY",parPWR,kNparPWR);
2011 10 : TVirtualMC::GetMC()->Gsposp("UTP3",ilayer+7*kNlayer,"BBTRD",-xpos, ypos, zpos
2012 5 : ,matrix[1],"ONLY",parPWR,kNparPWR);
2013 :
2014 : }
2015 :
2016 12 : for (ilayer = 1; ilayer < kNlayer; ilayer++) {
2017 :
2018 : // In back frame
2019 5 : xpos = fgkCwidth[ilayer]/2.0 + kPWRwid/2.0 + kPWRposx - 0.3;
2020 : ypos = -kBFSdz/2.0 + kBFMdz/2.0;
2021 5 : zpos = fgkVrocsm + fgkSMpltT - fgkCalZpos
2022 : + kPWRhgtB/2.0 - fgkSheight/2.0 + kPWRposz
2023 5 : + ilayer * (fgkCH + fgkVspace);
2024 5 : parPWR[0] = kPWRwid /2.0;
2025 5 : parPWR[1] = kBFSdz /2.0;
2026 5 : parPWR[2] = kPWRhgtB/2.0;
2027 10 : TVirtualMC::GetMC()->Gsposp("UTP3",ilayer+8*kNlayer,"BFTRD", xpos,ypos,zpos
2028 5 : ,matrix[0],"ONLY",parPWR,kNparPWR);
2029 10 : TVirtualMC::GetMC()->Gsposp("UTP3",ilayer+9*kNlayer,"BFTRD",-xpos,ypos,zpos
2030 5 : ,matrix[1],"ONLY",parPWR,kNparPWR);
2031 :
2032 : }
2033 :
2034 : // The upper most layer
2035 : // Along the chambers
2036 1 : xpos = fgkCwidth[5]/2.0 + kPWRhgtB/2.0 - 1.3;
2037 : ypos = 0.0;
2038 : zpos = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2039 1 : parPWR[0] = kPWRwid /2.0;
2040 1 : parPWR[1] = fgkSlength/2.0;
2041 1 : parPWR[2] = kPWRhgtB /2.0 ;
2042 2 : TVirtualMC::GetMC()->Gsposp("UTP1",6 ,"UTI1", xpos,ypos,zpos
2043 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2044 2 : TVirtualMC::GetMC()->Gsposp("UTP1",6+ kNlayer,"UTI1",-xpos,ypos,zpos
2045 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2046 2 : TVirtualMC::GetMC()->Gsposp("UTP1",6+ 6*kNlayer,"UTI2", xpos,ypos,zpos
2047 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2048 2 : TVirtualMC::GetMC()->Gsposp("UTP1",6+ 7*kNlayer,"UTI2",-xpos,ypos,zpos
2049 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2050 2 : TVirtualMC::GetMC()->Gsposp("UTP1",6+ 8*kNlayer,"UTI3", xpos,ypos,zpos
2051 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2052 2 : TVirtualMC::GetMC()->Gsposp("UTP1",6+ 9*kNlayer,"UTI3",-xpos,ypos,zpos
2053 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2054 2 : TVirtualMC::GetMC()->Gsposp("UTP1",6+10*kNlayer,"UTI4", xpos,ypos,zpos
2055 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2056 2 : TVirtualMC::GetMC()->Gsposp("UTP1",6+11*kNlayer,"UTI4",-xpos,ypos,zpos
2057 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2058 : // Front of supermodules
2059 : xpos = fgkCwidth[5]/2.0 + kPWRhgtB/2.0 - 1.3;
2060 : ypos = 0.0;
2061 : zpos = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2062 1 : parPWR[0] = kPWRwid /2.0;
2063 1 : parPWR[1] = fgkFlength/2.0;
2064 1 : parPWR[2] = kPWRhgtB /2.0;
2065 2 : TVirtualMC::GetMC()->Gsposp("UTP3",6+2*kNlayer,"UTF1", xpos,ypos,zpos
2066 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2067 2 : TVirtualMC::GetMC()->Gsposp("UTP3",6+3*kNlayer,"UTF1",-xpos,ypos,zpos
2068 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2069 2 : TVirtualMC::GetMC()->Gsposp("UTP3",6+4*kNlayer,"UTF2", xpos,ypos,zpos
2070 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2071 2 : TVirtualMC::GetMC()->Gsposp("UTP3",6+5*kNlayer,"UTF2",-xpos,ypos,zpos
2072 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2073 : // In baby frame
2074 1 : xpos = fgkCwidth[5]/2.0 + kPWRhgtB/2.0 - 3.0;
2075 : ypos = kBBSdz/2.0 - kBBMdz/2.0;
2076 : zpos = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2077 1 : parPWR[0] = kPWRwid /2.0;
2078 1 : parPWR[1] = kBBSdz /2.0;
2079 1 : parPWR[2] = kPWRhgtB/2.0;
2080 2 : TVirtualMC::GetMC()->Gsposp("UTP3",6+6*kNlayer,"BBTRD", xpos, ypos, zpos
2081 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2082 2 : TVirtualMC::GetMC()->Gsposp("UTP3",6+7*kNlayer,"BBTRD",-xpos, ypos, zpos
2083 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2084 : // In back frame
2085 : xpos = fgkCwidth[5]/2.0 + kPWRhgtB/2.0 - 1.3;
2086 : ypos = -kBFSdz/2.0 + kBFMdz/2.0;
2087 : zpos = fgkSheight/2.0 - fgkSMpltT - 0.6 - kPWRwid/2.0;
2088 1 : parPWR[0] = kPWRwid /2.0;
2089 1 : parPWR[1] = kBFSdz /2.0;
2090 1 : parPWR[2] = kPWRhgtB/2.0;
2091 2 : TVirtualMC::GetMC()->Gsposp("UTP3",6+8*kNlayer,"BFTRD", xpos,ypos,zpos
2092 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2093 2 : TVirtualMC::GetMC()->Gsposp("UTP3",6+9*kNlayer,"BFTRD",-xpos,ypos,zpos
2094 1 : ,matrix[3],"ONLY",parPWR,kNparPWR);
2095 :
2096 : //
2097 : // The gas tubes connecting the chambers in the super modules with holes
2098 : // Material: Stainless steel
2099 : //
2100 :
2101 : // PHOS holes
2102 1 : parTube[0] = 0.0;
2103 1 : parTube[1] = 2.2/2.0;
2104 1 : parTube[2] = fgkClength[5][2]/2.0 - fgkHspace/2.0;
2105 1 : TVirtualMC::GetMC()->Gsvolu("UTG1","TUBE",idtmed[1308-1],parTube,kNparTube);
2106 1 : parTube[0] = 0.0;
2107 1 : parTube[1] = 2.1/2.0;
2108 1 : parTube[2] = fgkClength[5][2]/2.0 - fgkHspace/2.0;
2109 1 : TVirtualMC::GetMC()->Gsvolu("UTG2","TUBE",idtmed[1309-1],parTube,kNparTube);
2110 : xpos = 0.0;
2111 : ypos = 0.0;
2112 : zpos = 0.0;
2113 1 : TVirtualMC::GetMC()->Gspos("UTG2",1,"UTG1",xpos,ypos,zpos,0,"ONLY");
2114 14 : for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2115 6 : xpos = fgkCwidth[ilayer]/2.0 + kCOLwid/2.0 - 1.5;
2116 : ypos = 0.0;
2117 6 : zpos = fgkVrocsm + fgkSMpltT + kCOLhgt/2.0 - fgkSheight/2.0 + 5.0
2118 6 : + ilayer * (fgkCH + fgkVspace);
2119 6 : TVirtualMC::GetMC()->Gspos("UTG1",1+ilayer,"UTI3", xpos, ypos, zpos,matrix[4],"ONLY");
2120 6 : TVirtualMC::GetMC()->Gspos("UTG1",7+ilayer,"UTI3",-xpos, ypos, zpos,matrix[4],"ONLY");
2121 : }
2122 : // Missing L4S4 chamber in sector 17
2123 1 : parTube[0] = 0.0;
2124 1 : parTube[1] = 2.2/2.0;
2125 1 : parTube[2] = fgkClength[4][4]/2.0 - fgkHspace/2.0;
2126 1 : TVirtualMC::GetMC()->Gsvolu("UTG3","TUBE",idtmed[1308-1],parTube,kNparTube);
2127 1 : parTube[0] = 0.0;
2128 1 : parTube[1] = 2.1/2.0;
2129 1 : parTube[2] = fgkClength[4][4]/2.0 - fgkHspace/2.0;
2130 1 : TVirtualMC::GetMC()->Gsvolu("UTG4","TUBE",idtmed[1309-1],parTube,kNparTube);
2131 : xpos = 0.0;
2132 : ypos = 0.0;
2133 : zpos = 0.0;
2134 1 : TVirtualMC::GetMC()->Gspos("UTG4",1,"UTG3",xpos,ypos,zpos,0,"ONLY");
2135 1 : xpos = fgkCwidth[4]/2.0 + kCOLwid/2.0 - 1.5;
2136 1 : ypos = -fgkClength[4][0]/2.0 - fgkClength[4][1] - fgkClength[4][2]/2.0;
2137 : zpos = fgkVrocsm + fgkSMpltT + kCOLhgt/2.0 - fgkSheight/2.0 + 5.0 + 4 * (fgkCH + fgkVspace);
2138 1 : TVirtualMC::GetMC()->Gspos("UTG3",1,"UTI4", xpos, ypos, zpos,matrix[4],"ONLY");
2139 1 : TVirtualMC::GetMC()->Gspos("UTG4",2,"UTI4",-xpos, ypos, zpos,matrix[4],"ONLY");
2140 :
2141 : //
2142 : // The volumes for the services at the chambers
2143 : //
2144 :
2145 : const Int_t kNparServ = 3;
2146 1 : Float_t parServ[kNparServ];
2147 :
2148 12 : for (istack = 0; istack < kNstack; istack++) {
2149 70 : for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2150 :
2151 30 : Int_t iDet = GetDetectorSec(ilayer,istack);
2152 :
2153 30 : snprintf(cTagV,kTag,"UU%02d",iDet);
2154 30 : parServ[0] = fgkCwidth[ilayer] /2.0;
2155 30 : parServ[1] = fgkClength[ilayer][istack]/2.0 - fgkHspace/2.0;
2156 30 : parServ[2] = fgkCsvH /2.0;
2157 30 : TVirtualMC::GetMC()->Gsvolu(cTagV,"BOX",idtmed[1302-1],parServ,kNparServ);
2158 :
2159 : }
2160 : }
2161 :
2162 : //
2163 : // The cooling pipes inside the service volumes
2164 : //
2165 :
2166 : // The cooling pipes
2167 1 : parTube[0] = 0.0;
2168 1 : parTube[1] = 0.0;
2169 1 : parTube[2] = 0.0;
2170 1 : TVirtualMC::GetMC()->Gsvolu("UTCP","TUBE",idtmed[1324-1],parTube,0);
2171 : // The cooling water
2172 1 : parTube[0] = 0.0;
2173 1 : parTube[1] = 0.2/2.0;
2174 1 : parTube[2] = -1.0;
2175 1 : TVirtualMC::GetMC()->Gsvolu("UTCH","TUBE",idtmed[1314-1],parTube,kNparTube);
2176 : // Water inside the cooling pipe
2177 : xpos = 0.0;
2178 : ypos = 0.0;
2179 : zpos = 0.0;
2180 1 : TVirtualMC::GetMC()->Gspos("UTCH",1,"UTCP",xpos,ypos,zpos,0,"ONLY");
2181 :
2182 : // Position the cooling pipes in the mother volume
2183 12 : for (istack = 0; istack < kNstack; istack++) {
2184 70 : for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2185 30 : Int_t iDet = GetDetectorSec(ilayer,istack);
2186 30 : Int_t iCopy = GetDetector(ilayer,istack,0) * 100;
2187 30 : Int_t nMCMrow = GetRowMax(ilayer,istack,0);
2188 60 : Float_t ySize = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2189 30 : / ((Float_t) nMCMrow);
2190 30 : snprintf(cTagV,kTag,"UU%02d",iDet);
2191 972 : for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2192 : xpos = 0.0;
2193 912 : ypos = (0.5 + iMCMrow) * ySize
2194 456 : - fgkClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2195 : zpos = 0.0 + 0.742/2.0;
2196 : // The cooling pipes
2197 456 : parTube[0] = 0.0;
2198 456 : parTube[1] = 0.3/2.0; // Thickness of the cooling pipes
2199 456 : parTube[2] = fgkCwidth[ilayer]/2.0;
2200 912 : TVirtualMC::GetMC()->Gsposp("UTCP",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
2201 456 : ,matrix[2],"ONLY",parTube,kNparTube);
2202 : }
2203 : }
2204 : }
2205 :
2206 : //
2207 : // The power lines
2208 : //
2209 :
2210 : // The copper power lines
2211 1 : parTube[0] = 0.0;
2212 1 : parTube[1] = 0.0;
2213 1 : parTube[2] = 0.0;
2214 1 : TVirtualMC::GetMC()->Gsvolu("UTPL","TUBE",idtmed[1305-1],parTube,0);
2215 :
2216 : // Position the power lines in the mother volume
2217 12 : for (istack = 0; istack < kNstack; istack++) {
2218 70 : for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2219 30 : Int_t iDet = GetDetectorSec(ilayer,istack);
2220 30 : Int_t iCopy = GetDetector(ilayer,istack,0) * 100;
2221 30 : Int_t nMCMrow = GetRowMax(ilayer,istack,0);
2222 60 : Float_t ySize = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2223 30 : / ((Float_t) nMCMrow);
2224 30 : snprintf(cTagV,kTag,"UU%02d",iDet);
2225 972 : for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2226 : xpos = 0.0;
2227 912 : ypos = (0.5 + iMCMrow) * ySize - 1.0
2228 456 : - fgkClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2229 : zpos = -0.4 + 0.742/2.0;
2230 456 : parTube[0] = 0.0;
2231 456 : parTube[1] = 0.2/2.0; // Thickness of the power lines
2232 456 : parTube[2] = fgkCwidth[ilayer]/2.0;
2233 912 : TVirtualMC::GetMC()->Gsposp("UTPL",iCopy+iMCMrow,cTagV,xpos,ypos,zpos
2234 456 : ,matrix[2],"ONLY",parTube,kNparTube);
2235 : }
2236 : }
2237 : }
2238 :
2239 : //
2240 : // The MCMs
2241 : //
2242 :
2243 : const Float_t kMCMx = 3.0;
2244 : const Float_t kMCMy = 3.0;
2245 : const Float_t kMCMz = 0.3;
2246 :
2247 : const Float_t kMCMpcTh = 0.1;
2248 : const Float_t kMCMcuTh = 0.0025;
2249 : const Float_t kMCMsiTh = 0.03;
2250 : const Float_t kMCMcoTh = 0.04;
2251 :
2252 : // The mother volume for the MCMs (air)
2253 : const Int_t kNparMCM = 3;
2254 1 : Float_t parMCM[kNparMCM];
2255 1 : parMCM[0] = kMCMx /2.0;
2256 1 : parMCM[1] = kMCMy /2.0;
2257 1 : parMCM[2] = kMCMz /2.0;
2258 1 : TVirtualMC::GetMC()->Gsvolu("UMCM","BOX",idtmed[1302-1],parMCM,kNparMCM);
2259 :
2260 : // The MCM carrier G10 layer
2261 1 : parMCM[0] = kMCMx /2.0;
2262 1 : parMCM[1] = kMCMy /2.0;
2263 1 : parMCM[2] = kMCMpcTh/2.0;
2264 1 : TVirtualMC::GetMC()->Gsvolu("UMC1","BOX",idtmed[1319-1],parMCM,kNparMCM);
2265 : // The MCM carrier Cu layer
2266 1 : parMCM[0] = kMCMx /2.0;
2267 1 : parMCM[1] = kMCMy /2.0;
2268 1 : parMCM[2] = kMCMcuTh/2.0;
2269 1 : TVirtualMC::GetMC()->Gsvolu("UMC2","BOX",idtmed[1318-1],parMCM,kNparMCM);
2270 : // The silicon of the chips
2271 1 : parMCM[0] = kMCMx /2.0;
2272 1 : parMCM[1] = kMCMy /2.0;
2273 1 : parMCM[2] = kMCMsiTh/2.0;
2274 1 : TVirtualMC::GetMC()->Gsvolu("UMC3","BOX",idtmed[1320-1],parMCM,kNparMCM);
2275 : // The aluminum of the cooling plates
2276 1 : parMCM[0] = kMCMx /2.0;
2277 1 : parMCM[1] = kMCMy /2.0;
2278 1 : parMCM[2] = kMCMcoTh/2.0;
2279 1 : TVirtualMC::GetMC()->Gsvolu("UMC4","BOX",idtmed[1324-1],parMCM,kNparMCM);
2280 :
2281 : // Put the MCM material inside the MCM mother volume
2282 : xpos = 0.0;
2283 : ypos = 0.0;
2284 : zpos = -kMCMz /2.0 + kMCMpcTh/2.0;
2285 1 : TVirtualMC::GetMC()->Gspos("UMC1",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2286 : zpos += kMCMpcTh/2.0 + kMCMcuTh/2.0;
2287 1 : TVirtualMC::GetMC()->Gspos("UMC2",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2288 : zpos += kMCMcuTh/2.0 + kMCMsiTh/2.0;
2289 1 : TVirtualMC::GetMC()->Gspos("UMC3",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2290 : zpos += kMCMsiTh/2.0 + kMCMcoTh/2.0;
2291 1 : TVirtualMC::GetMC()->Gspos("UMC4",1,"UMCM",xpos,ypos,zpos,0,"ONLY");
2292 :
2293 : // Position the MCMs in the mother volume
2294 12 : for (istack = 0; istack < kNstack; istack++) {
2295 70 : for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2296 30 : Int_t iDet = GetDetectorSec(ilayer,istack);
2297 30 : Int_t iCopy = GetDetector(ilayer,istack,0) * 1000;
2298 30 : Int_t nMCMrow = GetRowMax(ilayer,istack,0);
2299 60 : Float_t ySize = (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2300 30 : / ((Float_t) nMCMrow);
2301 : Int_t nMCMcol = 8;
2302 60 : Float_t xSize = (GetChamberWidth(ilayer) - 2.0*fgkCpadW)
2303 30 : / ((Float_t) nMCMcol + 6); // Introduce 6 gaps
2304 30 : Int_t iMCM[8] = { 1, 2, 3, 5, 8, 9, 10, 12 }; // 0..7 MCM + 6 gap structure
2305 30 : snprintf(cTagV,kTag,"UU%02d",iDet);
2306 972 : for (Int_t iMCMrow = 0; iMCMrow < nMCMrow; iMCMrow++) {
2307 8208 : for (Int_t iMCMcol = 0; iMCMcol < nMCMcol; iMCMcol++) {
2308 7296 : xpos = (0.5 + iMCM[iMCMcol]) * xSize + 1.0
2309 3648 : - fgkCwidth[ilayer]/2.0;
2310 7296 : ypos = (0.5 + iMCMrow) * ySize + 1.0
2311 3648 : - fgkClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2312 : zpos = -0.4 + 0.742/2.0;
2313 7296 : TVirtualMC::GetMC()->Gspos("UMCM",iCopy+iMCMrow*10+iMCMcol,cTagV
2314 3648 : ,xpos,ypos,zpos,0,"ONLY");
2315 : // Add two additional smaller cooling pipes on top of the MCMs
2316 : // to mimic the meandering structure
2317 7296 : xpos = (0.5 + iMCM[iMCMcol]) * xSize + 1.0
2318 3648 : - fgkCwidth[ilayer]/2.0;
2319 3648 : ypos = (0.5 + iMCMrow) * ySize
2320 3648 : - fgkClength[ilayer][istack]/2.0 + fgkHspace/2.0;
2321 : zpos = 0.0 + 0.742/2.0;
2322 3648 : parTube[0] = 0.0;
2323 3648 : parTube[1] = 0.3/2.0; // Thickness of the cooling pipes
2324 3648 : parTube[2] = kMCMx/2.0;
2325 7296 : TVirtualMC::GetMC()->Gsposp("UTCP",iCopy+iMCMrow*10+iMCMcol+ 50,cTagV
2326 3648 : ,xpos,ypos+1.0,zpos
2327 3648 : ,matrix[2],"ONLY",parTube,kNparTube);
2328 7296 : TVirtualMC::GetMC()->Gsposp("UTCP",iCopy+iMCMrow*10+iMCMcol+500,cTagV
2329 3648 : ,xpos,ypos+2.0,zpos
2330 3648 : ,matrix[2],"ONLY",parTube,kNparTube);
2331 :
2332 : }
2333 : }
2334 :
2335 30 : }
2336 : }
2337 :
2338 : //
2339 : // The DCS boards
2340 : //
2341 :
2342 : const Float_t kDCSx = 9.0;
2343 : const Float_t kDCSy = 14.5;
2344 : const Float_t kDCSz = 0.3;
2345 :
2346 : const Float_t kDCSpcTh = 0.15;
2347 : const Float_t kDCScuTh = 0.01;
2348 : const Float_t kDCScoTh = 0.04;
2349 :
2350 : // The mother volume for the DCSs (air)
2351 : const Int_t kNparDCS = 3;
2352 1 : Float_t parDCS[kNparDCS];
2353 1 : parDCS[0] = kDCSx /2.0;
2354 1 : parDCS[1] = kDCSy /2.0;
2355 1 : parDCS[2] = kDCSz /2.0;
2356 1 : TVirtualMC::GetMC()->Gsvolu("UDCS","BOX",idtmed[1302-1],parDCS,kNparDCS);
2357 :
2358 : // The DCS carrier G10 layer
2359 1 : parDCS[0] = kDCSx /2.0;
2360 1 : parDCS[1] = kDCSy /2.0;
2361 1 : parDCS[2] = kDCSpcTh/2.0;
2362 1 : TVirtualMC::GetMC()->Gsvolu("UDC1","BOX",idtmed[1319-1],parDCS,kNparDCS);
2363 : // The DCS carrier Cu layer
2364 1 : parDCS[0] = kDCSx /2.0;
2365 1 : parDCS[1] = kDCSy /2.0;
2366 1 : parDCS[2] = kDCScuTh/2.0;
2367 1 : TVirtualMC::GetMC()->Gsvolu("UDC2","BOX",idtmed[1318-1],parDCS,kNparDCS);
2368 : // The aluminum of the cooling plates
2369 1 : parDCS[0] = 5.0 /2.0;
2370 1 : parDCS[1] = 5.0 /2.0;
2371 1 : parDCS[2] = kDCScoTh/2.0;
2372 1 : TVirtualMC::GetMC()->Gsvolu("UDC3","BOX",idtmed[1324-1],parDCS,kNparDCS);
2373 :
2374 : // Put the DCS material inside the DCS mother volume
2375 : xpos = 0.0;
2376 : ypos = 0.0;
2377 : zpos = -kDCSz /2.0 + kDCSpcTh/2.0;
2378 1 : TVirtualMC::GetMC()->Gspos("UDC1",1,"UDCS",xpos,ypos,zpos,0,"ONLY");
2379 : zpos += kDCSpcTh/2.0 + kDCScuTh/2.0;
2380 1 : TVirtualMC::GetMC()->Gspos("UDC2",1,"UDCS",xpos,ypos,zpos,0,"ONLY");
2381 : zpos += kDCScuTh/2.0 + kDCScoTh/2.0;
2382 1 : TVirtualMC::GetMC()->Gspos("UDC3",1,"UDCS",xpos,ypos,zpos,0,"ONLY");
2383 :
2384 : // Put the DCS board in the chamber services mother volume
2385 12 : for (istack = 0; istack < kNstack; istack++) {
2386 70 : for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2387 30 : Int_t iDet = GetDetectorSec(ilayer,istack);
2388 30 : Int_t iCopy = iDet + 1;
2389 60 : xpos = fgkCwidth[ilayer]/2.0 - 1.9 * (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2390 30 : / ((Float_t) GetRowMax(ilayer,istack,0));
2391 30 : ypos = 0.05 * fgkClength[ilayer][istack];
2392 : zpos = kDCSz/2.0 - fgkCsvH/2.0;
2393 30 : snprintf(cTagV,kTag,"UU%02d",iDet);
2394 30 : TVirtualMC::GetMC()->Gspos("UDCS",iCopy,cTagV,xpos,ypos,zpos,0,"ONLY");
2395 : }
2396 : }
2397 :
2398 : //
2399 : // The ORI boards
2400 : //
2401 :
2402 : const Float_t kORIx = 4.2;
2403 : const Float_t kORIy = 13.5;
2404 : const Float_t kORIz = 0.3;
2405 :
2406 : const Float_t kORIpcTh = 0.15;
2407 : const Float_t kORIcuTh = 0.01;
2408 : const Float_t kORIcoTh = 0.04;
2409 :
2410 : // The mother volume for the ORIs (air)
2411 : const Int_t kNparORI = 3;
2412 1 : Float_t parORI[kNparORI];
2413 1 : parORI[0] = kORIx /2.0;
2414 1 : parORI[1] = kORIy /2.0;
2415 1 : parORI[2] = kORIz /2.0;
2416 1 : TVirtualMC::GetMC()->Gsvolu("UORI","BOX",idtmed[1302-1],parORI,kNparORI);
2417 :
2418 : // The ORI carrier G10 layer
2419 1 : parORI[0] = kORIx /2.0;
2420 1 : parORI[1] = kORIy /2.0;
2421 1 : parORI[2] = kORIpcTh/2.0;
2422 1 : TVirtualMC::GetMC()->Gsvolu("UOR1","BOX",idtmed[1319-1],parORI,kNparORI);
2423 : // The ORI carrier Cu layer
2424 1 : parORI[0] = kORIx /2.0;
2425 1 : parORI[1] = kORIy /2.0;
2426 1 : parORI[2] = kORIcuTh/2.0;
2427 1 : TVirtualMC::GetMC()->Gsvolu("UOR2","BOX",idtmed[1318-1],parORI,kNparORI);
2428 : // The aluminum of the cooling plates
2429 1 : parORI[0] = kORIx /2.0;
2430 1 : parORI[1] = kORIy /2.0;
2431 1 : parORI[2] = kORIcoTh/2.0;
2432 1 : TVirtualMC::GetMC()->Gsvolu("UOR3","BOX",idtmed[1324-1],parORI,kNparORI);
2433 :
2434 : // Put the ORI material inside the ORI mother volume
2435 : xpos = 0.0;
2436 : ypos = 0.0;
2437 : zpos = -kORIz /2.0 + kORIpcTh/2.0;
2438 1 : TVirtualMC::GetMC()->Gspos("UOR1",1,"UORI",xpos,ypos,zpos,0,"ONLY");
2439 : zpos += kORIpcTh/2.0 + kORIcuTh/2.0;
2440 1 : TVirtualMC::GetMC()->Gspos("UOR2",1,"UORI",xpos,ypos,zpos,0,"ONLY");
2441 : zpos += kORIcuTh/2.0 + kORIcoTh/2.0;
2442 1 : TVirtualMC::GetMC()->Gspos("UOR3",1,"UORI",xpos,ypos,zpos,0,"ONLY");
2443 :
2444 : // Put the ORI board in the chamber services mother volume
2445 12 : for (istack = 0; istack < kNstack; istack++) {
2446 70 : for (ilayer = 0; ilayer < kNlayer; ilayer++) {
2447 30 : Int_t iDet = GetDetectorSec(ilayer,istack);
2448 30 : Int_t iCopy = iDet + 1;
2449 60 : xpos = fgkCwidth[ilayer]/2.0 - 1.92 * (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2450 30 : / ((Float_t) GetRowMax(ilayer,istack,0));
2451 : ypos = -16.0;
2452 : zpos = kORIz/2.0 - fgkCsvH/2.0;
2453 30 : snprintf(cTagV,kTag,"UU%02d",iDet);
2454 30 : TVirtualMC::GetMC()->Gspos("UORI",iCopy ,cTagV,xpos,ypos,zpos,0,"ONLY");
2455 60 : xpos = -fgkCwidth[ilayer]/2.0 + 3.8 * (GetChamberLength(ilayer,istack) - 2.0*fgkRpadW)
2456 30 : / ((Float_t) GetRowMax(ilayer,istack,0));
2457 : ypos = -16.0;
2458 : zpos = kORIz/2.0 - fgkCsvH/2.0;
2459 30 : snprintf(cTagV,kTag,"UU%02d",iDet);
2460 30 : TVirtualMC::GetMC()->Gspos("UORI",iCopy+kNdet,cTagV,xpos,ypos,zpos,0,"ONLY");
2461 : }
2462 : }
2463 :
2464 : //
2465 : // Services in front of the super module
2466 : //
2467 :
2468 : // Gas in-/outlet pipes (INOX)
2469 1 : parTube[0] = 0.0;
2470 1 : parTube[1] = 0.0;
2471 1 : parTube[2] = 0.0;
2472 1 : TVirtualMC::GetMC()->Gsvolu("UTG3","TUBE",idtmed[1308-1],parTube,0);
2473 : // The gas inside the in-/outlet pipes (Xe)
2474 1 : parTube[0] = 0.0;
2475 1 : parTube[1] = 1.2/2.0;
2476 1 : parTube[2] = -1.0;
2477 1 : TVirtualMC::GetMC()->Gsvolu("UTG4","TUBE",idtmed[1309-1],parTube,kNparTube);
2478 : xpos = 0.0;
2479 : ypos = 0.0;
2480 : zpos = 0.0;
2481 1 : TVirtualMC::GetMC()->Gspos("UTG4",1,"UTG3",xpos,ypos,zpos,0,"ONLY");
2482 12 : for (ilayer = 0; ilayer < kNlayer-1; ilayer++) {
2483 : xpos = 0.0;
2484 10 : ypos = fgkClength[ilayer][2]/2.0
2485 5 : + fgkClength[ilayer][1]
2486 5 : + fgkClength[ilayer][0];
2487 5 : zpos = 9.0 - fgkSheight/2.0
2488 5 : + ilayer * (fgkCH + fgkVspace);
2489 5 : parTube[0] = 0.0;
2490 5 : parTube[1] = 1.5/2.0;
2491 5 : parTube[2] = fgkCwidth[ilayer]/2.0 - 2.5;
2492 10 : TVirtualMC::GetMC()->Gsposp("UTG3",ilayer+1 ,"UTI1", xpos, ypos, zpos
2493 5 : ,matrix[2],"ONLY",parTube,kNparTube);
2494 10 : TVirtualMC::GetMC()->Gsposp("UTG3",ilayer+1+1*kNlayer,"UTI1", xpos,-ypos, zpos
2495 5 : ,matrix[2],"ONLY",parTube,kNparTube);
2496 10 : TVirtualMC::GetMC()->Gsposp("UTG3",ilayer+1+2*kNlayer,"UTI2", xpos, ypos, zpos
2497 5 : ,matrix[2],"ONLY",parTube,kNparTube);
2498 10 : TVirtualMC::GetMC()->Gsposp("UTG3",ilayer+1+3*kNlayer,"UTI2", xpos,-ypos, zpos
2499 5 : ,matrix[2],"ONLY",parTube,kNparTube);
2500 10 : TVirtualMC::GetMC()->Gsposp("UTG3",ilayer+1+4*kNlayer,"UTI3", xpos, ypos, zpos
2501 5 : ,matrix[2],"ONLY",parTube,kNparTube);
2502 10 : TVirtualMC::GetMC()->Gsposp("UTG3",ilayer+1+5*kNlayer,"UTI3", xpos,-ypos, zpos
2503 5 : ,matrix[2],"ONLY",parTube,kNparTube);
2504 10 : TVirtualMC::GetMC()->Gsposp("UTG3",ilayer+1+6*kNlayer,"UTI4", xpos, ypos, zpos
2505 5 : ,matrix[2],"ONLY",parTube,kNparTube);
2506 10 : TVirtualMC::GetMC()->Gsposp("UTG3",ilayer+1+7*kNlayer,"UTI4", xpos,-ypos, zpos
2507 5 : ,matrix[2],"ONLY",parTube,kNparTube);
2508 : }
2509 :
2510 : // Gas distribution box
2511 1 : parBox[0] = 14.50/2.0;
2512 1 : parBox[1] = 4.52/2.0;
2513 1 : parBox[2] = 5.00/2.0;
2514 1 : TVirtualMC::GetMC()->Gsvolu("UTGD","BOX ",idtmed[1308-1],parBox,kNparBox);
2515 1 : parBox[0] = 14.50/2.0;
2516 1 : parBox[1] = 4.00/2.0;
2517 1 : parBox[2] = 4.40/2.0;
2518 1 : TVirtualMC::GetMC()->Gsvolu("UTGI","BOX ",idtmed[1309-1],parBox,kNparBox);
2519 1 : parTube[0] = 0.0;
2520 1 : parTube[1] = 4.0/2.0;
2521 1 : parTube[2] = 8.0/2.0;
2522 1 : TVirtualMC::GetMC()->Gsvolu("UTGT","TUBE",idtmed[1308-1],parTube,kNparTube);
2523 1 : parTube[0] = 0.0;
2524 1 : parTube[1] = 3.4/2.0;
2525 1 : parTube[2] = 8.0/2.0;
2526 1 : TVirtualMC::GetMC()->Gsvolu("UTGG","TUBE",idtmed[1309-1],parTube,kNparTube);
2527 : xpos = 0.0;
2528 : ypos = 0.0;
2529 : zpos = 0.0;
2530 1 : TVirtualMC::GetMC()->Gspos("UTGI",1,"UTGD",xpos,ypos,zpos, 0,"ONLY");
2531 1 : TVirtualMC::GetMC()->Gspos("UTGG",1,"UTGT",xpos,ypos,zpos, 0,"ONLY");
2532 : xpos = 0.0;
2533 : ypos = 0.0;
2534 : zpos = 0.0;
2535 1 : TVirtualMC::GetMC()->Gspos("UTGD",1,"UTF1",xpos,ypos,zpos, 0,"ONLY");
2536 : xpos = -3.0;
2537 : ypos = 0.0;
2538 : zpos = 6.5;
2539 1 : TVirtualMC::GetMC()->Gspos("UTGT",1,"UTF1",xpos,ypos,zpos, 0,"ONLY");
2540 : xpos = -11.25;
2541 : ypos = 0.0;
2542 : zpos = 0.5;
2543 1 : TVirtualMC::GetMC()->Gspos("UTGT",3,"UTF1",xpos,ypos,zpos,matrix[2],"ONLY");
2544 : xpos = 11.25;
2545 : ypos = 0.0;
2546 : zpos = 0.5;
2547 1 : TVirtualMC::GetMC()->Gspos("UTGT",5,"UTF1",xpos,ypos,zpos,matrix[2],"ONLY");
2548 :
2549 : // Cooling manifolds
2550 1 : parBox[0] = 5.0/2.0;
2551 1 : parBox[1] = 23.0/2.0;
2552 1 : parBox[2] = 70.0/2.0;
2553 1 : TVirtualMC::GetMC()->Gsvolu("UTCM","BOX ",idtmed[1302-1],parBox,kNparBox);
2554 1 : parBox[0] = 5.0/2.0;
2555 1 : parBox[1] = 5.0/2.0;
2556 1 : parBox[2] = 70.0/2.0;
2557 1 : TVirtualMC::GetMC()->Gsvolu("UTCA","BOX ",idtmed[1308-1],parBox,kNparBox);
2558 1 : parBox[0] = 5.0/2.0 - 0.3;
2559 1 : parBox[1] = 5.0/2.0 - 0.3;
2560 1 : parBox[2] = 70.0/2.0 - 0.3;
2561 1 : TVirtualMC::GetMC()->Gsvolu("UTCW","BOX ",idtmed[1314-1],parBox,kNparBox);
2562 : xpos = 0.0;
2563 : ypos = 0.0;
2564 : zpos = 0.0;
2565 1 : TVirtualMC::GetMC()->Gspos("UTCW",1,"UTCA", xpos, ypos, zpos, 0,"ONLY");
2566 : xpos = 0.0;
2567 : ypos = 5.0/2.0 - 23.0/2.0;
2568 : zpos = 0.0;
2569 1 : TVirtualMC::GetMC()->Gspos("UTCA",1,"UTCM", xpos, ypos, zpos, 0,"ONLY");
2570 1 : parTube[0] = 0.0;
2571 1 : parTube[1] = 3.0/2.0;
2572 1 : parTube[2] = 18.0/2.0;
2573 1 : TVirtualMC::GetMC()->Gsvolu("UTCO","TUBE",idtmed[1308-1],parTube,kNparTube);
2574 1 : parTube[0] = 0.0;
2575 1 : parTube[1] = 3.0/2.0 - 0.3;
2576 1 : parTube[2] = 18.0/2.0;
2577 1 : TVirtualMC::GetMC()->Gsvolu("UTCL","TUBE",idtmed[1314-1],parTube,kNparTube);
2578 : xpos = 0.0;
2579 : ypos = 0.0;
2580 : zpos = 0.0;
2581 1 : TVirtualMC::GetMC()->Gspos("UTCL",1,"UTCO", xpos, ypos, zpos, 0,"ONLY");
2582 : xpos = 0.0;
2583 : ypos = 2.5;
2584 : zpos = -70.0/2.0 + 7.0;
2585 1 : TVirtualMC::GetMC()->Gspos("UTCO",1,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2586 : zpos += 7.0;
2587 1 : TVirtualMC::GetMC()->Gspos("UTCO",2,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2588 : zpos += 7.0;
2589 1 : TVirtualMC::GetMC()->Gspos("UTCO",3,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2590 : zpos += 7.0;
2591 1 : TVirtualMC::GetMC()->Gspos("UTCO",4,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2592 : zpos += 7.0;
2593 1 : TVirtualMC::GetMC()->Gspos("UTCO",5,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2594 : zpos += 7.0;
2595 1 : TVirtualMC::GetMC()->Gspos("UTCO",6,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2596 : zpos += 7.0;
2597 1 : TVirtualMC::GetMC()->Gspos("UTCO",7,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2598 : zpos += 7.0;
2599 1 : TVirtualMC::GetMC()->Gspos("UTCO",8,"UTCM", xpos, ypos, zpos,matrix[4],"ONLY");
2600 :
2601 : xpos = 40.0;
2602 : ypos = fgkFlength/2.0 - 23.0/2.0;
2603 : zpos = 0.0;
2604 1 : TVirtualMC::GetMC()->Gspos("UTCM",1,"UTF1", xpos, ypos, zpos,matrix[0],"ONLY");
2605 1 : TVirtualMC::GetMC()->Gspos("UTCM",2,"UTF1",-xpos, ypos, zpos,matrix[1],"ONLY");
2606 1 : TVirtualMC::GetMC()->Gspos("UTCM",3,"UTF2", xpos,-ypos, zpos,matrix[5],"ONLY");
2607 1 : TVirtualMC::GetMC()->Gspos("UTCM",4,"UTF2",-xpos,-ypos, zpos,matrix[6],"ONLY");
2608 :
2609 : // Power connection boards (Cu)
2610 1 : parBox[0] = 0.5/2.0;
2611 1 : parBox[1] = 15.0/2.0;
2612 1 : parBox[2] = 7.0/2.0;
2613 1 : TVirtualMC::GetMC()->Gsvolu("UTPC","BOX ",idtmed[1325-1],parBox,kNparBox);
2614 12 : for (ilayer = 0; ilayer < kNlayer-1; ilayer++) {
2615 5 : xpos = fgkCwidth[ilayer]/2.0 + kPWRwid/2.0;
2616 : ypos = 0.0;
2617 5 : zpos = fgkVrocsm + fgkSMpltT + kPWRhgtA/2.0 - fgkSheight/2.0 + kPWRposz
2618 5 : + (ilayer+1) * (fgkCH + fgkVspace);
2619 5 : TVirtualMC::GetMC()->Gspos("UTPC",ilayer ,"UTF1", xpos,ypos,zpos,matrix[0],"ONLY");
2620 5 : TVirtualMC::GetMC()->Gspos("UTPC",ilayer+kNlayer,"UTF1",-xpos,ypos,zpos,matrix[1],"ONLY");
2621 : }
2622 1 : xpos = fgkCwidth[5]/2.0 + kPWRhgtA/2.0 - 2.0;
2623 : ypos = 0.0;
2624 : zpos = fgkSheight/2.0 - fgkSMpltT - 2.0;
2625 1 : TVirtualMC::GetMC()->Gspos("UTPC",5 ,"UTF1", xpos,ypos,zpos,matrix[3],"ONLY");
2626 1 : TVirtualMC::GetMC()->Gspos("UTPC",5+kNlayer,"UTF1",-xpos,ypos,zpos,matrix[3],"ONLY");
2627 :
2628 : // Power connection panel (Al)
2629 1 : parBox[0] = 60.0/2.0;
2630 1 : parBox[1] = 10.0/2.0;
2631 1 : parBox[2] = 3.0/2.0;
2632 1 : TVirtualMC::GetMC()->Gsvolu("UTPP","BOX ",idtmed[1301-1],parBox,kNparBox);
2633 : xpos = 0.0;
2634 : ypos = 0.0;
2635 : zpos = 18.0;
2636 1 : TVirtualMC::GetMC()->Gspos("UTPP",1,"UTF1", xpos,ypos,zpos,0,"ONLY");
2637 :
2638 : //
2639 : // Electronics boxes
2640 : //
2641 :
2642 : // Casing (INOX)
2643 1 : parBox[0] = 60.0/2.0;
2644 1 : parBox[1] = 10.0/2.0;
2645 1 : parBox[2] = 6.0/2.0;
2646 1 : TVirtualMC::GetMC()->Gsvolu("UTE1","BOX ",idtmed[1308-1],parBox,kNparBox);
2647 : // Interior (air)
2648 1 : parBox[0] = parBox[0] - 0.5;
2649 1 : parBox[1] = parBox[1] - 0.5;
2650 1 : parBox[2] = parBox[2] - 0.5;
2651 1 : TVirtualMC::GetMC()->Gsvolu("UTE2","BOX ",idtmed[1302-1],parBox,kNparBox);
2652 : xpos = 0.0;
2653 : ypos = 0.0;
2654 : zpos = 0.0;
2655 1 : TVirtualMC::GetMC()->Gspos("UTE2",1,"UTE1",xpos,ypos,zpos,0,"ONLY");
2656 : xpos = 0.0;
2657 : ypos = fgkSlength/2.0 - 10.0/2.0 - 3.0;
2658 : zpos = -fgkSheight/2.0 + 6.0/2.0 + 1.0;
2659 1 : TVirtualMC::GetMC()->Gspos("UTE1",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2660 1 : TVirtualMC::GetMC()->Gspos("UTE1",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2661 1 : TVirtualMC::GetMC()->Gspos("UTE1",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2662 1 : TVirtualMC::GetMC()->Gspos("UTE1",4,"UTI4", xpos,ypos,zpos,0,"ONLY");
2663 :
2664 : // Casing (INOX)
2665 1 : parBox[0] = 50.0/2.0;
2666 1 : parBox[1] = 15.0/2.0;
2667 1 : parBox[2] = 20.0/2.0;
2668 1 : TVirtualMC::GetMC()->Gsvolu("UTE3","BOX ",idtmed[1308-1],parBox,kNparBox);
2669 : // Interior (air)
2670 1 : parBox[0] = parBox[0] - 0.5;
2671 1 : parBox[1] = parBox[1] - 0.5;
2672 1 : parBox[2] = parBox[2] - 0.5;
2673 1 : TVirtualMC::GetMC()->Gsvolu("UTE4","BOX ",idtmed[1302-1],parBox,kNparBox);
2674 : xpos = 0.0;
2675 : ypos = 0.0;
2676 : zpos = 0.0;
2677 1 : TVirtualMC::GetMC()->Gspos("UTE4",1,"UTE3",xpos,ypos,zpos,0,"ONLY");
2678 : xpos = 0.0;
2679 : ypos = -fgkSlength/2.0 + 15.0/2.0 + 3.0;
2680 : zpos = -fgkSheight/2.0 + 20.0/2.0 + 1.0;
2681 1 : TVirtualMC::GetMC()->Gspos("UTE3",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2682 1 : TVirtualMC::GetMC()->Gspos("UTE3",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2683 1 : TVirtualMC::GetMC()->Gspos("UTE3",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2684 1 : TVirtualMC::GetMC()->Gspos("UTE3",4,"UTI4", xpos,ypos,zpos,0,"ONLY");
2685 :
2686 : // Casing (INOX)
2687 1 : parBox[0] = 20.0/2.0;
2688 1 : parBox[1] = 7.0/2.0;
2689 1 : parBox[2] = 20.0/2.0;
2690 1 : TVirtualMC::GetMC()->Gsvolu("UTE5","BOX ",idtmed[1308-1],parBox,kNparBox);
2691 : // Interior (air)
2692 1 : parBox[0] = parBox[0] - 0.5;
2693 1 : parBox[1] = parBox[1] - 0.5;
2694 1 : parBox[2] = parBox[2] - 0.5;
2695 1 : TVirtualMC::GetMC()->Gsvolu("UTE6","BOX ",idtmed[1302-1],parBox,kNparBox);
2696 : xpos = 0.0;
2697 : ypos = 0.0;
2698 : zpos = 0.0;
2699 1 : TVirtualMC::GetMC()->Gspos("UTE6",1,"UTE5",xpos,ypos,zpos,0,"ONLY");
2700 : xpos = 20.0;
2701 : ypos = -fgkSlength/2.0 + 7.0/2.0 + 3.0;
2702 : zpos = 0.0;
2703 1 : TVirtualMC::GetMC()->Gspos("UTE5",1,"UTI1", xpos,ypos,zpos,0,"ONLY");
2704 1 : TVirtualMC::GetMC()->Gspos("UTE5",2,"UTI2", xpos,ypos,zpos,0,"ONLY");
2705 1 : TVirtualMC::GetMC()->Gspos("UTE5",3,"UTI3", xpos,ypos,zpos,0,"ONLY");
2706 1 : TVirtualMC::GetMC()->Gspos("UTE5",4,"UTI4", xpos,ypos,zpos,0,"ONLY");
2707 : xpos = -xpos;
2708 1 : TVirtualMC::GetMC()->Gspos("UTE5",5,"UTI1", xpos,ypos,zpos,0,"ONLY");
2709 1 : TVirtualMC::GetMC()->Gspos("UTE5",6,"UTI2", xpos,ypos,zpos,0,"ONLY");
2710 1 : TVirtualMC::GetMC()->Gspos("UTE5",7,"UTI3", xpos,ypos,zpos,0,"ONLY");
2711 1 : TVirtualMC::GetMC()->Gspos("UTE5",8,"UTI4", xpos,ypos,zpos,0,"ONLY");
2712 :
2713 1 : }
2714 :
2715 : //_____________________________________________________________________________
2716 : void AliTRDgeometry::AssembleChamber(Int_t ilayer, Int_t istack)
2717 : {
2718 : //
2719 : // Group volumes UA, UD, UF, UU into an assembly that defines the
2720 : // alignable volume of a single readout chamber
2721 : //
2722 :
2723 : const Int_t kTag = 100;
2724 60 : Char_t cTagV[kTag];
2725 30 : Char_t cTagM[kTag];
2726 :
2727 : Double_t xpos = 0.0;
2728 : Double_t ypos = 0.0;
2729 : Double_t zpos = 0.0;
2730 :
2731 30 : Int_t idet = GetDetectorSec(ilayer,istack);
2732 :
2733 : // Create the assembly for a given ROC
2734 30 : snprintf(cTagM,kTag,"UT%02d",idet);
2735 60 : TGeoVolume *roc = new TGeoVolumeAssembly(cTagM);
2736 :
2737 : // Add the lower part of the chamber (aluminum frame),
2738 : // including radiator and drift region
2739 : xpos = 0.0;
2740 : ypos = 0.0;
2741 : zpos = fgkCraH/2.0 + fgkCdrH/2.0 - fgkCHsv/2.0;
2742 30 : snprintf(cTagV,kTag,"UA%02d",idet);
2743 30 : TGeoVolume *rocA = gGeoManager->GetVolume(cTagV);
2744 60 : roc->AddNode(rocA,1,new TGeoTranslation(xpos,ypos,zpos));
2745 :
2746 : // Add the additional aluminum ledges
2747 30 : xpos = fgkCwidth[ilayer]/2.0 + fgkCalWmod/2.0;
2748 : ypos = 0.0;
2749 : zpos = fgkCraH + fgkCdrH - fgkCalZpos - fgkCalHmod/2.0 - fgkCHsv/2.0;
2750 30 : snprintf(cTagV,kTag,"UZ%02d",idet);
2751 30 : TGeoVolume *rocZ = gGeoManager->GetVolume(cTagV);
2752 60 : roc->AddNode(rocZ,1,new TGeoTranslation( xpos,ypos,zpos));
2753 60 : roc->AddNode(rocZ,2,new TGeoTranslation(-xpos,ypos,zpos));
2754 :
2755 : // Add the additional wacosit ledges
2756 30 : xpos = fgkCwidth[ilayer]/2.0 + fgkCwsW/2.0;
2757 : ypos = 0.0;
2758 : zpos = fgkCraH + fgkCdrH - fgkCwsH/2.0 - fgkCHsv/2.0;
2759 30 : snprintf(cTagV,kTag,"UP%02d",idet);
2760 30 : TGeoVolume *rocP = gGeoManager->GetVolume(cTagV);
2761 60 : roc->AddNode(rocP,1,new TGeoTranslation( xpos,ypos,zpos));
2762 60 : roc->AddNode(rocP,2,new TGeoTranslation(-xpos,ypos,zpos));
2763 :
2764 : // Add the middle part of the chamber (G10 frame),
2765 : // including amplification region
2766 : xpos = 0.0;
2767 : ypos = 0.0;
2768 : zpos = fgkCamH/2.0 + fgkCraH + fgkCdrH - fgkCHsv/2.0;
2769 30 : snprintf(cTagV,kTag,"UD%02d",idet);
2770 30 : TGeoVolume *rocD = gGeoManager->GetVolume(cTagV);
2771 60 : roc->AddNode(rocD,1,new TGeoTranslation(xpos,ypos,zpos));
2772 :
2773 : // Add the upper part of the chamber (aluminum frame),
2774 : // including back panel and FEE
2775 : xpos = 0.0;
2776 : ypos = 0.0;
2777 : zpos = fgkCroH/2.0 + fgkCamH + fgkCraH + fgkCdrH - fgkCHsv/2.0;
2778 30 : snprintf(cTagV,kTag,"UF%02d",idet);
2779 30 : TGeoVolume *rocF = gGeoManager->GetVolume(cTagV);
2780 60 : roc->AddNode(rocF,1,new TGeoTranslation(xpos,ypos,zpos));
2781 :
2782 : // Add the volume with services on top of the back panel
2783 : xpos = 0.0;
2784 : ypos = 0.0;
2785 : zpos = fgkCsvH/2.0 + fgkCroH + fgkCamH + fgkCraH + fgkCdrH - fgkCHsv/2.0;
2786 30 : snprintf(cTagV,kTag,"UU%02d",idet);
2787 30 : TGeoVolume *rocU = gGeoManager->GetVolume(cTagV);
2788 60 : roc->AddNode(rocU,1,new TGeoTranslation(xpos,ypos,zpos));
2789 :
2790 : // Place the ROC assembly into the super modules
2791 : xpos = 0.0;
2792 : ypos = 0.0;
2793 30 : ypos = fgkClength[ilayer][0] + fgkClength[ilayer][1] + fgkClength[ilayer][2]/2.0;
2794 180 : for (Int_t ic = 0; ic < istack; ic++) {
2795 60 : ypos -= fgkClength[ilayer][ic];
2796 : }
2797 30 : ypos -= fgkClength[ilayer][istack]/2.0;
2798 : zpos = fgkVrocsm + fgkSMpltT + fgkCHsv/2.0 - fgkSheight/2.0
2799 30 : + ilayer * (fgkCH + fgkVspace);
2800 30 : TGeoVolume *sm1 = gGeoManager->GetVolume("UTI1");
2801 30 : TGeoVolume *sm2 = gGeoManager->GetVolume("UTI2");
2802 30 : TGeoVolume *sm3 = gGeoManager->GetVolume("UTI3");
2803 30 : TGeoVolume *sm4 = gGeoManager->GetVolume("UTI4");
2804 60 : sm1->AddNode(roc,1,new TGeoTranslation(xpos,ypos,zpos));
2805 60 : sm2->AddNode(roc,1,new TGeoTranslation(xpos,ypos,zpos));
2806 30 : if (istack != 2) {
2807 : // w/o middle stack
2808 48 : sm3->AddNode(roc,1,new TGeoTranslation(xpos,ypos,zpos));
2809 24 : }
2810 30 : if (!((ilayer == 4) && (istack == 4))) {
2811 : // Sector 17 w/o L4S4 chamber
2812 58 : sm4->AddNode(roc,1,new TGeoTranslation(xpos,ypos,zpos));
2813 29 : }
2814 :
2815 30 : }
2816 :
2817 : //_____________________________________________________________________________
2818 : Bool_t AliTRDgeometry::RotateBack(Int_t det
2819 : , const Double_t * const loc
2820 : , Double_t *glb) const
2821 : {
2822 : //
2823 : // Rotates a chambers to transform the corresponding local frame
2824 : // coordinates <loc> into the coordinates of the ALICE restframe <glb>.
2825 : //
2826 :
2827 1982 : Int_t sector = GetSector(det);
2828 991 : Float_t phi = 2.0 * TMath::Pi() / (Float_t) fgkNsector * ((Float_t) sector + 0.5);
2829 :
2830 991 : glb[0] = loc[0] * TMath::Cos(phi) - loc[1] * TMath::Sin(phi);
2831 991 : glb[1] = loc[0] * TMath::Sin(phi) + loc[1] * TMath::Cos(phi);
2832 991 : glb[2] = loc[2];
2833 :
2834 991 : return kTRUE;
2835 :
2836 : }
2837 :
2838 : //_____________________________________________________________________________
2839 : Int_t AliTRDgeometry::GetDetectorSec(Int_t layer, Int_t stack)
2840 : {
2841 : //
2842 : // Convert plane / stack into detector number for one single sector
2843 : //
2844 :
2845 47192 : return (layer + stack * fgkNlayer);
2846 :
2847 : }
2848 :
2849 : //_____________________________________________________________________________
2850 : Int_t AliTRDgeometry::GetDetector(Int_t layer, Int_t stack, Int_t sector)
2851 : {
2852 : //
2853 : // Convert layer / stack / sector into detector number
2854 : //
2855 :
2856 80400 : return (layer + stack * fgkNlayer + sector * fgkNlayer * fgkNstack);
2857 :
2858 : }
2859 :
2860 : //_____________________________________________________________________________
2861 : Int_t AliTRDgeometry::GetLayer(Int_t det)
2862 : {
2863 : //
2864 : // Reconstruct the layer number from the detector number
2865 : //
2866 :
2867 202594 : return ((Int_t) (det % fgkNlayer));
2868 :
2869 : }
2870 :
2871 : //_____________________________________________________________________________
2872 : Int_t AliTRDgeometry::GetStack(Int_t det)
2873 : {
2874 : //
2875 : // Reconstruct the stack number from the detector number
2876 : //
2877 :
2878 5195334 : return ((Int_t) (det % (fgkNlayer * fgkNstack)) / fgkNlayer);
2879 :
2880 : }
2881 :
2882 : //_____________________________________________________________________________
2883 : Int_t AliTRDgeometry::GetStack(Double_t z, Int_t layer)
2884 : {
2885 : //
2886 : // Reconstruct the chamber number from the z position and layer number
2887 : //
2888 : // The return function has to be protected for positiveness !!
2889 : //
2890 :
2891 3264 : if ((layer < 0) ||
2892 1088 : (layer >= fgkNlayer)) return -1;
2893 :
2894 : Int_t istck = fgkNstack;
2895 : Double_t zmin = 0.0;
2896 : Double_t zmax = 0.0;
2897 :
2898 1088 : do {
2899 3336 : istck--;
2900 3336 : if (istck < 0) break;
2901 3336 : AliTRDpadPlane *pp = GetPadPlane(layer,istck);
2902 3336 : zmax = pp->GetRow0();
2903 3336 : Int_t nrows = pp->GetNrows();
2904 3336 : zmin = zmax - 2 * pp->GetLengthOPad()
2905 3336 : - (nrows-2) * pp->GetLengthIPad()
2906 3336 : - (nrows-1) * pp->GetRowSpacing();
2907 6672 : } while((z < zmin) || (z > zmax));
2908 :
2909 : return istck;
2910 :
2911 1088 : }
2912 :
2913 : //_____________________________________________________________________________
2914 : Int_t AliTRDgeometry::GetSector(Int_t det)
2915 : {
2916 : //
2917 : // Reconstruct the sector number from the detector number
2918 : //
2919 :
2920 72596 : return ((Int_t) (det / (fgkNlayer * fgkNstack)));
2921 :
2922 : }
2923 :
2924 : //_____________________________________________________________________________
2925 : AliTRDpadPlane *AliTRDgeometry::GetPadPlane(Int_t layer, Int_t stack)
2926 : {
2927 : //
2928 : // Returns the pad plane for a given plane <pl> and stack <st> number
2929 : //
2930 :
2931 45188 : if (!fgPadPlaneArray) {
2932 3 : CreatePadPlaneArray();
2933 3 : }
2934 :
2935 22594 : Int_t ipp = GetDetectorSec(layer,stack);
2936 22594 : return ((AliTRDpadPlane *) fgPadPlaneArray->At(ipp));
2937 :
2938 : }
2939 :
2940 : //_____________________________________________________________________________
2941 : Int_t AliTRDgeometry::GetRowMax(Int_t layer, Int_t stack, Int_t /*sector*/)
2942 : {
2943 : //
2944 : // Returns the number of rows on the pad plane
2945 : //
2946 :
2947 30540 : return GetPadPlane(layer,stack)->GetNrows();
2948 :
2949 : }
2950 :
2951 : //_____________________________________________________________________________
2952 : Int_t AliTRDgeometry::GetColMax(Int_t layer)
2953 : {
2954 : //
2955 : // Returns the number of rows on the pad plane
2956 : //
2957 :
2958 0 : return GetPadPlane(layer,0)->GetNcols();
2959 :
2960 : }
2961 :
2962 : //_____________________________________________________________________________
2963 : Double_t AliTRDgeometry::GetRow0(Int_t layer, Int_t stack, Int_t /*sector*/)
2964 : {
2965 : //
2966 : // Returns the position of the border of the first pad in a row
2967 : //
2968 :
2969 698 : return GetPadPlane(layer,stack)->GetRow0();
2970 :
2971 : }
2972 :
2973 : //_____________________________________________________________________________
2974 : Double_t AliTRDgeometry::GetCol0(Int_t layer)
2975 : {
2976 : //
2977 : // Returns the position of the border of the first pad in a column
2978 : //
2979 :
2980 0 : return GetPadPlane(layer,0)->GetCol0();
2981 :
2982 : }
2983 :
2984 : //_____________________________________________________________________________
2985 : Bool_t AliTRDgeometry::CreateClusterMatrixArray()
2986 : {
2987 : //
2988 : // Create the matrices to transform cluster coordinates from the
2989 : // local chamber system to the tracking coordinate system
2990 : //
2991 :
2992 3490 : if (!gGeoManager) {
2993 0 : return kFALSE;
2994 : }
2995 :
2996 1745 : if(fgClusterMatrixArray)
2997 1742 : return kTRUE;
2998 :
2999 3 : TString volPath;
3000 3 : TString vpStr = "ALIC_1/B077_1/BSEGMO";
3001 3 : TString vpApp1 = "_1/BTRD";
3002 3 : TString vpApp2 = "_1";
3003 3 : TString vpApp3a = "/UTR1_1/UTS1_1/UTI1_1";
3004 3 : TString vpApp3b = "/UTR2_1/UTS2_1/UTI2_1";
3005 3 : TString vpApp3c = "/UTR3_1/UTS3_1/UTI3_1";
3006 3 : TString vpApp3d = "/UTR4_1/UTS4_1/UTI4_1";
3007 :
3008 9 : fgClusterMatrixArray = new TObjArray(kNdet);
3009 3 : AliAlignObjParams o;
3010 :
3011 42 : for (Int_t iLayer = AliGeomManager::kTRD1; iLayer <= AliGeomManager::kTRD6; iLayer++) {
3012 4914 : for (Int_t iModule = 0; iModule < AliGeomManager::LayerSize(iLayer); iModule++) {
3013 :
3014 1620 : Int_t isector = iModule/Nstack();
3015 1620 : Int_t istack = iModule%Nstack();
3016 1620 : Int_t iLayerTRD = iLayer - AliGeomManager::kTRD1;
3017 1620 : Int_t lid = GetDetector(iLayerTRD,istack,isector);
3018 :
3019 : // Check for disabled supermodules
3020 1620 : volPath = vpStr;
3021 1620 : volPath += isector;
3022 1620 : volPath += vpApp1;
3023 1620 : volPath += isector;
3024 1620 : volPath += vpApp2;
3025 1620 : switch (isector) {
3026 : case 17:
3027 90 : if ((istack == 4) && (iLayerTRD == 4)) {
3028 3 : continue;
3029 : }
3030 87 : volPath += vpApp3d;
3031 : break;
3032 : case 13:
3033 : case 14:
3034 : case 15:
3035 : // Check for holes in from of PHOS
3036 270 : if (istack == 2) {
3037 54 : continue;
3038 : }
3039 216 : volPath += vpApp3c;
3040 : break;
3041 : case 11:
3042 : case 12:
3043 180 : volPath += vpApp3b;
3044 : break;
3045 : default:
3046 1080 : volPath += vpApp3a;
3047 : };
3048 4689 : if (!gGeoManager->CheckPath(volPath)) {
3049 : //AliInfo(Form("Path not found in geometry: %s",volPath.Data()));
3050 653 : continue;
3051 : }
3052 :
3053 910 : UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iModule);
3054 910 : const char *symname = AliGeomManager::SymName(volid);
3055 910 : TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
3056 : const char *path = symname;
3057 910 : if (pne) {
3058 910 : path = pne->GetTitle();
3059 : }
3060 : else {
3061 0 : continue;
3062 : }
3063 1820 : if (!strstr(path,"ALIC")) {
3064 0 : AliDebugClass(1,Form("Not a valid path: %s\n",path));
3065 0 : continue;
3066 : }
3067 1820 : if (!gGeoManager->cd(path)) {
3068 0 : AliErrorClass(Form("Cannot go to path: %s\n",path));
3069 0 : continue;
3070 : }
3071 910 : TGeoHMatrix *m = gGeoManager->GetCurrentMatrix();
3072 :
3073 910 : TGeoRotation mchange;
3074 910 : mchange.RotateY(90);
3075 910 : mchange.RotateX(90);
3076 :
3077 : //
3078 : // Cluster transformation matrix
3079 : //
3080 1820 : TGeoHMatrix rotMatrix(mchange.Inverse());
3081 910 : rotMatrix.MultiplyLeft(m);
3082 910 : Double_t sectorAngle = 20.0 * (isector % 18) + 10.0;
3083 910 : TGeoHMatrix rotSector;
3084 910 : rotSector.RotateZ(sectorAngle);
3085 1820 : rotMatrix.MultiplyLeft(&rotSector.Inverse());
3086 :
3087 2730 : fgClusterMatrixArray->AddAt(new TGeoHMatrix(rotMatrix),lid);
3088 :
3089 910 : }
3090 : }
3091 :
3092 : return kTRUE;
3093 :
3094 1748 : }
3095 :
3096 : //_____________________________________________________________________________
3097 : TGeoHMatrix *AliTRDgeometry::GetClusterMatrix(Int_t det)
3098 : {
3099 : //
3100 : // Returns the cluster transformation matrix for a given detector
3101 : //
3102 :
3103 6954 : if (!fgClusterMatrixArray) {
3104 1 : if (!CreateClusterMatrixArray()) {
3105 0 : return NULL;
3106 : }
3107 : }
3108 3477 : return (TGeoHMatrix *) fgClusterMatrixArray->At(det);
3109 :
3110 3477 : }
3111 :
3112 : //_____________________________________________________________________________
3113 : Bool_t AliTRDgeometry::ChamberInGeometry(Int_t det)
3114 : {
3115 : //
3116 : // Checks whether the given detector is part of the current geometry
3117 : //
3118 :
3119 4320 : if (!GetClusterMatrix(det)) {
3120 1324 : return kFALSE;
3121 : }
3122 : else {
3123 836 : return kTRUE;
3124 : }
3125 :
3126 2160 : }
3127 :
3128 : //_____________________________________________________________________________
3129 : Bool_t AliTRDgeometry::IsHole(Int_t /*la*/, Int_t st, Int_t se) const
3130 : {
3131 : //
3132 : // Checks for holes in front of PHOS
3133 : //
3134 :
3135 1878 : if (((se == 13) || (se == 14) || (se == 15)) &&
3136 626 : (st == 2)) {
3137 24 : return kTRUE;
3138 : }
3139 :
3140 602 : return kFALSE;
3141 :
3142 626 : }
3143 :
3144 : //_____________________________________________________________________________
3145 : Bool_t AliTRDgeometry::IsOnBoundary(Int_t det, Float_t y, Float_t z, Float_t eps) const
3146 : {
3147 : //
3148 : // Checks whether position is at the boundary of the sensitive volume
3149 : //
3150 :
3151 924 : Int_t ly = GetLayer(det);
3152 924 : if ((ly < 0) ||
3153 462 : (ly >= fgkNlayer)) return kTRUE;
3154 :
3155 462 : Int_t stk = GetStack(det);
3156 924 : if ((stk < 0) ||
3157 462 : (stk >= fgkNstack)) return kTRUE;
3158 :
3159 462 : AliTRDpadPlane *pp = (AliTRDpadPlane*) fgPadPlaneArray->At(GetDetectorSec(ly, stk));
3160 462 : if(!pp) return kTRUE;
3161 :
3162 462 : Double_t max = pp->GetRow0();
3163 462 : Int_t n = pp->GetNrows();
3164 462 : Double_t min = max - 2 * pp->GetLengthOPad()
3165 462 : - (n-2) * pp->GetLengthIPad()
3166 462 : - (n-1) * pp->GetRowSpacing();
3167 924 : if(z < min+eps || z > max-eps){
3168 : //printf("z : min[%7.2f (%7.2f)] %7.2f max[(%7.2f) %7.2f]\n", min, min+eps, z, max-eps, max);
3169 0 : return kTRUE;
3170 : }
3171 462 : min = pp->GetCol0();
3172 462 : n = pp->GetNcols();
3173 462 : max = min +2 * pp->GetWidthOPad()
3174 462 : + (n-2) * pp->GetWidthIPad()
3175 462 : + (n-1) * pp->GetColSpacing();
3176 894 : if(y < min+eps || y > max-eps){
3177 : //printf("y : min[%7.2f (%7.2f)] %7.2f max[(%7.2f) %7.2f]\n", min, min+eps, y, max-eps, max);
3178 60 : return kTRUE;
3179 : }
3180 :
3181 402 : return kFALSE;
3182 :
3183 462 : }
|
