]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSv11GeometrySupport.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Extrusions of thermal shield on SPD cone removed (M.Sitta)
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySupport.cxx
CommitLineData
172b0d90 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
cee918ed 16// This class Defines the Geometry for the ITS services and support cones
17// outside of the ceneteral volume (except for the Ceneteral support
18// cylinders. Other classes define the rest of the ITS. Specificaly the ITS
19// The SSD support cone,SSD Support centeral cylinder, SDD support cone,
20// The SDD cupport centeral cylinder, the SPD Thermal Sheald, The supports
21// and cable trays on both the RB26 (muon dump) and RB24 sides, and all of
22// the cabling from the ladders/stave ends out past the TPC.
23
172b0d90 24/* $Id$ */
172b0d90 25// General Root includes
172b0d90 26#include <TMath.h>
172b0d90 27// Root Geometry includes
543b7370 28//#include <AliLog.h>
172b0d90 29#include <TGeoManager.h>
30#include <TGeoVolume.h>
31#include <TGeoPcon.h>
32#include <TGeoCone.h>
33#include <TGeoTube.h> // contaings TGeoTubeSeg
34#include <TGeoArb8.h>
db486a6e 35#include <TGeoXtru.h>
172b0d90 36#include <TGeoCompositeShape.h>
37#include <TGeoMatrix.h>
172b0d90 38#include "AliITSv11GeometrySupport.h"
39
40ClassImp(AliITSv11GeometrySupport)
41
42#define SQ(A) (A)*(A)
43
44//______________________________________________________________________
43aefea7 45void AliITSv11GeometrySupport::SPDCone(TGeoVolume *moth,const TGeoManager *mgr)
a275e8ba 46{
47//
48// Creates the SPD thermal shield as a volume assembly
49// and adds it to the mother volume
50// (this is actually a merge of the previous SPDThermalSheald method
51// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06 and the
52// CreateSPDThermalShield method of AliITSv11Hybrid)
53//
54// Input:
55// moth : the TGeoVolume owing the volume structure
56// mgr : the GeoManager (default gGeoManager)
57// Output:
58//
59// Created: ??? ???
60// Updated: 11 Dec 2007 Mario Sitta
6f88a698 61// Updated: 20 Mar 2011 Mario Sitta Reimplemented with simpler shapes
a275e8ba 62//
63// Technical data are taken from: ALICE-Thermal Screen "Cone transition"
64// (thermal-screen1_a3.ps), "Cylinder" (thermal-screen2_a3.ps), "Half
65// assembly" (thermal-screen3_a3.ps), "Flange" (thermal-screen4_a3.ps)
66
67
68 // Dimensions of the Central shield
0801d201 69 const Double_t kHalfLengthCentral = 399.9*fgkmm;
a275e8ba 70 const Double_t kThicknessCentral = 0.4*fgkmm;
71 const Double_t kInnerRadiusCentral = 8.1475*fgkcm;
72 const Double_t kOuterRadiusCentral = 9.9255*fgkcm;
73 const Double_t kInnerACentral = 3.1674*fgkcm;
74 const Double_t kInnerBCentral = 2.023 *fgkcm;
75 const Double_t kOuterACentral = 2.4374*fgkcm;
76 const Double_t kOuterBCentral = 3.8162*fgkcm;
77 // Dimensions of the EndCap shield
78 const Double_t kHalfLengthEndCap = 25.*fgkmm;
79 const Double_t kThicknessEndCap = 2.0*fgkmm;
80 const Double_t kInnerRadiusEndCap = 8.0775*fgkcm;
81 const Double_t kOuterRadiusEndCap = 9.9955*fgkcm;
82 const Double_t kInnerAEndCap = 3.1453*fgkcm;
83 const Double_t kInnerBEndCap = 2.0009*fgkcm;
84 const Double_t kOuterAEndCap = 2.4596*fgkcm;
85 const Double_t kOuterBEndCap = 3.8384*fgkcm;
86 // Dimensions of the Cone shield
87 const Double_t kHalfLengthCone = 145.*fgkmm;
88 const Double_t kThicknessCone = 0.3*fgkmm;
89 const Double_t kInnerRadialCone = 37.3*fgkcm;
90 const Double_t kOuterRadialCone = 39.0*fgkcm;
91 const Double_t kInnerACone = 14.2344*fgkcm;
c573c6ec 92 const Double_t kInnerBCone = 9.0915*fgkcm;
a275e8ba 93 const Double_t kOuterACone = 9.5058*fgkcm;
c573c6ec 94 const Double_t kOuterBCone = 14.8831*fgkcm;
a275e8ba 95 // Dimensions of the Flange's Ring and Wing
96 const Double_t kHalfLengthRing = 7.5*fgkmm;
97 const Double_t kThicknessRing = 0.3*fgkmm;
98 const Double_t kInnerRadiusRing = 37.3*fgkcm;
99 const Double_t kOuterRadiusRing = 42.0*fgkcm;
100 const Double_t kOuterRadiusWing = 49.25*fgkcm;
ca86fdb4 101 const Double_t kWideWing = 6.0*fgkcm;
0b9c8a10 102 const Double_t kThetaWing = 45.0;
a275e8ba 103 // Common data
104 const Double_t kTheta = 36.0*TMath::DegToRad();
105 const Double_t kThicknessOmega = 0.3*fgkmm;
106
107 // Local variables
0801d201 108 Double_t zpos;
a275e8ba 109 Double_t xshld[24], yshld[24];
c573c6ec 110 Double_t xair[24] , yair[24]; // Coord. of whole air shape
111 Double_t xair1[4] , yair1[4]; // Coord. of every single air volume
a275e8ba 112 Double_t xomega[48], yomega[48];
113 // Double_t *xyarb8;
114
115 // The entire shield is made up of two half central shields
116 // symmetric with respect to the XZ plane, four half end cap
117 // shields, again symmetric with respect to the XZ plane, and four
118 // half cones, symmetric with respect to the XZ plane too.
119
120 TGeoVolumeAssembly *vM = new TGeoVolumeAssembly("ITSspdThermalShield");
121
122 // The central half shield: a half tube of carbon fiber,
c573c6ec 123 // filled with air volumes, which together make the whole shield
124 // (i.e. the tube and the Omega-shaped insert).
a275e8ba 125 // They are all XTru shapes
126
127 TGeoXtru *centralshape = new TGeoXtru(2);
128
129 CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
130 kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
131 kTheta,xshld,yshld);
132
133 centralshape->DefinePolygon(24,xshld,yshld);
134 centralshape->DefineSection(0,-kHalfLengthCentral);
135 centralshape->DefineSection(1, kHalfLengthCentral);
136
137 // Now rescale to get the air volume dimensions
138 InsidePoint(xshld[23], yshld[23],
139 xshld[ 0], yshld[ 0],
140 xshld[ 1], yshld[ 1], kThicknessCentral,
141 xair[0], yair[0]);
142 for (Int_t i=1; i<23; i++) {
143 InsidePoint(xshld[i-1], yshld[i-1],
144 xshld[ i ], yshld[ i ],
145 xshld[i+1], yshld[i+1], kThicknessCentral,
146 xair[i], yair[i]);
147 }
148 InsidePoint(xshld[22], yshld[22],
149 xshld[23], yshld[23],
150 xshld[ 0], yshld[ 0], kThicknessCentral,
151 xair[23], yair[23]);
152
c573c6ec 153 // Then use them to determine the Omega shape points
154 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
a275e8ba 155
c573c6ec 156 // Finally create the single air volumes
157 TGeoXtru *centralair1shape = new TGeoXtru(2);
158
159 xair1[0] = xomega[1];
160 yair1[0] = yomega[1];
161 xair1[1] = xomega[0];
162 yair1[1] = yomega[0];
163 xair1[2] = -xair1[1];
164 yair1[2] = yair1[1];
165 xair1[3] = -xair1[0];
166 yair1[3] = yair1[0];
167
168 centralair1shape->DefinePolygon(4,xair1,yair1);
169 centralair1shape->DefineSection(0,-kHalfLengthCentral);
170 centralair1shape->DefineSection(1, kHalfLengthCentral);
171
172 TGeoXtru *centralair2shape = new TGeoXtru(2);
173
174 xair1[0] = xomega[21];
175 yair1[0] = yomega[21];
176 xair1[1] = xomega[20];
177 yair1[1] = yomega[20];
178 xair1[2] = xomega[23];
179 yair1[2] = yomega[23];
180 xair1[3] = xomega[22];
181 yair1[3] = yomega[22];
182
183 centralair2shape->DefinePolygon(4,xair1,yair1);
184 centralair2shape->DefineSection(0,-kHalfLengthCentral);
185 centralair2shape->DefineSection(1, kHalfLengthCentral);
186
187 TGeoXtru *centralair3shape = new TGeoXtru(2);
188
189 xair1[0] = xomega[2];
190 yair1[0] = yomega[2];
191 xair1[1] = xomega[3];
192 yair1[1] = yomega[3];
193 xair1[2] = xomega[4];
194 yair1[2] = yomega[4];
195 xair1[3] = xomega[5];
196 yair1[3] = yomega[5];
197
198 centralair3shape->DefinePolygon(4,xair1,yair1);
199 centralair3shape->DefineSection(0,-kHalfLengthCentral);
200 centralair3shape->DefineSection(1, kHalfLengthCentral);
201
202 TGeoXtru *centralair4shape = new TGeoXtru(2);
203
204 xair1[0] = xomega[16];
205 yair1[0] = yomega[16];
206 xair1[1] = xomega[17];
207 yair1[1] = yomega[17];
208 xair1[2] = xomega[18];
209 yair1[2] = yomega[18];
210 xair1[3] = xomega[19];
211 yair1[3] = yomega[19];
212
213 centralair4shape->DefinePolygon(4,xair1,yair1);
214 centralair4shape->DefineSection(0,-kHalfLengthCentral);
215 centralair4shape->DefineSection(1, kHalfLengthCentral);
216
217 TGeoXtru *centralair5shape = new TGeoXtru(2);
218
219 xair1[0] = xomega[6];
220 yair1[0] = yomega[6];
221 xair1[1] = xomega[7];
222 yair1[1] = yomega[7];
223 xair1[2] = xomega[8];
224 yair1[2] = yomega[8];
225 xair1[3] = xomega[9];
226 yair1[3] = yomega[9];
227
228 centralair5shape->DefinePolygon(4,xair1,yair1);
229 centralair5shape->DefineSection(0,-kHalfLengthCentral);
230 centralair5shape->DefineSection(1, kHalfLengthCentral);
231
232 TGeoXtru *centralair6shape = new TGeoXtru(2);
233
234 xair1[0] = xomega[12];
235 yair1[0] = yomega[12];
236 xair1[1] = xomega[13];
237 yair1[1] = yomega[13];
238 xair1[2] = xomega[14];
239 yair1[2] = yomega[14];
240 xair1[3] = xomega[15];
241 yair1[3] = yomega[15];
242
243 centralair6shape->DefinePolygon(4,xair1,yair1);
244 centralair6shape->DefineSection(0,-kHalfLengthCentral);
245 centralair6shape->DefineSection(1, kHalfLengthCentral);
a275e8ba 246
a275e8ba 247
248 // The end cap half shield: a half tube of carbon fiber,
c573c6ec 249 // filled with air volumes, which together make the whole shield
250 // (i.e. the tube and the Omega-shaped insert).
a275e8ba 251 // They are all XTru shapes
252
253 TGeoXtru *endcapshape = new TGeoXtru(2);
254
255 CreateSPDThermalShape(kInnerAEndCap,kInnerBEndCap,kInnerRadiusEndCap,
256 kOuterAEndCap,kOuterBEndCap,kOuterRadiusEndCap,
257 kTheta,xshld,yshld);
258
259 endcapshape->DefinePolygon(24,xshld,yshld);
260 endcapshape->DefineSection(0,-kHalfLengthEndCap);
261 endcapshape->DefineSection(1, kHalfLengthEndCap);
262
263 // Now rescale to get the air volume dimensions
264 InsidePoint(xshld[23], yshld[23],
265 xshld[ 0], yshld[ 0],
266 xshld[ 1], yshld[ 1], kThicknessEndCap,
267 xair[0], yair[0]);
268 for (Int_t i=1; i<23; i++) {
269 InsidePoint(xshld[i-1], yshld[i-1],
270 xshld[ i ], yshld[ i ],
271 xshld[i+1], yshld[i+1], kThicknessEndCap,
272 xair[i], yair[i]);
273 }
274 InsidePoint(xshld[22], yshld[22],
275 xshld[23], yshld[23],
276 xshld[ 0], yshld[ 0], kThicknessEndCap,
277 xair[23], yair[23]);
278
c573c6ec 279 // Then use them to determine the Omega shape points
3d2705b6 280 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
c573c6ec 281
282 // Finally create the single air volumes
283 TGeoXtru *endcapair1shape = new TGeoXtru(2);
284
285 xair1[0] = xomega[1];
286 yair1[0] = yomega[1];
287 xair1[1] = xomega[0];
288 yair1[1] = yomega[0];
289 xair1[2] = -xair1[1];
290 yair1[2] = yair1[1];
291 xair1[3] = -xair1[0];
292 yair1[3] = yair1[0];
293
294 endcapair1shape->DefinePolygon(4,xair1,yair1);
295 endcapair1shape->DefineSection(0,-kHalfLengthEndCap);
296 endcapair1shape->DefineSection(1, kHalfLengthEndCap);
297
298 TGeoXtru *endcapair2shape = new TGeoXtru(2);
299
300 xair1[0] = xomega[21];
301 yair1[0] = yomega[21];
302 xair1[1] = xomega[20];
303 yair1[1] = yomega[20];
304 xair1[2] = xomega[23];
305 yair1[2] = yomega[23];
306 xair1[3] = xomega[22];
307 yair1[3] = yomega[22];
308
309 endcapair2shape->DefinePolygon(4,xair1,yair1);
310 endcapair2shape->DefineSection(0,-kHalfLengthEndCap);
311 endcapair2shape->DefineSection(1, kHalfLengthEndCap);
312
313 TGeoXtru *endcapair3shape = new TGeoXtru(2);
314
315 xair1[0] = xomega[2];
316 yair1[0] = yomega[2];
317 xair1[1] = xomega[3];
318 yair1[1] = yomega[3];
319 xair1[2] = xomega[4];
320 yair1[2] = yomega[4];
321 xair1[3] = xomega[5];
322 yair1[3] = yomega[5];
323
324 endcapair3shape->DefinePolygon(4,xair1,yair1);
325 endcapair3shape->DefineSection(0,-kHalfLengthEndCap);
326 endcapair3shape->DefineSection(1, kHalfLengthEndCap);
327
328 TGeoXtru *endcapair4shape = new TGeoXtru(2);
329
330 xair1[0] = xomega[16];
331 yair1[0] = yomega[16];
332 xair1[1] = xomega[17];
333 yair1[1] = yomega[17];
334 xair1[2] = xomega[18];
335 yair1[2] = yomega[18];
336 xair1[3] = xomega[19];
337 yair1[3] = yomega[19];
338
339 endcapair4shape->DefinePolygon(4,xair1,yair1);
340 endcapair4shape->DefineSection(0,-kHalfLengthEndCap);
341 endcapair4shape->DefineSection(1, kHalfLengthEndCap);
342
343 TGeoXtru *endcapair5shape = new TGeoXtru(2);
344
345 xair1[0] = xomega[6];
346 yair1[0] = yomega[6];
347 xair1[1] = xomega[7];
348 yair1[1] = yomega[7];
349 xair1[2] = xomega[8];
350 yair1[2] = yomega[8];
351 xair1[3] = xomega[9];
352 yair1[3] = yomega[9];
353
354 endcapair5shape->DefinePolygon(4,xair1,yair1);
355 endcapair5shape->DefineSection(0,-kHalfLengthEndCap);
356 endcapair5shape->DefineSection(1, kHalfLengthEndCap);
357
358 TGeoXtru *endcapair6shape = new TGeoXtru(2);
359
360 xair1[0] = xomega[12];
361 yair1[0] = yomega[12];
362 xair1[1] = xomega[13];
363 yair1[1] = yomega[13];
364 xair1[2] = xomega[14];
365 yair1[2] = yomega[14];
366 xair1[3] = xomega[15];
367 yair1[3] = yomega[15];
368
369 endcapair6shape->DefinePolygon(4,xair1,yair1);
370 endcapair6shape->DefineSection(0,-kHalfLengthEndCap);
371 endcapair6shape->DefineSection(1, kHalfLengthEndCap);
a275e8ba 372
373 // The cone half shield is more complex since there is no basic
6f88a698 374 // TGeo shape to describe it correctly. So it is a Composite Shape
375 // of a series of TGeoArb8 shapes, in which TGeoArb8 shapes filled
376 // with air are placed, which all together make up the cone AND
377 // its internal insert. Part of the following code is adapted from
378 // old SPDThermalSheald method.
a275e8ba 379
c573c6ec 380 // sCn : Filled portions, sChn : Air holes
381 TGeoArb8 *sC1 = new TGeoArb8(kHalfLengthCone);
382 TGeoArb8 *sC2 = new TGeoArb8(kHalfLengthCone);
383 TGeoArb8 *sC3 = new TGeoArb8(kHalfLengthCone);
384 TGeoArb8 *sC4 = new TGeoArb8(kHalfLengthCone);
385 TGeoArb8 *sC5 = new TGeoArb8(kHalfLengthCone);
386 TGeoArb8 *sC6 = new TGeoArb8(kHalfLengthCone);
387 TGeoArb8 *sC7 = new TGeoArb8(kHalfLengthCone);
388 TGeoArb8 *sC8 = new TGeoArb8(kHalfLengthCone);
389 TGeoArb8 *sC9 = new TGeoArb8(kHalfLengthCone);
390 TGeoArb8 *sC10 = new TGeoArb8(kHalfLengthCone);
391 TGeoArb8 *sC11 = new TGeoArb8(kHalfLengthCone);
392
393 sC1->SetName("sC1");
394 sC2->SetName("sC2");
395 sC3->SetName("sC3");
396 sC4->SetName("sC4");
397 sC5->SetName("sC5");
398 sC6->SetName("sC6");
399 sC7->SetName("sC7");
400 sC8->SetName("sC8");
401 sC9->SetName("sC9");
402 sC10->SetName("sC10");
403 sC11->SetName("sC11");
404
405 TGeoArb8 *sCh1 = new TGeoArb8(kHalfLengthCone);
406 TGeoArb8 *sCh2 = new TGeoArb8(kHalfLengthCone);
407 TGeoArb8 *sCh3 = new TGeoArb8(kHalfLengthCone);
408 TGeoArb8 *sCh4 = new TGeoArb8(kHalfLengthCone);
409 TGeoArb8 *sCh5 = new TGeoArb8(kHalfLengthCone);
410 TGeoArb8 *sCh6 = new TGeoArb8(kHalfLengthCone);
411 TGeoArb8 *sCh7 = new TGeoArb8(kHalfLengthCone);
412 TGeoArb8 *sCh8 = new TGeoArb8(kHalfLengthCone);
413 TGeoArb8 *sCh9 = new TGeoArb8(kHalfLengthCone);
414 TGeoArb8 *sCh10 = new TGeoArb8(kHalfLengthCone);
415 TGeoArb8 *sCh11 = new TGeoArb8(kHalfLengthCone);
416
417 sCh1->SetName("sCh1");
418 sCh2->SetName("sCh2");
419 sCh3->SetName("sCh3");
420 sCh4->SetName("sCh4");
421 sCh5->SetName("sCh5");
422 sCh6->SetName("sCh6");
423 sCh7->SetName("sCh7");
424 sCh8->SetName("sCh8");
425 sCh9->SetName("sCh9");
426 sCh10->SetName("sCh10");
427 sCh11->SetName("sCh11");
428
429 // Smaller end: determine the coordinates of the points of carbon fiber
a275e8ba 430 CreateSPDThermalShape(kInnerACentral,kInnerBCentral,kInnerRadiusCentral,
431 kOuterACentral,kOuterBCentral,kOuterRadiusCentral,
432 kTheta,xshld,yshld);
433
c573c6ec 434 sC1->SetVertex(0, xshld[12], yshld[12]);
435 sC1->SetVertex(1, xshld[11], yshld[11]);
436 sC1->SetVertex(2, xshld[ 0], yshld[ 0]);
437 sC1->SetVertex(3, xshld[23], yshld[23]);
438
439 sC2->SetVertex(0, xshld[11], yshld[11]);
440 sC2->SetVertex(1, xshld[10], yshld[10]);
441 sC2->SetVertex(2, xshld[ 1], yshld[ 1]);
442 sC2->SetVertex(3, xshld[ 0], yshld[ 0]);
443
444 sC3->SetVertex(0, xshld[10], yshld[10]);
445 sC3->SetVertex(1, xshld[ 9], yshld[ 9]);
446 sC3->SetVertex(2, xshld[ 2], yshld[ 2]);
447 sC3->SetVertex(3, xshld[ 1], yshld[ 1]);
448
449 sC4->SetVertex(0, xshld[ 9], yshld[ 9]);
450 sC4->SetVertex(1, xshld[ 8], yshld[ 8]);
451 sC4->SetVertex(2, xshld[ 3], yshld[ 3]);
452 sC4->SetVertex(3, xshld[ 2], yshld[ 2]);
453
454 sC5->SetVertex(0, xshld[ 8], yshld[ 8]);
455 sC5->SetVertex(1, xshld[ 7], yshld[ 7]);
456 sC5->SetVertex(2, xshld[ 4], yshld[ 4]);
457 sC5->SetVertex(3, xshld[ 3], yshld[ 3]);
458
459 sC6->SetVertex(0, xshld[ 7], yshld[ 7]);
460 sC6->SetVertex(1, xshld[ 6], yshld[ 6]);
461 sC6->SetVertex(2, xshld[ 5], yshld[ 5]);
462 sC6->SetVertex(3, xshld[ 4], yshld[ 4]);
463
464 sC7->SetVertex(0,-xshld[10], yshld[10]);
465 sC7->SetVertex(1,-xshld[11], yshld[11]);
466 sC7->SetVertex(2,-xshld[ 0], yshld[ 0]);
467 sC7->SetVertex(3,-xshld[ 1], yshld[ 1]);
468
469 sC8->SetVertex(0,-xshld[ 9], yshld[ 9]);
470 sC8->SetVertex(1,-xshld[10], yshld[10]);
471 sC8->SetVertex(2,-xshld[ 1], yshld[ 1]);
472 sC8->SetVertex(3,-xshld[ 2], yshld[ 2]);
473
474 sC9->SetVertex(0,-xshld[ 8], yshld[ 8]);
475 sC9->SetVertex(1,-xshld[ 9], yshld[ 9]);
476 sC9->SetVertex(2,-xshld[ 2], yshld[ 2]);
477 sC9->SetVertex(3,-xshld[ 3], yshld[ 3]);
478
479 sC10->SetVertex(0,-xshld[ 7], yshld[ 7]);
480 sC10->SetVertex(1,-xshld[ 8], yshld[ 8]);
481 sC10->SetVertex(2,-xshld[ 3], yshld[ 3]);
482 sC10->SetVertex(3,-xshld[ 4], yshld[ 4]);
483
484 sC11->SetVertex(0,-xshld[ 6], yshld[ 6]);
485 sC11->SetVertex(1,-xshld[ 7], yshld[ 7]);
486 sC11->SetVertex(2,-xshld[ 4], yshld[ 4]);
487 sC11->SetVertex(3,-xshld[ 5], yshld[ 5]);
488
489 // Then rescale to get the air volume dimensions
490 InsidePoint(xshld[23], yshld[23],
491 xshld[ 0], yshld[ 0],
492 xshld[ 1], yshld[ 1], kThicknessCone,
493 xair[0], yair[0]);
494 for (Int_t i=1; i<23; i++) {
495 InsidePoint(xshld[i-1], yshld[i-1],
496 xshld[ i ], yshld[ i ],
497 xshld[i+1], yshld[i+1], kThicknessCone,
498 xair[i], yair[i]);
499 }
500 InsidePoint(xshld[22], yshld[22],
501 xshld[23], yshld[23],
502 xshld[ 0], yshld[ 0], kThicknessCone,
503 xair[23], yair[23]);
504
505 // Then use them to determine the Omega shape points
506 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
a275e8ba 507
c573c6ec 508 // Finally fill the small end coordinates of the air shapes
509 sCh1->SetVertex(0, xomega[ 0], yomega[ 0]);
510 sCh1->SetVertex(1, xomega[ 1], yomega[ 1]);
511 sCh1->SetVertex(2,-xomega[ 1], yomega[ 1]);
512 sCh1->SetVertex(3,-xomega[ 0], yomega[ 0]);
513
514 sCh2->SetVertex(0, xomega[20], yomega[20]);
515 sCh2->SetVertex(1, xomega[21], yomega[21]);
516 sCh2->SetVertex(2, xomega[22], yomega[22]);
517 sCh2->SetVertex(3, xomega[23], yomega[23]);
518
519 sCh3->SetVertex(0, xomega[ 2], yomega[ 2]);
520 sCh3->SetVertex(1, xomega[ 3], yomega[ 3]);
521 sCh3->SetVertex(2, xomega[ 4], yomega[ 4]);
522 sCh3->SetVertex(3, xomega[ 5], yomega[ 5]);
523
524 sCh4->SetVertex(0, xomega[16], yomega[16]);
525 sCh4->SetVertex(1, xomega[17], yomega[17]);
526 sCh4->SetVertex(2, xomega[18], yomega[18]);
527 sCh4->SetVertex(3, xomega[19], yomega[19]);
528
529 sCh5->SetVertex(0, xomega[ 6], yomega[ 6]);
530 sCh5->SetVertex(1, xomega[ 7], yomega[ 7]);
531 sCh5->SetVertex(2, xomega[ 8], yomega[ 8]);
532 sCh5->SetVertex(3, xomega[ 9], yomega[ 9]);
533
534 sCh6->SetVertex(0, xomega[12], yomega[12]);
535 sCh6->SetVertex(1, xomega[13], yomega[13]);
536 sCh6->SetVertex(2, xomega[14], yomega[14]);
537 sCh6->SetVertex(3, xomega[15], yomega[15]);
538
539 sCh7->SetVertex(0,-xomega[21], yomega[21]);
540 sCh7->SetVertex(1,-xomega[20], yomega[20]);
541 sCh7->SetVertex(2,-xomega[23], yomega[23]);
542 sCh7->SetVertex(3,-xomega[22], yomega[22]);
543
544 sCh8->SetVertex(0,-xomega[ 3], yomega[ 3]);
545 sCh8->SetVertex(1,-xomega[ 2], yomega[ 2]);
546 sCh8->SetVertex(2,-xomega[ 5], yomega[ 5]);
547 sCh8->SetVertex(3,-xomega[ 4], yomega[ 4]);
548
549 sCh9->SetVertex(0,-xomega[17], yomega[17]);
550 sCh9->SetVertex(1,-xomega[16], yomega[16]);
551 sCh9->SetVertex(2,-xomega[19], yomega[19]);
552 sCh9->SetVertex(3,-xomega[18], yomega[18]);
553
554 sCh10->SetVertex(0,-xomega[ 7], yomega[ 7]);
555 sCh10->SetVertex(1,-xomega[ 6], yomega[ 6]);
556 sCh10->SetVertex(2,-xomega[ 9], yomega[ 9]);
557 sCh10->SetVertex(3,-xomega[ 8], yomega[ 8]);
558
559 sCh11->SetVertex(0,-xomega[13], yomega[13]);
560 sCh11->SetVertex(1,-xomega[12], yomega[12]);
561 sCh11->SetVertex(2,-xomega[15], yomega[15]);
562 sCh11->SetVertex(3,-xomega[14], yomega[14]);
563
564 // Bigger end: determine the coordinates of the points of carbon fiber
a275e8ba 565
566 // Drawings give only the radius, convert it to the apothegm
567 Double_t kInnerRadiusCone = TMath::Sqrt(kInnerRadialCone*kInnerRadialCone
568 - 0.25*kInnerACone*kInnerACone);
569 Double_t kOuterRadiusCone = TMath::Sqrt(kOuterRadialCone*kOuterRadialCone
570 - 0.25*kOuterACone*kOuterACone);
571
c573c6ec 572 CreateSPDThermalShape(kInnerACone,kInnerBCone,kInnerRadiusCone,
573 kOuterACone,kOuterBCone,kOuterRadiusCone,
574 kTheta,xshld,yshld);
a275e8ba 575
c573c6ec 576 sC1->SetVertex(4, xshld[12], yshld[12]);
577 sC1->SetVertex(5, xshld[11], yshld[11]);
578 sC1->SetVertex(6, xshld[ 0], yshld[ 0]);
579 sC1->SetVertex(7, xshld[23], yshld[23]);
580
581 sC2->SetVertex(4, xshld[11], yshld[11]);
582 sC2->SetVertex(5, xshld[10], yshld[10]);
583 sC2->SetVertex(6, xshld[ 1], yshld[ 1]);
584 sC2->SetVertex(7, xshld[ 0], yshld[ 0]);
585
586 sC3->SetVertex(4, xshld[10], yshld[10]);
587 sC3->SetVertex(5, xshld[ 9], yshld[ 9]);
588 sC3->SetVertex(6, xshld[ 2], yshld[ 2]);
589 sC3->SetVertex(7, xshld[ 1], yshld[ 1]);
590
591 sC4->SetVertex(4, xshld[ 9], yshld[ 9]);
592 sC4->SetVertex(5, xshld[ 8], yshld[ 8]);
593 sC4->SetVertex(6, xshld[ 3], yshld[ 3]);
594 sC4->SetVertex(7, xshld[ 2], yshld[ 2]);
595
596 sC5->SetVertex(4, xshld[ 8], yshld[ 8]);
597 sC5->SetVertex(5, xshld[ 7], yshld[ 7]);
598 sC5->SetVertex(6, xshld[ 4], yshld[ 4]);
599 sC5->SetVertex(7, xshld[ 3], yshld[ 3]);
600
601 sC6->SetVertex(4, xshld[ 7], yshld[ 7]);
602 sC6->SetVertex(5, xshld[ 6], yshld[ 6]);
603 sC6->SetVertex(6, xshld[ 5], yshld[ 5]);
604 sC6->SetVertex(7, xshld[ 4], yshld[ 4]);
605
606 sC7->SetVertex(4,-xshld[10], yshld[10]);
607 sC7->SetVertex(5,-xshld[11], yshld[11]);
608 sC7->SetVertex(6,-xshld[ 0], yshld[ 0]);
609 sC7->SetVertex(7,-xshld[ 1], yshld[ 1]);
610
611 sC8->SetVertex(4,-xshld[ 9], yshld[ 9]);
612 sC8->SetVertex(5,-xshld[10], yshld[10]);
613 sC8->SetVertex(6,-xshld[ 1], yshld[ 1]);
614 sC8->SetVertex(7,-xshld[ 2], yshld[ 2]);
615
616 sC9->SetVertex(4,-xshld[ 8], yshld[ 8]);
617 sC9->SetVertex(5,-xshld[ 9], yshld[ 9]);
618 sC9->SetVertex(6,-xshld[ 2], yshld[ 2]);
619 sC9->SetVertex(7,-xshld[ 3], yshld[ 3]);
620
621 sC10->SetVertex(4,-xshld[ 7], yshld[ 7]);
622 sC10->SetVertex(5,-xshld[ 8], yshld[ 8]);
623 sC10->SetVertex(6,-xshld[ 3], yshld[ 3]);
624 sC10->SetVertex(7,-xshld[ 4], yshld[ 4]);
625
626 sC11->SetVertex(4,-xshld[ 6], yshld[ 6]);
627 sC11->SetVertex(5,-xshld[ 7], yshld[ 7]);
628 sC11->SetVertex(6,-xshld[ 4], yshld[ 4]);
629 sC11->SetVertex(7,-xshld[ 5], yshld[ 5]);
630
631 // Then rescale to get the air volume dimensions
632 InsidePoint(xshld[23], yshld[23],
633 xshld[ 0], yshld[ 0],
634 xshld[ 1], yshld[ 1], kThicknessCone,
635 xair[0], yair[0]);
636 for (Int_t i=1; i<23; i++) {
637 InsidePoint(xshld[i-1], yshld[i-1],
638 xshld[ i ], yshld[ i ],
639 xshld[i+1], yshld[i+1], kThicknessCone,
640 xair[i], yair[i]);
641 }
642 InsidePoint(xshld[22], yshld[22],
643 xshld[23], yshld[23],
644 xshld[ 0], yshld[ 0], kThicknessCone,
645 xair[23], yair[23]);
a275e8ba 646
c573c6ec 647 // Then use them to determine the Omega shape points
648 CreateSPDOmegaShape(xair,yair,kThicknessOmega,xomega,yomega);
a275e8ba 649
c573c6ec 650 // Finally fill the big end coordinates of the air shapes
651 sCh1->SetVertex(4, xomega[ 0], yomega[ 0]);
652 sCh1->SetVertex(5, xomega[ 1], yomega[ 1]);
653 sCh1->SetVertex(6,-xomega[ 1], yomega[ 1]);
654 sCh1->SetVertex(7,-xomega[ 0], yomega[ 0]);
655
656 sCh2->SetVertex(4, xomega[20], yomega[20]);
657 sCh2->SetVertex(5, xomega[21], yomega[21]);
658 sCh2->SetVertex(6, xomega[22], yomega[22]);
659 sCh2->SetVertex(7, xomega[23], yomega[23]);
660
661 sCh3->SetVertex(4, xomega[ 2], yomega[ 2]);
662 sCh3->SetVertex(5, xomega[ 3], yomega[ 3]);
663 sCh3->SetVertex(6, xomega[ 4], yomega[ 4]);
664 sCh3->SetVertex(7, xomega[ 5], yomega[ 5]);
665
666 sCh4->SetVertex(4, xomega[16], yomega[16]);
667 sCh4->SetVertex(5, xomega[17], yomega[17]);
668 sCh4->SetVertex(6, xomega[18], yomega[18]);
669 sCh4->SetVertex(7, xomega[19], yomega[19]);
670
671 sCh5->SetVertex(4, xomega[ 6], yomega[ 6]);
672 sCh5->SetVertex(5, xomega[ 7], yomega[ 7]);
673 sCh5->SetVertex(6, xomega[ 8], yomega[ 8]);
674 sCh5->SetVertex(7, xomega[ 9], yomega[ 9]);
675
676 sCh6->SetVertex(4, xomega[12], yomega[12]);
677 sCh6->SetVertex(5, xomega[13], yomega[13]);
678 sCh6->SetVertex(6, xomega[14], yomega[14]);
679 sCh6->SetVertex(7, xomega[15], yomega[15]);
680
681 sCh7->SetVertex(4,-xomega[21], yomega[21]);
682 sCh7->SetVertex(5,-xomega[20], yomega[20]);
683 sCh7->SetVertex(6,-xomega[23], yomega[23]);
684 sCh7->SetVertex(7,-xomega[22], yomega[22]);
685
686 sCh8->SetVertex(4,-xomega[ 3], yomega[ 3]);
687 sCh8->SetVertex(5,-xomega[ 2], yomega[ 2]);
688 sCh8->SetVertex(6,-xomega[ 5], yomega[ 5]);
689 sCh8->SetVertex(7,-xomega[ 4], yomega[ 4]);
690
691 sCh9->SetVertex(4,-xomega[17], yomega[17]);
692 sCh9->SetVertex(5,-xomega[16], yomega[16]);
693 sCh9->SetVertex(6,-xomega[19], yomega[19]);
694 sCh9->SetVertex(7,-xomega[18], yomega[18]);
695
696 sCh10->SetVertex(4,-xomega[ 7], yomega[ 7]);
697 sCh10->SetVertex(5,-xomega[ 6], yomega[ 6]);
698 sCh10->SetVertex(6,-xomega[ 9], yomega[ 9]);
699 sCh10->SetVertex(7,-xomega[ 8], yomega[ 8]);
700
701 sCh11->SetVertex(4,-xomega[13], yomega[13]);
702 sCh11->SetVertex(5,-xomega[12], yomega[12]);
703 sCh11->SetVertex(6,-xomega[15], yomega[15]);
704 sCh11->SetVertex(7,-xomega[14], yomega[14]);
705
6f88a698 706 // Now the actual carbon fiber cone: a CompositeShape
707 TGeoCompositeShape *sCone = new TGeoCompositeShape("sCone",
708 "sC1+sC2+sC3+sC4+sC5+sC6+sC7+sC8+sC9+sC10+sC11");
709
a275e8ba 710 // Finally the carbon fiber Ring with its Wings and their
711 // stesalite inserts. They are Tube and TubeSeg shapes
712
713 TGeoTube *ringshape = new TGeoTube(kInnerRadiusRing,kOuterRadiusRing,
714 kHalfLengthRing);
715
716 TGeoTube *ringinsertshape = new TGeoTube(kInnerRadiusRing+kThicknessRing,
717 kOuterRadiusRing-kThicknessRing,
718 kHalfLengthRing-kThicknessRing);
719
720 Double_t angleWideWing, angleWideWingThickness;
721 angleWideWing = (kWideWing/kOuterRadiusWing)*TMath::RadToDeg();
722 angleWideWingThickness = (kThicknessRing/kOuterRadiusWing)*TMath::RadToDeg();
723
724 TGeoTubeSeg *wingshape = new TGeoTubeSeg(kOuterRadiusRing,kOuterRadiusWing,
725 kHalfLengthRing, 0, angleWideWing);
726
727 TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kOuterRadiusRing,
728 kOuterRadiusWing-kThicknessRing, kHalfLengthRing-kThicknessRing,
729 angleWideWingThickness, angleWideWing-angleWideWingThickness);
730
731
732 // We have the shapes: now create the real volumes
733
734 TGeoMedium *medSPDcf = mgr->GetMedium("ITS_SPD shield$");
735 TGeoMedium *medSPDair = mgr->GetMedium("ITS_SPD AIR$");
736 TGeoMedium *medSPDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
737
738 TGeoVolume *centralshield = new TGeoVolume("SPDcentralshield",
739 centralshape,medSPDcf);
740 centralshield->SetVisibility(kTRUE);
741 centralshield->SetLineColor(7);
742 centralshield->SetLineWidth(1);
c573c6ec 743 centralshield->SetFillColor(centralshield->GetLineColor());
744 centralshield->SetFillStyle(4090); // 90% transparent
745
746 TGeoVolume *centralair1 = new TGeoVolume("SPDcentralair1shield",
747 centralair1shape,medSPDair);
748 centralair1->SetVisibility(kTRUE);
749 centralair1->SetLineColor(5); // Yellow
750 centralair1->SetLineWidth(1);
751 centralair1->SetFillColor(centralair1->GetLineColor());
752 centralair1->SetFillStyle(4090); // 90% transparent
753
754 TGeoVolume *centralair2 = new TGeoVolume("SPDcentralair2shield",
755 centralair2shape,medSPDair);
756 centralair2->SetVisibility(kTRUE);
757 centralair2->SetLineColor(5); // Yellow
758 centralair2->SetLineWidth(1);
759 centralair2->SetFillColor(centralair2->GetLineColor());
760 centralair2->SetFillStyle(4090); // 90% transparent
761
762 TGeoVolume *centralair3 = new TGeoVolume("SPDcentralair3shield",
763 centralair3shape,medSPDair);
764 centralair3->SetVisibility(kTRUE);
765 centralair3->SetLineColor(5); // Yellow
766 centralair3->SetLineWidth(1);
767 centralair3->SetFillColor(centralair3->GetLineColor());
768 centralair3->SetFillStyle(4090); // 90% transparent
769
770 TGeoVolume *centralair4 = new TGeoVolume("SPDcentralair4shield",
771 centralair4shape,medSPDair);
772 centralair4->SetVisibility(kTRUE);
773 centralair4->SetLineColor(5); // Yellow
774 centralair4->SetLineWidth(1);
775 centralair4->SetFillColor(centralair4->GetLineColor());
776 centralair4->SetFillStyle(4090); // 90% transparent
777
778 TGeoVolume *centralair5 = new TGeoVolume("SPDcentralair5shield",
779 centralair5shape,medSPDair);
780 centralair5->SetVisibility(kTRUE);
781 centralair5->SetLineColor(5); // Yellow
782 centralair5->SetLineWidth(1);
783 centralair5->SetFillColor(centralair5->GetLineColor());
784 centralair5->SetFillStyle(4090); // 90% transparent
785
786 TGeoVolume *centralair6 = new TGeoVolume("SPDcentralair6shield",
787 centralair6shape,medSPDair);
788 centralair6->SetVisibility(kTRUE);
789 centralair6->SetLineColor(5); // Yellow
790 centralair6->SetLineWidth(1);
791 centralair6->SetFillColor(centralair6->GetLineColor());
792 centralair6->SetFillStyle(4090); // 90% transparent
793
794 centralshield->AddNode(centralair1,1,0);
795 centralshield->AddNode(centralair2,1,0);
796 centralshield->AddNode(centralair2,2,new TGeoRotation("",90,180,-90));
797 centralshield->AddNode(centralair3,1,0);
798 centralshield->AddNode(centralair3,2,new TGeoRotation("",90,180,-90));
799 centralshield->AddNode(centralair4,1,0);
800 centralshield->AddNode(centralair4,2,new TGeoRotation("",90,180,-90));
801 centralshield->AddNode(centralair5,1,0);
802 centralshield->AddNode(centralair5,2,new TGeoRotation("",90,180,-90));
803 centralshield->AddNode(centralair6,1,0);
804 centralshield->AddNode(centralair6,2,new TGeoRotation("",90,180,-90));
a275e8ba 805
806 TGeoVolume *endcapshield = new TGeoVolume("SPDendcapshield",
807 endcapshape,medSPDcf);
808 endcapshield->SetVisibility(kTRUE);
809 endcapshield->SetLineColor(7);
810 endcapshield->SetLineWidth(1);
811
c573c6ec 812 TGeoVolume *endcapair1 = new TGeoVolume("SPDendcapair1shield",
813 endcapair1shape,medSPDair);
814 endcapair1->SetVisibility(kTRUE);
815 endcapair1->SetLineColor(5); // Yellow
816 endcapair1->SetLineWidth(1);
817 endcapair1->SetFillColor(endcapair1->GetLineColor());
818 endcapair1->SetFillStyle(4090); // 90% transparent
819
820 TGeoVolume *endcapair2 = new TGeoVolume("SPDendcapair2shield",
821 endcapair2shape,medSPDair);
822 endcapair2->SetVisibility(kTRUE);
823 endcapair2->SetLineColor(5); // Yellow
824 endcapair2->SetLineWidth(1);
825 endcapair2->SetFillColor(endcapair2->GetLineColor());
826 endcapair2->SetFillStyle(4090); // 90% transparent
827
828 TGeoVolume *endcapair3 = new TGeoVolume("SPDendcapair3shield",
829 endcapair3shape,medSPDair);
830 endcapair3->SetVisibility(kTRUE);
831 endcapair3->SetLineColor(5); // Yellow
832 endcapair3->SetLineWidth(1);
833 endcapair3->SetFillColor(endcapair3->GetLineColor());
834 endcapair3->SetFillStyle(4090); // 90% transparent
835
836 TGeoVolume *endcapair4 = new TGeoVolume("SPDendcapair4shield",
837 endcapair4shape,medSPDair);
838 endcapair4->SetVisibility(kTRUE);
839 endcapair4->SetLineColor(5); // Yellow
840 endcapair4->SetLineWidth(1);
841 endcapair4->SetFillColor(endcapair4->GetLineColor());
842 endcapair4->SetFillStyle(4090); // 90% transparent
843
844 TGeoVolume *endcapair5 = new TGeoVolume("SPDendcapair5shield",
845 endcapair5shape,medSPDair);
846 endcapair5->SetVisibility(kTRUE);
847 endcapair5->SetLineColor(5); // Yellow
848 endcapair5->SetLineWidth(1);
849 endcapair5->SetFillColor(endcapair5->GetLineColor());
850 endcapair5->SetFillStyle(4090); // 90% transparent
851
852 TGeoVolume *endcapair6 = new TGeoVolume("SPDendcapair6shield",
853 endcapair6shape,medSPDair);
854 endcapair6->SetVisibility(kTRUE);
855 endcapair6->SetLineColor(5); // Yellow
856 endcapair6->SetLineWidth(1);
857 endcapair6->SetFillColor(endcapair6->GetLineColor());
858 endcapair6->SetFillStyle(4090); // 90% transparent
859
860 endcapshield->AddNode(endcapair1,1,0);
861 endcapshield->AddNode(endcapair2,1,0);
862 endcapshield->AddNode(endcapair2,2,new TGeoRotation("",90,180,-90));
863 endcapshield->AddNode(endcapair3,1,0);
864 endcapshield->AddNode(endcapair3,2,new TGeoRotation("",90,180,-90));
865 endcapshield->AddNode(endcapair4,1,0);
866 endcapshield->AddNode(endcapair4,2,new TGeoRotation("",90,180,-90));
867 endcapshield->AddNode(endcapair5,1,0);
868 endcapshield->AddNode(endcapair5,2,new TGeoRotation("",90,180,-90));
869 endcapshield->AddNode(endcapair6,1,0);
870 endcapshield->AddNode(endcapair6,2,new TGeoRotation("",90,180,-90));
a275e8ba 871
6f88a698 872 TGeoVolume *vCone = new TGeoVolume("SPDconeshield",sCone,medSPDcf);
873 vCone->SetVisibility(kTRUE);
874 vCone->SetLineColor(7);
875 vCone->SetLineWidth(1);
876 vCone->SetFillColor(vCone->GetLineColor());
877 vCone->SetFillStyle(4090); // 90% transparent
a275e8ba 878
879 TGeoVolume *vCh1 = new TGeoVolume("SPDconeshieldH1",sCh1,medSPDair);
a275e8ba 880 vCh1->SetVisibility(kTRUE);
881 vCh1->SetLineColor(5); // Yellow
882 vCh1->SetLineWidth(1);
883 vCh1->SetFillColor(vCh1->GetLineColor());
884 vCh1->SetFillStyle(4090); // 90% transparent
885
a275e8ba 886 TGeoVolume *vCh2 = new TGeoVolume("SPDconeshieldH2",sCh2,medSPDair);
a275e8ba 887 vCh2->SetVisibility(kTRUE);
888 vCh2->SetLineColor(5); // Yellow
889 vCh2->SetLineWidth(1);
890 vCh2->SetFillColor(vCh2->GetLineColor());
891 vCh2->SetFillStyle(4090); // 90% transparent
892
c573c6ec 893 TGeoVolume *vCh3 = new TGeoVolume("SPDconeshieldH3",sCh3,medSPDair);
894 vCh3->SetVisibility(kTRUE);
895 vCh3->SetLineColor(5); // Yellow
896 vCh3->SetLineWidth(1);
897 vCh3->SetFillColor(vCh3->GetLineColor());
898 vCh3->SetFillStyle(4090); // 90% transparent
899
c573c6ec 900 TGeoVolume *vCh4 = new TGeoVolume("SPDconeshieldH4",sCh4,medSPDair);
901 vCh4->SetVisibility(kTRUE);
902 vCh4->SetLineColor(5); // Yellow
903 vCh4->SetLineWidth(1);
904 vCh4->SetFillColor(vCh4->GetLineColor());
905 vCh4->SetFillStyle(4090); // 90% transparent
906
c573c6ec 907 TGeoVolume *vCh5 = new TGeoVolume("SPDconeshieldH5",sCh5,medSPDair);
908 vCh5->SetVisibility(kTRUE);
909 vCh5->SetLineColor(5); // Yellow
910 vCh5->SetLineWidth(1);
911 vCh5->SetFillColor(vCh5->GetLineColor());
912 vCh5->SetFillStyle(4090); // 90% transparent
913
c573c6ec 914 TGeoVolume *vCh6 = new TGeoVolume("SPDconeshieldH6",sCh6,medSPDair);
915 vCh6->SetVisibility(kTRUE);
916 vCh6->SetLineColor(5); // Yellow
917 vCh6->SetLineWidth(1);
918 vCh6->SetFillColor(vCh6->GetLineColor());
919 vCh6->SetFillStyle(4090); // 90% transparent
920
c573c6ec 921 TGeoVolume *vCh7 = new TGeoVolume("SPDconeshieldH7",sCh7,medSPDair);
922 vCh7->SetVisibility(kTRUE);
923 vCh7->SetLineColor(5); // Yellow
924 vCh7->SetLineWidth(1);
925 vCh7->SetFillColor(vCh7->GetLineColor());
926 vCh7->SetFillStyle(4090); // 90% transparent
927
c573c6ec 928 TGeoVolume *vCh8 = new TGeoVolume("SPDconeshieldH8",sCh8,medSPDair);
929 vCh8->SetVisibility(kTRUE);
930 vCh8->SetLineColor(5); // Yellow
931 vCh8->SetLineWidth(1);
932 vCh8->SetFillColor(vCh8->GetLineColor());
933 vCh8->SetFillStyle(4090); // 90% transparent
934
c573c6ec 935 TGeoVolume *vCh9 = new TGeoVolume("SPDconeshieldH9",sCh9,medSPDair);
936 vCh9->SetVisibility(kTRUE);
937 vCh9->SetLineColor(5); // Yellow
938 vCh9->SetLineWidth(1);
939 vCh9->SetFillColor(vCh9->GetLineColor());
940 vCh9->SetFillStyle(4090); // 90% transparent
941
c573c6ec 942 TGeoVolume *vCh10 = new TGeoVolume("SPDconeshieldH10",sCh10,medSPDair);
943 vCh10->SetVisibility(kTRUE);
944 vCh10->SetLineColor(5); // Yellow
945 vCh10->SetLineWidth(1);
946 vCh10->SetFillColor(vCh10->GetLineColor());
947 vCh10->SetFillStyle(4090); // 90% transparent
948
c573c6ec 949 TGeoVolume *vCh11 = new TGeoVolume("SPDconeshieldH11",sCh11,medSPDair);
950 vCh11->SetVisibility(kTRUE);
951 vCh11->SetLineColor(5); // Yellow
952 vCh11->SetLineWidth(1);
953 vCh11->SetFillColor(vCh11->GetLineColor());
954 vCh11->SetFillStyle(4090); // 90% transparent
955
6f88a698 956 vCone->AddNode(vCh1 ,1,0);
957 vCone->AddNode(vCh2 ,1,0);
958 vCone->AddNode(vCh3 ,1,0);
959 vCone->AddNode(vCh4 ,1,0);
960 vCone->AddNode(vCh5 ,1,0);
961 vCone->AddNode(vCh6 ,1,0);
962 vCone->AddNode(vCh7 ,1,0);
963 vCone->AddNode(vCh8 ,1,0);
964 vCone->AddNode(vCh9 ,1,0);
965 vCone->AddNode(vCh10,1,0);
966 vCone->AddNode(vCh11,1,0);
c573c6ec 967
a275e8ba 968 TGeoVolume *ring = new TGeoVolume("SPDshieldring",ringshape,medSPDcf);
969 ring->SetVisibility(kTRUE);
970 ring->SetLineColor(7);
971 ring->SetLineWidth(1);
972
973 TGeoVolume *ringinsert = new TGeoVolume("SPDshieldringinsert",
974 ringinsertshape,medSPDste);
975 ringinsert->SetVisibility(kTRUE);
976 ringinsert->SetLineColor(3); // Green
977// ringinsert->SetLineWidth(1);
978 ringinsert->SetFillColor(ringinsert->GetLineColor());
979 ringinsert->SetFillStyle(4010); // 10% transparent
980
981 ring->AddNode(ringinsert,1,0);
982
983 TGeoVolume *wing = new TGeoVolume("SPDshieldringwing",wingshape,medSPDcf);
984 wing->SetVisibility(kTRUE);
985 wing->SetLineColor(7);
986 wing->SetLineWidth(1);
987
6f88a698 988 TGeoVolume *winginsert = new TGeoVolume("SPDshieldwinginsert",
a275e8ba 989 winginsertshape,medSPDste);
990 winginsert->SetVisibility(kTRUE);
991 winginsert->SetLineColor(3); // Green
992// winginsert->SetLineWidth(1);
993 winginsert->SetFillColor(winginsert->GetLineColor());
994 winginsert->SetFillStyle(4010); // 10% transparent
995
996 wing->AddNode(winginsert,1,0);
997
998
999 // Add all volumes in the assembly
0801d201 1000 const Double_t kLittleZTrans = 0.1*fgkmm;
1001 vM->AddNode(centralshield,1,new TGeoTranslation(0,0,-kLittleZTrans));
1002 vM->AddNode(centralshield,2,new TGeoCombiTrans( 0,0,-kLittleZTrans,
1003 new TGeoRotation("",180,0,0)));
a275e8ba 1004
0801d201 1005 zpos = kHalfLengthCentral+kHalfLengthEndCap;
a275e8ba 1006 vM->AddNode(endcapshield,1,
0801d201 1007 new TGeoTranslation(0,0, zpos-kLittleZTrans));
a275e8ba 1008 vM->AddNode(endcapshield,2,
0801d201 1009 new TGeoTranslation(0,0,-zpos-kLittleZTrans));
a275e8ba 1010 vM->AddNode(endcapshield,3,new TGeoCombiTrans(
0801d201 1011 0, 0, zpos-kLittleZTrans, new TGeoRotation("",180,0,0) ) );
a275e8ba 1012 vM->AddNode(endcapshield,4,new TGeoCombiTrans(
0801d201 1013 0, 0,-zpos-kLittleZTrans, new TGeoRotation("",180,0,0) ) );
a275e8ba 1014
0801d201 1015 zpos = kHalfLengthCentral+2*kHalfLengthEndCap+kHalfLengthCone;
6f88a698 1016 vM->AddNode(vCone ,1, new TGeoTranslation(0, 0, zpos-kLittleZTrans));
1017
1018 vM->AddNode(vCone ,2, new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
c573c6ec 1019 new TGeoRotation("", 0, 0, 180) ));
1020
6f88a698 1021 vM->AddNode(vCone ,3, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
c573c6ec 1022 new TGeoRotation("", 0, 180, 0) ));
1023
6f88a698 1024 vM->AddNode(vCone ,4, new TGeoCombiTrans(0, 0, -zpos-kLittleZTrans,
c573c6ec 1025 new TGeoRotation("", 0, 180, 180) ));
a275e8ba 1026
0801d201 1027 zpos = kHalfLengthCentral+2*kHalfLengthEndCap+2*kHalfLengthCone
1028 + kHalfLengthRing;
1029 vM->AddNode(ring,1,new TGeoTranslation(0, 0, zpos-kLittleZTrans));
1030 vM->AddNode(ring,2,new TGeoTranslation(0, 0,-zpos-kLittleZTrans));
a275e8ba 1031
0b9c8a10 1032 for (Int_t i=0; i<4; i++) {
1033 Double_t thetaW = kThetaWing*(2*i+1) - angleWideWing/2.;
0801d201 1034 vM->AddNode(wing,2*i+1,new TGeoCombiTrans(0, 0, zpos-kLittleZTrans,
1035 new TGeoRotation("",thetaW,0,0) ) );
1036 vM->AddNode(wing,2*i+2,new TGeoCombiTrans(0, 0,-zpos-kLittleZTrans,
1037 new TGeoRotation("",thetaW,0,0) ) );
a275e8ba 1038 }
1039
1040 // Some debugging if requested
1041 if(GetDebug(1)){
1042 vM->PrintNodes();
1043 vM->InspectShape();
1044 }
1045
1046 // Finally put the entire shield in the mother volume
1047 moth->AddNode(vM,1,0);
1048
1049 return;
1050}
1051
1052//______________________________________________________________________
1053void AliITSv11GeometrySupport::CreateSPDThermalShape(
1054 Double_t ina, Double_t inb, Double_t inr,
1055 Double_t oua, Double_t oub, Double_t our,
43aefea7 1056 Double_t t, Double_t *x , Double_t *y ) const
a275e8ba 1057{
1058//
1059// Creates the proper sequence of X and Y coordinates to determine
1060// the base XTru polygon for the SPD thermal shapes
1061//
1062// Input:
1063// ina, inb : inner shape sides
1064// inr : inner radius
1065// oua, oub : outer shape sides
1066// our : outer radius
1067// t : theta angle
1068//
1069// Output:
1070// x, y : coordinate vectors [24]
1071//
1072// Created: 14 Nov 2007 Mario Sitta
1073// Updated: 11 Dec 2007 Mario Sitta
1074//
1075 Double_t xlocal[6],ylocal[6];
1076
1077 //Create the first inner quadrant (X > 0)
1078 FillSPDXtruShape(ina,inb,inr,t,xlocal,ylocal);
1079 for (Int_t i=0; i<6; i++) {
1080 x[i] = xlocal[i];
1081 y[i] = ylocal[i];
1082 }
1083
1084 // Then reflex on the second quadrant (X < 0)
1085 for (Int_t i=0; i<6; i++) {
1086 x[23-i] = -x[i];
1087 y[23-i] = y[i];
1088 }
1089
1090 // Now create the first outer quadrant (X > 0)
1091 FillSPDXtruShape(oua,oub,our,t,xlocal,ylocal);
1092 for (Int_t i=0; i<6; i++) {
1093 x[11-i] = xlocal[i];
1094 y[11-i] = ylocal[i];
1095 }
1096
1097 // Finally reflex on the second quadrant (X < 0)
1098 for (Int_t i=0; i<6; i++) {
1099 x[12+i] = -x[11-i];
1100 y[12+i] = y[11-i];
1101 }
1102
1103 return;
1104}
1105
1106//______________________________________________________________________
1107void AliITSv11GeometrySupport::CreateSPDOmegaShape(
21ea473f 1108 const Double_t *xin, const Double_t *yin, Double_t d,
1109 Double_t *x, Double_t *y)
a275e8ba 1110{
1111//
1112// Creates the proper sequence of X and Y coordinates to determine
1113// the SPD Omega XTru polygon
1114//
1115// Input:
1116// xin, yin : coordinates of the air volume
1117// d : Omega shape thickness
1118// t : theta angle
1119//
1120// Output:
1121// x, y : coordinate vectors [48]
1122//
1123// Created: 17 Nov 2007 Mario Sitta
1124// Updated: 11 Dec 2007 Mario Sitta
3d2705b6 1125// Updated: 20 Feb 2009 Mario Sitta New algorithm (the old one
1126// gives erroneous vertexes)
a275e8ba 1127//
a275e8ba 1128
3d2705b6 1129 // This vector contains the index of those points which coincide
1130 // with the corresponding points in the air shape
1131 Int_t indexAir2Omega[12] = {1, 2, 5, 6, 9, 10, 11, 15, 16, 19, 20, 23};
a275e8ba 1132
3d2705b6 1133 // First fill those vertexes corresponding to
1134 // the edges aligned to the air shape edges
1135 for (Int_t j=0; j<12; j++) {
1136 x[*(indexAir2Omega+j)] = xin[j];
1137 y[*(indexAir2Omega+j)] = yin[j];
1138 }
a275e8ba 1139
3d2705b6 1140 // Now get the coordinates of the first inner point
1141 PointFromParallelLines(x[23],y[23],x[1],y[1],d,x[0],y[0]);
a275e8ba 1142
3d2705b6 1143 // Knowing this, the second internal point can be determined
1144 InsidePoint(x[0],y[0],x[1],y[1],x[2],y[2],d,x[22],y[22]);
a275e8ba 1145
3d2705b6 1146 // The third point is now computable
1147 ReflectPoint(x[1],y[1],x[2],y[2],x[22],y[22],x[21],y[21]);
a275e8ba 1148
3d2705b6 1149 // Repeat this logic
1150 InsidePoint(x[21],y[21],x[20],y[20],x[19],y[19],-d,x[3],y[3]);
a275e8ba 1151
3d2705b6 1152 ReflectPoint(x[20],y[20],x[19],y[19],x[3],y[3],x[4],y[4]);
a275e8ba 1153
3d2705b6 1154 InsidePoint(x[4],y[4],x[5],y[5],x[6],y[6],d,x[18],y[18]);
a275e8ba 1155
3d2705b6 1156 ReflectPoint(x[5],y[5],x[6],y[6],x[18],y[18],x[17],y[17]);
a275e8ba 1157
3d2705b6 1158 InsidePoint(x[17],y[17],x[16],y[16],x[15],y[15],-d,x[7],y[7]);
a275e8ba 1159
3d2705b6 1160 ReflectPoint(x[16],y[16],x[15],y[15],x[7],y[7],x[8],y[8]);
a275e8ba 1161
3d2705b6 1162 InsidePoint(x[8],y[8],x[9],y[9],x[10],y[10],d,x[14],y[14]);
a275e8ba 1163
1164 // These need to be fixed explicitly
a275e8ba 1165 x[12] = x[11];
1166 y[12] = y[11] + d;
1167 x[13] = x[10] + d;
1168 y[13] = y[12];
1169
3d2705b6 1170 // Finally reflect on the negative side
a275e8ba 1171 for (Int_t i=0; i<24; i++) {
1172 x[24+i] = -x[23-i];
1173 y[24+i] = y[23-i];
1174 }
1175
1176 // Wow ! We've finished
1177 return;
172b0d90 1178}
a275e8ba 1179
172b0d90 1180//______________________________________________________________________
a275e8ba 1181void AliITSv11GeometrySupport::FillSPDXtruShape(Double_t a, Double_t b,
1182 Double_t r, Double_t t,
21ea473f 1183 Double_t *x, Double_t *y) const
a275e8ba 1184{
1185//
1186// Creates the partial sequence of X and Y coordinates to determine
1187// the lateral part of the SPD thermal shield
1188//
1189// Input:
1190// a, b : shape sides
1191// r : radius
1192// t : theta angle
1193//
1194// Output:
1195// x, y : coordinate vectors [6]
1196//
1197// Created: 14 Nov 2007 Mario Sitta
1198//
1199 x[0] = a/2;
1200 y[0] = r;
1201
1202 x[1] = x[0] + b * TMath::Cos(t/2);
1203 y[1] = y[0] - b * TMath::Sin(t/2);
1204
1205 x[2] = x[1] + a * TMath::Cos(t);
1206 y[2] = y[1] - a * TMath::Sin(t);
1207
1208 x[3] = x[2] + b * TMath::Cos(3*t/2);
1209 y[3] = y[2] - b * TMath::Sin(3*t/2);
1210
1211 x[4] = x[3] + a * TMath::Cos(2*t);
1212 y[4] = y[3] - a * TMath::Sin(2*t);
1213
1214 x[5] = x[4];
1215 y[5] = 0.;
1216
1217 return;
172b0d90 1218}
a275e8ba 1219
3d2705b6 1220//______________________________________________________________________
1221void AliITSv11GeometrySupport::PointFromParallelLines(Double_t x1, Double_t y1,
1222 Double_t x2, Double_t y2, Double_t d,
21ea473f 1223 Double_t &x, Double_t &y) const
3d2705b6 1224{
1225//
1226// Determines the X and Y of the first internal point of the Omega shape
1227// (i.e. the coordinates of a point given two parallel lines passing by
1228// two points and placed at a known distance)
1229//
1230// Input:
1231// x1, y1 : first point
1232// x2, y2 : second point
1233// d : distance between the two lines
1234//
1235// Output:
1236// x, y : coordinate of the point
1237//
1238// Created: 22 Feb 2009 Mario Sitta
1239//
1240//Begin_Html
1241/*
1242<img src="ITS/doc/PointFromParallelLines.gif">
1243*/
1244//End_Html
1245
1246 // The slope of the paralles lines at a distance d
1247 Double_t m;
1248
1249 // The parameters of the solving equation
1250 // a x^2 - 2 b x + c = 0
1251 Double_t a = (x1 - x2)*(x1 - x2) - d*d;
1252 Double_t b = (x1 - x2)*(y1 - y2);
1253 Double_t c = (y1 - y2)*(y1 - y2) - d*d;
1254
21ea473f 1255 // (delta4 is Delta/4 because we use the reduced formula)
1256 Double_t delta4 = b*b - a*c;
3d2705b6 1257
1258 // Compute the slope of the two parallel lines
1259 // (one of the two possible slopes, the one with the smaller
1260 // absolute value is needed)
21ea473f 1261 if (delta4 < 0) { // Should never happen with our data, but just to be sure
3d2705b6 1262 x = -1; // x is expected positive, so this flags an error
1263 return;
1264 } else
21ea473f 1265 m = (b + TMath::Sqrt(delta4))/a; // b is negative with our data
3d2705b6 1266
1267 // Finally compute the coordinates of the point
1268 x = x2 + (y1 - y2 - d)/m;
1269 y = y1 - d;
1270
1271 // Done
1272 return;
1273}
1274
1275//______________________________________________________________________
1276void AliITSv11GeometrySupport::ReflectPoint(Double_t x1, Double_t y1,
1277 Double_t x2, Double_t y2,
1278 Double_t x3, Double_t y3,
21ea473f 1279 Double_t &x, Double_t &y) const
3d2705b6 1280{
1281//
1282// Given two points (x1,y1) and (x2,y2), determines the point (x,y)
1283// lying on the line parallel to the line passing by these points,
1284// at a distance d and passing by the point (x3,y3), which is symmetric to
1285// the third point with respect to the axis of the segment delimited by
1286// the two first points.
1287//
1288// Input:
1289// x1, y1 : first point
1290// x2, y2 : second point
1291// x3, y3 : third point
1292// d : distance between the two lines
1293//
1294// Output:
1295// x, y : coordinate of the reflected point
1296//
1297// Created: 22 Feb 2009 Mario Sitta
1298//
1299//Begin_Html
1300/*
1301<img src="ITS/doc/ReflectPoint.gif">
1302*/
1303//End_Html
1304
1305 // The slope of the line passing by the first two points
1306 Double_t k = (y2 - y1)/(x2 - x1);
1307
1308 // The middle point of the segment 1-2
1309 Double_t xK = (x1 + x2)/2.;
1310 Double_t yK = (y1 + y2)/2.;
1311
1312 // The intercept between the axis of the segment 1-2 and the line
1313 // passing by 3 and parallel to the line passing by 1-2
1314 Double_t xH = (k*k*x3 + k*(yK - y3) + xK)/(k*k + 1);
1315 Double_t yH = k*(xH - x3) + y3;
1316
1317 // The point symmetric to 3 with respect to H
1318 x = 2*xH - x3;
1319 y = 2*yH - y3;
1320
1321 // Done
1322 return;
1323}
1324
172b0d90 1325//______________________________________________________________________
43aefea7 1326void AliITSv11GeometrySupport::SDDCone(TGeoVolume *moth,const TGeoManager *mgr)
7d6c23de 1327{
1328//
1329// Creates the SDD support cone and cylinder geometry as a
1330// volume assembly and adds it to the mother volume
1331// (part of this code is taken or anyway inspired to SDDCone method
1332// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
1333//
1334// Input:
1335// moth : the TGeoVolume owing the volume structure
1336// mgr : the GeoManager (default gGeoManager)
1337// Output:
1338//
1339// Created: ??? Bjorn S. Nilsen
1340// Updated: 18 Feb 2008 Mario Sitta
6b99a08f 1341// Updated: 25 Jul 2008 Mario Sitta SDDCarbonFiberCone simpler
96eb8210 1342// Updated: 10 Jun 2010 Mario Sitta Cables across cone holes added
7d6c23de 1343//
1344// Technical data are taken from: "Supporto Generale Settore SDD"
1345// (technical drawings ALR-0816/1-B), "Supporto Globale Settore SDD"
1346// (technical drawings ALR-0816/2A, ALR-0816/2B, ALR-0816/2C, ALR-0816/2D),
1347// private communication with B. Giraudo
1348
1349 // Dimensions of the Central cylinder and flanges
1350 const Double_t kCylinderHalfLength = (790.0/2)*fgkmm;
1351 const Double_t kCylinderInnerR = (210.0/2)*fgkmm;
1352 const Double_t kCylinderOuterR = (231.0/2)*fgkmm;
1353 const Double_t kFlangeHalfLength = ( 15.0/2)*fgkmm;
1354 const Double_t kFlangeInnerR = (210.5/2)*fgkmm;
1355 const Double_t kFlangeOuterR = (230.5/2)*fgkmm;
1356 const Double_t kInsertoHalfLength =
1357 kCylinderHalfLength - 2*kFlangeHalfLength;
1358// const Double_t kCFThickness = kFlangeInnerR - kCylinderInnerR;
1359 const Double_t kBoltDiameter = 6.0*fgkmm; // M6 screw
1360 const Double_t kBoltDepth = 6.0*fgkmm; // In the flange
1361 const Double_t kBoltRadius = (220.0/2)*fgkmm; // Radius in flange
1362 const Double_t kThetaBolt = 30.0*fgkDegree;
1363 const Int_t kNBolts = (Int_t)(360.0/kThetaBolt);
1364 // Dimensions of the Cone
1365 const Double_t kConeROutMin = (540.0/2)*fgkmm;
1366 const Double_t kConeROutMax = (560.0/2)*fgkmm;
3a299c65 1367 const Double_t kConeRCurv = 10.0*fgkmm; // Radius of curvature
7d6c23de 1368 const Double_t kConeRinMin = (210.0/2)*fgkmm;
6b99a08f 1369// const Double_t kConeRinMax = (216.0/2)*fgkmm;
7d6c23de 1370 const Double_t kConeRinCylinder = (231.0/2)*fgkmm;
3a299c65 1371 const Double_t kConeZCylinder = 192.0*fgkmm;
7d6c23de 1372 const Double_t kConeZOuterMilled = 23.0*fgkmm;
1373 const Double_t kConeDZin = 15.0*fgkmm; // ???
3a299c65 1374 const Double_t kConeThickness = 10.0*fgkmm; // Rohacell + Carb.Fib.
7d6c23de 1375 const Double_t kConeTheta = 45.0*fgkDegree; // SDD cone angle
1376 const Double_t kSinConeTheta =
1377 TMath::Sin(kConeTheta*TMath::DegToRad());
1378 const Double_t kCosConeTheta =
1379 TMath::Cos(kConeTheta*TMath::DegToRad());
1380 const Double_t kTanConeTheta =
1381 TMath::Tan(kConeTheta*TMath::DegToRad());
1382 // Dimensions of the Cone Inserts
96eb8210 1383 const Double_t kConeCFThickness = 1.5*fgkmm;//Carbon fiber thickness
7d6c23de 1384 // Dimensions of the Cone Holes
1385 const Double_t kHole1RMin = (450.0/2)*fgkmm;
3a299c65 1386 const Double_t kHole1RMax = (530.0/2)*fgkmm;
7d6c23de 1387 const Double_t kHole2RMin = (280.0/2)*fgkmm;
1388 const Double_t kHole2RMax = (375.0/2)*fgkmm;
1389 const Double_t kHole1Phi = 25.0*fgkDegree;
1390 const Double_t kHole2Phi = 50.0*fgkDegree;
1391 const Double_t kHole3RMin = 205.0*fgkmm;
1392 const Double_t kHole3DeltaR = 15*fgkmm;
1393 const Double_t kHole3Width = 30*fgkmm;
1394 const Int_t kNHole3 = 6 ;
1395 const Double_t kHole4RMin = 116.0*fgkmm;
1396 const Double_t kHole4DeltaR = 15*fgkmm;
3a299c65 1397 const Double_t kHole4Width = 30*fgkmm;
1398 // const Int_t kNHole4 = 3 ;
96eb8210 1399 // Fraction of materials in holes
1400 const Double_t kHolePlasticFrac = 0.55846;
1401 const Double_t kHoleCuFrac = 0.06319;
1402 const Double_t kHoleGlassFrac = 0.02652;
7d6c23de 1403
1404 // Local variables
1405 Double_t x, y, z, t, dza, rmin, rmax;
1406
1407
7d6c23de 1408 // Recover the needed materials
96eb8210 1409 TGeoMedium *medSDDcf = mgr->GetMedium("ITS_SDD C (M55J)$");
1410 TGeoMedium *medSDDair = mgr->GetMedium("ITS_SDD AIR$");
1411 TGeoMedium *medSDDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
1412 TGeoMedium *medSDDroh = mgr->GetMedium("ITS_ROHACELL$");
1413 TGeoMedium *medSDDss = mgr->GetMedium("ITS_INOX$");
1414 TGeoMedium *medSDDplast = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
1415 TGeoMedium *medSDDCu = mgr->GetMedium("ITS_COPPER$");
1416 TGeoMedium *medSDDglass = mgr->GetMedium("ITS_SDD OPTICFIB$");
7d6c23de 1417
1418 // First define the geometrical shapes
1419
1420 // Central cylinder with its internal foam and the lateral flanges:
1421 // a carbon fiber Tube which contains a rohacell Tube and two
1422 // stesalite Tube's
1423 TGeoTube *cylindershape = new TGeoTube(kCylinderInnerR,kCylinderOuterR,
1424 kCylinderHalfLength);
1425
1426 TGeoTube *insertoshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
1427 kInsertoHalfLength);
1428
1429 TGeoTube *flangeshape = new TGeoTube(kFlangeInnerR,kFlangeOuterR,
1430 kFlangeHalfLength);
1431
1432 // The flange bolt: it is a Tube
1433 TGeoTube *boltshape = new TGeoTube(0.0, 0.5*kBoltDiameter, 0.5*kBoltDepth);
1434
1435 // Debug if requested
1436 if (GetDebug(1)) {
1437 cylindershape->InspectShape();
1438 insertoshape->InspectShape();
1439 flangeshape->InspectShape();
1440 boltshape->InspectShape();
1441 }
1442
1443
1444 // We have the shapes: now create the real volumes
1445
1446 TGeoVolume *cfcylinder = new TGeoVolume("SDDCarbonFiberCylinder",
1447 cylindershape,medSDDcf);
1448 cfcylinder->SetVisibility(kTRUE);
1449 cfcylinder->SetLineColor(4); // Blue
1450 cfcylinder->SetLineWidth(1);
1451 cfcylinder->SetFillColor(cfcylinder->GetLineColor());
1452 cfcylinder->SetFillStyle(4000); // 0% transparent
1453
1454 TGeoVolume *foamcylinder = new TGeoVolume("SDDFoamCylinder",
1455 insertoshape,medSDDroh);
1456 foamcylinder->SetVisibility(kTRUE);
1457 foamcylinder->SetLineColor(3); // Green
1458 foamcylinder->SetLineWidth(1);
1459 foamcylinder->SetFillColor(foamcylinder->GetLineColor());
1460 foamcylinder->SetFillStyle(4050); // 50% transparent
1461
1462 TGeoVolume *flangecylinder = new TGeoVolume("SDDFlangeCylinder",
1463 flangeshape,medSDDste);
1464 flangecylinder->SetVisibility(kTRUE);
1465 flangecylinder->SetLineColor(2); // Red
1466 flangecylinder->SetLineWidth(1);
1467 flangecylinder->SetFillColor(flangecylinder->GetLineColor());
1468 flangecylinder->SetFillStyle(4050); // 50% transparent
1469
1470 TGeoVolume *bolt = new TGeoVolume("SDDFlangeBolt",boltshape,medSDDss);
1471 bolt->SetVisibility(kTRUE);
1472 bolt->SetLineColor(1); // Black
1473 bolt->SetLineWidth(1);
1474 bolt->SetFillColor(bolt->GetLineColor());
1475 bolt->SetFillStyle(4050); // 50% transparent
1476
1477 // Mount up the cylinder
1478 for(Int_t i=0; i<kNBolts; i++){
1479 t = kThetaBolt*i;
aa177c73 1480 x = kBoltRadius*CosD(t);
1481 y = kBoltRadius*SinD(t);
7d6c23de 1482 z = kFlangeHalfLength-kBoltDepth;
1483 flangecylinder->AddNode(bolt, i+1, new TGeoTranslation("",x,y,z));
1484 }
1485
1486 cfcylinder->AddNode(foamcylinder,1,0);
1487 cfcylinder->AddNode(flangecylinder,1,
1488 new TGeoTranslation(0, 0, kInsertoHalfLength+kFlangeHalfLength));
1489 cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
1490 0, 0, -kInsertoHalfLength-kFlangeHalfLength,
1491 new TGeoRotation("",0,180,0) ) );
1492
1493
1494 // SDD Support Cone with its internal inserts: a carbon fiber Pcon
1495 // with holes which contains a stesalite Pcon which on turn contains a
1496 // rohacell Pcon
1497
1498 dza = kConeThickness/kSinConeTheta-(kConeROutMax-kConeROutMin)/kTanConeTheta;
1499
6b99a08f 1500 TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 10);
7d6c23de 1501
1502 coneshape->Z(0) = 0.0;
1503 coneshape->Rmin(0) = kConeROutMin;
1504 coneshape->Rmax(0) = kConeROutMax;
1505
1506 coneshape->Z(1) = kConeZOuterMilled - dza;
1507 coneshape->Rmin(1) = coneshape->GetRmin(0);
1508 coneshape->Rmax(1) = coneshape->GetRmax(0);
1509
1510 coneshape->Z(2) = kConeZOuterMilled;
1511 coneshape->Rmax(2) = coneshape->GetRmax(0);
1512
1513 RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(1),
1514 coneshape->GetRmin(1),kConeTheta,z,rmin);
1515 coneshape->Z(3) = z;
1516 coneshape->Rmin(3) = rmin;
1517
1518 coneshape->Rmin(2) = RminFrom2Points(coneshape,3,1,coneshape->GetZ(2));
1519
1520 RadiusOfCurvature(kConeRCurv,0.,coneshape->GetZ(2),
1521 coneshape->GetRmax(2),kConeTheta,z,rmax);
1522 coneshape->Z(4) = z;
1523 coneshape->Rmax(4) = rmax;
1524 coneshape->Rmin(4) = RminFromZpCone(coneshape,3,kConeTheta,
1525 coneshape->GetZ(4),0.0);
1526
1527 coneshape->Rmax(3) = RmaxFrom2Points(coneshape,4,2,coneshape->GetZ(3));
1528
6b99a08f 1529 coneshape->Z(6) = kConeZCylinder - kConeDZin;
1530
1531 RadiusOfCurvature(kConeRCurv,90.0,coneshape->GetZ(6),0.0,
1532 90.0-kConeTheta,z,rmin);
1533 coneshape->Z(5) = z;
1534 coneshape->Rmin(5) = RminFromZpCone(coneshape,3,kConeTheta,z);
1535 coneshape->Rmax(5) = RmaxFromZpCone(coneshape,4,kConeTheta,z);
1536
1537 RadiusOfCurvature(kConeRCurv,90.-kConeTheta,
1538 0.0,coneshape->Rmin(5),90.0,z,rmin);
1539 coneshape->Rmin(6) = rmin;
1540 coneshape->Rmax(6) = RmaxFromZpCone(coneshape,4,kConeTheta,
1541 coneshape->GetZ(6));
1542
1543 coneshape->Z(7) = coneshape->GetZ(6);
7d6c23de 1544 coneshape->Rmin(7) = kConeRinMin;
6b99a08f 1545 coneshape->Rmax(7) = coneshape->GetRmax(6);
7d6c23de 1546
1547 coneshape->Rmin(8) = kConeRinMin;
1548
6b99a08f 1549 RadiusOfCurvature(kConeRCurv,90.0,kConeZCylinder,kConeRinCylinder,
1550 90.0-kConeTheta,z,rmax);
1551 coneshape->Z(8) = z;
7d6c23de 1552 coneshape->Rmax(8) = rmax;
7d6c23de 1553
1554 coneshape->Z(9) = kConeZCylinder;
1555 coneshape->Rmin(9) = kConeRinMin;
6b99a08f 1556 coneshape->Rmax(9) = kConeRinCylinder;
7d6c23de 1557
7d6c23de 1558
1559 // SDD Cone Insert: another Pcon
1560 Double_t x0, y0, x1, y1, x2, y2;
1561 TGeoPcon *coneinsertshape = new TGeoPcon(0.0, 360.0, 9);
1562
1563 coneinsertshape->Z(0) = coneshape->GetZ(0) + kConeCFThickness;
1564 coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kConeCFThickness;
1565 coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kConeCFThickness;
1566
1567 x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
1568 x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
1569 x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
1570 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1571 coneinsertshape->Z(1) = z;
1572 coneinsertshape->Rmin(1) = rmin;
1573 coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0);
1574
1575 x0 = coneshape->GetZ(1); y0 = coneshape->GetRmax(1);
1576 x1 = coneshape->GetZ(2); y1 = coneshape->GetRmax(2);
1577 x2 = coneshape->GetZ(3); y2 = coneshape->GetRmax(3);
1578 InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
1579 coneinsertshape->Z(2) = z;
1580 coneinsertshape->Rmax(2) = rmax;
1581
1582 x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
1583 x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
1584 x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
1585 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1586 coneinsertshape->Z(3) = z;
1587 coneinsertshape->Rmin(3) = rmin;
1588
1589 x0 = coneinsertshape->GetZ(1); y0 = coneinsertshape->GetRmin(1);
1590 x1 = coneinsertshape->GetZ(3); y1 = coneinsertshape->GetRmin(3);
1591 coneinsertshape->Rmin(2) = Yfrom2Points(x0, y0, x1, y1,
1592 coneinsertshape->Z(2));
1593
1594 x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
1595 x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
1596 x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
1597 InsidePoint(x0, y0, x1, y1, x2, y2, -kConeCFThickness, z, rmax);
1598 coneinsertshape->Z(4) = z;
1599 coneinsertshape->Rmax(4) = rmax;
1600
1601 x0 = coneinsertshape->GetZ(2); y0 = coneinsertshape->GetRmax(2);
1602 x1 = coneinsertshape->GetZ(4); y1 = coneinsertshape->GetRmax(4);
1603 coneinsertshape->Rmax(3) = Yfrom2Points(x0, y0, x1, y1,
1604 coneinsertshape->Z(3));
1605
1606 x0 = coneshape->GetZ(4); y0 = coneshape->GetRmin(4);
1607 x1 = coneshape->GetZ(5); y1 = coneshape->GetRmin(5);
1608 x2 = coneshape->GetZ(6); y2 = coneshape->GetRmin(6);
1609 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1610 coneinsertshape->Z(5) = z;
1611 coneinsertshape->Rmin(5) = rmin;
1612 coneinsertshape->Rmax(5) = coneinsertshape->GetRmax(4) -
1613 kTanConeTheta*(coneinsertshape->GetZ(5) - coneinsertshape->GetZ(4));
1614
1615 x0 = coneinsertshape->GetZ(3); y0 = coneinsertshape->GetRmin(3);
1616 x1 = coneinsertshape->GetZ(5); y1 = coneinsertshape->GetRmin(5);
1617 coneinsertshape->Rmin(4) = Yfrom2Points(x0, y0, x1, y1,
1618 coneinsertshape->Z(4));
1619
1620 x0 = coneshape->GetZ(5); y0 = coneshape->GetRmin(5);
1621 x1 = coneshape->GetZ(6); y1 = coneshape->GetRmin(6);
1622 x2 = coneshape->GetZ(7); y2 = coneshape->GetRmin(7);
1623 InsidePoint(x0, y0, x1, y1, x2, y2, kConeCFThickness, z, rmin);
1624 coneinsertshape->Z(6) = z;
1625 coneinsertshape->Rmin(6) = rmin;
1626 coneinsertshape->Rmax(6) = coneinsertshape->GetRmax(4) -
1627 kTanConeTheta*(coneinsertshape->GetZ(6) - coneinsertshape->GetZ(4));
1628
1629 coneinsertshape->Z(7) = coneinsertshape->GetZ(6);
1630 coneinsertshape->Rmin(7) = coneshape->GetRmin(7) + kConeCFThickness;
1631 coneinsertshape->Rmax(7) = coneinsertshape->GetRmax(6);
1632
1633 coneinsertshape->Z(8) = coneshape->GetZ(9) - kConeCFThickness;
1634 coneinsertshape->Rmin(8) = coneinsertshape->GetRmin(7);
1635 coneinsertshape->Rmax(8) = coneinsertshape->GetRmax(4) -
1636 kTanConeTheta*(coneinsertshape->GetZ(8) - coneinsertshape->GetZ(4));
1637
1638 // SDD Cone Foam: another Pcon
1639 TGeoPcon *conefoamshape = new TGeoPcon(0.0, 360.0, 4);
1640
1641 RadiusOfCurvature(kConeRCurv+kConeCFThickness,0.0,coneinsertshape->GetZ(1),
1642 coneinsertshape->GetRmin(1),kConeTheta,z,rmin);
1643
1644 conefoamshape->Z(0) = z;
1645 conefoamshape->Rmin(0) = rmin;
1646 conefoamshape->Rmax(0) = conefoamshape->GetRmin(0);
1647
1648 conefoamshape->Z(1) = conefoamshape->GetZ(0)+
1649 (kConeThickness-2.0*kConeCFThickness)/kSinConeTheta;
1650 conefoamshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1651 conefoamshape->GetZ(1));
1652 conefoamshape->Rmax(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1653 conefoamshape->GetZ(1));
1654
1655 conefoamshape->Z(2) = coneshape->GetZ(5)-kConeCFThickness;
1656 conefoamshape->Rmin(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1657 conefoamshape->GetZ(2));
1658 conefoamshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1659 conefoamshape->GetZ(2));
1660
1661 conefoamshape->Z(3) = coneinsertshape->GetZ(5)+
1662 (kConeThickness-2.0*kConeCFThickness)*kCosConeTheta;
1663 conefoamshape->Rmax(3) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1664 conefoamshape->GetZ(3));
1665 conefoamshape->Rmin(3) = conefoamshape->GetRmax(3);
1666
1667 // SDD Cone Holes: Pcon's
a30e33f0 1668 // A single hole volume gives an overlap with coneinsert, so
1669 // three contiguous volumes are created: one to be put in the cone foam
1670 // and two in the cone carbon fiber envelope
7d6c23de 1671 TGeoPcon *hole1shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1672
1673 hole1shape->Rmin(0) = kHole1RMax;
1674 hole1shape->Rmax(0) = hole1shape->GetRmin(0);
a30e33f0 1675 hole1shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1676 hole1shape->GetRmin(0));
1677
1678 hole1shape->Rmax(1) = hole1shape->GetRmax(0);
a30e33f0 1679 hole1shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1680 hole1shape->GetRmax(1));
a30e33f0 1681 hole1shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1682 hole1shape->GetZ(1));
1683
1684 hole1shape->Rmin(2) = kHole1RMin;
a30e33f0 1685 hole1shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1686 hole1shape->GetRmin(2));
a30e33f0 1687 hole1shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1688 hole1shape->GetZ(2));
1689
1690 hole1shape->Rmin(3) = hole1shape->GetRmin(2);
1691 hole1shape->Rmax(3) = hole1shape->GetRmin(3);
a30e33f0 1692 hole1shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1693 hole1shape->GetRmax(3));
1694
a30e33f0 1695 TGeoPcon *hole11shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1696
1697 hole11shape->Rmin(0) = kHole1RMax;
1698 hole11shape->Rmax(0) = hole11shape->GetRmin(0);
1699 hole11shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1700 hole11shape->GetRmin(0));
1701
1702 hole11shape->Rmax(1) = hole11shape->GetRmax(0);
1703 hole11shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1704 hole11shape->GetRmax(1));
1705 hole11shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1706 hole11shape->GetZ(1));
1707
1708 hole11shape->Rmin(2) = kHole1RMin;
1709 hole11shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1710 hole11shape->GetRmin(2));
1711 hole11shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1712 hole11shape->GetZ(2));
1713
1714 hole11shape->Rmin(3) = hole11shape->GetRmin(2);
1715 hole11shape->Rmax(3) = hole11shape->GetRmin(3);
1716 hole11shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1717 hole11shape->GetRmax(3));
1718
1719 TGeoPcon *hole12shape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1720
1721 hole12shape->Rmin(0) = kHole1RMax;
1722 hole12shape->Rmax(0) = hole12shape->GetRmin(0);
1723 hole12shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1724 hole12shape->GetRmin(0));
1725
1726 hole12shape->Rmax(1) = hole12shape->GetRmax(0);
1727 hole12shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1728 hole12shape->GetRmax(1));
1729 hole12shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1730 hole12shape->GetZ(1));
1731
1732 hole12shape->Rmin(2) = kHole1RMin;
1733 hole12shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1734 hole12shape->GetRmin(2));
1735 hole12shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1736 hole12shape->GetZ(2));
1737
1738 hole12shape->Rmin(3) = hole12shape->GetRmin(2);
1739 hole12shape->Rmax(3) = hole12shape->GetRmin(3);
1740 hole12shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1741 hole12shape->GetRmax(3));
1742
1743 //
7d6c23de 1744 TGeoPcon *hole2shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1745
1746 hole2shape->Rmin(0) = kHole2RMax;
1747 hole2shape->Rmax(0) = hole2shape->GetRmin(0);
a30e33f0 1748 hole2shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1749 hole2shape->GetRmin(0));
1750
1751 hole2shape->Rmax(1) = hole2shape->GetRmax(0);
a30e33f0 1752 hole2shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1753 hole2shape->GetRmax(1));
a30e33f0 1754 hole2shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1755 hole2shape->GetZ(1));
1756
1757 hole2shape->Rmin(2) = kHole2RMin;
a30e33f0 1758 hole2shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1759 hole2shape->GetRmin(2));
a30e33f0 1760 hole2shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1761 hole2shape->GetZ(2));
1762
1763 hole2shape->Rmin(3) = hole2shape->GetRmin(2);
1764 hole2shape->Rmax(3) = hole2shape->GetRmin(3);
a30e33f0 1765 hole2shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1766 hole2shape->GetRmax(3));
1767
a30e33f0 1768 TGeoPcon *hole21shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1769
1770 hole21shape->Rmin(0) = kHole2RMax;
1771 hole21shape->Rmax(0) = hole21shape->GetRmin(0);
1772 hole21shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1773 hole21shape->GetRmin(0));
1774
1775 hole21shape->Rmax(1) = hole21shape->GetRmax(0);
1776 hole21shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1777 hole21shape->GetRmax(1));
1778 hole21shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1779 hole21shape->GetZ(1));
1780
1781 hole21shape->Rmin(2) = kHole2RMin;
1782 hole21shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1783 hole21shape->GetRmin(2));
1784 hole21shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1785 hole21shape->GetZ(2));
1786
1787 hole21shape->Rmin(3) = hole21shape->GetRmin(2);
1788 hole21shape->Rmax(3) = hole21shape->GetRmin(3);
1789 hole21shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1790 hole21shape->GetRmax(3));
1791
1792 TGeoPcon *hole22shape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1793
1794 hole22shape->Rmin(0) = kHole2RMax;
1795 hole22shape->Rmax(0) = hole22shape->GetRmin(0);
1796 hole22shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1797 hole22shape->GetRmin(0));
1798
1799 hole22shape->Rmax(1) = hole22shape->GetRmax(0);
1800 hole22shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1801 hole22shape->GetRmax(1));
1802 hole22shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1803 hole22shape->GetZ(1));
1804
1805 hole22shape->Rmin(2) = kHole2RMin;
1806 hole22shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1807 hole22shape->GetRmin(2));
1808 hole22shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1809 hole22shape->GetZ(2));
1810
1811 hole22shape->Rmin(3) = hole22shape->GetRmin(2);
1812 hole22shape->Rmax(3) = hole22shape->GetRmin(3);
1813 hole22shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1814 hole22shape->GetRmax(3));
1815
1816 //
7d6c23de 1817 Double_t holePhi;
1818 holePhi = (kHole3Width/kHole3RMin)*TMath::RadToDeg();
1819
1820 TGeoPcon *hole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1821
1822 hole3shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1823 hole3shape->Rmax(0) = hole3shape->GetRmin(0);
a30e33f0 1824 hole3shape->Z(0) = ZFromRminpCone(conefoamshape,0,kConeTheta,
7d6c23de 1825 hole3shape->GetRmin(0));
1826
1827 hole3shape->Rmax(1) = hole3shape->GetRmax(0);
a30e33f0 1828 hole3shape->Z(1) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1829 hole3shape->GetRmax(1));
a30e33f0 1830 hole3shape->Rmin(1) = RminFromZpCone(conefoamshape,1,kConeTheta,
7d6c23de 1831 hole3shape->GetZ(1));
1832
1833 hole3shape->Rmin(2) = kHole3RMin;
a30e33f0 1834 hole3shape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
7d6c23de 1835 hole3shape->GetRmin(2));
a30e33f0 1836 hole3shape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
7d6c23de 1837 hole3shape->GetZ(2));
1838
1839 hole3shape->Rmin(3) = hole3shape->GetRmin(2);
1840 hole3shape->Rmax(3) = hole3shape->GetRmin(3);
a30e33f0 1841 hole3shape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
7d6c23de 1842 hole3shape->GetRmax(3));
1843
a30e33f0 1844 TGeoPcon *hole31shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1845
1846 hole31shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1847 hole31shape->Rmax(0) = hole31shape->GetRmin(0);
1848 hole31shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1849 hole31shape->GetRmin(0));
1850
1851 hole31shape->Rmax(1) = hole31shape->GetRmax(0);
1852 hole31shape->Z(1) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1853 hole31shape->GetRmax(1));
1854 hole31shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1855 hole31shape->GetZ(1));
1856
1857 hole31shape->Rmin(2) = kHole3RMin;
1858 hole31shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1859 hole31shape->GetRmin(2));
1860 hole31shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,kConeTheta,
1861 hole31shape->GetZ(2));
1862
1863 hole31shape->Rmin(3) = hole31shape->GetRmin(2);
1864 hole31shape->Rmax(3) = hole31shape->GetRmin(3);
1865 hole31shape->Z(3) = ZFromRminpCone(coneinsertshape,3,kConeTheta,
1866 hole31shape->GetRmax(3));
1867
1868 TGeoPcon *hole32shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1869
1870 hole32shape->Rmin(0) = kHole3RMin + kHole3DeltaR;
1871 hole32shape->Rmax(0) = hole32shape->GetRmin(0);
1872 hole32shape->Z(0) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1873 hole32shape->GetRmin(0));
1874
1875 hole32shape->Rmax(1) = hole32shape->GetRmax(0);
1876 hole32shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1877 hole32shape->GetRmax(1));
1878 hole32shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,4,kConeTheta,
1879 hole32shape->GetZ(1));
1880
1881 hole32shape->Rmin(2) = kHole3RMin;
1882 hole32shape->Z(2) = ZFromRmaxpCone(coneinsertshape,4,kConeTheta,
1883 hole32shape->GetRmin(2));
1884 hole32shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1885 hole32shape->GetZ(2));
1886
1887 hole32shape->Rmin(3) = hole32shape->GetRmin(2);
1888 hole32shape->Rmax(3) = hole32shape->GetRmin(3);
1889 hole32shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1890 hole32shape->GetRmax(3));
1891
1892 //
3a299c65 1893 holePhi = (kHole4Width/kHole4RMin)*TMath::RadToDeg();
1894
7d6c23de 1895 TGeoPcon *hole4shape = new TGeoPcon(-holePhi/2., holePhi, 4);
1896
1897 hole4shape->Rmin(0) = kHole4RMin + kHole4DeltaR;
1898 hole4shape->Rmax(0) = hole4shape->GetRmin(0);
1899 hole4shape->Z(0) = ZFromRminpCone(coneshape,3,kConeTheta,
1900 hole4shape->GetRmin(0));
1901
1902 hole4shape->Rmax(1) = hole4shape->GetRmax(0);
1903 hole4shape->Z(1) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1904 hole4shape->GetRmax(1));
1905 hole4shape->Rmin(1) = RminFromZpCone(coneshape,3,kConeTheta,
1906 hole4shape->GetZ(1));
1907
1908 hole4shape->Rmin(2) = kHole4RMin;
1909 hole4shape->Z(2) = ZFromRminpCone(coneshape,3,kConeTheta,
1910 hole4shape->GetRmin(2));
1911 hole4shape->Rmax(2) = RmaxFromZpCone(coneshape,4,kConeTheta,
1912 hole4shape->GetZ(2));
1913
1914 hole4shape->Rmin(3) = hole4shape->GetRmin(2);
1915 hole4shape->Rmax(3) = hole4shape->GetRmin(3);
1916 hole4shape->Z(3) = ZFromRmaxpCone(coneshape,4,kConeTheta,
1917 hole4shape->GetRmax(3));
1918
96eb8210 1919 // Cables to be put inside the holes: Pcon's
1920 // (fractions are manually computed from AliITSv11GeometrySDD::SDDCables
1921 TGeoPcon *hole1plastshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1922
1923 hole1plastshape->Rmin(0) = hole1shape->GetRmin(0);
1924 hole1plastshape->Rmax(0) = hole1shape->GetRmax(0);
1925 hole1plastshape->Z(0) = hole1shape->GetZ(0);
1926
1927 hole1plastshape->Rmin(1) = hole1shape->GetRmin(1);
1928 hole1plastshape->Rmax(1) = hole1shape->GetRmax(1);
1929 hole1plastshape->Z(1) = hole1shape->GetZ(1);
1930
1931 dza = hole1plastshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHolePlasticFrac;
1932
1933 hole1plastshape->Rmin(2) = dza;
1934 hole1plastshape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1935 hole1plastshape->GetRmin(2));
1936 hole1plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
1937 hole1plastshape->GetZ(2));
1938
1939 hole1plastshape->Rmin(3) = hole1plastshape->GetRmin(2);
1940 hole1plastshape->Rmax(3) = hole1plastshape->GetRmin(3);
1941 hole1plastshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1942 hole1plastshape->GetRmax(3));
1943
1944 TGeoPcon *hole1Cushape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1945
1946 hole1Cushape->Rmin(0) = hole1plastshape->GetRmin(2);
1947 hole1Cushape->Rmax(0) = hole1Cushape->GetRmin(0);
1948 hole1Cushape->Z(0) = hole1plastshape->GetZ(2);
1949
1950 dza = hole1Cushape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleCuFrac;
1951
1952 hole1Cushape->Rmin(1) = dza;
1953 hole1Cushape->Rmax(1) = hole1Cushape->GetRmax(0);
1954 hole1Cushape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1955 hole1Cushape->GetRmin(1));
1956
1957 hole1Cushape->Rmax(2) = hole1Cushape->GetRmax(0);
1958 hole1Cushape->Rmin(2) = hole1Cushape->GetRmin(1);
1959 hole1Cushape->Z(2) = hole1plastshape->GetZ(3);
1960
1961 hole1Cushape->Rmin(3) = hole1Cushape->GetRmin(1);
1962 hole1Cushape->Rmax(3) = hole1Cushape->GetRmin(3);
1963 hole1Cushape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1964 hole1Cushape->GetRmax(3));
1965
1966 TGeoPcon *hole1glassshape = new TGeoPcon(-kHole1Phi/2., kHole1Phi, 4);
1967
1968 hole1glassshape->Rmin(0) = hole1Cushape->GetRmin(1);
1969 hole1glassshape->Rmax(0) = hole1glassshape->GetRmin(0);
1970 hole1glassshape->Z(0) = hole1Cushape->GetZ(1);
1971
1972 dza = hole1glassshape->GetRmax(0) - (kHole1RMax-kHole1RMin)*kHoleGlassFrac;
1973
1974 hole1glassshape->Rmin(1) = dza;
1975 hole1glassshape->Rmax(1) = hole1glassshape->GetRmax(0);
1976 hole1glassshape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
1977 hole1glassshape->GetRmin(1));
1978
1979 hole1glassshape->Rmax(2) = hole1glassshape->GetRmax(0);
1980 hole1glassshape->Rmin(2) = hole1glassshape->GetRmin(1);
1981 hole1glassshape->Z(2) = hole1Cushape->GetZ(3);
1982
1983 hole1glassshape->Rmin(3) = hole1glassshape->GetRmin(1);
1984 hole1glassshape->Rmax(3) = hole1glassshape->GetRmin(3);
1985 hole1glassshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
1986 hole1glassshape->GetRmax(3));
1987 //
1988 TGeoPcon *hole2plastshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
1989
1990 hole2plastshape->Rmin(0) = hole2shape->GetRmin(0);
1991 hole2plastshape->Rmax(0) = hole2shape->GetRmax(0);
1992 hole2plastshape->Z(0) = hole2shape->GetZ(0);
1993
1994 hole2plastshape->Rmin(1) = hole2shape->GetRmin(1);
1995 hole2plastshape->Rmax(1) = hole2shape->GetRmax(1);
1996 hole2plastshape->Z(1) = hole2shape->GetZ(1);
1997
1998 dza = hole2plastshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHolePlasticFrac;
1999
2000 hole2plastshape->Rmin(2) = dza;
2001 hole2plastshape->Z(2) = ZFromRminpCone(conefoamshape,1,kConeTheta,
2002 hole2plastshape->GetRmin(2));
2003 hole2plastshape->Rmax(2) = RmaxFromZpCone(conefoamshape,3,kConeTheta,
2004 hole2plastshape->GetZ(2));
2005
2006 hole2plastshape->Rmin(3) = hole2plastshape->GetRmin(2);
2007 hole2plastshape->Rmax(3) = hole2plastshape->GetRmin(3);
2008 hole2plastshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
2009 hole2plastshape->GetRmax(3));
2010
2011 TGeoPcon *hole2Cushape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
2012
2013 hole2Cushape->Rmin(0) = hole2plastshape->GetRmin(2);
2014 hole2Cushape->Rmax(0) = hole2Cushape->GetRmin(0);
2015 hole2Cushape->Z(0) = hole2plastshape->GetZ(2);
2016
2017 dza = hole2Cushape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleCuFrac;
2018
2019 hole2Cushape->Rmin(1) = dza;
2020 hole2Cushape->Rmax(1) = hole2Cushape->GetRmax(0);
2021 hole2Cushape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
2022 hole2Cushape->GetRmin(1));
2023
2024 hole2Cushape->Rmax(2) = hole2Cushape->GetRmax(0);
2025 hole2Cushape->Rmin(2) = hole2Cushape->GetRmin(1);
2026 hole2Cushape->Z(2) = hole2plastshape->GetZ(3);
2027
2028 hole2Cushape->Rmin(3) = hole2Cushape->GetRmin(1);
2029 hole2Cushape->Rmax(3) = hole2Cushape->GetRmin(3);
2030 hole2Cushape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
2031 hole2Cushape->GetRmax(3));
2032
2033 TGeoPcon *hole2glassshape = new TGeoPcon(-kHole2Phi/2., kHole2Phi, 4);
2034
2035 hole2glassshape->Rmin(0) = hole2Cushape->GetRmin(1);
2036 hole2glassshape->Rmax(0) = hole2glassshape->GetRmin(0);
2037 hole2glassshape->Z(0) = hole2Cushape->GetZ(1);
2038
2039 dza = hole2glassshape->GetRmax(0) - (kHole2RMax-kHole2RMin)*kHoleGlassFrac;
2040
2041 hole2glassshape->Rmin(1) = dza;
2042 hole2glassshape->Rmax(1) = hole2glassshape->GetRmax(0);
2043 hole2glassshape->Z(1) = ZFromRminpCone(conefoamshape,1,kConeTheta,
2044 hole2glassshape->GetRmin(1));
2045
2046 hole2glassshape->Rmax(2) = hole2glassshape->GetRmax(0);
2047 hole2glassshape->Rmin(2) = hole2glassshape->GetRmin(1);
2048 hole2glassshape->Z(2) = hole2Cushape->GetZ(3);
2049
2050 hole2glassshape->Rmin(3) = hole2glassshape->GetRmin(1);
2051 hole2glassshape->Rmax(3) = hole2glassshape->GetRmin(3);
2052 hole2glassshape->Z(3) = ZFromRmaxpCone(conefoamshape,3,kConeTheta,
2053 hole2glassshape->GetRmax(3));
2054
2055
7d6c23de 2056 // Debug if requested
2057 if (GetDebug(1)) {
2058 coneshape->InspectShape();
2059 coneinsertshape->InspectShape();
2060 conefoamshape->InspectShape();
2061 hole1shape->InspectShape();
2062 hole2shape->InspectShape();
a30e33f0 2063 hole3shape->InspectShape();
2064 hole4shape->InspectShape();
7d6c23de 2065 }
2066
2067
2068 // We have the shapes: now create the real volumes
2069
2070 TGeoVolume *cfcone = new TGeoVolume("SDDCarbonFiberCone",
2071 coneshape,medSDDcf);
2072 cfcone->SetVisibility(kTRUE);
2073 cfcone->SetLineColor(4); // Blue
2074 cfcone->SetLineWidth(1);
2075 cfcone->SetFillColor(cfcone->GetLineColor());
2076 cfcone->SetFillStyle(4000); // 0% transparent
2077
2078 TGeoVolume *cfconeinsert = new TGeoVolume("SDDCarbonFiberConeInsert",
2079 coneinsertshape,medSDDste);
2080 cfconeinsert->SetVisibility(kTRUE);
2081 cfconeinsert->SetLineColor(2); // Red
2082 cfconeinsert->SetLineWidth(1);
2083 cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
2084 cfconeinsert->SetFillStyle(4050); // 50% transparent
2085
2086 TGeoVolume *cfconefoam = new TGeoVolume("SDDCarbonFiberConeFoam",
2087 conefoamshape,medSDDroh);
2088 cfconefoam->SetVisibility(kTRUE);
2089 cfconefoam->SetLineColor(7); // Light blue
2090 cfconefoam->SetLineWidth(1);
2091 cfconefoam->SetFillColor(cfconefoam->GetLineColor());
2092 cfconefoam->SetFillStyle(4050); // 50% transparent
2093
2094 TGeoVolume *hole1 = new TGeoVolume("SDDCableHole1",
2095 hole1shape,medSDDair);
2096 hole1->SetVisibility(kTRUE);
2097 hole1->SetLineColor(5); // Yellow
2098 hole1->SetLineWidth(1);
2099 hole1->SetFillColor(hole1->GetLineColor());
2100 hole1->SetFillStyle(4090); // 90% transparent
2101
a30e33f0 2102 TGeoVolume *hole11 = new TGeoVolume("SDDCableHole11",
2103 hole11shape,medSDDair);
2104 hole11->SetVisibility(kTRUE);
2105 hole11->SetLineColor(5); // Yellow
2106 hole11->SetLineWidth(1);
2107 hole11->SetFillColor(hole11->GetLineColor());
2108 hole11->SetFillStyle(4090); // 90% transparent
2109
2110 TGeoVolume *hole12 = new TGeoVolume("SDDCableHole12",
2111 hole12shape,medSDDair);
2112 hole12->SetVisibility(kTRUE);
2113 hole12->SetLineColor(5); // Yellow
2114 hole12->SetLineWidth(1);
2115 hole12->SetFillColor(hole12->GetLineColor());
2116 hole12->SetFillStyle(4090); // 90% transparent
2117
96eb8210 2118 TGeoVolume *hole1plast = new TGeoVolume("SDDCableHole1Plast",
2119 hole1plastshape,medSDDplast);
2120 hole1plast->SetVisibility(kTRUE);
2121 hole1plast->SetLineColor(kBlue);
2122 hole1plast->SetLineWidth(1);
2123 hole1plast->SetFillColor(hole1plast->GetLineColor());
2124 hole1plast->SetFillStyle(4090); // 90% transparent
2125
2126 TGeoVolume *hole1Cu = new TGeoVolume("SDDCableHole1Cu",
2127 hole1Cushape,medSDDCu);
2128 hole1Cu->SetVisibility(kTRUE);
2129 hole1Cu->SetLineColor(kRed);
2130 hole1Cu->SetLineWidth(1);
2131 hole1Cu->SetFillColor(hole1Cu->GetLineColor());
2132 hole1Cu->SetFillStyle(4090); // 90% transparent
2133
2134 TGeoVolume *hole1glass = new TGeoVolume("SDDCableHole1glass",
2135 hole1glassshape,medSDDglass);
2136 hole1glass->SetVisibility(kTRUE);
2137 hole1glass->SetLineColor(kGreen);
2138 hole1glass->SetLineWidth(1);
2139 hole1glass->SetFillColor(hole1glass->GetLineColor());
2140 hole1glass->SetFillStyle(4090); // 90% transparent
2141
7d6c23de 2142 TGeoVolume *hole2 = new TGeoVolume("SDDCableHole2",
2143 hole2shape,medSDDair);
2144 hole2->SetVisibility(kTRUE);
2145 hole2->SetLineColor(5); // Yellow
2146 hole2->SetLineWidth(1);
2147 hole2->SetFillColor(hole2->GetLineColor());
2148 hole2->SetFillStyle(4090); // 90% transparent
2149
a30e33f0 2150 TGeoVolume *hole21 = new TGeoVolume("SDDCableHole21",
2151 hole21shape,medSDDair);
2152 hole21->SetVisibility(kTRUE);
2153 hole21->SetLineColor(5); // Yellow
2154 hole21->SetLineWidth(1);
2155 hole21->SetFillColor(hole21->GetLineColor());
2156 hole21->SetFillStyle(4090); // 90% transparent
2157
2158 TGeoVolume *hole22 = new TGeoVolume("SDDCableHole22",
2159 hole22shape,medSDDair);
2160 hole22->SetVisibility(kTRUE);
2161 hole22->SetLineColor(5); // Yellow
2162 hole22->SetLineWidth(1);
2163 hole22->SetFillColor(hole22->GetLineColor());
2164 hole22->SetFillStyle(4090); // 90% transparent
2165
96eb8210 2166 TGeoVolume *hole2plast = new TGeoVolume("SDDCableHole2Plast",
2167 hole2plastshape,medSDDplast);
2168 hole2plast->SetVisibility(kTRUE);
2169 hole2plast->SetLineColor(kBlue);
2170 hole2plast->SetLineWidth(1);
2171 hole2plast->SetFillColor(hole2plast->GetLineColor());
2172 hole2plast->SetFillStyle(4090); // 90% transparent
2173
2174 TGeoVolume *hole2Cu = new TGeoVolume("SDDCableHole2Cu",
2175 hole2Cushape,medSDDCu);
2176 hole2Cu->SetVisibility(kTRUE);
2177 hole2Cu->SetLineColor(kRed);
2178 hole2Cu->SetLineWidth(1);
2179 hole2Cu->SetFillColor(hole2Cu->GetLineColor());
2180 hole2Cu->SetFillStyle(4090); // 90% transparent
2181
2182 TGeoVolume *hole2glass = new TGeoVolume("SDDCableHole2glass",
2183 hole2glassshape,medSDDglass);
2184 hole2glass->SetVisibility(kTRUE);
2185 hole2glass->SetLineColor(kGreen);
2186 hole2glass->SetLineWidth(1);
2187 hole2glass->SetFillColor(hole2glass->GetLineColor());
2188 hole2glass->SetFillStyle(4090); // 90% transparent
2189
7d6c23de 2190 TGeoVolume *hole3 = new TGeoVolume("SDDCableHole3",
2191 hole3shape,medSDDair);
2192 hole3->SetVisibility(kTRUE);
2193 hole3->SetLineColor(5); // Yellow
2194 hole3->SetLineWidth(1);
2195 hole3->SetFillColor(hole3->GetLineColor());
2196 hole3->SetFillStyle(4090); // 90% transparent
2197
a30e33f0 2198 TGeoVolume *hole31 = new TGeoVolume("SDDCableHole31",
2199 hole31shape,medSDDair);
2200 hole31->SetVisibility(kTRUE);
2201 hole31->SetLineColor(5); // Yellow
2202 hole31->SetLineWidth(1);
2203 hole31->SetFillColor(hole31->GetLineColor());
2204 hole31->SetFillStyle(4090); // 90% transparent
2205
2206 TGeoVolume *hole32 = new TGeoVolume("SDDCableHole32",
2207 hole32shape,medSDDair);
2208 hole32->SetVisibility(kTRUE);
2209 hole32->SetLineColor(5); // Yellow
2210 hole32->SetLineWidth(1);
2211 hole32->SetFillColor(hole32->GetLineColor());
2212 hole32->SetFillStyle(4090); // 90% transparent
2213
7d6c23de 2214 TGeoVolume *hole4 = new TGeoVolume("SDDCableHole4",
2215 hole4shape,medSDDair);
2216 hole4->SetVisibility(kTRUE);
2217 hole4->SetLineColor(5); // Yellow
2218 hole4->SetLineWidth(1);
2219 hole4->SetFillColor(hole4->GetLineColor());
2220 hole4->SetFillStyle(4090); // 90% transparent
2221
2222 // Mount up a cone
2223 cfconeinsert->AddNode(cfconefoam,1,0);
2224
96eb8210 2225 hole1->AddNode(hole1plast, 1, 0);
2226 hole1->AddNode(hole1Cu, 1, 0);
2227 hole1->AddNode(hole1glass, 1, 0);
2228
2229 hole2->AddNode(hole2plast, 1, 0);
2230 hole2->AddNode(hole2Cu, 1, 0);
2231 hole2->AddNode(hole2glass, 1, 0);
2232
7d6c23de 2233 for (Int_t i=0; i<12; i++) {
2234 Double_t phiH = i*30.0;
a30e33f0 2235 cfconefoam->AddNode(hole1 , i+1, new TGeoRotation("", 0, 0, phiH));
2236 cfcone->AddNode(hole11, i+1, new TGeoRotation("", 0, 0, phiH));
2237 cfcone->AddNode(hole12, i+1, new TGeoRotation("", 0, 0, phiH));
7d6c23de 2238 }
2239
2240 for (Int_t i=0; i<6; i++) {
2241 Double_t phiH = i*60.0;
a30e33f0 2242 cfconefoam->AddNode(hole2 , i+1, new TGeoRotation("", 0, 0, phiH));
2243 cfcone->AddNode(hole21, i+1, new TGeoRotation("", 0, 0, phiH));
2244 cfcone->AddNode(hole22, i+1, new TGeoRotation("", 0, 0, phiH));
7d6c23de 2245 }
2246
2247 for (Int_t i=0; i<kNHole3; i++) {
2248 Double_t phiH0 = 360./(Double_t)kNHole3;
2249 Double_t phiH = i*phiH0 + 0.5*phiH0;
a30e33f0 2250 cfconefoam->AddNode(hole3 , i+1, new TGeoRotation("", phiH, 0, 0));
2251 cfcone->AddNode(hole31, i+1, new TGeoRotation("", phiH, 0, 0));
2252 cfcone->AddNode(hole32, i+1, new TGeoRotation("", phiH, 0, 0));
7d6c23de 2253 }
a30e33f0 2254
2255 cfcone->AddNode(cfconeinsert,1,0);
2256
7d6c23de 2257/*
2258 for (Int_t i=0; i<kNHole4; i++) {
2259 Double_t phiH0 = 360./(Double_t)kNHole4;
2260 Double_t phiH = i*phiH0 + 0.25*phiH0;
2261 cfcone->AddNode(hole4, i+1, new TGeoRotation("", phiH, 0, 0));
2262 }
2263*/
3a299c65 2264 // Finally put everything in the mother volume
2265 moth->AddNode(cfcylinder,1,0);
7d6c23de 2266
2267 z = coneshape->Z(9);
3a299c65 2268 moth->AddNode(cfcone,1,new TGeoTranslation(0, 0, -z - kCylinderHalfLength));
2269 moth->AddNode(cfcone,2,new TGeoCombiTrans (0, 0, z + kCylinderHalfLength,
2270 new TGeoRotation("", 0, 180, 0) ));
7d6c23de 2271
7d6c23de 2272
2273 return;
172b0d90 2274}
7d6c23de 2275
172b0d90 2276//______________________________________________________________________
43aefea7 2277void AliITSv11GeometrySupport::SSDCone(TGeoVolume *moth,const TGeoManager *mgr)
3a299c65 2278{
2279//
2280// Creates the SSD support cone and cylinder geometry. as a
2281// volume assembly and adds it to the mother volume
2282// (part of this code is taken or anyway inspired to SSDCone method
2283// of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
2284//
2285// Input:
2286// moth : the TGeoVolume owing the volume structure
2287// mgr : the GeoManager (default gGeoManager)
2288// Output:
2289//
2290// Created: ??? Bjorn S. Nilsen
2291// Updated: 08 Mar 2008 Mario Sitta
2292//
2293// Technical data are taken from: "ITS Supporto Generale" (technical
2294// drawings ALR3-0743/1, ALR3-0743/1A and ALR3-0743/1B), "Supporto Generale
2295// Settore SSD" (technical drawings ALR3-0743/2A and ALR3-0743/2E), private
2296// communication with B. Giraudo
5e15508a 2297//
2298// Updated: 11 Apr 2008 Mario Sitta
2299// Measures from drawings give overlaps with SPD thermal shield wings,
2300// so the terminal part of the SSD cone was reduced
573a206f 2301//
2302// Updated: 30 Mar 2010 Mario Sitta
2303// Following M. van Leeuwen's suggestion on material budget, the thickness
2304// of the carbon fiber cylinder was increased from 0.6 to 0.625mm
3a299c65 2305
2306 // Dimensions of the Central cylinder and flanges
0801d201 2307 const Double_t kCylinderHalfLength = (1143.6/2) *fgkmm;
3a299c65 2308 const Double_t kCylinderOuterRadius = ( 595.0/2) *fgkmm;
573a206f 2309 const Double_t kCylinderThickness = 0.625*fgkmm;
3a299c65 2310 const Double_t kFoamHalfLength = (1020.0/2) *fgkmm;
2311 const Double_t kFoamThickness = 5.0 *fgkmm;
2312 const Double_t kFlangeHalfLength =
2313 (kCylinderHalfLength-kFoamHalfLength)/2.;
2314 const Double_t kFlangeInnerRadius = ( 563.0/2) *fgkmm;
2315 // Dimensions of the Cone
fd5b6398 2316 const Double_t kConeROuterMin = ( 957.0/2) *fgkmm;
2317 const Double_t kConeROuterMax = ( 997.0/2) *fgkmm;
3a299c65 2318 const Double_t kConeRInnerMin = ( 564.0/2) *fgkmm;
2319 const Double_t kConeRCurv1 = 10.0 *fgkmm;
2320 const Double_t kConeRCurv2 = 25.0 *fgkmm;
2321 const Double_t kConeCent1RCurv2 = ( 578.0/2) *fgkmm;
6b42825b 2322 const Double_t kConeCent2RCurv2 = ( 592.0/2) *fgkmm;
5e15508a 2323// const Double_t kConeZOuterRing = 47.0 *fgkmm;
2324// const Double_t kConeZOuterRingInside = 30.25*fgkmm;
2325// const Double_t kConeZInnerRing = 161.5 *fgkmm;
2326// const Double_t kConeZLength = 176.5 *fgkmm;
2327 const Double_t kConeZOuterRing = 38.5 *fgkmm;
2328 const Double_t kConeZOuterRingInside = 22.2 *fgkmm;
2329 const Double_t kConeZInnerRing = 153.0 *fgkmm;
2330 const Double_t kConeZLength = 168.0 *fgkmm;
3a299c65 2331 const Double_t kConeZPosition = kConeZLength + kCylinderHalfLength;
2332 const Double_t kConeThickness = 13.0 *fgkmm; // Cone thickness
81adc4e0 2333 const Double_t kConeTheta = 39.1 *fgkDegree; // Cone angle
3a299c65 2334 const Double_t kSinConeTheta =
2335 TMath::Sin(kConeTheta*TMath::DegToRad());
2336 const Double_t kCosConeTheta =
2337 TMath::Cos(kConeTheta*TMath::DegToRad());
2338 // Dimensions of the Foam cores
2339 const Double_t kConeFoam1Length = 112.3 *fgkmm;
2340 const Double_t kConeFoam2Length = 58.4 *fgkmm;
2341 // Dimensions of the Cone Holes
2342 const Double_t kCoolingHoleWidth = 40.0 *fgkmm;
2343 const Double_t kCoolingHoleHight = 30.0 *fgkmm;
2344 const Double_t kCoolingHoleRmin = 350.0 *fgkmm;
2345 const Double_t kCoolingHolePhi = 45.0 *fgkDegree;
2346 const Double_t kMountingHoleWidth = 20.0 *fgkmm;
2347 const Double_t kMountingHoleHight = 20.0 *fgkmm;
2348 const Double_t kMountingHoleRmin = 317.5 *fgkmm;
2349 const Double_t kMountingHolePhi = 60.0 *fgkDegree;
2350 const Double_t kCableHoleRin = ( 800.0/2) *fgkmm;
2351 const Double_t kCableHoleRout = ( 920.0/2) *fgkmm;
2352 const Double_t kCableHoleWidth = 200.0 *fgkmm;
2353// const Double_t kCableHoleAngle = 42.0 *fgkDegree;
2354 // Dimensions of the Cone Wings
2355 const Double_t kWingRmax = 527.5 *fgkmm;
2356 const Double_t kWingWidth = 70.0 *fgkmm;
2357 const Double_t kWingHalfThick = ( 10.0/2) *fgkmm;
2358 const Double_t kThetaWing = 45.0 *fgkDegree;
2359 // Dimensions of the SSD-SDD Mounting Brackets
989ee428 2360 const Double_t kBracketRmin = ( 541.0/2) *fgkmm;// See SDD ROutMin
3a299c65 2361 const Double_t kBracketRmax = ( 585.0/2) *fgkmm;
2362 const Double_t kBracketHalfLength = ( 4.0/2) *fgkmm;
2363 const Double_t kBracketPhi = (70.*fgkmm/kBracketRmax)*fgkRadian;
2364 // Common data
2365 const Double_t kCFThickness = 0.75*fgkmm; //Carb. fib. thick.
2366
2367
2368 // Local variables
2369 Double_t rmin1, rmin2, rmax, z;
2370
2371 //
2372 //Begin_Html
2373 /*
2374 <img src="picts/ITS/file_name.gif">
2375 <P>
2376 <FONT FACE'"TIMES">
2377 ITS SSD central support and thermal shield cylinder.
2378 </FONT>
2379 </P>
2380 */
2381 //End_Html
2382 //
2383
2384 // Central cylinder with its internal foam and the lateral flanges:
2385 // a carbon fiber Pcon which contains a rohacell Tube and two
2386 // stesalite Cone's
2387 TGeoPcon *externalcylshape = new TGeoPcon(0,360,4);
2388
2389 rmax = kCylinderOuterRadius;
2390 rmin1 = kFlangeInnerRadius - kCylinderThickness;
2391 rmin2 = rmax - 2*kCylinderThickness - kFoamThickness;
2392 externalcylshape->DefineSection(0,-kCylinderHalfLength,rmin1,rmax);
2393 externalcylshape->DefineSection(1,-kFoamHalfLength ,rmin2,rmax);
2394 externalcylshape->DefineSection(2, kFoamHalfLength ,rmin2,rmax);
2395 externalcylshape->DefineSection(3, kCylinderHalfLength,rmin1,rmax);
2396
2397 rmax = kCylinderOuterRadius - kCylinderThickness;
2398 rmin1 = rmax - kFoamThickness;
2399 TGeoTube *foamshape = new TGeoTube(rmin1,rmax,kFoamHalfLength);
2400
2401 rmax = kCylinderOuterRadius - kCylinderThickness;
2402 rmin1 = rmax - kFoamThickness;
2403 rmin2 = kFlangeInnerRadius;
2404 TGeoCone *flangeshape = new TGeoCone(kFlangeHalfLength,
2405 rmin1,rmax,rmin2,rmax);
2406
2407
2408 // We have the shapes: now create the real volumes
2409
2410 TGeoMedium *medSSDcf = mgr->GetMedium("ITS_SSD C (M55J)$");
2411 TGeoMedium *medSSDair = mgr->GetMedium("ITS_SSD AIR$");
2412 TGeoMedium *medSSDste = mgr->GetMedium("ITS_G10FR4$"); // stesalite
2413 TGeoMedium *medSSDroh = mgr->GetMedium("ITS_ROHACELL$");
2414 TGeoMedium *medSSDal = mgr->GetMedium("ITS_ALUMINUM$");
2415
2416 TGeoVolume *cfcylinder = new TGeoVolume("SSDexternalcylinder",
2417 externalcylshape,medSSDcf);
2418 cfcylinder->SetVisibility(kTRUE);
2419 cfcylinder->SetLineColor(4); // blue
2420 cfcylinder->SetLineWidth(1);
2421 cfcylinder->SetFillColor(cfcylinder->GetLineColor());
2422 cfcylinder->SetFillStyle(4000); // 0% transparent
2423
2424 TGeoVolume *foamcylinder = new TGeoVolume("SSDfoamcylinder",
2425 foamshape,medSSDroh);
2426 foamcylinder->SetVisibility(kTRUE);
2427 foamcylinder->SetLineColor(3); // green
2428 foamcylinder->SetLineWidth(1);
2429 foamcylinder->SetFillColor(foamcylinder->GetLineColor());
2430 foamcylinder->SetFillStyle(4050); // 50% transparent
2431
2432 TGeoVolume *flangecylinder = new TGeoVolume("SSDflangecylinder",
2433 flangeshape,medSSDste);
2434 flangecylinder->SetVisibility(kTRUE);
2435 flangecylinder->SetLineColor(2); // red
2436 flangecylinder->SetLineWidth(1);
2437 flangecylinder->SetFillColor(flangecylinder->GetLineColor());
2438 flangecylinder->SetFillStyle(4050); // 50% transparent
2439
2440 // Mount up the cylinder
2441 cfcylinder->AddNode(foamcylinder,1,0);
2442 cfcylinder->AddNode(flangecylinder,1,
2443 new TGeoTranslation(0, 0, kFoamHalfLength+kFlangeHalfLength));
2444 cfcylinder->AddNode(flangecylinder,2,new TGeoCombiTrans(
2445 0, 0, -kFoamHalfLength-kFlangeHalfLength,
2446 new TGeoRotation("",0,180,0) ) );
2447
2448
2449 // The whole Cone as an assembly
2450 TGeoVolumeAssembly *vC = new TGeoVolumeAssembly("ITSssdCone");
2451
2452
2453 // SSD Support Cone with its internal inserts: a carbon fiber Pcon
2454 // with holes which contains a stesalite Pcon which on turn contains a
2455 // rohacell Pcon
2456 TGeoPcon *coneshape = new TGeoPcon(0.0, 360.0, 12);
2457
2458 coneshape->Z(0) = 0.0;
2459 coneshape->Rmin(0) = kConeROuterMin;
2460 coneshape->Rmax(0) = kConeROuterMax;
2461
2462 coneshape->Z(1) = kConeZOuterRingInside - kConeRCurv1;
2463 coneshape->Rmin(1) = coneshape->GetRmin(0);
2464 coneshape->Rmax(1) = coneshape->GetRmax(0);
2465
2466 coneshape->Z(2) = kConeZOuterRingInside;
2467 coneshape->Rmin(2) = coneshape->GetRmin(1) - kConeRCurv1;
2468 coneshape->Rmax(2) = coneshape->GetRmax(0);
2469
2470 coneshape->Z(3) = coneshape->GetZ(2);
2471 coneshape->Rmax(3) = coneshape->GetRmax(0);
2472
2473 coneshape->Z(4) = kConeZOuterRing - kConeRCurv1;
2474 coneshape->Rmax(4) = coneshape->GetRmax(0);
2475
2476 coneshape->Z(5) = kConeZOuterRing;
2477 coneshape->Rmax(5) = coneshape->GetRmax(4) - kConeRCurv1;
2478
2479 coneshape->Z(6) = coneshape->GetZ(5);
2480
2481 RadiusOfCurvature(kConeRCurv2,90.0,kConeZInnerRing,kConeCent1RCurv2,
2482 90.0-kConeTheta,z,rmin1);
2483 coneshape->Z(7) = z;
2484 coneshape->Rmin(7) = rmin1;
2485
2486 coneshape->Rmin(3) = RminFromZpCone(coneshape,7,90.-kConeTheta,
2487 coneshape->GetZ(3));
2488
2489 coneshape->Rmin(4) = RminFrom2Points(coneshape,3,7,coneshape->GetZ(4));
2490
2491 coneshape->Rmin(5) = RminFrom2Points(coneshape,3,7,coneshape->GetZ(5));
2492
2493 coneshape->Rmin(6) = coneshape->GetRmin(5);
2494
2495 coneshape->Z(8) = kConeZInnerRing;
2496 coneshape->Rmin(8) = kConeCent1RCurv2;
2497
2498 coneshape->Z(9) = coneshape->GetZ(8);
2499 coneshape->Rmin(9) = kConeRInnerMin;
2500
2501 RadiusOfCurvature(kConeRCurv2,90.0,kConeZLength,kConeCent2RCurv2,
2502 90.0-kConeTheta,z,rmax);
2503
2504 coneshape->Z(10) = z;
2505 coneshape->Rmin(10) = coneshape->GetRmin(9);
2506 coneshape->Rmax(10) = rmax;
2507
2508 coneshape->Rmax(6) = RmaxFromZpCone(coneshape,10,90.-kConeTheta,
2509 coneshape->GetZ(6));
2510
2511 coneshape->Rmax(7) = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(7));
2512
2513 coneshape->Rmax(8) = RmaxFrom2Points(coneshape,6,10,coneshape->GetZ(8));
2514
2515 coneshape->Rmax(9) = coneshape->GetRmax(8);
2516
2517 coneshape->Z(11) = kConeZLength;
2518 coneshape->Rmin(11) = coneshape->GetRmin(10);
2519 coneshape->Rmax(11) = kConeCent2RCurv2;
2520
2521 // SSD Cone Insert: another Pcon
2522 Double_t x0, y0, x1, y1, x2, y2;
2523 TGeoPcon *coneinsertshape = new TGeoPcon(0.0,360.0,12);
2524
2525 coneinsertshape->Z(0) = coneshape->GetZ(0) + kCFThickness;
2526 coneinsertshape->Rmin(0) = coneshape->GetRmin(0) + kCFThickness;
2527 coneinsertshape->Rmax(0) = coneshape->GetRmax(0) - kCFThickness;
2528
2529 x0 = coneshape->GetZ(0); y0 = coneshape->GetRmin(0);
2530 x1 = coneshape->GetZ(1); y1 = coneshape->GetRmin(1);
2531 x2 = coneshape->GetZ(2); y2 = coneshape->GetRmin(2);
2532 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2533 coneinsertshape->Z(1) = z;
2534 coneinsertshape->Rmin(1) = rmin1;
2535 coneinsertshape->Rmax(1) = coneinsertshape->GetRmax(0);
2536
2537 x0 = coneshape->GetZ(1); y0 = coneshape->GetRmin(1);
2538 x1 = coneshape->GetZ(2); y1 = coneshape->GetRmin(2);
2539 x2 = coneshape->GetZ(3); y2 = coneshape->GetRmin(3);
2540 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2541 coneinsertshape->Z(2) = z;
2542 coneinsertshape->Rmin(2) = rmin1;
2543 coneinsertshape->Rmax(2) = coneinsertshape->GetRmax(1);
2544
2545 x0 = coneshape->GetZ(2); y0 = coneshape->GetRmin(2);
2546 x1 = coneshape->GetZ(3); y1 = coneshape->GetRmin(3);
2547 x2 = coneshape->GetZ(4); y2 = coneshape->GetRmin(4);
2548 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2549 coneinsertshape->Z(3) = z;
2550 coneinsertshape->Rmin(3) = rmin1;
2551 coneinsertshape->Rmax(3) = coneinsertshape->GetRmax(2);
2552
2553 x0 = coneshape->GetZ(3); y0 = coneshape->GetRmax(3);
2554 x1 = coneshape->GetZ(4); y1 = coneshape->GetRmax(4);
2555 x2 = coneshape->GetZ(5); y2 = coneshape->GetRmax(5);
2556 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2557 coneinsertshape->Z(4) = z;
2558 coneinsertshape->Rmax(4) = rmax;
2559
2560 x0 = coneshape->GetZ(4); y0 = coneshape->GetRmax(4);
2561 x1 = coneshape->GetZ(5); y1 = coneshape->GetRmax(5);
2562 x2 = coneshape->GetZ(6); y2 = coneshape->GetRmax(6);
2563 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2564 coneinsertshape->Z(5) = z;
2565 coneinsertshape->Rmax(5) = rmax;
2566
2567 x0 = coneshape->GetZ(5); y0 = coneshape->GetRmax(5);
2568 x1 = coneshape->GetZ(6); y1 = coneshape->GetRmax(6);
2569 x2 = coneshape->GetZ(7); y2 = coneshape->GetRmax(7);
2570 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2571 coneinsertshape->Z(6) = z;
2572 coneinsertshape->Rmax(6) = rmax;
2573
2574 x0 = coneshape->GetZ(6); y0 = coneshape->GetRmin(6);
2575 x1 = coneshape->GetZ(7); y1 = coneshape->GetRmin(7);
2576 x2 = coneshape->GetZ(8); y2 = coneshape->GetRmin(8);
2577 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2578 coneinsertshape->Z(7) = z;
2579 coneinsertshape->Rmin(7) = rmin1;
2580
2581 coneinsertshape->Rmin(4) = RminFrom2Points(coneinsertshape,3,7,
2582 coneinsertshape->GetZ(4));
2583
2584 coneinsertshape->Rmin(5) = RminFrom2Points(coneinsertshape,3,7,
2585 coneinsertshape->GetZ(5));
2586
2587 coneinsertshape->Rmin(6) = coneinsertshape->GetRmin(5);
2588
2589 x0 = coneshape->GetZ(7); y0 = coneshape->GetRmin(7);
2590 x1 = coneshape->GetZ(8); y1 = coneshape->GetRmin(8);
2591 x2 = coneshape->GetZ(9); y2 = coneshape->GetRmin(9);
2592 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2593 coneinsertshape->Z(8) = z;
2594 coneinsertshape->Rmin(8) = rmin1;
2595
2596 x0 = coneshape->GetZ( 8); y0 = coneshape->GetRmin( 8);
2597 x1 = coneshape->GetZ( 9); y1 = coneshape->GetRmin( 9);
2598 x2 = coneshape->GetZ(10); y2 = coneshape->GetRmin(10);
2599 InsidePoint(x0, y0, x1, y1, x2, y2, kCFThickness, z, rmin1);
2600 coneinsertshape->Z(9) = z;
2601 coneinsertshape->Rmin(9) = rmin1;
2602
2603 x0 = coneshape->GetZ( 9); y0 = coneshape->GetRmax( 9);
2604 x1 = coneshape->GetZ(10); y1 = coneshape->GetRmax(10);
2605 x2 = coneshape->GetZ(11); y2 = coneshape->GetRmax(11);
2606 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2607 coneinsertshape->Z(10) = z;
2608 coneinsertshape->Rmax(10) = rmax;
2609 coneinsertshape->Rmin(10) = coneinsertshape->GetRmin(9);
2610
2611 coneinsertshape->Rmax(7) = RmaxFrom2Points(coneinsertshape,6,10,
2612 coneinsertshape->GetZ(7));
2613
2614 coneinsertshape->Rmax(8) = RmaxFrom2Points(coneinsertshape,6,10,
2615 coneinsertshape->GetZ(8));
2616
2617 coneinsertshape->Rmax(9) = coneinsertshape->GetRmax(8);
2618
2619 x0 = coneshape->GetZ(10); y0 = coneshape->GetRmax(10);
2620 x1 = coneshape->GetZ(11); y1 = coneshape->GetRmax(11);
2621 x2 = coneshape->GetZ(11); y2 = coneshape->GetRmin(11);
2622 InsidePoint(x0, y0, x1, y1, x2, y2, -kCFThickness, z, rmax);
2623 coneinsertshape->Z(11) = z;
2624 coneinsertshape->Rmax(11) = rmax;
2625 coneinsertshape->Rmin(11) = coneinsertshape->GetRmin(10);
2626
2627 // SSD Cone Foams: two other Pcon's
2628 TGeoPcon *conefoam1shape = new TGeoPcon(0.0, 360.0, 4);
2629
2630 conefoam1shape->Z(0) = coneinsertshape->GetZ(3);
2631 conefoam1shape->Rmin(0) = coneinsertshape->GetRmin(3);
2632 conefoam1shape->Rmax(0) = conefoam1shape->GetRmin(0);
2633
2634 conefoam1shape->Rmax(1) = conefoam1shape->GetRmax(0);
2635 conefoam1shape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2636 conefoam1shape->GetRmax(1));
2637 conefoam1shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2638 conefoam1shape->GetZ(1));
2639
2640 Double_t t = kConeThickness - 2*kCFThickness;
2641 conefoam1shape->Rmin(2) = conefoam1shape->GetRmax(0) -
2642 (kConeFoam1Length*kCosConeTheta - t*kSinConeTheta);
2643 conefoam1shape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2644 conefoam1shape->GetRmin(2));
2645 conefoam1shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2646 conefoam1shape->GetZ(2));
2647
2648 conefoam1shape->Rmin(3) = conefoam1shape->GetRmin(2);
2649 conefoam1shape->Rmax(3) = conefoam1shape->GetRmin(3);
2650 conefoam1shape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2651 conefoam1shape->GetRmax(3));
2652
2653 TGeoPcon *conefoam2shape = new TGeoPcon(0.0, 360.0, 4);
2654
2655 conefoam2shape->Z(3) = coneinsertshape->GetZ(10);
2656 conefoam2shape->Rmin(3) = coneinsertshape->GetRmax(10);
2657 conefoam2shape->Rmax(3) = conefoam2shape->GetRmin(3);
2658
2659 conefoam2shape->Rmin(2) = conefoam2shape->GetRmin(3);
2660 conefoam2shape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2661 conefoam2shape->GetRmin(2));
2662 conefoam2shape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2663 conefoam2shape->GetZ(2));
2664
2665 conefoam2shape->Rmin(0) = conefoam2shape->GetRmax(2) +
2666 (kConeFoam2Length*kCosConeTheta - t*kSinConeTheta);
2667 conefoam2shape->Rmax(0) = conefoam2shape->GetRmin(0);
2668 conefoam2shape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2669 conefoam2shape->GetRmin(0));
2670
2671 conefoam2shape->Rmax(1) = conefoam2shape->GetRmax(0);
2672 conefoam2shape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2673 conefoam2shape->GetRmax(1));
2674 conefoam2shape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2675 conefoam2shape->GetZ(1));
2676
2677 // SSD Cone Holes: Pcon's
a30e33f0 2678 // A single hole volume gives an overlap with coneinsert, so
2679 // three contiguous volumes are created: one to be put in coneinsert
2680 // and two in the cone carbon fiber envelope
3a299c65 2681 Double_t holePhi;
2682 holePhi = (kCoolingHoleWidth/kCoolingHoleRmin)*TMath::RadToDeg();
2683
2684 TGeoPcon *coolingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
2685
2686 coolingholeshape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2687 coolingholeshape->Rmax(0) = coolingholeshape->GetRmin(0);
a30e33f0 2688 coolingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2689 coolingholeshape->GetRmin(0));
2690
2691 coolingholeshape->Rmax(1) = coolingholeshape->GetRmax(0);
a30e33f0 2692 coolingholeshape->Z(1) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2693 coolingholeshape->GetRmax(1));
a30e33f0 2694 coolingholeshape->Rmin(1) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2695 coolingholeshape->GetZ(1));
2696
2697 coolingholeshape->Rmin(2) = kCoolingHoleRmin;
a30e33f0 2698 coolingholeshape->Z(2) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
3a299c65 2699 coolingholeshape->GetRmin(2));
a30e33f0 2700 coolingholeshape->Rmax(2) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2701 coolingholeshape->GetZ(2));
2702
2703 coolingholeshape->Rmin(3) = coolingholeshape->GetRmin(2);
2704 coolingholeshape->Rmax(3) = coolingholeshape->GetRmin(3);
a30e33f0 2705 coolingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
3a299c65 2706 coolingholeshape->GetRmax(3));
2707
a30e33f0 2708 TGeoPcon *coolinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2709
2710 coolinghole2shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2711 coolinghole2shape->Rmax(0) = coolinghole2shape->GetRmin(0);
2712 coolinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2713 coolinghole2shape->GetRmin(0));
2714
2715 coolinghole2shape->Rmax(1) = coolinghole2shape->GetRmax(0);
2716 coolinghole2shape->Z(1) = coolingholeshape->GetZ(0);
2717 coolinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
2718 coolinghole2shape->GetZ(1));
2719
2720 coolinghole2shape->Rmin(2) = kCoolingHoleRmin;
2721 coolinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2722 coolinghole2shape->GetRmin(2));
2723 coolinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2724 coolinghole2shape->GetZ(2));
2725
2726 coolinghole2shape->Rmin(3) = coolinghole2shape->GetRmin(2);
2727 coolinghole2shape->Rmax(3) = coolinghole2shape->GetRmin(3);
2728 coolinghole2shape->Z(3) = coolingholeshape->GetZ(2);
2729
2730 TGeoPcon *coolinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2731
2732 coolinghole3shape->Rmin(0) = kCoolingHoleRmin + kCoolingHoleHight;
2733 coolinghole3shape->Rmax(0) = coolinghole3shape->GetRmin(0);
2734 coolinghole3shape->Z(0) = coolingholeshape->GetZ(1);
2735
2736 coolinghole3shape->Rmax(1) = coolinghole3shape->GetRmax(0);
2737 coolinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2738 coolinghole3shape->GetRmax(1));
2739 coolinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2740 coolinghole3shape->GetZ(1));
2741
2742 coolinghole3shape->Rmin(2) = kCoolingHoleRmin;
2743 coolinghole3shape->Z(2) = coolingholeshape->GetZ(3);
2744 coolinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
2745 coolinghole3shape->GetZ(2));
2746
2747 coolinghole3shape->Rmin(3) = coolinghole3shape->GetRmin(2);
2748 coolinghole3shape->Rmax(3) = coolinghole3shape->GetRmin(3);
2749 coolinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2750 coolinghole3shape->GetRmax(3));
2751
2752 //
3a299c65 2753 holePhi = (kMountingHoleWidth/kMountingHoleRmin)*TMath::RadToDeg();
2754
2755 TGeoPcon *mountingholeshape = new TGeoPcon(-holePhi/2., holePhi, 4);
2756
2757 mountingholeshape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2758 mountingholeshape->Rmax(0) = mountingholeshape->GetRmin(0);
2759 mountingholeshape->Z(0) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2760 mountingholeshape->GetRmin(0));
2761
2762 mountingholeshape->Rmin(1) = kMountingHoleRmin;
2763 mountingholeshape->Rmax(1) = mountingholeshape->GetRmax(0);
2764 mountingholeshape->Z(1) = ZFromRminpCone(coneinsertshape,3,90.-kConeTheta,
2765 mountingholeshape->GetRmin(1));
2766
2767 mountingholeshape->Rmin(2) = mountingholeshape->GetRmin(1);
2768 mountingholeshape->Rmax(2) = mountingholeshape->GetRmax(1);
2769 mountingholeshape->Z(2) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2770 mountingholeshape->GetRmax(2));
2771
2772 mountingholeshape->Rmin(3) = mountingholeshape->GetRmin(2);
2773 mountingholeshape->Rmax(3) = mountingholeshape->GetRmin(3);
2774 mountingholeshape->Z(3) = ZFromRmaxpCone(coneinsertshape,7,90.-kConeTheta,
2775 mountingholeshape->GetRmax(3));
2776
2777 TGeoPcon *mountinghole2shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2778
2779 mountinghole2shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2780 mountinghole2shape->Rmax(0) = mountingholeshape->GetRmin(0);
2781 mountinghole2shape->Z(0) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2782 mountinghole2shape->GetRmin(0));
2783
2784 mountinghole2shape->Rmax(1) = mountinghole2shape->GetRmax(0);
2785 mountinghole2shape->Z(1) = mountingholeshape->Z(0);
2786 mountinghole2shape->Rmin(1) = RminFromZpCone(coneshape,3,90.-kConeTheta,
2787 mountinghole2shape->GetZ(1));
2788
2789 mountinghole2shape->Rmin(2) = kMountingHoleRmin;
2790 mountinghole2shape->Z(2) = ZFromRminpCone(coneshape,3,90.-kConeTheta,
2791 mountinghole2shape->GetRmin(2));
2792 mountinghole2shape->Rmax(2) = RminFromZpCone(coneinsertshape,3,90.-kConeTheta,
2793 mountinghole2shape->GetZ(2));
2794
2795 mountinghole2shape->Rmin(3) = mountinghole2shape->Rmin(2);
2796 mountinghole2shape->Rmax(3) = mountinghole2shape->Rmin(3);
2797 mountinghole2shape->Z(3) = mountingholeshape->Z(1);
2798
2799 TGeoPcon *mountinghole3shape = new TGeoPcon(-holePhi/2., holePhi, 4);
2800
2801 mountinghole3shape->Rmin(0) = kMountingHoleRmin + kMountingHoleHight;
2802 mountinghole3shape->Rmax(0) = mountingholeshape->GetRmin(0);
2803 mountinghole3shape->Z(0) = mountingholeshape->GetZ(2);
2804
2805 mountinghole3shape->Rmax(1) = mountinghole3shape->GetRmax(0);
2806 mountinghole3shape->Z(1) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2807 mountinghole3shape->GetRmax(1));
2808 mountinghole3shape->Rmin(1) = RmaxFromZpCone(coneinsertshape,7,90.-kConeTheta,
2809 mountinghole3shape->GetZ(1));
2810
2811 mountinghole3shape->Rmin(2) = kMountingHoleRmin;
2812 mountinghole3shape->Z(2) = mountingholeshape->Z(3);
2813 mountinghole3shape->Rmax(2) = RmaxFromZpCone(coneshape,7,90.-kConeTheta,
2814 mountinghole3shape->GetZ(2));
2815
2816 mountinghole3shape->Rmin(3) = mountinghole3shape->Rmin(2);
2817 mountinghole3shape->Rmax(3) = mountinghole3shape->Rmin(3);
2818 mountinghole3shape->Z(3) = ZFromRmaxpCone(coneshape,7,90.-kConeTheta,
2819 mountinghole3shape->GetRmax(3));
2820
2821 // The Cable Hole is even more complicated, a Composite Shape
2822 // is unavoidable here (gosh!)
2823 TGeoPcon *coneshapecopy = new TGeoPcon("conecopy",0.0, 360.0, 12);
2824
2825 for (Int_t i=0; i<12; i++) {
2826 coneshapecopy->Rmin(i) = coneshape->GetRmin(i);
2827 coneshapecopy->Rmax(i) = coneshape->GetRmax(i);
2828 coneshapecopy->Z(i) = coneshape->GetZ(i);
2829 }
2830
2831 holePhi = (kCableHoleWidth/kCableHoleRout)*TMath::RadToDeg();
2832 TGeoConeSeg *chCS = new TGeoConeSeg("chCS", 0.5*kConeZLength,
2833 kCableHoleRin, kCableHoleRout,
2834 kCableHoleRin, kCableHoleRout,
2835 -0.5*holePhi, 0.5*holePhi);
2836
2837 TGeoCompositeShape *cableholeshape = new TGeoCompositeShape(
2838 "SSDCableHoleShape",
2839 "conecopy*chCS");
2840
2841 if(GetDebug(1)){
2842 chCS->InspectShape();
2843 cableholeshape->InspectShape();
2844 }
2845
2846 // SSD Cone Wings: Tube and TubeSeg shapes
2847 Double_t angleWideWing, angleWideWingThickness;
2848 angleWideWing = (kWingWidth/kWingRmax)*TMath::RadToDeg();
2849 angleWideWingThickness = (kCFThickness/kWingRmax)*TMath::RadToDeg();
2850
2851 TGeoTubeSeg *wingshape = new TGeoTubeSeg(kConeROuterMax, kWingRmax,
2852 kWingHalfThick,
2853 0, angleWideWing);
2854
2855 TGeoTubeSeg *winginsertshape = new TGeoTubeSeg(kConeROuterMax,
2856 kWingRmax-kCFThickness,
2857 kWingHalfThick-kCFThickness,
2858 angleWideWingThickness,
2859 angleWideWing-angleWideWingThickness);
2860
2861 // SDD support plate, SSD side (Mounting Bracket): a TubeSeg
2862 TGeoTubeSeg *bracketshape = new TGeoTubeSeg(kBracketRmin, kBracketRmax,
2863 kBracketHalfLength, -kBracketPhi/2, kBracketPhi/2);
2864
2865
2866 // We have the shapes: now create the real volumes
2867
2868 TGeoVolume *cfcone = new TGeoVolume("SSDCarbonFiberCone",
2869 coneshape,medSSDcf);
2870 cfcone->SetVisibility(kTRUE);
2871 cfcone->SetLineColor(4); // Blue
2872 cfcone->SetLineWidth(1);
2873 cfcone->SetFillColor(cfcone->GetLineColor());
2874 cfcone->SetFillStyle(4000); // 0% transparent
2875
2876 TGeoVolume *cfconeinsert = new TGeoVolume("SSDCarbonFiberConeInsert",
2877 coneinsertshape,medSSDste);
2878 cfconeinsert->SetVisibility(kTRUE);
2879 cfconeinsert->SetLineColor(2); // Red
2880 cfconeinsert->SetLineWidth(1);
2881 cfconeinsert->SetFillColor(cfconeinsert->GetLineColor());
2882 cfconeinsert->SetFillStyle(4050); // 50% transparent
2883
2884 TGeoVolume *cfconefoam1 = new TGeoVolume("SSDCarbonFiberConeFoam1",
2885 conefoam1shape,medSSDroh);
2886 cfconefoam1->SetVisibility(kTRUE);
2887 cfconefoam1->SetLineColor(3); // Green
2888 cfconefoam1->SetLineWidth(1);
2889 cfconefoam1->SetFillColor(cfconefoam1->GetLineColor());
2890 cfconefoam1->SetFillStyle(4050); // 50% transparent
2891
2892 TGeoVolume *cfconefoam2 = new TGeoVolume("SSDCarbonFiberConeFoam2",
2893 conefoam2shape,medSSDroh);
2894 cfconefoam2->SetVisibility(kTRUE);
2895 cfconefoam2->SetLineColor(3); // Green
2896 cfconefoam2->SetLineWidth(1);
2897 cfconefoam2->SetFillColor(cfconefoam2->GetLineColor());
2898 cfconefoam2->SetFillStyle(4050); // 50% transparent
2899
2900 TGeoVolume *coolinghole = new TGeoVolume("SSDCoolingHole",
2901 coolingholeshape,medSSDair);
2902 coolinghole->SetVisibility(kTRUE);
2903 coolinghole->SetLineColor(5); // Yellow
2904 coolinghole->SetLineWidth(1);
2905 coolinghole->SetFillColor(coolinghole->GetLineColor());
2906 coolinghole->SetFillStyle(4090); // 90% transparent
2907
a30e33f0 2908 TGeoVolume *coolinghole2 = new TGeoVolume("SSDCoolingHole2",
2909 coolinghole2shape,medSSDair);
2910 coolinghole2->SetVisibility(kTRUE);
2911 coolinghole2->SetLineColor(5); // Yellow
2912 coolinghole2->SetLineWidth(1);
2913 coolinghole2->SetFillColor(coolinghole2->GetLineColor());
2914 coolinghole2->SetFillStyle(4090); // 90% transparent
2915
2916 TGeoVolume *coolinghole3 = new TGeoVolume("SSDCoolingHole3",
2917 coolinghole3shape,medSSDair);
2918 coolinghole3->SetVisibility(kTRUE);
2919 coolinghole3->SetLineColor(5); // Yellow
2920 coolinghole3->SetLineWidth(1);
2921 coolinghole3->SetFillColor(coolinghole3->GetLineColor());
2922 coolinghole3->SetFillStyle(4090); // 90% transparent
2923
3a299c65 2924 TGeoVolume *mountinghole = new TGeoVolume("SSDMountingHole",
2925 mountingholeshape,medSSDair);
2926 mountinghole->SetVisibility(kTRUE);
2927 mountinghole->SetLineColor(5); // Yellow
2928 mountinghole->SetLineWidth(1);
2929 mountinghole->SetFillColor(mountinghole->GetLineColor());
2930 mountinghole->SetFillStyle(4090); // 90% transparent
2931
2932 TGeoVolume *mountinghole2 = new TGeoVolume("SSDMountingHole2",
2933 mountinghole2shape,medSSDair);
2934 mountinghole2->SetVisibility(kTRUE);
2935 mountinghole2->SetLineColor(5); // Yellow
2936 mountinghole2->SetLineWidth(1);
2937 mountinghole2->SetFillColor(mountinghole2->GetLineColor());
2938 mountinghole2->SetFillStyle(4090); // 90% transparent
2939
2940 TGeoVolume *mountinghole3 = new TGeoVolume("SSDMountingHole3",
2941 mountinghole3shape,medSSDair);
2942 mountinghole3->SetVisibility(kTRUE);
2943 mountinghole3->SetLineColor(5); // Yellow
2944 mountinghole3->SetLineWidth(1);
2945 mountinghole3->SetFillColor(mountinghole3->GetLineColor());
2946 mountinghole3->SetFillStyle(4090); // 90% transparent
2947
2948 TGeoVolume *wing = new TGeoVolume("SSDWing",wingshape,medSSDcf);
2949 wing->SetVisibility(kTRUE);
2950 wing->SetLineColor(4); // Blue
2951 wing->SetLineWidth(1);
2952 wing->SetFillColor(wing->GetLineColor());
2953 wing->SetFillStyle(4000); // 0% transparent
2954
2955 TGeoVolume *cablehole = new TGeoVolume("SSDCableHole",
2956 cableholeshape,medSSDair);
2957 cablehole->SetVisibility(kTRUE);
2958 cablehole->SetLineColor(5); // Yellow
2959 cablehole->SetLineWidth(1);
2960 cablehole->SetFillColor(cablehole->GetLineColor());
2961 cablehole->SetFillStyle(4090); // 90% transparent
2962
2963 TGeoVolume *winginsert = new TGeoVolume("SSDWingInsert",
2964 winginsertshape,medSSDste);
2965 winginsert->SetVisibility(kTRUE);
2966 winginsert->SetLineColor(2); // Red
2967 winginsert->SetLineWidth(1);
2968 winginsert->SetFillColor(winginsert->GetLineColor());
2969 winginsert->SetFillStyle(4050); // 50% transparent
2970
2971 TGeoVolume *bracket = new TGeoVolume("SSDMountingBracket",
2972 bracketshape,medSSDal);
2973 bracket->SetVisibility(kTRUE);
2974 bracket->SetLineColor(6); // Purple
2975 bracket->SetLineWidth(1);
2976 bracket->SetFillColor(bracket->GetLineColor());
2977 bracket->SetFillStyle(4000); // 0% transparent
2978
2979 // Mount up a cone
2980 for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
2981 Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
2982 cfconefoam2->AddNode(mountinghole,i+1, new TGeoRotation("", phiH, 0, 0));
2983 }
2984
a30e33f0 2985 for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
2986 Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
2987 cfconeinsert->AddNodeOverlap(coolinghole,i+1, new TGeoRotation("", phiH, 0, 0));
2988 }
2989
3a299c65 2990 cfconeinsert->AddNode(cfconefoam1,1,0);
2991 cfconeinsert->AddNode(cfconefoam2,1,0);
2992
2993 cfcone->AddNode(cfconeinsert,1,0);
2994
2995 for (Int_t i=0; i<(Int_t)(360./kCoolingHolePhi); i++) {
2996 Double_t phiH = i*kCoolingHolePhi + 0.5*kCoolingHolePhi;
a30e33f0 2997 cfcone->AddNode(coolinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
2998 cfcone->AddNode(coolinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
3a299c65 2999 cfcone->AddNodeOverlap(cablehole,i+1, new TGeoRotation("", phiH, 0, 0));
3000 }
3001
3002 for (Int_t i=0; i<(Int_t)(360./kMountingHolePhi); i++) {
3003 Double_t phiH = i*kMountingHolePhi + 0.5*kMountingHolePhi;
3004 cfcone->AddNode(mountinghole2,i+1, new TGeoRotation("", phiH, 0, 0));
3005 cfcone->AddNode(mountinghole3,i+1, new TGeoRotation("", phiH, 0, 0));
3006 }
3007
3008 wing->AddNode(winginsert,1,0);
3009
3010 // Add all volumes in the Cone assembly
3011 vC->AddNode(cfcone,1,new TGeoTranslation(0,0,-kConeZPosition));
3012
3013 for (Int_t i=0; i<4; i++) {
85234543 3014 Double_t thetaW = kThetaWing + 90.*i + angleWideWing/2.;
3015 vC->AddNode(wing, i+1, new TGeoCombiTrans(0, 0, -kConeZPosition+kWingHalfThick,
3a299c65 3016 new TGeoRotation("",thetaW,180,0)));
3017 }
3018
3019 Double_t zBracket = kConeZPosition - coneshape->GetZ(9) +
a30e33f0 3020 2*bracketshape->GetDz();
3a299c65 3021 for (Int_t i=0; i<3; i++) {
3022 Double_t thetaB = 60 + 120.*i;
3023 vC->AddNode(bracket, i+1, new TGeoCombiTrans(0, 0, -zBracket,
3024 new TGeoRotation("",thetaB,0,0)));
3025 }
3026
3027 // Finally put everything in the mother volume
3028 moth->AddNode(cfcylinder,1,0);
3029
3030 moth->AddNode(vC, 1, 0 );
3031 moth->AddNode(vC, 2, new TGeoRotation("",180, 180, 0) );
3032
3033 // Some debugging if requested
3034 if(GetDebug(1)){
3035 vC->PrintNodes();
3036 vC->InspectShape();
3037 }
3038
3039 return;
172b0d90 3040}
3041
3042//______________________________________________________________________
543b7370 3043void AliITSv11GeometrySupport::ServicesCableSupport(TGeoVolume *moth,
3044 TGeoManager *mgr){
798b4e0c 3045//
3046// Creates the cable trays which are outside the ITS support cones
3047// but still inside the TPC
3048// This is now a stearing routine, the actual work is done by three
3049// specialized methods to avoid a really huge unique method
3050//
3051// Input:
3052// moth : the TGeoVolume owing the volume structure
3053// mgr : the GeoManager (default gGeoManager)
3054// Output:
3055//
3056// Created: 15 Nov 2009 Mario Sitta
3057//
3058
3059 TraySupportsSideA(moth, mgr);
3060
3061 ServicesCableSupportSPD(moth, mgr);
3062 ServicesCableSupportSDD(moth, mgr);
3063 ServicesCableSupportSSD(moth, mgr);
3064
3065 return;
3066}
3067
3068//______________________________________________________________________
3069void AliITSv11GeometrySupport::TraySupportsSideA(TGeoVolume *moth,
43aefea7 3070 const TGeoManager *mgr){
798b4e0c 3071//
3072// Creates the structure supporting the ITS cable trays on Side A
3073//
3074// Input:
3075// moth : the TGeoVolume owing the volume structure
3076// mgr : the GeoManager (default gGeoManager)
3077// Output:
3078//
3079// Created: 14 Dec 2009 Mario Sitta
3080// Updated: 26 Feb 2010 Mario Sitta
3081//
3082// Technical data are taken from AutoCAD drawings, L.Simonetti technical
3083// drawings and other (oral) information given by F.Tosello
3084//
3085
3086 // Dimensions and positions of the A-Side Cable Tray Support Ring
3087 // (0872/G/A/01)
3088 const Double_t kSuppRingYTrans = 110.00 *fgkmm;
3089 const Double_t kSuppRingZTrans =(1011.00+435.00) *fgkmm;
3090 const Double_t kSuppForwYTrans = 185.00 *fgkmm;
3091
3092 const Double_t kExtSuppRingSpace1 = 33.00 *fgkmm;
3093 const Double_t kExtSuppRingSpace2 = 45.00 *fgkmm;
3094 const Double_t kExtSuppRingSpcAbov = 30.00 *fgkmm;
3095 const Double_t kExtSuppRingBase = 491.50 *fgkmm;
3096 const Double_t kExtSuppRingInward = 35.00 *fgkmm;
3097 const Double_t kExtSuppRingRmax = 540.00 *fgkmm;
3098 const Double_t kExtSuppRingRint1 = 465.00 *fgkmm;
3099 const Double_t kExtSuppRingRint2 = 467.00 *fgkmm;
3100 const Double_t kExtSuppRingInnerHi = 450.00 *fgkmm;
3101 const Double_t kExtSuppRingInWide = 100.00 *fgkmm;
3102 const Double_t kExtSuppRingR7 = 7.00 *fgkmm;
3103 const Double_t kExtSuppRingR5 = 5.00 *fgkmm;
3104 const Double_t kExtSuppRingThick = 20.00 *fgkmm;
3105
3106 const Double_t kExtSuppRingSpcAng = 10.50 *TMath::DegToRad();
3107 const Double_t kExtSuppRingPartPhi = 15.00 *TMath::DegToRad();
3108 const Double_t kExtSuppRingIntAng = 7.00 *TMath::DegToRad();
3109 const Double_t kExtSuppRingBaseAng = 75.00 *TMath::DegToRad();
3110 const Double_t kExtSuppRingR7Ang = 100.00 *TMath::DegToRad(); // Guessed
3111
3112 const Int_t kExtSuppRingNPtsArc = 10; // N.points to approximate arc
3113
3114 const Double_t kIntSuppRingThick1 = 15.00 *fgkmm;
3115 const Double_t kIntSuppRingThick2 = 13.00 *fgkmm;
3116 const Double_t kIntSuppRingInward = 24.00 *fgkmm;
3117 const Double_t kIntSuppRingThick = 20.00 *fgkmm;
3118
3119 const Double_t kSuppCylHeight = 340.00 *fgkmm;
3120 const Double_t kSuppCylRint = 475.00 *fgkmm;
3121 const Double_t kSuppCylRext = 478.00 *fgkmm;
3122 const Double_t kSuppCylDispl = 137.70 *fgkmm;
3123
3124 const Double_t kSuppSpacerHeight = 30.00 *fgkmm;
3125 const Double_t kSuppSpacerThick = 10.00 *fgkmm;
3126
3127 const Double_t kSuppSpacerAngle = 15.00; // Degrees
3128
3129 const Double_t kSuppForwRingRint1 = 500.00 *fgkmm;
3130 const Double_t kSuppForwRingRint2 = 540.00 *fgkmm;
3131 const Double_t kSuppForwRingRext = 560.00 *fgkmm;
3132 const Double_t kSuppForwRingThikAll = 50.00 *fgkmm;
3133 const Double_t kSuppForwRingThikInt = 20.00 *fgkmm;
3134
3135 // (0872/G/B/01)
3136 const Double_t kSuppForwConeRmin = 558.00 *fgkmm;
3137 const Double_t kSuppForwConeRmax = 681.00 *fgkmm;
3138 const Double_t kSuppForwConeLen1 = 318.00 *fgkmm;
3139 const Double_t kSuppForwConeLen2 = 662.00 *fgkmm;
3140 const Double_t kSuppForwConeThick = 3.00 *fgkmm;
3141
3142 const Double_t kSuppBackRingPlacTop = 90.00 *fgkmm;
3143 const Double_t kSuppBackRingPlacSid = 50.00 *fgkmm;
3144 const Double_t kSuppBackRingHeight = 760.00 *fgkmm;
3145 const Double_t kSuppBackRingRext = 760.00 *fgkmm;
3146 const Double_t kSuppBackRingRint = 685.00 *fgkmm;
3147// const Double_t kSuppBackRingRint2 = 675.00 *fgkmm;
3148 const Double_t kSuppBackRingR10 = 10.00 *fgkmm;
3149 const Double_t kSuppBackRingBase = 739.00 *fgkmm;
3150 const Double_t kSuppBackRingThikAll = 50.00 *fgkmm;
3151 const Double_t kSuppBackRingThick1 = 20.00 *fgkmm;
3152 const Double_t kSuppBackRingThick2 = 20.00 *fgkmm;
3153
3154// const Double_t kSuppBackRingPlacAng = 10.00 *TMath::DegToRad();
3155 const Double_t kSuppBackRingPlacAng = 10.25 *TMath::DegToRad();//Fix ovlp.
3156 const Double_t kSuppBackRing2ndAng1 = 78.40 *TMath::DegToRad();
3157 const Double_t kSuppBackRing2ndAng2 = 45.00 *TMath::DegToRad();
3158
3159 const Int_t kSuppBackRingNPtsArc = 10; // N.points to approximate arc
3160
3161 // (0872/G/C/01)
3162 const Double_t kRearSuppZTransGlob =(1011.00+9315.00-6040.00) *fgkmm;
3163 const Double_t kBackRodZTrans = 2420.00 *fgkmm;
3164
3165 const Double_t kBackRodLength = 1160.00 *fgkmm;
3166 const Double_t kBackRodThickLen = 20.00 *fgkmm;
3167 const Double_t kBackRodDiameter = 20.00 *fgkmm;
3168
3169 const Double_t kSuppRearRingRint = 360.00 *fgkmm;
3170 const Double_t kSuppRearRingRext1 = 410.00 *fgkmm;
3171 const Double_t kSuppRearRingRext2 = 414.00 *fgkmm;
3172 const Double_t kSuppRearRingHeight = 397.00 *fgkmm;
3173 const Double_t kSuppRearRingTopWide = 111.87 *fgkmm;
3174 const Double_t kSuppRearRingBase = 451.50 *fgkmm;
3175 const Double_t kSuppRearRingBaseHi = 58.00 *fgkmm;
3176 const Double_t kSuppRearRingSideHi = 52.00 *fgkmm;
3177 const Double_t kSuppRearRingInside = 40.00 *fgkmm;
3178 const Double_t kSuppRearRingInsideHi= 12.00 *fgkmm;
3179 const Double_t kSuppRearRingThick = 20.00 *fgkmm;
3180 const Double_t kSuppRearRingXRodHole= 441.50 *fgkmm;
3181 const Double_t kSuppRearRingYRodHole= 42.00 *fgkmm;
3182
3183 const Double_t kSuppRearRing1stAng = 22.00 *TMath::DegToRad();
3184 const Double_t kSuppRearRingStepAng = 15.00 *TMath::DegToRad();
3185
3186 const Int_t kSuppRearRingNPtsArc = 10; // N.points to approximate arc
3187
3188
3189 // Local variables
3190 Double_t xprof[2*(15+kExtSuppRingNPtsArc)],yprof[2*(15+kExtSuppRingNPtsArc)];
3191 Double_t slp1, slp2, phi, xm, ym;
3192 Double_t xloc, yloc, zloc, rmin, rmax, deltaR;
3193 Int_t npoints;
3194
3195
3196 // The whole support as an assembly
3197 TGeoVolumeAssembly *trayASuppStruct = new TGeoVolumeAssembly("ITSsuppSideAStructure");
3198
3199
3200 // First create all needed shapes
3201
3202 // The External Ring (part of 0872/G/A/01): a really complex Xtru
3203 TGeoXtru *extSuppRing = new TGeoXtru(2);
3204
3205 // First the upper notch...
3206 xprof[ 0] = kExtSuppRingSpace1;
3207 yprof[ 0] = kExtSuppRingInnerHi + kExtSuppRingSpcAbov;
3208
3209 slp1 = TMath::Tan(TMath::Pi()/2 - kExtSuppRingSpcAng);
3210 IntersectCircle(slp1, xprof[0], yprof[0], kExtSuppRingRmax, 0., 0.,
3211 xprof[5], yprof[5], xm, ym); // Ignore dummy xm,ym
3212
3213 xprof[ 4] = xprof[5];
3214 yprof[ 4] = yprof[5] - kExtSuppRingR5/TMath::Tan(kExtSuppRingSpcAng);
3215 xprof[ 3] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/6));
3216 yprof[ 3] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/6));
3217 xprof[ 2] = xprof[4] - kExtSuppRingR5*(1 - TMath::Cos(TMath::Pi()/3));
3218 yprof[ 2] = yprof[4] - kExtSuppRingR5*( TMath::Sin(TMath::Pi()/3));
3219 xprof[ 1] = xprof[4] - kExtSuppRingR5;
3220 yprof[ 1] = yprof[4] - kExtSuppRingR5;
3221
3222 Int_t indx = 5+kExtSuppRingNPtsArc;
3223 // ...then the external arc, approximated with segments,...
3224 xprof[indx] = kExtSuppRingBase;
3225 yprof[indx] = TMath::Sqrt(kExtSuppRingRmax*kExtSuppRingRmax -
3226 kExtSuppRingBase*kExtSuppRingBase);
3227 Double_t alphamin = TMath::ASin(kExtSuppRingSpace2/kExtSuppRingRmax);
3228 Double_t alphamax = TMath::Pi()/2 -
3229 TMath::ASin(yprof[5+kExtSuppRingNPtsArc]/kExtSuppRingRmax);
3230
3231 for (Int_t jp = 1; jp < kExtSuppRingNPtsArc; jp++) {
3232 Double_t alpha = jp*(alphamax-alphamin)/kExtSuppRingNPtsArc;
3233 xprof[5+jp] = kExtSuppRingRmax*TMath::Sin(alpha);
3234 yprof[5+jp] = kExtSuppRingRmax*TMath::Cos(alpha);
3235 }
3236 // ...and finally the interior profile
3237 xprof[indx+1] = kExtSuppRingBase;
3238 yprof[indx+1] = kSuppRingYTrans;
3239 xprof[indx+2] = xprof[indx+1] - kExtSuppRingInward;
3240 yprof[indx+2] = yprof[indx+1];
3241
3242 phi = TMath::Pi()/2 - 4*kExtSuppRingPartPhi - kExtSuppRingIntAng;
3243 slp1 = TMath::Tan(TMath::Pi() - kExtSuppRingBaseAng);
3244 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3245 xm = kExtSuppRingRint2*TMath::Cos(phi);
3246 ym = kExtSuppRingRint2*TMath::Sin(phi);
3247 IntersectLines(slp1, xprof[indx+2], yprof[indx+2], slp2, xm, ym,
3248 xprof[indx+3], yprof[indx+3]);
3249
3250 slp1 = slp2;
3251 phi += kExtSuppRingPartPhi;
3252 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3253 xm = kExtSuppRingRint1*TMath::Cos(phi);
3254 ym = kExtSuppRingRint1*TMath::Sin(phi);
3255 IntersectLines(slp1, xprof[indx+3], yprof[indx+3], slp2, xm, ym,
3256 xprof[indx+4], yprof[indx+4]);
3257
3258 slp1 = slp2;
3259 phi += kExtSuppRingPartPhi;
3260 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3261 xm = kExtSuppRingRint2*TMath::Cos(phi);
3262 ym = kExtSuppRingRint2*TMath::Sin(phi);
3263 IntersectLines(slp1, xprof[indx+4], yprof[indx+4], slp2, xm, ym,
3264 xprof[indx+5], yprof[indx+5]);
3265
3266 slp1 = slp2;
3267 phi += kExtSuppRingPartPhi;
3268 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3269 xm = kExtSuppRingRint1*TMath::Cos(phi);
3270 ym = kExtSuppRingRint1*TMath::Sin(phi);
3271 IntersectLines(slp1, xprof[indx+5], yprof[indx+5], slp2, xm, ym,
3272 xprof[indx+6], yprof[indx+6]);
3273
3274 xprof[indx+9] = kExtSuppRingInWide;
3275 yprof[indx+9] = kExtSuppRingInnerHi;
3276 xprof[indx+8] = xprof[indx+9] +
3277 (1 - TMath::Cos(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
3278 yprof[indx+8] = yprof[indx+9] +
3279 ( TMath::Sin(kExtSuppRingR7Ang/2))*kExtSuppRingR7;
3280 xprof[indx+7] = xprof[indx+9] +
3281 (1 + TMath::Cos(kExtSuppRingR7Ang ))*kExtSuppRingR7;
3282 yprof[indx+7] = yprof[indx+9] +
3283 ( TMath::Sin(kExtSuppRingR7Ang ))*kExtSuppRingR7;
3284 // Gosh, we did the right side! now reflex on the left side
3285 npoints = (sizeof(xprof)/sizeof(Double_t))/2;
3286 for (Int_t jp = 0; jp < npoints; jp++) {
3287 xprof[npoints+jp] = -xprof[npoints-1-jp];
3288 yprof[npoints+jp] = yprof[npoints-1-jp];
3289 }
3290 // wow! now the actual Xtru
3291 extSuppRing->DefinePolygon(2*npoints, xprof, yprof);
3292 extSuppRing->DefineSection(0,0);
3293 extSuppRing->DefineSection(1,kExtSuppRingThick);
3294
3295 // The Internal Ring (part of 0872/G/A/01): another complex Xtru
3296 TGeoXtru *intSuppRing = new TGeoXtru(2);
3297
3298 // First the external profile...
3299 npoints = 0;
3300
3301 slp1 = 0;
3302 phi = TMath::Pi()/2 - kExtSuppRingPartPhi - kExtSuppRingIntAng;
3303 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3304 xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
3305 ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
3306 IntersectLines(slp1, 0, kExtSuppRingInnerHi+kExtSuppRingSpcAbov,
3307 slp2, xm, ym,
3308 xprof[npoints], yprof[npoints]);
3309 npoints++;
3310
3311 slp1 = slp2;
3312 phi -= kExtSuppRingPartPhi;
3313 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3314 xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
3315 ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
3316 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3317 slp2, xm, ym,
3318 xprof[npoints], yprof[npoints]);
3319 npoints++;
3320
3321 slp1 = slp2;
3322 phi -= kExtSuppRingPartPhi;
3323 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3324 xm = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Cos(phi);
3325 ym = (kExtSuppRingRint1+kIntSuppRingThick1)*TMath::Sin(phi);
3326 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3327 slp2, xm, ym,
3328 xprof[npoints], yprof[npoints]);
3329 npoints++;
3330
3331 slp1 = slp2;
3332 phi -= kExtSuppRingPartPhi;
3333 slp2 = TMath::Tan(TMath::Pi()/2 + phi);
3334 xm = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Cos(phi);
3335 ym = (kExtSuppRingRint2+kIntSuppRingThick2)*TMath::Sin(phi);
3336 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3337 slp2, xm, ym,
3338 xprof[npoints], yprof[npoints]);
3339 npoints++;
3340
3341 xprof[npoints] = kExtSuppRingBase-kIntSuppRingInward;
3342 yprof[npoints] = Yfrom2Points(xprof[npoints-1], yprof[npoints-1], xm, ym,
3343 xprof[npoints]);
3344 npoints++;
3345
3346 xprof[npoints] = xprof[npoints-1];
3347 yprof[npoints] = kSuppRingYTrans;
3348 npoints++;
3349 // ...and then the interior profile, which is identical to extSuppRing one
3350 for (Int_t jp=0; jp < 8; jp++) {
3351 xprof[npoints] = extSuppRing->GetX(17+jp);
3352 yprof[npoints] = extSuppRing->GetY(17+jp);
3353 npoints++;
3354 }
3355 // We did the right side! now reflex on the left side
3356 for (Int_t jp = 0; jp < npoints; jp++) {
3357 xprof[npoints+jp] = -xprof[npoints-1-jp];
3358 yprof[npoints+jp] = yprof[npoints-1-jp];
3359 }
3360 // And now the actual Xtru
3361 intSuppRing->DefinePolygon(2*npoints, xprof, yprof);
3362 intSuppRing->DefineSection(0,0);
3363 intSuppRing->DefineSection(1,kIntSuppRingThick);
3364
3365 // The intermediate cylinder (0872/G/A/03): a TubeSeg
3366 alphamin = TMath::ASin(kSuppCylDispl/kSuppCylRint)*TMath::RadToDeg();
3367 alphamax = 180 - alphamin;
3368 TGeoTubeSeg *interCylind = new TGeoTubeSeg(kSuppCylRint, kSuppCylRext,
3369 kSuppCylHeight/2, alphamin, alphamax);
3370
3371 // The spacer (0872/G/A/03): a simple Xtru
3372 TGeoXtru *suppSpacer = new TGeoXtru(2);
3373
3374 xprof[0] = kSuppSpacerHeight;
3375 yprof[0] = kSuppSpacerThick;
3376 xprof[1] = xprof[0];
3377 yprof[1] = 0;
3378 xprof[2] = 0;
3379 yprof[2] = 0;
3380 xprof[3] = kSuppSpacerThick*SinD(kSuppSpacerAngle);
3381 yprof[3] = yprof[0];
3382
3383 suppSpacer->DefinePolygon(4, xprof, yprof);
3384 suppSpacer->DefineSection(0,-kSuppCylHeight/2);
3385 suppSpacer->DefineSection(1, kSuppCylHeight/2);
3386
3387 // The forward ring (0872/G/B/02): a Pcon (slight oversimplification)
3388 Double_t rmean = (kSuppForwRingRint1+kSuppForwRingRext)/2;
3389 alphamin = TMath::ASin(kSuppForwYTrans/rmean)*TMath::RadToDeg();
3390 alphamax = 180 - alphamin;
3391
3392 TGeoPcon *forwardRing = new TGeoPcon(alphamin,alphamax-alphamin,4);
3393
3394 forwardRing->DefineSection(0,0,
3395 kSuppForwRingRint1,kSuppForwRingRext);
3396 forwardRing->DefineSection(1,kSuppForwRingThikInt,
3397 kSuppForwRingRint1,kSuppForwRingRext);
3398 forwardRing->DefineSection(2,kSuppForwRingThikInt,
3399 kSuppForwRingRint2,kSuppForwRingRext);
3400 forwardRing->DefineSection(3,kSuppForwRingThikAll,
3401 kSuppForwRingRint2,kSuppForwRingRext);
3402
3403 // The forward cone (0872/G/B/03): a TGeoPcon
3404 TGeoPcon *forwardCone = new TGeoPcon(alphamin,alphamax-alphamin,3);
3405
3406 forwardCone->DefineSection(0,0,
3407 kSuppForwConeRmin-kSuppForwConeThick,
3408 kSuppForwConeRmin);
3409 forwardCone->DefineSection(1,kSuppForwConeLen1,
3410 kSuppForwConeRmin-kSuppForwConeThick,
3411 kSuppForwConeRmin);
3412 forwardCone->DefineSection(2,kSuppForwConeLen1+kSuppForwConeLen2,
3413 kSuppForwConeRmax-kSuppForwConeThick,
3414 kSuppForwConeRmax);
3415
3416 // The first part of the Back Ring (part of 0872/G/B/01): a complex Xtru
3417 TGeoXtru *firstSuppBackRing = new TGeoXtru(2);
3418
3419 // First the external profile... (the arc is approximated with segments)
3420 npoints = 0;
3421
3422 xprof[npoints] = kSuppBackRingPlacTop;
3423 yprof[npoints] = kSuppBackRingHeight;
3424 npoints++;
3425
3426 alphamax = TMath::Pi()/2 - TMath::ASin(kSuppBackRingPlacTop/kSuppBackRingRext);
3427 alphamin = TMath::ASin((kSuppForwYTrans+kSuppBackRingPlacSid)/kSuppBackRingRext);
3428
3429 xprof[npoints] = xprof[npoints-1];
3430 yprof[npoints] = kSuppBackRingRext*TMath::Sin(alphamax);
3431 npoints++;
3432
3433 for (Int_t jp = 1; jp <= kSuppBackRingNPtsArc; jp++) {
3434 Double_t alpha = alphamax - jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
3435 xprof[npoints] = kSuppBackRingRext*TMath::Cos(alpha);
3436 yprof[npoints] = kSuppBackRingRext*TMath::Sin(alpha);
3437 npoints++;
3438 }
3439
3440 xprof[npoints] = kSuppBackRingBase -
3441 kSuppBackRingPlacSid*TMath::Tan(kSuppBackRingPlacAng);
3442 yprof[npoints] = yprof[npoints-1];
3443 npoints++;
3444
3445 xprof[npoints] = kSuppBackRingBase;
3446 yprof[npoints] = kSuppForwYTrans;
3447 npoints++;
3448 // ...then the internal profile (the arc is approximated with segments)
3449 alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint);
3450 alphamax = TMath::Pi()/2;
3451
3452 for (Int_t jp = 0; jp < kSuppBackRingNPtsArc; jp++) {
3453 Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppBackRingNPtsArc;
3454 xprof[npoints] = kSuppBackRingRint*TMath::Cos(alpha);
3455 yprof[npoints] = kSuppBackRingRint*TMath::Sin(alpha);
3456 npoints++;
3457 }
3458
3459 xprof[npoints] = 0;
3460 yprof[npoints] = kSuppBackRingRint;
3461 npoints++;
3462 // We did the right side! now reflex on the left side (except last point)
3463 for (Int_t jp = 0; jp < npoints-1; jp++) {
3464 xprof[npoints+jp] = -xprof[npoints-jp-2];
3465 yprof[npoints+jp] = yprof[npoints-jp-2];
3466 }
3467 // And now the actual Xtru
3468 firstSuppBackRing->DefinePolygon(2*npoints-1, xprof, yprof);
3469 firstSuppBackRing->DefineSection(0,0);
3470 firstSuppBackRing->DefineSection(1,kSuppBackRingThick1);
3471
3472 // The second part of the Back Ring (part of 0872/G/B/01): a Pcon
3473 // (slight oversimplification)
3474 alphamin = TMath::ASin(kSuppForwYTrans/kSuppBackRingRint)*TMath::RadToDeg();
3475 alphamax = 180 - alphamin;
3476
3477 TGeoPcon *secondSuppBackRing = new TGeoPcon(alphamin,alphamax-alphamin,6);
3478
3479 deltaR = kSuppBackRingThick2/TMath::Sin(kSuppBackRing2ndAng1);
3480 rmin = kSuppBackRingRint - kSuppBackRingThick1/TMath::Tan(kSuppBackRing2ndAng1);
3481 rmax = rmin + deltaR + kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
3482 secondSuppBackRing->DefineSection(0, 0, rmin, rmax);
3483
3484 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1/3));
3485 rmax -= kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1/3);
3486 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3487 secondSuppBackRing->DefineSection(1, zloc, rmin, rmax);
3488
3489 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1*2/3));
3490 rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1*2/3);
3491 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3492 secondSuppBackRing->DefineSection(2, zloc, rmin, rmax);
3493
3494 zloc = kSuppBackRingR10*(1 - TMath::Cos(kSuppBackRing2ndAng1));
3495 rmax = secondSuppBackRing->GetRmax(0) - kSuppBackRingR10*TMath::Sin(kSuppBackRing2ndAng1);
3496 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3497 secondSuppBackRing->DefineSection(3, zloc, rmin, rmax);
3498
3499 slp1 = TMath::Tan(kSuppBackRing2ndAng2);
3500 slp2 = TMath::Tan(TMath::Pi()/2 + kSuppBackRing2ndAng1);
3501 IntersectLines(-slp1,kSuppBackRingThikAll,deltaR/2,
3502 slp2,kSuppBackRingThikAll,deltaR,
3503 xm, ym);
3504
3505 zloc = xm - kSuppBackRingThick1;
3506 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3507 rmax = rmin + deltaR;
3508 secondSuppBackRing->DefineSection(4, zloc, rmin, rmax);
3509
3510 zloc = kSuppBackRingThikAll - kSuppBackRingThick1;
3511 rmin = secondSuppBackRing->GetRmin(0) - zloc/TMath::Tan(kSuppBackRing2ndAng1);
3512 rmax = rmin + deltaR/2;
3513 secondSuppBackRing->DefineSection(5, zloc, rmin, rmax);
3514
3515 // The supporting rod: a Tube
3516 TGeoTube *suppRod = new TGeoTube(0, kBackRodDiameter/2,
3517 (kBackRodLength - kBackRodThickLen)/2);
3518
3519 // The Back Ring (0872/G/C/01): another complex Xtru
3520 TGeoXtru *suppRearRing = new TGeoXtru(2);
3521
3522 // First the external profile...
3523 npoints = 0;
3524
3525 xprof[npoints] = kSuppRearRingTopWide;
3526 yprof[npoints] = kSuppRearRingHeight;
3527 npoints++;
3528
3529 phi = kSuppRearRing1stAng;
3530 slp1 = TMath::Tan(TMath::Pi() - phi);
3531 phi += kSuppRearRingStepAng;
3532 slp2 = TMath::Tan(TMath::Pi() - phi);
3533 xm = kSuppRearRingRext2*TMath::Sin(phi);
3534 ym = kSuppRearRingRext2*TMath::Cos(phi);
3535 IntersectLines(slp1, kSuppRearRingTopWide, kSuppRearRingHeight,
3536 slp2, xm, ym,
3537 xprof[npoints], yprof[npoints]);
3538 npoints++;
3539
3540 slp1 = slp2;
3541 phi += kSuppRearRingStepAng;
3542 slp2 = TMath::Tan(TMath::Pi() - phi);
3543 xm = kSuppRearRingRext1*TMath::Sin(phi);
3544 ym = kSuppRearRingRext1*TMath::Cos(phi);
3545 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3546 slp2, xm, ym,
3547 xprof[npoints], yprof[npoints]);
3548 npoints++;
3549
3550 slp1 = slp2;
3551 phi += kSuppRearRingStepAng;
3552 slp2 = TMath::Tan(TMath::Pi() - phi);
3553 xm = kSuppRearRingRext2*TMath::Sin(phi);
3554 ym = kSuppRearRingRext2*TMath::Cos(phi);
3555 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3556 slp2, xm, ym,
3557 xprof[npoints], yprof[npoints]);
3558 npoints++;
3559
3560 slp1 = slp2;
3561 slp2 = 0;
3562 xm = kSuppRearRingBase;
3563 ym = kSuppRearRingBaseHi + kSuppRearRingSideHi;
3564 IntersectLines(slp1, xprof[npoints-1], yprof[npoints-1],
3565 slp2, xm, ym,
3566 xprof[npoints], yprof[npoints]);
3567 npoints++;
3568
3569 xprof[npoints] = kSuppRearRingBase;
3570 yprof[npoints] = kSuppRearRingBaseHi + kSuppRearRingSideHi;
3571 npoints++;
3572 xprof[npoints] = xprof[npoints - 1];
3573 yprof[npoints] = kSuppRearRingBaseHi;
3574 npoints++;
3575 xprof[npoints] = xprof[npoints - 1] - kSuppRearRingInside;
3576 yprof[npoints] = yprof[npoints - 1];
3577 npoints++;
3578 xprof[npoints] = xprof[npoints - 1];
3579 yprof[npoints] = yprof[npoints - 1] + kSuppRearRingInsideHi;
3580 npoints++;
3581 // ...then the internal arc, approximated with segments,...
3582 xprof[npoints] = kSuppRearRingRint;
3583 yprof[npoints] = yprof[npoints - 1];
3584
3585 alphamin = TMath::ASin(kSuppRearRingBaseHi/kSuppRearRingRint);
3586 alphamax = TMath::Pi()/2;
3587
3588 for (Int_t jp = 1; jp < kSuppRearRingNPtsArc; jp++) {
3589 Double_t alpha = alphamin + jp*(alphamax-alphamin)/kSuppRearRingNPtsArc;
3590 xprof[npoints+jp] = kSuppRearRingRint*TMath::Cos(alpha);
3591 yprof[npoints+jp] = kSuppRearRingRint*TMath::Sin(alpha);
3592 }
3593
3594 xprof[npoints+kSuppRearRingNPtsArc] = 0;
3595 yprof[npoints+kSuppRearRingNPtsArc] = kSuppRearRingRint;
3596 // We did the right side! now reflex on the left side
3597 Int_t nTotalPoints = npoints+kSuppRearRingNPtsArc;
3598 for (Int_t jp = 0; jp < nTotalPoints; jp++) {
3599 xprof[nTotalPoints+1+jp] = -xprof[nTotalPoints-1-jp];
3600 yprof[nTotalPoints+1+jp] = yprof[nTotalPoints-1-jp];
3601 }
3602
3603 // And now the actual Xtru
3604 suppRearRing->DefinePolygon(2*nTotalPoints+1, xprof, yprof);
3605 suppRearRing->DefineSection(0,0);
3606 suppRearRing->DefineSection(1,kSuppRearRingThick);
3607
3608
3609 // We have all shapes: now create the real volumes
3610 TGeoMedium *medAl = mgr->GetMedium("ITS_ANTICORODAL$");
3611
3612 TGeoVolume *sideAExtSuppRing = new TGeoVolume("ITSsuppSideAExtSuppRing",
3613 extSuppRing, medAl);
3614
3615 sideAExtSuppRing->SetVisibility(kTRUE);
3616 sideAExtSuppRing->SetLineColor(kMagenta+1);
3617 sideAExtSuppRing->SetLineWidth(1);
3618 sideAExtSuppRing->SetFillColor(sideAExtSuppRing->GetLineColor());
3619 sideAExtSuppRing->SetFillStyle(4000); // 0% transparent
3620
3621 TGeoVolume *sideAIntSuppRing = new TGeoVolume("ITSsuppSideAIntSuppRing",
3622 intSuppRing, medAl);
3623
3624 sideAIntSuppRing->SetVisibility(kTRUE);
3625 sideAIntSuppRing->SetLineColor(kMagenta+1);
3626 sideAIntSuppRing->SetLineWidth(1);
3627 sideAIntSuppRing->SetFillColor(sideAIntSuppRing->GetLineColor());
3628 sideAIntSuppRing->SetFillStyle(4000); // 0% transparent
3629
3630 TGeoVolume *sideASuppCyl = new TGeoVolume("ITSsuppSideASuppCyl",
3631 interCylind, medAl);
3632
3633 sideASuppCyl->SetVisibility(kTRUE);
3634 sideASuppCyl->SetLineColor(kMagenta+1);
3635 sideASuppCyl->SetLineWidth(1);
3636 sideASuppCyl->SetFillColor(sideASuppCyl->GetLineColor());
3637 sideASuppCyl->SetFillStyle(4000); // 0% transparent
3638
3639 TGeoVolume *sideASuppSpacer = new TGeoVolume("ITSsuppSideASuppSpacer",
3640 suppSpacer, medAl);
3641
3642 sideASuppSpacer->SetVisibility(kTRUE);
3643 sideASuppSpacer->SetLineColor(kMagenta+1);
3644 sideASuppSpacer->SetLineWidth(1);
3645 sideASuppSpacer->SetFillColor(sideASuppSpacer->GetLineColor());
3646 sideASuppSpacer->SetFillStyle(4000); // 0% transparent
3647
3648 TGeoVolume *sideASuppForwRing = new TGeoVolume("ITSsuppSideASuppForwRing",
3649 forwardRing, medAl);
3650
3651 sideASuppForwRing->SetVisibility(kTRUE);
3652 sideASuppForwRing->SetLineColor(kMagenta+1);
3653 sideASuppForwRing->SetLineWidth(1);
3654 sideASuppForwRing->SetFillColor(sideASuppForwRing->GetLineColor());
3655 sideASuppForwRing->SetFillStyle(4000); // 0% transparent
3656
3657 TGeoVolume *sideASuppForwCone = new TGeoVolume("ITSsuppSideASuppForwCone",
3658 forwardCone, medAl);
3659
3660 sideASuppForwCone->SetVisibility(kTRUE);
3661 sideASuppForwCone->SetLineColor(kMagenta+1);
3662 sideASuppForwCone->SetLineWidth(1);
3663 sideASuppForwCone->SetFillColor(sideASuppForwCone->GetLineColor());
3664 sideASuppForwCone->SetFillStyle(4000); // 0% transparent
3665
3666 TGeoVolume *sideAFirstSuppBackRing = new TGeoVolume("ITSsuppSideAFirstSuppBackRing",
3667 firstSuppBackRing, medAl);
3668
3669 sideAFirstSuppBackRing->SetVisibility(kTRUE);
3670 sideAFirstSuppBackRing->SetLineColor(kMagenta+1);
3671 sideAFirstSuppBackRing->SetLineWidth(1);
3672 sideAFirstSuppBackRing->SetFillColor(sideAFirstSuppBackRing->GetLineColor());
3673 sideAFirstSuppBackRing->SetFillStyle(4000); // 0% transparent
3674
3675 TGeoVolume *sideASecondSuppBackRing = new TGeoVolume("ITSsuppSideASecondSuppBackRing",
3676 secondSuppBackRing, medAl);
3677
3678 sideASecondSuppBackRing->SetVisibility(kTRUE);
3679 sideASecondSuppBackRing->SetLineColor(kMagenta+1);
3680 sideASecondSuppBackRing->SetLineWidth(1);
3681 sideASecondSuppBackRing->SetFillColor(sideASecondSuppBackRing->GetLineColor());
3682 sideASecondSuppBackRing->SetFillStyle(4000); // 0% transparent
3683
3684 TGeoVolume *sideASuppRod = new TGeoVolume("ITSsuppSideASuppRod",
3685 suppRod, medAl);
3686
3687 sideASuppRod->SetVisibility(kTRUE);
3688 sideASuppRod->SetLineColor(kMagenta+1);
3689 sideASuppRod->SetLineWidth(1);
3690 sideASuppRod->SetFillColor(sideASuppRod->GetLineColor());
3691 sideASuppRod->SetFillStyle(4000); // 0% transparent
3692
3693 TGeoVolume *sideASuppRearRing = new TGeoVolume("ITSsuppSideASuppRearRing",
3694 suppRearRing, medAl);
3695
3696 sideASuppRearRing->SetVisibility(kTRUE);
3697 sideASuppRearRing->SetLineColor(kMagenta+1);
3698 sideASuppRearRing->SetLineWidth(1);
3699 sideASuppRearRing->SetFillColor(sideASuppRearRing->GetLineColor());
3700 sideASuppRearRing->SetFillStyle(4000); // 0% transparent
3701
3702
3703 // Now build up the support structure
3704 zloc = kSuppRingZTrans;
3705 trayASuppStruct->AddNode(sideAExtSuppRing, 1,
3706 new TGeoTranslation(0, 0, zloc) );
3707 trayASuppStruct->AddNode(sideAExtSuppRing, 2,
3708 new TGeoCombiTrans( 0, 0, zloc,
3709 new TGeoRotation("",180,0,0)));
3710
3711 zloc += kExtSuppRingThick;
3712 trayASuppStruct->AddNode(sideAIntSuppRing, 1,
3713 new TGeoTranslation(0, 0, zloc) );
3714 trayASuppStruct->AddNode(sideAIntSuppRing, 2,
3715 new TGeoCombiTrans( 0, 0, zloc,
3716 new TGeoRotation("",180,0,0)));
3717
3718 xloc = kExtSuppRingBase - kIntSuppRingInward;
3719 yloc = kSuppRingYTrans;
3720 zloc += (kIntSuppRingThick + kSuppCylHeight/2);
3721 trayASuppStruct->AddNode(sideASuppCyl, 1,
3722 new TGeoTranslation(0, 0, zloc) );
3723 trayASuppStruct->AddNode(sideASuppCyl, 2,
3724 new TGeoCombiTrans( 0, 0, zloc,
3725 new TGeoRotation("",180,0,0)));
3726 trayASuppStruct->AddNode(sideASuppSpacer, 1,
3727 new TGeoCombiTrans( xloc, yloc, zloc,
3728 new TGeoRotation("",90+kSuppSpacerAngle,0,0)));
3729 trayASuppStruct->AddNode(sideASuppSpacer, 2,
3730 new TGeoCombiTrans(-xloc, yloc, zloc,
3731 new TGeoRotation("",0,180,kSuppSpacerAngle-90)));
3732 trayASuppStruct->AddNode(sideASuppSpacer, 3,
3733 new TGeoCombiTrans( xloc,-yloc, zloc,
3734 new TGeoRotation("",180,180,kSuppSpacerAngle-90)));
3735 trayASuppStruct->AddNode(sideASuppSpacer, 4,
3736 new TGeoCombiTrans(-xloc,-yloc, zloc,
3737 new TGeoRotation("",270+kSuppSpacerAngle,0,0)));
3738
3739
3740 zloc += kSuppCylHeight/2;
3741 trayASuppStruct->AddNode(sideAIntSuppRing, 3,
3742 new TGeoTranslation(0, 0, zloc) );
3743 trayASuppStruct->AddNode(sideAIntSuppRing, 4,
3744 new TGeoCombiTrans( 0, 0, zloc,
3745 new TGeoRotation("",180,0,0)));
3746
3747 zloc += kIntSuppRingThick;
3748 trayASuppStruct->AddNode(sideAExtSuppRing, 3,
3749 new TGeoTranslation(0, 0, zloc) );
3750 trayASuppStruct->AddNode(sideAExtSuppRing, 4,
3751 new TGeoCombiTrans( 0, 0, zloc,
3752 new TGeoRotation("",180,0,0)));
3753
3754 zloc += kExtSuppRingThick;
3755 trayASuppStruct->AddNode(sideASuppForwRing, 1,
3756 new TGeoTranslation(0, 0, zloc) );
3757 trayASuppStruct->AddNode(sideASuppForwRing, 2,
3758 new TGeoCombiTrans( 0, 0, zloc,
3759 new TGeoRotation("",180,0,0)));
3760
3761 zloc += kSuppForwRingThikAll;
3762 trayASuppStruct->AddNode(sideASuppForwCone, 1,
3763 new TGeoTranslation(0, 0, zloc) );
3764 trayASuppStruct->AddNode(sideASuppForwCone, 2,
3765 new TGeoCombiTrans( 0, 0, zloc,
3766 new TGeoRotation("",180,0,0)));
3767
3768 zloc += (kSuppForwConeLen1+kSuppForwConeLen2);
3769 trayASuppStruct->AddNode(sideAFirstSuppBackRing, 1,
3770 new TGeoTranslation(0, 0, zloc) );
3771 trayASuppStruct->AddNode(sideAFirstSuppBackRing, 2,
3772 new TGeoCombiTrans( 0, 0, zloc,
3773 new TGeoRotation("",180,0,0)));
3774
3775 zloc += kSuppBackRingThick1;
3776 trayASuppStruct->AddNode(sideASecondSuppBackRing, 1,
3777 new TGeoTranslation(0, 0, zloc) );
3778 trayASuppStruct->AddNode(sideASecondSuppBackRing, 2,
3779 new TGeoCombiTrans( 0, 0, zloc,
3780 new TGeoRotation("",180,0,0)));
3781
3782 xloc = kSuppRearRingXRodHole;
3783 yloc = kSuppRearRingBaseHi + kSuppRearRingYRodHole;
3784 zloc = kRearSuppZTransGlob - kBackRodZTrans + suppRod->GetDz();
3785 trayASuppStruct->AddNode(sideASuppRod, 1,
3786 new TGeoTranslation( xloc, yloc, zloc) );
3787 trayASuppStruct->AddNode(sideASuppRod, 2,
3788 new TGeoTranslation(-xloc, yloc, zloc) );
3789 trayASuppStruct->AddNode(sideASuppRod, 3,
3790 new TGeoTranslation( xloc,-yloc, zloc) );
3791 trayASuppStruct->AddNode(sideASuppRod, 4,
3792 new TGeoTranslation(-xloc,-yloc, zloc) );
3793
3794 zloc += suppRod->GetDz();
3795 trayASuppStruct->AddNode(sideASuppRearRing, 1,
3796 new TGeoTranslation( 0, 0, zloc) );
3797 trayASuppStruct->AddNode(sideASuppRearRing, 2,
3798 new TGeoCombiTrans( 0, 0, zloc,
3799 new TGeoRotation("",180,0,0)));
3800
3801
3802 // Finally put everything in the mother volume
3803 moth->AddNode(trayASuppStruct,1,0);
3804
3805 return;
3806}
3807
3808//______________________________________________________________________
3809void AliITSv11GeometrySupport::ServicesCableSupportSPD(TGeoVolume *moth,
3810 TGeoManager *mgr){
3811//
3812// Creates the all SPD cable trays which are outside the ITS support cones
3813// but still inside the TPC
3814// In order to avoid a huge monolithic routine, this method actually
3815// calls inner methods to create and assemble the various (macro)pieces
3816//
3817// Input:
3818// moth : the TGeoVolume owing the volume structure
3819// mgr : the GeoManager (default gGeoManager)
3820// Output:
3821//
3822// Created: ??? Bjorn S. Nilsen
3823// Updated: 15 Nov 2009 Mario Sitta
3824//
3825// Technical data are taken from AutoCAD drawings and other (oral)
3826// information given by F.Tosello
3827//
3828
3829 SPDCableTraysSideA(moth, mgr);
aa177c73 3830 SPDCableTraysSideC(moth, mgr);
798b4e0c 3831
3832}
3833
3834//______________________________________________________________________
3835void AliITSv11GeometrySupport::ServicesCableSupportSDD(TGeoVolume *moth,
3836 TGeoManager *mgr){
3837//
3838// Creates the all SDD cable trays which are outside the ITS support cones
3839// but still inside the TPC
3840// In order to avoid a huge monolithic routine, this method actually
3841// calls inner methods to create and assemble the various (macro)pieces
3842//
3843// Input:
3844// moth : the TGeoVolume owing the volume structure
3845// mgr : the GeoManager (default gGeoManager)
3846// Output:
3847//
3848// Created: 14 Dec 2009 Mario Sitta
3849//
3850
3851 SDDCableTraysSideA(moth, mgr);
aa177c73 3852 SDDCableTraysSideC(moth, mgr);
798b4e0c 3853
3854 return;
3855}
3856
3857//______________________________________________________________________
3858void AliITSv11GeometrySupport::ServicesCableSupportSSD(TGeoVolume *moth,
3859 TGeoManager *mgr){
3860//
3861// Creates the SSD cable trays which are outside the ITS support cones
3862// but still inside the TPC
3863// In order to avoid a huge monolithic routine, this method actually
3864// calls inner methods to create and assemble the various (macro)pieces
3865//
3866// Input:
3867// moth : the TGeoVolume owing the volume structure
3868// mgr : the GeoManager (default gGeoManager)
3869// Output:
3870//
3871// Created: 15 Nov 2009 Mario Sitta
3872//
3873
3874 SSDCableTraysSideA(moth, mgr);
aa177c73 3875 SSDCableTraysSideC(moth, mgr);
798b4e0c 3876
3877 return;
3878}
3879
3880//______________________________________________________________________
3881void AliITSv11GeometrySupport::SPDCableTraysSideA(TGeoVolume *moth,
43aefea7 3882 const TGeoManager *mgr){
798b4e0c 3883//
3884// Creates the SPD cable trays which are outside the ITS support cones
3885// but still inside the TPC on Side A
3886// (part of this code is taken or anyway inspired to ServicesCableSupport
3887// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
3888//
3889// Input:
3890// moth : the TGeoVolume owing the volume structure
3891// mgr : the GeoManager (default gGeoManager)
3892// Output:
3893//
3894// Created: 15 Feb 2010 Mario Sitta
96eb8210 3895// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
57126ea1 3896// Updated: 08 Sep 2010 Mario Sitta
1c5895a3 3897// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
798b4e0c 3898//
3899// Technical data are taken from AutoCAD drawings, L.Simonetti technical
3900// drawings and other (oral) information given by F.Tosello and D.Elia
3901// (small differences with blueprints - e.g. -0.07mm in R1Trans and
3902// R2Trans - fix small overlaps; they are then compensated in positioning
3903// the Rear Tray to avoid its own overlaps with the rear supporting ring)
57126ea1 3904// Optical fibers and voltage cables are approximated with mean materials
3905// and square cross sections, but preserving the total material budget.
798b4e0c 3906//
3907
3908 // Overall position and rotation of the A-Side Cable Trays
3909 // (parts of 0872/G/D)
3910 const Double_t kTrayAR1Trans = 396.93 *fgkmm;
3911 const Double_t kTrayAR2Trans = 413.93 *fgkmm;
3912 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
3913 const Double_t kTrayAZRot = (180-169.5);// Degrees
3914 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
3915 const Double_t kTrayASecondRotAng = 15.00; // Degrees
3916
3917 const Double_t kForwardTrayWide = 94.00 *fgkmm;//!!!TO BE CHECKED!!!
3918 const Double_t kForwardTrayFirstHigh = 83.00 *fgkmm;//!!!TO BE CHECKED!!!
3919 const Double_t kForwardTraySecondHigh = 52.70 *fgkmm;//!!!TO BE CHECKED!!!
3920 const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
3921 const Double_t kForwardTrayFirstLen = 435.00 *fgkmm;
3922 const Double_t kForwardTrayWingWide = 16.00 *fgkmm;//!!!TO BE CHECKED!!!
3923 const Double_t kForwardTrayInterSpace = 18.00 *fgkmm;//!!!TO BE CHECKED!!!
3924 const Double_t kForwardTrayThick = 2.00 *fgkmm;
3925
1c5895a3 3926 const Int_t kForwardSideNpoints = 6;
798b4e0c 3927
3928 const Double_t kExternalTrayLen = 1200.00 *fgkmm;
3929 const Double_t kExternalTrayWide = kForwardTrayWide;
3930 const Double_t kExternalTrayHigh = kForwardTraySecondHigh;
3931 const Double_t kExternalTrayThick = kForwardTrayThick;
3932
57126ea1 3933 const Double_t kCoolingTubeRmin = 2.00 *fgkmm;
3934 const Double_t kCoolingTubeRmax = 3.00 *fgkmm;
798b4e0c 3935
3936 const Double_t kOpticalFibersSect = 8.696*fgkmm;//!!!ESTIMATED!!!
57126ea1 3937 const Double_t kLowVoltageCableSectCu = 7.675*fgkmm;// Computed
3938 const Double_t kLowVoltageCableHighPUR = 1.000*fgkmm;// Computed
3939 const Double_t kHiVoltageCableSectCu = 1.535*fgkmm;// Computed
3940 const Double_t kHiVoltageCableHighPUR = 0.500*fgkmm;// Computed
d8826f33 3941 const Double_t kCoaxCableSectCu = 6.024*fgkmm;// Computed
3942 const Double_t kCoaxCableHighMeg = 5.695*fgkmm;// Computed
96eb8210 3943
1c5895a3 3944 const Double_t kTrayCCablesRot = 75.000*fgkDegree;// Computed
3945 const Double_t kTrayCCablesZLenOut = 227.000*fgkmm;// Computed
3946
798b4e0c 3947
3948 // Local variables
3949 Double_t xprof[kForwardSideNpoints], yprof[kForwardSideNpoints];
3950 Double_t xloc, yloc, zloc, alpharot;
3951
3952
3953 // The two tray components as assemblies
3954 TGeoVolumeAssembly *cableTrayAForw =
3955 new TGeoVolumeAssembly("ITSsupportSPDTrayAForwRear");
3956 TGeoVolumeAssembly *cableTrayAExt =
3957 new TGeoVolumeAssembly("ITSsupportSPDTrayAExt");
3958
3959
3960 // First create all needed shapes
3961
3962 // The lower face of the forward tray: a BBox
3963 TGeoBBox *forwTrayLowerFace = new TGeoBBox(kForwardTrayWide/2,
3964 kForwardTrayThick/2,
3965 kForwardTrayTotalLen/2);
3966
3967 // The side face of the forward tray: a Xtru
3968 TGeoXtru *forwTraySideFace = new TGeoXtru(2);
3969 forwTraySideFace->SetName("ITSsuppSPDForwTraySide");
3970
3971 xprof[0] = 0;
3972 yprof[0] = kForwardTrayThick;
3973 xprof[1] = kForwardTrayTotalLen;
3974 yprof[1] = yprof[0];
3975 xprof[2] = xprof[1];
3976 yprof[2] = kForwardTraySecondHigh - kForwardTrayThick;
3977 xprof[3] = kForwardTrayFirstLen;
3978 yprof[3] = yprof[2];
3979 xprof[4] = xprof[3];
3980 yprof[4] = kForwardTrayFirstHigh - kForwardTrayThick;
3981 xprof[5] = xprof[0];
3982 yprof[5] = yprof[4];
3983
3984 forwTraySideFace->DefinePolygon(6, xprof, yprof);
3985 forwTraySideFace->DefineSection(0, 0);
3986 forwTraySideFace->DefineSection(1, kForwardTrayThick);
3987
3988 // The covers of the forward tray: two BBox's
3989 TGeoBBox *forwTrayShortCover = new TGeoBBox(kForwardTrayWide/2,
3990 kForwardTrayThick/2,
3991 kForwardTrayFirstLen/2);
3992
3993 TGeoBBox *forwTrayLongCover = new TGeoBBox(kForwardTrayWide/2,
3994 kForwardTrayThick/2,
3995 (kForwardTrayTotalLen - kForwardTrayFirstLen)/2);
3996
3997 // Each small wing of the forward tray: a BBox
3998 TGeoBBox *forwTrayWing = new TGeoBBox(kForwardTrayWingWide/2,
3999 (kForwardTrayFirstHigh-kForwardTraySecondHigh)/2,
4000 kForwardTrayThick/2);
4001
4002 // The internal plane of the forward tray: a BBox
4003 TGeoBBox *forwTrayPlane = new TGeoBBox(kForwardTrayWide/2-kForwardTrayThick,
4004 kForwardTrayThick/2,
4005 kForwardTrayTotalLen/2);
4006
4007 // The internal wall of the forward tray: a BBox
4008 TGeoBBox *forwTrayWall = new TGeoBBox(kForwardTrayThick/2,
4009 (kForwardTrayInterSpace-kForwardTrayThick)/2,
4010 kForwardTrayTotalLen/2);
4011
4012 // Each horizontal face of the external tray: a BBox
4013 TGeoBBox *extTrayHorFace = new TGeoBBox(kExternalTrayWide/2-kExternalTrayThick,
4014 kExternalTrayThick/2,
4015 kExternalTrayLen/2);
4016
4017 // Each vertical face of the external tray: a BBox
4018 TGeoBBox *extTrayVerFace = new TGeoBBox(kExternalTrayThick/2,
4019 kExternalTrayHigh/2,
4020 kExternalTrayLen/2);
4021
4022 // The internal wall of the external tray: a BBox
4023 TGeoBBox *extTrayWall = new TGeoBBox(kExternalTrayThick/2,
4024 (kForwardTrayInterSpace-kExternalTrayThick)/2,
4025 kExternalTrayLen/2);
4026
96eb8210 4027 // The cooling tube inside the forward tray: a Tube
798b4e0c 4028 Double_t zelong = (kForwardTraySecondHigh - 2*kForwardTrayThick
4029 - 2*forwTrayWall->GetDY() - kCoolingTubeRmax)*SinD(kTrayAZRot);
4030 Double_t zlen = (zelong + kForwardTrayTotalLen)/2;
96eb8210 4031 TGeoTube *coolTubeForw = new TGeoTube(0, kCoolingTubeRmax, zlen);
4032
4033 // The freon inside the forward tray tubes: a Tube
4034 TGeoTube *freonTubeForw = new TGeoTube(0, kCoolingTubeRmin, zlen);
798b4e0c 4035
4036 // The cooling tube inside the external tray: a Ctub
96eb8210 4037 TGeoCtub *coolTubeExt = new TGeoCtub(0, kCoolingTubeRmax,
798b4e0c 4038 kExternalTrayLen/2, 0, 360,
4039 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
4040 0, 0, 1);
4041
96eb8210 4042 // The freon inside the forward tray tubes: a Tube
4043 TGeoCtub *freonTubeExt = new TGeoCtub(0, kCoolingTubeRmin,
4044 kExternalTrayLen/2, 0, 360,
4045 0, SinD(kTrayAZRot),-CosD(kTrayAZRot),
4046 0, 0, 1);
4047
1c5895a3 4048 // The optical fibers inside the forward tray: a Xtru
4049 TGeoXtru *optFibsForw = new TGeoXtru(2);
4050
4051 xprof[0] = -kTrayCCablesZLenOut;
4052 yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
4053 xprof[1] = 0;
4054 yprof[1] = 0;
4055 xprof[2] = kForwardTrayTotalLen;
4056 yprof[2] = yprof[1];
4057 xprof[3] = xprof[2];
4058 yprof[3] = yprof[2] + kOpticalFibersSect;
4059 xprof[4] = xprof[1];
4060 yprof[4] = yprof[3];
4061 xprof[5] = xprof[0];
4062 yprof[5] = yprof[0] + kOpticalFibersSect;
4063
4064 optFibsForw->DefinePolygon(6, xprof, yprof);
4065 optFibsForw->DefineSection(0,-kOpticalFibersSect/2);
4066 optFibsForw->DefineSection(1, kOpticalFibersSect/2);
798b4e0c 4067
4068 // The optical fibers inside the external tray: a Xtru
4069 TGeoXtru *optFibsExt = new TGeoXtru(2);
1c5895a3 4070 optFibsExt->SetName("ITSsuppSPDExtTrayOptFibs");
798b4e0c 4071
4072 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
4073 + 2*forwTrayWall->GetDY();
4074 xprof[0] = yprof[0]*TanD(kTrayAZRot);
4075 xprof[1] = kExternalTrayLen;
4076 yprof[1] = yprof[0];
4077 xprof[2] = xprof[1];
4078 yprof[2] = yprof[1] + kOpticalFibersSect;
4079 yprof[3] = yprof[2];
4080 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4081
4082 optFibsExt->DefinePolygon(4, xprof, yprof);
4083 optFibsExt->DefineSection(0, 0);
4084 optFibsExt->DefineSection(1, kOpticalFibersSect);
4085
1c5895a3 4086 // The Low Voltage cables inside the forward tray: two Xtru
4087 TGeoXtru *lowCablesForwCu = new TGeoXtru(2);
4088
4089 xprof[0] = -kTrayCCablesZLenOut;
4090 yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
4091 xprof[1] = 0;
4092 yprof[1] = 0;
4093 xprof[2] = kForwardTrayTotalLen;
4094 yprof[2] = yprof[1];
4095 xprof[3] = xprof[2];
4096 yprof[3] = yprof[2] + kLowVoltageCableSectCu/2;
4097 xprof[4] = xprof[1];
4098 yprof[4] = yprof[3];
4099 xprof[5] = xprof[0];
4100 yprof[5] = yprof[0] + kLowVoltageCableSectCu/2;
4101
4102 lowCablesForwCu->DefinePolygon(6, xprof, yprof);
4103 lowCablesForwCu->DefineSection(0,-kLowVoltageCableSectCu);
4104 lowCablesForwCu->DefineSection(1, kLowVoltageCableSectCu);
57126ea1 4105
1c5895a3 4106 TGeoXtru *lowCablesForwPUR = new TGeoXtru(2);
4107
4108 xprof[0] = lowCablesForwCu->GetX(5);
4109 yprof[0] = lowCablesForwCu->GetY(5);
4110 xprof[1] = lowCablesForwCu->GetX(4);
4111 yprof[1] = lowCablesForwCu->GetY(4);
4112 xprof[2] = lowCablesForwCu->GetX(3);
4113 yprof[2] = lowCablesForwCu->GetY(3);
4114 xprof[3] = xprof[2];
4115 yprof[3] = yprof[2] + kLowVoltageCableHighPUR/2;
4116 xprof[4] = xprof[1];
4117 yprof[4] = yprof[3];
4118 xprof[5] = xprof[0];
4119 yprof[5] = yprof[0] + kLowVoltageCableHighPUR/2;
4120
4121 lowCablesForwPUR->DefinePolygon(6, xprof, yprof);
4122 lowCablesForwPUR->DefineSection(0,-kLowVoltageCableSectCu);
4123 lowCablesForwPUR->DefineSection(1, kLowVoltageCableSectCu);
798b4e0c 4124
57126ea1 4125 // The Low Voltage inside the external tray: two Xtru
4126 TGeoXtru *lowCablesExtCu = new TGeoXtru(2);
4127 lowCablesExtCu->SetName("ITSsuppSPDExtTrayLowVoltageCu");
798b4e0c 4128
4129 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
4130 + 2*forwTrayWall->GetDY();
4131 xprof[0] = yprof[0]*TanD(kTrayAZRot);
4132 xprof[1] = kExternalTrayLen;
4133 yprof[1] = yprof[0];
4134 xprof[2] = xprof[1];
57126ea1 4135 yprof[2] = yprof[1] + kLowVoltageCableSectCu/2;
798b4e0c 4136 yprof[3] = yprof[2];
4137 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4138
57126ea1 4139 lowCablesExtCu->DefinePolygon(4, xprof, yprof);
4140 lowCablesExtCu->DefineSection(0, 0);
4141 lowCablesExtCu->DefineSection(1, kLowVoltageCableSectCu*2);
798b4e0c 4142
57126ea1 4143 TGeoXtru *lowCablesExtPUR = new TGeoXtru(2);
4144 lowCablesExtPUR->SetName("ITSsuppSPDExtTrayLowVoltagePUR");
4145
4146 xprof[0] = lowCablesExtCu->GetX(3);
4147 yprof[0] = lowCablesExtCu->GetY(3);
4148 xprof[1] = lowCablesExtCu->GetX(2);
4149 yprof[1] = lowCablesExtCu->GetY(2);
4150 xprof[2] = xprof[1];
4151 yprof[2] = yprof[1] + kLowVoltageCableHighPUR/2;
4152 yprof[3] = yprof[2];
4153 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4154
4155 lowCablesExtPUR->DefinePolygon(4, xprof, yprof);
4156 lowCablesExtPUR->DefineSection(0, 0);
4157 lowCablesExtPUR->DefineSection(1, kLowVoltageCableSectCu*2);
4158
1c5895a3 4159 // The High Voltage cables inside the forward tray: two Xtru
4160 TGeoXtru *hiCablesForwCu = new TGeoXtru(2);
96eb8210 4161
1c5895a3 4162 xprof[0] = -kTrayCCablesZLenOut;
4163 yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
4164 xprof[1] = 0;
4165 yprof[1] = 0;
4166 xprof[2] = kForwardTrayTotalLen;
4167 yprof[2] = yprof[1];
4168 xprof[3] = xprof[2];
4169 yprof[3] = yprof[2] + kHiVoltageCableSectCu/2;
4170 xprof[4] = xprof[1];
4171 yprof[4] = yprof[3];
4172 xprof[5] = xprof[0];
4173 yprof[5] = yprof[0] + kHiVoltageCableSectCu/2;
4174
4175 hiCablesForwCu->DefinePolygon(6, xprof, yprof);
4176 hiCablesForwCu->DefineSection(0,-kHiVoltageCableSectCu);
4177 hiCablesForwCu->DefineSection(1, kHiVoltageCableSectCu);
4178
4179 TGeoXtru *hiCablesForwPUR = new TGeoXtru(2);
4180
4181 xprof[0] = hiCablesForwCu->GetX(5);
4182 yprof[0] = hiCablesForwCu->GetY(5);
4183 xprof[1] = hiCablesForwCu->GetX(4);
4184 yprof[1] = hiCablesForwCu->GetY(4);
4185 xprof[2] = hiCablesForwCu->GetX(3);
4186 yprof[2] = hiCablesForwCu->GetY(3);
4187 xprof[3] = xprof[2];
4188 yprof[3] = yprof[2] + kHiVoltageCableHighPUR/2;
4189 xprof[4] = xprof[1];
4190 yprof[4] = yprof[3];
4191 xprof[5] = xprof[0];
4192 yprof[5] = yprof[0] + kHiVoltageCableHighPUR/2;
4193
4194 hiCablesForwPUR->DefinePolygon(6, xprof, yprof);
4195 hiCablesForwPUR->DefineSection(0,-kHiVoltageCableSectCu);
4196 hiCablesForwPUR->DefineSection(1, kHiVoltageCableSectCu);
57126ea1 4197
4198 // The High Voltage inside the external tray: two Xtru
4199 TGeoXtru *hiCablesExtCu = new TGeoXtru(2);
4200 hiCablesExtCu->SetName("ITSsuppSPDExtTrayHiVoltageCu");
96eb8210 4201
4202 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
4203 + 2*forwTrayWall->GetDY();
4204 xprof[0] = yprof[0]*TanD(kTrayAZRot);
4205 xprof[1] = kExternalTrayLen;
4206 yprof[1] = yprof[0];
4207 xprof[2] = xprof[1];
57126ea1 4208 yprof[2] = yprof[1] + kHiVoltageCableSectCu/2;
4209 yprof[3] = yprof[2];
4210 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4211
4212 hiCablesExtCu->DefinePolygon(4, xprof, yprof);
4213 hiCablesExtCu->DefineSection(0, 0);
4214 hiCablesExtCu->DefineSection(1, kHiVoltageCableSectCu*2);
4215
4216 TGeoXtru *hiCablesExtPUR = new TGeoXtru(2);
4217 hiCablesExtPUR->SetName("ITSsuppSPDExtTrayHiVoltagePUR");
4218
4219 xprof[0] = hiCablesExtCu->GetX(3);
4220 yprof[0] = hiCablesExtCu->GetY(3);
4221 xprof[1] = hiCablesExtCu->GetX(2);
4222 yprof[1] = hiCablesExtCu->GetY(2);
4223 xprof[2] = xprof[1];
4224 yprof[2] = yprof[1] + kHiVoltageCableHighPUR/2;
4225 yprof[3] = yprof[2];
4226 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4227
4228 hiCablesExtPUR->DefinePolygon(4, xprof, yprof);
4229 hiCablesExtPUR->DefineSection(0, 0);
4230 hiCablesExtPUR->DefineSection(1, kHiVoltageCableSectCu*2);
4231
1c5895a3 4232 // The Coaxial cables inside the forward tray: two Xtru
4233 TGeoXtru *coaxCablesForwCu = new TGeoXtru(2);
d8826f33 4234 coaxCablesForwCu->SetName("ITSsuppSPDForwTrayCoaxCu");
57126ea1 4235
1c5895a3 4236 xprof[0] = -kTrayCCablesZLenOut;
4237 yprof[0] = xprof[0]/TanD(kTrayCCablesRot);
4238 xprof[1] = 0;
4239 yprof[1] = 0;
4240 xprof[2] = kForwardTrayTotalLen;
4241 yprof[2] = yprof[1];
4242 xprof[3] = xprof[2];
4243 yprof[3] = yprof[2] + kCoaxCableSectCu/2;
4244 xprof[4] = xprof[1];
4245 yprof[4] = yprof[3];
4246 xprof[5] = xprof[0];
4247 yprof[5] = yprof[0] + kCoaxCableSectCu/2;
4248
4249 coaxCablesForwCu->DefinePolygon(6, xprof, yprof);
4250 coaxCablesForwCu->DefineSection(0,-kCoaxCableSectCu);
4251 coaxCablesForwCu->DefineSection(1, kCoaxCableSectCu);
4252
d8826f33 4253 TGeoXtru *coaxCablesForwMeg = new TGeoXtru(2);
4254 coaxCablesForwMeg->SetName("ITSsuppSPDForwTrayCoaxMeg");
1c5895a3 4255
4256 xprof[0] = coaxCablesForwCu->GetX(5);
4257 yprof[0] = coaxCablesForwCu->GetY(5);
4258 xprof[1] = coaxCablesForwCu->GetX(4);
4259 yprof[1] = coaxCablesForwCu->GetY(4);
4260 xprof[2] = coaxCablesForwCu->GetX(3);
4261 yprof[2] = coaxCablesForwCu->GetY(3);
4262 xprof[3] = xprof[2];
d8826f33 4263 yprof[3] = yprof[2] + kCoaxCableHighMeg/2;
1c5895a3 4264 xprof[4] = xprof[1];
4265 yprof[4] = yprof[3];
4266 xprof[5] = xprof[0];
d8826f33 4267 yprof[5] = yprof[0] + kCoaxCableHighMeg/2;
1c5895a3 4268
d8826f33 4269 coaxCablesForwMeg->DefinePolygon(6, xprof, yprof);
4270 coaxCablesForwMeg->DefineSection(0,-kCoaxCableSectCu);
4271 coaxCablesForwMeg->DefineSection(1, kCoaxCableSectCu);
57126ea1 4272
4273 // The Coaxial inside the external tray: two Xtru
4274 TGeoXtru *coaxCablesExtCu = new TGeoXtru(2);
4275 coaxCablesExtCu->SetName("ITSsuppSPDExtTrayCoaxCu");
4276
4277 yprof[0] = -kExternalTrayHigh + 2*kExternalTrayThick
4278 + 2*forwTrayWall->GetDY();
4279 xprof[0] = yprof[0]*TanD(kTrayAZRot);
4280 xprof[1] = kExternalTrayLen;
4281 yprof[1] = yprof[0];
4282 xprof[2] = xprof[1];
4283 yprof[2] = yprof[1] + kCoaxCableSectCu/2;
4284 yprof[3] = yprof[2];
4285 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4286
4287 coaxCablesExtCu->DefinePolygon(4, xprof, yprof);
4288 coaxCablesExtCu->DefineSection(0, 0);
4289 coaxCablesExtCu->DefineSection(1, kCoaxCableSectCu*2);
4290
d8826f33 4291 TGeoXtru *coaxCablesExtMeg = new TGeoXtru(2);
4292 coaxCablesExtMeg->SetName("ITSsuppSPDExtTrayCoaxMeg");
57126ea1 4293
4294 xprof[0] = coaxCablesExtCu->GetX(3);
4295 yprof[0] = coaxCablesExtCu->GetY(3);
4296 xprof[1] = coaxCablesExtCu->GetX(2);
4297 yprof[1] = coaxCablesExtCu->GetY(2);
4298 xprof[2] = xprof[1];
d8826f33 4299 yprof[2] = yprof[1] + kCoaxCableHighMeg/2;
96eb8210 4300 yprof[3] = yprof[2];
4301 xprof[3] = yprof[2]*TanD(kTrayAZRot);
4302
d8826f33 4303 coaxCablesExtMeg->DefinePolygon(4, xprof, yprof);
4304 coaxCablesExtMeg->DefineSection(0, 0);
4305 coaxCablesExtMeg->DefineSection(1, kCoaxCableSectCu*2);
96eb8210 4306
798b4e0c 4307
4308 // We have all shapes: now create the real volumes
0801d201 4309 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
4310 TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
96eb8210 4311 TGeoMedium *medFreon = mgr->GetMedium("ITS_GASEOUS FREON$");
0801d201 4312 TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!TO BE CHECKED!
4313 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
4314 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
d8826f33 4315 TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
798b4e0c 4316
4317 TGeoVolume *forwTrayABase = new TGeoVolume("ITSsuppSPDSideAForwTrayABase",
4318 forwTrayLowerFace, medAl);
4319
4320 forwTrayABase->SetVisibility(kTRUE);
4321 forwTrayABase->SetLineColor(6); // Purple
4322 forwTrayABase->SetLineWidth(1);
4323 forwTrayABase->SetFillColor(forwTrayABase->GetLineColor());
4324 forwTrayABase->SetFillStyle(4000); // 0% transparent
4325
4326 TGeoVolume *forwTrayASide = new TGeoVolume("ITSsuppSPDSideAForwTrayASide",
4327 forwTraySideFace, medAl);
4328
4329 forwTrayASide->SetVisibility(kTRUE);
4330 forwTrayASide->SetLineColor(6); // Purple
4331 forwTrayASide->SetLineWidth(1);
4332 forwTrayASide->SetFillColor(forwTrayASide->GetLineColor());
4333 forwTrayASide->SetFillStyle(4000); // 0% transparent
4334
4335 TGeoVolume *forwTrayACoverShort = new TGeoVolume("ITSsuppSPDSideAForwTrayASC",
4336 forwTrayShortCover, medAl);
4337
4338 forwTrayACoverShort->SetVisibility(kTRUE);
4339 forwTrayACoverShort->SetLineColor(6); // Purple
4340 forwTrayACoverShort->SetLineWidth(1);
4341 forwTrayACoverShort->SetFillColor(forwTrayACoverShort->GetLineColor());
4342 forwTrayACoverShort->SetFillStyle(4000); // 0% transparent
4343
4344 TGeoVolume *forwTrayACoverLong = new TGeoVolume("ITSsuppSPDSideAForwTrayALC",
4345 forwTrayLongCover, medAl);
4346
4347 forwTrayACoverLong->SetVisibility(kTRUE);
4348 forwTrayACoverLong->SetLineColor(6); // Purple
4349 forwTrayACoverLong->SetLineWidth(1);
4350 forwTrayACoverLong->SetFillColor(forwTrayACoverLong->GetLineColor());
4351 forwTrayACoverLong->SetFillStyle(4000); // 0% transparent
4352
4353 TGeoVolume *forwTrayAWing = new TGeoVolume("ITSsuppSPDSideAForwTrayAWing",
4354 forwTrayWing, medAl);
4355
4356 forwTrayAWing->SetVisibility(kTRUE);
4357 forwTrayAWing->SetLineColor(6); // Purple
4358 forwTrayAWing->SetLineWidth(1);
4359 forwTrayAWing->SetFillColor(forwTrayAWing->GetLineColor());
4360 forwTrayAWing->SetFillStyle(4000); // 0% transparent
4361
4362 TGeoVolume *forwTrayAPlane = new TGeoVolume("ITSsuppSPDSideAForwTrayAPlane",
4363 forwTrayPlane, medAl);
4364
4365 forwTrayAPlane->SetVisibility(kTRUE);
4366 forwTrayAPlane->SetLineColor(6); // Purple
4367 forwTrayAPlane->SetLineWidth(1);
4368 forwTrayAPlane->SetFillColor(forwTrayAPlane->GetLineColor());
4369 forwTrayAPlane->SetFillStyle(4000); // 0% transparent
4370
4371 TGeoVolume *forwTrayAWall = new TGeoVolume("ITSsuppSPDSideAForwTrayAWall",
4372 forwTrayWall, medAl);
4373
4374 forwTrayAWall->SetVisibility(kTRUE);
4375 forwTrayAWall->SetLineColor(6); // Purple
4376 forwTrayAWall->SetLineWidth(1);
4377 forwTrayAWall->SetFillColor(forwTrayAWall->GetLineColor());
4378 forwTrayAWall->SetFillStyle(4000); // 0% transparent
4379
4380 TGeoVolume *extTrayAHorFace = new TGeoVolume("ITSsuppSPDSideAExtTrayHorFace",
4381 extTrayHorFace, medAl);
4382
4383 extTrayAHorFace->SetVisibility(kTRUE);
4384 extTrayAHorFace->SetLineColor(6); // Purple
4385 extTrayAHorFace->SetLineWidth(1);
4386 extTrayAHorFace->SetFillColor(extTrayAHorFace->GetLineColor());
4387 extTrayAHorFace->SetFillStyle(4000); // 0% transparent
4388
4389 TGeoVolume *extTrayAVerFace = new TGeoVolume("ITSsuppSPDSideAExtTrayVerFace",
4390 extTrayVerFace, medAl);
4391
4392 extTrayAVerFace->SetVisibility(kTRUE);
4393 extTrayAVerFace->SetLineColor(6); // Purple
4394 extTrayAVerFace->SetLineWidth(1);
4395 extTrayAVerFace->SetFillColor(extTrayAVerFace->GetLineColor());
4396 extTrayAVerFace->SetFillStyle(4000); // 0% transparent
4397
4398 TGeoVolume *extTrayAWall = new TGeoVolume("ITSsuppSPDSideAExtTrayWall",
4399 extTrayWall, medAl);
4400
4401 extTrayAWall->SetVisibility(kTRUE);
4402 extTrayAWall->SetLineColor(6); // Purple
4403 extTrayAWall->SetLineWidth(1);
4404 extTrayAWall->SetFillColor(extTrayAWall->GetLineColor());
4405 extTrayAWall->SetFillStyle(4000); // 0% transparent
4406
4407 TGeoVolume *forwCoolTube = new TGeoVolume("ITSsuppSPDSideAForwTrayCoolTube",
4408 coolTubeForw, medIn);
4409
4410 forwCoolTube->SetVisibility(kTRUE);
4411 forwCoolTube->SetLineColor(kGray); // as in GeometrySPD
4412 forwCoolTube->SetLineWidth(1);
4413 forwCoolTube->SetFillColor(forwCoolTube->GetLineColor());
4414 forwCoolTube->SetFillStyle(4000); // 0% transparent
4415
96eb8210 4416 TGeoVolume *forwCoolFreon = new TGeoVolume("ITSsuppSPDSideAForwTrayFreon",
4417 freonTubeForw, medFreon);
4418
4419 forwCoolFreon->SetVisibility(kTRUE);
4420 forwCoolFreon->SetLineColor(kBlue); // Blue
4421 forwCoolFreon->SetLineWidth(1);
4422 forwCoolFreon->SetFillColor(forwCoolFreon->GetLineColor());
4423 forwCoolFreon->SetFillStyle(4000); // 0% transparent
4424
798b4e0c 4425 TGeoVolume *extCoolTube = new TGeoVolume("ITSsuppSPDSideAExtTrayCoolTube",
4426 coolTubeExt, medIn);
4427
4428 extCoolTube->SetVisibility(kTRUE);
4429 extCoolTube->SetLineColor(kGray); // as in GeometrySPD
4430 extCoolTube->SetLineWidth(1);
4431 extCoolTube->SetFillColor(extCoolTube->GetLineColor());
4432 extCoolTube->SetFillStyle(4000); // 0% transparent
4433
96eb8210 4434 TGeoVolume *extCoolFreon = new TGeoVolume("ITSsuppSPDSideAExtTrayFreon",
4435 freonTubeExt, medFreon);
4436
4437 extCoolFreon->SetVisibility(kTRUE);
4438 extCoolFreon->SetLineColor(kBlue); // Blue
4439 extCoolFreon->SetLineWidth(1);
4440 extCoolFreon->SetFillColor(extCoolFreon->GetLineColor());
4441 extCoolFreon->SetFillStyle(4000); // 0% transparent
4442
798b4e0c 4443 TGeoVolume *forwOptFibs = new TGeoVolume("ITSsuppSPDSideAForwTrayOptFibs",
4444 optFibsForw, medFibs);
4445
4446 forwOptFibs->SetVisibility(kTRUE);
4447 forwOptFibs->SetLineColor(kOrange); // Orange
4448 forwOptFibs->SetLineWidth(1);
4449 forwOptFibs->SetFillColor(forwOptFibs->GetLineColor());
4450 forwOptFibs->SetFillStyle(4000); // 0% transparent
4451
4452 TGeoVolume *extOptFibs = new TGeoVolume("ITSsuppSPDSideAExtTrayOptFibs",
4453 optFibsExt, medFibs);
4454
4455 extOptFibs->SetVisibility(kTRUE);
4456 extOptFibs->SetLineColor(kOrange); // Orange
4457 extOptFibs->SetLineWidth(1);
4458 extOptFibs->SetFillColor(extOptFibs->GetLineColor());
4459 extOptFibs->SetFillStyle(4000); // 0% transparent
4460
57126ea1 4461 TGeoVolume *forwLowCabsCu = new TGeoVolume("ITSsuppSPDSideAForwLowCabsCu",
4462 lowCablesForwCu, medCu);
4463
4464 forwLowCabsCu->SetVisibility(kTRUE);
4465 forwLowCabsCu->SetLineColor(kRed); // Red
4466 forwLowCabsCu->SetLineWidth(1);
4467 forwLowCabsCu->SetFillColor(forwLowCabsCu->GetLineColor());
4468 forwLowCabsCu->SetFillStyle(4000); // 0% transparent
4469
4470 TGeoVolume *forwLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwLowCabsPUR",
4471 lowCablesForwPUR, medPUR);
4472
4473 forwLowCabsPUR->SetVisibility(kTRUE);
4474 forwLowCabsPUR->SetLineColor(kBlack); // Black
4475 forwLowCabsPUR->SetLineWidth(1);
4476 forwLowCabsPUR->SetFillColor(forwLowCabsPUR->GetLineColor());
4477 forwLowCabsPUR->SetFillStyle(4000); // 0% transparent
4478
4479 TGeoVolume *extLowCabsCu = new TGeoVolume("ITSsuppSPDSideAExtLowCabsCu",
4480 lowCablesExtCu, medCu);
4481
4482 extLowCabsCu->SetVisibility(kTRUE);
4483 extLowCabsCu->SetLineColor(kRed); // Red
4484 extLowCabsCu->SetLineWidth(1);
4485 extLowCabsCu->SetFillColor(extLowCabsCu->GetLineColor());
4486 extLowCabsCu->SetFillStyle(4000); // 0% transparent
4487
4488 TGeoVolume *extLowCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtLowCabsPUR",
4489 lowCablesExtPUR, medPUR);
4490
4491 extLowCabsPUR->SetVisibility(kTRUE);
4492 extLowCabsPUR->SetLineColor(kBlack); // Black
4493 extLowCabsPUR->SetLineWidth(1);
4494 extLowCabsPUR->SetFillColor(extLowCabsPUR->GetLineColor());
4495 extLowCabsPUR->SetFillStyle(4000); // 0% transparent
4496
4497 TGeoVolume *forwHiCabsCu = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsCu",
4498 hiCablesForwCu, medCu);
4499
4500 forwHiCabsCu->SetVisibility(kTRUE);
4501 forwHiCabsCu->SetLineColor(kRed); // Red
4502 forwHiCabsCu->SetLineWidth(1);
4503 forwHiCabsCu->SetFillColor(forwHiCabsCu->GetLineColor());
4504 forwHiCabsCu->SetFillStyle(4000); // 0% transparent
4505
4506 TGeoVolume *forwHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAForwTrayHiCabsPUR",
4507 hiCablesForwPUR, medPUR);
4508
4509 forwHiCabsPUR->SetVisibility(kTRUE);
4510 forwHiCabsPUR->SetLineColor(kBlack); // Black
4511 forwHiCabsPUR->SetLineWidth(1);
4512 forwHiCabsPUR->SetFillColor(forwHiCabsPUR->GetLineColor());
4513 forwHiCabsPUR->SetFillStyle(4000); // 0% transparent
4514
4515 TGeoVolume *extHiCabsCu = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsCu",
4516 hiCablesExtCu, medCu);
4517
4518 extHiCabsCu->SetVisibility(kTRUE);
4519 extHiCabsCu->SetLineColor(kRed); // Red
4520 extHiCabsCu->SetLineWidth(1);
4521 extHiCabsCu->SetFillColor(extHiCabsCu->GetLineColor());
4522 extHiCabsCu->SetFillStyle(4000); // 0% transparent
4523
4524 TGeoVolume *extHiCabsPUR = new TGeoVolume("ITSsuppSPDSideAExtTrayHiCabsPUR",
4525 hiCablesExtPUR, medPUR);
4526
4527 extHiCabsPUR->SetVisibility(kTRUE);
4528 extHiCabsPUR->SetLineColor(kBlack); // Black
4529 extHiCabsPUR->SetLineWidth(1);
4530 extHiCabsPUR->SetFillColor(extHiCabsPUR->GetLineColor());
4531 extHiCabsPUR->SetFillStyle(4000); // 0% transparent
4532
4533 TGeoVolume *forwCoaxCu = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxCu",
4534 coaxCablesForwCu, medCu);
4535
4536 forwCoaxCu->SetVisibility(kTRUE);
4537 forwCoaxCu->SetLineColor(kRed); // Red
4538 forwCoaxCu->SetLineWidth(1);
4539 forwCoaxCu->SetFillColor(forwCoaxCu->GetLineColor());
4540 forwCoaxCu->SetFillStyle(4000); // 0% transparent
4541
d8826f33 4542 TGeoVolume *forwCoaxMeg = new TGeoVolume("ITSsuppSPDSideAForwTrayCoaxMeg",
4543 coaxCablesForwMeg, medMeg);
57126ea1 4544
d8826f33 4545 forwCoaxMeg->SetVisibility(kTRUE);
4546 forwCoaxMeg->SetLineColor(kBlack); // Black
4547 forwCoaxMeg->SetLineWidth(1);
4548 forwCoaxMeg->SetFillColor(forwCoaxMeg->GetLineColor());
4549 forwCoaxMeg->SetFillStyle(4000); // 0% transparent
57126ea1 4550
4551 TGeoVolume *extCoaxCu = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxCu",
4552 coaxCablesExtCu, medCu);
4553
4554 extCoaxCu->SetVisibility(kTRUE);
4555 extCoaxCu->SetLineColor(kRed); // Red
4556 extCoaxCu->SetLineWidth(1);
4557 extCoaxCu->SetFillColor(extCoaxCu->GetLineColor());
4558 extCoaxCu->SetFillStyle(4000); // 0% transparent
4559
d8826f33 4560 TGeoVolume *extCoaxMeg = new TGeoVolume("ITSsuppSPDSideAExtTrayCoaxMeg",
4561 coaxCablesExtMeg, medMeg);
57126ea1 4562
d8826f33 4563 extCoaxMeg->SetVisibility(kTRUE);
4564 extCoaxMeg->SetLineColor(kBlack); // Black
4565 extCoaxMeg->SetLineWidth(1);
4566 extCoaxMeg->SetFillColor(extCoaxMeg->GetLineColor());
4567 extCoaxMeg->SetFillStyle(4000); // 0% transparent
96eb8210 4568
798b4e0c 4569
4570 // Now build up the trays
4571 yloc = forwTrayLowerFace->GetDY();
4572 zloc = forwTrayLowerFace->GetDZ();
4573 cableTrayAForw->AddNode(forwTrayABase, 1,
4574 new TGeoTranslation(0, yloc, zloc));
4575
4576 xloc = kForwardTrayWide/2;
4577 cableTrayAForw->AddNode(forwTrayASide, 1,
4578 new TGeoCombiTrans( xloc, 0, 0,
4579 new TGeoRotation("",90,-90,-90)));
4580 cableTrayAForw->AddNode(forwTrayASide, 2,
4581 new TGeoCombiTrans(-xloc+kForwardTrayThick, 0, 0,
4582 new TGeoRotation("",90,-90,-90)));
4583
4584 yloc = kForwardTrayFirstHigh - forwTrayShortCover->GetDY();
4585 zloc = forwTrayShortCover->GetDZ();
4586 cableTrayAForw->AddNode(forwTrayACoverShort, 1,
4587 new TGeoTranslation(0, yloc, zloc));
4588
4589 yloc = kForwardTraySecondHigh - forwTrayLongCover->GetDY();
4590 zloc = kForwardTrayFirstLen + forwTrayLongCover->GetDZ();
4591 cableTrayAForw->AddNode(forwTrayACoverLong, 1,
4592 new TGeoTranslation(0, yloc, zloc));
4593
4594 xloc = kForwardTrayWide/2 - kForwardTrayThick - forwTrayWing->GetDX();
4595 yloc = kForwardTrayFirstHigh - kForwardTrayThick - forwTrayWing->GetDY();
4596 zloc = kForwardTrayFirstLen - forwTrayWing->GetDZ();
4597 cableTrayAForw->AddNode(forwTrayAWing, 1,
4598 new TGeoTranslation( xloc, yloc, zloc));
4599 cableTrayAForw->AddNode(forwTrayAWing, 2,
4600 new TGeoTranslation(-xloc, yloc, zloc));
4601
4602 yloc = kForwardTrayThick + kForwardTrayInterSpace - forwTrayPlane->GetDY();
4603 zloc = forwTrayPlane->GetDZ();
4604 cableTrayAForw->AddNode(forwTrayAPlane, 1,
4605 new TGeoTranslation(0, yloc, zloc));
4606
4607 yloc = kForwardTrayThick + forwTrayWall->GetDY();
4608 zloc = forwTrayWall->GetDZ();
4609 cableTrayAForw->AddNode(forwTrayAWall, 1,
4610 new TGeoTranslation(0, yloc, zloc));
4611
96eb8210 4612 forwCoolTube->AddNode(forwCoolFreon, 1, 0);
4613
798b4e0c 4614 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY()
4615 + coolTubeForw->GetRmax();
4616 zloc = coolTubeForw->GetDz();
4617 cableTrayAForw->AddNode(forwCoolTube, 1,
4618 new TGeoTranslation(0, yloc, zloc));
4619
1c5895a3 4620 xloc = optFibsForw->GetZ(1) + coolTubeForw->GetRmax();
4621 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
798b4e0c 4622 cableTrayAForw->AddNode(forwOptFibs, 1,
1c5895a3 4623 new TGeoCombiTrans( xloc, yloc, 0,
4624 new TGeoRotation("",-90.,90.,90.)));
798b4e0c 4625
0801d201 4626 xloc = lowCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
1c5895a3 4627 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
57126ea1 4628 cableTrayAForw->AddNode(forwLowCabsCu, 1,
0801d201 4629 new TGeoCombiTrans(-xloc, yloc, 0,
1c5895a3 4630 new TGeoRotation("",-90.,90.,90.)));
57126ea1 4631 cableTrayAForw->AddNode(forwLowCabsPUR, 1,
0801d201 4632 new TGeoCombiTrans(-xloc, yloc, 0,
1c5895a3 4633 new TGeoRotation("",-90.,90.,90.)));
798b4e0c 4634
0801d201 4635 xloc = 2*lowCablesForwCu->GetZ(1) +
1c5895a3 4636 hiCablesForwCu->GetZ(1) + coolTubeForw->GetRmax();
4637 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
57126ea1 4638 cableTrayAForw->AddNode(forwHiCabsCu, 1,
0801d201 4639 new TGeoCombiTrans(-xloc, yloc, 0,
1c5895a3 4640 new TGeoRotation("",-90.,90.,90.)));
57126ea1 4641 cableTrayAForw->AddNode(forwHiCabsPUR, 1,
0801d201 4642 new TGeoCombiTrans(-xloc, yloc, 0,
1c5895a3 4643 new TGeoRotation("",-90.,90.,90.)));
96eb8210 4644
0801d201 4645 xloc = 2*optFibsForw->GetZ(1) + coaxCablesForwCu->GetZ(1) +
4646 coolTubeForw->GetRmax();
1c5895a3 4647 yloc = 2*kForwardTrayThick + 2*forwTrayWall->GetDY();
57126ea1 4648 cableTrayAForw->AddNode(forwCoaxCu, 1,
0801d201 4649 new TGeoCombiTrans( xloc, yloc, 0,
1c5895a3 4650 new TGeoRotation("",-90.,90.,90.)));
d8826f33 4651 cableTrayAForw->AddNode(forwCoaxMeg, 1,
0801d201 4652 new TGeoCombiTrans( xloc, yloc, 0,
1c5895a3 4653 new TGeoRotation("",-90.,90.,90.)));
57126ea1 4654
798b4e0c 4655 // To simplify following placement in MARS, origin is on top
4656 yloc = -kExternalTrayHigh + kExternalTrayThick/2;
4657 zloc = kExternalTrayLen/2;
4658 cableTrayAExt->AddNode(extTrayAHorFace, 1,
4659 new TGeoTranslation( 0, yloc, zloc));
4660
4661 xloc = kExternalTrayWide/2 - kExternalTrayThick/2;
4662 yloc = -kExternalTrayHigh/2;
4663 cableTrayAExt->AddNode(extTrayAVerFace, 1,
4664 new TGeoTranslation( xloc, yloc, zloc));
4665 cableTrayAExt->AddNode(extTrayAVerFace, 2,
4666 new TGeoTranslation(-xloc, yloc, zloc));
4667
4668 yloc = -kExternalTrayThick/2;
4669 cableTrayAExt->AddNode(extTrayAHorFace, 2,
4670 new TGeoTranslation( 0, yloc, zloc));
4671
4672 yloc = -kExternalTrayHigh
4673 + kExternalTrayThick + kForwardTrayInterSpace - kExternalTrayThick/2;
4674 cableTrayAExt->AddNode(extTrayAHorFace, 3,
4675 new TGeoTranslation( 0, yloc, zloc));
4676
4677 yloc = -kExternalTrayHigh + kExternalTrayThick + extTrayWall->GetDY();
4678 cableTrayAExt->AddNode(extTrayAWall, 1,
4679 new TGeoTranslation( 0, yloc, zloc));
4680
96eb8210 4681 extCoolTube->AddNode(extCoolFreon, 1, 0);
4682
798b4e0c 4683 yloc = -kExternalTrayHigh + 2*kExternalTrayThick + 2*extTrayWall->GetDY()
4684 + coolTubeExt->GetRmax();
4685 zloc = coolTubeExt->GetDz();
4686 cableTrayAExt->AddNode(extCoolTube, 1,
4687 new TGeoTranslation(0, yloc, zloc));
4688
57126ea1 4689 xloc = optFibsExt->GetZ(1) + coolTubeExt->GetRmax();
798b4e0c 4690 cableTrayAExt->AddNode(extOptFibs, 1,
4691 new TGeoCombiTrans( xloc, 0, 0,
4692 new TGeoRotation("",90,-90,-90)));
4693
57126ea1 4694 xloc = coolTubeExt->GetRmax();
4695 cableTrayAExt->AddNode(extLowCabsCu, 1,
4696 new TGeoCombiTrans(-xloc, 0, 0,
4697 new TGeoRotation("",90,-90,-90)));
4698 cableTrayAExt->AddNode(extLowCabsPUR, 1,
798b4e0c 4699 new TGeoCombiTrans(-xloc, 0, 0,
4700 new TGeoRotation("",90,-90,-90)));
4701
57126ea1 4702 xloc = lowCablesExtCu->GetZ(1) + coolTubeExt->GetRmax();
4703 cableTrayAExt->AddNode(extHiCabsCu, 1,
4704 new TGeoCombiTrans(-xloc, 0, 0,
4705 new TGeoRotation("",90,-90,-90)));
4706 cableTrayAExt->AddNode(extHiCabsPUR, 1,
96eb8210 4707 new TGeoCombiTrans(-xloc, 0, 0,
4708 new TGeoRotation("",90,-90,-90)));
4709
57126ea1 4710 xloc = coaxCablesExtCu->GetZ(1) + optFibsExt->GetZ(1) +
4711 coolTubeExt->GetRmax();
4712 cableTrayAExt->AddNode(extCoaxCu, 1,
4713 new TGeoCombiTrans( xloc, 0, 0,
4714 new TGeoRotation("",90,-90,-90)));
d8826f33 4715 cableTrayAExt->AddNode(extCoaxMeg, 1,
57126ea1 4716 new TGeoCombiTrans( xloc, 0, 0,
4717 new TGeoRotation("",90,-90,-90)));
4718
798b4e0c 4719
4720 // Finally put everything in the mother volume
4721 Double_t rExtTray = kTrayAR2Trans + kExternalTrayHigh;
4722
4723 moth->AddNode(cableTrayAForw,1,
4724 new TGeoTranslation( 0, kTrayAR1Trans, kTrayAZTrans));
4725 moth->AddNode(cableTrayAForw,2,
4726 new TGeoCombiTrans( 0,-kTrayAR1Trans, kTrayAZTrans,
4727 new TGeoRotation("",180, 0, 0)));
4728
4729 yloc = kTrayAR1Trans + kExternalTrayHigh;
4730 zloc = kTrayAZTrans + kForwardTrayTotalLen;
4731 moth->AddNode(cableTrayAExt,1,
4732 new TGeoCombiTrans( 0, yloc, zloc,
4733 new TGeoRotation("", 0,-kTrayAZRot, 0)));
4734 moth->AddNode(cableTrayAExt,2,
4735 new TGeoCombiTrans( 0,-yloc, zloc,
4736 new TGeoRotation("",180,-kTrayAZRot, 0)));
4737
4738 alpharot = kTrayAFirstRotAng + kTrayASecondRotAng;
4739 xloc = kTrayAR2Trans*SinD(alpharot);
4740 yloc = kTrayAR2Trans*CosD(alpharot);
4741 moth->AddNode(cableTrayAForw,3,
4742 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4743 new TGeoRotation("",-alpharot,0,0) ) );
4744 xloc = rExtTray*SinD(alpharot);
4745 yloc = rExtTray*CosD(alpharot);
4746 moth->AddNode(cableTrayAExt,3,
4747 new TGeoCombiTrans( xloc, yloc, zloc,
4748 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4749
4750 alpharot += 180;
4751 xloc = kTrayAR2Trans*SinD(alpharot);
4752 yloc = kTrayAR2Trans*CosD(alpharot);
4753 moth->AddNode(cableTrayAForw,4,
4754 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4755 new TGeoRotation("",-alpharot,0,0) ) );
4756 xloc = rExtTray*SinD(alpharot);
4757 yloc = rExtTray*CosD(alpharot);
4758 moth->AddNode(cableTrayAExt,4,
4759 new TGeoCombiTrans( xloc, yloc, zloc,
4760 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4761
4762 alpharot = - kTrayAFirstRotAng - kTrayASecondRotAng;
4763 xloc = kTrayAR2Trans*SinD(alpharot);
4764 yloc = kTrayAR2Trans*CosD(alpharot);
4765 moth->AddNode(cableTrayAForw,5,
4766 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4767 new TGeoRotation("",-alpharot,0,0) ) );
4768 xloc = rExtTray*SinD(alpharot);
4769 yloc = rExtTray*CosD(alpharot);
4770 moth->AddNode(cableTrayAExt,5,
4771 new TGeoCombiTrans( xloc, yloc, zloc,
4772 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4773
4774 alpharot += 180;
4775 xloc = kTrayAR2Trans*SinD(alpharot);
4776 yloc = kTrayAR2Trans*CosD(alpharot);
4777 moth->AddNode(cableTrayAForw,6,
4778 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4779 new TGeoRotation("",-alpharot,0,0) ) );
4780 xloc = rExtTray*SinD(alpharot);
4781 yloc = rExtTray*CosD(alpharot);
4782 moth->AddNode(cableTrayAExt,6,
4783 new TGeoCombiTrans( xloc, yloc, zloc,
4784 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4785
4786 alpharot = kTrayAFirstRotAng + 3*kTrayASecondRotAng;
4787 xloc = kTrayAR2Trans*SinD(alpharot);
4788 yloc = kTrayAR2Trans*CosD(alpharot);
4789 moth->AddNode(cableTrayAForw,7,
4790 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4791 new TGeoRotation("",-alpharot,0,0) ) );
4792 xloc = rExtTray*SinD(alpharot);
4793 yloc = rExtTray*CosD(alpharot);
4794 moth->AddNode(cableTrayAExt,7,
4795 new TGeoCombiTrans( xloc, yloc, zloc,
4796 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4797
4798 alpharot += 180;
4799 xloc = kTrayAR2Trans*SinD(alpharot);
4800 yloc = kTrayAR2Trans*CosD(alpharot);
4801 moth->AddNode(cableTrayAForw,8,
4802 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4803 new TGeoRotation("",-alpharot,0,0) ) );
4804 xloc = rExtTray*SinD(alpharot);
4805 yloc = rExtTray*CosD(alpharot);
4806 moth->AddNode(cableTrayAExt,8,
4807 new TGeoCombiTrans( xloc, yloc, zloc,
4808 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4809
4810 alpharot = - kTrayAFirstRotAng - 3*kTrayASecondRotAng;
4811 xloc = kTrayAR2Trans*SinD(alpharot);
4812 yloc = kTrayAR2Trans*CosD(alpharot);
4813 moth->AddNode(cableTrayAForw,9,
4814 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4815 new TGeoRotation("",-alpharot,0,0) ) );
4816 xloc = rExtTray*SinD(alpharot);
4817 yloc = rExtTray*CosD(alpharot);
4818 moth->AddNode(cableTrayAExt,9,
4819 new TGeoCombiTrans( xloc, yloc, zloc,
4820 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4821
4822 alpharot += 180;
4823 xloc = kTrayAR2Trans*SinD(alpharot);
4824 yloc = kTrayAR2Trans*CosD(alpharot);
4825 moth->AddNode(cableTrayAForw,10,
4826 new TGeoCombiTrans( xloc, yloc, kTrayAZTrans,
4827 new TGeoRotation("",-alpharot,0,0) ) );
4828 xloc = rExtTray*SinD(alpharot);
4829 yloc = rExtTray*CosD(alpharot);
4830 moth->AddNode(cableTrayAExt,10,
4831 new TGeoCombiTrans( xloc, yloc, zloc,
4832 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
4833
4834
4835 return;
4836}
4837
aa177c73 4838//______________________________________________________________________
4839void AliITSv11GeometrySupport::SPDCableTraysSideC(TGeoVolume *moth,
43aefea7 4840 const TGeoManager *mgr){
aa177c73 4841//
4842// Creates the SPD cable trays which are outside the ITS support cones
4843// but still inside the TPC on Side C
4844// (part of this code is taken or anyway inspired to ServicesCableSupport
4845// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
4846//
4847// Input:
4848// moth : the TGeoVolume owing the volume structure
4849// mgr : the GeoManager (default gGeoManager)
4850// Output:
4851//
4852// Return:
4853//
4854// Created: ??? Bjorn S. Nilsen
4855// Updated: 22 Apr 2010 Mario Sitta
96eb8210 4856// Updated: 10 Jun 2010 Mario Sitta Freon inside cooling pipes
57126ea1 4857// Updated: 08 Sep 2010 Mario Sitta
1c5895a3 4858// Updated: 14 Sep 2010 Mario Sitta Cables prolonged till cone
5d9d4033 4859// Updated: 20 Dec 2011 Mario Sitta Composite vol to avoid new overlap
aa177c73 4860//
4861// Technical data are taken from AutoCAD drawings and other (oral)
4862// information given by D.Elia
57126ea1 4863// Optical fibers and voltage cables are approximated with mean materials
4864// and square cross sections, but preserving the total material budget.
aa177c73 4865//
4866
4867 // Dimensions and positions of the C-Side Cable Tray elements
4868 const Int_t kNumTraysSideC = 10;
4869
1c5895a3 4870 const Double_t kTrayCCablesOutRot = 75.000 *fgkDegree;// Computed
4871 const Double_t kTrayCCablesZLenOut = 245.000 *fgkmm;// Computed
4872
aa177c73 4873 const Double_t kTrayCHalfWide = 6.350 *fgkcm;
4874 const Double_t kTrayCLength1 = 172.800 *fgkcm;
4875 const Double_t kTrayCLength2 = 189.300 *fgkcm;
4876 const Double_t kTrayCFirstLen = 435.000 *fgkmm;
4877 const Double_t kTrayCFirstHigh = 83.000 *fgkmm;//!!!TO BE CHECKED!!!
4878 const Double_t kTrayCSecondHigh = 52.700 *fgkmm;//!!!TO BE CHECKED!!!
4879 const Double_t kTrayCThick = 0.200 *fgkcm;
4880 const Double_t kTrayCInterSpace = 18.000 *fgkmm;//!!!TO BE CHECKED!!!
4881 const Double_t kTrayCFoldAngle = 5.000 *fgkDegree;
4882
57126ea1 4883 const Double_t kCoolingTubeRmin = 2.000 *fgkmm;
4884 const Double_t kCoolingTubeRmax = 3.000 *fgkmm;
aa177c73 4885 const Double_t kOpticalFibersSect = 8.696 *fgkmm;//!!!ESTIMATED!!!
57126ea1 4886 const Double_t kLowVoltCableSectCu = 7.675 *fgkmm;// Computed
4887 const Double_t kLowVoltCableHighPUR = 1.000 *fgkmm;// Computed
4888 const Double_t kHiVoltCableSectCu = 1.535 *fgkmm;// Computed
4889 const Double_t kHiVoltCableHighPUR = 0.500 *fgkmm;// Computed
d8826f33 4890 const Double_t kCoaxCableSectCu = 6.024 *fgkmm;// Computed
4891 const Double_t kCoaxCableHighMeg = 5.695 *fgkmm;// Computed
aa177c73 4892
5d9d4033 4893 const Double_t kCablesYtrans = 2.500 *fgkmm;// Avoid ovlps
4894
aa177c73 4895 // Overall position and rotation of the C-Side Cable Trays
4896 const Double_t kTraySideCRPos = 45.300 *fgkcm;
4897 const Double_t kTraySideCZPos = -102.400 *fgkcm;
4898 const Double_t kTraySideCAlphaRot[kNumTraysSideC/2] =
4899 { 0.0, 41.0, -41.0, 76.0, -76.0};
4900 // From position of the other trays
4901
4902
4903 // Local variables
4904 Double_t xprof[8], yprof[8];
4905 Double_t xloc, yloc, zloc, delta, alpharot;
4906
4907
4908 // The single C-Side Cable tray as an assembly
4909 TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly("ITSsupportSPDTrayC");
4910
4911 // First create all needed shapes
4912
4913 // The Cable Tray lower face: a Xtru
4914 TGeoXtru *sideCHorFace = new TGeoXtru(2);
5d9d4033 4915 sideCHorFace->SetName("ITSsuppSPDTraySideCHor");
aa177c73 4916
4917 xprof[0] = 0.;
4918 yprof[0] = 0.;
4919 xprof[1] = kTrayCLength1;
4920 yprof[1] = 0.;
4921 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4922 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4923 xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
4924 yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
4925 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4926 kTrayCThick , xprof[4], yprof[4]);
4927 xprof[5] = 0.;
4928 yprof[5] = kTrayCThick;
4929
4930 delta = kTrayCHalfWide - kTrayCThick;
4931
4932 sideCHorFace->DefinePolygon(6, xprof, yprof);
4933 sideCHorFace->DefineSection(0,-delta);
4934 sideCHorFace->DefineSection(1, delta);
4935
4936 // The Cable Tray middle face: a Xtru
4937 // (somehow duplicate of HorFace, but in this way avoid an overlap with Wall)
4938 TGeoXtru *sideCMidFace = new TGeoXtru(2);
4939
4940 xprof[0] = 0.;
4941 yprof[0] = kTrayCInterSpace + kTrayCThick;
4942 xprof[1] = kTrayCLength1;
4943 yprof[1] = yprof[0];
4944 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4945 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4946 xprof[3] = xprof[2] - kTrayCThick*SinD(kTrayCFoldAngle);
4947 yprof[3] = yprof[2] + kTrayCThick*CosD(kTrayCFoldAngle);
4948 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4949 kTrayCThick , xprof[4], yprof[4]);
4950 xprof[5] = 0.;
4951 yprof[5] = yprof[0] + kTrayCThick;
4952
4953 delta = kTrayCHalfWide - kTrayCThick;
4954
4955 sideCMidFace->DefinePolygon(6, xprof, yprof);
4956 sideCMidFace->DefineSection(0,-delta);
4957 sideCMidFace->DefineSection(1, delta);
4958
4959 // The Cable Tray lower face: a Xtru
4960 TGeoXtru *sideCSideFace = new TGeoXtru(2);
4961
4962 xprof[0] = 0.;
4963 yprof[0] = 0.;
4964 xprof[1] = kTrayCLength1;
4965 yprof[1] = 0.;
4966 xprof[2] = xprof[1] + kTrayCLength2*CosD(kTrayCFoldAngle);
4967 yprof[2] = yprof[1] + kTrayCLength2*SinD(kTrayCFoldAngle);
4968 xprof[3] = xprof[2] - kTrayCSecondHigh*SinD(kTrayCFoldAngle);
4969 yprof[3] = yprof[2] + kTrayCSecondHigh*CosD(kTrayCFoldAngle);
4970 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
4971 kTrayCSecondHigh , xprof[4], yprof[4]);
4972 xprof[5] = kTrayCFirstLen;
4973 yprof[5] = kTrayCSecondHigh;
4974 xprof[6] = xprof[5];
4975 yprof[6] = kTrayCFirstHigh;
4976 xprof[7] = xprof[0];
4977 yprof[7] = yprof[6];
4978
4979 sideCSideFace->DefinePolygon(8, xprof, yprof);
4980 sideCSideFace->DefineSection(0, 0);
4981 sideCSideFace->DefineSection(1, kTrayCThick);
4982
4983 // The short cover: a BBox
4984 TGeoBBox *sideCShortCover = new TGeoBBox(kTrayCFirstLen/2,
4985 kTrayCThick/2,
4986 kTrayCHalfWide-kTrayCThick);
4987
4988 // The long cover: a Xtru
4989 TGeoXtru *sideCLongCover = new TGeoXtru(2);
4990
4991 xprof[5] = sideCSideFace->GetX(5);
4992 yprof[5] = sideCSideFace->GetY(5);
4993 xprof[4] = sideCSideFace->GetX(4);
4994 yprof[4] = sideCSideFace->GetY(4);
4995 xprof[3] = sideCSideFace->GetX(3);
4996 yprof[3] = sideCSideFace->GetY(3);
4997 xprof[2] = xprof[3] + kTrayCThick*SinD(kTrayCFoldAngle);
4998 yprof[2] = yprof[3] - kTrayCThick*CosD(kTrayCFoldAngle);
4999 InsidePoint(xprof[5], yprof[5], xprof[4], yprof[4], xprof[3], yprof[3],
5000 -kTrayCThick , xprof[1], yprof[1]);
5001 xprof[0] = xprof[5];
5002 yprof[0] = yprof[5] - kTrayCThick;
5003
5004 delta = kTrayCHalfWide - kTrayCThick;
5005
5006 sideCLongCover->DefinePolygon(6, xprof, yprof);
5007 sideCLongCover->DefineSection(0,-delta);
5008 sideCLongCover->DefineSection(1, delta);
5009
5010 // The internal wall: a Xtru
5011 TGeoXtru *intWall = new TGeoXtru(2);
5d9d4033 5012 intWall->SetName("ITSsuppSPDTraySideCWall");
aa177c73 5013
5014 xprof[0] = sideCHorFace->GetX(5);
5015 yprof[0] = sideCHorFace->GetY(5);
5016 xprof[1] = sideCHorFace->GetX(4);
5017 yprof[1] = sideCHorFace->GetY(4);
5018 xprof[2] = sideCHorFace->GetX(3);
5019 yprof[2] = sideCHorFace->GetY(3);
5020 xprof[3] = sideCMidFace->GetX(2);
5021 yprof[3] = sideCMidFace->GetY(2);
5022 xprof[4] = sideCMidFace->GetX(1);
5023 yprof[4] = sideCMidFace->GetY(1);
5024 xprof[5] = sideCMidFace->GetX(0);
5025 yprof[5] = sideCMidFace->GetY(0);
5026
5027 intWall->DefinePolygon(6, xprof, yprof);
5028 intWall->DefineSection(0,-kTrayCThick/2);
5029 intWall->DefineSection(1, kTrayCThick/2);
5030
5031 // The horizontal part of the cooling tube inside the tray: a Tube
5032 delta = sideCMidFace->GetX(4) - sideCMidFace->GetX(5);
96eb8210 5033 TGeoTube *horTube = new TGeoTube(0, kCoolingTubeRmax, delta/2);
5034
5035 // The freon inside the horizontal part of the cooling tube: a Tube
5036 TGeoTube *horFreon = new TGeoTube(0, kCoolingTubeRmin, delta/2);
aa177c73 5037
5038 // The inclined part of the cooling tube inside the tray: a Ctub
5039 Double_t x3, y3, x4, y4;
5040 x3 = sideCMidFace->GetX(3);
5041 y3 = sideCMidFace->GetY(3);
5042 x4 = sideCMidFace->GetX(4);
5043 y4 = sideCMidFace->GetY(4);
5044 delta = TMath::Sqrt( (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
5045 (x4 - x3 + kCoolingTubeRmax*SinD(kTrayCFoldAngle)) +
5046 (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle))*
5047 (y4 + kCoolingTubeRmax - y3 - kCoolingTubeRmax*SinD(kTrayCFoldAngle)) );
5048
96eb8210 5049 TGeoCtub *incTube = new TGeoCtub(0, kCoolingTubeRmax, delta/2, 0, 360,
5050 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
5051 0, 0, 1);
5052
5053 // The freon inside the inclined part of the cooling tube: a Ctub
5054 TGeoCtub *incFreon = new TGeoCtub(0, kCoolingTubeRmin, delta/2, 0, 360,
aa177c73 5055 0, SinD(kTrayCFoldAngle),-CosD(kTrayCFoldAngle),
5056 0, 0, 1);
5057
1c5895a3 5058 // The part of the cooling tube outside the tray: a Ctub
5059 TGeoCtub *outTube = new TGeoCtub(0, kCoolingTubeRmax,
5060 0.5*kTrayCCablesZLenOut/SinD(kTrayCCablesOutRot),
5061 0, 360,
5062 0, 0, -1,
5063 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
5064
5065 // The freon inside the part of the cooling tube outside the tray: a Ctub
5066 TGeoCtub *outFreon = new TGeoCtub(0, kCoolingTubeRmin,
5067 outTube->GetDz(),
5068 0, 360,
5069 0, 0, -1,
5070 0,-SinD(kTrayCCablesOutRot), CosD(kTrayCCablesOutRot));
5071
aa177c73 5072 // The optical fibers inside the tray: a Xtru
5073 TGeoXtru *optFibs = new TGeoXtru(2);
5074
1c5895a3 5075 xprof[0] = -kTrayCCablesZLenOut;
5076 yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
5077 xprof[1] = sideCMidFace->GetX(5);
5d9d4033 5078 yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
1c5895a3 5079 xprof[2] = sideCMidFace->GetX(4);
5d9d4033 5080 yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
1c5895a3 5081 xprof[3] = sideCMidFace->GetX(3);
5d9d4033 5082 yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
1c5895a3 5083 xprof[4] = xprof[3] - kOpticalFibersSect*SinD(kTrayCFoldAngle);
5084 yprof[4] = yprof[3] + kOpticalFibersSect*CosD(kTrayCFoldAngle);
5085 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5086 kOpticalFibersSect , xprof[5], yprof[5]);
5087 xprof[6] = 0.;
5088 yprof[6] = yprof[1] + kOpticalFibersSect;
5089 xprof[7] = xprof[0];
5090 yprof[7] = yprof[0] + kOpticalFibersSect;
aa177c73 5091
1c5895a3 5092 optFibs->DefinePolygon(8, xprof, yprof);
aa177c73 5093 optFibs->DefineSection(0, 0);
5094 optFibs->DefineSection(1, kOpticalFibersSect);
5095
57126ea1 5096 // The low voltage cables inside the tray: two Xtru
5097 TGeoXtru *lowCablesCu = new TGeoXtru(2);
5098
1c5895a3 5099 xprof[0] = -kTrayCCablesZLenOut;
5100 yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
5101 xprof[1] = sideCMidFace->GetX(5);
5d9d4033 5102 yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
1c5895a3 5103 xprof[2] = sideCMidFace->GetX(4);
5d9d4033 5104 yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
1c5895a3 5105 xprof[3] = sideCMidFace->GetX(3);
5d9d4033 5106 yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
1c5895a3 5107 xprof[4] = xprof[3] - kLowVoltCableSectCu*SinD(kTrayCFoldAngle);
5108 yprof[4] = yprof[3] + kLowVoltCableSectCu*CosD(kTrayCFoldAngle);
5109 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5110 kLowVoltCableSectCu , xprof[5], yprof[5]);
5111 xprof[6] = 0.;
5112 yprof[6] = yprof[1] + kLowVoltCableSectCu;
5113 xprof[7] = xprof[0];
5114 yprof[7] = yprof[0] + kLowVoltCableSectCu;
57126ea1 5115
1c5895a3 5116 lowCablesCu->DefinePolygon(8, xprof, yprof);
57126ea1 5117 lowCablesCu->DefineSection(0, 0);
5118 lowCablesCu->DefineSection(1, kLowVoltCableSectCu);
5119
5120 TGeoXtru *lowCablesPUR = new TGeoXtru(2);
5121
1c5895a3 5122 xprof[0] = lowCablesCu->GetX(7);
5123 yprof[0] = lowCablesCu->GetY(7);
5124 xprof[1] = lowCablesCu->GetX(6);
5125 yprof[1] = lowCablesCu->GetY(6);
5126 xprof[2] = lowCablesCu->GetX(5);
5127 yprof[2] = lowCablesCu->GetY(5);
5128 xprof[3] = lowCablesCu->GetX(4);
5129 yprof[3] = lowCablesCu->GetY(4);
5130 xprof[4] = xprof[3] - kLowVoltCableHighPUR*SinD(kTrayCFoldAngle);
5131 yprof[4] = yprof[3] + kLowVoltCableHighPUR*CosD(kTrayCFoldAngle);
5132 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5133 kLowVoltCableHighPUR , xprof[5], yprof[5]);
5134 xprof[6] = 0.;
5135 yprof[6] = yprof[1] + kLowVoltCableHighPUR;
5136 xprof[7] = xprof[0];
5137 yprof[7] = yprof[0] + kLowVoltCableHighPUR;
57126ea1 5138
1c5895a3 5139 lowCablesPUR->DefinePolygon(8, xprof, yprof);
57126ea1 5140 lowCablesPUR->DefineSection(0, 0);
5141 lowCablesPUR->DefineSection(1, kLowVoltCableSectCu);
5142
5143 // The high voltage cables inside the tray: two Xtru
5144 TGeoXtru *hiCablesCu = new TGeoXtru(2);
aa177c73 5145
1c5895a3 5146 xprof[0] = -kTrayCCablesZLenOut;
5147 yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
5148 xprof[1] = sideCMidFace->GetX(5);
5d9d4033 5149 yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
1c5895a3 5150 xprof[2] = sideCMidFace->GetX(4);
5d9d4033 5151 yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
1c5895a3 5152 xprof[3] = sideCMidFace->GetX(3);
5d9d4033 5153 yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
1c5895a3 5154 xprof[4] = xprof[3] - kHiVoltCableSectCu*SinD(kTrayCFoldAngle);
5155 yprof[4] = yprof[3] + kHiVoltCableSectCu*CosD(kTrayCFoldAngle);
5156 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5157 kHiVoltCableSectCu , xprof[5], yprof[5]);
5158 xprof[6] = 0.;
5159 yprof[6] = yprof[1] + kHiVoltCableSectCu;
5160 xprof[7] = xprof[0];
5161 yprof[7] = yprof[0] + kHiVoltCableSectCu;
57126ea1 5162
1c5895a3 5163 hiCablesCu->DefinePolygon(8, xprof, yprof);
57126ea1 5164 hiCablesCu->DefineSection(0, 0);
5165 hiCablesCu->DefineSection(1, kHiVoltCableSectCu);
5166
5167 TGeoXtru *hiCablesPUR = new TGeoXtru(2);
5168
1c5895a3 5169 xprof[0] = hiCablesCu->GetX(7);
5170 yprof[0] = hiCablesCu->GetY(7);
5171 xprof[1] = hiCablesCu->GetX(6);
5172 yprof[1] = hiCablesCu->GetY(6);
5173 xprof[2] = hiCablesCu->GetX(5);
5174 yprof[2] = hiCablesCu->GetY(5);
5175 xprof[3] = hiCablesCu->GetX(4);
5176 yprof[3] = hiCablesCu->GetY(4);
5177 xprof[4] = xprof[3] - kHiVoltCableHighPUR*SinD(kTrayCFoldAngle);
5178 yprof[4] = yprof[3] + kHiVoltCableHighPUR*CosD(kTrayCFoldAngle);
5179 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5180 kHiVoltCableHighPUR , xprof[5], yprof[5]);
5181 xprof[6] = 0.;
5182 yprof[6] = yprof[1] + kHiVoltCableHighPUR;
5183 xprof[7] = xprof[0];
5184 yprof[7] = yprof[0] + kHiVoltCableHighPUR;
aa177c73 5185
1c5895a3 5186 hiCablesPUR->DefinePolygon(8, xprof, yprof);
57126ea1 5187 hiCablesPUR->DefineSection(0, 0);
5188 hiCablesPUR->DefineSection(1, kHiVoltCableSectCu);
aa177c73 5189
57126ea1 5190 // The coaxial cables inside the tray: two Xtru
5191 TGeoXtru *coaxCablesCu = new TGeoXtru(2);
96eb8210 5192
1c5895a3 5193 xprof[0] = -kTrayCCablesZLenOut;
5194 yprof[0] = xprof[0]/TanD(kTrayCCablesOutRot);
5195 xprof[1] = sideCMidFace->GetX(5);
5d9d4033 5196 yprof[1] = sideCMidFace->GetY(5) + kCablesYtrans;
1c5895a3 5197 xprof[2] = sideCMidFace->GetX(4);
5d9d4033 5198 yprof[2] = sideCMidFace->GetY(4) + kCablesYtrans;
1c5895a3 5199 xprof[3] = sideCMidFace->GetX(3);
5d9d4033 5200 yprof[3] = sideCMidFace->GetY(3) + kCablesYtrans;
1c5895a3 5201 xprof[4] = xprof[3] - kCoaxCableSectCu*SinD(kTrayCFoldAngle);
5202 yprof[4] = yprof[3] + kCoaxCableSectCu*CosD(kTrayCFoldAngle);
5203 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
5204 kCoaxCableSectCu , xprof[5], yprof[5]);
5205 xprof[6] = 0.;
5206 yprof[6] = yprof[1] + kCoaxCableSectCu;
5207 xprof[7] = xprof[0];
5208 yprof[7] = yprof[0] + kCoaxCableSectCu;
57126ea1 5209
1c5895a3 5210 coaxCablesCu->DefinePolygon(8, xprof, yprof);
57126ea1 5211 coaxCablesCu->DefineSection(0, 0);
5212 coaxCablesCu->DefineSection(1, kCoaxCableSectCu);
5213
d8826f33 5214 TGeoXtru *coaxCablesMeg = new TGeoXtru(2);
57126ea1 5215
1c5895a3 5216 xprof[0] = coaxCablesCu->GetX(7);
5217 yprof[0] = coaxCablesCu->GetY(7);
5218 xprof[1] = coaxCablesCu->GetX(6);
5219 yprof[1] = coaxCablesCu->GetY(6);
5220 xprof[2] = coaxCablesCu->GetX(5);
5221 yprof[2] = coaxCablesCu->GetY(5);
5222 xprof[3] = coaxCablesCu->GetX(4);
5223 yprof[3] = coaxCablesCu->GetY(4);
d8826f33 5224 xprof[4] = xprof[3] - kCoaxCableHighMeg*SinD(kTrayCFoldAngle);
5225 yprof[4] = yprof[3] + kCoaxCableHighMeg*CosD(kTrayCFoldAngle);
1c5895a3 5226 InsidePoint(xprof[1], yprof[1], xprof[2], yprof[2], xprof[3], yprof[3],
d8826f33 5227 kCoaxCableHighMeg , xprof[5], yprof[5]);
1c5895a3 5228 xprof[6] = 0.;
d8826f33 5229 yprof[6] = yprof[1] + kCoaxCableHighMeg;
1c5895a3 5230 xprof[7] = xprof[0];
d8826f33 5231 yprof[7] = yprof[0] + kCoaxCableHighMeg;
96eb8210 5232
d8826f33 5233 coaxCablesMeg->DefinePolygon(8, xprof, yprof);
5234 coaxCablesMeg->DefineSection(0, 0);
5235 coaxCablesMeg->DefineSection(1, kCoaxCableSectCu);
96eb8210 5236
5d9d4033 5237 // To avoid a newly discovered overlap,
5238 // transform the two overlapping volumes into a Composite Shape
5239 TGeoCompositeShape *trayIntern =
5240 new TGeoCompositeShape("ITSSPDInternalTrayC",
5241 "ITSsuppSPDTraySideCHor+ITSsuppSPDTraySideCWall");
aa177c73 5242
5243 // We have all shapes: now create the real volumes
0801d201 5244 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
5245 TGeoMedium *medIn = mgr->GetMedium("ITS_INOX$");
96eb8210 5246 TGeoMedium *medFr = mgr->GetMedium("ITS_Freon$");
0801d201 5247 TGeoMedium *medFibs = mgr->GetMedium("ITS_SDD OPTICFIB$");//!!TO BE CHECKED!!
5248 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
5249 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
d8826f33 5250 TGeoMedium *medMeg = mgr->GetMedium("ITS_MEGOLON$");
aa177c73 5251
5d9d4033 5252 TGeoVolume *traySideCIntern = new TGeoVolume("ITSsuppSPDTraySideCInternal",
5253 trayIntern, medAl);
aa177c73 5254
5d9d4033 5255 traySideCIntern->SetVisibility(kTRUE);
5256 traySideCIntern->SetLineColor(6); // Purple
5257 traySideCIntern->SetLineWidth(1);
5258 traySideCIntern->SetFillColor(traySideCIntern->GetLineColor());
5259 traySideCIntern->SetFillStyle(4000); // 0% transparent
aa177c73 5260
5261 TGeoVolume *traySideCMidFace = new TGeoVolume("ITSsuppSPDTraySideCMid",
5262 sideCMidFace, medAl);
5263
5264 traySideCMidFace->SetVisibility(kTRUE);
5265 traySideCMidFace->SetLineColor(6); // Purple
5266 traySideCMidFace->SetLineWidth(1);
5267 traySideCMidFace->SetFillColor(traySideCMidFace->GetLineColor());
5268 traySideCMidFace->SetFillStyle(4000); // 0% transparent
5269
5270 TGeoVolume *traySideCSideFace = new TGeoVolume("ITSsuppSPDTraySideCSide",
5271 sideCSideFace, medAl);
5272
5273 traySideCSideFace->SetVisibility(kTRUE);
5274 traySideCSideFace->SetLineColor(6); // Purple
5275 traySideCSideFace->SetLineWidth(1);
5276 traySideCSideFace->SetFillColor(traySideCSideFace->GetLineColor());
5277 traySideCSideFace->SetFillStyle(4000); // 0% transparent
5278
5279 TGeoVolume *traySideCShortCover = new TGeoVolume("ITSsuppSPDTraySideCShCov",
5280 sideCShortCover, medAl);
5281
5282 traySideCShortCover->SetVisibility(kTRUE);
5283 traySideCShortCover->SetLineColor(6); // Purple
5284 traySideCShortCover->SetLineWidth(1);
5285 traySideCShortCover->SetFillColor(traySideCShortCover->GetLineColor());
5286 traySideCShortCover->SetFillStyle(4000); // 0% transparent
5287
5288 TGeoVolume *traySideCLongCover = new TGeoVolume("ITSsuppSPDTraySideCLnCov",
5289 sideCLongCover, medAl);
5290
5291 traySideCLongCover->SetVisibility(kTRUE);
5292 traySideCLongCover->SetLineColor(6); // Purple
5293 traySideCLongCover->SetLineWidth(1);
5294 traySideCLongCover->SetFillColor(traySideCLongCover->GetLineColor());
5295 traySideCLongCover->SetFillStyle(4000); // 0% transparent
5296
aa177c73 5297 TGeoVolume *traySideCHorTube = new TGeoVolume("ITSsuppSPDTraySideCHorTube",
5298 horTube, medIn);
5299
5300 traySideCHorTube->SetVisibility(kTRUE);
5301 traySideCHorTube->SetLineColor(kGray); // as in GeometrySPD
5302 traySideCHorTube->SetLineWidth(1);
5303 traySideCHorTube->SetFillColor(traySideCHorTube->GetLineColor());
5304 traySideCHorTube->SetFillStyle(4000); // 0% transparent
5305
96eb8210 5306 TGeoVolume *traySideCHorFreon = new TGeoVolume("ITSsuppSPDTraySideCHorFreon",
5307 horFreon, medFr);
5308
5309 traySideCHorFreon->SetVisibility(kTRUE);
5310 traySideCHorFreon->SetLineColor(kBlue); // Blue
5311 traySideCHorFreon->SetLineWidth(1);
5312 traySideCHorFreon->SetFillColor(traySideCHorFreon->GetLineColor());
5313 traySideCHorFreon->SetFillStyle(4000); // 0% transparent
5314
aa177c73 5315 TGeoVolume *traySideCIncTube = new TGeoVolume("ITSsuppSPDTraySideCIncTube",
5316 incTube, medIn);
5317
5318 traySideCIncTube->SetVisibility(kTRUE);
5319 traySideCIncTube->SetLineColor(kGray); // as in GeometrySPD
5320 traySideCIncTube->SetLineWidth(1);
5321 traySideCIncTube->SetFillColor(traySideCIncTube->GetLineColor());
5322 traySideCIncTube->SetFillStyle(4000); // 0% transparent
5323
96eb8210 5324 TGeoVolume *traySideCIncFreon = new TGeoVolume("ITSsuppSPDTraySideCIncFreon",
5325 incFreon, medFr);
5326
5327 traySideCIncFreon->SetVisibility(kTRUE);
5328 traySideCIncFreon->SetLineColor(kBlue); // Blue
5329 traySideCIncFreon->SetLineWidth(1);
5330 traySideCIncFreon->SetFillColor(traySideCIncFreon->GetLineColor());
5331 traySideCIncFreon->SetFillStyle(4000); // 0% transparent
5332
1c5895a3 5333 TGeoVolume *traySideCOutTube = new TGeoVolume("ITSsuppSPDTraySideCOutTube",
5334 outTube, medIn);
5335
5336 traySideCOutTube->SetVisibility(kTRUE);
5337 traySideCOutTube->SetLineColor(kGray); // as in GeometrySPD
5338 traySideCOutTube->SetLineWidth(1);
5339 traySideCOutTube->SetFillColor(traySideCOutTube->GetLineColor());
5340 traySideCOutTube->SetFillStyle(4000); // 0% transparent
5341
5342 TGeoVolume *traySideCOutFreon = new TGeoVolume("ITSsuppSPDTraySideCOutFreon",
5343 outFreon, medFr);
5344
5345 traySideCOutFreon->SetVisibility(kTRUE);
5346 traySideCOutFreon->SetLineColor(kBlue); // Blue
5347 traySideCOutFreon->SetLineWidth(1);
5348 traySideCOutFreon->SetFillColor(traySideCOutFreon->GetLineColor());
5349 traySideCOutFreon->SetFillStyle(4000); // 0% transparent
5350
aa177c73 5351 TGeoVolume *traySideCOptFibs = new TGeoVolume("ITSsuppSPDTraySideCOptFibs",
5352 optFibs, medFibs);
5353
5354 traySideCOptFibs->SetVisibility(kTRUE);
5355 traySideCOptFibs->SetLineColor(kOrange); // Orange
5356 traySideCOptFibs->SetLineWidth(1);
5357 traySideCOptFibs->SetFillColor(traySideCOptFibs->GetLineColor());
5358 traySideCOptFibs->SetFillStyle(4000); // 0% transparent
5359
57126ea1 5360 TGeoVolume *traySideCLowCabsCu = new TGeoVolume("ITSsuppSPDTraySideCLVCu",
5361 lowCablesCu, medCu);
5362
5363 traySideCLowCabsCu->SetVisibility(kTRUE);
5364 traySideCLowCabsCu->SetLineColor(kRed); // Red
5365 traySideCLowCabsCu->SetLineWidth(1);
5366 traySideCLowCabsCu->SetFillColor(traySideCLowCabsCu->GetLineColor());
5367 traySideCLowCabsCu->SetFillStyle(4000); // 0% transparent
5368
5369 TGeoVolume *traySideCLowCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCLVPUR",
5370 lowCablesPUR, medPUR);
5371
5372 traySideCLowCabsPUR->SetVisibility(kTRUE);
5373 traySideCLowCabsPUR->SetLineColor(kBlack); // Black
5374 traySideCLowCabsPUR->SetLineWidth(1);
5375 traySideCLowCabsPUR->SetFillColor(traySideCLowCabsPUR->GetLineColor());
5376 traySideCLowCabsPUR->SetFillStyle(4000); // 0% transparent
aa177c73 5377
57126ea1 5378 TGeoVolume *traySideCHiCabsCu = new TGeoVolume("ITSsuppSPDTraySideCHVCu",
5379 hiCablesCu, medCu);
aa177c73 5380
57126ea1 5381 traySideCHiCabsCu->SetVisibility(kTRUE);
5382 traySideCHiCabsCu->SetLineColor(kRed); // Red
5383 traySideCHiCabsCu->SetLineWidth(1);
5384 traySideCHiCabsCu->SetFillColor(traySideCHiCabsCu->GetLineColor());
5385 traySideCHiCabsCu->SetFillStyle(4000); // 0% transparent
96eb8210 5386
57126ea1 5387 TGeoVolume *traySideCHiCabsPUR = new TGeoVolume("ITSsuppSPDTraySideCHVPUR",
5388 hiCablesPUR, medPUR);
5389
5390 traySideCHiCabsPUR->SetVisibility(kTRUE);
5391 traySideCHiCabsPUR->SetLineColor(kBlack); // Black
5392 traySideCHiCabsPUR->SetLineWidth(1);
5393 traySideCHiCabsPUR->SetFillColor(traySideCHiCabsPUR->GetLineColor());
5394 traySideCHiCabsPUR->SetFillStyle(4000); // 0% transparent
5395
5396 TGeoVolume *traySideCCoaxCu = new TGeoVolume("ITSsuppSPDTraySideCCoaxCu",
5397 coaxCablesCu, medCu);
5398
5399 traySideCCoaxCu->SetVisibility(kTRUE);
5400 traySideCCoaxCu->SetLineColor(kRed); // Red
5401 traySideCCoaxCu->SetLineWidth(1);
5402 traySideCCoaxCu->SetFillColor(traySideCCoaxCu->GetLineColor());
5403 traySideCCoaxCu->SetFillStyle(4000); // 0% transparent
5404
d8826f33 5405 TGeoVolume *traySideCCoaxMeg = new TGeoVolume("ITSsuppSPDTraySideCCoaxMeg",
5406 coaxCablesMeg, medMeg);
57126ea1 5407
d8826f33 5408 traySideCCoaxMeg->SetVisibility(kTRUE);
5409 traySideCCoaxMeg->SetLineColor(kBlack); // Black
5410 traySideCCoaxMeg->SetLineWidth(1);
5411 traySideCCoaxMeg->SetFillColor(traySideCCoaxMeg->GetLineColor());
5412 traySideCCoaxMeg->SetFillStyle(4000); // 0% transparent
96eb8210 5413
aa177c73 5414
5415 // Now build up the trays
5d9d4033 5416 cableTrayC->AddNode(traySideCIntern,1,0);
aa177c73 5417
5418 cableTrayC->AddNode(traySideCMidFace,1,0);
5419
5420 zloc = kTrayCHalfWide - kTrayCThick;
5421 cableTrayC->AddNode(traySideCSideFace, 1,
5422 new TGeoTranslation( 0, 0, zloc));
5423 zloc = -kTrayCHalfWide;
5424 cableTrayC->AddNode(traySideCSideFace, 2,
5425 new TGeoTranslation( 0, 0, zloc));
5426
5427 xloc = sideCShortCover->GetDX();
5428 yloc = kTrayCFirstHigh - sideCShortCover->GetDY();
5429 cableTrayC->AddNode(traySideCShortCover, 1,
5430 new TGeoTranslation( xloc, yloc, 0));
5431
5432 cableTrayC->AddNode(traySideCLongCover,1,0);
5433
96eb8210 5434 traySideCHorTube->AddNode(traySideCHorFreon, 1, 0);
5435 traySideCIncTube->AddNode(traySideCIncFreon, 1, 0);
1c5895a3 5436 traySideCOutTube->AddNode(traySideCOutFreon, 1, 0);
96eb8210 5437
aa177c73 5438 xloc = horTube->GetDz();
5439 yloc = sideCMidFace->GetY(5) + horTube->GetRmax();
5440 cableTrayC->AddNode(traySideCHorTube, 1,
5441 new TGeoCombiTrans( xloc, yloc, 0,
5442 new TGeoRotation("",-90.,-90.,90.)));
5443
5444 xloc = sideCMidFace->GetX(4) + (incTube->GetDz())*CosD(kTrayCFoldAngle);
5445 yloc = sideCMidFace->GetY(4) + incTube->GetRmax() +
5446 (incTube->GetDz())*SinD(kTrayCFoldAngle)+0.005;//Avoid small ovrlp
5447 cableTrayC->AddNode(traySideCIncTube, 1,
5448 new TGeoCombiTrans( xloc, yloc, 0,
5449 new TGeoRotation("",-90.+kTrayCFoldAngle,-90.,90.)));
5450
1c5895a3 5451 xloc = -kTrayCCablesZLenOut/2 - outTube->GetRmax();
5452 yloc = xloc/TanD(kTrayCCablesOutRot) + sideCMidFace->GetY(4) -
5453 2*outTube->GetRmax();
5454 cableTrayC->AddNode(traySideCOutTube, 1,
5455 new TGeoCombiTrans( xloc, yloc, 0,
5456 new TGeoRotation("",-70.,-90.,90.)));
5457
aa177c73 5458 zloc = horTube->GetRmax();
5459 cableTrayC->AddNode(traySideCOptFibs, 1,
5460 new TGeoTranslation( 0, 0, zloc));
5461
57126ea1 5462 zloc = kLowVoltCableSectCu + horTube->GetRmax();
5463 cableTrayC->AddNode(traySideCLowCabsCu, 1,
5464 new TGeoTranslation( 0, 0,-zloc));
5465 cableTrayC->AddNode(traySideCLowCabsPUR, 1,
aa177c73 5466 new TGeoTranslation( 0, 0,-zloc));
5467
57126ea1 5468 zloc = kHiVoltCableSectCu + kLowVoltCableSectCu + horTube->GetRmax();
5469 cableTrayC->AddNode(traySideCHiCabsCu, 1,
5470 new TGeoTranslation( 0, 0,-zloc));
5471 cableTrayC->AddNode(traySideCHiCabsPUR, 1,
96eb8210 5472 new TGeoTranslation( 0, 0,-zloc));
5473
57126ea1 5474 zloc = kOpticalFibersSect + kCoaxCableSectCu + horTube->GetRmax();
5475 cableTrayC->AddNode(traySideCCoaxCu, 1,
5476 new TGeoTranslation( 0, 0, zloc));
d8826f33 5477 cableTrayC->AddNode(traySideCCoaxMeg, 1,
57126ea1 5478 new TGeoTranslation( 0, 0, zloc));
5479
aa177c73 5480
5481 // Finally put everything in the mother volume
5482 for (Int_t jt = 0; jt < kNumTraysSideC/2; jt++) {
5483 alpharot = kTraySideCAlphaRot[jt];
5484
5485 xloc = kTraySideCRPos*SinD(alpharot);
5486 yloc = kTraySideCRPos*CosD(alpharot);
5487 moth->AddNode(cableTrayC,2*jt+1,
5488 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
5489 new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
5490 alpharot += 180;
5491 xloc = kTraySideCRPos*SinD(alpharot);
5492 yloc = kTraySideCRPos*CosD(alpharot);
5493 moth->AddNode(cableTrayC,2*jt+2,
5494 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
5495 new TGeoRotation("",-90.+alpharot,-90.,90.+kTrayCFoldAngle)));
5496 }
5497
5498
5499 return;
5500}
5501
798b4e0c 5502//______________________________________________________________________
5503void AliITSv11GeometrySupport::SDDCableTraysSideA(TGeoVolume *moth,
f510fd70 5504 const TGeoManager *mgr){
798b4e0c 5505//
5506// Creates the SDD cable trays which are outside the ITS support cones
5507// but still inside the TPC on Side A
5508// (part of this code is taken or anyway inspired to ServicesCableSupport
5509// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
5510//
5511// Input:
5512// moth : the TGeoVolume owing the volume structure
5513// mgr : the GeoManager (default gGeoManager)
5514// Output:
5515//
5516// Created: ??? Bjorn S. Nilsen
5517// Updated: 5 Jan 2010 Mario Sitta
5518// Updated: 26 Feb 2010 Mario Sitta
57126ea1 5519// Updated: 06 Sep 2010 Mario Sitta
798b4e0c 5520//
5521// Technical data are taken from AutoCAD drawings, L.Simonetti technical
5522// drawings and other (oral) information given by F.Tosello
5523//
5524
5525 // Overall position and rotation of the A-Side Cable Trays
5526 // (parts of 0872/G/D)
573a206f 5527 const Double_t kTrayARTrans = 408.35 *fgkmm;
798b4e0c 5528 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
5529 const Double_t kTrayAZToSupportRing = 435.00 *fgkmm;
57126ea1 5530 const Double_t kExternTrayYTrans = 96.00 *fgkmm; // Computed
5531 const Double_t kExternTrayZTrans = 823.00 *fgkmm;
798b4e0c 5532 const Double_t kExternCoverYTrans = 2.00 *fgkmm;
5533 const Double_t kTrayAZRot = (180-169.5);// Degrees
5534 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
5535 const Double_t kTrayASecondRotAng = 15.00; // Degrees
5536
57126ea1 5537 const Double_t kForwardTrayThick = 2.00 *fgkmm;
798b4e0c 5538 const Double_t kForwardTrayTailHeight = 100.00 *fgkmm; // Computed
5539 const Double_t kForwardTrayTotalHeight = 170.00 *fgkmm; // Computed
5540 const Double_t kForwardTrayUpperLength = 405.00 *fgkmm; // Computed
5541 const Double_t kForwardCoverLength = 380.00 *fgkmm;
5542 const Double_t kForwardCoverWide = 133.00 *fgkmm;
5543 const Double_t kForwardCoverHeight = 10.00 *fgkmm;
5544 const Double_t kForwardCoverThick = 1.00 *fgkmm;
5545
5546 const Double_t kExternTrayTotalLen = 1200.00 *fgkmm;
5547 const Double_t kExternTrayTotalHeight = 52.00 *fgkmm;
5548 const Double_t kExternCoverLen = kExternTrayTotalLen;
5549 const Double_t kExternCoverThick = 5.00 *fgkmm;
5550 const Double_t kExternCoverSideThick = 3.00 *fgkmm;
5551
5552 const Int_t kForwardTrayNpoints = 8;
5553
57126ea1 5554 // Dimensions and positions of the Cable Tray elements
5555 const Double_t kSideACoolManifWide = 8.23 *fgkcm;
5556 const Double_t kSideACoolManifHigh = 8.06 *fgkcm;
5557 const Double_t kSideACoolManifLen = 3.90 *fgkcm;
5558 const Double_t kSideACoolManifPOMFrac = 0.0054;
5559 const Double_t kSideACoolManifSteelFrac= 0.8850;
5560 const Double_t kSideACoolManifWaterFrac= 0.0913;
5561 const Double_t kSideACoolManifAlFrac = 0.0183;
5562
5563 const Double_t kSideACoolTubesWide = 9.07 *fgkcm;
5564 const Double_t kSideACoolTubesHigh = 1.88 *fgkcm;
5565 const Double_t kSideACoolTubesTrans = 0.88 *fgkcm;
5566 const Double_t kSideACoolTubesPURFrac = 0.5897;
5567 const Double_t kSideACoolTubesWaterFrac= 0.4101;
5568 const Double_t kSideACoolTubesAirFrac = 0.0002;
5569
5570 const Double_t kSideAOptConnWide = 0.90 *fgkcm;
5571 const Double_t kSideAOptConnLen = 1.37 *fgkcm;
5572 const Double_t kSideAOptConnPBTFrac = 0.5010;
5573 const Double_t kSideAOptConnSteelFrac = 0.1784;
5574 const Double_t kSideAOptConnAlFrac = 0.3206;
5575
5576 const Double_t kSideAOptFibsWide = 0.71 *fgkcm;
5577 const Double_t kSideAOptFibsHigh = 3.20 *fgkcm;
5578
5579 const Double_t kSideAInputCablesWide = 12.50 *fgkcm;
5580 const Double_t kSideAInputCablesHigh = 1.24 *fgkcm;
5581 const Double_t kSideAInputCablesLen = 25.20 *fgkcm;
5582 const Double_t kSideAInputCablesYTrans = 1.15 *fgkcm;
5583 const Double_t kSideAInputCablesCu = 0.7404;
5584 const Double_t kSideAInputCablesPlast = 0.1269;
5585 const Double_t kSideAInputCablesAl = 0.0057;
5586 const Double_t kSideAInputCablesKapton = 0.0172;
5587 const Double_t kSideAInputCablesPOLYAX = 0.1098;
5588
5589 const Double_t kSideAOutputCablesWide = 8.30 *fgkcm;
5590 const Double_t kSideAOutputCablesHigh = 1.56 *fgkcm;
5591 const Double_t kSideAOutputCablesCu = 0.6783;
5592 const Double_t kSideAOutputCablesPlast = 0.1605;
5593 const Double_t kSideAOutputCablesAl = 0.0078;
5594 const Double_t kSideAOutputCablesKapton= 0.0232;
5595 const Double_t kSideAOutputCablesPOLYAX= 0.1302;
5596
5597 const Double_t kSideAPCBBoardsWide = 12.50 *fgkcm;
5598 const Double_t kSideAPCBBoardsHigh = 6.32 *fgkcm;
5599 const Double_t kSideAPCBBoardsLen = 24.00 *fgkcm;
5600 const Double_t kSideAPCBBoardsYTrans = 0.75 *fgkcm;
5601 const Double_t kSideAPCBBoardsCu = 0.3864;
5602 const Double_t kSideAPCBBoardsEpoxy = 0.1486;
5603 const Double_t kSideAPCBBoardsPlast = 0.0578;
5604 const Double_t kSideAPCBBoardsSteel = 0.1521;
5605 const Double_t kSideAPCBBoardsPPS = 0.2551;
5606
798b4e0c 5607
5608 // Local variables
5609 Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
57126ea1 5610 Double_t xloc, yloc, zloc, alpharot, height;
798b4e0c 5611
5612
5613 // The whole tray as an assembly
5614 TGeoVolumeAssembly *cableTrayA = new TGeoVolumeAssembly("ITSsupportSDDTrayA");
5615
5616
5617 // First create all needed shapes
5618
5619 // The forward tray is very complex and deserves a dedicated method
57126ea1 5620 CreateSDDForwardTraySideA(cableTrayA,mgr);
798b4e0c 5621
5622 // The forward cover: a Xtru
5623 TGeoXtru *forwardCover = new TGeoXtru(2);
5624 forwardCover->SetName("ITSsuppSDDForwCover");
5625
5626 xprof[0] = kForwardCoverWide/2;
5627 yprof[0] = kForwardCoverHeight;
5628 xprof[1] = xprof[0];
5629 yprof[1] = 0;
5630 xprof[2] = xprof[1] - kForwardCoverThick;
5631 yprof[2] = yprof[1];
5632 xprof[3] = xprof[2];
5633 yprof[3] = yprof[0] - kForwardCoverThick;
5634
5635 // We did the right side, now reflex on the left side
5636 for (Int_t jp = 0; jp < 4; jp++) {
5637 xprof[4+jp] = -xprof[3-jp];
5638 yprof[4+jp] = yprof[3-jp];
5639 }
5640
5641 forwardCover->DefinePolygon(8, xprof, yprof);
5642 forwardCover->DefineSection(0, 0);
5643 forwardCover->DefineSection(1, kForwardCoverLength);
5644
5645 // The external tray (as 0872/G/D/03): a Xtru
5646 TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternTrayTotalLen,
5647 kExternTrayTotalHeight);
5648
5649 // The external covers: a Composite Shape
5650 TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternCoverLen);
5651
57126ea1 5652 // Now the volumes inside it
5653 // The cooling manifold: four boxes
5654 TGeoBBox *coolManifPOM = new TGeoBBox(kSideACoolManifWide/2,
5655 kSideACoolManifPOMFrac*kSideACoolManifHigh/2,
5656 kSideACoolManifLen/2);
5657
5658 TGeoBBox *coolManifSteel = new TGeoBBox(kSideACoolManifWide/2,
5659 kSideACoolManifSteelFrac*kSideACoolManifHigh/2,
5660 kSideACoolManifLen/2);
5661
5662 TGeoBBox *coolManifWater = new TGeoBBox(kSideACoolManifWide/2,
5663 kSideACoolManifWaterFrac*kSideACoolManifHigh/2,
5664 kSideACoolManifLen/2);
5665
5666 TGeoBBox *coolManifAl = new TGeoBBox(kSideACoolManifWide/2,
5667 kSideACoolManifAlFrac*kSideACoolManifHigh/2,
5668 kSideACoolManifLen/2);
5669
5670 // The cooling tubes: three Xtru's
5671 TGeoXtru *coolTubesPUR = new TGeoXtru(2);
5672
5673 height = kSideACoolTubesHigh*kSideACoolTubesPURFrac;
5674
5675 xprof[0] = kSideACoolManifLen;
5676 yprof[0] = kForwardTrayThick + kSideACoolTubesTrans;
5677 xprof[2] = kExternTrayZTrans + kForwardTrayTotalHeight*SinD(kTrayAZRot) +
5678 kExternTrayTotalLen*CosD(kTrayAZRot) - xprof[0]/2;
5679 yprof[2] = kForwardTrayTotalHeight*(1 - CosD(kTrayAZRot)) +
5680 kExternTrayYTrans - kExternTrayTotalHeight*CosD(kTrayAZRot) +
5681 kExternTrayTotalLen*SinD(kTrayAZRot) + yprof[0];
5682 IntersectLines( 0 , xprof[0], yprof[0],
5683 TanD(kTrayAZRot), xprof[2], yprof[2],
5684 xprof[1], yprof[1]);
5685 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5686 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5687 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5688 height, xprof[4], yprof[4]);
5689 xprof[5] = xprof[0];
5690 yprof[5] = yprof[0] + height;
5691
5692 coolTubesPUR->DefinePolygon(6, xprof, yprof);
5693 coolTubesPUR->DefineSection(0,-kSideACoolTubesWide/2);
5694 coolTubesPUR->DefineSection(1, kSideACoolTubesWide/2);
5695
5696 TGeoXtru *coolTubesWater = new TGeoXtru(2);
5697
5698 height = kSideACoolTubesHigh*kSideACoolTubesWaterFrac;
5699
5700 xprof[0] = coolTubesPUR->GetX(5);
5701 yprof[0] = coolTubesPUR->GetY(5);
5702 xprof[1] = coolTubesPUR->GetX(4);
5703 yprof[1] = coolTubesPUR->GetY(4);
5704 xprof[2] = coolTubesPUR->GetX(3);
5705 yprof[2] = coolTubesPUR->GetY(3);
5706 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5707 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5708 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5709 height, xprof[4], yprof[4]);
5710 xprof[5] = xprof[0];
5711 yprof[5] = yprof[0] + height;
5712
5713 coolTubesWater->DefinePolygon(6, xprof, yprof);
5714 coolTubesWater->DefineSection(0,-kSideACoolTubesWide/2);
5715 coolTubesWater->DefineSection(1, kSideACoolTubesWide/2);
5716
5717 TGeoXtru *coolTubesAir = new TGeoXtru(2);
5718
5719 height = kSideACoolTubesHigh*kSideACoolTubesAirFrac;
5720
5721 xprof[0] = coolTubesWater->GetX(5);
5722 yprof[0] = coolTubesWater->GetY(5);
5723 xprof[1] = coolTubesWater->GetX(4);
5724 yprof[1] = coolTubesWater->GetY(4);
5725 xprof[2] = coolTubesWater->GetX(3);
5726 yprof[2] = coolTubesWater->GetY(3);
5727 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5728 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5729 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5730 height, xprof[4], yprof[4]);
5731 xprof[5] = xprof[0];
5732 yprof[5] = yprof[0] + height;
5733
5734 coolTubesAir->DefinePolygon(6, xprof, yprof);
5735 coolTubesAir->DefineSection(0,-kSideACoolTubesWide/2);
5736 coolTubesAir->DefineSection(1, kSideACoolTubesWide/2);
5737
5738 // The optical fiber connectors: three boxes
5739 TGeoBBox *optConnPBT = new TGeoBBox(kSideAOptConnWide/2,
5740 kSideAOptConnPBTFrac*kSideACoolManifHigh/2,
5741 kSideAOptConnLen/2);
5742
5743 TGeoBBox *optConnSteel = new TGeoBBox(kSideAOptConnWide/2,
5744 kSideAOptConnSteelFrac*kSideACoolManifHigh/2,
5745 kSideAOptConnLen/2);
5746
5747 TGeoBBox *optConnAl = new TGeoBBox(kSideAOptConnWide/2,
5748 kSideAOptConnAlFrac*kSideACoolManifHigh/2,
5749 kSideAOptConnLen/2);
5750
5751 // The optical fibers: a Xtru
5752 TGeoXtru *opticalFibs = new TGeoXtru(2);
5753
5754 xprof[0] = kSideAOptConnLen;
5755 yprof[0] = coolTubesPUR->GetY(0);
5756 xprof[1] = coolTubesPUR->GetX(1);
5757 yprof[1] = coolTubesPUR->GetY(1);
5758 xprof[2] = coolTubesPUR->GetX(2);
5759 yprof[2] = coolTubesPUR->GetY(2);
5760 xprof[3] = xprof[2] - kSideAOptFibsHigh*SinD(kTrayAZRot);
5761 yprof[3] = yprof[2] + kSideAOptFibsHigh*CosD(kTrayAZRot);
5762 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5763 kSideAOptFibsHigh, xprof[4], yprof[4]);
5764 xprof[5] = xprof[0];
5765 yprof[5] = yprof[0] + kSideAOptFibsHigh;
5766
5767 opticalFibs->DefinePolygon(6, xprof, yprof);
5768 opticalFibs->DefineSection(0,-kSideAOptFibsWide/2);
5769 opticalFibs->DefineSection(1, kSideAOptFibsWide/2);
5770
5771 // The input cables: five boxes
5772 TGeoBBox *inputCabsCu = new TGeoBBox(kSideAInputCablesWide/2,
5773 kSideAInputCablesCu*kSideAInputCablesHigh/2,
5774 kSideAInputCablesLen/2);
5775
5776 TGeoBBox *inputCabsPlast = new TGeoBBox(kSideAInputCablesWide/2,
5777 kSideAInputCablesPlast*kSideAInputCablesHigh/2,
5778 kSideAInputCablesLen/2);
5779
5780 TGeoBBox *inputCabsAl = new TGeoBBox(kSideAInputCablesWide/2,
5781 kSideAInputCablesAl*kSideAInputCablesHigh/2,
5782 kSideAInputCablesLen/2);
5783
5784 TGeoBBox *inputCabsKapton = new TGeoBBox(kSideAInputCablesWide/2,
5785 kSideAInputCablesKapton*kSideAInputCablesHigh/2,
5786 kSideAInputCablesLen/2);
5787
5788 TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideAInputCablesWide/2,
5789 kSideAInputCablesPOLYAX*kSideAInputCablesHigh/2,
5790 kSideAInputCablesLen/2);
5791
5792 // The output cables: five Xtru
5793 TGeoXtru *outputCabsCu = new TGeoXtru(2);
5794
5795 height = kSideAOutputCablesCu*kSideAOutputCablesHigh;
5796
5797 xprof[0] = kSideAInputCablesLen/2 + kSideAPCBBoardsLen/2;
5798 yprof[0] = coolTubesAir->GetY(5);
5799 xprof[1] = coolTubesAir->GetX(4);
5800 yprof[1] = coolTubesAir->GetY(4);
5801 xprof[2] = coolTubesAir->GetX(3);
5802 yprof[2] = coolTubesAir->GetY(3);
5803 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5804 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5805 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5806 height, xprof[4], yprof[4]);
5807 xprof[5] = xprof[0];
5808 yprof[5] = yprof[0] + height;
5809
5810 outputCabsCu->DefinePolygon(6, xprof, yprof);
5811 outputCabsCu->DefineSection(0,-kSideAOutputCablesWide/2);
5812 outputCabsCu->DefineSection(1, kSideAOutputCablesWide/2);
5813
5814 TGeoXtru *outputCabsPlast = new TGeoXtru(2);
5815
5816 height = kSideAOutputCablesPlast*kSideAOutputCablesHigh;
5817
5818 xprof[0] = outputCabsCu->GetX(5);
5819 yprof[0] = outputCabsCu->GetY(5);
5820 xprof[1] = outputCabsCu->GetX(4);
5821 yprof[1] = outputCabsCu->GetY(4);
5822 xprof[2] = outputCabsCu->GetX(3);
5823 yprof[2] = outputCabsCu->GetY(3);
5824 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5825 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5826 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5827 height, xprof[4], yprof[4]);
5828 xprof[5] = xprof[0];
5829 yprof[5] = yprof[0] + height;
5830
5831 outputCabsPlast->DefinePolygon(6, xprof, yprof);
5832 outputCabsPlast->DefineSection(0,-kSideAOutputCablesWide/2);
5833 outputCabsPlast->DefineSection(1, kSideAOutputCablesWide/2);
5834
5835 TGeoXtru *outputCabsAl = new TGeoXtru(2);
5836
5837 height = kSideAOutputCablesAl*kSideAOutputCablesHigh;
5838
5839 xprof[0] = outputCabsPlast->GetX(5);
5840 yprof[0] = outputCabsPlast->GetY(5);
5841 xprof[1] = outputCabsPlast->GetX(4);
5842 yprof[1] = outputCabsPlast->GetY(4);
5843 xprof[2] = outputCabsPlast->GetX(3);
5844 yprof[2] = outputCabsPlast->GetY(3);
5845 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5846 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5847 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5848 height, xprof[4], yprof[4]);
5849 xprof[5] = xprof[0];
5850 yprof[5] = yprof[0] + height;
5851
5852 outputCabsAl->DefinePolygon(6, xprof, yprof);
5853 outputCabsAl->DefineSection(0,-kSideAOutputCablesWide/2);
5854 outputCabsAl->DefineSection(1, kSideAOutputCablesWide/2);
5855
5856 TGeoXtru *outputCabsKapton = new TGeoXtru(2);
5857
5858 height = kSideAOutputCablesKapton*kSideAOutputCablesHigh;
5859
5860 xprof[0] = outputCabsAl->GetX(5);
5861 yprof[0] = outputCabsAl->GetY(5);
5862 xprof[1] = outputCabsAl->GetX(4);
5863 yprof[1] = outputCabsAl->GetY(4);
5864 xprof[2] = outputCabsAl->GetX(3);
5865 yprof[2] = outputCabsAl->GetY(3);
5866 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5867 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5868 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5869 height, xprof[4], yprof[4]);
5870 xprof[5] = xprof[0];
5871 yprof[5] = yprof[0] + height;
5872
5873 outputCabsKapton->DefinePolygon(6, xprof, yprof);
5874 outputCabsKapton->DefineSection(0,-kSideAOutputCablesWide/2);
5875 outputCabsKapton->DefineSection(1, kSideAOutputCablesWide/2);
5876
5877 TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
5878
5879 height = kSideAOutputCablesPOLYAX*kSideAOutputCablesHigh;
5880
5881 xprof[0] = outputCabsKapton->GetX(5);
5882 yprof[0] = outputCabsKapton->GetY(5);
5883 xprof[1] = outputCabsKapton->GetX(4);
5884 yprof[1] = outputCabsKapton->GetY(4);
5885 xprof[2] = outputCabsKapton->GetX(3);
5886 yprof[2] = outputCabsKapton->GetY(3);
5887 xprof[3] = xprof[2] - height*SinD(kTrayAZRot);
5888 yprof[3] = yprof[2] + height*CosD(kTrayAZRot);
5889 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
5890 height, xprof[4], yprof[4]);
5891 xprof[5] = xprof[0];
5892 yprof[5] = yprof[0] + height;
5893
5894 outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
5895 outputCabsPOLYAX->DefineSection(0,-kSideAOutputCablesWide/2);
5896 outputCabsPOLYAX->DefineSection(1, kSideAOutputCablesWide/2);
5897
5898 // The PCB boards: five boxes
5899 TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideAPCBBoardsWide/2,
5900 kSideAPCBBoardsCu*kSideAPCBBoardsHigh/2,
5901 kSideAPCBBoardsLen/2);
5902
5903 TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideAPCBBoardsWide/2,
5904 kSideAPCBBoardsEpoxy*kSideAPCBBoardsHigh/2,
5905 kSideAPCBBoardsLen/2);
5906
5907 TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideAPCBBoardsWide/2,
5908 kSideAPCBBoardsPlast*kSideAPCBBoardsHigh/2,
5909 kSideAPCBBoardsLen/2);
5910
5911 TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideAPCBBoardsWide/2,
5912 kSideAPCBBoardsSteel*kSideAPCBBoardsHigh/2,
5913 kSideAPCBBoardsLen/2);
5914
5915 TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideAPCBBoardsWide/2,
5916 kSideAPCBBoardsPPS*kSideAPCBBoardsHigh/2,
5917 kSideAPCBBoardsLen/2);
5918
798b4e0c 5919
5920 // We have all shapes: now create the real volumes
0801d201 5921 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
57126ea1 5922 TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
5923 TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
0801d201 5924 TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
5925 TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
5926 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
57126ea1 5927 TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
5928 TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
0801d201 5929 TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
5930 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
5931 TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
57126ea1 5932 TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
5933 TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
0801d201 5934 TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
798b4e0c 5935
5936 TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSDDSideAForwTrayCover",
5937 forwardCover, medAl);
5938
5939 forwardTrayCover->SetVisibility(kTRUE);
5940 forwardTrayCover->SetLineColor(kMagenta+1); // Purple
5941 forwardTrayCover->SetLineWidth(1);
5942 forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
5943 forwardTrayCover->SetFillStyle(4000); // 0% transparent
5944
5945 TGeoVolume *externalTraySDD = new TGeoVolume("ITSsuppSDDSideAExternalTray",
5946 externalTray, medAl);
5947
5948 externalTraySDD->SetVisibility(kTRUE);
5949 externalTraySDD->SetLineColor(6); // Purple
5950 externalTraySDD->SetLineWidth(1);
5951 externalTraySDD->SetFillColor(externalTraySDD->GetLineColor());
5952 externalTraySDD->SetFillStyle(4000); // 0% transparent
5953
5954 TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSDDSideAExtTrayCover",
5955 externCover, medAntic);
5956
5957 externTrayCover->SetVisibility(kTRUE);
5958 externTrayCover->SetLineColor(kMagenta+1); // Purple
5959 externTrayCover->SetLineWidth(1);
5960 externTrayCover->SetFillColor(externTrayCover->GetLineColor());
5961 externTrayCover->SetFillStyle(4000); // 0% transparent
5962
21ea473f 5963 TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifPOM",
57126ea1 5964 coolManifPOM, medPOM);
5965
21ea473f 5966 pomCoolManif->SetVisibility(kTRUE);
5967 pomCoolManif->SetLineColor(kRed); // Red
5968 pomCoolManif->SetLineWidth(1);
5969 pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
5970 pomCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 5971
21ea473f 5972 TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifSteel",
57126ea1 5973 coolManifSteel, medSteel);
5974
21ea473f 5975 steelCoolManif->SetVisibility(kTRUE);
5976 steelCoolManif->SetLineColor(kBlue); // Blue
5977 steelCoolManif->SetLineWidth(1);
5978 steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
5979 steelCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 5980
21ea473f 5981 TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifWater",
57126ea1 5982 coolManifWater, medWater);
5983
21ea473f 5984 waterCoolManif->SetVisibility(kTRUE);
5985 waterCoolManif->SetLineColor(33); // Light Blue
5986 waterCoolManif->SetLineWidth(1);
5987 waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
5988 waterCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 5989
21ea473f 5990 TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideACoolManifAl",
57126ea1 5991 coolManifAl, medAl);
5992
21ea473f 5993 alCoolManif->SetVisibility(kTRUE);
5994 alCoolManif->SetLineColor(6); // Purple
5995 alCoolManif->SetLineWidth(1);
5996 alCoolManif->SetFillColor(alCoolManif->GetLineColor());
5997 alCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 5998
21ea473f 5999 TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesPUR",
57126ea1 6000 coolTubesPUR, medPUR);
6001
21ea473f 6002 purCoolTubes->SetVisibility(kTRUE);
6003 purCoolTubes->SetLineColor(kRed); // Red
6004 purCoolTubes->SetLineWidth(1);
6005 purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
6006 purCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6007
21ea473f 6008 TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesWater",
57126ea1 6009 coolTubesWater, medWater);
6010
21ea473f 6011 waterCoolTubes->SetVisibility(kTRUE);
6012 waterCoolTubes->SetLineColor(33); // Light Blue
6013 waterCoolTubes->SetLineWidth(1);
6014 waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
6015 waterCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6016
21ea473f 6017 TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideACoolTubesAir",
57126ea1 6018 coolTubesAir, medAir);
6019
21ea473f 6020 airCoolTubes->SetVisibility(kTRUE);
6021 airCoolTubes->SetLineColor(41);
6022 airCoolTubes->SetLineWidth(1);
6023 airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
6024 airCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6025
21ea473f 6026 TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnPBT",
57126ea1 6027 optConnPBT, medPBT);
6028
21ea473f 6029 pbtOptConn->SetVisibility(kTRUE);
6030 pbtOptConn->SetLineColor(kRed); // Red
6031 pbtOptConn->SetLineWidth(1);
6032 pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
6033 pbtOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6034
21ea473f 6035 TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnSteel",
57126ea1 6036 optConnSteel, medSteel);
6037
21ea473f 6038 steelOptConn->SetVisibility(kTRUE);
6039 steelOptConn->SetLineColor(kBlue); // Blue
6040 steelOptConn->SetLineWidth(1);
6041 steelOptConn->SetFillColor(steelOptConn->GetLineColor());
6042 steelOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6043
21ea473f 6044 TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideAOptConnAl",
57126ea1 6045 optConnAl, medAl);
6046
21ea473f 6047 alOptConn->SetVisibility(kTRUE);
6048 alOptConn->SetLineColor(6); // Purple
6049 alOptConn->SetLineWidth(1);
6050 alOptConn->SetFillColor(alOptConn->GetLineColor());
6051 alOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6052
21ea473f 6053 TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideAOptFibs",
57126ea1 6054 opticalFibs, medOptFib);
6055
21ea473f 6056 optFibs->SetVisibility(kTRUE);
6057 optFibs->SetLineColor(kOrange+2); // Orange
6058 optFibs->SetLineWidth(1);
6059 optFibs->SetFillColor(optFibs->GetLineColor());
6060 optFibs->SetFillStyle(4000); // 0% transparent
57126ea1 6061
21ea473f 6062 TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsCu",
57126ea1 6063 inputCabsCu, medCu);
6064
21ea473f 6065 cuInputCabs->SetVisibility(kTRUE);
6066 cuInputCabs->SetLineColor(kBlack); // Black
6067 cuInputCabs->SetLineWidth(1);
6068 cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
6069 cuInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6070
21ea473f 6071 TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPlast",
57126ea1 6072 inputCabsPlast, medPUR);
6073
21ea473f 6074 plastInputCabs->SetVisibility(kTRUE);
6075 plastInputCabs->SetLineColor(kRed); // Red
6076 plastInputCabs->SetLineWidth(1);
6077 plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
6078 plastInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6079
21ea473f 6080 TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsAl",
57126ea1 6081 inputCabsAl, medAl);
6082
21ea473f 6083 alInputCabs->SetVisibility(kTRUE);
6084 alInputCabs->SetLineColor(6); // Purple
6085 alInputCabs->SetLineWidth(1);
6086 alInputCabs->SetFillColor(alInputCabs->GetLineColor());
6087 alInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6088
21ea473f 6089 TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsKapton",
57126ea1 6090 inputCabsKapton, medKapton);
6091
21ea473f 6092 kaptonInputCabs->SetVisibility(kTRUE);
6093 kaptonInputCabs->SetLineColor(14); //
6094 kaptonInputCabs->SetLineWidth(1);
6095 kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
6096 kaptonInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6097
1c5895a3 6098 TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideAInputCabsPOLYAX",
57126ea1 6099 inputCabsPOLYAX, medPOLYAX);
6100
1c5895a3 6101 polyaxInputCabs->SetVisibility(kTRUE);
6102 polyaxInputCabs->SetLineColor(34); //
6103 polyaxInputCabs->SetLineWidth(1);
6104 polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
6105 polyaxInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6106
21ea473f 6107 TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsCu",
57126ea1 6108 outputCabsCu, medCu);
6109
21ea473f 6110 cuOutputCabs->SetVisibility(kTRUE);
6111 cuOutputCabs->SetLineColor(kBlack); // Black
6112 cuOutputCabs->SetLineWidth(1);
6113 cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
6114 cuOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6115
21ea473f 6116 TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPlast",
57126ea1 6117 outputCabsPlast, medPUR);
6118
21ea473f 6119 plastOutputCabs->SetVisibility(kTRUE);
6120 plastOutputCabs->SetLineColor(kRed); // Red
6121 plastOutputCabs->SetLineWidth(1);
6122 plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
6123 plastOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6124
21ea473f 6125 TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsAl",
57126ea1 6126 outputCabsAl, medAl);
6127
21ea473f 6128 alOutputCabs->SetVisibility(kTRUE);
6129 alOutputCabs->SetLineColor(6); // Purple
6130 alOutputCabs->SetLineWidth(1);
6131 alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
6132 alOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6133
21ea473f 6134 TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsKapton",
57126ea1 6135 outputCabsKapton, medKapton);
6136
21ea473f 6137 kaptonOutputCabs->SetVisibility(kTRUE);
6138 kaptonOutputCabs->SetLineColor(14); //
6139 kaptonOutputCabs->SetLineWidth(1);
6140 kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
6141 kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6142
1c5895a3 6143 TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideAOutputCabsPOLYAX",
57126ea1 6144 outputCabsPOLYAX, medPOLYAX);
6145
1c5895a3 6146 polyaxOutputCabs->SetVisibility(kTRUE);
6147 polyaxOutputCabs->SetLineColor(34); //
6148 polyaxOutputCabs->SetLineWidth(1);
6149 polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
6150 polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6151
21ea473f 6152 TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsCu",
57126ea1 6153 pcbBoardsCu, medCu);
6154
21ea473f 6155 cuPCBBoards->SetVisibility(kTRUE);
6156 cuPCBBoards->SetLineColor(kBlack); // Black
6157 cuPCBBoards->SetLineWidth(1);
6158 cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
6159 cuPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6160
21ea473f 6161 TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsEpoxy",
57126ea1 6162 pcbBoardsEpoxy, medEpoxy);
6163
21ea473f 6164 epoxyPCBBoards->SetVisibility(kTRUE);
6165 epoxyPCBBoards->SetLineColor(22); //
6166 epoxyPCBBoards->SetLineWidth(1);
6167 epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
6168 epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6169
21ea473f 6170 TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPlast",
57126ea1 6171 pcbBoardsPlast, medPUR);
6172
21ea473f 6173 plastPCBBoards->SetVisibility(kTRUE);
6174 plastPCBBoards->SetLineColor(kRed); // Red
6175 plastPCBBoards->SetLineWidth(1);
6176 plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
6177 plastPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6178
21ea473f 6179 TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsSteel",
57126ea1 6180 pcbBoardsSteel, medSteel);
6181
21ea473f 6182 steelPCBBoards->SetVisibility(kTRUE);
6183 steelPCBBoards->SetLineColor(kBlue); // Blue
6184 steelPCBBoards->SetLineWidth(1);
6185 steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
6186 steelPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6187
1c5895a3 6188 TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideAPCBBoardsPPS",
57126ea1 6189 pcbBoardsPPS, medPPS);
6190
1c5895a3 6191 ppsPCBBoards->SetVisibility(kTRUE);
6192 ppsPCBBoards->SetLineColor(kGreen); // Green
6193 ppsPCBBoards->SetLineWidth(1);
6194 ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
6195 ppsPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6196
798b4e0c 6197
6198 // Now build up the tray
57126ea1 6199 yloc = kForwardTrayTotalHeight - forwardCover->GetY(3);
6200 zloc = kForwardTrayUpperLength - kForwardCoverLength;
798b4e0c 6201 cableTrayA->AddNode(forwardTrayCover, 1,
6202 new TGeoTranslation( 0, yloc, zloc) );
6203
6204 Double_t totalhi = kExternTrayTotalHeight + kExternCoverThick
6205 - kExternCoverYTrans;
6206
57126ea1 6207 yloc = totalhi*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
6208 kExternTrayTotalHeight*CosD(kTrayAZRot);
798b4e0c 6209 zloc = kExternTrayZTrans + totalhi*SinD(kTrayAZRot);
6210 cableTrayA->AddNode(externalTraySDD, 1,
6211 new TGeoCombiTrans( 0, yloc, zloc,
6212 new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
6213
57126ea1 6214 yloc = kExternCoverThick*(1 - CosD(kTrayAZRot)) + kExternTrayYTrans -
6215 kExternCoverYTrans*CosD(kTrayAZRot)/2-0.01;
6216 zloc = kExternTrayZTrans + kExternCoverThick*SinD(kTrayAZRot);
798b4e0c 6217 cableTrayA->AddNode(externTrayCover,1,
6218 new TGeoCombiTrans( 0, yloc, zloc,
6219 new TGeoRotation("", 0,-kTrayAZRot, 0) ) );
6220
57126ea1 6221 yloc = kForwardTrayThick + coolManifPOM->GetDY();
6222 zloc = coolManifPOM->GetDZ();
21ea473f 6223 cableTrayA->AddNode(pomCoolManif, 1,
57126ea1 6224 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6225
57126ea1 6226 yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
21ea473f 6227 cableTrayA->AddNode(steelCoolManif, 1,
57126ea1 6228 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6229
57126ea1 6230 yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
21ea473f 6231 cableTrayA->AddNode(waterCoolManif, 1,
57126ea1 6232 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6233
57126ea1 6234 yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
21ea473f 6235 cableTrayA->AddNode(alCoolManif, 1,
57126ea1 6236 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6237
21ea473f 6238 cableTrayA->AddNode(purCoolTubes,1,
57126ea1 6239 new TGeoCombiTrans( 0, 0, 0,
6240 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6241 cableTrayA->AddNode(waterCoolTubes,1,
57126ea1 6242 new TGeoCombiTrans( 0, 0, 0,
6243 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6244 cableTrayA->AddNode(airCoolTubes,1,
57126ea1 6245 new TGeoCombiTrans( 0, 0, 0,
6246 new TGeoRotation("",-90, 90, 90) ) );
6247
6248 xloc = coolManifPOM->GetDX() + optConnPBT->GetDX();
6249 yloc = kForwardTrayThick + optConnPBT->GetDY();
6250 zloc = optConnPBT->GetDZ();
21ea473f 6251 cableTrayA->AddNode(pbtOptConn, 1,
57126ea1 6252 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 6253 cableTrayA->AddNode(pbtOptConn, 2,
57126ea1 6254 new TGeoTranslation(-xloc, yloc, zloc) );
6255
6256 yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
21ea473f 6257 cableTrayA->AddNode(steelOptConn, 1,
57126ea1 6258 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 6259 cableTrayA->AddNode(steelOptConn, 2,
57126ea1 6260 new TGeoTranslation(-xloc, yloc, zloc) );
6261
6262 yloc += optConnSteel->GetDY() + optConnAl->GetDY();
21ea473f 6263 cableTrayA->AddNode(alOptConn, 1,
57126ea1 6264 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 6265 cableTrayA->AddNode(alOptConn, 2,
57126ea1 6266 new TGeoTranslation(-xloc, yloc, zloc) );
6267
6268
6269 xloc = kSideACoolTubesWide/2 + kSideAOptFibsWide/2;
21ea473f 6270 cableTrayA->AddNode(optFibs,1,
57126ea1 6271 new TGeoCombiTrans( xloc, 0, 0,
6272 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6273 cableTrayA->AddNode(optFibs,2,
57126ea1 6274 new TGeoCombiTrans(-xloc, 0, 0,
6275 new TGeoRotation("",-90, 90, 90) ) );
6276
6277 yloc = kForwardTrayTotalHeight - forwardCover->GetY(3) -
6278 kSideAInputCablesYTrans - inputCabsPOLYAX->GetDY();
6279 zloc = inputCabsPOLYAX->GetDZ();
1c5895a3 6280 cableTrayA->AddNode(polyaxInputCabs, 1,
57126ea1 6281 new TGeoTranslation( 0, yloc, zloc) );
6282
6283 yloc -= (inputCabsPOLYAX->GetDY() + inputCabsKapton->GetDY());
21ea473f 6284 cableTrayA->AddNode(kaptonInputCabs, 1,
57126ea1 6285 new TGeoTranslation( 0, yloc, zloc) );
6286
6287 yloc -= (inputCabsKapton->GetDY() + inputCabsAl->GetDY());
21ea473f 6288 cableTrayA->AddNode(alInputCabs, 1,
57126ea1 6289 new TGeoTranslation( 0, yloc, zloc) );
6290
6291 yloc -= (inputCabsAl->GetDY() + inputCabsPlast->GetDY());
21ea473f 6292 cableTrayA->AddNode(plastInputCabs, 1,
57126ea1 6293 new TGeoTranslation( 0, yloc, zloc) );
798b4e0c 6294
57126ea1 6295 yloc -= (inputCabsPlast->GetDY() + inputCabsCu->GetDY());
21ea473f 6296 cableTrayA->AddNode(cuInputCabs, 1,
57126ea1 6297 new TGeoTranslation( 0, yloc, zloc) );
6298
6299 yloc -= (inputCabsCu->GetDY()+pcbBoardsPPS->GetDY()+kSideAPCBBoardsYTrans);
6300 zloc += pcbBoardsPPS->GetDZ();
1c5895a3 6301 cableTrayA->AddNode(ppsPCBBoards, 1,
57126ea1 6302 new TGeoTranslation( 0, yloc, zloc) );
6303
6304 yloc -= (pcbBoardsPPS->GetDY()+pcbBoardsSteel->GetDY());
21ea473f 6305 cableTrayA->AddNode(steelPCBBoards, 1,
57126ea1 6306 new TGeoTranslation( 0, yloc, zloc) );
6307
6308 yloc -= (pcbBoardsSteel->GetDY()+pcbBoardsPlast->GetDY());
21ea473f 6309 cableTrayA->AddNode(plastPCBBoards, 1,
57126ea1 6310 new TGeoTranslation( 0, yloc, zloc) );
6311
6312 yloc -= (pcbBoardsPlast->GetDY()+pcbBoardsEpoxy->GetDY());
21ea473f 6313 cableTrayA->AddNode(epoxyPCBBoards, 1,
57126ea1 6314 new TGeoTranslation( 0, yloc, zloc) );
6315
6316 yloc -= (pcbBoardsEpoxy->GetDY()+pcbBoardsCu->GetDY());
21ea473f 6317 cableTrayA->AddNode(cuPCBBoards, 1,
57126ea1 6318 new TGeoTranslation( 0, yloc, zloc) );
6319
21ea473f 6320 cableTrayA->AddNode(cuOutputCabs,1,
57126ea1 6321 new TGeoCombiTrans( 0, 0, 0,
6322 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6323 cableTrayA->AddNode(plastOutputCabs,1,
57126ea1 6324 new TGeoCombiTrans( 0, 0, 0,
6325 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6326 cableTrayA->AddNode(alOutputCabs,1,
57126ea1 6327 new TGeoCombiTrans( 0, 0, 0,
6328 new TGeoRotation("",-90, 90, 90) ) );
21ea473f 6329 cableTrayA->AddNode(kaptonOutputCabs,1,
57126ea1 6330 new TGeoCombiTrans( 0, 0, 0,
6331 new TGeoRotation("",-90, 90, 90) ) );
1c5895a3 6332 cableTrayA->AddNode(polyaxOutputCabs,1,
57126ea1 6333 new TGeoCombiTrans( 0, 0, 0,
6334 new TGeoRotation("",-90, 90, 90) ) );
6335
6336
6337 // Finally put everything in the mother volume
798b4e0c 6338 Double_t rforw = kTrayARTrans + kExternTrayTotalHeight +
6339 kExternCoverSideThick -
6340 kForwardTrayTailHeight;
6341
6342 alpharot = -kTrayAFirstRotAng;
6343 xloc = rforw*SinD(alpharot);
6344 yloc = rforw*CosD(alpharot);
6345 zloc = kTrayAZTrans + kTrayAZToSupportRing - kForwardTrayUpperLength;
6346
57126ea1 6347 moth->AddNode(cableTrayA,1,
798b4e0c 6348 new TGeoCombiTrans( xloc, yloc, zloc,
6349 new TGeoRotation("",-alpharot,0,0) ) );
6350
6351 alpharot += 180;
6352 xloc = rforw*SinD(alpharot);
6353 yloc = rforw*CosD(alpharot);
57126ea1 6354 moth->AddNode(cableTrayA,2,
798b4e0c 6355 new TGeoCombiTrans( xloc, yloc, zloc,
6356 new TGeoRotation("",-alpharot,0,0) ) );
6357
6358 alpharot = kTrayAFirstRotAng + 2*kTrayASecondRotAng;
6359 xloc = rforw*SinD(alpharot);
6360 yloc = rforw*CosD(alpharot);
57126ea1 6361 moth->AddNode(cableTrayA,3,
798b4e0c 6362 new TGeoCombiTrans( xloc, yloc, zloc,
6363 new TGeoRotation("",-alpharot,0,0) ) );
6364
6365 alpharot += 180;
6366 xloc = rforw*SinD(alpharot);
6367 yloc = rforw*CosD(alpharot);
57126ea1 6368 moth->AddNode(cableTrayA,4,
798b4e0c 6369 new TGeoCombiTrans( xloc, yloc, zloc,
6370 new TGeoRotation("",-alpharot,0,0) ) );
6371
6372
6373 return;
6374}
6375
aa177c73 6376//______________________________________________________________________
6377void AliITSv11GeometrySupport::SDDCableTraysSideC(TGeoVolume *moth,
43aefea7 6378 const TGeoManager *mgr){
aa177c73 6379//
6380// Creates the SDD cable trays which are outside the ITS support cones
6381// but still inside the TPC on Side C
6382// (part of this code is taken or anyway inspired to ServicesCableSupport
6383// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
6384//
6385// Input:
6386// moth : the TGeoVolume owing the volume structure
6387// mgr : the GeoManager (default gGeoManager)
6388// Output:
6389//
6390// Created: ??? Bjorn S. Nilsen
6391// Updated: 17 Apr 2010 Mario Sitta
6392//
6393// Technical data are taken from AutoCAD drawings and other (oral)
6394// information given by F.Tosello
6395//
6396
57126ea1 6397 // Dimensions and positions of the C-Side Cable Tray
6398 // (Change accordingly to CreateSDDSSDTraysSideC !)
aa177c73 6399 const Int_t kNumTraySideC = 4;
6400
57126ea1 6401 const Double_t kSideCHalfThick = 0.100 *fgkcm;
6402 const Double_t kSideCLength1 = 172.800 *fgkcm;
6403 const Double_t kSideCLength2 = 189.300 *fgkcm;
6404 const Double_t kBarCoolRmax = 0.4 *fgkcm;
6405 const Double_t kXShiftBarCool = 13.00 *fgkcm;
6406
aa177c73 6407 const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
6408
57126ea1 6409 // Dimensions and positions of the Cable Tray elements
6410 const Double_t kSideCCoolManifHalfX = 4.25 *fgkcm;
6411 const Double_t kSideCCoolManifHalfY = 4.03 *fgkcm;
6412 const Double_t kSideCCoolManifHalfZ = 2.17 *fgkcm;
6413 const Double_t kSideCCoolManifPOMFrac = 0.0051;
6414 const Double_t kSideCCoolManifSteelFrac= 0.8502;
6415 const Double_t kSideCCoolManifWaterFrac= 0.0868;
6416 const Double_t kSideCCoolManifAlFrac = 0.0579;
6417
6418 const Double_t kSideCCoolTubesHigh = 1.88 *fgkcm;
6419 const Double_t kSideCCoolTubesTrans = 0.85 *fgkcm;
6420 const Double_t kSideCCoolTubesPURFrac = 0.5884;
6421 const Double_t kSideCCoolTubesWaterFrac= 0.4114;
6422 const Double_t kSideCCoolTubesAirFrac = 0.0002;
6423
6424 const Double_t kSideCOptConnHalfX = 0.90 *fgkcm;
6425 const Double_t kSideCOptConnHalfZ = 1.37 *fgkcm;
6426 const Double_t kSideCOptConnPBTFrac = 0.6798;
6427 const Double_t kSideCOptConnSteelFrac = 0.2421;
6428 const Double_t kSideCOptConnAlFrac = 0.0781;
6429
6430 const Double_t kSideCOptFibsWide = 0.71 *fgkcm;
6431 const Double_t kSideCOptFibsHigh = 3.20 *fgkcm;
6432 const Double_t kSideCOptFibsTrans = 0.20 *fgkcm;
6433
6434 const Double_t kSideCInputCablesLen = 31.45 *fgkcm;
6435 const Double_t kSideCInputCablesWide = 12.50 *fgkcm;
6436 const Double_t kSideCInputCablesHigh = 0.95 *fgkcm;
6437 const Double_t kSideCInputCablesTrans = 1.15 *fgkcm;
6438 const Double_t kSideCInputCablesCu = 0.7405;
6439 const Double_t kSideCInputCablesPlast = 0.1268;
6440 const Double_t kSideCInputCablesAl = 0.0057;
6441 const Double_t kSideCInputCablesKapton = 0.0172;
6442 const Double_t kSideCInputCablesPOLYAX = 0.1098;
6443
6444 const Double_t kSideCOutputCablesX0 = 27.40 *fgkcm;
5d9d4033 6445 const Double_t kSideCOutputCablesWide = 8.50 *fgkcm;
57126ea1 6446 const Double_t kSideCOutputCablesHigh = 1.18 *fgkcm;
6447 const Double_t kSideCOutputCablesCu = 0.6775;
6448 const Double_t kSideCOutputCablesPlast = 0.1613;
6449 const Double_t kSideCOutputCablesAl = 0.0078;
6450 const Double_t kSideCOutputCablesKapton= 0.0234;
6451 const Double_t kSideCOutputCablesPOLYAX= 0.1300;
6452
6453 const Double_t kSideCPCBBoardsHalfX = 6.30 *fgkcm;
6454 const Double_t kSideCPCBBoardsHalfY = 2.00 *fgkcm;
6455 const Double_t kSideCPCBBoardsHalfZ = 21.93 *fgkcm;
6456 const Double_t kSideCPCBBoardsCu = 0.3864;
6457 const Double_t kSideCPCBBoardsEpoxy = 0.1491;
6458 const Double_t kSideCPCBBoardsPlast = 0.0579;
6459 const Double_t kSideCPCBBoardsSteel = 0.1517;
6460 const Double_t kSideCPCBBoardsPPS = 0.2549;
6461
aa177c73 6462 // Overall position and rotation of the C-Side Cable Trays
6463 const Double_t kTraySideCRPos = 45.30 *fgkcm;
6464 const Double_t kTraySideCZPos = -102.40 *fgkcm;
6465 const Double_t kTraySideCAlphaRot[kNumTraySideC] = { -23.0, 59.0,
6466 /* from SSD tray position */ 180.-23.0, 180.+59.0};
6467
6468
6469 // Local variables
57126ea1 6470 Double_t xprof[6], yprof[6];
6471 Double_t height, xloc, yloc, zloc, alpharot, alphafold;
aa177c73 6472
6473
6474 // The assembly holding the metallic structure
57126ea1 6475 TGeoVolumeAssembly *trayStructure = CreateSDDSSDTraysSideC("ITSsupportSDDTrayC");
6476
6477 // Now the volumes inside it
6478 // The cooling manifold: four boxes
6479 // (X and Z are inverted on tray reference system)
6480 TGeoBBox *coolManifPOM = new TGeoBBox(kSideCCoolManifHalfZ,
6481 kSideCCoolManifPOMFrac*kSideCCoolManifHalfY,
6482 kSideCCoolManifHalfX);
6483
6484 TGeoBBox *coolManifSteel = new TGeoBBox(kSideCCoolManifHalfZ,
6485 kSideCCoolManifSteelFrac*kSideCCoolManifHalfY,
6486 kSideCCoolManifHalfX);
6487
6488 TGeoBBox *coolManifWater = new TGeoBBox(kSideCCoolManifHalfZ,
6489 kSideCCoolManifWaterFrac*kSideCCoolManifHalfY,
6490 kSideCCoolManifHalfX);
6491
6492 TGeoBBox *coolManifAl = new TGeoBBox(kSideCCoolManifHalfZ,
6493 kSideCCoolManifAlFrac*kSideCCoolManifHalfY,
6494 kSideCCoolManifHalfX);
6495
6496 // The cooling tubes: three Xtru's
6497 alpharot = kSideCFoldAngle*TMath::DegToRad();
6498
6499 TGeoXtru *coolTubesPUR = new TGeoXtru(2);
6500
6501 height = kSideCCoolTubesHigh*kSideCCoolTubesPURFrac;
6502
6503 xprof[0] = 2*kSideCCoolManifHalfZ;
6504 yprof[0] = 2*kSideCHalfThick + kSideCCoolTubesTrans;
6505 xprof[1] = kSideCLength1;
6506 yprof[1] = yprof[0];
6507 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
6508 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
6509 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6510 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6511 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6512 height, xprof[4], yprof[4]);
6513 xprof[5] = xprof[0];
6514 yprof[5] = yprof[0] + height;
6515
6516 coolTubesPUR->DefinePolygon(6, xprof, yprof);
6517 coolTubesPUR->DefineSection(0,-kSideCCoolManifHalfX);
6518 coolTubesPUR->DefineSection(1, kSideCCoolManifHalfX);
6519
6520 TGeoXtru *coolTubesWater = new TGeoXtru(2);
6521
6522 height = kSideCCoolTubesHigh*kSideCCoolTubesWaterFrac;
6523
6524 xprof[0] = coolTubesPUR->GetX(5);
6525 yprof[0] = coolTubesPUR->GetY(5);
6526 xprof[1] = coolTubesPUR->GetX(4);
6527 yprof[1] = coolTubesPUR->GetY(4);
6528 xprof[2] = coolTubesPUR->GetX(3);
6529 yprof[2] = coolTubesPUR->GetY(3);
6530 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6531 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6532 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6533 height, xprof[4], yprof[4]);
6534 xprof[5] = xprof[0];
6535 yprof[5] = yprof[0] + height;
6536
6537 coolTubesWater->DefinePolygon(6, xprof, yprof);
6538 coolTubesWater->DefineSection(0,-kSideCCoolManifHalfX);
6539 coolTubesWater->DefineSection(1, kSideCCoolManifHalfX);
6540
6541 TGeoXtru *coolTubesAir = new TGeoXtru(2);
6542
6543 height = kSideCCoolTubesHigh*kSideCCoolTubesAirFrac;
6544
6545 xprof[0] = coolTubesWater->GetX(5);
6546 yprof[0] = coolTubesWater->GetY(5);
6547 xprof[1] = coolTubesWater->GetX(4);
6548 yprof[1] = coolTubesWater->GetY(4);
6549 xprof[2] = coolTubesWater->GetX(3);
6550 yprof[2] = coolTubesWater->GetY(3);
6551 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6552 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6553 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6554 height, xprof[4], yprof[4]);
6555 xprof[5] = xprof[0];
6556 yprof[5] = yprof[0] + height;
6557
6558 coolTubesAir->DefinePolygon(6, xprof, yprof);
6559 coolTubesAir->DefineSection(0,-kSideCCoolManifHalfX);
6560 coolTubesAir->DefineSection(1, kSideCCoolManifHalfX);
6561
6562 // The optical fiber connectors: three boxes
6563 // (X and Z are inverted on tray reference system)
6564 TGeoBBox *optConnPBT = new TGeoBBox(kSideCOptConnHalfZ,
6565 kSideCOptConnPBTFrac*kSideCCoolManifHalfY,
6566 kSideCOptConnHalfX);
6567
6568 TGeoBBox *optConnSteel = new TGeoBBox(kSideCOptConnHalfZ,
6569 kSideCOptConnSteelFrac*kSideCCoolManifHalfY,
6570 kSideCOptConnHalfX);
6571
6572 TGeoBBox *optConnAl = new TGeoBBox(kSideCOptConnHalfZ,
6573 kSideCOptConnAlFrac*kSideCCoolManifHalfY,
6574 kSideCOptConnHalfX);
6575
6576 // The optical fibers: a Xtru
6577 TGeoXtru *opticalFibs = new TGeoXtru(2);
6578
6579 xprof[0] = 2*kSideCOptConnHalfZ;
6580 yprof[0] = 2*kSideCHalfThick + kSideCOptFibsTrans;
6581 xprof[1] = kSideCLength1;
6582 yprof[1] = yprof[0];
6583 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(alpharot);
6584 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(alpharot);
6585 xprof[3] = xprof[2] - kSideCOptFibsHigh*TMath::Sin(alpharot);
6586 yprof[3] = yprof[2] + kSideCOptFibsHigh*TMath::Cos(alpharot);
6587 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6588 kSideCOptFibsHigh, xprof[4], yprof[4]);
6589 xprof[5] = xprof[0];
6590 yprof[5] = yprof[0] + kSideCOptFibsHigh;
6591
6592 opticalFibs->DefinePolygon(6, xprof, yprof);
6593 opticalFibs->DefineSection(0,-kSideCOptFibsWide/2);
6594 opticalFibs->DefineSection(1, kSideCOptFibsWide/2);
6595
6596 // The input cables: five boxes
6597 // (X and Z are inverted on tray reference system)
6598 TGeoBBox *inputCabsCu = new TGeoBBox(kSideCInputCablesLen/2,
6599 kSideCInputCablesCu*kSideCInputCablesHigh/2,
6600 kSideCInputCablesWide/2);
6601
6602 TGeoBBox *inputCabsPlast = new TGeoBBox(kSideCInputCablesLen/2,
6603 kSideCInputCablesPlast*kSideCInputCablesHigh/2,
6604 kSideCInputCablesWide/2);
6605
6606 TGeoBBox *inputCabsAl = new TGeoBBox(kSideCInputCablesLen/2,
6607 kSideCInputCablesAl*kSideCInputCablesHigh/2,
6608 kSideCInputCablesWide/2);
6609
6610 TGeoBBox *inputCabsKapton = new TGeoBBox(kSideCInputCablesLen/2,
6611 kSideCInputCablesKapton*kSideCInputCablesHigh/2,
6612 kSideCInputCablesWide/2);
6613
6614 TGeoBBox *inputCabsPOLYAX = new TGeoBBox(kSideCInputCablesLen/2,
6615 kSideCInputCablesPOLYAX*kSideCInputCablesHigh/2,
6616 kSideCInputCablesWide/2);
6617
6618 // The output cables: five Xtru
6619 TGeoXtru *outputCabsCu = new TGeoXtru(2);
6620
6621 height = kSideCOutputCablesCu*kSideCOutputCablesHigh;
6622
6623 xprof[0] = coolTubesAir->GetX(5) + kSideCOutputCablesX0;
6624 yprof[0] = coolTubesAir->GetY(5);
6625 xprof[1] = coolTubesAir->GetX(4);
6626 yprof[1] = coolTubesAir->GetY(4);
6627 xprof[2] = coolTubesAir->GetX(3);
6628 yprof[2] = coolTubesAir->GetY(3);
6629 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6630 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6631 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6632 height, xprof[4], yprof[4]);
6633 xprof[5] = xprof[0];
6634 yprof[5] = yprof[0] + height;
6635
6636 outputCabsCu->DefinePolygon(6, xprof, yprof);
6637 outputCabsCu->DefineSection(0,-kSideCOutputCablesWide/2);
6638 outputCabsCu->DefineSection(1, kSideCOutputCablesWide/2);
6639
6640 TGeoXtru *outputCabsPlast = new TGeoXtru(2);
6641
6642 height = kSideCOutputCablesPlast*kSideCOutputCablesHigh;
6643
6644 xprof[0] = outputCabsCu->GetX(5);
6645 yprof[0] = outputCabsCu->GetY(5);
6646 xprof[1] = outputCabsCu->GetX(4);
6647 yprof[1] = outputCabsCu->GetY(4);
6648 xprof[2] = outputCabsCu->GetX(3);
6649 yprof[2] = outputCabsCu->GetY(3);
6650 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6651 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6652 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6653 height, xprof[4], yprof[4]);
6654 xprof[5] = xprof[0];
6655 yprof[5] = yprof[0] + height;
6656
6657 outputCabsPlast->DefinePolygon(6, xprof, yprof);
6658 outputCabsPlast->DefineSection(0,-kSideCOutputCablesWide/2);
6659 outputCabsPlast->DefineSection(1, kSideCOutputCablesWide/2);
6660
6661 TGeoXtru *outputCabsAl = new TGeoXtru(2);
6662
6663 height = kSideCOutputCablesAl*kSideCOutputCablesHigh;
6664
6665 xprof[0] = outputCabsPlast->GetX(5);
6666 yprof[0] = outputCabsPlast->GetY(5);
6667 xprof[1] = outputCabsPlast->GetX(4);
6668 yprof[1] = outputCabsPlast->GetY(4);
6669 xprof[2] = outputCabsPlast->GetX(3);
6670 yprof[2] = outputCabsPlast->GetY(3);
6671 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6672 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6673 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6674 height, xprof[4], yprof[4]);
6675 xprof[5] = xprof[0];
6676 yprof[5] = yprof[0] + height;
6677
6678 outputCabsAl->DefinePolygon(6, xprof, yprof);
6679 outputCabsAl->DefineSection(0,-kSideCOutputCablesWide/2);
6680 outputCabsAl->DefineSection(1, kSideCOutputCablesWide/2);
6681
6682 TGeoXtru *outputCabsKapton = new TGeoXtru(2);
6683
6684 height = kSideCOutputCablesKapton*kSideCOutputCablesHigh;
6685
6686 xprof[0] = outputCabsAl->GetX(5);
6687 yprof[0] = outputCabsAl->GetY(5);
6688 xprof[1] = outputCabsAl->GetX(4);
6689 yprof[1] = outputCabsAl->GetY(4);
6690 xprof[2] = outputCabsAl->GetX(3);
6691 yprof[2] = outputCabsAl->GetY(3);
6692 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6693 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6694 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6695 height, xprof[4], yprof[4]);
6696 xprof[5] = xprof[0];
6697 yprof[5] = yprof[0] + height;
6698
6699 outputCabsKapton->DefinePolygon(6, xprof, yprof);
6700 outputCabsKapton->DefineSection(0,-kSideCOutputCablesWide/2);
6701 outputCabsKapton->DefineSection(1, kSideCOutputCablesWide/2);
6702
6703 TGeoXtru *outputCabsPOLYAX = new TGeoXtru(2);
6704
6705 height = kSideCOutputCablesPOLYAX*kSideCOutputCablesHigh;
6706
6707 xprof[0] = outputCabsKapton->GetX(5);
6708 yprof[0] = outputCabsKapton->GetY(5);
6709 xprof[1] = outputCabsKapton->GetX(4);
6710 yprof[1] = outputCabsKapton->GetY(4);
6711 xprof[2] = outputCabsKapton->GetX(3);
6712 yprof[2] = outputCabsKapton->GetY(3);
6713 xprof[3] = xprof[2] - height*TMath::Sin(alpharot);
6714 yprof[3] = yprof[2] + height*TMath::Cos(alpharot);
6715 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
6716 height, xprof[4], yprof[4]);
6717 xprof[5] = xprof[0];
6718 yprof[5] = yprof[0] + height;
6719
6720 outputCabsPOLYAX->DefinePolygon(6, xprof, yprof);
6721 outputCabsPOLYAX->DefineSection(0,-kSideCOutputCablesWide/2);
6722 outputCabsPOLYAX->DefineSection(1, kSideCOutputCablesWide/2);
6723
6724 // The PCB boards: five boxes
6725 // (X and Z are inverted on tray reference system)
6726 TGeoBBox *pcbBoardsCu = new TGeoBBox(kSideCPCBBoardsHalfZ,
6727 kSideCPCBBoardsCu*kSideCPCBBoardsHalfY,
6728 kSideCPCBBoardsHalfX);
6729
6730 TGeoBBox *pcbBoardsEpoxy = new TGeoBBox(kSideCPCBBoardsHalfZ,
6731 kSideCPCBBoardsEpoxy*kSideCPCBBoardsHalfY,
6732 kSideCPCBBoardsHalfX);
6733
6734 TGeoBBox *pcbBoardsPlast = new TGeoBBox(kSideCPCBBoardsHalfZ,
6735 kSideCPCBBoardsPlast*kSideCPCBBoardsHalfY,
6736 kSideCPCBBoardsHalfX);
6737
6738 TGeoBBox *pcbBoardsSteel = new TGeoBBox(kSideCPCBBoardsHalfZ,
6739 kSideCPCBBoardsSteel*kSideCPCBBoardsHalfY,
6740 kSideCPCBBoardsHalfX);
6741
6742 TGeoBBox *pcbBoardsPPS = new TGeoBBox(kSideCPCBBoardsHalfZ,
6743 kSideCPCBBoardsPPS*kSideCPCBBoardsHalfY,
6744 kSideCPCBBoardsHalfX);
aa177c73 6745
6746
6747 // We have all shapes: now create the real volumes
57126ea1 6748 TGeoMedium *medPOM = mgr->GetMedium("ITS_POLYOXYMETHYLENE$");
0801d201 6749 TGeoMedium *medSteel = mgr->GetMedium("ITS_INOX$");
6750 TGeoMedium *medWater = mgr->GetMedium("ITS_WATER$");
6751 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
6752 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
6753 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
57126ea1 6754 TGeoMedium *medPOLYAX = mgr->GetMedium("ITS_POLYAX$");
0801d201 6755 TGeoMedium *medKapton = mgr->GetMedium("ITS_SDDKAPTON (POLYCH2)$");
57126ea1 6756 TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
6757 TGeoMedium *medPBT = mgr->GetMedium("ITS_PBT$");
0801d201 6758 TGeoMedium *medOptFib = mgr->GetMedium("ITS_SDD OPTICFIB$");
57126ea1 6759 TGeoMedium *medPPS = mgr->GetMedium("ITS_PPS$");
0801d201 6760 TGeoMedium *medEpoxy = mgr->GetMedium("ITS_EPOXY$");
57126ea1 6761
21ea473f 6762 TGeoVolume *pomCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifPOM",
57126ea1 6763 coolManifPOM, medPOM);
6764
21ea473f 6765 pomCoolManif->SetVisibility(kTRUE);
6766 pomCoolManif->SetLineColor(kRed); // Red
6767 pomCoolManif->SetLineWidth(1);
6768 pomCoolManif->SetFillColor(pomCoolManif->GetLineColor());
6769 pomCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6770
21ea473f 6771 TGeoVolume *steelCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifSteel",
57126ea1 6772 coolManifSteel, medSteel);
6773
21ea473f 6774 steelCoolManif->SetVisibility(kTRUE);
6775 steelCoolManif->SetLineColor(kBlue); // Blue
6776 steelCoolManif->SetLineWidth(1);
6777 steelCoolManif->SetFillColor(steelCoolManif->GetLineColor());
6778 steelCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6779
21ea473f 6780 TGeoVolume *waterCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifWater",
57126ea1 6781 coolManifWater, medWater);
6782
21ea473f 6783 waterCoolManif->SetVisibility(kTRUE);
6784 waterCoolManif->SetLineColor(33); // Light Blue
6785 waterCoolManif->SetLineWidth(1);
6786 waterCoolManif->SetFillColor(waterCoolManif->GetLineColor());
6787 waterCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6788
21ea473f 6789 TGeoVolume *alCoolManif = new TGeoVolume("ITSsuppSDDSideCCoolManifAl",
57126ea1 6790 coolManifAl, medAl);
6791
21ea473f 6792 alCoolManif->SetVisibility(kTRUE);
6793 alCoolManif->SetLineColor(6); // Purple
6794 alCoolManif->SetLineWidth(1);
6795 alCoolManif->SetFillColor(alCoolManif->GetLineColor());
6796 alCoolManif->SetFillStyle(4000); // 0% transparent
57126ea1 6797
21ea473f 6798 TGeoVolume *purCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesPUR",
57126ea1 6799 coolTubesPUR, medPUR);
6800
21ea473f 6801 purCoolTubes->SetVisibility(kTRUE);
6802 purCoolTubes->SetLineColor(kRed); // Red
6803 purCoolTubes->SetLineWidth(1);
6804 purCoolTubes->SetFillColor(purCoolTubes->GetLineColor());
6805 purCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6806
21ea473f 6807 TGeoVolume *waterCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesWater",
57126ea1 6808 coolTubesWater, medWater);
6809
21ea473f 6810 waterCoolTubes->SetVisibility(kTRUE);
6811 waterCoolTubes->SetLineColor(33); // Light Blue
6812 waterCoolTubes->SetLineWidth(1);
6813 waterCoolTubes->SetFillColor(waterCoolTubes->GetLineColor());
6814 waterCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6815
21ea473f 6816 TGeoVolume *airCoolTubes = new TGeoVolume("ITSsuppSDDSideCCoolTubesAir",
57126ea1 6817 coolTubesAir, medAir);
6818
21ea473f 6819 airCoolTubes->SetVisibility(kTRUE);
6820 airCoolTubes->SetLineColor(41);
6821 airCoolTubes->SetLineWidth(1);
6822 airCoolTubes->SetFillColor(airCoolTubes->GetLineColor());
6823 airCoolTubes->SetFillStyle(4000); // 0% transparent
57126ea1 6824
21ea473f 6825 TGeoVolume *pbtOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnPBT",
57126ea1 6826 optConnPBT, medPBT);
6827
21ea473f 6828 pbtOptConn->SetVisibility(kTRUE);
6829 pbtOptConn->SetLineColor(kRed); // Red
6830 pbtOptConn->SetLineWidth(1);
6831 pbtOptConn->SetFillColor(pbtOptConn->GetLineColor());
6832 pbtOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6833
21ea473f 6834 TGeoVolume *steelOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnSteel",
57126ea1 6835 optConnSteel, medSteel);
6836
21ea473f 6837 steelOptConn->SetVisibility(kTRUE);
6838 steelOptConn->SetLineColor(kBlue); // Blue
6839 steelOptConn->SetLineWidth(1);
6840 steelOptConn->SetFillColor(steelOptConn->GetLineColor());
6841 steelOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6842
21ea473f 6843 TGeoVolume *alOptConn = new TGeoVolume("ITSsuppSDDSideCOptConnAl",
57126ea1 6844 optConnAl, medAl);
6845
21ea473f 6846 alOptConn->SetVisibility(kTRUE);
6847 alOptConn->SetLineColor(6); // Purple
6848 alOptConn->SetLineWidth(1);
6849 alOptConn->SetFillColor(alOptConn->GetLineColor());
6850 alOptConn->SetFillStyle(4000); // 0% transparent
57126ea1 6851
21ea473f 6852 TGeoVolume *optFibs = new TGeoVolume("ITSsuppSDDSideCOptFibs",
57126ea1 6853 opticalFibs, medOptFib);
6854
21ea473f 6855 optFibs->SetVisibility(kTRUE);
6856 optFibs->SetLineColor(kOrange+2); // Orange
6857 optFibs->SetLineWidth(1);
6858 optFibs->SetFillColor(optFibs->GetLineColor());
6859 optFibs->SetFillStyle(4000); // 0% transparent
57126ea1 6860
21ea473f 6861 TGeoVolume *cuInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsCu",
57126ea1 6862 inputCabsCu, medCu);
6863
21ea473f 6864 cuInputCabs->SetVisibility(kTRUE);
6865 cuInputCabs->SetLineColor(kBlack); // Black
6866 cuInputCabs->SetLineWidth(1);
6867 cuInputCabs->SetFillColor(cuInputCabs->GetLineColor());
6868 cuInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6869
21ea473f 6870 TGeoVolume *plastInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPlast",
57126ea1 6871 inputCabsPlast, medPUR);
6872
21ea473f 6873 plastInputCabs->SetVisibility(kTRUE);
6874 plastInputCabs->SetLineColor(kRed); // Red
6875 plastInputCabs->SetLineWidth(1);
6876 plastInputCabs->SetFillColor(plastInputCabs->GetLineColor());
6877 plastInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6878
21ea473f 6879 TGeoVolume *alInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsAl",
57126ea1 6880 inputCabsAl, medAl);
6881
21ea473f 6882 alInputCabs->SetVisibility(kTRUE);
6883 alInputCabs->SetLineColor(6); // Purple
6884 alInputCabs->SetLineWidth(1);
6885 alInputCabs->SetFillColor(alInputCabs->GetLineColor());
6886 alInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6887
21ea473f 6888 TGeoVolume *kaptonInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsKapton",
57126ea1 6889 inputCabsKapton, medKapton);
6890
21ea473f 6891 kaptonInputCabs->SetVisibility(kTRUE);
6892 kaptonInputCabs->SetLineColor(14); //
6893 kaptonInputCabs->SetLineWidth(1);
6894 kaptonInputCabs->SetFillColor(kaptonInputCabs->GetLineColor());
6895 kaptonInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6896
1c5895a3 6897 TGeoVolume *polyaxInputCabs = new TGeoVolume("ITSsuppSDDSideCInputCabsPOLYAX",
57126ea1 6898 inputCabsPOLYAX, medPOLYAX);
6899
1c5895a3 6900 polyaxInputCabs->SetVisibility(kTRUE);
6901 polyaxInputCabs->SetLineColor(34); //
6902 polyaxInputCabs->SetLineWidth(1);
6903 polyaxInputCabs->SetFillColor(polyaxInputCabs->GetLineColor());
6904 polyaxInputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6905
21ea473f 6906 TGeoVolume *cuOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsCu",
57126ea1 6907 outputCabsCu, medCu);
6908
21ea473f 6909 cuOutputCabs->SetVisibility(kTRUE);
6910 cuOutputCabs->SetLineColor(kBlack); // Black
6911 cuOutputCabs->SetLineWidth(1);
6912 cuOutputCabs->SetFillColor(cuOutputCabs->GetLineColor());
6913 cuOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6914
21ea473f 6915 TGeoVolume *plastOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPlast",
57126ea1 6916 outputCabsPlast, medPUR);
6917
21ea473f 6918 plastOutputCabs->SetVisibility(kTRUE);
6919 plastOutputCabs->SetLineColor(kRed); // Red
6920 plastOutputCabs->SetLineWidth(1);
6921 plastOutputCabs->SetFillColor(plastOutputCabs->GetLineColor());
6922 plastOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6923
21ea473f 6924 TGeoVolume *alOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsAl",
57126ea1 6925 outputCabsAl, medAl);
6926
21ea473f 6927 alOutputCabs->SetVisibility(kTRUE);
6928 alOutputCabs->SetLineColor(6); // Purple
6929 alOutputCabs->SetLineWidth(1);
6930 alOutputCabs->SetFillColor(alOutputCabs->GetLineColor());
6931 alOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6932
21ea473f 6933 TGeoVolume *kaptonOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsKapton",
57126ea1 6934 outputCabsKapton, medKapton);
6935
21ea473f 6936 kaptonOutputCabs->SetVisibility(kTRUE);
6937 kaptonOutputCabs->SetLineColor(14); //
6938 kaptonOutputCabs->SetLineWidth(1);
6939 kaptonOutputCabs->SetFillColor(kaptonOutputCabs->GetLineColor());
6940 kaptonOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6941
1c5895a3 6942 TGeoVolume *polyaxOutputCabs = new TGeoVolume("ITSsuppSDDSideCOutputCabsPOLYAX",
57126ea1 6943 outputCabsPOLYAX, medPOLYAX);
6944
1c5895a3 6945 polyaxOutputCabs->SetVisibility(kTRUE);
6946 polyaxOutputCabs->SetLineColor(34); //
6947 polyaxOutputCabs->SetLineWidth(1);
6948 polyaxOutputCabs->SetFillColor(polyaxOutputCabs->GetLineColor());
6949 polyaxOutputCabs->SetFillStyle(4000); // 0% transparent
57126ea1 6950
21ea473f 6951 TGeoVolume *cuPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsCu",
57126ea1 6952 pcbBoardsCu, medCu);
6953
21ea473f 6954 cuPCBBoards->SetVisibility(kTRUE);
6955 cuPCBBoards->SetLineColor(kBlack); // Black
6956 cuPCBBoards->SetLineWidth(1);
6957 cuPCBBoards->SetFillColor(cuPCBBoards->GetLineColor());
6958 cuPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6959
21ea473f 6960 TGeoVolume *epoxyPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsEpoxy",
57126ea1 6961 pcbBoardsEpoxy, medEpoxy);
6962
21ea473f 6963 epoxyPCBBoards->SetVisibility(kTRUE);
6964 epoxyPCBBoards->SetLineColor(22); //
6965 epoxyPCBBoards->SetLineWidth(1);
6966 epoxyPCBBoards->SetFillColor(epoxyPCBBoards->GetLineColor());
6967 epoxyPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6968
21ea473f 6969 TGeoVolume *plastPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPlast",
57126ea1 6970 pcbBoardsPlast, medPUR);
6971
21ea473f 6972 plastPCBBoards->SetVisibility(kTRUE);
6973 plastPCBBoards->SetLineColor(kRed); // Red
6974 plastPCBBoards->SetLineWidth(1);
6975 plastPCBBoards->SetFillColor(plastPCBBoards->GetLineColor());
6976 plastPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6977
21ea473f 6978 TGeoVolume *steelPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsSteel",
57126ea1 6979 pcbBoardsSteel, medSteel);
6980
21ea473f 6981 steelPCBBoards->SetVisibility(kTRUE);
6982 steelPCBBoards->SetLineColor(kBlue); // Blue
6983 steelPCBBoards->SetLineWidth(1);
6984 steelPCBBoards->SetFillColor(steelPCBBoards->GetLineColor());
6985 steelPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6986
1c5895a3 6987 TGeoVolume *ppsPCBBoards = new TGeoVolume("ITSsuppSDDSideCPCBBoardsPPS",
57126ea1 6988 pcbBoardsPPS, medPPS);
6989
1c5895a3 6990 ppsPCBBoards->SetVisibility(kTRUE);
6991 ppsPCBBoards->SetLineColor(kGreen); // Green
6992 ppsPCBBoards->SetLineWidth(1);
6993 ppsPCBBoards->SetFillColor(ppsPCBBoards->GetLineColor());
6994 ppsPCBBoards->SetFillStyle(4000); // 0% transparent
57126ea1 6995
6996
6997 // Now fill the tray
6998 xloc = coolManifPOM->GetDX();
6999 yloc = 2*kSideCHalfThick + coolManifPOM->GetDY();
21ea473f 7000 trayStructure->AddNode(pomCoolManif, 1,
57126ea1 7001 new TGeoTranslation( xloc, yloc, 0) );
7002
7003 yloc += coolManifPOM->GetDY() + coolManifSteel->GetDY();
21ea473f 7004 trayStructure->AddNode(steelCoolManif, 1,
57126ea1 7005 new TGeoTranslation( xloc, yloc, 0) );
7006
7007 yloc += coolManifSteel->GetDY() + coolManifWater->GetDY();
21ea473f 7008 trayStructure->AddNode(waterCoolManif, 1,
57126ea1 7009 new TGeoTranslation( xloc, yloc, 0) );
7010
7011 yloc += coolManifWater->GetDY() + coolManifAl->GetDY();
21ea473f 7012 trayStructure->AddNode(alCoolManif, 1,
57126ea1 7013 new TGeoTranslation( xloc, yloc, 0) );
7014
7015 xloc = inputCabsCu->GetDX();
7016 yloc += coolManifWater->GetDY() + inputCabsCu->GetDY()
7017 + kSideCInputCablesTrans;
21ea473f 7018 trayStructure->AddNode(cuInputCabs, 1,
57126ea1 7019 new TGeoTranslation( xloc, yloc, 0) );
7020
7021 yloc += inputCabsCu->GetDY() + inputCabsPlast->GetDY();
21ea473f 7022 trayStructure->AddNode(plastInputCabs, 1,
57126ea1 7023 new TGeoTranslation( xloc, yloc, 0) );
7024
7025 yloc += inputCabsPlast->GetDY() + inputCabsAl->GetDY();
21ea473f 7026 trayStructure->AddNode(alInputCabs, 1,
57126ea1 7027 new TGeoTranslation( xloc, yloc, 0) );
7028
7029 yloc += inputCabsAl->GetDY() + inputCabsKapton->GetDY();
21ea473f 7030 trayStructure->AddNode(kaptonInputCabs, 1,
57126ea1 7031 new TGeoTranslation( xloc, yloc, 0) );
7032
7033 yloc += inputCabsKapton->GetDY() + inputCabsPOLYAX->GetDY();
1c5895a3 7034 trayStructure->AddNode(polyaxInputCabs, 1,
57126ea1 7035 new TGeoTranslation( xloc, yloc, 0) );
7036
21ea473f 7037 trayStructure->AddNode(purCoolTubes , 1, 0);
7038 trayStructure->AddNode(waterCoolTubes, 1, 0);
7039 trayStructure->AddNode(airCoolTubes , 1, 0);
57126ea1 7040
7041 xloc = optConnPBT->GetDX();
7042 yloc = 2*kSideCHalfThick + optConnPBT->GetDY();
7043 zloc = coolManifPOM->GetDZ() + optConnPBT->GetDZ();
21ea473f 7044 trayStructure->AddNode(pbtOptConn, 1,
57126ea1 7045 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 7046 trayStructure->AddNode(pbtOptConn, 2,
57126ea1 7047 new TGeoTranslation( xloc, yloc,-zloc) );
7048
7049 yloc += optConnPBT->GetDY() + optConnSteel->GetDY();
21ea473f 7050 trayStructure->AddNode(steelOptConn, 1,
57126ea1 7051 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 7052 trayStructure->AddNode(steelOptConn, 2,
57126ea1 7053 new TGeoTranslation( xloc, yloc,-zloc) );
7054
7055 yloc += optConnSteel->GetDY() + optConnAl->GetDY();
21ea473f 7056 trayStructure->AddNode(alOptConn, 1,
57126ea1 7057 new TGeoTranslation( xloc, yloc, zloc) );
21ea473f 7058 trayStructure->AddNode(alOptConn, 2,
57126ea1 7059 new TGeoTranslation( xloc, yloc,-zloc) );
7060
21ea473f 7061 trayStructure->AddNode(optFibs, 1,
57126ea1 7062 new TGeoTranslation( 0, 0, zloc) );
21ea473f 7063 trayStructure->AddNode(optFibs, 2,
57126ea1 7064 new TGeoTranslation( 0, 0,-zloc) );
7065
21ea473f 7066 trayStructure->AddNode(cuOutputCabs , 1, 0);
7067 trayStructure->AddNode(plastOutputCabs , 1, 0);
7068 trayStructure->AddNode(alOutputCabs , 1, 0);
7069 trayStructure->AddNode(kaptonOutputCabs, 1, 0);
1c5895a3 7070 trayStructure->AddNode(polyaxOutputCabs, 1, 0);
57126ea1 7071
7072 xloc = kXShiftBarCool + kBarCoolRmax + pcbBoardsCu->GetDX();
7073 yloc = outputCabsPOLYAX->GetY(5) + pcbBoardsCu->GetDY();
21ea473f 7074 trayStructure->AddNode(cuPCBBoards, 1,
57126ea1 7075 new TGeoTranslation( xloc, yloc , 0) );
7076
7077 yloc += pcbBoardsCu->GetDY() + pcbBoardsEpoxy->GetDY();
21ea473f 7078 trayStructure->AddNode(epoxyPCBBoards, 1,
57126ea1 7079 new TGeoTranslation( xloc, yloc , 0) );
7080
7081 yloc += pcbBoardsEpoxy->GetDY() + pcbBoardsPlast->GetDY();
21ea473f 7082 trayStructure->AddNode(plastPCBBoards, 1,
57126ea1 7083 new TGeoTranslation( xloc, yloc , 0) );
7084
7085 yloc += pcbBoardsPlast->GetDY() + pcbBoardsSteel->GetDY();
21ea473f 7086 trayStructure->AddNode(steelPCBBoards, 1,
57126ea1 7087 new TGeoTranslation( xloc, yloc , 0) );
7088
7089 yloc += pcbBoardsSteel->GetDY() + pcbBoardsPPS->GetDY();
1c5895a3 7090 trayStructure->AddNode(ppsPCBBoards, 1,
57126ea1 7091 new TGeoTranslation( xloc, yloc , 0) );
7092
aa177c73 7093
7094 // Finally put everything in the mother volume
7095 alphafold = kSideCFoldAngle;
7096
7097 for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
7098 alpharot = kTraySideCAlphaRot[jt];
7099 xloc = kTraySideCRPos*SinD(alpharot);
7100 yloc = kTraySideCRPos*CosD(alpharot);
57126ea1 7101 moth->AddNode(trayStructure,jt+1,
aa177c73 7102 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
7103 new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
7104 }
7105
7106
7107 return;
7108}
7109
7110
798b4e0c 7111//______________________________________________________________________
7112void AliITSv11GeometrySupport::SSDCableTraysSideA(TGeoVolume *moth,
43aefea7 7113 const TGeoManager *mgr){
798b4e0c 7114//
7115// Creates the SSD cable trays which are outside the ITS support cones
7116// but still inside the TPC on Side A
7117// (part of this code is taken or anyway inspired to ServicesCableSupport
7118// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
7119//
7120// Input:
7121// moth : the TGeoVolume owing the volume structure
7122// mgr : the GeoManager (default gGeoManager)
7123// Output:
7124//
7125// Created: ??? Bjorn S. Nilsen
7126// Updated: 30 Dec 2009 Mario Sitta
7127//
7128// Technical data are taken from AutoCAD drawings, L.Simonetti technical
7129// drawings and other (oral) information given by F.Tosello and
7130// Ton van den Brink
7131// Cables and cooling tubes are approximated with proper materials and
7132// rectangular cross sections, always preserving the total material budget.
7133//
7134
7135 // Dimensions and positions of the A-Side Cable Trays
7136 // (parts of 0872/G/D)
573a206f 7137 const Double_t kTrayARTrans = 408.35 *fgkmm;
798b4e0c 7138 const Double_t kTrayAZTrans = 1011.00 *fgkmm;
7139 const Double_t kForwardSideYTrans = 12.00 *fgkmm;//!!!TO BE CHECKED!!!
7140 const Double_t kCoversYTrans = 2.00 *fgkmm;
7141 const Double_t kTrayAZRot = (180-169.5);// Degrees
7142 const Double_t kTrayAFirstRotAng = 22.00; // Degrees
7143 const Double_t kTrayASecondRotAng = 15.00; // Degrees
7144
7145 const Double_t kTrayTotalHeight = 52.00 *fgkmm;
7146 const Double_t kTrayHeighToBend = 32.00 *fgkmm;
7147 const Double_t kTrayWidth = 130.00 *fgkmm;
7148 const Double_t kTrayThick = 2.00 *fgkmm;
7149
7150 const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
7151
7152 const Double_t kForwardTrayTotalLen = 853.00 *fgkmm;
7153 const Double_t kForwardTrayFirstLen = 350.00 *fgkmm;
7154 const Double_t kForwardTrayFirstHeight = 47.00 *fgkmm;
7155 const Double_t kForwardCoverLen = 420.00 *fgkmm;
7156
7157 const Double_t kForwardSideLength = kForwardTrayFirstLen;//!!!TO BE CHECKED!!!
7158 const Double_t kForwardSideHeight = 90.00 *fgkmm;//!!!TO BE CHECKED!!!
7159 const Double_t kForwardSideThick = 1.00 *fgkmm;//!!!TO BE CHECKED!!!
7160 const Double_t kForwardCoverHeight = 10.00 *fgkmm;//!!!TO BE CHECKED!!!
7161
7162 const Double_t kExternalTrayTotalLen = 1200.00 *fgkmm;
7163 const Double_t kExternalCoverLen = kExternalTrayTotalLen;
7164 const Double_t kExternalCoverThick = 5.00 *fgkmm;
7165
7166 const Int_t kForwardTrayNpoints = 16;
7167
7168 const Double_t kServicesWidth = 100.00 *fgkmm;
7169 const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
7170 const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
7171 const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
7172 const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
7173
7174
7175 // Local variables
7176 Double_t xprof[kForwardTrayNpoints], yprof[kForwardTrayNpoints];
7177 Double_t xloc, yloc, zloc, alpharot, totalhi;
7178
7179
7180 // The two tray components as assemblies
573a206f 7181 TGeoVolumeAssembly *cableTrayAForw =
7182 new TGeoVolumeAssembly("ITSsupportSSDTrayAForw");
798b4e0c 7183 TGeoVolumeAssembly *cableTrayAExt =
7184 new TGeoVolumeAssembly("ITSsupportSSDTrayAExt");
7185
7186
7187 // First create all needed shapes
7188
7189 // The first part of the forward tray (part of 0872/G/D/07): a Xtru
7190 TGeoXtru *forwTrayPart1 = new TGeoXtru(2);
7191
7192 xprof[3] = kTrayWidth/2;
7193 yprof[3] = kForwardTrayFirstHeight;
7194 xprof[2] = xprof[3] - kTrayThick;
7195 yprof[2] = yprof[3];
7196 xprof[4] = xprof[3];
7197 yprof[4] = kTrayTotalHeight - kTrayHeighToBend;
7198 xprof[5] = xprof[4] - yprof[4]*TMath::Tan(kTrayBendAngle);
7199 yprof[5] = 0;
7200
7201 InsidePoint( xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
7202 -kTrayThick, xprof[1], yprof[1]);
7203
7204 xprof[6] = -xprof[5];
7205 yprof[6] = yprof[5];
7206
7207 InsidePoint( xprof[4], yprof[4], xprof[5], yprof[5], xprof[6], yprof[6],
7208 -kTrayThick, xprof[0], yprof[0]);
7209
7210 // We did the right side, now reflex on the left side
7211 for (Int_t jp = 0; jp < 6; jp++) {
7212 xprof[6+jp] = -xprof[5-jp];
7213 yprof[6+jp] = yprof[5-jp];
7214 }
7215
7216 // And now the actual Xtru
7217 forwTrayPart1->DefinePolygon(12, xprof, yprof);
7218 forwTrayPart1->DefineSection(0, 0);
7219 forwTrayPart1->DefineSection(1, kForwardTrayFirstLen);
7220
7221 // The second part of the forward tray (part of 0872/G/D/07): a Xtru
7222 TGeoXtru *forwTrayPart2 =
7223 CreateSDDSSDTraysSideA(kForwardTrayTotalLen - kForwardTrayFirstLen,
7224 kTrayTotalHeight);
7225
7226 // The external tray (as 0872/G/D/03): a Xtru with same profile
7227 TGeoXtru *externalTray = CreateSDDSSDTraysSideA(kExternalTrayTotalLen,
7228 kTrayTotalHeight);
7229
7230 // The side wall of the forward tray: a BBox
7231 TGeoBBox *forwSide = new TGeoBBox(kForwardSideThick/2,
7232 kForwardSideHeight/2,
7233 kForwardSideLength/2);
7234
7235 // The side cover over the walls: a Xtru
7236 TGeoXtru *forwSideCover = new TGeoXtru(2);
7237 forwSideCover->SetName("ITSsuppSSDForwCover");
7238
7239 xprof[0] = kTrayWidth/2 + 2*kForwardSideThick;
7240 yprof[0] = kForwardCoverHeight;
7241 xprof[1] = xprof[0];
7242 yprof[1] = 0;
7243 xprof[2] = xprof[1] - kForwardSideThick;
7244 yprof[2] = yprof[1];
7245 xprof[3] = xprof[2];
7246 yprof[3] = yprof[0] - kForwardSideThick;
7247
7248 // We did the right side, now reflex on the left side
7249 for (Int_t jp = 0; jp < 4; jp++) {
7250 xprof[4+jp] = -xprof[3-jp];
7251 yprof[4+jp] = yprof[3-jp];
7252 }
7253
7254 forwSideCover->DefinePolygon(8, xprof, yprof);
7255 forwSideCover->DefineSection(0, 0);
7256 forwSideCover->DefineSection(1, kForwardSideLength);
7257
7258 // The forward and external covers: two Composite Shape's
7259 TGeoCompositeShape *forwardCover = CreateTrayAForwardCover(kForwardCoverLen);
7260
7261 TGeoCompositeShape *externCover = CreateTrayAExternalCover(kExternalCoverLen);
7262
7263 // The cable copper inside the forward tray: a BBox
7264 TGeoBBox *forwCopper = new TGeoBBox(kServicesWidth/2,
7265 kCopperHeight/2,
7266 kForwardTrayTotalLen/2);
7267
7268 // The cable copper inside the forward tray: a Xtru
7269 TGeoXtru *extCopper = new TGeoXtru(2);
7270 extCopper->SetName("ITSsuppSSDExtTrayCopper");
7271
7272 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
7273 - kTrayThick;
7274
7275 xprof[0] = -totalhi*TanD(kTrayAZRot);
7276 yprof[0] = kTrayThick;
7277 xprof[1] = kExternalTrayTotalLen;
7278 yprof[1] = yprof[0];
7279 xprof[2] = xprof[1];
7280 yprof[2] = yprof[1] + kCopperHeight;
7281 totalhi -= kCopperHeight;
7282 xprof[3] = -totalhi*TanD(kTrayAZRot);
7283 yprof[3] = yprof[2];
7284
7285 extCopper->DefinePolygon(4, xprof, yprof);
7286 extCopper->DefineSection(0, 0);
7287 extCopper->DefineSection(1, kServicesWidth);
7288
7289 // The cable plastic inside the forward tray: a BBox
7290 TGeoBBox *forwPlastic = new TGeoBBox(kServicesWidth/2,
7291 kCablePlasticHeight/2,
7292 kForwardTrayTotalLen/2);
7293
7294 // The cable plastic inside the forward tray: a Xtru
7295 TGeoXtru *extPlastic = new TGeoXtru(2);
7296 extPlastic->SetName("ITSsuppSSDExtTrayPlastic");
7297
7298 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
7299 - kTrayThick - kCopperHeight;
7300
7301 xprof[0] = -totalhi*TanD(kTrayAZRot);
7302 yprof[0] = kTrayThick;
7303 xprof[1] = kExternalTrayTotalLen;
7304 yprof[1] = yprof[0];
7305 xprof[2] = xprof[1];
7306 yprof[2] = yprof[1] + kCablePlasticHeight;
7307 totalhi -= kCablePlasticHeight;
7308 xprof[3] = -totalhi*TanD(kTrayAZRot);
7309 yprof[3] = yprof[2];
7310
7311 extPlastic->DefinePolygon(4, xprof, yprof);
7312 extPlastic->DefineSection(0, 0);
7313 extPlastic->DefineSection(1, kServicesWidth);
7314
7315 // The cooling water inside the forward tray: a BBox
7316 TGeoBBox *forwWater = new TGeoBBox(kServicesWidth/2,
7317 kCoolingWaterHeight/2,
7318 kForwardTrayTotalLen/2);
7319
7320 // The cooling water inside the forward tray: a Xtru
7321 TGeoXtru *extWater = new TGeoXtru(2);
7322 extWater->SetName("ITSsuppSSDExtTrayWater");
7323
7324 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
7325 - kTrayThick - kCopperHeight - kCablePlasticHeight;
7326
7327 xprof[0] = -totalhi*TanD(kTrayAZRot);
7328 yprof[0] = kTrayThick;
7329 xprof[1] = kExternalTrayTotalLen;
7330 yprof[1] = yprof[0];
7331 xprof[2] = xprof[1];
7332 yprof[2] = yprof[1] + kCoolingWaterHeight;
7333 totalhi -= kCoolingWaterHeight;
7334 xprof[3] = -totalhi*TanD(kTrayAZRot);
7335 yprof[3] = yprof[2];
7336
7337 extWater->DefinePolygon(4, xprof, yprof);
7338 extWater->DefineSection(0, 0);
7339 extWater->DefineSection(1, kServicesWidth);
7340
7341 // The polyurethane inside the forward tray: a BBox
7342 TGeoBBox *forwPUR = new TGeoBBox(kServicesWidth/2,
7343 kPoliUrethaneHeight/2,
7344 kForwardTrayTotalLen/2);
7345
7346 // The poliurethane inside the forward tray: a Xtru
7347 TGeoXtru *extPUR = new TGeoXtru(2);
7348 extPUR->SetName("ITSsuppSSDExtTrayPUR");
7349
7350 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans
7351 - kTrayThick - kCopperHeight - kCablePlasticHeight
7352 - kCoolingWaterHeight;
7353
7354 xprof[0] = -totalhi*TanD(kTrayAZRot);
7355 yprof[0] = kTrayThick;
7356 xprof[1] = kExternalTrayTotalLen;
7357 yprof[1] = yprof[0];
7358 xprof[2] = xprof[1];
7359 yprof[2] = yprof[1] + kPoliUrethaneHeight;
7360 totalhi -= kPoliUrethaneHeight;
7361 xprof[3] = -totalhi*TanD(kTrayAZRot);
7362 yprof[3] = yprof[2];
7363
7364 extPUR->DefinePolygon(4, xprof, yprof);
7365 extPUR->DefineSection(0, 0);
7366 extPUR->DefineSection(1, kServicesWidth);
7367
7368
7369 // We have all shapes: now create the real volumes
0801d201 7370 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
798b4e0c 7371 TGeoMedium *medAntic = mgr->GetMedium("ITS_ANTICORODAL$");
0801d201 7372 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
798b4e0c 7373 TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
0801d201 7374 TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
7375 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
798b4e0c 7376
7377 TGeoVolume *forwTrayFirst = new TGeoVolume("ITSsuppSSDSideAForwTrayFirst",
7378 forwTrayPart1, medAl);
7379
7380 forwTrayFirst->SetVisibility(kTRUE);
7381 forwTrayFirst->SetLineColor(6); // Purple
7382 forwTrayFirst->SetLineWidth(1);
7383 forwTrayFirst->SetFillColor(forwTrayFirst->GetLineColor());
7384 forwTrayFirst->SetFillStyle(4000); // 0% transparent
7385
7386 TGeoVolume *forwTraySecond = new TGeoVolume("ITSsuppSSDSideAForwTraySecond",
7387 forwTrayPart2, medAl);
7388
7389 forwTraySecond->SetVisibility(kTRUE);
7390 forwTraySecond->SetLineColor(6); // Purple
7391 forwTraySecond->SetLineWidth(1);
7392 forwTraySecond->SetFillColor(forwTraySecond->GetLineColor());
7393 forwTraySecond->SetFillStyle(4000); // 0% transparent
7394
7395 TGeoVolume *forwTraySide = new TGeoVolume("ITSsuppSSDSideAForwTraySide",
7396 forwSide, medAl);
7397
7398 forwTraySide->SetVisibility(kTRUE);
7399 forwTraySide->SetLineColor(6); // Purple
7400 forwTraySide->SetLineWidth(1);
7401 forwTraySide->SetFillColor(forwTraySide->GetLineColor());
7402 forwTraySide->SetFillStyle(4000); // 0% transparent
7403
7404 TGeoVolume *forwTraySideCover = new TGeoVolume("ITSsuppSSDSideAForwTraySideCover",
7405 forwSideCover, medAl);
7406
7407 forwTraySideCover->SetVisibility(kTRUE);
7408 forwTraySideCover->SetLineColor(6); // Purple
7409 forwTraySideCover->SetLineWidth(1);
7410 forwTraySideCover->SetFillColor(forwTraySideCover->GetLineColor());
7411 forwTraySideCover->SetFillStyle(4000); // 0% transparent
7412
7413 TGeoVolume *externalTraySSD = new TGeoVolume("ITSsuppSSDSideAExternalTray",
7414 externalTray, medAl);
7415
7416 externalTraySSD->SetVisibility(kTRUE);
7417 externalTraySSD->SetLineColor(6); // Purple
7418 externalTraySSD->SetLineWidth(1);
7419 externalTraySSD->SetFillColor(externalTraySSD->GetLineColor());
7420 externalTraySSD->SetFillStyle(4000); // 0% transparent
7421
7422 TGeoVolume *forwardTrayCover = new TGeoVolume("ITSsuppSSDSideAForwTrayCover",
7423 forwardCover, medAntic);
7424
7425 forwardTrayCover->SetVisibility(kTRUE);
7426 forwardTrayCover->SetLineColor(kMagenta+1); // Purple
7427 forwardTrayCover->SetLineWidth(1);
7428 forwardTrayCover->SetFillColor(forwardTrayCover->GetLineColor());
7429 forwardTrayCover->SetFillStyle(4000); // 0% transparent
7430
7431 TGeoVolume *externTrayCover = new TGeoVolume("ITSsuppSSDSideAExtTrayCover",
7432 externCover, medAntic);
7433
7434 externTrayCover->SetVisibility(kTRUE);
7435 externTrayCover->SetLineColor(kMagenta+1); // Purple
7436 externTrayCover->SetLineWidth(1);
7437 externTrayCover->SetFillColor(externTrayCover->GetLineColor());
7438 externTrayCover->SetFillStyle(4000); // 0% transparent
7439
7440 TGeoVolume *forwCableCu = new TGeoVolume("ITSsuppSSDSideAForwCableCu",
7441 forwCopper, medCu);
7442
7443 forwCableCu->SetVisibility(kTRUE);
7444 forwCableCu->SetLineColor(kRed); // Red
7445 forwCableCu->SetLineWidth(1);
7446 forwCableCu->SetFillColor(forwCableCu->GetLineColor());
7447 forwCableCu->SetFillStyle(4000); // 0% transparent
7448
7449 TGeoVolume *extCableCu = new TGeoVolume("ITSsuppSSDSideAExtCableCu",
7450 extCopper, medCu);
7451
7452 extCableCu->SetVisibility(kTRUE);
7453 extCableCu->SetLineColor(kRed); // Red
7454 extCableCu->SetLineWidth(1);
7455 extCableCu->SetFillColor(extCableCu->GetLineColor());
7456 extCableCu->SetFillStyle(4000); // 0% transparent
7457
7458 TGeoVolume *forwCableFEP = new TGeoVolume("ITSsuppSSDSideAForwCableFEP",
7459 forwPlastic, medFEP);
7460
7461 forwCableFEP->SetVisibility(kTRUE);
7462 forwCableFEP->SetLineColor(kYellow); // Yellow
7463 forwCableFEP->SetLineWidth(1);
7464 forwCableFEP->SetFillColor(forwCableFEP->GetLineColor());
7465 forwCableFEP->SetFillStyle(4000); // 0% transparent
7466
7467 TGeoVolume *extCableFEP = new TGeoVolume("ITSsuppSSDSideAExtCableFEP",
7468 extPlastic, medFEP);
7469
7470 extCableFEP->SetVisibility(kTRUE);
7471 extCableFEP->SetLineColor(kYellow); // Yellow
7472 extCableFEP->SetLineWidth(1);
7473 extCableFEP->SetFillColor(extCableFEP->GetLineColor());
7474 extCableFEP->SetFillStyle(4000); // 0% transparent
7475
7476 TGeoVolume *forwTrayWater = new TGeoVolume("ITSsuppSSDSideAForwTrayWater",
7477 forwWater, medH2O);
7478
7479 forwTrayWater->SetVisibility(kTRUE);
7480 forwTrayWater->SetLineColor(kBlue); // Blue
7481 forwTrayWater->SetLineWidth(1);
7482 forwTrayWater->SetFillColor(forwTrayWater->GetLineColor());
7483 forwTrayWater->SetFillStyle(4000); // 0% transparent
7484
7485 TGeoVolume *extTrayWater = new TGeoVolume("ITSsuppSSDSideAExtTrayWater",
7486 extWater, medH2O);
7487
7488 extTrayWater->SetVisibility(kTRUE);
7489 extTrayWater->SetLineColor(kBlue); // Blue
7490 extTrayWater->SetLineWidth(1);
7491 extTrayWater->SetFillColor(extTrayWater->GetLineColor());
7492 extTrayWater->SetFillStyle(4000); // 0% transparent
7493
7494 TGeoVolume *forwPolyUr = new TGeoVolume("ITSsuppSSDSideAForwPolyUr",
7495 forwPUR, medPUR);
7496
7497 forwPolyUr->SetVisibility(kTRUE);
7498 forwPolyUr->SetLineColor(kGray); // Gray
7499 forwPolyUr->SetLineWidth(1);
7500 forwPolyUr->SetFillColor(forwPolyUr->GetLineColor());
7501 forwPolyUr->SetFillStyle(4000); // 0% transparent
7502
7503 TGeoVolume *extPolyUr = new TGeoVolume("ITSsuppSSDSideAExtPolyUr",
7504 extPUR, medPUR);
7505
7506 extPolyUr->SetVisibility(kTRUE);
7507 extPolyUr->SetLineColor(kGray); // Gray
7508 extPolyUr->SetLineWidth(1);
7509 extPolyUr->SetFillColor(extPolyUr->GetLineColor());
7510 extPolyUr->SetFillStyle(4000); // 0% transparent
7511
7512
7513 // Now build up the tray
573a206f 7514 cableTrayAForw->AddNode(forwTrayFirst, 1, 0);
798b4e0c 7515
573a206f 7516 cableTrayAForw->AddNode(forwTraySecond, 1,
798b4e0c 7517 new TGeoTranslation(0, 0, kForwardTrayFirstLen) );
7518
7519 xloc = kTrayWidth/2 + kForwardSideThick/2;
7520 yloc = kForwardTrayFirstHeight + kForwardSideHeight/2 - kForwardSideYTrans;
7521 zloc = kForwardSideLength/2;
573a206f 7522 cableTrayAForw->AddNode(forwTraySide,1,
798b4e0c 7523 new TGeoTranslation( xloc, yloc, zloc) );
573a206f 7524 cableTrayAForw->AddNode(forwTraySide,2,
798b4e0c 7525 new TGeoTranslation(-xloc, yloc, zloc) );
7526
7527 yloc = kForwardTrayFirstHeight + kForwardSideHeight - kForwardSideYTrans
7528 - kForwardCoverHeight;
573a206f 7529 cableTrayAForw->AddNode(forwTraySideCover,1,
798b4e0c 7530 new TGeoTranslation(0, yloc, 0) );
7531
7532 yloc = kTrayTotalHeight - kCoversYTrans;
7533 zloc = kForwardTrayTotalLen - kForwardCoverLen;
573a206f 7534 cableTrayAForw->AddNode(forwardTrayCover,1,
798b4e0c 7535 new TGeoTranslation(0, yloc, zloc) );
7536
7537 yloc = kTrayThick + forwCopper->GetDY();
7538 zloc = forwCopper->GetDZ();
573a206f 7539 cableTrayAForw->AddNode(forwCableCu, 1,
798b4e0c 7540 new TGeoTranslation(0, yloc, zloc) );
7541
7542 yloc = kTrayThick + kCopperHeight + forwPlastic->GetDY();
7543 zloc = forwPlastic->GetDZ();
573a206f 7544 cableTrayAForw->AddNode(forwCableFEP, 1,
798b4e0c 7545 new TGeoTranslation(0, yloc, zloc) );
7546
7547 yloc = kTrayThick + kCopperHeight + kCablePlasticHeight + forwWater->GetDY();
7548 zloc = forwWater->GetDZ();
573a206f 7549 cableTrayAForw->AddNode(forwTrayWater, 1,
798b4e0c 7550 new TGeoTranslation(0, yloc, zloc) );
7551
7552 yloc = kTrayThick + kCopperHeight + kCablePlasticHeight
7553 + kCoolingWaterHeight + forwPUR->GetDY();
7554 zloc = forwPUR->GetDZ();
573a206f 7555 cableTrayAForw->AddNode(forwPolyUr, 1,
798b4e0c 7556 new TGeoTranslation(0, yloc, zloc) );
7557
7558 // To simplify following placement in MARS, origin is on top
7559 totalhi = kTrayTotalHeight + kExternalCoverThick - kCoversYTrans;
7560
7561 yloc = -totalhi;
7562 cableTrayAExt->AddNode(externalTraySSD, 1,
7563 new TGeoTranslation(0, yloc, 0) );
7564
7565 yloc = -totalhi + kTrayTotalHeight - kCoversYTrans;
7566 cableTrayAExt->AddNode(externTrayCover,1,
7567 new TGeoTranslation(0, yloc, 0) );
7568
7569 xloc = extCopper->GetDZ();
7570 yloc = -totalhi;
7571 cableTrayAExt->AddNode(extCableCu,1,
7572 new TGeoCombiTrans( xloc, yloc, 0,
7573 new TGeoRotation("",-90, 90, 90) ) );
7574
7575 xloc = extPlastic->GetDZ();
7576 yloc = -totalhi + kCopperHeight;
7577 cableTrayAExt->AddNode(extCableFEP,1,
7578 new TGeoCombiTrans( xloc, yloc, 0,
7579 new TGeoRotation("",-90, 90, 90) ) );
7580
7581 xloc = extWater->GetDZ();
7582 yloc = -totalhi + kCopperHeight + kCablePlasticHeight;
7583 cableTrayAExt->AddNode(extTrayWater,1,
7584 new TGeoCombiTrans( xloc, yloc, 0,
7585 new TGeoRotation("",-90, 90, 90) ) );
7586
7587 xloc = extPUR->GetDZ();
7588 yloc = -totalhi + kCopperHeight + kCablePlasticHeight + kCoolingWaterHeight;
7589 cableTrayAExt->AddNode(extPolyUr,1,
7590 new TGeoCombiTrans( xloc, yloc, 0,
7591 new TGeoRotation("",-90, 90, 90) ) );
7592
7593
7594 // Finally put everything in the mother volume
7595 zloc = kTrayAZTrans;
7596 Double_t zlocext = zloc + kForwardTrayTotalLen;
7597 Double_t rExtTray = kTrayARTrans + kTrayTotalHeight;
7598
7599 alpharot = kTrayAFirstRotAng;
7600 xloc = kTrayARTrans*SinD(alpharot);
7601 yloc = kTrayARTrans*CosD(alpharot);
573a206f 7602 moth->AddNode(cableTrayAForw,1,
798b4e0c 7603 new TGeoCombiTrans( xloc, yloc, zloc,
7604 new TGeoRotation("",-alpharot,0,0) ) );
7605 xloc = rExtTray*SinD(alpharot);
7606 yloc = rExtTray*CosD(alpharot);
7607 moth->AddNode(cableTrayAExt,1,
7608 new TGeoCombiTrans( xloc, yloc, zlocext,
7609 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
7610
7611 alpharot += 180;
7612 xloc = kTrayARTrans*SinD(alpharot);
7613 yloc = kTrayARTrans*CosD(alpharot);
573a206f 7614 moth->AddNode(cableTrayAForw,2,
798b4e0c 7615 new TGeoCombiTrans( xloc, yloc, zloc,
7616 new TGeoRotation("",-alpharot,0,0) ) );
7617 xloc = rExtTray*SinD(alpharot);
7618 yloc = rExtTray*CosD(alpharot);
7619 moth->AddNode(cableTrayAExt,2,
7620 new TGeoCombiTrans( xloc, yloc, zlocext,
7621 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
7622
7623 alpharot = -kTrayAFirstRotAng - 2*kTrayASecondRotAng;
7624 xloc = kTrayARTrans*SinD(alpharot);
7625 yloc = kTrayARTrans*CosD(alpharot);
573a206f 7626 moth->AddNode(cableTrayAForw,3,
798b4e0c 7627 new TGeoCombiTrans( xloc, yloc, zloc,
7628 new TGeoRotation("",-alpharot,0,0) ) );
7629 xloc = rExtTray*SinD(alpharot);
7630 yloc = rExtTray*CosD(alpharot);
7631 moth->AddNode(cableTrayAExt,3,
7632 new TGeoCombiTrans( xloc, yloc, zlocext,
7633 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
7634
7635 alpharot += 180;
7636 xloc = kTrayARTrans*SinD(alpharot);
7637 yloc = kTrayARTrans*CosD(alpharot);
573a206f 7638 moth->AddNode(cableTrayAForw,4,
798b4e0c 7639 new TGeoCombiTrans( xloc, yloc, zloc,
7640 new TGeoRotation("",-alpharot,0,0) ) );
7641 xloc = rExtTray*SinD(alpharot);
7642 yloc = rExtTray*CosD(alpharot);
7643 moth->AddNode(cableTrayAExt,4,
7644 new TGeoCombiTrans( xloc, yloc, zlocext,
7645 new TGeoRotation("",-alpharot,-kTrayAZRot,0) ) );
7646
7647
7648 return;
7649}
7650
aa177c73 7651//______________________________________________________________________
7652void AliITSv11GeometrySupport::SSDCableTraysSideC(TGeoVolume *moth,
43aefea7 7653 const TGeoManager *mgr){
aa177c73 7654//
7655// Creates the SSD cable trays which are outside the ITS support cones
7656// but still inside the TPC on Side C
7657// (part of this code is taken or anyway inspired to ServicesCableSupport
7658// method of AliITSv11GeometrySupport.cxx,v 1.9 2007/06/06)
7659//
7660// Input:
7661// moth : the TGeoVolume owing the volume structure
7662// mgr : the GeoManager (default gGeoManager)
7663// Output:
7664//
7665// Created: ??? Bjorn S. Nilsen
7666// Updated: 15 Apr 2010 Mario Sitta
7667//
7668// Technical data are taken from AutoCAD drawings and other (oral)
7669// information given by F.Tosello
7670//
7671
7672 // Dimensions and positions of the C-Side Cable Tray elements
7673 const Int_t kNumTraySideC = 4;
7674
7675 const Double_t kSideCFoldAngle = 5.00 *fgkDegree;
7676
7677 const Double_t kServicesWidth = 100.00 *fgkmm;
7678 const Double_t kCopperHeight = 11.20 *fgkmm;// 1120 mm^2
7679 const Double_t kCablePlasticHeight = 11.50 *fgkmm;// 1150 mm^2
7680 const Double_t kCoolingWaterHeight = 2.65 *fgkmm;// 265 mm^2
7681 const Double_t kPoliUrethaneHeight = 4.62 *fgkmm;// 462 mm^2
5d9d4033 7682 const Double_t kCablesYtrans = 2.50 *fgkmm;// Avoid ovlps
aa177c73 7683
7684 // Overall position and rotation of the C-Side Cable Trays
7685 const Double_t kTraySideCRPos = 45.30 *fgkcm;
7686 const Double_t kTraySideCZPos = -102.40 *fgkcm;
7687 const Double_t kTraySideCAlphaRot[kNumTraySideC] = { 23.0, -59.0,
7688 /* from Patch panel position */ 180.+23.0, 180.-59.0};
7689
7690
7691 // Local variables
7692 Double_t xprof[6], yprof[6];
7693 Double_t xloc, yloc, alpharot, alphafold;
7694
7695
7696 // The assembly holding the metallic structure
7697 TGeoVolumeAssembly *trayStructure =
7698 CreateSDDSSDTraysSideC("ITSsupportSSDTrayC");
7699
7700 // The cable copper inside the tray: a Xtru
7701 TGeoXtru *copper = new TGeoXtru(2);
7702 copper->SetName("ITSsuppSSDTrayCCopper");
7703
7704 // Copper lies on the lower plate: get position of its points
7705 TGeoXtru *lowerplate = (TGeoXtru*)(mgr->GetVolume("ITSsuppTraySideCLower")->GetShape());
7706 xprof[0] = lowerplate->GetX(5);
5d9d4033 7707 yprof[0] = lowerplate->GetY(5) + kCablesYtrans;
aa177c73 7708 xprof[1] = lowerplate->GetX(4);
5d9d4033 7709 yprof[1] = lowerplate->GetY(4) + kCablesYtrans;
aa177c73 7710 xprof[2] = lowerplate->GetX(3);
5d9d4033 7711 yprof[2] = lowerplate->GetY(3) + kCablesYtrans;
aa177c73 7712 xprof[3] = xprof[2] - kCopperHeight*SinD(kSideCFoldAngle);
7713 yprof[3] = yprof[2] + kCopperHeight*CosD(kSideCFoldAngle);
7714 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7715 kCopperHeight , xprof[4], yprof[4]);
7716 xprof[5] = xprof[0];
7717 yprof[5] = yprof[0] + kCopperHeight;
7718
7719 copper->DefinePolygon(6, xprof, yprof);
7720 copper->DefineSection(0, -kServicesWidth/2);
7721 copper->DefineSection(1, kServicesWidth/2);
7722
7723 // The cable plastic inside the tray: a Xtru
7724 TGeoXtru *plastic = new TGeoXtru(2);
7725 plastic->SetName("ITSsuppSSDTrayCPlastic");
7726
7727 xprof[0] = copper->GetX(5);
7728 yprof[0] = copper->GetY(5);
7729 xprof[1] = copper->GetX(4);
7730 yprof[1] = copper->GetY(4);
7731 xprof[2] = copper->GetX(3);
7732 yprof[2] = copper->GetY(3);
7733 xprof[3] = xprof[2] - kCablePlasticHeight*SinD(kSideCFoldAngle);
7734 yprof[3] = yprof[2] + kCablePlasticHeight*CosD(kSideCFoldAngle);
7735 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7736 kCablePlasticHeight , xprof[4], yprof[4]);
7737 xprof[5] = xprof[0];
7738 yprof[5] = yprof[0] + kCablePlasticHeight;
7739
7740 plastic->DefinePolygon(6, xprof, yprof);
7741 plastic->DefineSection(0, -kServicesWidth/2);
7742 plastic->DefineSection(1, kServicesWidth/2);
7743
7744 // The cooling water inside the tray: a Xtru
7745 TGeoXtru *water = new TGeoXtru(2);
7746 water->SetName("ITSsuppSSDTrayCWater");
7747
7748 xprof[0] = plastic->GetX(5);
7749 yprof[0] = plastic->GetY(5);
7750 xprof[1] = plastic->GetX(4);
7751 yprof[1] = plastic->GetY(4);
7752 xprof[2] = plastic->GetX(3);
7753 yprof[2] = plastic->GetY(3);
7754 xprof[3] = xprof[2] - kCoolingWaterHeight*SinD(kSideCFoldAngle);
7755 yprof[3] = yprof[2] + kCoolingWaterHeight*CosD(kSideCFoldAngle);
7756 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7757 kCoolingWaterHeight , xprof[4], yprof[4]);
7758 xprof[5] = xprof[0];
7759 yprof[5] = yprof[0] + kCoolingWaterHeight;
7760
7761 water->DefinePolygon(6, xprof, yprof);
7762 water->DefineSection(0, -kServicesWidth/2);
7763 water->DefineSection(1, kServicesWidth/2);
7764
7765 // The poliurethane inside the tray: a Xtru
1c5895a3 7766 TGeoXtru *pur = new TGeoXtru(2);
7767 pur->SetName("ITSsuppSSDTrayCPUR");
aa177c73 7768 xprof[0] = water->GetX(5);
7769 yprof[0] = water->GetY(5);
7770 xprof[1] = water->GetX(4);
7771 yprof[1] = water->GetY(4);
7772 xprof[2] = water->GetX(3);
7773 yprof[2] = water->GetY(3);
7774 xprof[3] = xprof[2] - kPoliUrethaneHeight*SinD(kSideCFoldAngle);
7775 yprof[3] = yprof[2] + kPoliUrethaneHeight*CosD(kSideCFoldAngle);
7776 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
7777 kPoliUrethaneHeight , xprof[4], yprof[4]);
7778 xprof[5] = xprof[0];
7779 yprof[5] = yprof[0] + kPoliUrethaneHeight;
7780
1c5895a3 7781 pur->DefinePolygon(6, xprof, yprof);
7782 pur->DefineSection(0, -kServicesWidth/2);
7783 pur->DefineSection(1, kServicesWidth/2);
aa177c73 7784
7785
7786 // We have all shapes: now create the real volumes
0801d201 7787 TGeoMedium *medCu = mgr->GetMedium("ITS_COPPER$");
aa177c73 7788 TGeoMedium *medFEP = mgr->GetMedium("ITS_SSD FEP$");
0801d201 7789 TGeoMedium *medH2O = mgr->GetMedium("ITS_WATER$");
7790 TGeoMedium *medPUR = mgr->GetMedium("ITS_POLYURETHANE$");
aa177c73 7791
7792 TGeoVolume *copperCable = new TGeoVolume("ITSsuppSSDSideCCableCu",
7793 copper, medCu);
7794
7795 copperCable->SetVisibility(kTRUE);
7796 copperCable->SetLineColor(kRed); // Red
7797 copperCable->SetLineWidth(1);
7798 copperCable->SetFillColor(copperCable->GetLineColor());
7799 copperCable->SetFillStyle(4000); // 0% transparent
7800
7801 TGeoVolume *cableFEP = new TGeoVolume("ITSsuppSSDSideCCableFEP",
7802 plastic, medFEP);
7803
7804 cableFEP->SetVisibility(kTRUE);
7805 cableFEP->SetLineColor(kYellow); // Yellow
7806 cableFEP->SetLineWidth(1);
7807 cableFEP->SetFillColor(cableFEP->GetLineColor());
7808 cableFEP->SetFillStyle(4000); // 0% transparent
7809
7810 TGeoVolume *trayWater = new TGeoVolume("ITSsuppSSDSideCTrayWater",
7811 water, medH2O);
7812
7813 trayWater->SetVisibility(kTRUE);
7814 trayWater->SetLineColor(kBlue); // Blue
7815 trayWater->SetLineWidth(1);
7816 trayWater->SetFillColor(trayWater->GetLineColor());
7817 trayWater->SetFillStyle(4000); // 0% transparent
7818
7819 TGeoVolume *trayPolyUr = new TGeoVolume("ITSsuppSSDSideCPolyUr",
1c5895a3 7820 pur, medPUR);
aa177c73 7821
7822 trayPolyUr->SetVisibility(kTRUE);
7823 trayPolyUr->SetLineColor(kGray); // Gray
7824 trayPolyUr->SetLineWidth(1);
7825 trayPolyUr->SetFillColor(trayPolyUr->GetLineColor());
7826 trayPolyUr->SetFillStyle(4000); // 0% transparent
7827
7828
7829 // Now fill in the tray
7830 trayStructure->AddNode(copperCable,1,0);
7831 trayStructure->AddNode(cableFEP,1,0);
7832 trayStructure->AddNode(trayWater,1,0);
7833 trayStructure->AddNode(trayPolyUr,1,0);
7834
7835
7836 // Finally put everything in the mother volume
7837 alphafold = kSideCFoldAngle;
7838
7839 for (Int_t jt = 0; jt < kNumTraySideC; jt++) {
7840 alpharot = kTraySideCAlphaRot[jt];
7841 xloc = kTraySideCRPos*SinD(alpharot);
7842 yloc = kTraySideCRPos*CosD(alpharot);
7843 moth->AddNode(trayStructure,jt+1,
7844 new TGeoCombiTrans(-xloc, yloc, kTraySideCZPos,
7845 new TGeoRotation("",-90.+alpharot,-90.,90.+alphafold)));
7846 }
7847
7848
7849 return;
7850}
7851
798b4e0c 7852//______________________________________________________________________
57126ea1 7853void AliITSv11GeometrySupport::CreateSDDForwardTraySideA(TGeoVolumeAssembly *tray,
43aefea7 7854 const TGeoManager *mgr){
798b4e0c 7855//
7856// Creates the forward SDD tray on Side A (0872/G/D/01)
7857//
7858// Input:
57126ea1 7859// tray : the TGeoVolumeAssembly to put the elements in
798b4e0c 7860// mgr : the GeoManager (used only to get the proper material)
7861//
7862// Output:
7863//
57126ea1 7864// Return:
798b4e0c 7865//
7866// Created: 08 Jan 2010 Mario Sitta
57126ea1 7867// Updated: 07 Sep 2010 Mario Sitta
798b4e0c 7868//
7869// Technical data are taken from AutoCAD drawings, L.Simonetti technical
7870// drawings and other (oral) information given by F.Tosello
7871//
7872
7873 // Dimensions of the A-Side Forward Cable Tray (0872/G/D/01)
7874 const Double_t kForwardTrayThick = 2.00 *fgkmm;
7875 const Double_t kForwardTraySideLength = 823.00 *fgkmm;
7876 const Double_t kForwardTrayTailLength = 212.00 *fgkmm;
7877 const Double_t kForwardTrayBaseHalfWide = 55.00 *fgkmm;
7878 const Double_t kForwardTrayNotchLength = 47.20 *fgkmm;
7879 const Double_t kForwardTrayNotchHeight = 25.00 *fgkmm;
7880 const Double_t kForwardTrayNotchDown = 10.00 *fgkmm;
7881 const Double_t kForwardTraySide1Height = 39.00 *fgkmm;
7882 const Double_t kForwardTraySide2Height = 26.00 *fgkmm;
7883 const Double_t kForwardTraySide2Expand = 10.50 *fgkmm;
7884 const Double_t kForwardTraySide3TailLen = 418.00 *fgkmm;
7885 const Double_t kForwardTraySide3TailHi = 31.00 *fgkmm;
7886 const Double_t kForwardTraySide3HeadLen = 425.00 *fgkmm;
7887 const Double_t kForwardTraySide3HeadHi = 72.00 *fgkmm;
7888 const Double_t kForwardTrayHorWingWide = 10.50 *fgkmm;
7889 const Double_t kForwardTrayVertWingWide = 15.00 *fgkmm;
7890
7891 const Int_t kForwardTraySideNpoints = 9;
7892
7893
7894 // Local variables
7895 Double_t xprof[kForwardTraySideNpoints], yprof[kForwardTraySideNpoints];
7896 Double_t ylen, zlen;
7897 Double_t xloc, yloc, zloc;
7898
7899
7900 // The tray has a very complex shape, so it is made by assembling
57126ea1 7901 // different elements (with some small simplifications)
798b4e0c 7902
7903 // The tray base: a BBox
7904 zlen = (kForwardTraySideLength-kForwardTrayTailLength)/2;
7905 TGeoBBox *trayBase = new TGeoBBox(kForwardTrayBaseHalfWide,
7906 kForwardTrayThick/2, zlen);
7907
7908 // The first part of the side wall: a Xtru
7909 TGeoXtru *traySide1 = new TGeoXtru(2);
7910
7911 xprof[0] = 0;
7912 yprof[0] = kForwardTrayThick;
7913 xprof[1] = kForwardTraySideLength-kForwardTrayTailLength;
7914 yprof[1] = yprof[0];
7915 xprof[2] = kForwardTraySideLength;
7916 yprof[2] = kForwardTraySide1Height + kForwardTrayThick;
7917 xprof[3] = 0;
7918 yprof[3] = yprof[2];
7919
7920 traySide1->DefinePolygon(4, xprof, yprof);
7921 traySide1->DefineSection(0, 0);
7922 traySide1->DefineSection(1, kForwardTrayThick);
7923
7924 // The second part of the side wall: a Xtru
7925 TGeoXtru *traySide2 = new TGeoXtru(2);
7926
7927 xprof[0] = kForwardTrayBaseHalfWide - kForwardTrayThick;
7928 yprof[0] = traySide1->GetY(2);
7929 xprof[1] = kForwardTrayBaseHalfWide;
7930 yprof[1] = yprof[0];
7931 xprof[2] = xprof[1] + kForwardTraySide2Expand;
7932 yprof[2] = yprof[1] + kForwardTraySide2Height;
7933 xprof[3] = xprof[2] - kForwardTrayThick;
7934 yprof[3] = yprof[2];
7935
7936 traySide2->DefinePolygon(4, xprof, yprof);
7937 traySide2->DefineSection(0, 0);
7938 traySide2->DefineSection(1, kForwardTraySideLength);
7939
7940 // The third part of the side wall: a Xtru
7941 TGeoXtru *traySide3 = new TGeoXtru(2);
7942
7943 xprof[0] = 0;
7944 yprof[0] = traySide2->GetY(2);
7945 xprof[1] = kForwardTraySideLength;
7946 yprof[1] = yprof[0];
7947 xprof[2] = xprof[1];
7948 yprof[2] = yprof[1] + kForwardTraySide3TailHi - kForwardTrayThick;
7949 xprof[3] = xprof[2] - kForwardTraySide3TailLen - kForwardTrayThick;
7950 yprof[3] = yprof[2];
7951 xprof[4] = xprof[3];
7952 yprof[4] = yprof[3] + kForwardTraySide3HeadHi + kForwardTrayThick;
7953 xprof[5] = xprof[4] - kForwardTraySide3HeadLen;
7954 yprof[5] = yprof[4];
7955 xprof[6] = xprof[5];
7956 yprof[6] = yprof[5] - kForwardTrayNotchHeight;
7957 xprof[7] = xprof[6] + kForwardTrayNotchLength;
7958 yprof[7] = yprof[6];
7959 xprof[8] = xprof[7];
7960 yprof[8] = yprof[7] - kForwardTrayNotchDown;
7961
7962 traySide3->DefinePolygon(9, xprof, yprof);
7963 traySide3->DefineSection(0, 0);
7964 traySide3->DefineSection(1, kForwardTrayThick);
7965
7966 // The horizontal wing: a BBox
7967 TGeoBBox *trayHorWing = new TGeoBBox(kForwardTrayHorWingWide/2,
7968 kForwardTrayThick/2,
7969 kForwardTraySide3TailLen/2);
7970
7971 // The vertical wing: a BBox
7972 ylen = (traySide3->GetY(4) - traySide3->GetY(3))/2;
7973 TGeoBBox *trayVertWing = new TGeoBBox(kForwardTrayVertWingWide/2,
7974 ylen, kForwardTrayThick/2);
7975
7976
7977 // We have all shapes: now create the real volumes
0801d201 7978 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
798b4e0c 7979
7980 TGeoVolume *forwTrayBase = new TGeoVolume("ITSsuppSDDSideAForwTrayBase",
7981 trayBase, medAl);
7982
7983 forwTrayBase->SetVisibility(kTRUE);
7984 forwTrayBase->SetLineColor(6); // Purple
7985 forwTrayBase->SetLineWidth(1);
7986 forwTrayBase->SetFillColor(forwTrayBase->GetLineColor());
7987 forwTrayBase->SetFillStyle(4000); // 0% transparent
7988
7989 TGeoVolume *forwTraySide1 = new TGeoVolume("ITSsuppSDDSideAForwTraySide1",
7990 traySide1, medAl);
7991
7992 forwTraySide1->SetVisibility(kTRUE);
7993 forwTraySide1->SetLineColor(6); // Purple
7994 forwTraySide1->SetLineWidth(1);
7995 forwTraySide1->SetFillColor(forwTraySide1->GetLineColor());
7996 forwTraySide1->SetFillStyle(4000); // 0% transparent
7997
7998 TGeoVolume *forwTraySide2 = new TGeoVolume("ITSsuppSDDSideAForwTraySide2",
7999 traySide2, medAl);
8000
8001 forwTraySide2->SetVisibility(kTRUE);
8002 forwTraySide2->SetLineColor(6); // Purple
8003 forwTraySide2->SetLineWidth(1);
8004 forwTraySide2->SetFillColor(forwTraySide2->GetLineColor());
8005 forwTraySide2->SetFillStyle(4000); // 0% transparent
8006
8007 TGeoVolume *forwTraySide3 = new TGeoVolume("ITSsuppSDDSideAForwTraySide3",
8008 traySide3, medAl);
8009
8010 forwTraySide3->SetVisibility(kTRUE);
8011 forwTraySide3->SetLineColor(6); // Purple
8012 forwTraySide3->SetLineWidth(1);
8013 forwTraySide3->SetFillColor(forwTraySide3->GetLineColor());
8014 forwTraySide3->SetFillStyle(4000); // 0% transparent
8015
8016 TGeoVolume *forwTrayHWing = new TGeoVolume("ITSsuppSDDSideAForwTrayHorWing",
8017 trayHorWing, medAl);
8018
8019 forwTrayHWing->SetVisibility(kTRUE);
8020 forwTrayHWing->SetLineColor(6); // Purple
8021 forwTrayHWing->SetLineWidth(1);
8022 forwTrayHWing->SetFillColor(forwTrayHWing->GetLineColor());
8023 forwTrayHWing->SetFillStyle(4000); // 0% transparent
8024
8025 TGeoVolume *forwTrayVWing = new TGeoVolume("ITSsuppSDDSideAForwTrayVertWing",
8026 trayVertWing, medAl);
8027
8028 forwTrayVWing->SetVisibility(kTRUE);
8029 forwTrayVWing->SetLineColor(6); // Purple
8030 forwTrayVWing->SetLineWidth(1);
8031 forwTrayVWing->SetFillColor(forwTrayVWing->GetLineColor());
8032 forwTrayVWing->SetFillStyle(4000); // 0% transparent
8033
8034
8035 // Now build up the tray
8036 yloc = kForwardTrayThick/2;
8037 zloc = zlen;
57126ea1 8038 tray->AddNode(forwTrayBase, 1,
8039 new TGeoTranslation(0, yloc, zloc) );
798b4e0c 8040
8041 xloc = kForwardTrayBaseHalfWide;
57126ea1 8042 tray->AddNode(forwTraySide1, 1,
8043 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 8044 new TGeoRotation("",90,-90,-90)));
8045 xloc = -xloc + kForwardTrayThick;
57126ea1 8046 tray->AddNode(forwTraySide1, 2,
8047 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 8048 new TGeoRotation("",90,-90,-90)));
8049
57126ea1 8050 tray->AddNode(forwTraySide2, 1, 0);
798b4e0c 8051 zloc = kForwardTraySideLength;
57126ea1 8052 tray->AddNode(forwTraySide2, 2,
8053 new TGeoCombiTrans(0, 0, zloc,
798b4e0c 8054 new TGeoRotation("",90,-180,-90)));
8055
8056 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand;
57126ea1 8057 tray->AddNode(forwTraySide3, 1,
8058 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 8059 new TGeoRotation("",90,-90,-90)));
8060 xloc = -xloc + kForwardTrayThick;
57126ea1 8061 tray->AddNode(forwTraySide3, 2,
8062 new TGeoCombiTrans(xloc, 0, 0,
798b4e0c 8063 new TGeoRotation("",90,-90,-90)));
8064
8065 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
8066 - kForwardTrayHorWingWide/2;
8067 yloc = traySide3->GetY(2) + kForwardTrayThick/2;
8068 zloc = kForwardTraySideLength - trayHorWing->GetDZ();
57126ea1 8069 tray->AddNode(forwTrayHWing, 1,
8070 new TGeoTranslation( xloc, yloc, zloc) );
8071 tray->AddNode(forwTrayHWing, 2,
8072 new TGeoTranslation(-xloc, yloc, zloc) );
798b4e0c 8073
8074 xloc = kForwardTrayBaseHalfWide + kForwardTraySide2Expand
8075 - kForwardTrayVertWingWide/2;
8076 yloc = traySide3->GetY(2) + trayVertWing->GetDY();
8077 zloc = traySide3->GetX(3) + kForwardTrayThick/2;
57126ea1 8078 tray->AddNode(forwTrayVWing, 1,
8079 new TGeoTranslation( xloc, yloc, zloc) );
8080 tray->AddNode(forwTrayVWing, 2,
8081 new TGeoTranslation(-xloc, yloc, zloc) );
798b4e0c 8082
8083
57126ea1 8084 return;
798b4e0c 8085}
8086
8087//______________________________________________________________________
8088TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAForwardCover(const Double_t coverLen){
8089//
8090// Creates the forward cover of the SDD and SSD cable trays on Side A
8091// (0872/G/D/02)
8092//
8093// Input:
8094// coverLen: the total length of the cover
8095//
8096// Output:
8097//
8098// Return: a TGeoCompositeShape for the cover
8099//
8100// Created: 03 Jan 2010 Mario Sitta
8101//
8102// Technical data are taken from AutoCAD drawings, L.Simonetti technical
8103// drawings and other (oral) information given by F.Tosello
8104//
8105
8106 // Dimensions and positions of the A-Side Cable Tray Forward Cover
8107 // (0872/G/D/02)
8108 const Double_t kForwardCoverWide = 130.00 *fgkmm;
8109 const Double_t kForwardCoverSideWide = 10.00 *fgkmm;
8110 const Double_t kForwardCoverHoleLen = 160.00 *fgkmm;
8111 const Double_t kForwardCoverHoleWide = 90.00 *fgkmm;
8112 const Double_t kForwardCoverHoleR10 = 10.00 *fgkmm;
8113 const Double_t kForwardCoverTotalThick = 5.00 *fgkmm;
8114 const Double_t kForwardCoverSideThick = 3.00 *fgkmm;
8115 const Double_t kForwardCoverInternThick = 2.00 *fgkmm;
8116
8117 const Double_t kForwardCoverHoleZTrans = 40.00 *fgkmm;
8118
8119
8120 // Local variables
8121 Double_t xprof[16], yprof[16];
8122 Double_t yloc, zloc;
8123
8124
8125 // The main shape: a Xtru
8126 TGeoXtru *forwCoverMain = new TGeoXtru(2);
8127 forwCoverMain->SetName("ITSsuppForwCoverMain");
8128
8129 xprof[0] = kForwardCoverWide/2;
8130 yprof[0] = kForwardCoverTotalThick;
8131 xprof[1] = xprof[0];
8132 yprof[1] = yprof[0] - kForwardCoverSideThick;
8133 xprof[2] = xprof[1] - kForwardCoverSideWide;
8134 yprof[2] = yprof[1];
8135 xprof[3] = xprof[2];
8136 yprof[3] = 0;
8137
8138 // We did the right side, now reflex on the left side
8139 for (Int_t jp = 0; jp < 4; jp++) {
8140 xprof[4+jp] = -xprof[3-jp];
8141 yprof[4+jp] = yprof[3-jp];
8142 }
8143
8144 // And now the actual Xtru
8145 forwCoverMain->DefinePolygon(8, xprof, yprof);
8146 forwCoverMain->DefineSection(0, 0);
8147 forwCoverMain->DefineSection(1, coverLen);
8148
8149 // The hole: another Xtru (rounded corners approximated with segments)
8150 TGeoXtru *forwCoverHole = new TGeoXtru(2);
8151 forwCoverHole->SetName("ITSsuppForwCoverHole");
8152
8153 CreateTrayACoverHolesShape(kForwardCoverHoleWide, kForwardCoverHoleLen,
8154 kForwardCoverHoleR10 , xprof, yprof);
8155
8156 // And now the actual Xtru
8157 forwCoverHole->DefinePolygon(16, xprof, yprof);
8158 forwCoverHole->DefineSection(0, 0);
8159 forwCoverHole->DefineSection(1, kForwardCoverTotalThick-kForwardCoverInternThick);
8160
8161 // Now the proper rototranslation matrices for the two holes
8162 yloc = kForwardCoverTotalThick-kForwardCoverInternThick-0.01;//Precision fix
8163 zloc = kForwardCoverHoleZTrans;
8164 TGeoCombiTrans *mf1 = new TGeoCombiTrans(0, yloc, zloc,
8165 new TGeoRotation("", 0, 90, 0) );
8166 mf1->SetName("mf1");
8167 mf1->RegisterYourself();
8168
8169 zloc = coverLen - kForwardCoverHoleZTrans - kForwardCoverHoleLen;
8170 TGeoCombiTrans *mf2 = new TGeoCombiTrans(0, yloc, zloc,
8171 new TGeoRotation("", 0, 90, 0) );
8172 mf2->SetName("mf2");
8173 mf2->RegisterYourself();
8174
8175 // Finally the actual cover shape
8176 TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppForwardCoverMain",
8177 "ITSsuppForwCoverMain-ITSsuppForwCoverHole:mf1-ITSsuppForwCoverHole:mf2");
8178
8179 return cover;
172b0d90 8180}
798b4e0c 8181
8182//______________________________________________________________________
8183TGeoCompositeShape* AliITSv11GeometrySupport::CreateTrayAExternalCover(const Double_t coverLen){
8184//
8185// Creates the external cover of the SDD and SSD cable trays on Side A
8186// (0872/G/D/04)
8187//
8188// Input:
8189// coverLen: the total length of the cover
8190//
8191// Output:
8192//
8193// Return: a TGeoCompositeShape for the cover
8194//
8195// Created: 03 Jan 2010 Mario Sitta
8196//
8197// Technical data are taken from AutoCAD drawings, L.Simonetti technical
8198// drawings and other (oral) information given by F.Tosello
8199//
8200
8201 // Dimensions and positions of the A-Side Cable Tray External Cover
8202 // (0872/G/D/04)
8203 const Double_t kExternalCoverWide = 130.00 *fgkmm;
8204 const Double_t kExternalCoverSideWide = 10.00 *fgkmm;
8205 const Double_t kExternalCoverHoleLen1 = 262.00 *fgkmm;
8206 const Double_t kExternalCoverHoleLen2 = 280.00 *fgkmm;
8207 const Double_t kExternalCoverHoleLen3 = 205.00 *fgkmm;
8208 const Double_t kExternalCoverHoleLen4 = 55.00 *fgkmm;
8209 const Double_t kExternalCoverHoleWide = 90.00 *fgkmm;
8210 const Double_t kExternalCoverHoleR10 = 10.00 *fgkmm;
8211 const Double_t kExternalCoverTotalThick = 5.00 *fgkmm;
8212 const Double_t kExternalCoverSideThick = 3.00 *fgkmm;
8213 const Double_t kExternalCoverInternThick = 2.00 *fgkmm;
8214
8215 const Double_t kExternalCoverHole1ZTrans = 28.00 *fgkmm;
8216 const Double_t kExternalCoverHolesZTrans = 20.00 *fgkmm;
8217
8218
8219 // Local variables
8220 Double_t xprof[16], yprof[16];
8221 Double_t yloc, zloc;
8222
8223
8224 // The main shape: a Xtru
8225 TGeoXtru *externCoverMain = new TGeoXtru(2);
8226 externCoverMain->SetName("ITSsuppExternCoverMain");
8227
8228 xprof[0] = kExternalCoverWide/2;
8229 yprof[0] = kExternalCoverTotalThick;
8230 xprof[1] = xprof[0];
8231 yprof[1] = yprof[0] - kExternalCoverSideThick;
8232 xprof[2] = xprof[1] - kExternalCoverSideWide;
8233 yprof[2] = yprof[1];
8234 xprof[3] = xprof[2];
8235 yprof[3] = 0;
8236
8237 // We did the right side, now reflex on the left side
8238 for (Int_t jp = 0; jp < 4; jp++) {
8239 xprof[4+jp] = -xprof[3-jp];
8240 yprof[4+jp] = yprof[3-jp];
8241 }
8242
8243 // And now the actual Xtru
8244 externCoverMain->DefinePolygon(8, xprof, yprof);
8245 externCoverMain->DefineSection(0, 0);
8246 externCoverMain->DefineSection(1, coverLen);
8247
8248 // The first hole: a Xtru (rounded corners approximated with segments)
8249 Double_t holethick = kExternalCoverTotalThick-kExternalCoverInternThick;
8250
8251 TGeoXtru *extCoverHole1 = new TGeoXtru(2);
8252 extCoverHole1->SetName("ITSsuppExtCoverHole1");
8253
8254 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen1,
8255 kExternalCoverHoleR10 , xprof, yprof);
8256
8257 extCoverHole1->DefinePolygon(16, xprof, yprof);
8258 extCoverHole1->DefineSection(0, 0);
8259 extCoverHole1->DefineSection(1, holethick);
8260
8261 // The second (and third) hole: another Xtru
8262 TGeoXtru *extCoverHole2 = new TGeoXtru(2);
8263 extCoverHole2->SetName("ITSsuppExtCoverHole2");
8264
8265 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen2,
8266 kExternalCoverHoleR10 , xprof, yprof);
8267
8268 extCoverHole2->DefinePolygon(16, xprof, yprof);
8269 extCoverHole2->DefineSection(0, 0);
8270 extCoverHole2->DefineSection(1, holethick);
8271
8272 // The fourth hole: another Xtru
8273 TGeoXtru *extCoverHole3 = new TGeoXtru(2);
8274 extCoverHole3->SetName("ITSsuppExtCoverHole3");
8275
8276 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen3,
8277 kExternalCoverHoleR10 , xprof, yprof);
8278
8279 extCoverHole3->DefinePolygon(16, xprof, yprof);
8280 extCoverHole3->DefineSection(0, 0);
8281 extCoverHole3->DefineSection(1, holethick);
8282
8283 // The fifth and last hole: another Xtru
8284 TGeoXtru *extCoverHole4 = new TGeoXtru(2);
8285 extCoverHole4->SetName("ITSsuppExtCoverHole4");
8286
8287 CreateTrayACoverHolesShape(kExternalCoverHoleWide, kExternalCoverHoleLen4,
8288 kExternalCoverHoleR10 , xprof, yprof);
8289
8290 extCoverHole4->DefinePolygon(16, xprof, yprof);
8291 extCoverHole4->DefineSection(0, 0);
8292 extCoverHole4->DefineSection(1, holethick);
8293
8294 // Now the proper rototranslation matrices for the holes
8295 yloc = kExternalCoverTotalThick - kExternalCoverInternThick-0.01;
8296 zloc = kExternalCoverHole1ZTrans;
8297 TGeoCombiTrans *me1 = new TGeoCombiTrans(0, yloc, zloc,
8298 new TGeoRotation("", 0, 90, 0) );
8299 me1->SetName("me1");
8300 me1->RegisterYourself();
8301
8302 zloc += (kExternalCoverHoleLen1 + kExternalCoverHolesZTrans);
8303 TGeoCombiTrans *me2 = new TGeoCombiTrans(0, yloc, zloc,
8304 new TGeoRotation("", 0, 90, 0) );
8305 me2->SetName("me2");
8306 me2->RegisterYourself();
8307
8308 zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
8309 TGeoCombiTrans *me3 = new TGeoCombiTrans(0, yloc, zloc,
8310 new TGeoRotation("", 0, 90, 0) );
8311 me3->SetName("me3");
8312 me3->RegisterYourself();
8313
8314 zloc += (kExternalCoverHoleLen2 + kExternalCoverHolesZTrans);
8315 TGeoCombiTrans *me4 = new TGeoCombiTrans(0, yloc, zloc,
8316 new TGeoRotation("", 0, 90, 0) );
8317 me4->SetName("me4");
8318 me4->RegisterYourself();
8319
8320 zloc += (kExternalCoverHoleLen3 + kExternalCoverHolesZTrans);
8321 TGeoCombiTrans *me5 = new TGeoCombiTrans(0, yloc, zloc,
8322 new TGeoRotation("", 0, 90, 0) );
8323 me5->SetName("me5");
8324 me5->RegisterYourself();
8325
8326 // Finally the actual cover shape
8327 TGeoCompositeShape *cover = new TGeoCompositeShape("ITSsuppExternCoverMain",
8328 "ITSsuppExternCoverMain-ITSsuppExtCoverHole1:me1-ITSsuppExtCoverHole2:me2-ITSsuppExtCoverHole2:me3-ITSsuppExtCoverHole3:me4-ITSsuppExtCoverHole4:me5");
8329
8330 return cover;
8331}
8332
8333//______________________________________________________________________
8334void AliITSv11GeometrySupport::CreateTrayACoverHolesShape(const Double_t wide,
8335 const Double_t length, const Double_t r10,
8336 Double_t *x, Double_t *y){
8337//
8338// Creates the proper sequence of X and Y coordinates to determine
8339// the base XTru polygon for the holes in the SDD and SSD tray covers
8340// (here the rounded corners are approximated with segments)
8341//
8342// Input:
8343// wide : the hole wide
8344// length : the hole length
8345// r10 : the radius of the rounded corners
8346//
8347// Output:
8348// x, y : coordinate vectors [16]
8349//
8350// Created: 03 Jan 2010 Mario Sitta
8351//
8352// Caller must guarantee that x and y have the correct dimensions
8353// (but being this a private method it's easy to tell)
8354//
8355
8356 x[0] = wide/2 - r10;
8357 y[0] = length;
8358 x[1] = x[0] + r10*SinD(30);
8359 y[1] = y[0] - r10*(1 - CosD(30));
8360 x[2] = x[0] + r10*SinD(60);
8361 y[2] = y[0] - r10*(1 - CosD(60));
8362 x[3] = x[0] + r10;
8363 y[3] = y[0] - r10;
8364 x[4] = x[3];
8365 y[4] = r10;
8366 x[5] = x[4] - r10*(1 - CosD(30));
8367 y[5] = y[4] - r10*SinD(30);
8368 x[6] = x[4] - r10*(1 - CosD(60));
8369 y[6] = y[4] - r10*SinD(60);
8370 x[7] = x[4] - r10;
8371 y[7] = 0;
8372
8373 // We did the right side, now reflex on the left side
8374 for (Int_t jp = 0; jp < 8; jp++) {
8375 x[8+jp] = -x[7-jp];
8376 y[8+jp] = y[7-jp];
8377 }
8378
8379 return;
8380}
8381
8382//______________________________________________________________________
8383TGeoXtru* AliITSv11GeometrySupport::CreateSDDSSDTraysSideA(
8384 const Double_t trayLen,
8385 const Double_t trayHi){
8386//
8387// Creates parts of the SDD and SSD Trays on Side A which are identical
8388// (0872/G/D/03, part of 0872/G/D/07, 0872/G/C/11)
8389//
8390// Input:
8391// trayLen : the length of the tray part
8392// trayHi : the height of the tray part
8393//
8394// Output:
8395//
8396// Return: a TGeoXtru
8397//
8398// Created: 26 Feb 2010 Mario Sitta
8399//
8400// Technical data are taken from AutoCAD drawings, L.Simonetti technical
8401// drawings and other (oral) information given by F.Tosello
8402//
8403
8404 // Dimensions and positions of the A-Side Cable Trays
8405 // (parts of 0872/G/C)
8406 const Double_t kTrayWidth = 130.00 *fgkmm;
8407 const Double_t kTrayWingWidth = 10.00 *fgkmm;
8408 const Double_t kTrayHeightToBend = 20.00 *fgkmm;
8409 const Double_t kTrayThick = 2.00 *fgkmm;
8410
8411 const Double_t kTrayBendAngle = 22.00 *TMath::DegToRad();
8412
8413 const Int_t kTrayNpoints = 16;
8414
8415 // Local variables
8416 Double_t xprof[kTrayNpoints], yprof[kTrayNpoints];
8417
8418
8419 // The tray shape: a Xtru
8420 TGeoXtru *trayPart = new TGeoXtru(2);
8421
8422 xprof[2] = kTrayWidth/2 - kTrayThick;
8423 yprof[2] = trayHi - kTrayThick;
8424 xprof[3] = kTrayWidth/2 - kTrayWingWidth;
8425 yprof[3] = yprof[2];
8426 xprof[4] = xprof[3];
8427 yprof[4] = trayHi;
8428 xprof[5] = kTrayWidth/2;
8429 yprof[5] = yprof[4];
8430 xprof[6] = xprof[5];
8431 yprof[6] = kTrayHeightToBend;
8432 xprof[7] = xprof[6] - yprof[6]*TMath::Tan(kTrayBendAngle);
8433 yprof[7] = 0;
8434
8435 InsidePoint( xprof[5], yprof[5], xprof[6], yprof[6], xprof[7], yprof[7],
8436 -kTrayThick, xprof[1], yprof[1]);
8437
8438 xprof[8] = -xprof[7];
8439 yprof[8] = yprof[7];
8440
8441 InsidePoint( xprof[6], yprof[6], xprof[7], yprof[7], xprof[8], yprof[8],
8442 -kTrayThick, xprof[0], yprof[0]);
8443
8444 // We did the right side, now reflex on the left side
8445 for (Int_t jp = 0; jp < 8; jp++) {
8446 xprof[8+jp] = -xprof[7-jp];
8447 yprof[8+jp] = yprof[7-jp];
8448 }
8449
8450 // And now the actual Xtru
8451 trayPart->DefinePolygon(kTrayNpoints, xprof, yprof);
8452 trayPart->DefineSection(0, 0);
8453 trayPart->DefineSection(1, trayLen);
8454
8455
8456 return trayPart;
8457}
8458
aa177c73 8459//______________________________________________________________________
8460TGeoVolumeAssembly* AliITSv11GeometrySupport::CreateSDDSSDTraysSideC(
43aefea7 8461 const char *trayName,
8462 const TGeoManager *mgr){
aa177c73 8463
8464//
8465// Creates the SDD and SSD Trays on Side C which are supposedly identical
8466//
8467// Input:
8468// trayName : the assembly name
8469//
8470// Output:
8471//
8472// Return: a TGeoVolumeAssembly
8473//
8474// Created: 16 Apr 2010 Mario Sitta
8475//
8476// Technical data are taken from AutoCAD drawings and other (oral)
8477// information given by F.Tosello
8478//
8479
8480 const Double_t kSideCHalfThick = 0.100 *fgkcm;
8481 const Double_t kSideCFoldAngle = 5.000 *TMath::DegToRad();
8482
8483 const Double_t kSideCLength1 = 172.800 *fgkcm;
8484 const Double_t kSideCLength2 = 189.300 *fgkcm;
8485 const Double_t kSideCHalfWide = 6.350 *fgkcm;
8486 const Double_t kSideCHeight1 = 11.800 *fgkcm;
8487 const Double_t kSideCHeight2 = 4.300 *fgkcm;
8488 const Double_t kSideCSideLength1 = 10.800 *fgkcm;
8489 const Double_t kSideCSideLength2 = 63.800 *fgkcm;
8490 const Double_t kSideCSideHeight = 8.800 *fgkcm;
8491 const Int_t kNPointsLowerFace = 6;
8492 const Int_t kNPointsLateralFace = 9;
8493
8494 const Double_t kSideCWingAHalfLen = 5.000 *fgkcm;
8495 const Double_t kSideCWingBHalfLen = 30.500 *fgkcm;
8496 const Double_t kSideCWingCHalfLen = 2.000 *fgkcm;
8497 const Double_t kSideCWingDHalfLen = 48.500 *fgkcm;
8498 const Double_t kSideCWingEHalfLen = 83.000 *fgkcm;
8499 const Double_t kSideCWingsHalfWide = 0.450 *fgkcm;
8500
8501 const Int_t kNPointsCoverFace = 12;
8502
8503 const Double_t kPlateHalfLen = 6.000 *fgkcm;
8504 const Double_t kPlateThick = 0.600 *fgkcm;
8505 const Double_t kPlateHeight = 4.200 *fgkcm;
8506 const Int_t kNPointsPlate = 6;
8507
8508 const Double_t kBarCoolRmax = 0.4 *fgkcm;
8509 const Int_t kNumBarCool = 2;
8510 const Double_t kXShiftBarCool[kNumBarCool] = { 8.7, 13.0 };
8511 const Double_t kYShiftBarCool[kNumBarCool] = { 8.5, 5.0 };
8512
8513
8514 // Local variables
8515 Double_t xprof[12], yprof[12];
8516 Double_t xloc, yloc, zloc, delta, alpharot;
8517
8518 // The single C-Side Cable tray as an assembly
8519 TGeoVolumeAssembly *cableTrayC = new TGeoVolumeAssembly(trayName);
8520
8521 // First create all needed shapes
8522
8523 // The Cable Tray lower face: a Xtru
8524 TGeoXtru *sideCLowerFace = new TGeoXtru(2);
8525
8526 xprof[0] = 0.;
8527 yprof[0] = 0.;
8528 xprof[1] = kSideCLength1;
8529 yprof[1] = 0.;
8530 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
8531 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
8532 xprof[3] = xprof[2] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
8533 yprof[3] = yprof[2] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
8534 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
8535 2*kSideCHalfThick , xprof[4], yprof[4]);
8536 xprof[5] = 0.;
8537 yprof[5] = 2*kSideCHalfThick;
8538
8539 sideCLowerFace->DefinePolygon(kNPointsLowerFace, xprof, yprof);
8540 sideCLowerFace->DefineSection(0,-kSideCHalfWide);
8541 sideCLowerFace->DefineSection(1, kSideCHalfWide);
8542
8543 // The Cable Tray lateral face: a Xtru
8544 TGeoXtru *sideCLateralFace = new TGeoXtru(2);
8545
8546 xprof[0] = 0.;
8547 yprof[0] = 0.;
8548 xprof[1] = kSideCLength1;
8549 yprof[1] = 0.;
8550 xprof[2] = xprof[1] + kSideCLength2*TMath::Cos(kSideCFoldAngle);
8551 yprof[2] = yprof[1] + kSideCLength2*TMath::Sin(kSideCFoldAngle);
8552 xprof[3] = xprof[2] - kSideCHeight2*TMath::Sin(kSideCFoldAngle);
8553 yprof[3] = yprof[2] + kSideCHeight2*TMath::Cos(kSideCFoldAngle);
8554 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
8555 kSideCHeight2, xprof[4], yprof[4]);
8556 xprof[5] = kSideCSideLength1 + kSideCSideLength2;
8557 yprof[5] = kSideCHeight2;
8558 xprof[6] = xprof[5];
8559 yprof[6] = kSideCSideHeight;
8560 xprof[7] = kSideCSideLength1;
8561 yprof[7] = kSideCHeight1;
8562 xprof[8] = 0;
8563 yprof[8] = yprof[7];
8564
8565 sideCLateralFace->DefinePolygon(kNPointsLateralFace, xprof, yprof);
8566 sideCLateralFace->DefineSection(0,-kSideCHalfThick);
8567 sideCLateralFace->DefineSection(1, kSideCHalfThick);
8568
8569 // The lateral wings: four BBox's
8570 TGeoBBox *sideCLateralWingA = new TGeoBBox(kSideCWingAHalfLen,
8571 kSideCHalfThick,
8572 kSideCWingsHalfWide);
8573
8574 TGeoBBox *sideCLateralWingB = new TGeoBBox(kSideCWingBHalfLen,
8575 kSideCHalfThick,
8576 kSideCWingsHalfWide);
8577
8578 TGeoBBox *sideCLateralWingC = new TGeoBBox(kSideCHalfThick, // With these
8579 kSideCWingCHalfLen, // X,Y avoid
8580 kSideCWingsHalfWide);//rotations
8581
8582 TGeoBBox *sideCLateralWingD = new TGeoBBox(kSideCWingDHalfLen,
8583 kSideCHalfThick,
8584 kSideCWingsHalfWide);
8585
8586 TGeoBBox *sideCLateralWingE = new TGeoBBox(kSideCWingEHalfLen,
8587 kSideCHalfThick,
8588 kSideCWingsHalfWide);
8589
8590 // The connecting lower plate: a Xtru
8591 TGeoXtru *sideCLowerPlate = new TGeoXtru(2);
8592
8593 xprof[0] = 0.;
8594 yprof[0] = 0.;
8595 xprof[1] = kPlateHalfLen;
8596 yprof[1] = 0.;
8597 xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
8598 yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
8599 xprof[3] = xprof[2] - kPlateThick*TMath::Sin(kSideCFoldAngle);
8600 yprof[3] = yprof[2] + kPlateThick*TMath::Cos(kSideCFoldAngle);
8601 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
8602 kPlateThick, xprof[4], yprof[4]);
8603 xprof[5] = 0.;
8604 yprof[5] = kPlateThick;
8605
8606 sideCLowerPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
8607 Double_t zwide = kSideCHalfWide + 2*kSideCHalfThick;
8608 sideCLowerPlate->DefineSection(0,-zwide);
8609 sideCLowerPlate->DefineSection(1, zwide);
8610
8611 // The connecting side plate: a Xtru
8612 TGeoXtru *sideCLateralPlate = new TGeoXtru(2);
8613
8614 xprof[0] = 0.;
8615 yprof[0] = 0.;
8616 xprof[1] = kPlateHalfLen;
8617 yprof[1] = 0.;
8618 xprof[2] = xprof[1] + kPlateHalfLen*TMath::Cos(kSideCFoldAngle);
8619 yprof[2] = kPlateHalfLen*TMath::Sin(kSideCFoldAngle);
8620 xprof[3] = xprof[2] - kPlateHeight*TMath::Sin(kSideCFoldAngle);
8621 yprof[3] = yprof[2] + kPlateHeight*TMath::Cos(kSideCFoldAngle);
8622 InsidePoint(xprof[0], yprof[0], xprof[1], yprof[1], xprof[2], yprof[2],
8623 kPlateHeight, xprof[4], yprof[4]); // Avoid small overlap
8624 xprof[5] = 0.;
8625 yprof[5] = kPlateHeight;
8626
8627 sideCLateralPlate->DefinePolygon(kNPointsPlate, xprof, yprof);
8628 sideCLateralPlate->DefineSection(0,-kPlateThick/2);
8629 sideCLateralPlate->DefineSection(1, kPlateThick/2);
8630
8631 // The bar fixing the cooling tubes: a Tube
8632 TGeoTube *coolBar = new TGeoTube(0., kBarCoolRmax, kSideCHalfWide);
8633
8634 // The Cable Tray cover: a (complex) Xtru
8635 TGeoXtru *sideCCoverFace = new TGeoXtru(2);
8636
8637 xprof[ 0] = sideCLateralFace->GetX(8);
8638 yprof[ 0] = sideCLateralFace->GetY(8);
8639 xprof[ 1] = sideCLateralFace->GetX(7);
8640 yprof[ 1] = sideCLateralFace->GetY(7);
8641 xprof[ 2] = sideCLateralFace->GetX(6);
8642 yprof[ 2] = sideCLateralFace->GetY(6);
8643 xprof[ 3] = sideCLateralFace->GetX(5);
8644 yprof[ 3] = sideCLateralFace->GetY(5);
8645 xprof[ 4] = sideCLateralFace->GetX(4);
8646 yprof[ 4] = sideCLateralFace->GetY(4);
8647
8648 xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
8649 delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
8650 xprof[ 5] = xprof[4]
8651 + (delta + 2*kSideCWingEHalfLen)*TMath::Cos(kSideCFoldAngle);
8652 yprof[ 5] = yprof[4]
8653 + (delta + 2*kSideCWingEHalfLen)*TMath::Sin(kSideCFoldAngle);
8654
8655 xprof[ 6] = xprof[5] - 2*kSideCHalfThick*TMath::Sin(kSideCFoldAngle);
8656 yprof[ 6] = yprof[5] + 2*kSideCHalfThick*TMath::Cos(kSideCFoldAngle);
8657 InsidePoint(xprof[3], yprof[3], xprof[4], yprof[4], xprof[5], yprof[5],
8658 2*kSideCHalfThick, xprof[7], yprof[7]);
8659 InsidePoint(xprof[2], yprof[2], xprof[3], yprof[3], xprof[4], yprof[4],
8660 2*kSideCHalfThick, xprof[8], yprof[8]);
8661 xprof[ 9] = xprof[2] + 2*kSideCHalfThick;
8662 yprof[ 9] = yprof[2] + 2*kSideCHalfThick;
8663 xprof[10] = xprof[1];
8664 yprof[10] = yprof[1] + 2*kSideCHalfThick;
8665 xprof[11] = xprof[0];
8666 yprof[11] = yprof[0] + 2*kSideCHalfThick;
8667
8668 sideCCoverFace->DefinePolygon(kNPointsCoverFace, xprof, yprof);
8669 zloc = kSideCHalfWide + 2*kSideCHalfThick + 2*kSideCWingsHalfWide;
8670 sideCCoverFace->DefineSection(0,-zloc);
8671 sideCCoverFace->DefineSection(1, zloc);
8672
8673
8674 // We have all shapes: now create the real volumes
0801d201 8675 TGeoMedium *medAl = mgr->GetMedium("ITS_ALUMINUM$");
aa177c73 8676
8677 TGeoVolume *traySideCLowerFace = new TGeoVolume("ITSsuppTraySideCLower",
8678 sideCLowerFace, medAl);
8679
8680 traySideCLowerFace->SetVisibility(kTRUE);
8681 traySideCLowerFace->SetLineColor(6); // Purple
8682 traySideCLowerFace->SetLineWidth(1);
8683 traySideCLowerFace->SetFillColor(traySideCLowerFace->GetLineColor());
8684 traySideCLowerFace->SetFillStyle(4000); // 0% transparent
8685
8686 TGeoVolume *traySideCLateralFace = new TGeoVolume("ITSsuppTraySideCLateral",
8687 sideCLateralFace, medAl);
8688
8689 traySideCLateralFace->SetVisibility(kTRUE);
8690 traySideCLateralFace->SetLineColor(6); // Purple
8691 traySideCLateralFace->SetLineWidth(1);
8692 traySideCLateralFace->SetFillColor(traySideCLateralFace->GetLineColor());
8693 traySideCLateralFace->SetFillStyle(4000); // 0% transparent
8694
8695 TGeoVolume *traySideCLateralWingA =
8696 new TGeoVolume("ITSsuppTraySideCLateralWingA", sideCLateralWingA, medAl);
8697
8698 traySideCLateralWingA->SetVisibility(kTRUE);
8699 traySideCLateralWingA->SetLineColor(6); // Purple
8700 traySideCLateralWingA->SetLineWidth(1);
8701 traySideCLateralWingA->SetFillColor(traySideCLateralWingA->GetLineColor());
8702 traySideCLateralWingA->SetFillStyle(4000); // 0% transparent
8703
8704 TGeoVolume *traySideCLateralWingB =
8705 new TGeoVolume("ITSsuppTraySideCLateralWingB", sideCLateralWingB, medAl);
8706
8707 traySideCLateralWingB->SetVisibility(kTRUE);
8708 traySideCLateralWingB->SetLineColor(6); // Purple
8709 traySideCLateralWingB->SetLineWidth(1);
8710 traySideCLateralWingB->SetFillColor(traySideCLateralWingB->GetLineColor());
8711 traySideCLateralWingB->SetFillStyle(4000); // 0% transparent
8712
8713 TGeoVolume *traySideCLateralWingC =
8714 new TGeoVolume("ITSsuppTraySideCLateralWingC", sideCLateralWingC, medAl);
8715
8716 traySideCLateralWingC->SetVisibility(kTRUE);
8717 traySideCLateralWingC->SetLineColor(6); // Purple
8718 traySideCLateralWingC->SetLineWidth(1);
8719 traySideCLateralWingC->SetFillColor(traySideCLateralWingC->GetLineColor());
8720 traySideCLateralWingC->SetFillStyle(4000); // 0% transparent
8721
8722 TGeoVolume *traySideCLateralWingD =
8723 new TGeoVolume("ITSsuppTraySideCLateralWingD", sideCLateralWingD, medAl);
8724
8725 traySideCLateralWingD->SetVisibility(kTRUE);
8726 traySideCLateralWingD->SetLineColor(6); // Purple
8727 traySideCLateralWingD->SetLineWidth(1);
8728 traySideCLateralWingD->SetFillColor(traySideCLateralWingD->GetLineColor());
8729 traySideCLateralWingD->SetFillStyle(4000); // 0% transparent
8730
8731 TGeoVolume *traySideCLateralWingE =
8732 new TGeoVolume("ITSsuppTraySideCLateralWingE", sideCLateralWingE, medAl);
8733
8734 traySideCLateralWingE->SetVisibility(kTRUE);
8735 traySideCLateralWingE->SetLineColor(6); // Purple
8736 traySideCLateralWingE->SetLineWidth(1);
8737 traySideCLateralWingE->SetFillColor(traySideCLateralWingE->GetLineColor());
8738 traySideCLateralWingE->SetFillStyle(4000); // 0% transparent
8739
8740 TGeoVolume *traySideCLowerPlate =
8741 new TGeoVolume("ITSsuppTraySideCLowerPlate", sideCLowerPlate, medAl);
8742
8743 traySideCLowerPlate->SetVisibility(kTRUE);
8744 traySideCLowerPlate->SetLineColor(6); // Purple
8745 traySideCLowerPlate->SetLineWidth(1);
8746 traySideCLowerPlate->SetFillColor(traySideCLowerPlate->GetLineColor());
8747 traySideCLowerPlate->SetFillStyle(4000); // 0% transparent
8748
8749 TGeoVolume *traySideCLateralPlate =
8750 new TGeoVolume("ITSsuppTraySideCLateralPlate", sideCLateralPlate, medAl);
8751
8752 traySideCLateralPlate->SetVisibility(kTRUE);
8753 traySideCLateralPlate->SetLineColor(6); // Purple
8754 traySideCLateralPlate->SetLineWidth(1);
8755 traySideCLateralPlate->SetFillColor(traySideCLateralPlate->GetLineColor());
8756 traySideCLateralPlate->SetFillStyle(4000); // 0% transparent
8757
8758 TGeoVolume *traySideCCoverFace =
8759 new TGeoVolume("ITSsuppTraySideCCoverFace", sideCCoverFace, medAl);
8760
8761 traySideCCoverFace->SetVisibility(kTRUE);
8762 traySideCCoverFace->SetLineColor(6); // Purple
8763 traySideCCoverFace->SetLineWidth(1);
8764 traySideCCoverFace->SetFillColor(traySideCCoverFace->GetLineColor());
8765 traySideCCoverFace->SetFillStyle(4000); // 0% transparent
8766
8767 TGeoVolume *coolingTubeBar = new TGeoVolume("ITSsuppTraySideCCoolBar",
8768 coolBar, medAl);
8769
8770 coolingTubeBar->SetVisibility(kTRUE);
8771 coolingTubeBar->SetLineColor(6); // Purple
8772 coolingTubeBar->SetLineWidth(1);
8773 coolingTubeBar->SetFillColor(coolingTubeBar->GetLineColor());
8774 coolingTubeBar->SetFillStyle(4000); // 0% transparent
8775
8776
8777 // Now build up the tray
8778 cableTrayC->AddNode(traySideCLowerFace,1,0);
8779
8780 zloc = kSideCHalfWide + kSideCHalfThick;
8781 cableTrayC->AddNode(traySideCLateralFace,1,
8782 new TGeoTranslation(0., 0., zloc) );
8783 cableTrayC->AddNode(traySideCLateralFace,2,
8784 new TGeoTranslation(0., 0.,-zloc) );
8785
8786 xloc = kSideCWingAHalfLen;
8787 yloc = kSideCHeight1 - kSideCHalfThick;
8788 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8789 cableTrayC->AddNode(traySideCLateralWingA,1,
8790 new TGeoTranslation(xloc, yloc, zloc) );
8791 cableTrayC->AddNode(traySideCLateralWingA,2,
8792 new TGeoTranslation(xloc, yloc,-zloc) );
8793
8794 xloc = kSideCSideLength1 + kSideCSideLength2/2;
8795 yloc = Yfrom2Points(kSideCSideLength1,kSideCHeight1,
8796 kSideCSideLength1+kSideCSideLength2,kSideCSideHeight,
8797 xloc) - kSideCHalfThick -0.0012; // Avoid small overlap
8798 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8799 alpharot = (-(kSideCHeight1 - kSideCSideHeight)/kSideCSideLength2 )*
8800 TMath::RadToDeg();
8801 cableTrayC->AddNode(traySideCLateralWingB,1,
8802 new TGeoCombiTrans(xloc, yloc, zloc,
8803 new TGeoRotation("",alpharot,0,0) ) );
8804 cableTrayC->AddNode(traySideCLateralWingB,2,
8805 new TGeoCombiTrans(xloc, yloc,-zloc,
8806 new TGeoRotation("",alpharot,0,0) ) );
8807
8808 xloc = kSideCSideLength1 + kSideCSideLength2 - kSideCHalfThick;
8809 yloc = kSideCSideHeight - kSideCWingCHalfLen;
8810 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8811 cableTrayC->AddNode(traySideCLateralWingC,1,
8812 new TGeoTranslation(xloc, yloc, zloc) );
8813 cableTrayC->AddNode(traySideCLateralWingC,2,
8814 new TGeoTranslation(xloc, yloc,-zloc) );
8815
8816 xloc = (kSideCLength1 + (kSideCSideLength1+kSideCSideLength2))/2;
8817 yloc = kSideCHeight2 - kSideCHalfThick;
8818 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8819 cableTrayC->AddNode(traySideCLateralWingD,1,
8820 new TGeoTranslation(xloc, yloc, zloc) );
8821 cableTrayC->AddNode(traySideCLateralWingD,2,
8822 new TGeoTranslation(xloc, yloc,-zloc) );
8823
8824 delta = kSideCLength1 - (xloc + kSideCWingDHalfLen);
8825 xloc = kSideCLength1 + delta + kSideCWingEHalfLen;
8826 yloc = (xloc - kSideCLength1)*TMath::Tan(kSideCFoldAngle) +
8827 kSideCHeight2*TMath::Cos(kSideCFoldAngle) - kSideCHalfThick;
8828 zloc = kSideCHalfWide + 2*kSideCHalfThick + kSideCWingsHalfWide;
8829 alpharot = kSideCFoldAngle*TMath::RadToDeg();
8830 cableTrayC->AddNode(traySideCLateralWingE,1,
8831 new TGeoCombiTrans(xloc, yloc, zloc,
8832 new TGeoRotation("",alpharot,0,0) ) );
8833 cableTrayC->AddNode(traySideCLateralWingE,2,
8834 new TGeoCombiTrans(xloc, yloc,-zloc,
8835 new TGeoRotation("",alpharot,0,0) ) );
8836
8837 xloc = kSideCLength1 - kPlateHalfLen;
8838 yloc = -kPlateThick -0.0025; // Avoid small overlap
8839 cableTrayC->AddNode(traySideCLowerPlate,1,
8840 new TGeoTranslation(xloc, yloc, 0.) );
8841
8842 xloc = kSideCLength1 - kPlateHalfLen;
8843 yloc = -kPlateThick;
8844 zloc = kSideCHalfWide + 2*kSideCHalfThick + kPlateThick/2;
8845 cableTrayC->AddNode(traySideCLateralPlate,1,
8846 new TGeoTranslation(xloc, yloc, zloc) );
8847 cableTrayC->AddNode(traySideCLateralPlate,2,
8848 new TGeoTranslation(xloc, yloc,-zloc) );
8849
8850 for (Int_t jc = 0; jc <kNumBarCool; jc++) {
8851 xloc = kXShiftBarCool[jc];
8852 yloc = kYShiftBarCool[jc];
8853 cableTrayC->AddNode(coolingTubeBar,jc+1,
8854 new TGeoTranslation(xloc, yloc, 0.) );
8855 }
8856
8857 cableTrayC->AddNode(traySideCCoverFace,1,0);
8858
8859
8860 // Finally return what we made up
8861
8862 return cableTrayC;
8863}
8864
f0a991bf 8865//______________________________________________________________________
8866void AliITSv11GeometrySupport::ITSTPCSupports(TGeoVolume *moth,
43aefea7 8867 const TGeoManager *mgr){
f0a991bf 8868//
8869// Creates the elements suspending the ITS to the TPC and other fixed
8870// elements used to hook the rails (0872/C and its daughters)
8871//
8b0d638d 8872// Input:
f0a991bf 8873// moth : the TGeoVolume owing the volume structure
8874// mgr : the GeoManager (default gGeoManager)
8875// Output:
8876//
8877// Return:
8878//
8879// Created: 28 Oct 2010 Mario Sitta
8b0d638d 8880// Updated: 18 Feb 2011 Mario Sitta
f0a991bf 8881//
8882// Technical data are taken from AutoCAD drawings, L.Simonetti technical
8883// drawings and other (oral) information given by F.Tosello
8884//
8885
8886 // Dimensions and positions of the half ring C2/C3 (0872/C/04)
8887 const Double_t kRingCZPos = 733.000*fgkmm;
8b0d638d 8888 const Double_t kRingCZToTPC = 5.500*fgkmm;
f0a991bf 8889
8890 const Double_t kRingCThick = 12.000*fgkmm;
8891 const Double_t kRingCRmin = 565.000*fgkmm;
8892 const Double_t kRingCRmax = 592.000*fgkmm;
8893 const Double_t kRingCHeight = 560.000*fgkmm;
8894 const Double_t kRingCXToInsert = 515.000*fgkmm;
8895 const Double_t kRingCYToInsert = 113.000*fgkmm;
8896
8897 const Int_t kNumberOfRingPoints = 23; // N.points to approximate arc
8898
8899 // Dimensions of the forward upper hook (0872/C/09)
8900 const Double_t kForwUpHookThick = 20.000*fgkmm;
8901 const Double_t kForwUpHookRext = 590.000*fgkmm;
8902 const Double_t kForwUpHookRint = 20.000*fgkmm;
8903 const Double_t kForwUpHookHiTot = 89.000*fgkmm;
8904 const Double_t kForwUpHookHiInt = 59.000*fgkmm;
8905 const Double_t kForwUpHookWide = 96.000*fgkmm;
8906 const Double_t kForwUpHookHalfBase = 25.000*fgkmm;
8907 const Double_t kForwUpHookBaseCut = 10.000*fgkmm;
8908 const Double_t kForwUpHookHoleWide = 25.000*fgkmm;
8909 const Double_t kForwUpHookHoleHi = 22.500*fgkmm;
8910 const Double_t kForwUpHookHoleBase = 5.000*fgkmm;
8911 const Double_t kForwUpHookHoleR5 = 5.000*fgkmm;
8912 const Double_t kForwUpHookHoleY = 8.000*fgkmm;
8913 const Double_t kForwUpHookHollowHi = 35.000*fgkmm;
8914 const Double_t kForwUpHookHollowWide= 5.000*fgkmm;
8915
8916 const Int_t kNumberOfForwUpHookPts = 11;
8917 const Int_t kNumbOfForwUpHookHolePts= 5;
8918
8919 // Dimensions of the forward lower hook (0872/C/08)
8920 const Double_t kForwLwHookThick = 20.000*fgkmm;
8921 const Double_t kForwLwHookRext = 590.000*fgkmm;
8922 const Double_t kForwLwHookRint = 20.000*fgkmm;
8923 const Double_t kForwLwHookHiTot = 88.500*fgkmm;
8924 const Double_t kForwLwHookWide = 96.000*fgkmm;
8925 const Double_t kForwLwHookHalfBase = 25.000*fgkmm;
8926 const Double_t kForwLwHookBaseCut = 10.000*fgkmm;
8927 const Double_t kForwLwHookYToHollow = 3.500*fgkmm;
8928 const Double_t kForwLwHookHoleR = 7.500*fgkmm;
8929 const Double_t kForwLwHookHoleIntHi = 35.000*fgkmm;
8930 const Double_t kForwLwHookHoleYPos = 13.500*fgkmm;
8931 const Double_t kForwLwHookHollowHi = 62.000*fgkmm;
8932 const Double_t kForwLwHookHollowWide= 5.000*fgkmm;
8933
8934 const Int_t kNumberOfForwLwHookPts = 11;
8935 const Int_t kNumbOfForwLwHookHolePts= 7;
8936
8937 // Dimensions of the rear upper hook (0872/C/10)
8938 const Double_t kRearUpHookThick = 15.000*fgkmm;
8939 const Double_t kRearUpHookRext = 590.000*fgkmm;
8940 const Double_t kRearUpHookRint = 20.000*fgkmm;
8941 const Double_t kRearUpHookHiTot = 53.500*fgkmm;
8942 const Double_t kRearUpHookHiInt = 23.500*fgkmm;
8943 const Double_t kRearUpHookWide = 96.000*fgkmm;
8944 const Double_t kRearUpHookHalfBase = 25.000*fgkmm;
8945 const Double_t kRearUpHookHoleWide = 25.000*fgkmm;
8946 const Double_t kRearUpHookHoleHi = 22.500*fgkmm;
8947 const Double_t kRearUpHookHoleBase = 5.000*fgkmm;
8948 const Double_t kRearUpHookHoleR5 = 5.000*fgkmm;
8949 const Double_t kRearUpHookHoleY = 8.000*fgkmm;
8950
8951 const Int_t kNumberOfRearUpHookPts = 10;
8952 const Int_t kNumbOfRearUpHookHolePts= 5;
8953
8954 // Dimensions of the forward lower hook (0872/C/11)
8955 const Double_t kRearLwHookThick = 20.000*fgkmm;
8956 const Double_t kRearLwHookRext = 590.000*fgkmm;
8957 const Double_t kRearLwHookHiTot = 30.000*fgkmm;
8958 const Double_t kRearLwHookWide = 96.000*fgkmm;
8959
8960 const Int_t kNumberOfRearLwHookPts = 3;
8961
8962 // Dimensions of the rear lower brackets (0872/C/16)
8963 const Double_t kRearLwBracketThick = 15.000*fgkmm;
8964 const Double_t kRearLwBracketHi1 = 42.000*fgkmm;
8965 const Double_t kRearLwBracketHi2 = 12.000*fgkmm;
8966 const Double_t kRearLwBracketWide1 = 34.000*fgkmm;
8967 const Double_t kRearLwBracketWide2 = 10.000*fgkmm;
8968// const Double_t kRearLwBracketR5 = 5.000*fgkmm
8969
8970 // Dimensions of the forward webcam supports (0872/C/V/01-03-04)
8971 const Double_t kForwWebSStirrDep = 20.000*fgkmm;
8972 const Double_t kForwWebSStirrLen1 = 15.000*fgkmm;
8973 const Double_t kForwWebSStirrLen2 = 55.000*fgkmm;
8974 const Double_t kForwWebSStirrLen3 = 10.000*fgkmm;
8975 const Double_t kForwWebSStirrWide1 = 45.000*fgkmm;
8976 const Double_t kForwWebSStirrWide2 = 38.000*fgkmm;
8977 const Double_t kForwWebSStirrWide3 = 23.000*fgkmm;
8978 const Double_t kForwWebTStirrThick = 5.000*fgkmm;
8979 const Double_t kForwWebTStirrWide1 = 30.000*fgkmm;
8980 const Double_t kForwWebTStirrWide2 = 10.000*fgkmm;
8981 const Double_t kForwWebTStirrTotLen3= 58.500*fgkmm;
8982 const Double_t kForwWebTStirrTotLen4= 36.000*fgkmm;
8983 const Double_t kForwWebTStirrLen1 = 10.000*fgkmm;
8984
8985 // Dimensions of the forward and rear webcam clamps (0872/C/V/02)
8986 const Double_t kFRWebClampThick = 10.000*fgkmm;
8987 const Double_t kFRWebClampExtWide = 30.000*fgkmm;
8988 const Double_t kFRWebClampIntWide = 18.000*fgkmm;
8989 const Double_t kFRWebClampExtHi = 22.000*fgkmm;
8990 const Double_t kFRWebClampIntHi = 17.000*fgkmm;
8991
8992 // Dimensions of the webcam itself
8993 const Double_t kWebcamLength = 35.000*fgkmm;//ESTIMATED!!!
8994
8995 // Dimensions of the rear upper webcam supports (0872/C/V/05-06)
8b0d638d 8996 const Double_t kRearUpWebStirrWide = 76.000*fgkmm;
f0a991bf 8997 const Double_t kRearUpWebStirrDep = 15.000*fgkmm;
8998 const Double_t kRearUpWebStirrThick = 5.000*fgkmm;
8999 const Double_t kRearUpWebStirrH1 = 27.000*fgkmm;
9000 const Double_t kRearUpWebStirrH2 = 32.000*fgkmm;
9001 const Double_t kRearUpWebBarLen = 130.000*fgkmm;
9002 const Double_t kRearUpWebBarHi = 20.000*fgkmm;
9003 const Double_t kRearUpWebBarThick = 5.000*fgkmm;
9004
9005 // Dimensions of the upper wheel slides (0872/C/Z/00-01-02)
9006 const Double_t kUpperSlideTotHeight = 93.500*fgkmm;
9007 const Double_t kUpperSlideBlockHi = 62.500*fgkmm;
9008 const Double_t kUpperSlideWidth = 36.000*fgkmm;
9009 const Double_t kUpperSlideTotDepth = 51.000*fgkmm;
9010 const Double_t kUpperSlideIntDepth = 36.000*fgkmm;
9011 const Double_t kUpperSlideStubHi = 15.000*fgkmm;
9012 const Double_t kUpperSlideStubDep = 8.000*fgkmm;
9013 const Double_t kUpperSlideWheelHi = 18.500*fgkmm;
9014 const Double_t kUpperSlideHoleRout = 11.000*fgkmm;
9015 const Double_t kUpperSlideHoleRint1 = 9.000*fgkmm;
9016 const Double_t kUpperSlideHoleRint2 = 11.500*fgkmm;
9017 const Double_t kUpperSlideHoleH1 = 7.000*fgkmm;
9018 const Double_t kUpperSlideHoleH2 = 46.000*fgkmm;
9019 const Double_t kUpperSlideHoleH3 = 1.100*fgkmm;
9020 const Double_t kUpperSlideHoleXPos = 20.000*fgkmm;
9021 const Double_t kUpperSlidePinRmin = 4.000*fgkmm;
9022 const Double_t kUpperSlidePinRmax = 6.000*fgkmm;
9023 const Double_t kUpperSlidePinH1 = 7.000*fgkmm;
9024 const Double_t kUpperSlidePinH2 = 46.000*fgkmm;
9025 const Double_t kUpperSlidePinH3 = 25.500*fgkmm;
9026
9027 // Dimensions of the lower wheel slides (0872/C/W/00-01-02-03)
9028 const Double_t kLowerSlideTotHeight = 80.000*fgkmm;
9029 const Double_t kLowerSlideBlockHi = 28.000*fgkmm;
9030 const Double_t kLowerSlideWidth = 36.000*fgkmm;
9031 const Double_t kLowerSlideTotDepth = 60.000*fgkmm;
9032 const Double_t kLowerSlideHoleRout = 9.500*fgkmm;
9033 const Double_t kLowerSlideHoleRint = 4.700*fgkmm;
9034 const Double_t kLowerSlideHoleH1 = 12.000*fgkmm;
9035 const Double_t kLowerSlideNoseBase = 40.000*fgkmm;
9036 const Double_t kLowerSlideNoseBasHi = 6.000*fgkmm;//Computed
9037 const Double_t kLowerSlideNoseUpWid = 25.000*fgkmm;
9038 const Double_t kLowerSlideNoseDepth = 10.000*fgkmm;
9039 const Double_t kLowerSlidePinRmin = 3.000*fgkmm;
9040 const Double_t kLowerSlidePinRmax = 4.000*fgkmm;
9041 const Double_t kLowerSlidePinH1 = 12.000*fgkmm;
9042 const Double_t kLowerSlidePinH2 = 10.000*fgkmm;
9043
8b0d638d 9044 // Dimensions and positions of the C1/C2 rail stirrups (0872/C/01-02)
9045 const Double_t kStirrCXPos = 759.000*fgkmm;
9046 const Double_t kStirrCZPos = 1867.000*fgkmm;
9047
9048 const Double_t kStirrC12Thick = 15.000*fgkmm;
9049 const Double_t kStirrC12TotLen = 314.000*fgkmm;
9050 const Double_t kStirrC12BodyHalfHi = 95.000*fgkmm;
9051 const Double_t kStirrC12BodyLen = 153.000*fgkmm;
9052 const Double_t kStirrC12HeadLen = 50.000*fgkmm;
9053 const Double_t kStirrC12HeadHalfHi = 165.000*fgkmm;
9054 const Double_t kStirrC12HeadIntHi = 114.000*fgkmm;
9055 const Double_t kStirrC12HeadIntLen = 45.000*fgkmm;
9056 const Double_t kStirrC12TailLen = 14.000*fgkmm;
9057 const Double_t kStirrC12R100 = 100.000*fgkmm;
9058 const Double_t kStirrC12R50 = 50.000*fgkmm;
9059 const Double_t kStirrC12R10 = 10.000*fgkmm;
9060 const Double_t kStirrC12HeadAng = 40.000; // Degree
9061
9062 const Int_t kNumberOfStirrCPoints = 23;
9063
9064 // Dimensions and positions of the C5 rail stirrups (0872/C/05)
9065 const Double_t kStirrC5BodyLen = 155.000*fgkmm;
9066
f0a991bf 9067
9068 // Local variables
8b0d638d 9069 Double_t xprof[2*kNumberOfStirrCPoints+1],yprof[2*kNumberOfStirrCPoints+1];
f0a991bf 9070 Double_t xpos, ypos, zpos, alpha;
8b0d638d 9071 Double_t xdummy, ydummy;
f0a991bf 9072
9073
9074 // First create all needed shapes
9075
9076 // The Supporting Ring (0872/C/04): a really complex Xtru
9077 // to approximate the arc with a polyline
9078 TGeoXtru *ringC2C3 = new TGeoXtru(2);
9079
9080 for (Int_t j=0; j<11; j++) { // The external arc
9081 xprof[j] = kRingCRmax*SinD(90*j/10);
9082 yprof[j] = kRingCRmax*CosD(90*j/10);
9083 }
9084
9085 xprof[11] = kRingCRmin;
9086 yprof[11] = yprof[10];
9087
9088 alpha = TMath::ASin(kRingCYToInsert/kRingCRmin); // Now the insert
9089 xprof[12] = kRingCRmin*TMath::Cos(alpha/2);
9090 yprof[12] = kRingCRmin*TMath::Sin(alpha/2);
9091 xprof[13] = kRingCRmin*TMath::Cos(alpha);
9092 yprof[13] = kRingCRmin*TMath::Sin(alpha);
9093
9094 xprof[14] = kRingCXToInsert;
9095 yprof[14] = yprof[13];
9096
9097 alpha = TMath::ACos(kRingCXToInsert/kRingCRmin); // The insert ending angle
9098 xprof[15] = kRingCRmin*TMath::Cos(alpha);
9099 yprof[15] = kRingCRmin*TMath::Sin(alpha);
9100
9101 for (Int_t j=7; j>1; j--) { // The internal arc
9102 xprof[23-j] = kRingCRmin*SinD(90*j/10);
9103 yprof[23-j] = kRingCRmin*CosD(90*j/10);
9104 }
9105
9106 alpha = TMath::ASin(kRingCHeight/kRingCRmin); // The angle till the notch
9107 xprof[22] = kRingCRmin*TMath::Cos(alpha);
9108 yprof[22] = kRingCRmin*TMath::Sin(alpha);
9109
9110 xprof[23] = xprof[0];
9111 yprof[23] = yprof[22];
9112
9113 // We did the right side, now reflex on the left side
9114 for (Int_t jp = 0; jp < 22; jp++) {
9115 xprof[24+jp] = -xprof[23-1-jp];
9116 yprof[24+jp] = yprof[23-1-jp];
9117 }
9118
9119 // wow! now the actual Xtru
9120 ringC2C3->DefinePolygon(2*kNumberOfRingPoints, xprof, yprof);
9121 ringC2C3->DefineSection(0, 0);
9122 ringC2C3->DefineSection(1, kRingCThick);
9123
9124 // The Forward Upper Hook (0872/C/09): a Composite Shape made of
9125 // a really complex Xtru to approximate the arc with a polyline,
9126 // another Xtru for the hole, and a BBox for the hollow
9127 // The main body
9128 TGeoXtru *forwUpHookMainBody = new TGeoXtru(2);
9129 forwUpHookMainBody->SetName("ITSforwUpHookMainBody");
9130
9131 xprof[ 0] = kForwUpHookHalfBase - kForwUpHookBaseCut;
9132 yprof[ 0] = kForwUpHookRext - kForwUpHookHiTot;
9133 xprof[ 1] = kForwUpHookHalfBase;
9134 yprof[ 1] = yprof[0] + kForwUpHookBaseCut;
9135 xprof[ 2] = xprof[1];
9136 yprof[ 2] = yprof[0] + (kForwUpHookHiInt - kForwUpHookRint);
9137 for (Int_t j=1; j<6; j++) {
9138 xprof[2+j] = xprof[2] + kForwUpHookRint*(1 - CosD(90*j/5));
9139 yprof[2+j] = yprof[2] + kForwUpHookRint*SinD(90*j/5);
9140 }
9141 xprof[ 8] = kForwUpHookWide/2;
9142 yprof[ 8] = yprof[7];
9143 xprof[ 9] = xprof[8];
9144 alpha = TMath::ASin(0.5*kForwUpHookWide/kForwUpHookRext);
9145 yprof[ 9] = kForwUpHookRext*TMath::Cos(alpha);
9146 xprof[10] = kForwUpHookRext*TMath::Sin(alpha/2);
9147 yprof[10] = kForwUpHookRext*TMath::Cos(alpha/2);
9148 xprof[11] = 0;
9149 yprof[11] = kForwUpHookRext;
9150
9151 // We did the right side, now reflex on the left side
9152 for (Int_t jp = 0; jp < kNumberOfForwUpHookPts; jp++) {
9153 xprof[12+jp] = -xprof[10-jp];
9154 yprof[12+jp] = yprof[10-jp];
9155 }
9156
9157 // Now the actual Xtru
9158 forwUpHookMainBody->DefinePolygon(2*kNumberOfForwUpHookPts+1, xprof, yprof);
9159 forwUpHookMainBody->DefineSection(0, 0);
9160 forwUpHookMainBody->DefineSection(1, kForwUpHookThick);
9161
9162 // The hole
9163 TGeoXtru *forwUpHookHole = new TGeoXtru(2);
9164 forwUpHookHole->SetName("ITSforwUpHookHole");
9165
9166 xprof[0] = kForwUpHookHoleBase/2;
9167 yprof[0] = forwUpHookMainBody->GetY(0) + kForwUpHookHoleY;
9168 xprof[1] = kForwUpHookHoleWide/2;
9169 yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
9170 xprof[2] = xprof[1];
9171 yprof[2] = yprof[0] + kForwUpHookHoleHi - kForwUpHookHoleR5;
9172 xprof[3] = xprof[2] - kForwUpHookHoleR5*(1 - CosD(45));
9173 yprof[3] = yprof[2] + kForwUpHookHoleR5*SinD(45);
9174 xprof[4] = xprof[2] - kForwUpHookHoleR5;
9175 yprof[4] = yprof[0] + kForwUpHookHoleHi;
9176
9177 // We did the right side, now reflex on the left side
9178 for (Int_t jp = 0; jp < kNumbOfForwUpHookHolePts; jp++) {
9179 xprof[5+jp] = -xprof[4-jp];
9180 yprof[5+jp] = yprof[4-jp];
9181 }
9182
9183 // Now the actual Xtru
9184 forwUpHookHole->DefinePolygon(2*kNumbOfForwUpHookHolePts, xprof, yprof);
9185 forwUpHookHole->DefineSection(0, -0.1);
9186 forwUpHookHole->DefineSection(1, kForwUpHookThick+0.1);
9187
9188 // The hollow
9189 TGeoBBox *forwUpHookHollow = new TGeoBBox(2.1 *kForwUpHookHalfBase,
9190 0.55*kForwUpHookHollowHi,
9191 0.55*kForwUpHookHollowWide);
9192 forwUpHookHollow->SetName("ITSforwUpHookHollow");
9193
9194 TGeoTranslation *forwUpHookHollPos = new TGeoTranslation(0.,
9195 forwUpHookMainBody->GetY(0) + 0.5*kForwUpHookHollowHi,
9196 forwUpHookMainBody->GetZ(1) - 0.5*kForwUpHookHollowWide);
9197 forwUpHookHollPos->SetName("ITSforwUpHookHollPos");
9198 forwUpHookHollPos->RegisterYourself();
9199
9200 // Finally the actual shape: a CompositeShape
9201 TGeoCompositeShape *forwUpHookShape = new TGeoCompositeShape("ITSforwUpHookMainBody-ITSforwUpHookHole-ITSforwUpHookHollow:ITSforwUpHookHollPos");
9202
9203 // The Forward Lower Hook (0872/C/08): a Composite Shape made of
9204 // a really complex Xtru to approximate the arc with a polyline,
9205 // another Xtru for the hole, and a BBox for the hollow
9206 // The main body
9207 TGeoXtru *forwLwHookMainBody = new TGeoXtru(2);
9208 forwLwHookMainBody->SetName("ITSforwLwHookMainBody");
9209
9210 xprof[ 0] = kForwLwHookHalfBase - kForwLwHookBaseCut;
9211 yprof[ 0] = kForwLwHookRext - kForwLwHookHiTot;
9212 xprof[ 1] = kForwLwHookHalfBase;
9213 yprof[ 1] = yprof[0] + kForwLwHookBaseCut;
9214 xprof[ 2] = xprof[1];
9215 yprof[ 2] = yprof[0] + (kForwLwHookHollowHi - kForwLwHookYToHollow
9216 - kForwLwHookRint);
9217 for (Int_t j=1; j<6; j++) {
9218 xprof[2+j] = xprof[2] + kForwLwHookRint*(1 - CosD(90*j/5));
9219 yprof[2+j] = yprof[2] + kForwLwHookRint*SinD(90*j/5);
9220 }
9221 xprof[ 8] = kForwLwHookWide/2;
9222 yprof[ 8] = yprof[7];
9223 xprof[ 9] = xprof[8];
9224 alpha = TMath::ASin(0.5*kForwLwHookWide/kForwLwHookRext);
9225 yprof[ 9] = kForwLwHookRext*TMath::Cos(alpha);
9226 xprof[10] = kForwLwHookRext*TMath::Sin(alpha/2);
9227 yprof[10] = kForwLwHookRext*TMath::Cos(alpha/2);
9228 xprof[11] = 0;
9229 yprof[11] = kForwLwHookRext;
9230
9231 // We did the right side, now reflex on the left side
9232 for (Int_t jp = 0; jp < kNumberOfForwLwHookPts; jp++) {
9233 xprof[12+jp] = -xprof[10-jp];
9234 yprof[12+jp] = yprof[10-jp];
9235 }
9236
9237 // Now the actual Xtru
9238 forwLwHookMainBody->DefinePolygon(2*kNumberOfForwLwHookPts+1, xprof, yprof);
9239 forwLwHookMainBody->DefineSection(0, 0);
9240 forwLwHookMainBody->DefineSection(1, kForwLwHookThick);
9241
9242 // The hole
9243 TGeoXtru *forwLwHookHole = new TGeoXtru(2);
9244 forwLwHookHole->SetName("ITSforwLwHookHole");
9245
9246 xprof[0] = 0;
9247 yprof[0] = forwLwHookMainBody->GetY(0) + kForwLwHookHoleYPos
9248 - kForwLwHookHoleR;
9249 for (Int_t j=1; j<3; j++) {
9250 xprof[0+j] = xprof[0] + kForwLwHookHoleR*SinD(90*j/3);
9251 yprof[0+j] = yprof[0] + kForwLwHookHoleR*(1 - CosD(90*j/3));
9252 }
9253 xprof[3] = xprof[0] + kForwLwHookHoleR;
9254 yprof[3] = yprof[0] + kForwLwHookHoleR;
9255 xprof[4] = xprof[3];
9256 yprof[4] = yprof[3] + kForwLwHookHoleIntHi;
9257 for (Int_t j=1; j<3; j++) {
9258 xprof[4+j] = xprof[4] - kForwLwHookHoleR*(1 - CosD(90*j/3));
9259 yprof[4+j] = yprof[4] + kForwLwHookHoleR*SinD(90*j/3);
9260 }
9261 xprof[7] = xprof[0];
9262 yprof[7] = yprof[4] + kForwLwHookHoleR;
9263
9264 // We did the right side, now reflex on the left side
9265 for (Int_t jp = 0; jp < kNumbOfForwLwHookHolePts-1; jp++) {
9266 xprof[8+jp] = -xprof[6-jp];
9267 yprof[8+jp] = yprof[6-jp];
9268 }
9269
9270 // Now the actual Xtru
9271 forwLwHookHole->DefinePolygon(2*kNumbOfForwLwHookHolePts, xprof, yprof);
9272 forwLwHookHole->DefineSection(0, -0.1);
9273 forwLwHookHole->DefineSection(1, kForwLwHookThick+0.1);
9274
9275 // The hollow
9276 TGeoBBox *forwLwHookHollow = new TGeoBBox(2.1 *kForwLwHookHalfBase,
9277 0.55*kForwLwHookHollowHi,
9278 0.55*kForwLwHookHollowWide);
9279 forwLwHookHollow->SetName("ITSforwLwHookHollow");
9280
9281 TGeoTranslation *forwLwHookHollPos = new TGeoTranslation(0.,
9282 forwLwHookMainBody->GetY(0) + 0.5*kForwLwHookHollowHi,
9283 forwLwHookMainBody->GetZ(1) - 0.5*kForwLwHookHollowWide);
9284 forwLwHookHollPos->SetName("ITSforwLwHookHollPos");
9285 forwLwHookHollPos->RegisterYourself();
9286
9287 // Finally the actual shape: a CompositeShape
9288 TGeoCompositeShape *forwLwHookShape = new TGeoCompositeShape("ITSforwLwHookMainBody-ITSforwLwHookHole-ITSforwLwHookHollow:ITSforwLwHookHollPos");
9289
9290 // The Rear Upper Hook (0872/C/10): a Composite Shape made of
9291 // a really complex Xtru to approximate the arc with a polyline,
9292 // and another Xtru for the hole
9293 // The main body
9294 TGeoXtru *rearUpHookMainBody = new TGeoXtru(2);
9295 rearUpHookMainBody->SetName("ITSrearUpHookMainBody");
9296
9297 xprof[0] = kRearUpHookHalfBase;
9298 yprof[0] = kRearUpHookRext - kRearUpHookHiTot;
9299 xprof[1] = xprof[0];
9300 yprof[1] = yprof[0] + (kRearUpHookHiInt - kRearUpHookRint);
9301 for (Int_t j=1; j<6; j++) {
9302 xprof[1+j] = xprof[1] + kRearUpHookRint*(1 - CosD(90*j/5));
9303 yprof[1+j] = yprof[1] + kRearUpHookRint*SinD(90*j/5);
9304 }
9305 xprof[ 7] = kRearUpHookWide/2;
9306 yprof[ 7] = yprof[5];
9307 xprof[ 8] = xprof[7];
9308 alpha = TMath::ASin(0.5*kRearUpHookWide/kRearUpHookRext);
9309 yprof[ 8] = kRearUpHookRext*TMath::Cos(alpha);
9310 xprof[ 9] = kRearUpHookRext*TMath::Sin(alpha/2);
9311 yprof[ 9] = kRearUpHookRext*TMath::Cos(alpha/2);
9312 xprof[10] = 0;
9313 yprof[10] = kRearUpHookRext;
9314
9315 // We did the right side, now reflex on the left side
9316 for (Int_t jp = 0; jp < kNumberOfRearUpHookPts; jp++) {
9317 xprof[11+jp] = -xprof[9-jp];
9318 yprof[11+jp] = yprof[9-jp];
9319 }
9320
9321 // Now the actual Xtru
9322 rearUpHookMainBody->DefinePolygon(2*kNumberOfRearUpHookPts+1, xprof, yprof);
9323 rearUpHookMainBody->DefineSection(0, 0);
9324 rearUpHookMainBody->DefineSection(1, kRearUpHookThick);
9325
9326 // The hole
9327 TGeoXtru *rearUpHookHole = new TGeoXtru(2);
9328 rearUpHookHole->SetName("ITSrearUpHookHole");
9329
9330 xprof[0] = kRearUpHookHoleBase/2;
9331 yprof[0] = rearUpHookMainBody->GetY(0) + kRearUpHookHoleY;
9332 xprof[1] = kRearUpHookHoleWide/2;
9333 yprof[1] = yprof[0] + (xprof[1] - xprof[0]); // Go at 45deg
9334 xprof[2] = xprof[1];
9335 yprof[2] = yprof[0] + kRearUpHookHoleHi - kRearUpHookHoleR5;
9336 xprof[3] = xprof[2] - kRearUpHookHoleR5*(1 - CosD(45));
9337 yprof[3] = yprof[2] + kRearUpHookHoleR5*SinD(45);
9338 xprof[4] = xprof[2] - kRearUpHookHoleR5;
9339 yprof[4] = yprof[0] + kRearUpHookHoleHi;
9340
9341 // We did the right side, now reflex on the left side
9342 for (Int_t jp = 0; jp < kNumbOfRearUpHookHolePts; jp++) {
9343 xprof[5+jp] = -xprof[4-jp];
9344 yprof[5+jp] = yprof[4-jp];
9345 }
9346
9347 // Now the actual Xtru
9348 rearUpHookHole->DefinePolygon(2*kNumbOfRearUpHookHolePts, xprof, yprof);
9349 rearUpHookHole->DefineSection(0, -0.1);
9350 rearUpHookHole->DefineSection(1, kRearUpHookThick+0.1);
9351
9352 // Finally the actual shape: a CompositeShape
9353 TGeoCompositeShape *rearUpHookShape = new TGeoCompositeShape("ITSrearUpHookMainBody-ITSrearUpHookHole");
9354
9355 // The Rear Lower Hook (0872/C/11): a Xtru
9356 TGeoXtru *rearLwHookShape = new TGeoXtru(2);
9357 rearLwHookShape->SetName("ITSrearLwHookShape");
9358
9359 xprof[0] = kRearLwHookWide/2;
9360 yprof[0] = kRearLwHookRext - kRearLwHookHiTot;
9361 xprof[1] = xprof[0];
9362 alpha = TMath::ASin(0.5*kRearLwHookWide/kRearLwHookRext);
9363 yprof[1] = kRearLwHookRext*TMath::Cos(alpha);
9364 xprof[2] = kRearLwHookRext*TMath::Sin(alpha/2);
9365 yprof[2] = kRearLwHookRext*TMath::Cos(alpha/2);
9366 xprof[3] = 0;
9367 yprof[3] = kRearLwHookRext;
9368
9369 // We did the right side, now reflex on the left side
9370 for (Int_t jp = 0; jp < kNumberOfRearLwHookPts; jp++) {
9371 xprof[4+jp] = -xprof[2-jp];
9372 yprof[4+jp] = yprof[2-jp];
9373 }
9374
9375 // Now the actual Xtru
9376 rearLwHookShape->DefinePolygon(2*kNumberOfRearLwHookPts+1, xprof, yprof);
9377 rearLwHookShape->DefineSection(0, 0);
9378 rearLwHookShape->DefineSection(1, kRearLwHookThick);
9379
9380 // The Rear Lower Bracket (0872/C/16): a Xtru
9381 TGeoXtru *rearLwBrackShape = new TGeoXtru(2);
9382 rearLwBrackShape->SetName("ITSrearLwBrackShape");
9383
9384 xprof[0] = 0;
9385 yprof[0] = 0;
9386 xprof[1] = xprof[0] + kRearLwBracketWide1 - kRearLwBracketWide2;
9387 yprof[1] = yprof[0];
9388 xprof[2] = xprof[1];
9389 yprof[2] = yprof[0] + kRearLwBracketHi2;
9390 xprof[3] = xprof[2] - kRearLwBracketWide1;
9391 yprof[3] = yprof[2];
9392 xprof[4] = xprof[3];
9393 yprof[4] = yprof[3] - kRearLwBracketHi1;
9394 xprof[5] = xprof[0];
9395 yprof[5] = yprof[4];
9396
9397 rearLwBrackShape->DefinePolygon(6, xprof, yprof);
9398 rearLwBrackShape->DefineSection(0,-kRearLwBracketThick/2);
9399 rearLwBrackShape->DefineSection(1, kRearLwBracketThick/2);
9400
9401 // The Forward S-shaped Stirrup for the webcam (0872/C/V/01): a Xtru
9402 TGeoXtru *forwWebSStirrSh = new TGeoXtru(2);
9403
9404 xprof[0] = 0;
9405 yprof[0] = 0;
9406 xprof[1] = xprof[0] + kForwWebSStirrLen1;
9407 yprof[1] = yprof[0];
9408 xprof[2] = xprof[1];
9409 yprof[2] = yprof[1] + kForwWebSStirrWide1;
9410 xprof[3] = xprof[0] - kForwWebSStirrLen2 + kForwWebSStirrLen3;
9411 yprof[3] = yprof[2];
9412 xprof[4] = xprof[3];
9413 yprof[4] = yprof[3] + kForwWebSStirrWide3;
9414 xprof[5] = xprof[4] - kForwWebSStirrLen3;
9415 yprof[5] = yprof[4];
9416 xprof[6] = xprof[5];
9417 yprof[6] = yprof[0] + kForwWebSStirrWide2;
9418 xprof[7] = xprof[0];
9419 yprof[7] = yprof[6];
9420
9421 forwWebSStirrSh->DefinePolygon(8, xprof, yprof);
9422 forwWebSStirrSh->DefineSection(0,-kForwWebSStirrDep/2);
9423 forwWebSStirrSh->DefineSection(1, kForwWebSStirrDep/2);
9424
9425 // The Forward T-shaped Stirrups for the webcam (0872/C/V/03-04): two Xtru
9426 TGeoXtru *forwWebTStirr3Sh = new TGeoXtru(2);
9427
9428 xprof[0] = -kForwWebTStirrWide2/2;
9429 yprof[0] = 0;
9430 xprof[1] = -kForwWebTStirrWide1/2;
9431 yprof[1] = yprof[0];
9432 xprof[2] = xprof[1];
9433 yprof[2] = yprof[1] - kForwWebTStirrLen1;
9434 xprof[3] =-xprof[2];
9435 yprof[3] = yprof[2];
9436 xprof[4] = xprof[3];
9437 yprof[4] = yprof[1];
9438 xprof[5] =-xprof[0];
9439 yprof[5] = yprof[4];
9440 xprof[6] = xprof[5];
9441 yprof[6] = kForwWebTStirrTotLen3 - kForwWebTStirrLen1;
9442 xprof[7] = xprof[0];
9443 yprof[7] = yprof[6];
9444
9445 forwWebTStirr3Sh->DefinePolygon(8, xprof, yprof);
9446 forwWebTStirr3Sh->DefineSection(0, 0);
9447 forwWebTStirr3Sh->DefineSection(1, kForwWebTStirrThick);
9448
9449 TGeoXtru *forwWebTStirr4Sh = new TGeoXtru(2);
9450
9451 yprof[6] = kForwWebTStirrTotLen4 - kForwWebTStirrLen1;
9452 yprof[7] = yprof[6];
9453
9454 forwWebTStirr4Sh->DefinePolygon(8, xprof, yprof);
9455 forwWebTStirr4Sh->DefineSection(0, 0);
9456 forwWebTStirr4Sh->DefineSection(1, kForwWebTStirrThick);
9457
9458 // The Forward and Rear clamp for the webcam (0872/C/V/02): a Xtru
9459 TGeoXtru *frWebClampSh = new TGeoXtru(2);
9460
9461 xprof[0] = kFRWebClampIntWide/2;
9462 yprof[0] = kFRWebClampIntHi;
9463 xprof[1] = xprof[0];
9464 yprof[1] = 0;
9465 xprof[2] = kFRWebClampExtWide/2;
9466 yprof[2] = yprof[1];
9467 xprof[3] = xprof[2];
9468 yprof[3] = kFRWebClampExtHi;
9469 for (Int_t jp = 0; jp < 4; jp++) {
9470 xprof[4+jp] = -xprof[3-jp];
9471 yprof[4+jp] = yprof[3-jp];
9472 }
9473
9474 frWebClampSh->DefinePolygon(8, xprof, yprof);
9475 frWebClampSh->DefineSection(0,-kFRWebClampThick/2);
9476 frWebClampSh->DefineSection(1, kFRWebClampThick/2);
9477
9478 // The Rear Upper Stirrup for the webcam (0872/C/V/05): a Xtru
9479 TGeoXtru *upWebStirrSh = new TGeoXtru(2);
9480
9481 xprof[0] = 0;
9482 yprof[0] = 0;
9483 xprof[1] = xprof[0] - (kRearUpWebStirrWide - 2*kRearUpWebStirrThick);
9484 yprof[1] = yprof[0];
9485 xprof[2] = xprof[1];
9486 yprof[2] = yprof[1] + (kRearUpWebStirrH1 - kRearUpWebStirrThick);
9487 xprof[3] = xprof[2] - kRearUpWebStirrThick;
9488 yprof[3] = yprof[2];
9489 xprof[4] = xprof[3];
9490 yprof[4] = yprof[3] - kRearUpWebStirrH1;
9491 xprof[5] = xprof[4] + kRearUpWebStirrWide;
9492 yprof[5] = yprof[4];
9493 xprof[6] = xprof[5];
9494 yprof[6] = yprof[5] + kRearUpWebStirrH2;
9495 xprof[7] = xprof[0];
9496 yprof[7] = yprof[6];
9497
9498 upWebStirrSh->DefinePolygon(8, xprof, yprof);
9499 upWebStirrSh->DefineSection(0,-kRearUpWebStirrDep/2);
9500 upWebStirrSh->DefineSection(1, kRearUpWebStirrDep/2);
9501
9502 // The Rear Upper Bar for the webcam (0872/C/V/06): a BBox
9503 TGeoBBox *upRearWebBarSh = new TGeoBBox(kRearUpWebBarLen/2,
9504 kRearUpWebBarHi/2,
9505 kRearUpWebBarThick/2);
9506
9507 // The Webcam: a BBox
9508 TGeoBBox *webcamShape = new TGeoBBox(kFRWebClampIntWide/2,
9509 kWebcamLength/2,
9510 kFRWebClampIntHi/2);
9511
9512 // The Upper Wheel Slide (0872/C/Z/00-01-02)
9513 // A mother volume of air (to avoid assembly) contains the Alluminum block
9514 // (a Composite Shape: a Xtru and a Pcon for the hole) and the Steel pin
9515 // (a Pcon) (The wheels are approximated as part of the block itself)
9516 // The Air mother volume
9517 TGeoXtru *upSlideAirSh = new TGeoXtru(2);
9518 upSlideAirSh->SetName("ITSupperSlideAirShape");
9519
9520 xprof[0] = 0;
9521 yprof[0] = 0;
9522 xprof[1] = xprof[0];
9523 yprof[1] = kUpperSlideBlockHi + kUpperSlideStubHi - kUpperSlideWheelHi;
9524 xprof[2] = xprof[1] - kUpperSlideIntDepth;
9525 yprof[2] = yprof[1];
9526 xprof[3] = xprof[2];
9527 yprof[3] = yprof[2] - kUpperSlideTotHeight;
9528 xprof[4] = xprof[3] + kUpperSlideTotDepth;
9529 yprof[4] = yprof[3];
9530 xprof[5] = xprof[4];
9531 yprof[5] = yprof[0];
9532
9533 upSlideAirSh->DefinePolygon(6, xprof, yprof);
9534 upSlideAirSh->DefineSection(0,-kUpperSlideWidth/2);
9535 upSlideAirSh->DefineSection(1, kUpperSlideWidth/2);
9536
9537 // The (filled) Aluminum block: a Xtru
9538 TGeoXtru *upSlideAluSh = new TGeoXtru(2);
9539 upSlideAluSh->SetName("ITSupperSlideAluShape");
9540
9541 xprof[0] = upSlideAirSh->GetX(0);
9542 yprof[0] = upSlideAirSh->GetY(0);
9543 xprof[1] = upSlideAirSh->GetX(1);
9544 yprof[1] = upSlideAirSh->GetY(1);
9545 xprof[2] = xprof[1] - kUpperSlideStubDep;
9546 yprof[2] = yprof[1];
9547 xprof[3] = xprof[2];
9548 yprof[3] = yprof[2] - kUpperSlideStubHi;
9549 xprof[4] = upSlideAirSh->GetX(2);
9550 yprof[4] = yprof[3];
9551 xprof[5] = xprof[4];
9552 yprof[5] = yprof[4] - kUpperSlideBlockHi;
9553 xprof[6] = upSlideAirSh->GetX(5);
9554 yprof[6] = yprof[5];
9555 xprof[7] = xprof[6];
9556 yprof[7] = yprof[0];
9557
9558 upSlideAluSh->DefinePolygon(8, xprof, yprof);
9559 upSlideAluSh->DefineSection(0, upSlideAirSh->GetZ(0));
9560 upSlideAluSh->DefineSection(1, upSlideAirSh->GetZ(1));
9561
9562 // The cylindrical hole in the block; a Pcon
9563 TGeoPcon *upSlideHoleSh = new TGeoPcon(0, 360, 10);
9564 upSlideHoleSh->SetName("ITSupperSlideHoleShape");
9565
9566 zpos = upSlideAluSh->GetY(5);
9567 upSlideHoleSh->DefineSection(0, zpos-0.1, 0, kUpperSlideHoleRout);
9568 zpos += (kUpperSlideBlockHi - kUpperSlideHoleH3 - kUpperSlideHoleH2
9569 - 2*kUpperSlideHoleH1);
9570 upSlideHoleSh->DefineSection(1, zpos, 0, kUpperSlideHoleRout);
9571 upSlideHoleSh->DefineSection(2, zpos, 0, kUpperSlideHoleRint2);
9572 zpos += kUpperSlideHoleH3;
9573 upSlideHoleSh->DefineSection(3, zpos, 0, kUpperSlideHoleRint2);
9574 upSlideHoleSh->DefineSection(4, zpos, 0, kUpperSlideHoleRout);
9575 zpos += kUpperSlideHoleH1;
9576 upSlideHoleSh->DefineSection(5, zpos, 0, kUpperSlideHoleRout);
9577 upSlideHoleSh->DefineSection(6, zpos, 0, kUpperSlideHoleRint1);
9578 zpos += kUpperSlideHoleH2;
9579 upSlideHoleSh->DefineSection(7, zpos, 0, kUpperSlideHoleRint1);
9580 upSlideHoleSh->DefineSection(8, zpos, 0, kUpperSlideHoleRout);
9581 zpos += kUpperSlideHoleH1;
9582 upSlideHoleSh->DefineSection(9, zpos+0.1, 0, kUpperSlideHoleRout);
9583
9584 TGeoCombiTrans *upSlideHolePos = new TGeoCombiTrans(-kUpperSlideHoleXPos,0,0,
9585 new TGeoRotation("",0,-90,0) );
9586 upSlideHolePos->SetName("ITSupperSlideHolePos");
9587 upSlideHolePos->RegisterYourself();
9588
9589 // The actual block: a CompositeShape
9590 TGeoCompositeShape *upSlideBlockSh = new TGeoCompositeShape("ITSupperSlideAluShape-ITSupperSlideHoleShape:ITSupperSlideHolePos");
9591
9592 // The Steel pin in the block; a Pcon
9593 TGeoPcon *upSlidePinSh = new TGeoPcon(0, 360, 6);
9594 upSlidePinSh->SetName("ITSupperSlidePinShape");
9595
9596 zpos = upSlideAluSh->GetY(5) - (kUpperSlidePinH1 + kUpperSlidePinH2
9597 + kUpperSlidePinH3 - kUpperSlideBlockHi);
9598 upSlidePinSh->DefineSection(0, zpos, 0, kUpperSlidePinRmin);
9599 zpos += kUpperSlidePinH3;
9600 upSlidePinSh->DefineSection(1, zpos, 0, kUpperSlidePinRmin);
9601 upSlidePinSh->DefineSection(2, zpos, 0, kUpperSlidePinRmax);
9602 zpos += kUpperSlidePinH2;
9603 upSlidePinSh->DefineSection(3, zpos, 0, kUpperSlidePinRmax);
9604 upSlidePinSh->DefineSection(4, zpos, 0, kUpperSlidePinRmin);
9605 zpos += kUpperSlidePinH1;
9606 upSlidePinSh->DefineSection(5, zpos, 0, kUpperSlidePinRmin);
9607
9608 // The Lower Wheel Slide (0872/C/W/00-01-02-03)
9609 // A mother volume of air (to avoid assembly) contains the Alluminum block
9610 // (a Composite Shape: a Xtru and a Pcon for the hole), the Alluminum nose
9611 // (a Xtru) and the Steel pin (a Pcon)
9612 // (The wheels are approximated as part of the block itself)
9613 // The Air mother volume
9614 TGeoXtru *lwSlideAirSh = new TGeoXtru(2);
9615 lwSlideAirSh->SetName("ITSlowerSlideAirShape");
9616
9617 xprof[0] = 0;
9618 yprof[0] = 0;
9619 xprof[1] = xprof[0] + kLowerSlideTotDepth/2 - kLowerSlideNoseBase/2;
9620 yprof[1] = yprof[0];
9621 xprof[2] = xprof[1];
9622 yprof[2] = yprof[1] - (kLowerSlideBlockHi + kLowerSlidePinH2);
9623 xprof[3] = xprof[2] - kLowerSlideTotDepth;
9624 yprof[3] = yprof[2];
9625 xprof[4] = xprof[3];
9626 yprof[4] = yprof[3] + kLowerSlidePinH2 + kLowerSlideTotHeight;
9627 xprof[5] = xprof[0];
9628 yprof[5] = yprof[4];
9629
9630 lwSlideAirSh->DefinePolygon(6, xprof, yprof);
9631 lwSlideAirSh->DefineSection(0,-kLowerSlideWidth/2);
9632 lwSlideAirSh->DefineSection(1, kLowerSlideWidth/2);
9633
9634 // The (filled) Aluminum block: a Xtru
9635 TGeoXtru *lwSlideAluSh = new TGeoXtru(2);
9636 lwSlideAluSh->SetName("ITSlowerSlideAluShape");
9637
9638 xprof[0] = lwSlideAirSh->GetX(0);
9639 yprof[0] = lwSlideAirSh->GetY(0);
9640 xprof[1] = lwSlideAirSh->GetX(1);
9641 yprof[1] = lwSlideAirSh->GetY(1);
9642 xprof[2] = xprof[1];
9643 yprof[2] = yprof[1] - kLowerSlideBlockHi;
9644 xprof[3] = lwSlideAirSh->GetX(3);
9645 yprof[3] = yprof[2];
9646 xprof[4] = xprof[3];
9647 yprof[4] = yprof[3] + kLowerSlideBlockHi;
9648 xprof[5] = xprof[4] + kLowerSlideTotDepth/2;
9649 yprof[5] = yprof[4];
9650 xprof[6] = xprof[5];
9651 yprof[6] = lwSlideAirSh->GetY(4);
9652 xprof[7] = xprof[0];
9653 yprof[7] = yprof[6];
9654
9655 lwSlideAluSh->DefinePolygon(8, xprof, yprof);
9656 lwSlideAluSh->DefineSection(0, lwSlideAirSh->GetZ(0));
9657 lwSlideAluSh->DefineSection(1, lwSlideAirSh->GetZ(1));
9658
9659 // The cylindrical hole in the block; a Pcon
9660 TGeoPcon *lwSlideHoleSh = new TGeoPcon(0, 360, 4);
9661 lwSlideHoleSh->SetName("ITSlowerSlideHoleShape");
9662
9663 zpos = lwSlideAluSh->GetY(2);
9664 lwSlideHoleSh->DefineSection(0, zpos-0.1, 0, kLowerSlideHoleRout);
9665 zpos += kLowerSlideHoleH1;
9666 lwSlideHoleSh->DefineSection(1, zpos, 0, kLowerSlideHoleRout);
9667 lwSlideHoleSh->DefineSection(2, zpos, 0, kLowerSlideHoleRint);
9668 zpos = lwSlideAluSh->GetY(4);
9669 lwSlideHoleSh->DefineSection(3, zpos, 0, kLowerSlideHoleRint);
9670
9671 TGeoCombiTrans *lwSlideHolePos = new TGeoCombiTrans(lwSlideAluSh->GetX(5),
9672 0, 0,
9673 new TGeoRotation("",0,-90,0) );
9674 lwSlideHolePos->SetName("ITSlowerSlideHolePos");
9675 lwSlideHolePos->RegisterYourself();
9676
9677 // The actual block: a CompositeShape
9678 TGeoCompositeShape *lwSlideBlockSh = new TGeoCompositeShape("ITSlowerSlideAluShape-ITSlowerSlideHoleShape:ITSlowerSlideHolePos");
9679
9680 // The Aluminum nose: a Xtru
9681 TGeoXtru *lwSlideNoseSh = new TGeoXtru(2);
9682 lwSlideNoseSh->SetName("ITSlowerSlideNoseShape");
9683
9684 xprof[0] = lwSlideAluSh->GetX(5);
9685 yprof[0] = lwSlideAluSh->GetY(5);
9686 xprof[1] = xprof[0] - kLowerSlideNoseBase/2;
9687 yprof[1] = yprof[0];
9688 xprof[2] = xprof[1];
9689 yprof[2] = yprof[1] + kLowerSlideNoseBasHi;
9690 xprof[3] = lwSlideAluSh->GetX(0) - kLowerSlideNoseUpWid;
9691 yprof[3] = lwSlideAluSh->GetY(6);
9692 xprof[4] = xprof[0];
9693 yprof[4] = yprof[3];
9694
9695 lwSlideNoseSh->DefinePolygon(5, xprof, yprof);
9696 lwSlideNoseSh->DefineSection(0,-kLowerSlideNoseDepth/2);
9697 lwSlideNoseSh->DefineSection(1, kLowerSlideNoseDepth/2);
9698
9699 // The Steel pin in the block; a Pcon
9700 TGeoPcon *lwSlidePinSh = new TGeoPcon(0, 360, 4);
9701 lwSlidePinSh->SetName("ITSlowerSlidePinShape");
9702
9703 zpos = lwSlideAirSh->GetY(2);
9704 lwSlidePinSh->DefineSection(0, zpos, 0, kLowerSlidePinRmax);
9705 zpos += kLowerSlidePinH2;
9706 lwSlidePinSh->DefineSection(1, zpos, 0, kLowerSlidePinRmax);
9707 lwSlidePinSh->DefineSection(2, zpos, 0, kLowerSlidePinRmin);
9708 zpos += kLowerSlidePinH1;
9709 lwSlidePinSh->DefineSection(3, zpos, 0, kLowerSlidePinRmin);
9710
8b0d638d 9711 // The Stirrup on the Muon side (0872/C/01-02): a really complex Xtru
9712 // to approximate arcs with polylines
9713 TGeoXtru *stirrupC1C2Sh = new TGeoXtru(2);
9714
9715 for (Int_t j=0; j<11; j++) { // The internal arc
9716 xprof[j] = kStirrC12R50*(1 - CosD(90*j/10));
9717 yprof[j] = kStirrC12R50*SinD(90*j/10);
9718 }
9719
9720 xprof[11] = xprof[10] + kStirrC12TailLen;
9721 yprof[11] = yprof[10];
9722 xprof[12] = xprof[11];
9723 yprof[12] = kStirrC12BodyHalfHi;
9724 xprof[13] = xprof[12] - kStirrC12BodyLen;
9725 yprof[13] = yprof[12];
9726
9727 xprof[17] = xprof[12] - kStirrC12TotLen + kStirrC12HeadLen;
9728 yprof[17] = kStirrC12HeadHalfHi;
9729 IntersectCircle(-TanD(kStirrC12HeadAng), xprof[17], yprof[17],
9730 kStirrC12R100, xprof[13], yprof[13]+kStirrC12R100,
9731 xprof[16], yprof[16], xdummy, ydummy);
9732 alpha = TMath::ASin((xprof[13]-xprof[16])/kStirrC12R100);
9733 xprof[14] = xprof[13] - kStirrC12R100*TMath::Sin(alpha/3);
9734 yprof[14] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(alpha/3));
9735 xprof[15] = xprof[13] - kStirrC12R100*TMath::Sin(2*alpha/3);
9736 yprof[15] = yprof[13] + kStirrC12R100*(1 - TMath::Cos(2*alpha/3));
9737
9738 xprof[18] = xprof[17] - kStirrC12HeadLen;
9739 yprof[18] = yprof[17];
9740 xprof[19] = xprof[18];
9741 yprof[19] = kStirrC12HeadIntHi;
9742 xprof[20] = xprof[19] + kStirrC12HeadIntLen - kStirrC12R10;
9743 yprof[20] = yprof[19];
9744 for (Int_t j=1; j<4; j++) {
9745 xprof[20+j] = xprof[20] + kStirrC12R10*SinD(90*j/3);
9746 yprof[20+j] = yprof[20] - kStirrC12R10*(1 - CosD(90*j/3));
9747 }
9748
9749 // We did the up side, now reflex on the bottom side
9750 for (Int_t jp = 0; jp < kNumberOfStirrCPoints; jp++) {
9751 xprof[24+jp] = xprof[23-jp];
9752 yprof[24+jp] = -yprof[23-jp];
9753 }
9754
9755 // Now the actual Xtru
9756 stirrupC1C2Sh->DefinePolygon(2*kNumberOfStirrCPoints+1, xprof, yprof);
9757 stirrupC1C2Sh->DefineSection(0,-kStirrC12Thick/2);
9758 stirrupC1C2Sh->DefineSection(1, kStirrC12Thick/2);
9759
9760 // The first element of the Stirrup on the Forward side (0872/C/05):
9761 // a really complex Xtru (equal to part of the Muon Stirrup)
9762 // (0872/C/06 and 0872/C/07 are dismounted after positioning the TPC to I.P.)
9763 TGeoXtru *stirrupC5Sh = new TGeoXtru(2);
9764
9765 for (Int_t j=0; j<13; j++) { // The internal arc and the tail
9766 xprof[j] = stirrupC1C2Sh->GetX(j);
9767 yprof[j] = stirrupC1C2Sh->GetY(j);
9768 }
9769
9770 xprof[13] = xprof[12] - kStirrC5BodyLen;
9771 yprof[13] = yprof[12];
9772
9773 // We did the up side, now reflex on the bottom side
9774 for (Int_t jp = 0; jp < 13; jp++) {
9775 xprof[14+jp] = xprof[13-jp];
9776 yprof[14+jp] = -yprof[13-jp];
9777 }
9778
9779 // Now the actual Xtru
9780 stirrupC5Sh->DefinePolygon(27, xprof, yprof);
9781 stirrupC5Sh->DefineSection(0,-kStirrC12Thick/2);
9782 stirrupC5Sh->DefineSection(1, kStirrC12Thick/2);
9783
f0a991bf 9784
9785 // We have all shapes: now create the real volumes
9786 TGeoMedium *medAlcoa = mgr->GetMedium("ITS_ALUMINUM$"); // To code!!!!!!
9787 TGeoMedium *medHokotol = mgr->GetMedium("ITS_HOKOTOL$");
9788 TGeoMedium *medAnticor = mgr->GetMedium("ITS_ANTICORODAL$");
8b0d638d 9789 TGeoMedium *medErgal = mgr->GetMedium("ITS_ERGAL$");
f0a991bf 9790 TGeoMedium *medAisi = mgr->GetMedium("ITS_AISI304L$");
9791 TGeoMedium *medAir = mgr->GetMedium("ITS_AIR$");
9792 TGeoMedium *medPlexy = mgr->GetMedium("ITS_PLEXYGLAS$");
9793 TGeoMedium *medPVC = mgr->GetMedium("ITS_PVC$");
9794
8b0d638d 9795
f0a991bf 9796 TGeoVolume *suppRingC2C3 = new TGeoVolume("ITSTPCsupportRingC2C3",
9797 ringC2C3, medAlcoa);
9798
9799 suppRingC2C3->SetVisibility(kTRUE);
9800 suppRingC2C3->SetLineColor(6); // Purple
9801 suppRingC2C3->SetLineWidth(1);
9802 suppRingC2C3->SetFillColor(suppRingC2C3->GetLineColor());
9803 suppRingC2C3->SetFillStyle(4000); // 0% transparent
9804
9805 TGeoVolume *forwUpHook = new TGeoVolume("ITSTPCsupportForwUpHook",
9806 forwUpHookShape, medHokotol);
9807
9808 forwUpHook->SetVisibility(kTRUE);
9809 forwUpHook->SetLineColor(6); // Purple
9810 forwUpHook->SetLineWidth(1);
9811 forwUpHook->SetFillColor(forwUpHook->GetLineColor());
9812 forwUpHook->SetFillStyle(4000); // 0% transparent
9813
9814 TGeoVolume *forwLwHook = new TGeoVolume("ITSTPCsupportForwLwHook",
9815 forwLwHookShape, medHokotol);
9816
9817 forwLwHook->SetVisibility(kTRUE);
9818 forwLwHook->SetLineColor(6); // Purple
9819 forwLwHook->SetLineWidth(1);
9820 forwLwHook->SetFillColor(forwLwHook->GetLineColor());
9821 forwLwHook->SetFillStyle(4000); // 0% transparent
9822
9823 TGeoVolume *rearUpHook = new TGeoVolume("ITSTPCsupportRearUpHook",
9824 rearUpHookShape, medHokotol);
9825
9826 rearUpHook->SetVisibility(kTRUE);
9827 rearUpHook->SetLineColor(6); // Purple
9828 rearUpHook->SetLineWidth(1);
9829 rearUpHook->SetFillColor(rearUpHook->GetLineColor());
9830 rearUpHook->SetFillStyle(4000); // 0% transparent
9831
9832 TGeoVolume *rearLwHook = new TGeoVolume("ITSTPCsupportRearLwHook",
9833 rearLwHookShape, medAnticor);
9834
9835 rearLwHook->SetVisibility(kTRUE);
9836 rearLwHook->SetLineColor(6); // Purple
9837 rearLwHook->SetLineWidth(1);
9838 rearLwHook->SetFillColor(rearLwHook->GetLineColor());
9839 rearLwHook->SetFillStyle(4000); // 0% transparent
9840
9841 TGeoVolume *rearLwBrack = new TGeoVolume("ITSTPCsupportRearLwBracket",
9842 rearLwBrackShape, medAnticor);
9843
9844 rearLwBrack->SetVisibility(kTRUE);
9845 rearLwBrack->SetLineColor(6); // Purple
9846 rearLwBrack->SetLineWidth(1);
9847 rearLwBrack->SetFillColor(rearLwBrack->GetLineColor());
9848 rearLwBrack->SetFillStyle(4000); // 0% transparent
9849
9850 TGeoVolume *forwWebSStirrup = new TGeoVolume("ITSTPCsupportForwWebSStirrup",
9851 forwWebSStirrSh, medAnticor);
9852
9853 forwWebSStirrup->SetVisibility(kTRUE);
9854 forwWebSStirrup->SetLineColor(6); // Purple
9855 forwWebSStirrup->SetLineWidth(1);
9856 forwWebSStirrup->SetFillColor(forwWebSStirrup->GetLineColor());
9857 forwWebSStirrup->SetFillStyle(4000); // 0% transparent
9858
9859 TGeoVolume *forwWebTStirr3 = new TGeoVolume("ITSTPCsupportForwWebTStirrup3",
9860 forwWebTStirr3Sh, medAnticor);
9861
9862 forwWebTStirr3->SetVisibility(kTRUE);
9863 forwWebTStirr3->SetLineColor(6); // Purple
9864 forwWebTStirr3->SetLineWidth(1);
9865 forwWebTStirr3->SetFillColor(forwWebTStirr3->GetLineColor());
9866 forwWebTStirr3->SetFillStyle(4000); // 0% transparent
9867
9868 TGeoVolume *forwWebTStirr4 = new TGeoVolume("ITSTPCsupportForwWebTStirrup4",
9869 forwWebTStirr4Sh, medAnticor);
9870
9871 forwWebTStirr4->SetVisibility(kTRUE);
9872 forwWebTStirr4->SetLineColor(6); // Purple
9873 forwWebTStirr4->SetLineWidth(1);
9874 forwWebTStirr4->SetFillColor(forwWebTStirr4->GetLineColor());
9875 forwWebTStirr4->SetFillStyle(4000); // 0% transparent
9876
9877 TGeoVolume *frWebClamp = new TGeoVolume("ITSTPCsupportForwRearWebClamp",
9878 frWebClampSh, medPlexy);
9879
9880 frWebClamp->SetVisibility(kTRUE);
9881 frWebClamp->SetLineColor(kAzure);
9882 frWebClamp->SetLineWidth(1);
9883 frWebClamp->SetFillColor(frWebClamp->GetLineColor());
9884 frWebClamp->SetFillStyle(4000); // 0% transparent
9885
9886 TGeoVolume *upWebStirrup = new TGeoVolume("ITSTPCsupportUpperWebStirrup",
9887 upWebStirrSh, medAnticor);
9888
9889 upWebStirrup->SetVisibility(kTRUE);
9890 upWebStirrup->SetLineColor(6); // Purple
9891 upWebStirrup->SetLineWidth(1);
9892 upWebStirrup->SetFillColor(upWebStirrup->GetLineColor());
9893 upWebStirrup->SetFillStyle(4000); // 0% transparent
9894
9895 TGeoVolume *upRearWebBar = new TGeoVolume("ITSTPCsupportUpperRearWebBar",
9896 upRearWebBarSh, medPlexy);
9897
9898 upRearWebBar->SetVisibility(kTRUE);
9899 upRearWebBar->SetLineColor(kAzure);
9900 upRearWebBar->SetLineWidth(1);
9901 upRearWebBar->SetFillColor(upRearWebBar->GetLineColor());
9902 upRearWebBar->SetFillStyle(4000); // 0% transparent
9903
9904 TGeoVolume *webCam = new TGeoVolume("ITSTPCsupportWebcam",
9905 webcamShape, medPVC);
9906
9907 webCam->SetVisibility(kTRUE);
9908 webCam->SetLineColor(kBlack);
9909 webCam->SetLineWidth(1);
9910 webCam->SetFillColor(webCam->GetLineColor());
9911 webCam->SetFillStyle(4000); // 0% transparent
9912
9913 TGeoVolume *upSlideVol = new TGeoVolume("ITSTPCsupportUpperSlide",
9914 upSlideAirSh, medAir);
9915
9916 upSlideVol->SetVisibility(kFALSE);
9917
9918 TGeoVolume *upSlideBlock = new TGeoVolume("ITSTPCsupportUpperSlideBlock",
9919 upSlideBlockSh, medAnticor);
9920
9921 upSlideBlock->SetVisibility(kTRUE);
9922 upSlideBlock->SetLineColor(6); // Purple
9923 upSlideBlock->SetLineWidth(1);
9924 upSlideBlock->SetFillColor(upSlideBlock->GetLineColor());
9925 upSlideBlock->SetFillStyle(4000); // 0% transparent
9926
9927 TGeoVolume *upSlidePin = new TGeoVolume("ITSTPCsupportUpperSlidePin",
9928 upSlidePinSh, medAisi);
9929
9930 upSlidePin->SetVisibility(kTRUE);
9931 upSlidePin->SetLineColor(kGray);
9932 upSlidePin->SetLineWidth(1);
9933 upSlidePin->SetFillColor(upSlidePin->GetLineColor());
9934 upSlidePin->SetFillStyle(4000); // 0% transparent
9935
9936 TGeoVolume *lwSlideVol = new TGeoVolume("ITSTPCsupportLowerSlide",
9937 lwSlideAirSh, medAir);
9938
9939 lwSlideVol->SetVisibility(kFALSE);
9940
9941 TGeoVolume *lwSlideBlock = new TGeoVolume("ITSTPCsupportLowerSlideBlock",
9942 lwSlideBlockSh, medAnticor);
9943
9944 lwSlideBlock->SetVisibility(kTRUE);
9945 lwSlideBlock->SetLineColor(6); // Purple
9946 lwSlideBlock->SetLineWidth(1);
9947 lwSlideBlock->SetFillColor(lwSlideBlock->GetLineColor());
9948 lwSlideBlock->SetFillStyle(4000); // 0% transparent
9949
9950 TGeoVolume *lwSlideNose = new TGeoVolume("ITSTPCsupportLowerSlideNose",
9951 lwSlideNoseSh, medAnticor);
9952
9953 lwSlideNose->SetVisibility(kTRUE);
9954 lwSlideNose->SetLineColor(6); // Purple
9955 lwSlideNose->SetLineWidth(1);
9956 lwSlideNose->SetFillColor(lwSlideNose->GetLineColor());
9957 lwSlideNose->SetFillStyle(4000); // 0% transparent
9958
9959 TGeoVolume *lwSlidePin = new TGeoVolume("ITSTPCsupportLowerSlidePin",
9960 lwSlidePinSh, medAisi);
9961
9962 lwSlidePin->SetVisibility(kTRUE);
9963 lwSlidePin->SetLineColor(kGray);
9964 lwSlidePin->SetLineWidth(1);
9965 lwSlidePin->SetFillColor(lwSlidePin->GetLineColor());
9966 lwSlidePin->SetFillStyle(4000); // 0% transparent
9967
8b0d638d 9968 TGeoVolume *stirrC1C2 = new TGeoVolume("ITSTPCsupportStirrupC1C2",
9969 stirrupC1C2Sh, medErgal);
9970
9971 stirrC1C2->SetVisibility(kTRUE);
9972 stirrC1C2->SetLineColor(6); // Purple
9973 stirrC1C2->SetLineWidth(1);
9974 stirrC1C2->SetFillColor(stirrC1C2->GetLineColor());
9975 stirrC1C2->SetFillStyle(4000); // 0% transparent
9976
9977 TGeoVolume *stirrC5 = new TGeoVolume("ITSTPCsupportStirrupC5",
9978 stirrupC5Sh, medErgal);
9979
9980 stirrC5->SetVisibility(kTRUE);
9981 stirrC5->SetLineColor(6); // Purple
9982 stirrC5->SetLineWidth(1);
9983 stirrC5->SetFillColor(stirrC5->GetLineColor());
9984 stirrC5->SetFillStyle(4000); // 0% transparent
9985
f0a991bf 9986
9987 // Build up the wheel slides
9988 upSlideVol->AddNode(upSlideBlock,1,0);
9989 upSlideVol->AddNode(upSlidePin, 1,
9990 new TGeoCombiTrans(-kUpperSlideHoleXPos, 0, 0,
9991 new TGeoRotation("",0,-90,0) ) );
9992
9993 lwSlideVol->AddNode(lwSlideBlock,1,0);
9994 lwSlideVol->AddNode(lwSlideNose ,1,0);
9995 lwSlideVol->AddNode(lwSlidePin, 1,
9996 new TGeoCombiTrans(lwSlideAluSh->GetX(5), 0, 0,
9997 new TGeoRotation("",0,-90,0) ) );
9998
9999
10000 // Finally put everything in the mother volume
10001 moth->AddNode(suppRingC2C3,1,
8b0d638d 10002 new TGeoTranslation(0, 0, kRingCZPos+kRingCZToTPC) );
f0a991bf 10003 moth->AddNode(suppRingC2C3,2,
10004 new TGeoCombiTrans( 0, 0,-kRingCZPos,
10005 new TGeoRotation("",0.,180.,0.) ) );
10006 moth->AddNode(suppRingC2C3,3,
8b0d638d 10007 new TGeoCombiTrans( 0, 0, kRingCZPos+kRingCZToTPC,
f0a991bf 10008 new TGeoRotation("",0.,0.,180.) ) );
10009 moth->AddNode(suppRingC2C3,4,
10010 new TGeoCombiTrans( 0, 0,-kRingCZPos,
10011 new TGeoRotation("",0.,180.,180.) ) );
10012
8b0d638d 10013 zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
f0a991bf 10014 moth->AddNode(forwUpHook,1,
10015 new TGeoTranslation( 0, 0, zpos) );
10016
8b0d638d 10017 zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
f0a991bf 10018 moth->AddNode(forwLwHook,1,
10019 new TGeoCombiTrans( 0, 0, zpos,
10020 new TGeoRotation("",0.,0.,180.) ) );
10021
10022 zpos = kRingCZPos + kRingCThick + kRearUpHookThick;
10023 moth->AddNode(rearUpHook,1,
10024 new TGeoTranslation( 0, 0,-zpos) );
10025
10026 zpos = kRingCZPos + kRingCThick + kRearLwHookThick;
10027 moth->AddNode(rearLwHook,1,
10028 new TGeoCombiTrans( 0, 0,-zpos,
10029 new TGeoRotation("",0.,0.,180.) ) );
10030
10031 xpos = kRearLwHookWide/2 + kRearLwBracketThick/2;
10032 ypos = -kRingCHeight;
10033 moth->AddNode(rearLwBrack,1,
10034 new TGeoCombiTrans( xpos, ypos,-zpos,
10035 new TGeoRotation("", 90.,-90.,-90.) ) );
10036 moth->AddNode(rearLwBrack,2,
10037 new TGeoCombiTrans(-xpos, ypos,-zpos,
10038 new TGeoRotation("", 90.,-90.,-90.) ) );
10039
10040 xpos = kForwUpHookWide/2;
10041 ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2;
8b0d638d 10042 zpos = kRingCZPos + kRingCThick + kRingCZToTPC;
f0a991bf 10043 moth->AddNode(forwWebSStirrup,1,
10044 new TGeoCombiTrans( xpos, ypos, zpos,
10045 new TGeoRotation("", 0., 90., 0.) ) );
10046 xpos = kForwLwHookWide/2;
10047 ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2;
10048 moth->AddNode(forwWebSStirrup,2,
10049 new TGeoCombiTrans( xpos,-ypos, zpos,
10050 new TGeoRotation("", 0., 90., 0.) ) );
10051
10052 xpos = kForwUpHookWide/2
10053 + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
10054 ypos = (forwUpHookMainBody->GetY(8) + forwUpHookMainBody->GetY(9))/2
10055 + forwWebSStirrSh->GetZ(1) - forwWebTStirr3Sh->GetY(7);
10056 zpos += (forwWebSStirrSh->GetY(4) - forwWebSStirrSh->GetY(0));
10057 moth->AddNode(forwWebTStirr3,1,
10058 new TGeoTranslation( xpos, ypos, zpos) );
10059
10060 ypos -= frWebClampSh->GetZ(1);
10061 moth->AddNode(frWebClamp,1,
10062 new TGeoCombiTrans( xpos, ypos, zpos+forwWebTStirr3Sh->GetZ(1),
10063 new TGeoRotation("", 0., 90., 0.) ) );
10064
10065 ypos -= webcamShape->GetDY()/2;
10066 moth->AddNode(webCam,1,
10067 new TGeoTranslation( xpos, ypos,
10068 zpos+forwWebTStirr3Sh->GetZ(1)+webcamShape->GetDZ()) );
10069
10070 xpos = kForwLwHookWide/2
10071 + (forwWebSStirrSh->GetX(4) + forwWebSStirrSh->GetX(5))/2;
10072 ypos = (forwLwHookMainBody->GetY(8) + forwLwHookMainBody->GetY(9))/2
10073 + forwWebSStirrSh->GetZ(1) - forwWebTStirr4Sh->GetY(7);
10074 moth->AddNode(forwWebTStirr4,1,
10075 new TGeoCombiTrans( xpos,-ypos, zpos,
10076 new TGeoRotation("", 180., 0., 0.) ) );
10077
10078 ypos -= frWebClampSh->GetZ(1);
10079 moth->AddNode(frWebClamp,2,
10080 new TGeoCombiTrans( xpos,-ypos, zpos+forwWebTStirr4Sh->GetZ(1),
10081 new TGeoRotation("", 0., 90., 0.) ) );
10082
10083 ypos -= webcamShape->GetDY()/2;
10084 moth->AddNode(webCam,2,
10085 new TGeoTranslation( xpos,-ypos,
10086 zpos+forwWebTStirr4Sh->GetZ(1)+webcamShape->GetDZ()) );
5ea15037 10087
f0a991bf 10088 xpos = kRearUpHookWide/2 + kRearUpWebStirrDep/2;
10089 ypos = kRingCHeight;
10090 zpos = kRingCZPos + kRingCThick;
10091 moth->AddNode(upWebStirrup,1,
10092 new TGeoCombiTrans( xpos, ypos,-zpos,
10093 new TGeoRotation("",-90.,-90., 90.) ) );
10094 moth->AddNode(upWebStirrup,2,
10095 new TGeoCombiTrans(-xpos, ypos,-zpos,
10096 new TGeoRotation("",-90.,-90., 90.) ) );
10097
10098 ypos = kRingCHeight + upWebStirrSh->GetY(2) - upRearWebBarSh->GetDY();
10099 zpos = kRingCZPos + kRingCThick + upWebStirrSh->GetX(3)
10100 - upRearWebBarSh->GetDZ();
10101 moth->AddNode(upRearWebBar,1,
10102 new TGeoTranslation( 0, ypos,-zpos) );
10103
10104 zpos -= upRearWebBarSh->GetDZ();
10105 moth->AddNode(frWebClamp,3,
10106 new TGeoCombiTrans( 0, ypos,-zpos,
10107 new TGeoRotation("", 0., 90., 0.) ) );
10108
10109 ypos -= webcamShape->GetDY()/2;
10110 zpos -= webcamShape->GetDZ();
10111 moth->AddNode(webCam,3,
10112 new TGeoTranslation( 0, ypos,-zpos) );
5ea15037 10113
f0a991bf 10114 xpos = ringC2C3->GetX(14) + kUpperSlideWidth/2;
10115 ypos = ringC2C3->GetY(14);
10116 zpos = kRingCZPos + kRingCThick;
10117 moth->AddNode(upSlideVol,1,
8b0d638d 10118 new TGeoCombiTrans( xpos, ypos, zpos + kRingCZToTPC,
f0a991bf 10119 new TGeoRotation("",-90.,-90., 90.) ) );
10120 moth->AddNode(upSlideVol,2,
8b0d638d 10121 new TGeoCombiTrans(-xpos, ypos, zpos + kRingCZToTPC,
f0a991bf 10122 new TGeoRotation("",-90.,-90., 90.) ) );
10123 moth->AddNode(upSlideVol,3,
10124 new TGeoCombiTrans( xpos, ypos, -zpos,
10125 new TGeoRotation("", 90.,-90.,-90.) ) );
10126 moth->AddNode(upSlideVol,4,
10127 new TGeoCombiTrans(-xpos, ypos, -zpos,
10128 new TGeoRotation("", 90.,-90.,-90.) ) );
10129
10130 moth->AddNode(lwSlideVol,1,
8b0d638d 10131 new TGeoCombiTrans( xpos,-ypos, zpos + kRingCZToTPC,
10132 new TGeoRotation("", 90.,-90., 90.) ) );
10133 moth->AddNode(lwSlideVol,2,
10134 new TGeoCombiTrans(-xpos,-ypos, zpos + kRingCZToTPC,
10135 new TGeoRotation("", 90.,-90., 90.) ) );
10136 moth->AddNode(lwSlideVol,3,
f0a991bf 10137 new TGeoCombiTrans( xpos,-ypos,-zpos,
10138 new TGeoRotation("",-90.,-90.,-90.) ) );
8b0d638d 10139 moth->AddNode(lwSlideVol,4,
f0a991bf 10140 new TGeoCombiTrans(-xpos,-ypos,-zpos,
10141 new TGeoRotation("",-90.,-90.,-90.) ) );
8b0d638d 10142
10143 xpos = kStirrCXPos;
10144 zpos = kRingCZPos + kStirrCZPos + stirrupC1C2Sh->GetZ(1) + kRingCZToTPC;
10145 moth->AddNode(stirrC1C2,1,
10146 new TGeoTranslation( xpos, 0, zpos) );
10147 moth->AddNode(stirrC1C2,2,
10148 new TGeoCombiTrans(-xpos, 0, zpos,
10149 new TGeoRotation("", 90.,-180.,-90.) ) );
10150
10151 xpos = kStirrCXPos + stirrupC1C2Sh->GetX(18) + kUpperSlideWidth/2;
10152 ypos = ringC2C3->GetY(14); // Slides are all at the same height
10153 zpos = kRingCZPos + kStirrCZPos + kStirrC12Thick + kRingCZToTPC;
10154 moth->AddNode(upSlideVol,5,
10155 new TGeoCombiTrans( xpos, ypos, zpos,
10156 new TGeoRotation("",-90.,-90., 90.) ) );
10157 moth->AddNode(upSlideVol,6,
10158 new TGeoCombiTrans(-xpos, ypos, zpos,
10159 new TGeoRotation("",-90.,-90., 90.) ) );
10160 moth->AddNode(lwSlideVol,5,
f0a991bf 10161 new TGeoCombiTrans( xpos,-ypos, zpos,
10162 new TGeoRotation("", 90.,-90., 90.) ) );
8b0d638d 10163 moth->AddNode(lwSlideVol,6,
f0a991bf 10164 new TGeoCombiTrans(-xpos,-ypos, zpos,
10165 new TGeoRotation("", 90.,-90., 90.) ) );
10166
8b0d638d 10167 xpos = kStirrCXPos;
10168 zpos = kRingCZPos + kStirrCZPos + stirrupC5Sh->GetZ(1);
10169 moth->AddNode(stirrC5,1,
10170 new TGeoTranslation( xpos, 0,-zpos) );
10171 moth->AddNode(stirrC5,2,
10172 new TGeoCombiTrans(-xpos, 0,-zpos,
10173 new TGeoRotation("", 90.,-180.,-90.) ) );
10174
f0a991bf 10175
10176 return;
10177}
10178